267a64325106ce2ab8d4cc4af81bd56fcdc825a1
[linux-2.6.git] / drivers / usb / wusbcore / rh.c
1 /*
2  * Wireless USB Host Controller
3  * Root Hub operations
4  *
5  *
6  * Copyright (C) 2005-2006 Intel Corporation
7  * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
8  *
9  * This program is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU General Public License version
11  * 2 as published by the Free Software Foundation.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
21  * 02110-1301, USA.
22  *
23  *
24  * We fake a root hub that has fake ports (as many as simultaneous
25  * devices the Wireless USB Host Controller can deal with). For each
26  * port we keep an state in @wusbhc->port[index] identical to the one
27  * specified in the USB2.0[ch11] spec and some extra device
28  * information that complements the one in 'struct usb_device' (as
29  * this lacs a hcpriv pointer).
30  *
31  * Note this is common to WHCI and HWA host controllers.
32  *
33  * Through here we enable most of the state changes that the USB stack
34  * will use to connect or disconnect devices. We need to do some
35  * forced adaptation of Wireless USB device states vs. wired:
36  *
37  *        USB:                 WUSB:
38  *
39  * Port   Powered-off          port slot n/a
40  *        Powered-on           port slot available
41  *        Disconnected         port slot available
42  *        Connected            port slot assigned device
43  *                             device sent DN_Connect
44  *                             device was authenticated
45  *        Enabled              device is authenticated, transitioned
46  *                             from unauth -> auth -> default address
47  *                             -> enabled
48  *        Reset                disconnect
49  *        Disable              disconnect
50  *
51  * This maps the standard USB port states with the WUSB device states
52  * so we can fake ports without having to modify the USB stack.
53  *
54  * FIXME: this process will change in the future
55  *
56  *
57  * ENTRY POINTS
58  *
59  * Our entry points into here are, as in hcd.c, the USB stack root hub
60  * ops defined in the usb_hcd struct:
61  *
62  * wusbhc_rh_status_data()      Provide hub and port status data bitmap
63  *
64  * wusbhc_rh_control()          Execution of all the major requests
65  *                              you can do to a hub (Set|Clear
66  *                              features, get descriptors, status, etc).
67  *
68  * wusbhc_rh_[suspend|resume]() That
69  *
70  * wusbhc_rh_start_port_reset() ??? unimplemented
71  */
72 #include "wusbhc.h"
73
74 #define D_LOCAL 0
75 #include <linux/uwb/debug.h>
76
77 /*
78  * Reset a fake port
79  *
80  * This can be called to reset a port from any other state or to reset
81  * it when connecting. In Wireless USB they are different; when doing
82  * a new connect that involves going over the authentication. When
83  * just reseting, its a different story.
84  *
85  * The Linux USB stack resets a port twice before it considers it
86  * enabled, so we have to detect and ignore that.
87  *
88  * @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
89  *
90  * Supposedly we are the only thread accesing @wusbhc->port; in any
91  * case, maybe we should move the mutex locking from
92  * wusbhc_devconnect_auth() to here.
93  *
94  * @port_idx refers to the wusbhc's port index, not the USB port number
95  */
96 static int wusbhc_rh_port_reset(struct wusbhc *wusbhc, u8 port_idx)
97 {
98         int result = 0;
99         struct wusb_port *port = wusb_port_by_idx(wusbhc, port_idx);
100
101         d_fnstart(3, wusbhc->dev, "(wusbhc %p port_idx %u)\n",
102                   wusbhc, port_idx);
103         if (port->reset_count == 0) {
104                 wusbhc_devconnect_auth(wusbhc, port_idx);
105                 port->reset_count++;
106         } else if (port->reset_count == 1)
107                 /* see header */
108                 d_printf(2, wusbhc->dev, "Ignoring second reset on port_idx "
109                         "%u\n", port_idx);
110         else
111                 result = wusbhc_dev_reset(wusbhc, port_idx);
112         d_fnend(3, wusbhc->dev, "(wusbhc %p port_idx %u) = %d\n",
113                 wusbhc, port_idx, result);
114         return result;
115 }
116
117 /*
118  * Return the hub change status bitmap
119  *
120  * The bits in the change status bitmap are cleared when a
121  * ClearPortFeature request is issued (USB2.0[11.12.3,11.12.4].
122  *
123  * @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
124  *
125  * WARNING!! This gets called from atomic context; we cannot get the
126  *           mutex--the only race condition we can find is some bit
127  *           changing just after we copy it, which shouldn't be too
128  *           big of a problem [and we can't make it an spinlock
129  *           because other parts need to take it and sleep] .
130  *
131  *           @usb_hcd is refcounted, so it won't dissapear under us
132  *           and before killing a host, the polling of the root hub
133  *           would be stopped anyway.
134  */
135 int wusbhc_rh_status_data(struct usb_hcd *usb_hcd, char *_buf)
136 {
137         struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd);
138         size_t cnt, size;
139         unsigned long *buf = (unsigned long *) _buf;
140
141         d_fnstart(1, wusbhc->dev, "(wusbhc %p)\n", wusbhc);
142         /* WE DON'T LOCK, see comment */
143         size = wusbhc->ports_max + 1 /* hub bit */;
144         size = (size + 8 - 1) / 8;      /* round to bytes */
145         for (cnt = 0; cnt < wusbhc->ports_max; cnt++)
146                 if (wusb_port_by_idx(wusbhc, cnt)->change)
147                         set_bit(cnt + 1, buf);
148                 else
149                         clear_bit(cnt + 1, buf);
150         d_fnend(1, wusbhc->dev, "(wusbhc %p) %u, buffer:\n", wusbhc, (int)size);
151         d_dump(1, wusbhc->dev, _buf, size);
152         return size;
153 }
154 EXPORT_SYMBOL_GPL(wusbhc_rh_status_data);
155
156 /*
157  * Return the hub's desciptor
158  *
159  * NOTE: almost cut and paste from ehci-hub.c
160  *
161  * @wusbhc is assumed referenced and @wusbhc->mutex unlocked
162  */
163 static int wusbhc_rh_get_hub_descr(struct wusbhc *wusbhc, u16 wValue,
164                                    u16 wIndex,
165                                    struct usb_hub_descriptor *descr,
166                                    u16 wLength)
167 {
168         u16 temp = 1 + (wusbhc->ports_max / 8);
169         u8 length = 7 + 2 * temp;
170
171         if (wLength < length)
172                 return -ENOSPC;
173         descr->bDescLength = 7 + 2 * temp;
174         descr->bDescriptorType = 0x29;  /* HUB type */
175         descr->bNbrPorts = wusbhc->ports_max;
176         descr->wHubCharacteristics = cpu_to_le16(
177                 0x00                    /* All ports power at once */
178                 | 0x00                  /* not part of compound device */
179                 | 0x10                  /* No overcurrent protection */
180                 | 0x00                  /* 8 FS think time FIXME ?? */
181                 | 0x00);                /* No port indicators */
182         descr->bPwrOn2PwrGood = 0;
183         descr->bHubContrCurrent = 0;
184         /* two bitmaps:  ports removable, and usb 1.0 legacy PortPwrCtrlMask */
185         memset(&descr->bitmap[0], 0, temp);
186         memset(&descr->bitmap[temp], 0xff, temp);
187         return 0;
188 }
189
190 /*
191  * Clear a hub feature
192  *
193  * @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
194  *
195  * Nothing to do, so no locking needed ;)
196  */
197 static int wusbhc_rh_clear_hub_feat(struct wusbhc *wusbhc, u16 feature)
198 {
199         int result;
200         struct device *dev = wusbhc->dev;
201
202         d_fnstart(4, dev, "(%p, feature 0x%04u)\n", wusbhc, feature);
203         switch (feature) {
204         case C_HUB_LOCAL_POWER:
205                 /* FIXME: maybe plug bit 0 to the power input status,
206                  * if any?
207                  * see wusbhc_rh_get_hub_status() */
208         case C_HUB_OVER_CURRENT:
209                 result = 0;
210                 break;
211         default:
212                 result = -EPIPE;
213         }
214         d_fnend(4, dev, "(%p, feature 0x%04u), %d\n", wusbhc, feature, result);
215         return result;
216 }
217
218 /*
219  * Return hub status (it is always zero...)
220  *
221  * @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
222  *
223  * Nothing to do, so no locking needed ;)
224  */
225 static int wusbhc_rh_get_hub_status(struct wusbhc *wusbhc, u32 *buf,
226                                     u16 wLength)
227 {
228         /* FIXME: maybe plug bit 0 to the power input status (if any)? */
229         *buf = 0;
230         return 0;
231 }
232
233 /*
234  * Set a port feature
235  *
236  * @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
237  */
238 static int wusbhc_rh_set_port_feat(struct wusbhc *wusbhc, u16 feature,
239                                    u8 selector, u8 port_idx)
240 {
241         int result = -EINVAL;
242         struct device *dev = wusbhc->dev;
243
244         d_fnstart(4, dev, "(feat 0x%04u, selector 0x%u, port_idx %d)\n",
245                   feature, selector, port_idx);
246
247         if (port_idx > wusbhc->ports_max)
248                 goto error;
249
250         switch (feature) {
251                 /* According to USB2.0[11.24.2.13]p2, these features
252                  * are not required to be implemented. */
253         case USB_PORT_FEAT_C_OVER_CURRENT:
254         case USB_PORT_FEAT_C_ENABLE:
255         case USB_PORT_FEAT_C_SUSPEND:
256         case USB_PORT_FEAT_C_CONNECTION:
257         case USB_PORT_FEAT_C_RESET:
258                 result = 0;
259                 break;
260
261         case USB_PORT_FEAT_POWER:
262                 /* No such thing, but we fake it works */
263                 mutex_lock(&wusbhc->mutex);
264                 wusb_port_by_idx(wusbhc, port_idx)->status |= USB_PORT_STAT_POWER;
265                 mutex_unlock(&wusbhc->mutex);
266                 result = 0;
267                 break;
268         case USB_PORT_FEAT_RESET:
269                 result = wusbhc_rh_port_reset(wusbhc, port_idx);
270                 break;
271         case USB_PORT_FEAT_ENABLE:
272         case USB_PORT_FEAT_SUSPEND:
273                 dev_err(dev, "(port_idx %d) set feat %d/%d UNIMPLEMENTED\n",
274                         port_idx, feature, selector);
275                 result = -ENOSYS;
276                 break;
277         default:
278                 dev_err(dev, "(port_idx %d) set feat %d/%d UNKNOWN\n",
279                         port_idx, feature, selector);
280                 result = -EPIPE;
281                 break;
282         }
283 error:
284         d_fnend(4, dev, "(feat 0x%04u, selector 0x%u, port_idx %d) = %d\n",
285                 feature, selector, port_idx, result);
286         return result;
287 }
288
289 /*
290  * Clear a port feature...
291  *
292  * @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
293  */
294 static int wusbhc_rh_clear_port_feat(struct wusbhc *wusbhc, u16 feature,
295                                      u8 selector, u8 port_idx)
296 {
297         int result = -EINVAL;
298         struct device *dev = wusbhc->dev;
299
300         d_fnstart(4, dev, "(wusbhc %p feat 0x%04x selector %d port_idx %d)\n",
301                   wusbhc, feature, selector, port_idx);
302
303         if (port_idx > wusbhc->ports_max)
304                 goto error;
305
306         mutex_lock(&wusbhc->mutex);
307         result = 0;
308         switch (feature) {
309         case USB_PORT_FEAT_POWER:       /* fake port always on */
310                 /* According to USB2.0[11.24.2.7.1.4], no need to implement? */
311         case USB_PORT_FEAT_C_OVER_CURRENT:
312                 break;
313         case USB_PORT_FEAT_C_RESET:
314                 wusb_port_by_idx(wusbhc, port_idx)->change &= ~USB_PORT_STAT_C_RESET;
315                 break;
316         case USB_PORT_FEAT_C_CONNECTION:
317                 wusb_port_by_idx(wusbhc, port_idx)->change &= ~USB_PORT_STAT_C_CONNECTION;
318                 break;
319         case USB_PORT_FEAT_ENABLE:
320                 __wusbhc_dev_disable(wusbhc, port_idx);
321                 break;
322         case USB_PORT_FEAT_C_ENABLE:
323                 wusb_port_by_idx(wusbhc, port_idx)->change &= ~USB_PORT_STAT_C_ENABLE;
324                 break;
325         case USB_PORT_FEAT_SUSPEND:
326         case USB_PORT_FEAT_C_SUSPEND:
327         case 0xffff:            /* ??? FIXME */
328                 dev_err(dev, "(port_idx %d) Clear feat %d/%d UNIMPLEMENTED\n",
329                         port_idx, feature, selector);
330                 /* dump_stack(); */
331                 result = -ENOSYS;
332                 break;
333         default:
334                 dev_err(dev, "(port_idx %d) Clear feat %d/%d UNKNOWN\n",
335                         port_idx, feature, selector);
336                 result = -EPIPE;
337                 break;
338         }
339         mutex_unlock(&wusbhc->mutex);
340 error:
341         d_fnend(4, dev, "(wusbhc %p feat 0x%04x selector %d port_idx %d) = "
342                 "%d\n", wusbhc, feature, selector, port_idx, result);
343         return result;
344 }
345
346 /*
347  * Return the port's status
348  *
349  * @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
350  */
351 static int wusbhc_rh_get_port_status(struct wusbhc *wusbhc, u16 port_idx,
352                                      u32 *_buf, u16 wLength)
353 {
354         int result = -EINVAL;
355         u16 *buf = (u16 *) _buf;
356
357         d_fnstart(1, wusbhc->dev, "(wusbhc %p port_idx %u wLength %u)\n",
358                   wusbhc, port_idx, wLength);
359         if (port_idx > wusbhc->ports_max)
360                 goto error;
361         mutex_lock(&wusbhc->mutex);
362         buf[0] = cpu_to_le16(wusb_port_by_idx(wusbhc, port_idx)->status);
363         buf[1] = cpu_to_le16(wusb_port_by_idx(wusbhc, port_idx)->change);
364         result = 0;
365         mutex_unlock(&wusbhc->mutex);
366 error:
367         d_fnend(1, wusbhc->dev, "(wusbhc %p) = %d, buffer:\n", wusbhc, result);
368         d_dump(1, wusbhc->dev, _buf, wLength);
369         return result;
370 }
371
372 /*
373  * Entry point for Root Hub operations
374  *
375  * @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
376  */
377 int wusbhc_rh_control(struct usb_hcd *usb_hcd, u16 reqntype, u16 wValue,
378                       u16 wIndex, char *buf, u16 wLength)
379 {
380         int result = -ENOSYS;
381         struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd);
382
383         switch (reqntype) {
384         case GetHubDescriptor:
385                 result = wusbhc_rh_get_hub_descr(
386                         wusbhc, wValue, wIndex,
387                         (struct usb_hub_descriptor *) buf, wLength);
388                 break;
389         case ClearHubFeature:
390                 result = wusbhc_rh_clear_hub_feat(wusbhc, wValue);
391                 break;
392         case GetHubStatus:
393                 result = wusbhc_rh_get_hub_status(wusbhc, (u32 *)buf, wLength);
394                 break;
395
396         case SetPortFeature:
397                 result = wusbhc_rh_set_port_feat(wusbhc, wValue, wIndex >> 8,
398                                                  (wIndex & 0xff) - 1);
399                 break;
400         case ClearPortFeature:
401                 result = wusbhc_rh_clear_port_feat(wusbhc, wValue, wIndex >> 8,
402                                                    (wIndex & 0xff) - 1);
403                 break;
404         case GetPortStatus:
405                 result = wusbhc_rh_get_port_status(wusbhc, wIndex - 1,
406                                                    (u32 *)buf, wLength);
407                 break;
408
409         case SetHubFeature:
410         default:
411                 dev_err(wusbhc->dev, "%s (%p [%p], %x, %x, %x, %p, %x) "
412                         "UNIMPLEMENTED\n", __func__, usb_hcd, wusbhc, reqntype,
413                         wValue, wIndex, buf, wLength);
414                 /* dump_stack(); */
415                 result = -ENOSYS;
416         }
417         return result;
418 }
419 EXPORT_SYMBOL_GPL(wusbhc_rh_control);
420
421 int wusbhc_rh_suspend(struct usb_hcd *usb_hcd)
422 {
423         struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd);
424         dev_err(wusbhc->dev, "%s (%p [%p]) UNIMPLEMENTED\n", __func__,
425                 usb_hcd, wusbhc);
426         /* dump_stack(); */
427         return -ENOSYS;
428 }
429 EXPORT_SYMBOL_GPL(wusbhc_rh_suspend);
430
431 int wusbhc_rh_resume(struct usb_hcd *usb_hcd)
432 {
433         struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd);
434         dev_err(wusbhc->dev, "%s (%p [%p]) UNIMPLEMENTED\n", __func__,
435                 usb_hcd, wusbhc);
436         /* dump_stack(); */
437         return -ENOSYS;
438 }
439 EXPORT_SYMBOL_GPL(wusbhc_rh_resume);
440
441 int wusbhc_rh_start_port_reset(struct usb_hcd *usb_hcd, unsigned port_idx)
442 {
443         struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd);
444         dev_err(wusbhc->dev, "%s (%p [%p], port_idx %u) UNIMPLEMENTED\n",
445                 __func__, usb_hcd, wusbhc, port_idx);
446         WARN_ON(1);
447         return -ENOSYS;
448 }
449 EXPORT_SYMBOL_GPL(wusbhc_rh_start_port_reset);
450
451 static void wusb_port_init(struct wusb_port *port)
452 {
453         port->status |= USB_PORT_STAT_HIGH_SPEED;
454 }
455
456 /*
457  * Alloc fake port specific fields and status.
458  */
459 int wusbhc_rh_create(struct wusbhc *wusbhc)
460 {
461         int result = -ENOMEM;
462         size_t port_size, itr;
463         port_size = wusbhc->ports_max * sizeof(wusbhc->port[0]);
464         wusbhc->port = kzalloc(port_size, GFP_KERNEL);
465         if (wusbhc->port == NULL)
466                 goto error_port_alloc;
467         for (itr = 0; itr < wusbhc->ports_max; itr++)
468                 wusb_port_init(&wusbhc->port[itr]);
469         result = 0;
470 error_port_alloc:
471         return result;
472 }
473
474 void wusbhc_rh_destroy(struct wusbhc *wusbhc)
475 {
476         kfree(wusbhc->port);
477 }