1
2
3
4
5
6
7
8
9
10
11#include <linux/kernel.h>
12#include <linux/errno.h>
13#include <linux/module.h>
14#include <linux/moduleparam.h>
15#include <linux/completion.h>
16#include <linux/sched.h>
17#include <linux/list.h>
18#include <linux/slab.h>
19#include <linux/ioctl.h>
20#include <linux/usb.h>
21#include <linux/usbdevice_fs.h>
22#include <linux/kthread.h>
23#include <linux/mutex.h>
24#include <linux/freezer.h>
25
26#include <asm/uaccess.h>
27#include <asm/byteorder.h>
28
29#include "usb.h"
30#include "hcd.h"
31#include "hub.h"
32
33
34#ifdef DEBUG
35#ifndef CONFIG_USB_ANNOUNCE_NEW_DEVICES
36#define CONFIG_USB_ANNOUNCE_NEW_DEVICES
37#endif
38#endif
39
40struct usb_hub {
41 struct device *intfdev;
42 struct usb_device *hdev;
43 struct kref kref;
44 struct urb *urb;
45
46
47 char (*buffer)[8];
48 dma_addr_t buffer_dma;
49 union {
50 struct usb_hub_status hub;
51 struct usb_port_status port;
52 } *status;
53 struct mutex status_mutex;
54
55 int error;
56 int nerrors;
57
58 struct list_head event_list;
59 unsigned long event_bits[1];
60 unsigned long change_bits[1];
61
62 unsigned long busy_bits[1];
63
64#if USB_MAXCHILDREN > 31
65#error event_bits[] is too short!
66#endif
67
68 struct usb_hub_descriptor *descriptor;
69 struct usb_tt tt;
70
71 unsigned mA_per_port;
72
73 unsigned limited_power:1;
74 unsigned quiescing:1;
75 unsigned disconnected:1;
76
77 unsigned has_indicators:1;
78 u8 indicator[USB_MAXCHILDREN];
79 struct delayed_work leds;
80 struct delayed_work init_work;
81 void **port_owners;
82};
83
84
85
86
87
88static DEFINE_SPINLOCK(device_state_lock);
89
90
91static DEFINE_SPINLOCK(hub_event_lock);
92static LIST_HEAD(hub_event_list);
93
94
95static DECLARE_WAIT_QUEUE_HEAD(khubd_wait);
96
97static struct task_struct *khubd_task;
98
99
100static int blinkenlights = 0;
101module_param (blinkenlights, bool, S_IRUGO);
102MODULE_PARM_DESC (blinkenlights, "true to cycle leds on hubs");
103
104
105
106
107
108
109static int initial_descriptor_timeout = USB_CTRL_GET_TIMEOUT;
110module_param(initial_descriptor_timeout, int, S_IRUGO|S_IWUSR);
111MODULE_PARM_DESC(initial_descriptor_timeout,
112 "initial 64-byte descriptor request timeout in milliseconds "
113 "(default 5000 - 5.0 seconds)");
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129static int old_scheme_first = 0;
130module_param(old_scheme_first, bool, S_IRUGO | S_IWUSR);
131MODULE_PARM_DESC(old_scheme_first,
132 "start with the old device initialization scheme");
133
134static int use_both_schemes = 1;
135module_param(use_both_schemes, bool, S_IRUGO | S_IWUSR);
136MODULE_PARM_DESC(use_both_schemes,
137 "try the other device initialization scheme if the "
138 "first one fails");
139
140
141
142
143DECLARE_RWSEM(ehci_cf_port_reset_rwsem);
144EXPORT_SYMBOL_GPL(ehci_cf_port_reset_rwsem);
145
146#define HUB_DEBOUNCE_TIMEOUT 1500
147#define HUB_DEBOUNCE_STEP 25
148#define HUB_DEBOUNCE_STABLE 100
149
150
151static int usb_reset_and_verify_device(struct usb_device *udev);
152
153static inline char *portspeed(int portstatus)
154{
155 if (portstatus & (1 << USB_PORT_FEAT_HIGHSPEED))
156 return "480 Mb/s";
157 else if (portstatus & (1 << USB_PORT_FEAT_LOWSPEED))
158 return "1.5 Mb/s";
159 else if (portstatus & (1 << USB_PORT_FEAT_SUPERSPEED))
160 return "5.0 Gb/s";
161 else
162 return "12 Mb/s";
163}
164
165
166static struct usb_hub *hdev_to_hub(struct usb_device *hdev)
167{
168 if (!hdev || !hdev->actconfig)
169 return NULL;
170 return usb_get_intfdata(hdev->actconfig->interface[0]);
171}
172
173
174static int get_hub_descriptor(struct usb_device *hdev, void *data, int size)
175{
176 int i, ret;
177
178 for (i = 0; i < 3; i++) {
179 ret = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
180 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB,
181 USB_DT_HUB << 8, 0, data, size,
182 USB_CTRL_GET_TIMEOUT);
183 if (ret >= (USB_DT_HUB_NONVAR_SIZE + 2))
184 return ret;
185 }
186 return -EINVAL;
187}
188
189
190
191
192static int clear_hub_feature(struct usb_device *hdev, int feature)
193{
194 return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
195 USB_REQ_CLEAR_FEATURE, USB_RT_HUB, feature, 0, NULL, 0, 1000);
196}
197
198
199
200
201static int clear_port_feature(struct usb_device *hdev, int port1, int feature)
202{
203 return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
204 USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature, port1,
205 NULL, 0, 1000);
206}
207
208
209
210
211static int set_port_feature(struct usb_device *hdev, int port1, int feature)
212{
213 return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
214 USB_REQ_SET_FEATURE, USB_RT_PORT, feature, port1,
215 NULL, 0, 1000);
216}
217
218
219
220
221
222static void set_port_led(
223 struct usb_hub *hub,
224 int port1,
225 int selector
226)
227{
228 int status = set_port_feature(hub->hdev, (selector << 8) | port1,
229 USB_PORT_FEAT_INDICATOR);
230 if (status < 0)
231 dev_dbg (hub->intfdev,
232 "port %d indicator %s status %d\n",
233 port1,
234 ({ char *s; switch (selector) {
235 case HUB_LED_AMBER: s = "amber"; break;
236 case HUB_LED_GREEN: s = "green"; break;
237 case HUB_LED_OFF: s = "off"; break;
238 case HUB_LED_AUTO: s = "auto"; break;
239 default: s = "??"; break;
240 }; s; }),
241 status);
242}
243
244#define LED_CYCLE_PERIOD ((2*HZ)/3)
245
246static void led_work (struct work_struct *work)
247{
248 struct usb_hub *hub =
249 container_of(work, struct usb_hub, leds.work);
250 struct usb_device *hdev = hub->hdev;
251 unsigned i;
252 unsigned changed = 0;
253 int cursor = -1;
254
255 if (hdev->state != USB_STATE_CONFIGURED || hub->quiescing)
256 return;
257
258 for (i = 0; i < hub->descriptor->bNbrPorts; i++) {
259 unsigned selector, mode;
260
261
262
263 switch (hub->indicator[i]) {
264
265 case INDICATOR_CYCLE:
266 cursor = i;
267 selector = HUB_LED_AUTO;
268 mode = INDICATOR_AUTO;
269 break;
270
271 case INDICATOR_GREEN_BLINK:
272 selector = HUB_LED_GREEN;
273 mode = INDICATOR_GREEN_BLINK_OFF;
274 break;
275 case INDICATOR_GREEN_BLINK_OFF:
276 selector = HUB_LED_OFF;
277 mode = INDICATOR_GREEN_BLINK;
278 break;
279
280 case INDICATOR_AMBER_BLINK:
281 selector = HUB_LED_AMBER;
282 mode = INDICATOR_AMBER_BLINK_OFF;
283 break;
284 case INDICATOR_AMBER_BLINK_OFF:
285 selector = HUB_LED_OFF;
286 mode = INDICATOR_AMBER_BLINK;
287 break;
288
289 case INDICATOR_ALT_BLINK:
290 selector = HUB_LED_GREEN;
291 mode = INDICATOR_ALT_BLINK_OFF;
292 break;
293 case INDICATOR_ALT_BLINK_OFF:
294 selector = HUB_LED_AMBER;
295 mode = INDICATOR_ALT_BLINK;
296 break;
297 default:
298 continue;
299 }
300 if (selector != HUB_LED_AUTO)
301 changed = 1;
302 set_port_led(hub, i + 1, selector);
303 hub->indicator[i] = mode;
304 }
305 if (!changed && blinkenlights) {
306 cursor++;
307 cursor %= hub->descriptor->bNbrPorts;
308 set_port_led(hub, cursor + 1, HUB_LED_GREEN);
309 hub->indicator[cursor] = INDICATOR_CYCLE;
310 changed++;
311 }
312 if (changed)
313 schedule_delayed_work(&hub->leds, LED_CYCLE_PERIOD);
314}
315
316
317#define USB_STS_TIMEOUT 1000
318#define USB_STS_RETRIES 5
319
320
321
322
323static int get_hub_status(struct usb_device *hdev,
324 struct usb_hub_status *data)
325{
326 int i, status = -ETIMEDOUT;
327
328 for (i = 0; i < USB_STS_RETRIES && status == -ETIMEDOUT; i++) {
329 status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
330 USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_HUB, 0, 0,
331 data, sizeof(*data), USB_STS_TIMEOUT);
332 }
333 return status;
334}
335
336
337
338
339static int get_port_status(struct usb_device *hdev, int port1,
340 struct usb_port_status *data)
341{
342 int i, status = -ETIMEDOUT;
343
344 for (i = 0; i < USB_STS_RETRIES && status == -ETIMEDOUT; i++) {
345 status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
346 USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, 0, port1,
347 data, sizeof(*data), USB_STS_TIMEOUT);
348 }
349 return status;
350}
351
352static int hub_port_status(struct usb_hub *hub, int port1,
353 u16 *status, u16 *change)
354{
355 int ret;
356
357 mutex_lock(&hub->status_mutex);
358 ret = get_port_status(hub->hdev, port1, &hub->status->port);
359 if (ret < 4) {
360 dev_err(hub->intfdev,
361 "%s failed (err = %d)\n", __func__, ret);
362 if (ret >= 0)
363 ret = -EIO;
364 } else {
365 *status = le16_to_cpu(hub->status->port.wPortStatus);
366 *change = le16_to_cpu(hub->status->port.wPortChange);
367 ret = 0;
368 }
369 mutex_unlock(&hub->status_mutex);
370 return ret;
371}
372
373static void kick_khubd(struct usb_hub *hub)
374{
375 unsigned long flags;
376
377
378 atomic_set(&to_usb_interface(hub->intfdev)->pm_usage_cnt, 1);
379
380 spin_lock_irqsave(&hub_event_lock, flags);
381 if (!hub->disconnected && list_empty(&hub->event_list)) {
382 list_add_tail(&hub->event_list, &hub_event_list);
383 wake_up(&khubd_wait);
384 }
385 spin_unlock_irqrestore(&hub_event_lock, flags);
386}
387
388void usb_kick_khubd(struct usb_device *hdev)
389{
390 struct usb_hub *hub = hdev_to_hub(hdev);
391
392 if (hub)
393 kick_khubd(hub);
394}
395
396
397
398static void hub_irq(struct urb *urb)
399{
400 struct usb_hub *hub = urb->context;
401 int status = urb->status;
402 unsigned i;
403 unsigned long bits;
404
405 switch (status) {
406 case -ENOENT:
407 case -ECONNRESET:
408 case -ESHUTDOWN:
409 return;
410
411 default:
412
413 dev_dbg (hub->intfdev, "transfer --> %d\n", status);
414 if ((++hub->nerrors < 10) || hub->error)
415 goto resubmit;
416 hub->error = status;
417
418
419
420 case 0:
421 bits = 0;
422 for (i = 0; i < urb->actual_length; ++i)
423 bits |= ((unsigned long) ((*hub->buffer)[i]))
424 << (i*8);
425 hub->event_bits[0] = bits;
426 break;
427 }
428
429 hub->nerrors = 0;
430
431
432 kick_khubd(hub);
433
434resubmit:
435 if (hub->quiescing)
436 return;
437
438 if ((status = usb_submit_urb (hub->urb, GFP_ATOMIC)) != 0
439 && status != -ENODEV && status != -EPERM)
440 dev_err (hub->intfdev, "resubmit --> %d\n", status);
441}
442
443
444static inline int
445hub_clear_tt_buffer (struct usb_device *hdev, u16 devinfo, u16 tt)
446{
447 return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
448 HUB_CLEAR_TT_BUFFER, USB_RT_PORT, devinfo,
449 tt, NULL, 0, 1000);
450}
451
452
453
454
455
456
457
458static void hub_tt_work(struct work_struct *work)
459{
460 struct usb_hub *hub =
461 container_of(work, struct usb_hub, tt.clear_work);
462 unsigned long flags;
463 int limit = 100;
464
465 spin_lock_irqsave (&hub->tt.lock, flags);
466 while (--limit && !list_empty (&hub->tt.clear_list)) {
467 struct list_head *next;
468 struct usb_tt_clear *clear;
469 struct usb_device *hdev = hub->hdev;
470 const struct hc_driver *drv;
471 int status;
472
473 next = hub->tt.clear_list.next;
474 clear = list_entry (next, struct usb_tt_clear, clear_list);
475 list_del (&clear->clear_list);
476
477
478 spin_unlock_irqrestore (&hub->tt.lock, flags);
479 status = hub_clear_tt_buffer (hdev, clear->devinfo, clear->tt);
480 if (status)
481 dev_err (&hdev->dev,
482 "clear tt %d (%04x) error %d\n",
483 clear->tt, clear->devinfo, status);
484
485
486 drv = clear->hcd->driver;
487 if (drv->clear_tt_buffer_complete)
488 (drv->clear_tt_buffer_complete)(clear->hcd, clear->ep);
489
490 kfree(clear);
491 spin_lock_irqsave(&hub->tt.lock, flags);
492 }
493 spin_unlock_irqrestore (&hub->tt.lock, flags);
494}
495
496
497
498
499
500
501
502
503
504
505
506
507
508int usb_hub_clear_tt_buffer(struct urb *urb)
509{
510 struct usb_device *udev = urb->dev;
511 int pipe = urb->pipe;
512 struct usb_tt *tt = udev->tt;
513 unsigned long flags;
514 struct usb_tt_clear *clear;
515
516
517
518
519
520 if ((clear = kmalloc (sizeof *clear, GFP_ATOMIC)) == NULL) {
521 dev_err (&udev->dev, "can't save CLEAR_TT_BUFFER state\n");
522
523 return -ENOMEM;
524 }
525
526
527 clear->tt = tt->multi ? udev->ttport : 1;
528 clear->devinfo = usb_pipeendpoint (pipe);
529 clear->devinfo |= udev->devnum << 4;
530 clear->devinfo |= usb_pipecontrol (pipe)
531 ? (USB_ENDPOINT_XFER_CONTROL << 11)
532 : (USB_ENDPOINT_XFER_BULK << 11);
533 if (usb_pipein (pipe))
534 clear->devinfo |= 1 << 15;
535
536
537 clear->hcd = bus_to_hcd(udev->bus);
538 clear->ep = urb->ep;
539
540
541 spin_lock_irqsave (&tt->lock, flags);
542 list_add_tail (&clear->clear_list, &tt->clear_list);
543 schedule_work(&tt->clear_work);
544 spin_unlock_irqrestore (&tt->lock, flags);
545 return 0;
546}
547EXPORT_SYMBOL_GPL(usb_hub_clear_tt_buffer);
548
549
550
551
552static unsigned hub_power_on(struct usb_hub *hub, bool do_delay)
553{
554 int port1;
555 unsigned pgood_delay = hub->descriptor->bPwrOn2PwrGood * 2;
556 unsigned delay;
557 u16 wHubCharacteristics =
558 le16_to_cpu(hub->descriptor->wHubCharacteristics);
559
560
561
562
563
564
565
566 if ((wHubCharacteristics & HUB_CHAR_LPSM) < 2)
567 dev_dbg(hub->intfdev, "enabling power on all ports\n");
568 else
569 dev_dbg(hub->intfdev, "trying to enable port power on "
570 "non-switchable hub\n");
571 for (port1 = 1; port1 <= hub->descriptor->bNbrPorts; port1++)
572 set_port_feature(hub->hdev, port1, USB_PORT_FEAT_POWER);
573
574
575 delay = max(pgood_delay, (unsigned) 100);
576 if (do_delay)
577 msleep(delay);
578 return delay;
579}
580
581static int hub_hub_status(struct usb_hub *hub,
582 u16 *status, u16 *change)
583{
584 int ret;
585
586 mutex_lock(&hub->status_mutex);
587 ret = get_hub_status(hub->hdev, &hub->status->hub);
588 if (ret < 0)
589 dev_err (hub->intfdev,
590 "%s failed (err = %d)\n", __func__, ret);
591 else {
592 *status = le16_to_cpu(hub->status->hub.wHubStatus);
593 *change = le16_to_cpu(hub->status->hub.wHubChange);
594 ret = 0;
595 }
596 mutex_unlock(&hub->status_mutex);
597 return ret;
598}
599
600static int hub_port_disable(struct usb_hub *hub, int port1, int set_state)
601{
602 struct usb_device *hdev = hub->hdev;
603 int ret = 0;
604
605 if (hdev->children[port1-1] && set_state)
606 usb_set_device_state(hdev->children[port1-1],
607 USB_STATE_NOTATTACHED);
608 if (!hub->error)
609 ret = clear_port_feature(hdev, port1, USB_PORT_FEAT_ENABLE);
610 if (ret)
611 dev_err(hub->intfdev, "cannot disable port %d (err = %d)\n",
612 port1, ret);
613 return ret;
614}
615
616
617
618
619
620
621static void hub_port_logical_disconnect(struct usb_hub *hub, int port1)
622{
623 dev_dbg(hub->intfdev, "logical disconnect on port %d\n", port1);
624 hub_port_disable(hub, port1, 1);
625
626
627
628
629
630
631
632
633
634
635 set_bit(port1, hub->change_bits);
636 kick_khubd(hub);
637}
638
639enum hub_activation_type {
640 HUB_INIT, HUB_INIT2, HUB_INIT3,
641 HUB_POST_RESET, HUB_RESUME, HUB_RESET_RESUME,
642};
643
644static void hub_init_func2(struct work_struct *ws);
645static void hub_init_func3(struct work_struct *ws);
646
647static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
648{
649 struct usb_device *hdev = hub->hdev;
650 int port1;
651 int status;
652 bool need_debounce_delay = false;
653 unsigned delay;
654
655
656 if (type == HUB_INIT2)
657 goto init2;
658 if (type == HUB_INIT3)
659 goto init3;
660
661
662
663
664 if (type != HUB_RESUME) {
665
666
667
668
669
670
671
672
673
674
675
676
677
678 if (type == HUB_INIT) {
679 delay = hub_power_on(hub, false);
680 PREPARE_DELAYED_WORK(&hub->init_work, hub_init_func2);
681 schedule_delayed_work(&hub->init_work,
682 msecs_to_jiffies(delay));
683
684
685 atomic_set(&to_usb_interface(hub->intfdev)->
686 pm_usage_cnt, 1);
687 return;
688 } else {
689 hub_power_on(hub, true);
690 }
691 }
692 init2:
693
694
695
696
697 for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
698 struct usb_device *udev = hdev->children[port1-1];
699 u16 portstatus, portchange;
700
701 portstatus = portchange = 0;
702 status = hub_port_status(hub, port1, &portstatus, &portchange);
703 if (udev || (portstatus & USB_PORT_STAT_CONNECTION))
704 dev_dbg(hub->intfdev,
705 "port %d: status %04x change %04x\n",
706 port1, portstatus, portchange);
707
708
709
710
711
712
713 if ((portstatus & USB_PORT_STAT_ENABLE) && (
714 type != HUB_RESUME ||
715 !(portstatus & USB_PORT_STAT_CONNECTION) ||
716 !udev ||
717 udev->state == USB_STATE_NOTATTACHED)) {
718 clear_port_feature(hdev, port1, USB_PORT_FEAT_ENABLE);
719 portstatus &= ~USB_PORT_STAT_ENABLE;
720 }
721
722
723 if (portchange & USB_PORT_STAT_C_CONNECTION) {
724 need_debounce_delay = true;
725 clear_port_feature(hub->hdev, port1,
726 USB_PORT_FEAT_C_CONNECTION);
727 }
728 if (portchange & USB_PORT_STAT_C_ENABLE) {
729 need_debounce_delay = true;
730 clear_port_feature(hub->hdev, port1,
731 USB_PORT_FEAT_C_ENABLE);
732 }
733
734 if (!udev || udev->state == USB_STATE_NOTATTACHED) {
735
736
737
738 if (udev || (portstatus & USB_PORT_STAT_CONNECTION))
739 set_bit(port1, hub->change_bits);
740
741 } else if (portstatus & USB_PORT_STAT_ENABLE) {
742
743
744
745
746
747 if (portchange)
748 set_bit(port1, hub->change_bits);
749
750 } else if (udev->persist_enabled) {
751#ifdef CONFIG_PM
752 udev->reset_resume = 1;
753#endif
754 set_bit(port1, hub->change_bits);
755
756 } else {
757
758 usb_set_device_state(udev, USB_STATE_NOTATTACHED);
759 set_bit(port1, hub->change_bits);
760 }
761 }
762
763
764
765
766
767
768
769
770
771 if (need_debounce_delay) {
772 delay = HUB_DEBOUNCE_STABLE;
773
774
775 if (type == HUB_INIT2) {
776 PREPARE_DELAYED_WORK(&hub->init_work, hub_init_func3);
777 schedule_delayed_work(&hub->init_work,
778 msecs_to_jiffies(delay));
779 return;
780 } else {
781 msleep(delay);
782 }
783 }
784 init3:
785 hub->quiescing = 0;
786
787 status = usb_submit_urb(hub->urb, GFP_NOIO);
788 if (status < 0)
789 dev_err(hub->intfdev, "activate --> %d\n", status);
790 if (hub->has_indicators && blinkenlights)
791 schedule_delayed_work(&hub->leds, LED_CYCLE_PERIOD);
792
793
794 kick_khubd(hub);
795}
796
797
798static void hub_init_func2(struct work_struct *ws)
799{
800 struct usb_hub *hub = container_of(ws, struct usb_hub, init_work.work);
801
802 hub_activate(hub, HUB_INIT2);
803}
804
805static void hub_init_func3(struct work_struct *ws)
806{
807 struct usb_hub *hub = container_of(ws, struct usb_hub, init_work.work);
808
809 hub_activate(hub, HUB_INIT3);
810}
811
812enum hub_quiescing_type {
813 HUB_DISCONNECT, HUB_PRE_RESET, HUB_SUSPEND
814};
815
816static void hub_quiesce(struct usb_hub *hub, enum hub_quiescing_type type)
817{
818 struct usb_device *hdev = hub->hdev;
819 int i;
820
821 cancel_delayed_work_sync(&hub->init_work);
822
823
824 hub->quiescing = 1;
825
826 if (type != HUB_SUSPEND) {
827
828 for (i = 0; i < hdev->maxchild; ++i) {
829 if (hdev->children[i])
830 usb_disconnect(&hdev->children[i]);
831 }
832 }
833
834
835 usb_kill_urb(hub->urb);
836 if (hub->has_indicators)
837 cancel_delayed_work_sync(&hub->leds);
838 if (hub->tt.hub)
839 cancel_work_sync(&hub->tt.clear_work);
840}
841
842
843static int hub_pre_reset(struct usb_interface *intf)
844{
845 struct usb_hub *hub = usb_get_intfdata(intf);
846
847 hub_quiesce(hub, HUB_PRE_RESET);
848 return 0;
849}
850
851
852static int hub_post_reset(struct usb_interface *intf)
853{
854 struct usb_hub *hub = usb_get_intfdata(intf);
855
856 hub_activate(hub, HUB_POST_RESET);
857 return 0;
858}
859
860static int hub_configure(struct usb_hub *hub,
861 struct usb_endpoint_descriptor *endpoint)
862{
863 struct usb_hcd *hcd;
864 struct usb_device *hdev = hub->hdev;
865 struct device *hub_dev = hub->intfdev;
866 u16 hubstatus, hubchange;
867 u16 wHubCharacteristics;
868 unsigned int pipe;
869 int maxp, ret;
870 char *message = "out of memory";
871
872 hub->buffer = usb_buffer_alloc(hdev, sizeof(*hub->buffer), GFP_KERNEL,
873 &hub->buffer_dma);
874 if (!hub->buffer) {
875 ret = -ENOMEM;
876 goto fail;
877 }
878
879 hub->status = kmalloc(sizeof(*hub->status), GFP_KERNEL);
880 if (!hub->status) {
881 ret = -ENOMEM;
882 goto fail;
883 }
884 mutex_init(&hub->status_mutex);
885
886 hub->descriptor = kmalloc(sizeof(*hub->descriptor), GFP_KERNEL);
887 if (!hub->descriptor) {
888 ret = -ENOMEM;
889 goto fail;
890 }
891
892
893
894
895
896 ret = get_hub_descriptor(hdev, hub->descriptor,
897 sizeof(*hub->descriptor));
898 if (ret < 0) {
899 message = "can't read hub descriptor";
900 goto fail;
901 } else if (hub->descriptor->bNbrPorts > USB_MAXCHILDREN) {
902 message = "hub has too many ports!";
903 ret = -ENODEV;
904 goto fail;
905 }
906
907 hdev->maxchild = hub->descriptor->bNbrPorts;
908 dev_info (hub_dev, "%d port%s detected\n", hdev->maxchild,
909 (hdev->maxchild == 1) ? "" : "s");
910
911 hub->port_owners = kzalloc(hdev->maxchild * sizeof(void *), GFP_KERNEL);
912 if (!hub->port_owners) {
913 ret = -ENOMEM;
914 goto fail;
915 }
916
917 wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);
918
919 if (wHubCharacteristics & HUB_CHAR_COMPOUND) {
920 int i;
921 char portstr [USB_MAXCHILDREN + 1];
922
923 for (i = 0; i < hdev->maxchild; i++)
924 portstr[i] = hub->descriptor->DeviceRemovable
925 [((i + 1) / 8)] & (1 << ((i + 1) % 8))
926 ? 'F' : 'R';
927 portstr[hdev->maxchild] = 0;
928 dev_dbg(hub_dev, "compound device; port removable status: %s\n", portstr);
929 } else
930 dev_dbg(hub_dev, "standalone hub\n");
931
932 switch (wHubCharacteristics & HUB_CHAR_LPSM) {
933 case 0x00:
934 dev_dbg(hub_dev, "ganged power switching\n");
935 break;
936 case 0x01:
937 dev_dbg(hub_dev, "individual port power switching\n");
938 break;
939 case 0x02:
940 case 0x03:
941 dev_dbg(hub_dev, "no power switching (usb 1.0)\n");
942 break;
943 }
944
945 switch (wHubCharacteristics & HUB_CHAR_OCPM) {
946 case 0x00:
947 dev_dbg(hub_dev, "global over-current protection\n");
948 break;
949 case 0x08:
950 dev_dbg(hub_dev, "individual port over-current protection\n");
951 break;
952 case 0x10:
953 case 0x18:
954 dev_dbg(hub_dev, "no over-current protection\n");
955 break;
956 }
957
958 spin_lock_init (&hub->tt.lock);
959 INIT_LIST_HEAD (&hub->tt.clear_list);
960 INIT_WORK(&hub->tt.clear_work, hub_tt_work);
961 switch (hdev->descriptor.bDeviceProtocol) {
962 case 0:
963 break;
964 case 1:
965 dev_dbg(hub_dev, "Single TT\n");
966 hub->tt.hub = hdev;
967 break;
968 case 2:
969 ret = usb_set_interface(hdev, 0, 1);
970 if (ret == 0) {
971 dev_dbg(hub_dev, "TT per port\n");
972 hub->tt.multi = 1;
973 } else
974 dev_err(hub_dev, "Using single TT (err %d)\n",
975 ret);
976 hub->tt.hub = hdev;
977 break;
978 case 3:
979
980 break;
981 default:
982 dev_dbg(hub_dev, "Unrecognized hub protocol %d\n",
983 hdev->descriptor.bDeviceProtocol);
984 break;
985 }
986
987
988 switch (wHubCharacteristics & HUB_CHAR_TTTT) {
989 case HUB_TTTT_8_BITS:
990 if (hdev->descriptor.bDeviceProtocol != 0) {
991 hub->tt.think_time = 666;
992 dev_dbg(hub_dev, "TT requires at most %d "
993 "FS bit times (%d ns)\n",
994 8, hub->tt.think_time);
995 }
996 break;
997 case HUB_TTTT_16_BITS:
998 hub->tt.think_time = 666 * 2;
999 dev_dbg(hub_dev, "TT requires at most %d "
1000 "FS bit times (%d ns)\n",
1001 16, hub->tt.think_time);
1002 break;
1003 case HUB_TTTT_24_BITS:
1004 hub->tt.think_time = 666 * 3;
1005 dev_dbg(hub_dev, "TT requires at most %d "
1006 "FS bit times (%d ns)\n",
1007 24, hub->tt.think_time);
1008 break;
1009 case HUB_TTTT_32_BITS:
1010 hub->tt.think_time = 666 * 4;
1011 dev_dbg(hub_dev, "TT requires at most %d "
1012 "FS bit times (%d ns)\n",
1013 32, hub->tt.think_time);
1014 break;
1015 }
1016
1017
1018 if (wHubCharacteristics & HUB_CHAR_PORTIND) {
1019 hub->has_indicators = 1;
1020 dev_dbg(hub_dev, "Port indicators are supported\n");
1021 }
1022
1023 dev_dbg(hub_dev, "power on to power good time: %dms\n",
1024 hub->descriptor->bPwrOn2PwrGood * 2);
1025
1026
1027
1028
1029 ret = usb_get_status(hdev, USB_RECIP_DEVICE, 0, &hubstatus);
1030 if (ret < 2) {
1031 message = "can't get hub status";
1032 goto fail;
1033 }
1034 le16_to_cpus(&hubstatus);
1035 if (hdev == hdev->bus->root_hub) {
1036 if (hdev->bus_mA == 0 || hdev->bus_mA >= 500)
1037 hub->mA_per_port = 500;
1038 else {
1039 hub->mA_per_port = hdev->bus_mA;
1040 hub->limited_power = 1;
1041 }
1042 } else if ((hubstatus & (1 << USB_DEVICE_SELF_POWERED)) == 0) {
1043 dev_dbg(hub_dev, "hub controller current requirement: %dmA\n",
1044 hub->descriptor->bHubContrCurrent);
1045 hub->limited_power = 1;
1046 if (hdev->maxchild > 0) {
1047 int remaining = hdev->bus_mA -
1048 hub->descriptor->bHubContrCurrent;
1049
1050 if (remaining < hdev->maxchild * 100)
1051 dev_warn(hub_dev,
1052 "insufficient power available "
1053 "to use all downstream ports\n");
1054 hub->mA_per_port = 100;
1055 }
1056 } else {
1057
1058
1059 hub->mA_per_port = 500;
1060 }
1061 if (hub->mA_per_port < 500)
1062 dev_dbg(hub_dev, "%umA bus power budget for each child\n",
1063 hub->mA_per_port);
1064
1065
1066
1067
1068 hcd = bus_to_hcd(hdev->bus);
1069 if (hcd->driver->update_hub_device) {
1070 ret = hcd->driver->update_hub_device(hcd, hdev,
1071 &hub->tt, GFP_KERNEL);
1072 if (ret < 0) {
1073 message = "can't update HCD hub info";
1074 goto fail;
1075 }
1076 }
1077
1078 ret = hub_hub_status(hub, &hubstatus, &hubchange);
1079 if (ret < 0) {
1080 message = "can't get hub status";
1081 goto fail;
1082 }
1083
1084
1085 if (hdev->actconfig->desc.bmAttributes & USB_CONFIG_ATT_SELFPOWER)
1086 dev_dbg(hub_dev, "local power source is %s\n",
1087 (hubstatus & HUB_STATUS_LOCAL_POWER)
1088 ? "lost (inactive)" : "good");
1089
1090 if ((wHubCharacteristics & HUB_CHAR_OCPM) == 0)
1091 dev_dbg(hub_dev, "%sover-current condition exists\n",
1092 (hubstatus & HUB_STATUS_OVERCURRENT) ? "" : "no ");
1093
1094
1095
1096
1097
1098
1099
1100 pipe = usb_rcvintpipe(hdev, endpoint->bEndpointAddress);
1101 maxp = usb_maxpacket(hdev, pipe, usb_pipeout(pipe));
1102
1103 if (maxp > sizeof(*hub->buffer))
1104 maxp = sizeof(*hub->buffer);
1105
1106 hub->urb = usb_alloc_urb(0, GFP_KERNEL);
1107 if (!hub->urb) {
1108 ret = -ENOMEM;
1109 goto fail;
1110 }
1111
1112 usb_fill_int_urb(hub->urb, hdev, pipe, *hub->buffer, maxp, hub_irq,
1113 hub, endpoint->bInterval);
1114 hub->urb->transfer_dma = hub->buffer_dma;
1115 hub->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1116
1117
1118 if (hub->has_indicators && blinkenlights)
1119 hub->indicator [0] = INDICATOR_CYCLE;
1120
1121 hub_activate(hub, HUB_INIT);
1122 return 0;
1123
1124fail:
1125 dev_err (hub_dev, "config failed, %s (err %d)\n",
1126 message, ret);
1127
1128 return ret;
1129}
1130
1131static void hub_release(struct kref *kref)
1132{
1133 struct usb_hub *hub = container_of(kref, struct usb_hub, kref);
1134
1135 usb_put_intf(to_usb_interface(hub->intfdev));
1136 kfree(hub);
1137}
1138
1139static unsigned highspeed_hubs;
1140
1141static void hub_disconnect(struct usb_interface *intf)
1142{
1143 struct usb_hub *hub = usb_get_intfdata (intf);
1144
1145
1146 spin_lock_irq(&hub_event_lock);
1147 list_del_init(&hub->event_list);
1148 hub->disconnected = 1;
1149 spin_unlock_irq(&hub_event_lock);
1150
1151
1152 hub->error = 0;
1153 hub_quiesce(hub, HUB_DISCONNECT);
1154
1155 usb_set_intfdata (intf, NULL);
1156 hub->hdev->maxchild = 0;
1157
1158 if (hub->hdev->speed == USB_SPEED_HIGH)
1159 highspeed_hubs--;
1160
1161 usb_free_urb(hub->urb);
1162 kfree(hub->port_owners);
1163 kfree(hub->descriptor);
1164 kfree(hub->status);
1165 usb_buffer_free(hub->hdev, sizeof(*hub->buffer), hub->buffer,
1166 hub->buffer_dma);
1167
1168 kref_put(&hub->kref, hub_release);
1169}
1170
1171static int hub_probe(struct usb_interface *intf, const struct usb_device_id *id)
1172{
1173 struct usb_host_interface *desc;
1174 struct usb_endpoint_descriptor *endpoint;
1175 struct usb_device *hdev;
1176 struct usb_hub *hub;
1177
1178 desc = intf->cur_altsetting;
1179 hdev = interface_to_usbdev(intf);
1180
1181 if (hdev->level == MAX_TOPO_LEVEL) {
1182 dev_err(&intf->dev,
1183 "Unsupported bus topology: hub nested too deep\n");
1184 return -E2BIG;
1185 }
1186
1187#ifdef CONFIG_USB_OTG_BLACKLIST_HUB
1188 if (hdev->parent) {
1189 dev_warn(&intf->dev, "ignoring external hub\n");
1190 return -ENODEV;
1191 }
1192#endif
1193
1194
1195
1196 if ((desc->desc.bInterfaceSubClass != 0) &&
1197 (desc->desc.bInterfaceSubClass != 1)) {
1198descriptor_error:
1199 dev_err (&intf->dev, "bad descriptor, ignoring hub\n");
1200 return -EIO;
1201 }
1202
1203
1204 if (desc->desc.bNumEndpoints != 1)
1205 goto descriptor_error;
1206
1207 endpoint = &desc->endpoint[0].desc;
1208
1209
1210 if (!usb_endpoint_is_int_in(endpoint))
1211 goto descriptor_error;
1212
1213
1214 dev_info (&intf->dev, "USB hub found\n");
1215
1216 hub = kzalloc(sizeof(*hub), GFP_KERNEL);
1217 if (!hub) {
1218 dev_dbg (&intf->dev, "couldn't kmalloc hub struct\n");
1219 return -ENOMEM;
1220 }
1221
1222 kref_init(&hub->kref);
1223 INIT_LIST_HEAD(&hub->event_list);
1224 hub->intfdev = &intf->dev;
1225 hub->hdev = hdev;
1226 INIT_DELAYED_WORK(&hub->leds, led_work);
1227 INIT_DELAYED_WORK(&hub->init_work, NULL);
1228 usb_get_intf(intf);
1229
1230 usb_set_intfdata (intf, hub);
1231 intf->needs_remote_wakeup = 1;
1232
1233 if (hdev->speed == USB_SPEED_HIGH)
1234 highspeed_hubs++;
1235
1236 if (hub_configure(hub, endpoint) >= 0)
1237 return 0;
1238
1239 hub_disconnect (intf);
1240 return -ENODEV;
1241}
1242
1243static int
1244hub_ioctl(struct usb_interface *intf, unsigned int code, void *user_data)
1245{
1246 struct usb_device *hdev = interface_to_usbdev (intf);
1247
1248
1249 switch (code) {
1250 case USBDEVFS_HUB_PORTINFO: {
1251 struct usbdevfs_hub_portinfo *info = user_data;
1252 int i;
1253
1254 spin_lock_irq(&device_state_lock);
1255 if (hdev->devnum <= 0)
1256 info->nports = 0;
1257 else {
1258 info->nports = hdev->maxchild;
1259 for (i = 0; i < info->nports; i++) {
1260 if (hdev->children[i] == NULL)
1261 info->port[i] = 0;
1262 else
1263 info->port[i] =
1264 hdev->children[i]->devnum;
1265 }
1266 }
1267 spin_unlock_irq(&device_state_lock);
1268
1269 return info->nports + 1;
1270 }
1271
1272 default:
1273 return -ENOSYS;
1274 }
1275}
1276
1277
1278
1279
1280
1281static int find_port_owner(struct usb_device *hdev, unsigned port1,
1282 void ***ppowner)
1283{
1284 if (hdev->state == USB_STATE_NOTATTACHED)
1285 return -ENODEV;
1286 if (port1 == 0 || port1 > hdev->maxchild)
1287 return -EINVAL;
1288
1289
1290
1291
1292 *ppowner = &(hdev_to_hub(hdev)->port_owners[port1 - 1]);
1293 return 0;
1294}
1295
1296
1297int usb_hub_claim_port(struct usb_device *hdev, unsigned port1, void *owner)
1298{
1299 int rc;
1300 void **powner;
1301
1302 rc = find_port_owner(hdev, port1, &powner);
1303 if (rc)
1304 return rc;
1305 if (*powner)
1306 return -EBUSY;
1307 *powner = owner;
1308 return rc;
1309}
1310
1311int usb_hub_release_port(struct usb_device *hdev, unsigned port1, void *owner)
1312{
1313 int rc;
1314 void **powner;
1315
1316 rc = find_port_owner(hdev, port1, &powner);
1317 if (rc)
1318 return rc;
1319 if (*powner != owner)
1320 return -ENOENT;
1321 *powner = NULL;
1322 return rc;
1323}
1324
1325void usb_hub_release_all_ports(struct usb_device *hdev, void *owner)
1326{
1327 int n;
1328 void **powner;
1329
1330 n = find_port_owner(hdev, 1, &powner);
1331 if (n == 0) {
1332 for (; n < hdev->maxchild; (++n, ++powner)) {
1333 if (*powner == owner)
1334 *powner = NULL;
1335 }
1336 }
1337}
1338
1339
1340bool usb_device_is_owned(struct usb_device *udev)
1341{
1342 struct usb_hub *hub;
1343
1344 if (udev->state == USB_STATE_NOTATTACHED || !udev->parent)
1345 return false;
1346 hub = hdev_to_hub(udev->parent);
1347 return !!hub->port_owners[udev->portnum - 1];
1348}
1349
1350
1351static void recursively_mark_NOTATTACHED(struct usb_device *udev)
1352{
1353 int i;
1354
1355 for (i = 0; i < udev->maxchild; ++i) {
1356 if (udev->children[i])
1357 recursively_mark_NOTATTACHED(udev->children[i]);
1358 }
1359 if (udev->state == USB_STATE_SUSPENDED) {
1360 udev->discon_suspended = 1;
1361 udev->active_duration -= jiffies;
1362 }
1363 udev->state = USB_STATE_NOTATTACHED;
1364}
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387void usb_set_device_state(struct usb_device *udev,
1388 enum usb_device_state new_state)
1389{
1390 unsigned long flags;
1391
1392 spin_lock_irqsave(&device_state_lock, flags);
1393 if (udev->state == USB_STATE_NOTATTACHED)
1394 ;
1395 else if (new_state != USB_STATE_NOTATTACHED) {
1396
1397
1398
1399
1400 if (udev->parent) {
1401 if (udev->state == USB_STATE_SUSPENDED
1402 || new_state == USB_STATE_SUSPENDED)
1403 ;
1404 else if (new_state == USB_STATE_CONFIGURED)
1405 device_init_wakeup(&udev->dev,
1406 (udev->actconfig->desc.bmAttributes
1407 & USB_CONFIG_ATT_WAKEUP));
1408 else
1409 device_init_wakeup(&udev->dev, 0);
1410 }
1411 if (udev->state == USB_STATE_SUSPENDED &&
1412 new_state != USB_STATE_SUSPENDED)
1413 udev->active_duration -= jiffies;
1414 else if (new_state == USB_STATE_SUSPENDED &&
1415 udev->state != USB_STATE_SUSPENDED)
1416 udev->active_duration += jiffies;
1417 udev->state = new_state;
1418 } else
1419 recursively_mark_NOTATTACHED(udev);
1420 spin_unlock_irqrestore(&device_state_lock, flags);
1421}
1422EXPORT_SYMBOL_GPL(usb_set_device_state);
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446static void choose_address(struct usb_device *udev)
1447{
1448 int devnum;
1449 struct usb_bus *bus = udev->bus;
1450
1451
1452 if (udev->wusb) {
1453 devnum = udev->portnum + 1;
1454 BUG_ON(test_bit(devnum, bus->devmap.devicemap));
1455 } else {
1456
1457
1458 devnum = find_next_zero_bit(bus->devmap.devicemap, 128,
1459 bus->devnum_next);
1460 if (devnum >= 128)
1461 devnum = find_next_zero_bit(bus->devmap.devicemap,
1462 128, 1);
1463 bus->devnum_next = ( devnum >= 127 ? 1 : devnum + 1);
1464 }
1465 if (devnum < 128) {
1466 set_bit(devnum, bus->devmap.devicemap);
1467 udev->devnum = devnum;
1468 }
1469}
1470
1471static void release_address(struct usb_device *udev)
1472{
1473 if (udev->devnum > 0) {
1474 clear_bit(udev->devnum, udev->bus->devmap.devicemap);
1475 udev->devnum = -1;
1476 }
1477}
1478
1479static void update_address(struct usb_device *udev, int devnum)
1480{
1481
1482 if (!udev->wusb)
1483 udev->devnum = devnum;
1484}
1485
1486#ifdef CONFIG_USB_SUSPEND
1487
1488static void usb_stop_pm(struct usb_device *udev)
1489{
1490
1491
1492
1493
1494 usb_pm_lock(udev);
1495 if (udev->parent && !udev->discon_suspended)
1496 usb_autosuspend_device(udev->parent);
1497 usb_pm_unlock(udev);
1498
1499
1500 cancel_delayed_work_sync(&udev->autosuspend);
1501 cancel_work_sync(&udev->autoresume);
1502}
1503
1504#else
1505
1506static inline void usb_stop_pm(struct usb_device *udev)
1507{ }
1508
1509#endif
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527void usb_disconnect(struct usb_device **pdev)
1528{
1529 struct usb_device *udev = *pdev;
1530 int i;
1531
1532 if (!udev) {
1533 pr_debug ("%s nodev\n", __func__);
1534 return;
1535 }
1536
1537
1538
1539
1540
1541 usb_set_device_state(udev, USB_STATE_NOTATTACHED);
1542 dev_info (&udev->dev, "USB disconnect, address %d\n", udev->devnum);
1543
1544 usb_lock_device(udev);
1545
1546
1547 for (i = 0; i < USB_MAXCHILDREN; i++) {
1548 if (udev->children[i])
1549 usb_disconnect(&udev->children[i]);
1550 }
1551
1552
1553
1554
1555
1556 dev_dbg (&udev->dev, "unregistering device\n");
1557 usb_disable_device(udev, 0);
1558 usb_hcd_synchronize_unlinks(udev);
1559
1560 usb_remove_ep_devs(&udev->ep0);
1561 usb_unlock_device(udev);
1562
1563
1564
1565
1566
1567 device_del(&udev->dev);
1568
1569
1570
1571
1572 release_address(udev);
1573
1574
1575 spin_lock_irq(&device_state_lock);
1576 *pdev = NULL;
1577 spin_unlock_irq(&device_state_lock);
1578
1579 usb_stop_pm(udev);
1580
1581 put_device(&udev->dev);
1582}
1583
1584#ifdef CONFIG_USB_ANNOUNCE_NEW_DEVICES
1585static void show_string(struct usb_device *udev, char *id, char *string)
1586{
1587 if (!string)
1588 return;
1589 dev_printk(KERN_INFO, &udev->dev, "%s: %s\n", id, string);
1590}
1591
1592static void announce_device(struct usb_device *udev)
1593{
1594 dev_info(&udev->dev, "New USB device found, idVendor=%04x, idProduct=%04x\n",
1595 le16_to_cpu(udev->descriptor.idVendor),
1596 le16_to_cpu(udev->descriptor.idProduct));
1597 dev_info(&udev->dev,
1598 "New USB device strings: Mfr=%d, Product=%d, SerialNumber=%d\n",
1599 udev->descriptor.iManufacturer,
1600 udev->descriptor.iProduct,
1601 udev->descriptor.iSerialNumber);
1602 show_string(udev, "Product", udev->product);
1603 show_string(udev, "Manufacturer", udev->manufacturer);
1604 show_string(udev, "SerialNumber", udev->serial);
1605}
1606#else
1607static inline void announce_device(struct usb_device *udev) { }
1608#endif
1609
1610#ifdef CONFIG_USB_OTG
1611#include "otg_whitelist.h"
1612#endif
1613
1614
1615
1616
1617
1618
1619
1620static int usb_configure_device_otg(struct usb_device *udev)
1621{
1622 int err = 0;
1623
1624#ifdef CONFIG_USB_OTG
1625
1626
1627
1628
1629
1630 if (!udev->bus->is_b_host
1631 && udev->config
1632 && udev->parent == udev->bus->root_hub) {
1633 struct usb_otg_descriptor *desc = 0;
1634 struct usb_bus *bus = udev->bus;
1635
1636
1637 if (__usb_get_extra_descriptor (udev->rawdescriptors[0],
1638 le16_to_cpu(udev->config[0].desc.wTotalLength),
1639 USB_DT_OTG, (void **) &desc) == 0) {
1640 if (desc->bmAttributes & USB_OTG_HNP) {
1641 unsigned port1 = udev->portnum;
1642
1643 dev_info(&udev->dev,
1644 "Dual-Role OTG device on %sHNP port\n",
1645 (port1 == bus->otg_port)
1646 ? "" : "non-");
1647
1648
1649 if (port1 == bus->otg_port)
1650 bus->b_hnp_enable = 1;
1651 err = usb_control_msg(udev,
1652 usb_sndctrlpipe(udev, 0),
1653 USB_REQ_SET_FEATURE, 0,
1654 bus->b_hnp_enable
1655 ? USB_DEVICE_B_HNP_ENABLE
1656 : USB_DEVICE_A_ALT_HNP_SUPPORT,
1657 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
1658 if (err < 0) {
1659
1660
1661
1662 dev_info(&udev->dev,
1663 "can't set HNP mode: %d\n",
1664 err);
1665 bus->b_hnp_enable = 0;
1666 }
1667 }
1668 }
1669 }
1670
1671 if (!is_targeted(udev)) {
1672
1673
1674
1675
1676 if (udev->bus->b_hnp_enable || udev->bus->is_b_host) {
1677 err = usb_port_suspend(udev, PMSG_SUSPEND);
1678 if (err < 0)
1679 dev_dbg(&udev->dev, "HNP fail, %d\n", err);
1680 }
1681 err = -ENOTSUPP;
1682 goto fail;
1683 }
1684fail:
1685#endif
1686 return err;
1687}
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702static int usb_configure_device(struct usb_device *udev)
1703{
1704 int err;
1705
1706 if (udev->config == NULL) {
1707 err = usb_get_configuration(udev);
1708 if (err < 0) {
1709 dev_err(&udev->dev, "can't read configurations, error %d\n",
1710 err);
1711 goto fail;
1712 }
1713 }
1714 if (udev->wusb == 1 && udev->authorized == 0) {
1715 udev->product = kstrdup("n/a (unauthorized)", GFP_KERNEL);
1716 udev->manufacturer = kstrdup("n/a (unauthorized)", GFP_KERNEL);
1717 udev->serial = kstrdup("n/a (unauthorized)", GFP_KERNEL);
1718 }
1719 else {
1720
1721 udev->product = usb_cache_string(udev, udev->descriptor.iProduct);
1722 udev->manufacturer = usb_cache_string(udev,
1723 udev->descriptor.iManufacturer);
1724 udev->serial = usb_cache_string(udev, udev->descriptor.iSerialNumber);
1725 }
1726 err = usb_configure_device_otg(udev);
1727fail:
1728 return err;
1729}
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752int usb_new_device(struct usb_device *udev)
1753{
1754 int err;
1755
1756
1757 if (udev->parent)
1758 usb_autoresume_device(udev->parent);
1759
1760 usb_detect_quirks(udev);
1761 err = usb_configure_device(udev);
1762 if (err < 0)
1763 goto fail;
1764 dev_dbg(&udev->dev, "udev %d, busnum %d, minor = %d\n",
1765 udev->devnum, udev->bus->busnum,
1766 (((udev->bus->busnum-1) * 128) + (udev->devnum-1)));
1767
1768 udev->dev.devt = MKDEV(USB_DEVICE_MAJOR,
1769 (((udev->bus->busnum-1) * 128) + (udev->devnum-1)));
1770
1771
1772 announce_device(udev);
1773
1774
1775
1776
1777
1778 err = device_add(&udev->dev);
1779 if (err) {
1780 dev_err(&udev->dev, "can't device_add, error %d\n", err);
1781 goto fail;
1782 }
1783
1784 (void) usb_create_ep_devs(&udev->dev, &udev->ep0, udev);
1785 return err;
1786
1787fail:
1788 usb_set_device_state(udev, USB_STATE_NOTATTACHED);
1789 usb_stop_pm(udev);
1790 return err;
1791}
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804int usb_deauthorize_device(struct usb_device *usb_dev)
1805{
1806 unsigned cnt;
1807 usb_lock_device(usb_dev);
1808 if (usb_dev->authorized == 0)
1809 goto out_unauthorized;
1810 usb_dev->authorized = 0;
1811 usb_set_configuration(usb_dev, -1);
1812 usb_dev->product = kstrdup("n/a (unauthorized)", GFP_KERNEL);
1813 usb_dev->manufacturer = kstrdup("n/a (unauthorized)", GFP_KERNEL);
1814 usb_dev->serial = kstrdup("n/a (unauthorized)", GFP_KERNEL);
1815 kfree(usb_dev->config);
1816 usb_dev->config = NULL;
1817 for (cnt = 0; cnt < usb_dev->descriptor.bNumConfigurations; cnt++)
1818 kfree(usb_dev->rawdescriptors[cnt]);
1819 usb_dev->descriptor.bNumConfigurations = 0;
1820 kfree(usb_dev->rawdescriptors);
1821out_unauthorized:
1822 usb_unlock_device(usb_dev);
1823 return 0;
1824}
1825
1826
1827int usb_authorize_device(struct usb_device *usb_dev)
1828{
1829 int result = 0, c;
1830 usb_lock_device(usb_dev);
1831 if (usb_dev->authorized == 1)
1832 goto out_authorized;
1833 kfree(usb_dev->product);
1834 usb_dev->product = NULL;
1835 kfree(usb_dev->manufacturer);
1836 usb_dev->manufacturer = NULL;
1837 kfree(usb_dev->serial);
1838 usb_dev->serial = NULL;
1839 result = usb_autoresume_device(usb_dev);
1840 if (result < 0) {
1841 dev_err(&usb_dev->dev,
1842 "can't autoresume for authorization: %d\n", result);
1843 goto error_autoresume;
1844 }
1845 result = usb_get_device_descriptor(usb_dev, sizeof(usb_dev->descriptor));
1846 if (result < 0) {
1847 dev_err(&usb_dev->dev, "can't re-read device descriptor for "
1848 "authorization: %d\n", result);
1849 goto error_device_descriptor;
1850 }
1851 usb_dev->authorized = 1;
1852 result = usb_configure_device(usb_dev);
1853 if (result < 0)
1854 goto error_configure;
1855
1856
1857
1858 c = usb_choose_configuration(usb_dev);
1859 if (c >= 0) {
1860 result = usb_set_configuration(usb_dev, c);
1861 if (result) {
1862 dev_err(&usb_dev->dev,
1863 "can't set config #%d, error %d\n", c, result);
1864
1865
1866 }
1867 }
1868 dev_info(&usb_dev->dev, "authorized to connect\n");
1869error_configure:
1870error_device_descriptor:
1871error_autoresume:
1872out_authorized:
1873 usb_unlock_device(usb_dev);
1874 return result;
1875}
1876
1877
1878
1879static unsigned hub_is_wusb(struct usb_hub *hub)
1880{
1881 struct usb_hcd *hcd;
1882 if (hub->hdev->parent != NULL)
1883 return 0;
1884 hcd = container_of(hub->hdev->bus, struct usb_hcd, self);
1885 return hcd->wireless;
1886}
1887
1888
1889#define PORT_RESET_TRIES 5
1890#define SET_ADDRESS_TRIES 2
1891#define GET_DESCRIPTOR_TRIES 2
1892#define SET_CONFIG_TRIES (2 * (use_both_schemes + 1))
1893#define USE_NEW_SCHEME(i) ((i) / 2 == old_scheme_first)
1894
1895#define HUB_ROOT_RESET_TIME 50
1896#define HUB_SHORT_RESET_TIME 10
1897#define HUB_LONG_RESET_TIME 200
1898#define HUB_RESET_TIMEOUT 500
1899
1900static int hub_port_wait_reset(struct usb_hub *hub, int port1,
1901 struct usb_device *udev, unsigned int delay)
1902{
1903 int delay_time, ret;
1904 u16 portstatus;
1905 u16 portchange;
1906
1907 for (delay_time = 0;
1908 delay_time < HUB_RESET_TIMEOUT;
1909 delay_time += delay) {
1910
1911 msleep(delay);
1912
1913
1914 ret = hub_port_status(hub, port1, &portstatus, &portchange);
1915 if (ret < 0)
1916 return ret;
1917
1918
1919 if (!(portstatus & USB_PORT_STAT_CONNECTION))
1920 return -ENOTCONN;
1921
1922
1923 if ((portchange & USB_PORT_STAT_C_CONNECTION))
1924 return -ENOTCONN;
1925
1926
1927 if (!(portstatus & USB_PORT_STAT_RESET) &&
1928 (portstatus & USB_PORT_STAT_ENABLE)) {
1929 if (hub_is_wusb(hub))
1930 udev->speed = USB_SPEED_VARIABLE;
1931 else if (portstatus & USB_PORT_STAT_HIGH_SPEED)
1932 udev->speed = USB_SPEED_HIGH;
1933 else if (portstatus & USB_PORT_STAT_LOW_SPEED)
1934 udev->speed = USB_SPEED_LOW;
1935 else
1936 udev->speed = USB_SPEED_FULL;
1937 return 0;
1938 }
1939
1940
1941 if (delay_time >= 2 * HUB_SHORT_RESET_TIME)
1942 delay = HUB_LONG_RESET_TIME;
1943
1944 dev_dbg (hub->intfdev,
1945 "port %d not reset yet, waiting %dms\n",
1946 port1, delay);
1947 }
1948
1949 return -EBUSY;
1950}
1951
1952static int hub_port_reset(struct usb_hub *hub, int port1,
1953 struct usb_device *udev, unsigned int delay)
1954{
1955 int i, status;
1956
1957
1958
1959
1960 down_read(&ehci_cf_port_reset_rwsem);
1961
1962
1963 for (i = 0; i < PORT_RESET_TRIES; i++) {
1964 status = set_port_feature(hub->hdev,
1965 port1, USB_PORT_FEAT_RESET);
1966 if (status)
1967 dev_err(hub->intfdev,
1968 "cannot reset port %d (err = %d)\n",
1969 port1, status);
1970 else {
1971 status = hub_port_wait_reset(hub, port1, udev, delay);
1972 if (status && status != -ENOTCONN)
1973 dev_dbg(hub->intfdev,
1974 "port_wait_reset: err = %d\n",
1975 status);
1976 }
1977
1978
1979 switch (status) {
1980 case 0:
1981
1982 msleep(10 + 40);
1983 update_address(udev, 0);
1984
1985 case -ENOTCONN:
1986 case -ENODEV:
1987 clear_port_feature(hub->hdev,
1988 port1, USB_PORT_FEAT_C_RESET);
1989
1990 usb_set_device_state(udev, status
1991 ? USB_STATE_NOTATTACHED
1992 : USB_STATE_DEFAULT);
1993 goto done;
1994 }
1995
1996 dev_dbg (hub->intfdev,
1997 "port %d not enabled, trying reset again...\n",
1998 port1);
1999 delay = HUB_LONG_RESET_TIME;
2000 }
2001
2002 dev_err (hub->intfdev,
2003 "Cannot enable port %i. Maybe the USB cable is bad?\n",
2004 port1);
2005
2006 done:
2007 up_read(&ehci_cf_port_reset_rwsem);
2008 return status;
2009}
2010
2011#ifdef CONFIG_PM
2012
2013#define MASK_BITS (USB_PORT_STAT_POWER | USB_PORT_STAT_CONNECTION | \
2014 USB_PORT_STAT_SUSPEND)
2015#define WANT_BITS (USB_PORT_STAT_POWER | USB_PORT_STAT_CONNECTION)
2016
2017
2018
2019
2020static int check_port_resume_type(struct usb_device *udev,
2021 struct usb_hub *hub, int port1,
2022 int status, unsigned portchange, unsigned portstatus)
2023{
2024
2025 if (status || (portstatus & MASK_BITS) != WANT_BITS) {
2026 if (status >= 0)
2027 status = -ENODEV;
2028 }
2029
2030
2031
2032
2033 else if (!(portstatus & USB_PORT_STAT_ENABLE) && !udev->reset_resume) {
2034 if (udev->persist_enabled)
2035 udev->reset_resume = 1;
2036 else
2037 status = -ENODEV;
2038 }
2039
2040 if (status) {
2041 dev_dbg(hub->intfdev,
2042 "port %d status %04x.%04x after resume, %d\n",
2043 port1, portchange, portstatus, status);
2044 } else if (udev->reset_resume) {
2045
2046
2047 if (portchange & USB_PORT_STAT_C_CONNECTION)
2048 clear_port_feature(hub->hdev, port1,
2049 USB_PORT_FEAT_C_CONNECTION);
2050 if (portchange & USB_PORT_STAT_C_ENABLE)
2051 clear_port_feature(hub->hdev, port1,
2052 USB_PORT_FEAT_C_ENABLE);
2053 }
2054
2055 return status;
2056}
2057
2058#ifdef CONFIG_USB_SUSPEND
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
2107{
2108 struct usb_hub *hub = hdev_to_hub(udev->parent);
2109 int port1 = udev->portnum;
2110 int status;
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120 if (udev->do_remote_wakeup) {
2121 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
2122 USB_REQ_SET_FEATURE, USB_RECIP_DEVICE,
2123 USB_DEVICE_REMOTE_WAKEUP, 0,
2124 NULL, 0,
2125 USB_CTRL_SET_TIMEOUT);
2126 if (status)
2127 dev_dbg(&udev->dev, "won't remote wakeup, status %d\n",
2128 status);
2129 }
2130
2131
2132 status = set_port_feature(hub->hdev, port1, USB_PORT_FEAT_SUSPEND);
2133 if (status) {
2134 dev_dbg(hub->intfdev, "can't suspend port %d, status %d\n",
2135 port1, status);
2136
2137 (void) usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
2138 USB_REQ_CLEAR_FEATURE, USB_RECIP_DEVICE,
2139 USB_DEVICE_REMOTE_WAKEUP, 0,
2140 NULL, 0,
2141 USB_CTRL_SET_TIMEOUT);
2142 } else {
2143
2144 dev_dbg(&udev->dev, "usb %ssuspend\n",
2145 (msg.event & PM_EVENT_AUTO ? "auto-" : ""));
2146 usb_set_device_state(udev, USB_STATE_SUSPENDED);
2147 msleep(10);
2148 }
2149 return status;
2150}
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163static int finish_port_resume(struct usb_device *udev)
2164{
2165 int status = 0;
2166 u16 devstatus;
2167
2168
2169 dev_dbg(&udev->dev, "%s\n",
2170 udev->reset_resume ? "finish reset-resume" : "finish resume");
2171
2172
2173
2174
2175
2176
2177 usb_set_device_state(udev, udev->actconfig
2178 ? USB_STATE_CONFIGURED
2179 : USB_STATE_ADDRESS);
2180
2181
2182
2183
2184
2185
2186 if (udev->reset_resume)
2187 retry_reset_resume:
2188 status = usb_reset_and_verify_device(udev);
2189
2190
2191
2192
2193
2194 if (status == 0) {
2195 devstatus = 0;
2196 status = usb_get_status(udev, USB_RECIP_DEVICE, 0, &devstatus);
2197 if (status >= 0)
2198 status = (status > 0 ? 0 : -ENODEV);
2199
2200
2201 if (status && !udev->reset_resume && udev->persist_enabled) {
2202 dev_dbg(&udev->dev, "retry with reset-resume\n");
2203 udev->reset_resume = 1;
2204 goto retry_reset_resume;
2205 }
2206 }
2207
2208 if (status) {
2209 dev_dbg(&udev->dev, "gone after usb resume? status %d\n",
2210 status);
2211 } else if (udev->actconfig) {
2212 le16_to_cpus(&devstatus);
2213 if (devstatus & (1 << USB_DEVICE_REMOTE_WAKEUP)) {
2214 status = usb_control_msg(udev,
2215 usb_sndctrlpipe(udev, 0),
2216 USB_REQ_CLEAR_FEATURE,
2217 USB_RECIP_DEVICE,
2218 USB_DEVICE_REMOTE_WAKEUP, 0,
2219 NULL, 0,
2220 USB_CTRL_SET_TIMEOUT);
2221 if (status)
2222 dev_dbg(&udev->dev,
2223 "disable remote wakeup, status %d\n",
2224 status);
2225 }
2226 status = 0;
2227 }
2228 return status;
2229}
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265int usb_port_resume(struct usb_device *udev, pm_message_t msg)
2266{
2267 struct usb_hub *hub = hdev_to_hub(udev->parent);
2268 int port1 = udev->portnum;
2269 int status;
2270 u16 portchange, portstatus;
2271
2272
2273 status = hub_port_status(hub, port1, &portstatus, &portchange);
2274 if (status == 0 && !(portstatus & USB_PORT_STAT_SUSPEND))
2275 goto SuspendCleared;
2276
2277
2278
2279 set_bit(port1, hub->busy_bits);
2280
2281
2282 status = clear_port_feature(hub->hdev,
2283 port1, USB_PORT_FEAT_SUSPEND);
2284 if (status) {
2285 dev_dbg(hub->intfdev, "can't resume port %d, status %d\n",
2286 port1, status);
2287 } else {
2288
2289 dev_dbg(&udev->dev, "usb %sresume\n",
2290 (msg.event & PM_EVENT_AUTO ? "auto-" : ""));
2291 msleep(25);
2292
2293
2294
2295
2296
2297 status = hub_port_status(hub, port1, &portstatus, &portchange);
2298
2299
2300 msleep(10);
2301 }
2302
2303 SuspendCleared:
2304 if (status == 0) {
2305 if (portchange & USB_PORT_STAT_C_SUSPEND)
2306 clear_port_feature(hub->hdev, port1,
2307 USB_PORT_FEAT_C_SUSPEND);
2308 }
2309
2310 clear_bit(port1, hub->busy_bits);
2311
2312 status = check_port_resume_type(udev,
2313 hub, port1, status, portchange, portstatus);
2314 if (status == 0)
2315 status = finish_port_resume(udev);
2316 if (status < 0) {
2317 dev_dbg(&udev->dev, "can't resume, status %d\n", status);
2318 hub_port_logical_disconnect(hub, port1);
2319 }
2320 return status;
2321}
2322
2323
2324static int remote_wakeup(struct usb_device *udev)
2325{
2326 int status = 0;
2327
2328 if (udev->state == USB_STATE_SUSPENDED) {
2329 dev_dbg(&udev->dev, "usb %sresume\n", "wakeup-");
2330 usb_mark_last_busy(udev);
2331 status = usb_external_resume_device(udev, PMSG_REMOTE_RESUME);
2332 }
2333 return status;
2334}
2335
2336#else
2337
2338
2339
2340int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
2341{
2342 return 0;
2343}
2344
2345
2346
2347int usb_port_resume(struct usb_device *udev, pm_message_t msg)
2348{
2349 struct usb_hub *hub = hdev_to_hub(udev->parent);
2350 int port1 = udev->portnum;
2351 int status;
2352 u16 portchange, portstatus;
2353
2354 status = hub_port_status(hub, port1, &portstatus, &portchange);
2355 status = check_port_resume_type(udev,
2356 hub, port1, status, portchange, portstatus);
2357
2358 if (status) {
2359 dev_dbg(&udev->dev, "can't resume, status %d\n", status);
2360 hub_port_logical_disconnect(hub, port1);
2361 } else if (udev->reset_resume) {
2362 dev_dbg(&udev->dev, "reset-resume\n");
2363 status = usb_reset_and_verify_device(udev);
2364 }
2365 return status;
2366}
2367
2368static inline int remote_wakeup(struct usb_device *udev)
2369{
2370 return 0;
2371}
2372
2373#endif
2374
2375static int hub_suspend(struct usb_interface *intf, pm_message_t msg)
2376{
2377 struct usb_hub *hub = usb_get_intfdata (intf);
2378 struct usb_device *hdev = hub->hdev;
2379 unsigned port1;
2380
2381
2382 for (port1 = 1; port1 <= hdev->maxchild; port1++) {
2383 struct usb_device *udev;
2384
2385 udev = hdev->children [port1-1];
2386 if (udev && udev->can_submit) {
2387 if (!(msg.event & PM_EVENT_AUTO))
2388 dev_dbg(&intf->dev, "port %d nyet suspended\n",
2389 port1);
2390 return -EBUSY;
2391 }
2392 }
2393
2394 dev_dbg(&intf->dev, "%s\n", __func__);
2395
2396
2397 hub_quiesce(hub, HUB_SUSPEND);
2398 return 0;
2399}
2400
2401static int hub_resume(struct usb_interface *intf)
2402{
2403 struct usb_hub *hub = usb_get_intfdata(intf);
2404
2405 dev_dbg(&intf->dev, "%s\n", __func__);
2406 hub_activate(hub, HUB_RESUME);
2407 return 0;
2408}
2409
2410static int hub_reset_resume(struct usb_interface *intf)
2411{
2412 struct usb_hub *hub = usb_get_intfdata(intf);
2413
2414 dev_dbg(&intf->dev, "%s\n", __func__);
2415 hub_activate(hub, HUB_RESET_RESUME);
2416 return 0;
2417}
2418
2419
2420
2421
2422
2423
2424
2425
2426
2427
2428
2429
2430void usb_root_hub_lost_power(struct usb_device *rhdev)
2431{
2432 dev_warn(&rhdev->dev, "root hub lost power or was reset\n");
2433 rhdev->reset_resume = 1;
2434}
2435EXPORT_SYMBOL_GPL(usb_root_hub_lost_power);
2436
2437#else
2438
2439static inline int remote_wakeup(struct usb_device *udev)
2440{
2441 return 0;
2442}
2443
2444#define hub_suspend NULL
2445#define hub_resume NULL
2446#define hub_reset_resume NULL
2447#endif
2448
2449
2450
2451
2452
2453
2454
2455
2456
2457
2458
2459
2460
2461
2462
2463
2464
2465static int hub_port_debounce(struct usb_hub *hub, int port1)
2466{
2467 int ret;
2468 int total_time, stable_time = 0;
2469 u16 portchange, portstatus;
2470 unsigned connection = 0xffff;
2471
2472 for (total_time = 0; ; total_time += HUB_DEBOUNCE_STEP) {
2473 ret = hub_port_status(hub, port1, &portstatus, &portchange);
2474 if (ret < 0)
2475 return ret;
2476
2477 if (!(portchange & USB_PORT_STAT_C_CONNECTION) &&
2478 (portstatus & USB_PORT_STAT_CONNECTION) == connection) {
2479 stable_time += HUB_DEBOUNCE_STEP;
2480 if (stable_time >= HUB_DEBOUNCE_STABLE)
2481 break;
2482 } else {
2483 stable_time = 0;
2484 connection = portstatus & USB_PORT_STAT_CONNECTION;
2485 }
2486
2487 if (portchange & USB_PORT_STAT_C_CONNECTION) {
2488 clear_port_feature(hub->hdev, port1,
2489 USB_PORT_FEAT_C_CONNECTION);
2490 }
2491
2492 if (total_time >= HUB_DEBOUNCE_TIMEOUT)
2493 break;
2494 msleep(HUB_DEBOUNCE_STEP);
2495 }
2496
2497 dev_dbg (hub->intfdev,
2498 "debounce: port %d: total %dms stable %dms status 0x%x\n",
2499 port1, total_time, stable_time, portstatus);
2500
2501 if (stable_time < HUB_DEBOUNCE_STABLE)
2502 return -ETIMEDOUT;
2503 return portstatus;
2504}
2505
2506void usb_ep0_reinit(struct usb_device *udev)
2507{
2508 usb_disable_endpoint(udev, 0 + USB_DIR_IN, true);
2509 usb_disable_endpoint(udev, 0 + USB_DIR_OUT, true);
2510 usb_enable_endpoint(udev, &udev->ep0, true);
2511}
2512EXPORT_SYMBOL_GPL(usb_ep0_reinit);
2513
2514#define usb_sndaddr0pipe() (PIPE_CONTROL << 30)
2515#define usb_rcvaddr0pipe() ((PIPE_CONTROL << 30) | USB_DIR_IN)
2516
2517static int hub_set_address(struct usb_device *udev, int devnum)
2518{
2519 int retval;
2520 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
2521
2522
2523
2524
2525
2526 if (!hcd->driver->address_device && devnum <= 1)
2527 return -EINVAL;
2528 if (udev->state == USB_STATE_ADDRESS)
2529 return 0;
2530 if (udev->state != USB_STATE_DEFAULT)
2531 return -EINVAL;
2532 if (hcd->driver->address_device) {
2533 retval = hcd->driver->address_device(hcd, udev);
2534 } else {
2535 retval = usb_control_msg(udev, usb_sndaddr0pipe(),
2536 USB_REQ_SET_ADDRESS, 0, devnum, 0,
2537 NULL, 0, USB_CTRL_SET_TIMEOUT);
2538 if (retval == 0)
2539 update_address(udev, devnum);
2540 }
2541 if (retval == 0) {
2542
2543 usb_set_device_state(udev, USB_STATE_ADDRESS);
2544 usb_ep0_reinit(udev);
2545 }
2546 return retval;
2547}
2548
2549
2550
2551
2552
2553
2554
2555
2556
2557
2558static int
2559hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
2560 int retry_counter)
2561{
2562 static DEFINE_MUTEX(usb_address0_mutex);
2563
2564 struct usb_device *hdev = hub->hdev;
2565 struct usb_hcd *hcd = bus_to_hcd(hdev->bus);
2566 int i, j, retval;
2567 unsigned delay = HUB_SHORT_RESET_TIME;
2568 enum usb_device_speed oldspeed = udev->speed;
2569 char *speed, *type;
2570 int devnum = udev->devnum;
2571
2572
2573
2574
2575 if (!hdev->parent) {
2576 delay = HUB_ROOT_RESET_TIME;
2577 if (port1 == hdev->bus->otg_port)
2578 hdev->bus->b_hnp_enable = 0;
2579 }
2580
2581
2582
2583 if (oldspeed == USB_SPEED_LOW)
2584 delay = HUB_LONG_RESET_TIME;
2585
2586 mutex_lock(&usb_address0_mutex);
2587
2588 if ((hcd->driver->flags & HCD_USB3) && udev->config) {
2589
2590 dev_dbg(&udev->dev,
2591 "xHCI reset of configured device "
2592 "not supported yet.\n");
2593 retval = -EINVAL;
2594 goto fail;
2595 } else if (!udev->config && oldspeed == USB_SPEED_SUPER) {
2596
2597 usb_set_device_state(udev, USB_STATE_DEFAULT);
2598 } else {
2599
2600
2601 retval = hub_port_reset(hub, port1, udev, delay);
2602 if (retval < 0)
2603 goto fail;
2604
2605 }
2606 retval = -ENODEV;
2607
2608 if (oldspeed != USB_SPEED_UNKNOWN && oldspeed != udev->speed) {
2609 dev_dbg(&udev->dev, "device reset changed speed!\n");
2610 goto fail;
2611 }
2612 oldspeed = udev->speed;
2613
2614
2615
2616
2617
2618
2619 switch (udev->speed) {
2620 case USB_SPEED_SUPER:
2621 case USB_SPEED_VARIABLE:
2622 udev->ep0.desc.wMaxPacketSize = cpu_to_le16(512);
2623 break;
2624 case USB_SPEED_HIGH:
2625 udev->ep0.desc.wMaxPacketSize = cpu_to_le16(64);
2626 break;
2627 case USB_SPEED_FULL:
2628
2629
2630
2631
2632 udev->ep0.desc.wMaxPacketSize = cpu_to_le16(64);
2633 break;
2634 case USB_SPEED_LOW:
2635 udev->ep0.desc.wMaxPacketSize = cpu_to_le16(8);
2636 break;
2637 default:
2638 goto fail;
2639 }
2640
2641 type = "";
2642 switch (udev->speed) {
2643 case USB_SPEED_LOW: speed = "low"; break;
2644 case USB_SPEED_FULL: speed = "full"; break;
2645 case USB_SPEED_HIGH: speed = "high"; break;
2646 case USB_SPEED_SUPER:
2647 speed = "super";
2648 break;
2649 case USB_SPEED_VARIABLE:
2650 speed = "variable";
2651 type = "Wireless ";
2652 break;
2653 default: speed = "?"; break;
2654 }
2655 if (udev->speed != USB_SPEED_SUPER)
2656 dev_info(&udev->dev,
2657 "%s %s speed %sUSB device using %s and address %d\n",
2658 (udev->config) ? "reset" : "new", speed, type,
2659 udev->bus->controller->driver->name, devnum);
2660
2661
2662 if (hdev->tt) {
2663 udev->tt = hdev->tt;
2664 udev->ttport = hdev->ttport;
2665 } else if (udev->speed != USB_SPEED_HIGH
2666 && hdev->speed == USB_SPEED_HIGH) {
2667 udev->tt = &hub->tt;
2668 udev->ttport = port1;
2669 }
2670
2671
2672
2673
2674
2675
2676
2677
2678
2679
2680
2681
2682
2683 for (i = 0; i < GET_DESCRIPTOR_TRIES; (++i, msleep(100))) {
2684
2685
2686
2687
2688 if (USE_NEW_SCHEME(retry_counter) && !(hcd->driver->flags & HCD_USB3)) {
2689 struct usb_device_descriptor *buf;
2690 int r = 0;
2691
2692#define GET_DESCRIPTOR_BUFSIZE 64
2693 buf = kmalloc(GET_DESCRIPTOR_BUFSIZE, GFP_NOIO);
2694 if (!buf) {
2695 retval = -ENOMEM;
2696 continue;
2697 }
2698
2699
2700
2701
2702
2703 for (j = 0; j < 3; ++j) {
2704 buf->bMaxPacketSize0 = 0;
2705 r = usb_control_msg(udev, usb_rcvaddr0pipe(),
2706 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
2707 USB_DT_DEVICE << 8, 0,
2708 buf, GET_DESCRIPTOR_BUFSIZE,
2709 initial_descriptor_timeout);
2710 switch (buf->bMaxPacketSize0) {
2711 case 8: case 16: case 32: case 64: case 255:
2712 if (buf->bDescriptorType ==
2713 USB_DT_DEVICE) {
2714 r = 0;
2715 break;
2716 }
2717
2718 default:
2719 if (r == 0)
2720 r = -EPROTO;
2721 break;
2722 }
2723 if (r == 0)
2724 break;
2725 }
2726 udev->descriptor.bMaxPacketSize0 =
2727 buf->bMaxPacketSize0;
2728 kfree(buf);
2729
2730 retval = hub_port_reset(hub, port1, udev, delay);
2731 if (retval < 0)
2732 goto fail;
2733 if (oldspeed != udev->speed) {
2734 dev_dbg(&udev->dev,
2735 "device reset changed speed!\n");
2736 retval = -ENODEV;
2737 goto fail;
2738 }
2739 if (r) {
2740 dev_err(&udev->dev,
2741 "device descriptor read/64, error %d\n",
2742 r);
2743 retval = -EMSGSIZE;
2744 continue;
2745 }
2746#undef GET_DESCRIPTOR_BUFSIZE
2747 }
2748
2749
2750
2751
2752
2753
2754 if (udev->wusb == 0) {
2755 for (j = 0; j < SET_ADDRESS_TRIES; ++j) {
2756 retval = hub_set_address(udev, devnum);
2757 if (retval >= 0)
2758 break;
2759 msleep(200);
2760 }
2761 if (retval < 0) {
2762 dev_err(&udev->dev,
2763 "device not accepting address %d, error %d\n",
2764 devnum, retval);
2765 goto fail;
2766 }
2767 if (udev->speed == USB_SPEED_SUPER) {
2768 devnum = udev->devnum;
2769 dev_info(&udev->dev,
2770 "%s SuperSpeed USB device using %s and address %d\n",
2771 (udev->config) ? "reset" : "new",
2772 udev->bus->controller->driver->name, devnum);
2773 }
2774
2775
2776
2777
2778
2779 msleep(10);
2780 if (USE_NEW_SCHEME(retry_counter) && !(hcd->driver->flags & HCD_USB3))
2781 break;
2782 }
2783
2784 retval = usb_get_device_descriptor(udev, 8);
2785 if (retval < 8) {
2786 dev_err(&udev->dev,
2787 "device descriptor read/8, error %d\n",
2788 retval);
2789 if (retval >= 0)
2790 retval = -EMSGSIZE;
2791 } else {
2792 retval = 0;
2793 break;
2794 }
2795 }
2796 if (retval)
2797 goto fail;
2798
2799 if (udev->descriptor.bMaxPacketSize0 == 0xff ||
2800 udev->speed == USB_SPEED_SUPER)
2801 i = 512;
2802 else
2803 i = udev->descriptor.bMaxPacketSize0;
2804 if (le16_to_cpu(udev->ep0.desc.wMaxPacketSize) != i) {
2805 if (udev->speed != USB_SPEED_FULL ||
2806 !(i == 8 || i == 16 || i == 32 || i == 64)) {
2807 dev_err(&udev->dev, "ep0 maxpacket = %d\n", i);
2808 retval = -EMSGSIZE;
2809 goto fail;
2810 }
2811 dev_dbg(&udev->dev, "ep0 maxpacket = %d\n", i);
2812 udev->ep0.desc.wMaxPacketSize = cpu_to_le16(i);
2813 usb_ep0_reinit(udev);
2814 }
2815
2816 retval = usb_get_device_descriptor(udev, USB_DT_DEVICE_SIZE);
2817 if (retval < (signed)sizeof(udev->descriptor)) {
2818 dev_err(&udev->dev, "device descriptor read/all, error %d\n",
2819 retval);
2820 if (retval >= 0)
2821 retval = -ENOMSG;
2822 goto fail;
2823 }
2824
2825 retval = 0;
2826
2827fail:
2828 if (retval) {
2829 hub_port_disable(hub, port1, 0);
2830 update_address(udev, devnum);
2831 }
2832 mutex_unlock(&usb_address0_mutex);
2833 return retval;
2834}
2835
2836static void
2837check_highspeed (struct usb_hub *hub, struct usb_device *udev, int port1)
2838{
2839 struct usb_qualifier_descriptor *qual;
2840 int status;
2841
2842 qual = kmalloc (sizeof *qual, GFP_KERNEL);
2843 if (qual == NULL)
2844 return;
2845
2846 status = usb_get_descriptor (udev, USB_DT_DEVICE_QUALIFIER, 0,
2847 qual, sizeof *qual);
2848 if (status == sizeof *qual) {
2849 dev_info(&udev->dev, "not running at top speed; "
2850 "connect to a high speed hub\n");
2851
2852 if (hub->has_indicators) {
2853 hub->indicator[port1-1] = INDICATOR_GREEN_BLINK;
2854 schedule_delayed_work (&hub->leds, 0);
2855 }
2856 }
2857 kfree(qual);
2858}
2859
2860static unsigned
2861hub_power_remaining (struct usb_hub *hub)
2862{
2863 struct usb_device *hdev = hub->hdev;
2864 int remaining;
2865 int port1;
2866
2867 if (!hub->limited_power)
2868 return 0;
2869
2870 remaining = hdev->bus_mA - hub->descriptor->bHubContrCurrent;
2871 for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
2872 struct usb_device *udev = hdev->children[port1 - 1];
2873 int delta;
2874
2875 if (!udev)
2876 continue;
2877
2878
2879
2880 if (udev->actconfig)
2881 delta = udev->actconfig->desc.bMaxPower * 2;
2882 else if (port1 != udev->bus->otg_port || hdev->parent)
2883 delta = 100;
2884 else
2885 delta = 8;
2886 if (delta > hub->mA_per_port)
2887 dev_warn(&udev->dev,
2888 "%dmA is over %umA budget for port %d!\n",
2889 delta, hub->mA_per_port, port1);
2890 remaining -= delta;
2891 }
2892 if (remaining < 0) {
2893 dev_warn(hub->intfdev, "%dmA over power budget!\n",
2894 - remaining);
2895 remaining = 0;
2896 }
2897 return remaining;
2898}
2899
2900
2901
2902
2903
2904
2905
2906
2907
2908static void hub_port_connect_change(struct usb_hub *hub, int port1,
2909 u16 portstatus, u16 portchange)
2910{
2911 struct usb_device *hdev = hub->hdev;
2912 struct device *hub_dev = hub->intfdev;
2913 struct usb_hcd *hcd = bus_to_hcd(hdev->bus);
2914 unsigned wHubCharacteristics =
2915 le16_to_cpu(hub->descriptor->wHubCharacteristics);
2916 struct usb_device *udev;
2917 int status, i;
2918
2919 dev_dbg (hub_dev,
2920 "port %d, status %04x, change %04x, %s\n",
2921 port1, portstatus, portchange, portspeed (portstatus));
2922
2923 if (hub->has_indicators) {
2924 set_port_led(hub, port1, HUB_LED_AUTO);
2925 hub->indicator[port1-1] = INDICATOR_AUTO;
2926 }
2927
2928#ifdef CONFIG_USB_OTG
2929
2930 if (hdev->bus->is_b_host)
2931 portchange &= ~(USB_PORT_STAT_C_CONNECTION |
2932 USB_PORT_STAT_C_ENABLE);
2933#endif
2934
2935
2936 udev = hdev->children[port1-1];
2937 if ((portstatus & USB_PORT_STAT_CONNECTION) && udev &&
2938 udev->state != USB_STATE_NOTATTACHED) {
2939 usb_lock_device(udev);
2940 if (portstatus & USB_PORT_STAT_ENABLE) {
2941 status = 0;
2942
2943#ifdef CONFIG_USB_SUSPEND
2944 } else if (udev->state == USB_STATE_SUSPENDED &&
2945 udev->persist_enabled) {
2946
2947
2948
2949 status = remote_wakeup(udev);
2950#endif
2951
2952 } else {
2953 status = -ENODEV;
2954 }
2955 usb_unlock_device(udev);
2956
2957 if (status == 0) {
2958 clear_bit(port1, hub->change_bits);
2959 return;
2960 }
2961 }
2962
2963
2964 if (udev)
2965 usb_disconnect(&hdev->children[port1-1]);
2966 clear_bit(port1, hub->change_bits);
2967
2968 if (portchange & (USB_PORT_STAT_C_CONNECTION |
2969 USB_PORT_STAT_C_ENABLE)) {
2970 status = hub_port_debounce(hub, port1);
2971 if (status < 0) {
2972 if (printk_ratelimit())
2973 dev_err(hub_dev, "connect-debounce failed, "
2974 "port %d disabled\n", port1);
2975 portstatus &= ~USB_PORT_STAT_CONNECTION;
2976 } else {
2977 portstatus = status;
2978 }
2979 }
2980
2981
2982 if (!(portstatus & USB_PORT_STAT_CONNECTION)) {
2983
2984
2985 if ((wHubCharacteristics & HUB_CHAR_LPSM) < 2
2986 && !(portstatus & (1 << USB_PORT_FEAT_POWER)))
2987 set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
2988
2989 if (portstatus & USB_PORT_STAT_ENABLE)
2990 goto done;
2991 return;
2992 }
2993
2994 for (i = 0; i < SET_CONFIG_TRIES; i++) {
2995
2996
2997
2998
2999 udev = usb_alloc_dev(hdev, hdev->bus, port1);
3000 if (!udev) {
3001 dev_err (hub_dev,
3002 "couldn't allocate port %d usb_device\n",
3003 port1);
3004 goto done;
3005 }
3006
3007 usb_set_device_state(udev, USB_STATE_POWERED);
3008 udev->bus_mA = hub->mA_per_port;
3009 udev->level = hdev->level + 1;
3010 udev->wusb = hub_is_wusb(hub);
3011
3012
3013
3014
3015
3016
3017
3018
3019
3020
3021 if (!(hcd->driver->flags & HCD_USB3))
3022 udev->speed = USB_SPEED_UNKNOWN;
3023 else if ((hdev->parent == NULL) &&
3024 (portstatus & (1 << USB_PORT_FEAT_SUPERSPEED)))
3025 udev->speed = USB_SPEED_SUPER;
3026 else
3027 udev->speed = USB_SPEED_UNKNOWN;
3028
3029
3030
3031
3032
3033 if (!(hcd->driver->flags & HCD_USB3)) {
3034
3035 choose_address(udev);
3036 if (udev->devnum <= 0) {
3037 status = -ENOTCONN;
3038 goto loop;
3039 }
3040 }
3041
3042
3043 status = hub_port_init(hub, udev, port1, i);
3044 if (status < 0)
3045 goto loop;
3046
3047
3048
3049
3050
3051
3052
3053 if (udev->descriptor.bDeviceClass == USB_CLASS_HUB
3054 && udev->bus_mA <= 100) {
3055 u16 devstat;
3056
3057 status = usb_get_status(udev, USB_RECIP_DEVICE, 0,
3058 &devstat);
3059 if (status < 2) {
3060 dev_dbg(&udev->dev, "get status %d ?\n", status);
3061 goto loop_disable;
3062 }
3063 le16_to_cpus(&devstat);
3064 if ((devstat & (1 << USB_DEVICE_SELF_POWERED)) == 0) {
3065 dev_err(&udev->dev,
3066 "can't connect bus-powered hub "
3067 "to this port\n");
3068 if (hub->has_indicators) {
3069 hub->indicator[port1-1] =
3070 INDICATOR_AMBER_BLINK;
3071 schedule_delayed_work (&hub->leds, 0);
3072 }
3073 status = -ENOTCONN;
3074 goto loop_disable;
3075 }
3076 }
3077
3078
3079 if (le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0200
3080 && udev->speed == USB_SPEED_FULL
3081 && highspeed_hubs != 0)
3082 check_highspeed (hub, udev, port1);
3083
3084
3085
3086
3087
3088 status = 0;
3089
3090
3091
3092
3093
3094 spin_lock_irq(&device_state_lock);
3095 if (hdev->state == USB_STATE_NOTATTACHED)
3096 status = -ENOTCONN;
3097 else
3098 hdev->children[port1-1] = udev;
3099 spin_unlock_irq(&device_state_lock);
3100
3101
3102 if (!status) {
3103 status = usb_new_device(udev);
3104 if (status) {
3105 spin_lock_irq(&device_state_lock);
3106 hdev->children[port1-1] = NULL;
3107 spin_unlock_irq(&device_state_lock);
3108 }
3109 }
3110
3111 if (status)
3112 goto loop_disable;
3113
3114 status = hub_power_remaining(hub);
3115 if (status)
3116 dev_dbg(hub_dev, "%dmA power budget left\n", status);
3117
3118 return;
3119
3120loop_disable:
3121 hub_port_disable(hub, port1, 1);
3122loop:
3123 usb_ep0_reinit(udev);
3124 release_address(udev);
3125 usb_put_dev(udev);
3126 if ((status == -ENOTCONN) || (status == -ENOTSUPP))
3127 break;
3128 }
3129 if (hub->hdev->parent ||
3130 !hcd->driver->port_handed_over ||
3131 !(hcd->driver->port_handed_over)(hcd, port1))
3132 dev_err(hub_dev, "unable to enumerate USB device on port %d\n",
3133 port1);
3134
3135done:
3136 hub_port_disable(hub, port1, 1);
3137 if (hcd->driver->relinquish_port && !hub->hdev->parent)
3138 hcd->driver->relinquish_port(hcd, port1);
3139}
3140
3141static void hub_events(void)
3142{
3143 struct list_head *tmp;
3144 struct usb_device *hdev;
3145 struct usb_interface *intf;
3146 struct usb_hub *hub;
3147 struct device *hub_dev;
3148 u16 hubstatus;
3149 u16 hubchange;
3150 u16 portstatus;
3151 u16 portchange;
3152 int i, ret;
3153 int connect_change;
3154
3155
3156
3157
3158
3159
3160
3161 while (1) {
3162
3163
3164 spin_lock_irq(&hub_event_lock);
3165 if (list_empty(&hub_event_list)) {
3166 spin_unlock_irq(&hub_event_lock);
3167 break;
3168 }
3169
3170 tmp = hub_event_list.next;
3171 list_del_init(tmp);
3172
3173 hub = list_entry(tmp, struct usb_hub, event_list);
3174 kref_get(&hub->kref);
3175 spin_unlock_irq(&hub_event_lock);
3176
3177 hdev = hub->hdev;
3178 hub_dev = hub->intfdev;
3179 intf = to_usb_interface(hub_dev);
3180 dev_dbg(hub_dev, "state %d ports %d chg %04x evt %04x\n",
3181 hdev->state, hub->descriptor
3182 ? hub->descriptor->bNbrPorts
3183 : 0,
3184
3185 (u16) hub->change_bits[0],
3186 (u16) hub->event_bits[0]);
3187
3188
3189
3190 usb_lock_device(hdev);
3191 if (unlikely(hub->disconnected))
3192 goto loop;
3193
3194
3195 if (hdev->state == USB_STATE_NOTATTACHED) {
3196 hub->error = -ENODEV;
3197 hub_quiesce(hub, HUB_DISCONNECT);
3198 goto loop;
3199 }
3200
3201
3202 ret = usb_autopm_get_interface(intf);
3203 if (ret) {
3204 dev_dbg(hub_dev, "Can't autoresume: %d\n", ret);
3205 goto loop;
3206 }
3207
3208
3209 if (hub->quiescing)
3210 goto loop_autopm;
3211
3212 if (hub->error) {
3213 dev_dbg (hub_dev, "resetting for error %d\n",
3214 hub->error);
3215
3216 ret = usb_reset_device(hdev);
3217 if (ret) {
3218 dev_dbg (hub_dev,
3219 "error resetting hub: %d\n", ret);
3220 goto loop_autopm;
3221 }
3222
3223 hub->nerrors = 0;
3224 hub->error = 0;
3225 }
3226
3227
3228 for (i = 1; i <= hub->descriptor->bNbrPorts; i++) {
3229 if (test_bit(i, hub->busy_bits))
3230 continue;
3231 connect_change = test_bit(i, hub->change_bits);
3232 if (!test_and_clear_bit(i, hub->event_bits) &&
3233 !connect_change)
3234 continue;
3235
3236 ret = hub_port_status(hub, i,
3237 &portstatus, &portchange);
3238 if (ret < 0)
3239 continue;
3240
3241 if (portchange & USB_PORT_STAT_C_CONNECTION) {
3242 clear_port_feature(hdev, i,
3243 USB_PORT_FEAT_C_CONNECTION);
3244 connect_change = 1;
3245 }
3246
3247 if (portchange & USB_PORT_STAT_C_ENABLE) {
3248 if (!connect_change)
3249 dev_dbg (hub_dev,
3250 "port %d enable change, "
3251 "status %08x\n",
3252 i, portstatus);
3253 clear_port_feature(hdev, i,
3254 USB_PORT_FEAT_C_ENABLE);
3255
3256
3257
3258
3259
3260
3261
3262 if (!(portstatus & USB_PORT_STAT_ENABLE)
3263 && !connect_change
3264 && hdev->children[i-1]) {
3265 dev_err (hub_dev,
3266 "port %i "
3267 "disabled by hub (EMI?), "
3268 "re-enabling...\n",
3269 i);
3270 connect_change = 1;
3271 }
3272 }
3273
3274 if (portchange & USB_PORT_STAT_C_SUSPEND) {
3275 struct usb_device *udev;
3276
3277 clear_port_feature(hdev, i,
3278 USB_PORT_FEAT_C_SUSPEND);
3279 udev = hdev->children[i-1];
3280 if (udev) {
3281 usb_lock_device(udev);
3282 ret = remote_wakeup(hdev->
3283 children[i-1]);
3284 usb_unlock_device(udev);
3285 if (ret < 0)
3286 connect_change = 1;
3287 } else {
3288 ret = -ENODEV;
3289 hub_port_disable(hub, i, 1);
3290 }
3291 dev_dbg (hub_dev,
3292 "resume on port %d, status %d\n",
3293 i, ret);
3294 }
3295
3296 if (portchange & USB_PORT_STAT_C_OVERCURRENT) {
3297 dev_err (hub_dev,
3298 "over-current change on port %d\n",
3299 i);
3300 clear_port_feature(hdev, i,
3301 USB_PORT_FEAT_C_OVER_CURRENT);
3302 hub_power_on(hub, true);
3303 }
3304
3305 if (portchange & USB_PORT_STAT_C_RESET) {
3306 dev_dbg (hub_dev,
3307 "reset change on port %d\n",
3308 i);
3309 clear_port_feature(hdev, i,
3310 USB_PORT_FEAT_C_RESET);
3311 }
3312
3313 if (connect_change)
3314 hub_port_connect_change(hub, i,
3315 portstatus, portchange);
3316 }
3317
3318
3319 if (test_and_clear_bit(0, hub->event_bits) == 0)
3320 ;
3321 else if (hub_hub_status(hub, &hubstatus, &hubchange) < 0)
3322 dev_err (hub_dev, "get_hub_status failed\n");
3323 else {
3324 if (hubchange & HUB_CHANGE_LOCAL_POWER) {
3325 dev_dbg (hub_dev, "power change\n");
3326 clear_hub_feature(hdev, C_HUB_LOCAL_POWER);
3327 if (hubstatus & HUB_STATUS_LOCAL_POWER)
3328
3329 hub->limited_power = 1;
3330 else
3331 hub->limited_power = 0;
3332 }
3333 if (hubchange & HUB_CHANGE_OVERCURRENT) {
3334 dev_dbg (hub_dev, "overcurrent change\n");
3335 msleep(500);
3336 clear_hub_feature(hdev, C_HUB_OVER_CURRENT);
3337 hub_power_on(hub, true);
3338 }
3339 }
3340
3341loop_autopm:
3342
3343 if (list_empty(&hub->event_list))
3344 usb_autopm_enable(intf);
3345loop:
3346 usb_unlock_device(hdev);
3347 kref_put(&hub->kref, hub_release);
3348
3349 }
3350}
3351
3352static int hub_thread(void *__unused)
3353{
3354
3355
3356
3357
3358
3359 set_freezable();
3360
3361 do {
3362 hub_events();
3363 wait_event_freezable(khubd_wait,
3364 !list_empty(&hub_event_list) ||
3365 kthread_should_stop());
3366 } while (!kthread_should_stop() || !list_empty(&hub_event_list));
3367
3368 pr_debug("%s: khubd exiting\n", usbcore_name);
3369 return 0;
3370}
3371
3372static struct usb_device_id hub_id_table [] = {
3373 { .match_flags = USB_DEVICE_ID_MATCH_DEV_CLASS,
3374 .bDeviceClass = USB_CLASS_HUB},
3375 { .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS,
3376 .bInterfaceClass = USB_CLASS_HUB},
3377 { }
3378};
3379
3380MODULE_DEVICE_TABLE (usb, hub_id_table);
3381
3382static struct usb_driver hub_driver = {
3383 .name = "hub",
3384 .probe = hub_probe,
3385 .disconnect = hub_disconnect,
3386 .suspend = hub_suspend,
3387 .resume = hub_resume,
3388 .reset_resume = hub_reset_resume,
3389 .pre_reset = hub_pre_reset,
3390 .post_reset = hub_post_reset,
3391 .ioctl = hub_ioctl,
3392 .id_table = hub_id_table,
3393 .supports_autosuspend = 1,
3394};
3395
3396int usb_hub_init(void)
3397{
3398 if (usb_register(&hub_driver) < 0) {
3399 printk(KERN_ERR "%s: can't register hub driver\n",
3400 usbcore_name);
3401 return -1;
3402 }
3403
3404 khubd_task = kthread_run(hub_thread, NULL, "khubd");
3405 if (!IS_ERR(khubd_task))
3406 return 0;
3407
3408
3409 usb_deregister(&hub_driver);
3410 printk(KERN_ERR "%s: can't start khubd\n", usbcore_name);
3411
3412 return -1;
3413}
3414
3415void usb_hub_cleanup(void)
3416{
3417 kthread_stop(khubd_task);
3418
3419
3420
3421
3422
3423
3424
3425
3426 usb_deregister(&hub_driver);
3427}
3428
3429static int descriptors_changed(struct usb_device *udev,
3430 struct usb_device_descriptor *old_device_descriptor)
3431{
3432 int changed = 0;
3433 unsigned index;
3434 unsigned serial_len = 0;
3435 unsigned len;
3436 unsigned old_length;
3437 int length;
3438 char *buf;
3439
3440 if (memcmp(&udev->descriptor, old_device_descriptor,
3441 sizeof(*old_device_descriptor)) != 0)
3442 return 1;
3443
3444
3445
3446
3447
3448
3449
3450 if (udev->serial)
3451 serial_len = strlen(udev->serial) + 1;
3452
3453 len = serial_len;
3454 for (index = 0; index < udev->descriptor.bNumConfigurations; index++) {
3455 old_length = le16_to_cpu(udev->config[index].desc.wTotalLength);
3456 len = max(len, old_length);
3457 }
3458
3459 buf = kmalloc(len, GFP_NOIO);
3460 if (buf == NULL) {
3461 dev_err(&udev->dev, "no mem to re-read configs after reset\n");
3462
3463 return 1;
3464 }
3465 for (index = 0; index < udev->descriptor.bNumConfigurations; index++) {
3466 old_length = le16_to_cpu(udev->config[index].desc.wTotalLength);
3467 length = usb_get_descriptor(udev, USB_DT_CONFIG, index, buf,
3468 old_length);
3469 if (length != old_length) {
3470 dev_dbg(&udev->dev, "config index %d, error %d\n",
3471 index, length);
3472 changed = 1;
3473 break;
3474 }
3475 if (memcmp (buf, udev->rawdescriptors[index], old_length)
3476 != 0) {
3477 dev_dbg(&udev->dev, "config index %d changed (#%d)\n",
3478 index,
3479 ((struct usb_config_descriptor *) buf)->
3480 bConfigurationValue);
3481 changed = 1;
3482 break;
3483 }
3484 }
3485
3486 if (!changed && serial_len) {
3487 length = usb_string(udev, udev->descriptor.iSerialNumber,
3488 buf, serial_len);
3489 if (length + 1 != serial_len) {
3490 dev_dbg(&udev->dev, "serial string error %d\n",
3491 length);
3492 changed = 1;
3493 } else if (memcmp(buf, udev->serial, length) != 0) {
3494 dev_dbg(&udev->dev, "serial string changed\n");
3495 changed = 1;
3496 }
3497 }
3498
3499 kfree(buf);
3500 return changed;
3501}
3502
3503
3504
3505
3506
3507
3508
3509
3510
3511
3512
3513
3514
3515
3516
3517
3518
3519
3520
3521
3522
3523
3524
3525
3526
3527
3528
3529
3530
3531
3532
3533static int usb_reset_and_verify_device(struct usb_device *udev)
3534{
3535 struct usb_device *parent_hdev = udev->parent;
3536 struct usb_hub *parent_hub;
3537 struct usb_device_descriptor descriptor = udev->descriptor;
3538 int i, ret = 0;
3539 int port1 = udev->portnum;
3540
3541 if (udev->state == USB_STATE_NOTATTACHED ||
3542 udev->state == USB_STATE_SUSPENDED) {
3543 dev_dbg(&udev->dev, "device reset not allowed in state %d\n",
3544 udev->state);
3545 return -EINVAL;
3546 }
3547
3548 if (!parent_hdev) {
3549
3550 dev_dbg(&udev->dev, "%s for root hub!\n", __func__);
3551 return -EISDIR;
3552 }
3553 parent_hub = hdev_to_hub(parent_hdev);
3554
3555 set_bit(port1, parent_hub->busy_bits);
3556 for (i = 0; i < SET_CONFIG_TRIES; ++i) {
3557
3558
3559
3560 usb_ep0_reinit(udev);
3561 ret = hub_port_init(parent_hub, udev, port1, i);
3562 if (ret >= 0 || ret == -ENOTCONN || ret == -ENODEV)
3563 break;
3564 }
3565 clear_bit(port1, parent_hub->busy_bits);
3566
3567 if (ret < 0)
3568 goto re_enumerate;
3569
3570
3571 if (descriptors_changed(udev, &descriptor)) {
3572 dev_info(&udev->dev, "device firmware changed\n");
3573 udev->descriptor = descriptor;
3574 goto re_enumerate;
3575 }
3576
3577
3578 if (!udev->actconfig)
3579 goto done;
3580 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3581 USB_REQ_SET_CONFIGURATION, 0,
3582 udev->actconfig->desc.bConfigurationValue, 0,
3583 NULL, 0, USB_CTRL_SET_TIMEOUT);
3584 if (ret < 0) {
3585 dev_err(&udev->dev,
3586 "can't restore configuration #%d (error=%d)\n",
3587 udev->actconfig->desc.bConfigurationValue, ret);
3588 goto re_enumerate;
3589 }
3590 usb_set_device_state(udev, USB_STATE_CONFIGURED);
3591
3592
3593
3594
3595
3596
3597
3598 for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
3599 struct usb_interface *intf = udev->actconfig->interface[i];
3600 struct usb_interface_descriptor *desc;
3601
3602 desc = &intf->cur_altsetting->desc;
3603 if (desc->bAlternateSetting == 0) {
3604 usb_disable_interface(udev, intf, true);
3605 usb_enable_interface(udev, intf, true);
3606 ret = 0;
3607 } else {
3608 ret = usb_set_interface(udev, desc->bInterfaceNumber,
3609 desc->bAlternateSetting);
3610 }
3611 if (ret < 0) {
3612 dev_err(&udev->dev, "failed to restore interface %d "
3613 "altsetting %d (error=%d)\n",
3614 desc->bInterfaceNumber,
3615 desc->bAlternateSetting,
3616 ret);
3617 goto re_enumerate;
3618 }
3619 }
3620
3621done:
3622 return 0;
3623
3624re_enumerate:
3625 hub_port_logical_disconnect(parent_hub, port1);
3626 return -ENODEV;
3627}
3628
3629
3630
3631
3632
3633
3634
3635
3636
3637
3638
3639
3640
3641
3642
3643
3644
3645
3646
3647
3648
3649int usb_reset_device(struct usb_device *udev)
3650{
3651 int ret;
3652 int i;
3653 struct usb_host_config *config = udev->actconfig;
3654
3655 if (udev->state == USB_STATE_NOTATTACHED ||
3656 udev->state == USB_STATE_SUSPENDED) {
3657 dev_dbg(&udev->dev, "device reset not allowed in state %d\n",
3658 udev->state);
3659 return -EINVAL;
3660 }
3661
3662
3663 usb_autoresume_device(udev);
3664
3665 if (config) {
3666 for (i = 0; i < config->desc.bNumInterfaces; ++i) {
3667 struct usb_interface *cintf = config->interface[i];
3668 struct usb_driver *drv;
3669 int unbind = 0;
3670
3671 if (cintf->dev.driver) {
3672 drv = to_usb_driver(cintf->dev.driver);
3673 if (drv->pre_reset && drv->post_reset)
3674 unbind = (drv->pre_reset)(cintf);
3675 else if (cintf->condition ==
3676 USB_INTERFACE_BOUND)
3677 unbind = 1;
3678 if (unbind)
3679 usb_forced_unbind_intf(cintf);
3680 }
3681 }
3682 }
3683
3684 ret = usb_reset_and_verify_device(udev);
3685
3686 if (config) {
3687 for (i = config->desc.bNumInterfaces - 1; i >= 0; --i) {
3688 struct usb_interface *cintf = config->interface[i];
3689 struct usb_driver *drv;
3690 int rebind = cintf->needs_binding;
3691
3692 if (!rebind && cintf->dev.driver) {
3693 drv = to_usb_driver(cintf->dev.driver);
3694 if (drv->post_reset)
3695 rebind = (drv->post_reset)(cintf);
3696 else if (cintf->condition ==
3697 USB_INTERFACE_BOUND)
3698 rebind = 1;
3699 }
3700 if (ret == 0 && rebind)
3701 usb_rebind_intf(cintf);
3702 }
3703 }
3704
3705 usb_autosuspend_device(udev);
3706 return ret;
3707}
3708EXPORT_SYMBOL_GPL(usb_reset_device);
3709
3710
3711
3712
3713
3714
3715
3716
3717
3718
3719
3720
3721
3722
3723
3724
3725
3726
3727
3728
3729
3730
3731
3732
3733
3734
3735
3736
3737
3738
3739
3740
3741
3742
3743
3744
3745
3746
3747void usb_queue_reset_device(struct usb_interface *iface)
3748{
3749 schedule_work(&iface->reset_ws);
3750}
3751EXPORT_SYMBOL_GPL(usb_queue_reset_device);
3752