uwb: don't use printk_ratelimit() so often
[linux-2.6.git] / drivers / usb / wusbcore / mmc.c
1 /*
2  * WUSB Wire Adapter: Control/Data Streaming Interface (WUSB[8])
3  * MMC (Microscheduled Management Command) handling
4  *
5  * Copyright (C) 2005-2006 Intel Corporation
6  * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License version
10  * 2 as published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
20  * 02110-1301, USA.
21  *
22  *
23  * WUIEs and MMC IEs...well, they are almost the same at the end. MMC
24  * IEs are Wireless USB IEs that go into the MMC period...[what is
25  * that? look in Design-overview.txt].
26  *
27  *
28  * This is a simple subsystem to keep track of which IEs are being
29  * sent by the host in the MMC period.
30  *
31  * For each WUIE we ask to send, we keep it in an array, so we can
32  * request its removal later, or replace the content. They are tracked
33  * by pointer, so be sure to use the same pointer if you want to
34  * remove it or update the contents.
35  *
36  * FIXME:
37  *  - add timers that autoremove intervalled IEs?
38  */
39 #include <linux/usb/wusb.h>
40 #include "wusbhc.h"
41
42 /* Initialize the MMCIEs handling mechanism */
43 int wusbhc_mmcie_create(struct wusbhc *wusbhc)
44 {
45         u8 mmcies = wusbhc->mmcies_max;
46         wusbhc->mmcie = kcalloc(mmcies, sizeof(wusbhc->mmcie[0]), GFP_KERNEL);
47         if (wusbhc->mmcie == NULL)
48                 return -ENOMEM;
49         mutex_init(&wusbhc->mmcie_mutex);
50         return 0;
51 }
52
53 /* Release resources used by the MMCIEs handling mechanism */
54 void wusbhc_mmcie_destroy(struct wusbhc *wusbhc)
55 {
56         kfree(wusbhc->mmcie);
57 }
58
59 /*
60  * Add or replace an MMC Wireless USB IE.
61  *
62  * @interval:    See WUSB1.0[8.5.3.1]
63  * @repeat_cnt:  See WUSB1.0[8.5.3.1]
64  * @handle:      See WUSB1.0[8.5.3.1]
65  * @wuie:        Pointer to the header of the WUSB IE data to add.
66  *               MUST BE allocated in a kmalloc buffer (no stack or
67  *               vmalloc).
68  *               THE CALLER ALWAYS OWNS THE POINTER (we don't free it
69  *               on remove, we just forget about it).
70  * @returns:     0 if ok, < 0 errno code on error.
71  *
72  * Goes over the *whole* @wusbhc->mmcie array looking for (a) the
73  * first free spot and (b) if @wuie is already in the array (aka:
74  * transmitted in the MMCs) the spot were it is.
75  *
76  * If present, we "overwrite it" (update).
77  *
78  *
79  * NOTE: Need special ordering rules -- see below WUSB1.0 Table 7-38.
80  *       The host uses the handle as the 'sort' index. We
81  *       allocate the last one always for the WUIE_ID_HOST_INFO, and
82  *       the rest, first come first serve in inverse order.
83  *
84  *       Host software must make sure that it adds the other IEs in
85  *       the right order... the host hardware is responsible for
86  *       placing the WCTA IEs in the right place with the other IEs
87  *       set by host software.
88  *
89  * NOTE: we can access wusbhc->wa_descr without locking because it is
90  *       read only.
91  */
92 int wusbhc_mmcie_set(struct wusbhc *wusbhc, u8 interval, u8 repeat_cnt,
93                      struct wuie_hdr *wuie)
94 {
95         int result = -ENOBUFS;
96         unsigned handle, itr;
97
98         /* Search a handle, taking into account the ordering */
99         mutex_lock(&wusbhc->mmcie_mutex);
100         switch (wuie->bIEIdentifier) {
101         case WUIE_ID_HOST_INFO:
102                 /* Always last */
103                 handle = wusbhc->mmcies_max - 1;
104                 break;
105         case WUIE_ID_ISOCH_DISCARD:
106                 dev_err(wusbhc->dev, "Special ordering case for WUIE ID 0x%x "
107                         "unimplemented\n", wuie->bIEIdentifier);
108                 result = -ENOSYS;
109                 goto error_unlock;
110         default:
111                 /* search for it or find the last empty slot */
112                 handle = ~0;
113                 for (itr = 0; itr < wusbhc->mmcies_max - 1; itr++) {
114                         if (wusbhc->mmcie[itr] == wuie) {
115                                 handle = itr;
116                                 break;
117                         }
118                         if (wusbhc->mmcie[itr] == NULL)
119                                 handle = itr;
120                 }
121                 if (handle == ~0)
122                         goto error_unlock;
123         }
124         result = (wusbhc->mmcie_add)(wusbhc, interval, repeat_cnt, handle,
125                                      wuie);
126         if (result >= 0)
127                 wusbhc->mmcie[handle] = wuie;
128 error_unlock:
129         mutex_unlock(&wusbhc->mmcie_mutex);
130         return result;
131 }
132 EXPORT_SYMBOL_GPL(wusbhc_mmcie_set);
133
134 /*
135  * Remove an MMC IE previously added with wusbhc_mmcie_set()
136  *
137  * @wuie        Pointer used to add the WUIE
138  */
139 void wusbhc_mmcie_rm(struct wusbhc *wusbhc, struct wuie_hdr *wuie)
140 {
141         int result;
142         unsigned handle, itr;
143
144         mutex_lock(&wusbhc->mmcie_mutex);
145         for (itr = 0; itr < wusbhc->mmcies_max; itr++) {
146                 if (wusbhc->mmcie[itr] == wuie) {
147                         handle = itr;
148                         goto found;
149                 }
150         }
151         mutex_unlock(&wusbhc->mmcie_mutex);
152         return;
153
154 found:
155         result = (wusbhc->mmcie_rm)(wusbhc, handle);
156         if (result == 0)
157                 wusbhc->mmcie[itr] = NULL;
158         mutex_unlock(&wusbhc->mmcie_mutex);
159 }
160 EXPORT_SYMBOL_GPL(wusbhc_mmcie_rm);
161
162 /*
163  * wusbhc_start - start transmitting MMCs and accepting connections
164  * @wusbhc: the HC to start
165  * @chid: the CHID to use for this host
166  *
167  * Establishes a cluster reservation, enables device connections, and
168  * starts MMCs with appropriate DNTS parameters.
169  */
170 int wusbhc_start(struct wusbhc *wusbhc, const struct wusb_ckhdid *chid)
171 {
172         int result;
173         struct device *dev = wusbhc->dev;
174
175         WARN_ON(wusbhc->wuie_host_info != NULL);
176
177         result = wusbhc_rsv_establish(wusbhc);
178         if (result < 0) {
179                 dev_err(dev, "cannot establish cluster reservation: %d\n",
180                         result);
181                 goto error_rsv_establish;
182         }
183
184         result = wusbhc_devconnect_start(wusbhc, chid);
185         if (result < 0) {
186                 dev_err(dev, "error enabling device connections: %d\n", result);
187                 goto error_devconnect_start;
188         }
189
190         result = wusbhc_sec_start(wusbhc);
191         if (result < 0) {
192                 dev_err(dev, "error starting security in the HC: %d\n", result);
193                 goto error_sec_start;
194         }
195         /* FIXME: the choice of the DNTS parameters is somewhat
196          * arbitrary */
197         result = wusbhc->set_num_dnts(wusbhc, 0, 15);
198         if (result < 0) {
199                 dev_err(dev, "Cannot set DNTS parameters: %d\n", result);
200                 goto error_set_num_dnts;
201         }
202         result = wusbhc->start(wusbhc);
203         if (result < 0) {
204                 dev_err(dev, "error starting wusbch: %d\n", result);
205                 goto error_wusbhc_start;
206         }
207         wusbhc->active = 1;
208         return 0;
209
210 error_wusbhc_start:
211         wusbhc_sec_stop(wusbhc);
212 error_set_num_dnts:
213 error_sec_start:
214         wusbhc_devconnect_stop(wusbhc);
215 error_devconnect_start:
216         wusbhc_rsv_terminate(wusbhc);
217 error_rsv_establish:
218         return result;
219 }
220
221 /*
222  * Disconnect all from the WUSB Channel
223  *
224  * Send a Host Disconnect IE in the MMC, wait, don't send it any more
225  */
226 static int __wusbhc_host_disconnect_ie(struct wusbhc *wusbhc)
227 {
228         int result = -ENOMEM;
229         struct wuie_host_disconnect *host_disconnect_ie;
230         might_sleep();
231         host_disconnect_ie = kmalloc(sizeof(*host_disconnect_ie), GFP_KERNEL);
232         if (host_disconnect_ie == NULL)
233                 goto error_alloc;
234         host_disconnect_ie->hdr.bLength       = sizeof(*host_disconnect_ie);
235         host_disconnect_ie->hdr.bIEIdentifier = WUIE_ID_HOST_DISCONNECT;
236         result = wusbhc_mmcie_set(wusbhc, 0, 0, &host_disconnect_ie->hdr);
237         if (result < 0)
238                 goto error_mmcie_set;
239
240         /* WUSB1.0[8.5.3.1 & 7.5.2] */
241         msleep(100);
242         wusbhc_mmcie_rm(wusbhc, &host_disconnect_ie->hdr);
243 error_mmcie_set:
244         kfree(host_disconnect_ie);
245 error_alloc:
246         return result;
247 }
248
249 /*
250  * wusbhc_stop - stop transmitting MMCs
251  * @wusbhc: the HC to stop
252  *
253  * Send a Host Disconnect IE, wait, remove all the MMCs (stop sending MMCs).
254  *
255  * If we can't allocate a Host Stop IE, screw it, we don't notify the
256  * devices we are disconnecting...
257  */
258 void wusbhc_stop(struct wusbhc *wusbhc)
259 {
260         if (wusbhc->active) {
261                 wusbhc->active = 0;
262                 wusbhc->stop(wusbhc);
263                 wusbhc_sec_stop(wusbhc);
264                 __wusbhc_host_disconnect_ie(wusbhc);
265                 wusbhc_devconnect_stop(wusbhc);
266                 wusbhc_rsv_terminate(wusbhc);
267         }
268 }
269 EXPORT_SYMBOL_GPL(wusbhc_stop);
270
271 /*
272  * Change the CHID in a WUSB Channel
273  *
274  * If it is just a new CHID, send a Host Disconnect IE and then change
275  * the CHID IE.
276  */
277 static int __wusbhc_chid_change(struct wusbhc *wusbhc,
278                                 const struct wusb_ckhdid *chid)
279 {
280         int result = -ENOSYS;
281         struct device *dev = wusbhc->dev;
282         dev_err(dev, "%s() not implemented yet\n", __func__);
283         return result;
284
285         BUG_ON(wusbhc->wuie_host_info == NULL);
286         __wusbhc_host_disconnect_ie(wusbhc);
287         wusbhc->wuie_host_info->CHID = *chid;
288         result = wusbhc_mmcie_set(wusbhc, 0, 0, &wusbhc->wuie_host_info->hdr);
289         if (result < 0)
290                 dev_err(dev, "Can't update Host Info WUSB IE: %d\n", result);
291         return result;
292 }
293
294 /*
295  * Set/reset/update a new CHID
296  *
297  * Depending on the previous state of the MMCs, start, stop or change
298  * the sent MMC. This effectively switches the host controller on and
299  * off (radio wise).
300  */
301 int wusbhc_chid_set(struct wusbhc *wusbhc, const struct wusb_ckhdid *chid)
302 {
303         int result = 0;
304
305         if (memcmp(chid, &wusb_ckhdid_zero, sizeof(chid)) == 0)
306                 chid = NULL;
307
308         mutex_lock(&wusbhc->mutex);
309         if (wusbhc->active) {
310                 if (chid)
311                         result = __wusbhc_chid_change(wusbhc, chid);
312                 else
313                         wusbhc_stop(wusbhc);
314         } else {
315                 if (chid)
316                         wusbhc_start(wusbhc, chid);
317         }
318         mutex_unlock(&wusbhc->mutex);
319         return result;
320 }
321 EXPORT_SYMBOL_GPL(wusbhc_chid_set);