Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/rric/oprofile
[linux-2.6] / drivers / usb / host / whci / wusb.c
1 /*
2  * Wireless Host Controller (WHC) WUSB operations.
3  *
4  * Copyright (C) 2007 Cambridge Silicon Radio Ltd.
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License version
8  * 2 as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
17  */
18 #include <linux/kernel.h>
19 #include <linux/init.h>
20 #include <linux/uwb/umc.h>
21
22 #include "../../wusbcore/wusbhc.h"
23
24 #include "whcd.h"
25
26 static int whc_update_di(struct whc *whc, int idx)
27 {
28         int offset = idx / 32;
29         u32 bit = 1 << (idx % 32);
30
31         le_writel(bit, whc->base + WUSBDIBUPDATED + offset);
32
33         return whci_wait_for(&whc->umc->dev,
34                              whc->base + WUSBDIBUPDATED + offset, bit, 0,
35                              100, "DI update");
36 }
37
38 /*
39  * WHCI starts MMCs based on there being a valid GTK so these need
40  * only start/stop the asynchronous and periodic schedules and send a
41  * channel stop command.
42  */
43
44 int whc_wusbhc_start(struct wusbhc *wusbhc)
45 {
46         struct whc *whc = wusbhc_to_whc(wusbhc);
47
48         asl_start(whc);
49         pzl_start(whc);
50
51         return 0;
52 }
53
54 void whc_wusbhc_stop(struct wusbhc *wusbhc, int delay)
55 {
56         struct whc *whc = wusbhc_to_whc(wusbhc);
57         u32 stop_time, now_time;
58         int ret;
59
60         pzl_stop(whc);
61         asl_stop(whc);
62
63         now_time = le_readl(whc->base + WUSBTIME) & WUSBTIME_CHANNEL_TIME_MASK;
64         stop_time = (now_time + ((delay * 8) << 7)) & 0x00ffffff;
65         ret = whc_do_gencmd(whc, WUSBGENCMDSTS_CHAN_STOP, stop_time, NULL, 0);
66         if (ret == 0)
67                 msleep(delay);
68 }
69
70 int whc_mmcie_add(struct wusbhc *wusbhc, u8 interval, u8 repeat_cnt,
71                   u8 handle, struct wuie_hdr *wuie)
72 {
73         struct whc *whc = wusbhc_to_whc(wusbhc);
74         u32 params;
75
76         params = (interval << 24)
77                 | (repeat_cnt << 16)
78                 | (wuie->bLength << 8)
79                 | handle;
80
81         return whc_do_gencmd(whc, WUSBGENCMDSTS_MMCIE_ADD, params, wuie, wuie->bLength);
82 }
83
84 int whc_mmcie_rm(struct wusbhc *wusbhc, u8 handle)
85 {
86         struct whc *whc = wusbhc_to_whc(wusbhc);
87         u32 params;
88
89         params = handle;
90
91         return whc_do_gencmd(whc, WUSBGENCMDSTS_MMCIE_RM, params, NULL, 0);
92 }
93
94 int whc_bwa_set(struct wusbhc *wusbhc, s8 stream_index, const struct uwb_mas_bm *mas_bm)
95 {
96         struct whc *whc = wusbhc_to_whc(wusbhc);
97
98         if (stream_index >= 0)
99                 whc_write_wusbcmd(whc, WUSBCMD_WUSBSI_MASK, WUSBCMD_WUSBSI(stream_index));
100
101         return whc_do_gencmd(whc, WUSBGENCMDSTS_SET_MAS, 0, (void *)mas_bm, sizeof(*mas_bm));
102 }
103
104 int whc_dev_info_set(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev)
105 {
106         struct whc *whc = wusbhc_to_whc(wusbhc);
107         int idx = wusb_dev->port_idx;
108         struct di_buf_entry *di = &whc->di_buf[idx];
109         int ret;
110
111         mutex_lock(&whc->mutex);
112
113         uwb_mas_bm_copy_le(di->availability_info, &wusb_dev->availability);
114         di->addr_sec_info &= ~(WHC_DI_DISABLE | WHC_DI_DEV_ADDR_MASK);
115         di->addr_sec_info |= WHC_DI_DEV_ADDR(wusb_dev->addr);
116
117         ret = whc_update_di(whc, idx);
118
119         mutex_unlock(&whc->mutex);
120
121         return ret;
122 }
123
124 /*
125  * Set the number of Device Notification Time Slots (DNTS) and enable
126  * device notifications.
127  */
128 int whc_set_num_dnts(struct wusbhc *wusbhc, u8 interval, u8 slots)
129 {
130         struct whc *whc = wusbhc_to_whc(wusbhc);
131         u32 dntsctrl;
132
133         dntsctrl = WUSBDNTSCTRL_ACTIVE
134                 | WUSBDNTSCTRL_INTERVAL(interval)
135                 | WUSBDNTSCTRL_SLOTS(slots);
136
137         le_writel(dntsctrl, whc->base + WUSBDNTSCTRL);
138
139         return 0;
140 }
141
142 static int whc_set_key(struct whc *whc, u8 key_index, uint32_t tkid,
143                        const void *key, size_t key_size, bool is_gtk)
144 {
145         uint32_t setkeycmd;
146         uint32_t seckey[4];
147         int i;
148         int ret;
149
150         memcpy(seckey, key, key_size);
151         setkeycmd = WUSBSETSECKEYCMD_SET | WUSBSETSECKEYCMD_IDX(key_index);
152         if (is_gtk)
153                 setkeycmd |= WUSBSETSECKEYCMD_GTK;
154
155         le_writel(tkid, whc->base + WUSBTKID);
156         for (i = 0; i < 4; i++)
157                 le_writel(seckey[i], whc->base + WUSBSECKEY + 4*i);
158         le_writel(setkeycmd, whc->base + WUSBSETSECKEYCMD);
159
160         ret = whci_wait_for(&whc->umc->dev, whc->base + WUSBSETSECKEYCMD,
161                             WUSBSETSECKEYCMD_SET, 0, 100, "set key");
162
163         return ret;
164 }
165
166 /**
167  * whc_set_ptk - set the PTK to use for a device.
168  *
169  * The index into the key table for this PTK is the same as the
170  * device's port index.
171  */
172 int whc_set_ptk(struct wusbhc *wusbhc, u8 port_idx, u32 tkid,
173                 const void *ptk, size_t key_size)
174 {
175         struct whc *whc = wusbhc_to_whc(wusbhc);
176         struct di_buf_entry *di = &whc->di_buf[port_idx];
177         int ret;
178
179         mutex_lock(&whc->mutex);
180
181         if (ptk) {
182                 ret = whc_set_key(whc, port_idx, tkid, ptk, key_size, false);
183                 if (ret)
184                         goto out;
185
186                 di->addr_sec_info &= ~WHC_DI_KEY_IDX_MASK;
187                 di->addr_sec_info |= WHC_DI_SECURE | WHC_DI_KEY_IDX(port_idx);
188         } else
189                 di->addr_sec_info &= ~WHC_DI_SECURE;
190
191         ret = whc_update_di(whc, port_idx);
192 out:
193         mutex_unlock(&whc->mutex);
194         return ret;
195 }
196
197 /**
198  * whc_set_gtk - set the GTK for subsequent broadcast packets
199  *
200  * The GTK is stored in the last entry in the key table (the previous
201  * N_DEVICES entries are for the per-device PTKs).
202  */
203 int whc_set_gtk(struct wusbhc *wusbhc, u32 tkid,
204                 const void *gtk, size_t key_size)
205 {
206         struct whc *whc = wusbhc_to_whc(wusbhc);
207         int ret;
208
209         mutex_lock(&whc->mutex);
210
211         ret = whc_set_key(whc, whc->n_devices, tkid, gtk, key_size, true);
212
213         mutex_unlock(&whc->mutex);
214
215         return ret;
216 }
217
218 int whc_set_cluster_id(struct whc *whc, u8 bcid)
219 {
220         whc_write_wusbcmd(whc, WUSBCMD_BCID_MASK, WUSBCMD_BCID(bcid));
221         return 0;
222 }