2befd475def426f961887ced0a13a9004d69b278
[linux-2.6.git] / 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/version.h>
19 #include <linux/kernel.h>
20 #include <linux/init.h>
21 #include <linux/uwb/umc.h>
22 #define D_LOCAL 1
23 #include <linux/uwb/debug.h>
24
25 #include "../../wusbcore/wusbhc.h"
26
27 #include "whcd.h"
28
29 #if D_LOCAL >= 1
30 static void dump_di(struct whc *whc, int idx)
31 {
32         struct di_buf_entry *di = &whc->di_buf[idx];
33         struct device *dev = &whc->umc->dev;
34         char buf[128];
35
36         bitmap_scnprintf(buf, sizeof(buf), (unsigned long *)di->availability_info, UWB_NUM_MAS);
37
38         d_printf(1, dev, "DI[%d]\n", idx);
39         d_printf(1, dev, "  availability: %s\n", buf);
40         d_printf(1, dev, "  %c%c key idx: %d dev addr: %d\n",
41                  (di->addr_sec_info & WHC_DI_SECURE) ? 'S' : ' ',
42                  (di->addr_sec_info & WHC_DI_DISABLE) ? 'D' : ' ',
43                  (di->addr_sec_info & WHC_DI_KEY_IDX_MASK) >> 8,
44                  (di->addr_sec_info & WHC_DI_DEV_ADDR_MASK));
45 }
46 #else
47 static inline void dump_di(struct whc *whc, int idx)
48 {
49 }
50 #endif
51
52 static int whc_update_di(struct whc *whc, int idx)
53 {
54         int offset = idx / 32;
55         u32 bit = 1 << (idx % 32);
56
57         dump_di(whc, idx);
58
59         le_writel(bit, whc->base + WUSBDIBUPDATED + offset);
60
61         return whci_wait_for(&whc->umc->dev,
62                              whc->base + WUSBDIBUPDATED + offset, bit, 0,
63                              100, "DI update");
64 }
65
66 /*
67  * WHCI starts MMCs based on there being a valid GTK so these need
68  * only start/stop the asynchronous and periodic schedules and send a
69  * channel stop command.
70  */
71
72 int whc_wusbhc_start(struct wusbhc *wusbhc)
73 {
74         struct whc *whc = wusbhc_to_whc(wusbhc);
75
76         asl_start(whc);
77         pzl_start(whc);
78
79         return 0;
80 }
81
82 void whc_wusbhc_stop(struct wusbhc *wusbhc, int delay)
83 {
84         struct whc *whc = wusbhc_to_whc(wusbhc);
85         u32 stop_time, now_time;
86         int ret;
87
88         pzl_stop(whc);
89         asl_stop(whc);
90
91         now_time = le_readl(whc->base + WUSBTIME) & WUSBTIME_CHANNEL_TIME_MASK;
92         stop_time = (now_time + ((delay * 8) << 7)) & 0x00ffffff;
93         ret = whc_do_gencmd(whc, WUSBGENCMDSTS_CHAN_STOP, stop_time, NULL, 0);
94         if (ret == 0)
95                 msleep(delay);
96 }
97
98 int whc_mmcie_add(struct wusbhc *wusbhc, u8 interval, u8 repeat_cnt,
99                   u8 handle, struct wuie_hdr *wuie)
100 {
101         struct whc *whc = wusbhc_to_whc(wusbhc);
102         u32 params;
103
104         params = (interval << 24)
105                 | (repeat_cnt << 16)
106                 | (wuie->bLength << 8)
107                 | handle;
108
109         return whc_do_gencmd(whc, WUSBGENCMDSTS_MMCIE_ADD, params, wuie, wuie->bLength);
110 }
111
112 int whc_mmcie_rm(struct wusbhc *wusbhc, u8 handle)
113 {
114         struct whc *whc = wusbhc_to_whc(wusbhc);
115         u32 params;
116
117         params = handle;
118
119         return whc_do_gencmd(whc, WUSBGENCMDSTS_MMCIE_RM, params, NULL, 0);
120 }
121
122 int whc_bwa_set(struct wusbhc *wusbhc, s8 stream_index, const struct uwb_mas_bm *mas_bm)
123 {
124         struct whc *whc = wusbhc_to_whc(wusbhc);
125
126         if (stream_index >= 0)
127                 whc_write_wusbcmd(whc, WUSBCMD_WUSBSI_MASK, WUSBCMD_WUSBSI(stream_index));
128
129         return whc_do_gencmd(whc, WUSBGENCMDSTS_SET_MAS, 0, (void *)mas_bm, sizeof(*mas_bm));
130 }
131
132 int whc_dev_info_set(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev)
133 {
134         struct whc *whc = wusbhc_to_whc(wusbhc);
135         int idx = wusb_dev->port_idx;
136         struct di_buf_entry *di = &whc->di_buf[idx];
137         int ret;
138
139         mutex_lock(&whc->mutex);
140
141         uwb_mas_bm_copy_le(di->availability_info, &wusb_dev->availability);
142         di->addr_sec_info &= ~(WHC_DI_DISABLE | WHC_DI_DEV_ADDR_MASK);
143         di->addr_sec_info |= WHC_DI_DEV_ADDR(wusb_dev->addr);
144
145         ret = whc_update_di(whc, idx);
146
147         mutex_unlock(&whc->mutex);
148
149         return ret;
150 }
151
152 /*
153  * Set the number of Device Notification Time Slots (DNTS) and enable
154  * device notifications.
155  */
156 int whc_set_num_dnts(struct wusbhc *wusbhc, u8 interval, u8 slots)
157 {
158         struct whc *whc = wusbhc_to_whc(wusbhc);
159         u32 dntsctrl;
160
161         dntsctrl = WUSBDNTSCTRL_ACTIVE
162                 | WUSBDNTSCTRL_INTERVAL(interval)
163                 | WUSBDNTSCTRL_SLOTS(slots);
164
165         le_writel(dntsctrl, whc->base + WUSBDNTSCTRL);
166
167         return 0;
168 }
169
170 static int whc_set_key(struct whc *whc, u8 key_index, uint32_t tkid,
171                        const void *key, size_t key_size, bool is_gtk)
172 {
173         uint32_t setkeycmd;
174         uint32_t seckey[4];
175         int i;
176         int ret;
177
178         memcpy(seckey, key, key_size);
179         setkeycmd = WUSBSETSECKEYCMD_SET | WUSBSETSECKEYCMD_IDX(key_index);
180         if (is_gtk)
181                 setkeycmd |= WUSBSETSECKEYCMD_GTK;
182
183         le_writel(tkid, whc->base + WUSBTKID);
184         for (i = 0; i < 4; i++)
185                 le_writel(seckey[i], whc->base + WUSBSECKEY + 4*i);
186         le_writel(setkeycmd, whc->base + WUSBSETSECKEYCMD);
187
188         ret = whci_wait_for(&whc->umc->dev, whc->base + WUSBSETSECKEYCMD,
189                             WUSBSETSECKEYCMD_SET, 0, 100, "set key");
190
191         return ret;
192 }
193
194 /**
195  * whc_set_ptk - set the PTK to use for a device.
196  *
197  * The index into the key table for this PTK is the same as the
198  * device's port index.
199  */
200 int whc_set_ptk(struct wusbhc *wusbhc, u8 port_idx, u32 tkid,
201                 const void *ptk, size_t key_size)
202 {
203         struct whc *whc = wusbhc_to_whc(wusbhc);
204         struct di_buf_entry *di = &whc->di_buf[port_idx];
205         int ret;
206
207         mutex_lock(&whc->mutex);
208
209         if (ptk) {
210                 ret = whc_set_key(whc, port_idx, tkid, ptk, key_size, false);
211                 if (ret)
212                         goto out;
213
214                 di->addr_sec_info &= ~WHC_DI_KEY_IDX_MASK;
215                 di->addr_sec_info |= WHC_DI_SECURE | WHC_DI_KEY_IDX(port_idx);
216         } else
217                 di->addr_sec_info &= ~WHC_DI_SECURE;
218
219         ret = whc_update_di(whc, port_idx);
220 out:
221         mutex_unlock(&whc->mutex);
222         return ret;
223 }
224
225 /**
226  * whc_set_gtk - set the GTK for subsequent broadcast packets
227  *
228  * The GTK is stored in the last entry in the key table (the previous
229  * N_DEVICES entries are for the per-device PTKs).
230  */
231 int whc_set_gtk(struct wusbhc *wusbhc, u32 tkid,
232                 const void *gtk, size_t key_size)
233 {
234         struct whc *whc = wusbhc_to_whc(wusbhc);
235         int ret;
236
237         mutex_lock(&whc->mutex);
238
239         ret = whc_set_key(whc, whc->n_devices, tkid, gtk, key_size, true);
240
241         mutex_unlock(&whc->mutex);
242
243         return ret;
244 }
245
246 int whc_set_cluster_id(struct whc *whc, u8 bcid)
247 {
248         whc_write_wusbcmd(whc, WUSBCMD_BCID_MASK, WUSBCMD_BCID(bcid));
249         return 0;
250 }