aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/usb/core
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@woody.linux-foundation.org>2007-10-12 18:49:10 -0400
committerLinus Torvalds <torvalds@woody.linux-foundation.org>2007-10-12 18:49:10 -0400
commit117494a1b65183f0e3fcc817b07944bc5c465050 (patch)
treec375cf06bdf869f2b870fe61808b060c4fadab45 /drivers/usb/core
parent4d5709a7b7d54fc5882d2943a14988a92d48c00a (diff)
parentd1aa3e6aa8edfeb864af7c930523d9e588b28bea (diff)
Merge master.kernel.org:/pub/scm/linux/kernel/git/gregkh/usb-2.6
* master.kernel.org:/pub/scm/linux/kernel/git/gregkh/usb-2.6: (142 commits) USB: fix race in autosuspend reschedule atmel_usba_udc: Keep track of the device status USB: Nikon D40X unusual_devs entry USB: serial core should respect driver requirements USB: documentation for USB power management USB: skip autosuspended devices during system resume USB: mutual exclusion for EHCI init and port resets USB: allow usbstorage to have LUNS greater than 2Tb USB: Adding support for SHARP WS011SH to ipaq.c USB: add atmel_usba_udc driver USB: ohci SSB bus glue USB: ehci build fixes on au1xxx, ppc-soc USB: add runtime frame_no quirk for big-endian OHCI USB: funsoft: Fix termios USB: visor: termios bits USB: unusual_devs entry for Nikon DSC D2Xs USB: re-remove <linux/usb_sl811.h> USB: move <linux/usb_gadget.h> to <linux/usb/gadget.h> USB: Export URB statistics for powertop USB: serial gadget: Disable endpoints on unload ...
Diffstat (limited to 'drivers/usb/core')
-rw-r--r--drivers/usb/core/config.c24
-rw-r--r--drivers/usb/core/devio.c77
-rw-r--r--drivers/usb/core/driver.c90
-rw-r--r--drivers/usb/core/endpoint.c1
-rw-r--r--drivers/usb/core/generic.c26
-rw-r--r--drivers/usb/core/hcd.c718
-rw-r--r--drivers/usb/core/hcd.h46
-rw-r--r--drivers/usb/core/hub.c276
-rw-r--r--drivers/usb/core/message.c50
-rw-r--r--drivers/usb/core/quirks.c81
-rw-r--r--drivers/usb/core/sysfs.c50
-rw-r--r--drivers/usb/core/urb.c106
-rw-r--r--drivers/usb/core/usb.c41
-rw-r--r--drivers/usb/core/usb.h5
14 files changed, 973 insertions, 618 deletions
diff --git a/drivers/usb/core/config.c b/drivers/usb/core/config.c
index cb69aa1e02e..1a8edcee7f3 100644
--- a/drivers/usb/core/config.c
+++ b/drivers/usb/core/config.c
@@ -507,18 +507,30 @@ void usb_destroy_configuration(struct usb_device *dev)
507} 507}
508 508
509 509
510// hub-only!! ... and only in reset path, or usb_new_device() 510/*
511// (used by real hubs and virtual root hubs) 511 * Get the USB config descriptors, cache and parse'em
512 *
513 * hub-only!! ... and only in reset path, or usb_new_device()
514 * (used by real hubs and virtual root hubs)
515 *
516 * NOTE: if this is a WUSB device and is not authorized, we skip the
517 * whole thing. A non-authorized USB device has no
518 * configurations.
519 */
512int usb_get_configuration(struct usb_device *dev) 520int usb_get_configuration(struct usb_device *dev)
513{ 521{
514 struct device *ddev = &dev->dev; 522 struct device *ddev = &dev->dev;
515 int ncfg = dev->descriptor.bNumConfigurations; 523 int ncfg = dev->descriptor.bNumConfigurations;
516 int result = -ENOMEM; 524 int result = 0;
517 unsigned int cfgno, length; 525 unsigned int cfgno, length;
518 unsigned char *buffer; 526 unsigned char *buffer;
519 unsigned char *bigbuffer; 527 unsigned char *bigbuffer;
520 struct usb_config_descriptor *desc; 528 struct usb_config_descriptor *desc;
521 529
530 cfgno = 0;
531 if (dev->authorized == 0) /* Not really an error */
532 goto out_not_authorized;
533 result = -ENOMEM;
522 if (ncfg > USB_MAXCONFIG) { 534 if (ncfg > USB_MAXCONFIG) {
523 dev_warn(ddev, "too many configurations: %d, " 535 dev_warn(ddev, "too many configurations: %d, "
524 "using maximum allowed: %d\n", ncfg, USB_MAXCONFIG); 536 "using maximum allowed: %d\n", ncfg, USB_MAXCONFIG);
@@ -545,14 +557,15 @@ int usb_get_configuration(struct usb_device *dev)
545 goto err2; 557 goto err2;
546 desc = (struct usb_config_descriptor *)buffer; 558 desc = (struct usb_config_descriptor *)buffer;
547 559
548 for (cfgno = 0; cfgno < ncfg; cfgno++) { 560 result = 0;
561 for (; cfgno < ncfg; cfgno++) {
549 /* We grab just the first descriptor so we know how long 562 /* We grab just the first descriptor so we know how long
550 * the whole configuration is */ 563 * the whole configuration is */
551 result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, 564 result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno,
552 buffer, USB_DT_CONFIG_SIZE); 565 buffer, USB_DT_CONFIG_SIZE);
553 if (result < 0) { 566 if (result < 0) {
554 dev_err(ddev, "unable to read config index %d " 567 dev_err(ddev, "unable to read config index %d "
555 "descriptor/%s\n", cfgno, "start"); 568 "descriptor/%s: %d\n", cfgno, "start", result);
556 dev_err(ddev, "chopping to %d config(s)\n", cfgno); 569 dev_err(ddev, "chopping to %d config(s)\n", cfgno);
557 dev->descriptor.bNumConfigurations = cfgno; 570 dev->descriptor.bNumConfigurations = cfgno;
558 break; 571 break;
@@ -599,6 +612,7 @@ int usb_get_configuration(struct usb_device *dev)
599 612
600err: 613err:
601 kfree(buffer); 614 kfree(buffer);
615out_not_authorized:
602 dev->descriptor.bNumConfigurations = cfgno; 616 dev->descriptor.bNumConfigurations = cfgno;
603err2: 617err2:
604 if (result == -ENOMEM) 618 if (result == -ENOMEM)
diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c
index 927a181120a..e5ad76b4a73 100644
--- a/drivers/usb/core/devio.c
+++ b/drivers/usb/core/devio.c
@@ -71,6 +71,7 @@ struct async {
71 void __user *userbuffer; 71 void __user *userbuffer;
72 void __user *userurb; 72 void __user *userurb;
73 struct urb *urb; 73 struct urb *urb;
74 int status;
74 u32 secid; 75 u32 secid;
75}; 76};
76 77
@@ -289,10 +290,8 @@ static void snoop_urb(struct urb *urb, void __user *userurb)
289 if (!usbfs_snoop) 290 if (!usbfs_snoop)
290 return; 291 return;
291 292
292 if (urb->pipe & USB_DIR_IN) 293 dev_info(&urb->dev->dev, "direction=%s\n",
293 dev_info(&urb->dev->dev, "direction=IN\n"); 294 usb_urb_dir_in(urb) ? "IN" : "OUT");
294 else
295 dev_info(&urb->dev->dev, "direction=OUT\n");
296 dev_info(&urb->dev->dev, "userurb=%p\n", userurb); 295 dev_info(&urb->dev->dev, "userurb=%p\n", userurb);
297 dev_info(&urb->dev->dev, "transfer_buffer_length=%d\n", 296 dev_info(&urb->dev->dev, "transfer_buffer_length=%d\n",
298 urb->transfer_buffer_length); 297 urb->transfer_buffer_length);
@@ -312,9 +311,10 @@ static void async_completed(struct urb *urb)
312 spin_lock(&ps->lock); 311 spin_lock(&ps->lock);
313 list_move_tail(&as->asynclist, &ps->async_completed); 312 list_move_tail(&as->asynclist, &ps->async_completed);
314 spin_unlock(&ps->lock); 313 spin_unlock(&ps->lock);
314 as->status = urb->status;
315 if (as->signr) { 315 if (as->signr) {
316 sinfo.si_signo = as->signr; 316 sinfo.si_signo = as->signr;
317 sinfo.si_errno = as->urb->status; 317 sinfo.si_errno = as->status;
318 sinfo.si_code = SI_ASYNCIO; 318 sinfo.si_code = SI_ASYNCIO;
319 sinfo.si_addr = as->userurb; 319 sinfo.si_addr = as->userurb;
320 kill_pid_info_as_uid(as->signr, &sinfo, as->pid, as->uid, 320 kill_pid_info_as_uid(as->signr, &sinfo, as->pid, as->uid,
@@ -910,6 +910,7 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
910 struct usb_ctrlrequest *dr = NULL; 910 struct usb_ctrlrequest *dr = NULL;
911 unsigned int u, totlen, isofrmlen; 911 unsigned int u, totlen, isofrmlen;
912 int ret, ifnum = -1; 912 int ret, ifnum = -1;
913 int is_in;
913 914
914 if (uurb->flags & ~(USBDEVFS_URB_ISO_ASAP|USBDEVFS_URB_SHORT_NOT_OK| 915 if (uurb->flags & ~(USBDEVFS_URB_ISO_ASAP|USBDEVFS_URB_SHORT_NOT_OK|
915 URB_NO_FSBR|URB_ZERO_PACKET)) 916 URB_NO_FSBR|URB_ZERO_PACKET))
@@ -924,16 +925,18 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
924 if ((ret = checkintf(ps, ifnum))) 925 if ((ret = checkintf(ps, ifnum)))
925 return ret; 926 return ret;
926 } 927 }
927 if ((uurb->endpoint & USB_ENDPOINT_DIR_MASK) != 0) 928 if ((uurb->endpoint & USB_ENDPOINT_DIR_MASK) != 0) {
928 ep = ps->dev->ep_in [uurb->endpoint & USB_ENDPOINT_NUMBER_MASK]; 929 is_in = 1;
929 else 930 ep = ps->dev->ep_in[uurb->endpoint & USB_ENDPOINT_NUMBER_MASK];
930 ep = ps->dev->ep_out [uurb->endpoint & USB_ENDPOINT_NUMBER_MASK]; 931 } else {
932 is_in = 0;
933 ep = ps->dev->ep_out[uurb->endpoint & USB_ENDPOINT_NUMBER_MASK];
934 }
931 if (!ep) 935 if (!ep)
932 return -ENOENT; 936 return -ENOENT;
933 switch(uurb->type) { 937 switch(uurb->type) {
934 case USBDEVFS_URB_TYPE_CONTROL: 938 case USBDEVFS_URB_TYPE_CONTROL:
935 if ((ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) 939 if (!usb_endpoint_xfer_control(&ep->desc))
936 != USB_ENDPOINT_XFER_CONTROL)
937 return -EINVAL; 940 return -EINVAL;
938 /* min 8 byte setup packet, max 8 byte setup plus an arbitrary data stage */ 941 /* min 8 byte setup packet, max 8 byte setup plus an arbitrary data stage */
939 if (uurb->buffer_length < 8 || uurb->buffer_length > (8 + MAX_USBFS_BUFFER_SIZE)) 942 if (uurb->buffer_length < 8 || uurb->buffer_length > (8 + MAX_USBFS_BUFFER_SIZE))
@@ -952,23 +955,32 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
952 kfree(dr); 955 kfree(dr);
953 return ret; 956 return ret;
954 } 957 }
955 uurb->endpoint = (uurb->endpoint & ~USB_ENDPOINT_DIR_MASK) | (dr->bRequestType & USB_ENDPOINT_DIR_MASK);
956 uurb->number_of_packets = 0; 958 uurb->number_of_packets = 0;
957 uurb->buffer_length = le16_to_cpup(&dr->wLength); 959 uurb->buffer_length = le16_to_cpup(&dr->wLength);
958 uurb->buffer += 8; 960 uurb->buffer += 8;
959 if (!access_ok((uurb->endpoint & USB_DIR_IN) ? VERIFY_WRITE : VERIFY_READ, uurb->buffer, uurb->buffer_length)) { 961 if ((dr->bRequestType & USB_DIR_IN) && uurb->buffer_length) {
962 is_in = 1;
963 uurb->endpoint |= USB_DIR_IN;
964 } else {
965 is_in = 0;
966 uurb->endpoint &= ~USB_DIR_IN;
967 }
968 if (!access_ok(is_in ? VERIFY_WRITE : VERIFY_READ,
969 uurb->buffer, uurb->buffer_length)) {
960 kfree(dr); 970 kfree(dr);
961 return -EFAULT; 971 return -EFAULT;
962 } 972 }
963 snoop(&ps->dev->dev, "control urb: bRequest=%02x " 973 snoop(&ps->dev->dev, "control urb: bRequest=%02x "
964 "bRrequestType=%02x wValue=%04x " 974 "bRrequestType=%02x wValue=%04x "
965 "wIndex=%04x wLength=%04x\n", 975 "wIndex=%04x wLength=%04x\n",
966 dr->bRequest, dr->bRequestType, dr->wValue, 976 dr->bRequest, dr->bRequestType,
967 dr->wIndex, dr->wLength); 977 __le16_to_cpup(&dr->wValue),
978 __le16_to_cpup(&dr->wIndex),
979 __le16_to_cpup(&dr->wLength));
968 break; 980 break;
969 981
970 case USBDEVFS_URB_TYPE_BULK: 982 case USBDEVFS_URB_TYPE_BULK:
971 switch (ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) { 983 switch (usb_endpoint_type(&ep->desc)) {
972 case USB_ENDPOINT_XFER_CONTROL: 984 case USB_ENDPOINT_XFER_CONTROL:
973 case USB_ENDPOINT_XFER_ISOC: 985 case USB_ENDPOINT_XFER_ISOC:
974 return -EINVAL; 986 return -EINVAL;
@@ -977,7 +989,8 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
977 uurb->number_of_packets = 0; 989 uurb->number_of_packets = 0;
978 if (uurb->buffer_length > MAX_USBFS_BUFFER_SIZE) 990 if (uurb->buffer_length > MAX_USBFS_BUFFER_SIZE)
979 return -EINVAL; 991 return -EINVAL;
980 if (!access_ok((uurb->endpoint & USB_DIR_IN) ? VERIFY_WRITE : VERIFY_READ, uurb->buffer, uurb->buffer_length)) 992 if (!access_ok(is_in ? VERIFY_WRITE : VERIFY_READ,
993 uurb->buffer, uurb->buffer_length))
981 return -EFAULT; 994 return -EFAULT;
982 snoop(&ps->dev->dev, "bulk urb\n"); 995 snoop(&ps->dev->dev, "bulk urb\n");
983 break; 996 break;
@@ -986,8 +999,7 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
986 /* arbitrary limit */ 999 /* arbitrary limit */
987 if (uurb->number_of_packets < 1 || uurb->number_of_packets > 128) 1000 if (uurb->number_of_packets < 1 || uurb->number_of_packets > 128)
988 return -EINVAL; 1001 return -EINVAL;
989 if ((ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) 1002 if (!usb_endpoint_xfer_isoc(&ep->desc))
990 != USB_ENDPOINT_XFER_ISOC)
991 return -EINVAL; 1003 return -EINVAL;
992 isofrmlen = sizeof(struct usbdevfs_iso_packet_desc) * uurb->number_of_packets; 1004 isofrmlen = sizeof(struct usbdevfs_iso_packet_desc) * uurb->number_of_packets;
993 if (!(isopkt = kmalloc(isofrmlen, GFP_KERNEL))) 1005 if (!(isopkt = kmalloc(isofrmlen, GFP_KERNEL)))
@@ -1014,12 +1026,12 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
1014 1026
1015 case USBDEVFS_URB_TYPE_INTERRUPT: 1027 case USBDEVFS_URB_TYPE_INTERRUPT:
1016 uurb->number_of_packets = 0; 1028 uurb->number_of_packets = 0;
1017 if ((ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) 1029 if (!usb_endpoint_xfer_int(&ep->desc))
1018 != USB_ENDPOINT_XFER_INT)
1019 return -EINVAL; 1030 return -EINVAL;
1020 if (uurb->buffer_length > MAX_USBFS_BUFFER_SIZE) 1031 if (uurb->buffer_length > MAX_USBFS_BUFFER_SIZE)
1021 return -EINVAL; 1032 return -EINVAL;
1022 if (!access_ok((uurb->endpoint & USB_DIR_IN) ? VERIFY_WRITE : VERIFY_READ, uurb->buffer, uurb->buffer_length)) 1033 if (!access_ok(is_in ? VERIFY_WRITE : VERIFY_READ,
1034 uurb->buffer, uurb->buffer_length))
1023 return -EFAULT; 1035 return -EFAULT;
1024 snoop(&ps->dev->dev, "interrupt urb\n"); 1036 snoop(&ps->dev->dev, "interrupt urb\n");
1025 break; 1037 break;
@@ -1039,8 +1051,11 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
1039 return -ENOMEM; 1051 return -ENOMEM;
1040 } 1052 }
1041 as->urb->dev = ps->dev; 1053 as->urb->dev = ps->dev;
1042 as->urb->pipe = (uurb->type << 30) | __create_pipe(ps->dev, uurb->endpoint & 0xf) | (uurb->endpoint & USB_DIR_IN); 1054 as->urb->pipe = (uurb->type << 30) |
1043 as->urb->transfer_flags = uurb->flags; 1055 __create_pipe(ps->dev, uurb->endpoint & 0xf) |
1056 (uurb->endpoint & USB_DIR_IN);
1057 as->urb->transfer_flags = uurb->flags |
1058 (is_in ? URB_DIR_IN : URB_DIR_OUT);
1044 as->urb->transfer_buffer_length = uurb->buffer_length; 1059 as->urb->transfer_buffer_length = uurb->buffer_length;
1045 as->urb->setup_packet = (unsigned char*)dr; 1060 as->urb->setup_packet = (unsigned char*)dr;
1046 as->urb->start_frame = uurb->start_frame; 1061 as->urb->start_frame = uurb->start_frame;
@@ -1070,13 +1085,13 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
1070 as->uid = current->uid; 1085 as->uid = current->uid;
1071 as->euid = current->euid; 1086 as->euid = current->euid;
1072 security_task_getsecid(current, &as->secid); 1087 security_task_getsecid(current, &as->secid);
1073 if (!(uurb->endpoint & USB_DIR_IN)) { 1088 if (!is_in) {
1074 if (copy_from_user(as->urb->transfer_buffer, uurb->buffer, as->urb->transfer_buffer_length)) { 1089 if (copy_from_user(as->urb->transfer_buffer, uurb->buffer,
1090 as->urb->transfer_buffer_length)) {
1075 free_async(as); 1091 free_async(as);
1076 return -EFAULT; 1092 return -EFAULT;
1077 } 1093 }
1078 } 1094 }
1079 snoop(&as->urb->dev->dev, "submit urb\n");
1080 snoop_urb(as->urb, as->userurb); 1095 snoop_urb(as->urb, as->userurb);
1081 async_newpending(as); 1096 async_newpending(as);
1082 if ((ret = usb_submit_urb(as->urb, GFP_KERNEL))) { 1097 if ((ret = usb_submit_urb(as->urb, GFP_KERNEL))) {
@@ -1119,14 +1134,14 @@ static int processcompl(struct async *as, void __user * __user *arg)
1119 if (as->userbuffer) 1134 if (as->userbuffer)
1120 if (copy_to_user(as->userbuffer, urb->transfer_buffer, urb->transfer_buffer_length)) 1135 if (copy_to_user(as->userbuffer, urb->transfer_buffer, urb->transfer_buffer_length))
1121 return -EFAULT; 1136 return -EFAULT;
1122 if (put_user(urb->status, &userurb->status)) 1137 if (put_user(as->status, &userurb->status))
1123 return -EFAULT; 1138 return -EFAULT;
1124 if (put_user(urb->actual_length, &userurb->actual_length)) 1139 if (put_user(urb->actual_length, &userurb->actual_length))
1125 return -EFAULT; 1140 return -EFAULT;
1126 if (put_user(urb->error_count, &userurb->error_count)) 1141 if (put_user(urb->error_count, &userurb->error_count))
1127 return -EFAULT; 1142 return -EFAULT;
1128 1143
1129 if (usb_pipeisoc(urb->pipe)) { 1144 if (usb_endpoint_xfer_isoc(&urb->ep->desc)) {
1130 for (i = 0; i < urb->number_of_packets; i++) { 1145 for (i = 0; i < urb->number_of_packets; i++) {
1131 if (put_user(urb->iso_frame_desc[i].actual_length, 1146 if (put_user(urb->iso_frame_desc[i].actual_length,
1132 &userurb->iso_frame_desc[i].actual_length)) 1147 &userurb->iso_frame_desc[i].actual_length))
@@ -1233,14 +1248,14 @@ static int processcompl_compat(struct async *as, void __user * __user *arg)
1233 if (as->userbuffer) 1248 if (as->userbuffer)
1234 if (copy_to_user(as->userbuffer, urb->transfer_buffer, urb->transfer_buffer_length)) 1249 if (copy_to_user(as->userbuffer, urb->transfer_buffer, urb->transfer_buffer_length))
1235 return -EFAULT; 1250 return -EFAULT;
1236 if (put_user(urb->status, &userurb->status)) 1251 if (put_user(as->status, &userurb->status))
1237 return -EFAULT; 1252 return -EFAULT;
1238 if (put_user(urb->actual_length, &userurb->actual_length)) 1253 if (put_user(urb->actual_length, &userurb->actual_length))
1239 return -EFAULT; 1254 return -EFAULT;
1240 if (put_user(urb->error_count, &userurb->error_count)) 1255 if (put_user(urb->error_count, &userurb->error_count))
1241 return -EFAULT; 1256 return -EFAULT;
1242 1257
1243 if (usb_pipeisoc(urb->pipe)) { 1258 if (usb_endpoint_xfer_isoc(&urb->ep->desc)) {
1244 for (i = 0; i < urb->number_of_packets; i++) { 1259 for (i = 0; i < urb->number_of_packets; i++) {
1245 if (put_user(urb->iso_frame_desc[i].actual_length, 1260 if (put_user(urb->iso_frame_desc[i].actual_length,
1246 &userurb->iso_frame_desc[i].actual_length)) 1261 &userurb->iso_frame_desc[i].actual_length))
diff --git a/drivers/usb/core/driver.c b/drivers/usb/core/driver.c
index 63b1243a913..c27bc080d84 100644
--- a/drivers/usb/core/driver.c
+++ b/drivers/usb/core/driver.c
@@ -202,6 +202,11 @@ static int usb_probe_interface(struct device *dev)
202 intf = to_usb_interface(dev); 202 intf = to_usb_interface(dev);
203 udev = interface_to_usbdev(intf); 203 udev = interface_to_usbdev(intf);
204 204
205 if (udev->authorized == 0) {
206 dev_err(&intf->dev, "Device is not authorized for usage\n");
207 return -ENODEV;
208 }
209
205 id = usb_match_id(intf, driver->id_table); 210 id = usb_match_id(intf, driver->id_table);
206 if (!id) 211 if (!id)
207 id = usb_match_dynamic_id(intf, driver); 212 id = usb_match_dynamic_id(intf, driver);
@@ -945,11 +950,11 @@ done:
945#ifdef CONFIG_USB_SUSPEND 950#ifdef CONFIG_USB_SUSPEND
946 951
947/* Internal routine to check whether we may autosuspend a device. */ 952/* Internal routine to check whether we may autosuspend a device. */
948static int autosuspend_check(struct usb_device *udev) 953static int autosuspend_check(struct usb_device *udev, int reschedule)
949{ 954{
950 int i; 955 int i;
951 struct usb_interface *intf; 956 struct usb_interface *intf;
952 unsigned long suspend_time; 957 unsigned long suspend_time, j;
953 958
954 /* For autosuspend, fail fast if anything is in use or autosuspend 959 /* For autosuspend, fail fast if anything is in use or autosuspend
955 * is disabled. Also fail if any interfaces require remote wakeup 960 * is disabled. Also fail if any interfaces require remote wakeup
@@ -991,20 +996,20 @@ static int autosuspend_check(struct usb_device *udev)
991 } 996 }
992 997
993 /* If everything is okay but the device hasn't been idle for long 998 /* If everything is okay but the device hasn't been idle for long
994 * enough, queue a delayed autosuspend request. 999 * enough, queue a delayed autosuspend request. If the device
1000 * _has_ been idle for long enough and the reschedule flag is set,
1001 * likewise queue a delayed (1 second) autosuspend request.
995 */ 1002 */
996 if (time_after(suspend_time, jiffies)) { 1003 j = jiffies;
1004 if (time_before(j, suspend_time))
1005 reschedule = 1;
1006 else
1007 suspend_time = j + HZ;
1008 if (reschedule) {
997 if (!timer_pending(&udev->autosuspend.timer)) { 1009 if (!timer_pending(&udev->autosuspend.timer)) {
998
999 /* The value of jiffies may change between the
1000 * time_after() comparison above and the subtraction
1001 * below. That's okay; the system behaves sanely
1002 * when a timer is registered for the present moment
1003 * or for the past.
1004 */
1005 queue_delayed_work(ksuspend_usb_wq, &udev->autosuspend, 1010 queue_delayed_work(ksuspend_usb_wq, &udev->autosuspend,
1006 round_jiffies_relative(suspend_time - jiffies)); 1011 round_jiffies_relative(suspend_time - j));
1007 } 1012 }
1008 return -EAGAIN; 1013 return -EAGAIN;
1009 } 1014 }
1010 return 0; 1015 return 0;
@@ -1012,7 +1017,7 @@ static int autosuspend_check(struct usb_device *udev)
1012 1017
1013#else 1018#else
1014 1019
1015static inline int autosuspend_check(struct usb_device *udev) 1020static inline int autosuspend_check(struct usb_device *udev, int reschedule)
1016{ 1021{
1017 return 0; 1022 return 0;
1018} 1023}
@@ -1069,7 +1074,7 @@ static int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
1069 udev->do_remote_wakeup = device_may_wakeup(&udev->dev); 1074 udev->do_remote_wakeup = device_may_wakeup(&udev->dev);
1070 1075
1071 if (udev->auto_pm) { 1076 if (udev->auto_pm) {
1072 status = autosuspend_check(udev); 1077 status = autosuspend_check(udev, 0);
1073 if (status < 0) 1078 if (status < 0)
1074 goto done; 1079 goto done;
1075 } 1080 }
@@ -1083,15 +1088,8 @@ static int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
1083 break; 1088 break;
1084 } 1089 }
1085 } 1090 }
1086 if (status == 0) { 1091 if (status == 0)
1087
1088 /* Non-root devices don't need to do anything for FREEZE
1089 * or PRETHAW. */
1090 if (udev->parent && (msg.event == PM_EVENT_FREEZE ||
1091 msg.event == PM_EVENT_PRETHAW))
1092 goto done;
1093 status = usb_suspend_device(udev, msg); 1092 status = usb_suspend_device(udev, msg);
1094 }
1095 1093
1096 /* If the suspend failed, resume interfaces that did get suspended */ 1094 /* If the suspend failed, resume interfaces that did get suspended */
1097 if (status != 0) { 1095 if (status != 0) {
@@ -1102,12 +1100,24 @@ static int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
1102 1100
1103 /* Try another autosuspend when the interfaces aren't busy */ 1101 /* Try another autosuspend when the interfaces aren't busy */
1104 if (udev->auto_pm) 1102 if (udev->auto_pm)
1105 autosuspend_check(udev); 1103 autosuspend_check(udev, status == -EBUSY);
1106 1104
1107 /* If the suspend succeeded, propagate it up the tree */ 1105 /* If the suspend succeeded then prevent any more URB submissions,
1106 * flush any outstanding URBs, and propagate the suspend up the tree.
1107 */
1108 } else { 1108 } else {
1109 cancel_delayed_work(&udev->autosuspend); 1109 cancel_delayed_work(&udev->autosuspend);
1110 if (parent) 1110 udev->can_submit = 0;
1111 for (i = 0; i < 16; ++i) {
1112 usb_hcd_flush_endpoint(udev, udev->ep_out[i]);
1113 usb_hcd_flush_endpoint(udev, udev->ep_in[i]);
1114 }
1115
1116 /* If this is just a FREEZE or a PRETHAW, udev might
1117 * not really be suspended. Only true suspends get
1118 * propagated up the device tree.
1119 */
1120 if (parent && udev->state == USB_STATE_SUSPENDED)
1111 usb_autosuspend_device(parent); 1121 usb_autosuspend_device(parent);
1112 } 1122 }
1113 1123
@@ -1156,6 +1166,7 @@ static int usb_resume_both(struct usb_device *udev)
1156 status = -ENODEV; 1166 status = -ENODEV;
1157 goto done; 1167 goto done;
1158 } 1168 }
1169 udev->can_submit = 1;
1159 1170
1160 /* Propagate the resume up the tree, if necessary */ 1171 /* Propagate the resume up the tree, if necessary */
1161 if (udev->state == USB_STATE_SUSPENDED) { 1172 if (udev->state == USB_STATE_SUSPENDED) {
@@ -1529,9 +1540,21 @@ int usb_external_resume_device(struct usb_device *udev)
1529 1540
1530static int usb_suspend(struct device *dev, pm_message_t message) 1541static int usb_suspend(struct device *dev, pm_message_t message)
1531{ 1542{
1543 struct usb_device *udev;
1544
1532 if (!is_usb_device(dev)) /* Ignore PM for interfaces */ 1545 if (!is_usb_device(dev)) /* Ignore PM for interfaces */
1533 return 0; 1546 return 0;
1534 return usb_external_suspend_device(to_usb_device(dev), message); 1547 udev = to_usb_device(dev);
1548
1549 /* If udev is already suspended, we can skip this suspend and
1550 * we should also skip the upcoming system resume. */
1551 if (udev->state == USB_STATE_SUSPENDED) {
1552 udev->skip_sys_resume = 1;
1553 return 0;
1554 }
1555
1556 udev->skip_sys_resume = 0;
1557 return usb_external_suspend_device(udev, message);
1535} 1558}
1536 1559
1537static int usb_resume(struct device *dev) 1560static int usb_resume(struct device *dev)
@@ -1542,13 +1565,14 @@ static int usb_resume(struct device *dev)
1542 return 0; 1565 return 0;
1543 udev = to_usb_device(dev); 1566 udev = to_usb_device(dev);
1544 1567
1545 /* If autoresume is disabled then we also want to prevent resume 1568 /* If udev->skip_sys_resume is set then udev was already suspended
1546 * during system wakeup. However, a "persistent-device" reset-resume 1569 * when the system suspend started, so we don't want to resume
1547 * after power loss counts as a wakeup event. So allow a 1570 * udev during this system wakeup. However a reset-resume counts
1548 * reset-resume to occur if remote wakeup is enabled. */ 1571 * as a wakeup event, so allow a reset-resume to occur if remote
1549 if (udev->autoresume_disabled) { 1572 * wakeup is enabled. */
1573 if (udev->skip_sys_resume) {
1550 if (!(udev->reset_resume && udev->do_remote_wakeup)) 1574 if (!(udev->reset_resume && udev->do_remote_wakeup))
1551 return -EPERM; 1575 return -EHOSTUNREACH;
1552 } 1576 }
1553 return usb_external_resume_device(udev); 1577 return usb_external_resume_device(udev);
1554} 1578}
diff --git a/drivers/usb/core/endpoint.c b/drivers/usb/core/endpoint.c
index e0ec7045e86..7dc123d6b2d 100644
--- a/drivers/usb/core/endpoint.c
+++ b/drivers/usb/core/endpoint.c
@@ -267,7 +267,6 @@ static void ep_device_release(struct device *dev)
267{ 267{
268 struct ep_device *ep_dev = to_ep_device(dev); 268 struct ep_device *ep_dev = to_ep_device(dev);
269 269
270 dev_dbg(dev, "%s called for %s\n", __FUNCTION__, dev->bus_id);
271 endpoint_free_minor(ep_dev); 270 endpoint_free_minor(ep_dev);
272 kfree(ep_dev); 271 kfree(ep_dev);
273} 272}
diff --git a/drivers/usb/core/generic.c b/drivers/usb/core/generic.c
index b2fc2b11525..c1cb94e9f24 100644
--- a/drivers/usb/core/generic.c
+++ b/drivers/usb/core/generic.c
@@ -40,7 +40,7 @@ static int is_activesync(struct usb_interface_descriptor *desc)
40 && desc->bInterfaceProtocol == 1; 40 && desc->bInterfaceProtocol == 1;
41} 41}
42 42
43static int choose_configuration(struct usb_device *udev) 43int usb_choose_configuration(struct usb_device *udev)
44{ 44{
45 int i; 45 int i;
46 int num_configs; 46 int num_configs;
@@ -161,17 +161,20 @@ static int generic_probe(struct usb_device *udev)
161 /* Choose and set the configuration. This registers the interfaces 161 /* Choose and set the configuration. This registers the interfaces
162 * with the driver core and lets interface drivers bind to them. 162 * with the driver core and lets interface drivers bind to them.
163 */ 163 */
164 c = choose_configuration(udev); 164 if (udev->authorized == 0)
165 if (c >= 0) { 165 dev_err(&udev->dev, "Device is not authorized for usage\n");
166 err = usb_set_configuration(udev, c); 166 else {
167 if (err) { 167 c = usb_choose_configuration(udev);
168 dev_err(&udev->dev, "can't set config #%d, error %d\n", 168 if (c >= 0) {
169 err = usb_set_configuration(udev, c);
170 if (err) {
171 dev_err(&udev->dev, "can't set config #%d, error %d\n",
169 c, err); 172 c, err);
170 /* This need not be fatal. The user can try to 173 /* This need not be fatal. The user can try to
171 * set other configurations. */ 174 * set other configurations. */
175 }
172 } 176 }
173 } 177 }
174
175 /* USB device state == configured ... usable */ 178 /* USB device state == configured ... usable */
176 usb_notify_add_device(udev); 179 usb_notify_add_device(udev);
177 180
@@ -203,8 +206,13 @@ static int generic_suspend(struct usb_device *udev, pm_message_t msg)
203 */ 206 */
204 if (!udev->parent) 207 if (!udev->parent)
205 rc = hcd_bus_suspend(udev); 208 rc = hcd_bus_suspend(udev);
209
210 /* Non-root devices don't need to do anything for FREEZE or PRETHAW */
211 else if (msg.event == PM_EVENT_FREEZE || msg.event == PM_EVENT_PRETHAW)
212 rc = 0;
206 else 213 else
207 rc = usb_port_suspend(udev); 214 rc = usb_port_suspend(udev);
215
208 return rc; 216 return rc;
209} 217}
210 218
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index 42ef1d5f6c8..3dd997df850 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -356,10 +356,18 @@ static int rh_call_control (struct usb_hcd *hcd, struct urb *urb)
356 const u8 *bufp = tbuf; 356 const u8 *bufp = tbuf;
357 int len = 0; 357 int len = 0;
358 int patch_wakeup = 0; 358 int patch_wakeup = 0;
359 unsigned long flags; 359 int status;
360 int status = 0;
361 int n; 360 int n;
362 361
362 might_sleep();
363
364 spin_lock_irq(&hcd_root_hub_lock);
365 status = usb_hcd_link_urb_to_ep(hcd, urb);
366 spin_unlock_irq(&hcd_root_hub_lock);
367 if (status)
368 return status;
369 urb->hcpriv = hcd; /* Indicate it's queued */
370
363 cmd = (struct usb_ctrlrequest *) urb->setup_packet; 371 cmd = (struct usb_ctrlrequest *) urb->setup_packet;
364 typeReq = (cmd->bRequestType << 8) | cmd->bRequest; 372 typeReq = (cmd->bRequestType << 8) | cmd->bRequest;
365 wValue = le16_to_cpu (cmd->wValue); 373 wValue = le16_to_cpu (cmd->wValue);
@@ -523,13 +531,18 @@ error:
523 } 531 }
524 532
525 /* any errors get returned through the urb completion */ 533 /* any errors get returned through the urb completion */
526 local_irq_save (flags); 534 spin_lock_irq(&hcd_root_hub_lock);
527 spin_lock (&urb->lock); 535 usb_hcd_unlink_urb_from_ep(hcd, urb);
528 if (urb->status == -EINPROGRESS) 536
529 urb->status = status; 537 /* This peculiar use of spinlocks echoes what real HC drivers do.
530 spin_unlock (&urb->lock); 538 * Avoiding calls to local_irq_disable/enable makes the code
531 usb_hcd_giveback_urb (hcd, urb); 539 * RT-friendly.
532 local_irq_restore (flags); 540 */
541 spin_unlock(&hcd_root_hub_lock);
542 usb_hcd_giveback_urb(hcd, urb, status);
543 spin_lock(&hcd_root_hub_lock);
544
545 spin_unlock_irq(&hcd_root_hub_lock);
533 return 0; 546 return 0;
534} 547}
535 548
@@ -559,31 +572,23 @@ void usb_hcd_poll_rh_status(struct usb_hcd *hcd)
559 if (length > 0) { 572 if (length > 0) {
560 573
561 /* try to complete the status urb */ 574 /* try to complete the status urb */
562 local_irq_save (flags); 575 spin_lock_irqsave(&hcd_root_hub_lock, flags);
563 spin_lock(&hcd_root_hub_lock);
564 urb = hcd->status_urb; 576 urb = hcd->status_urb;
565 if (urb) { 577 if (urb) {
566 spin_lock(&urb->lock); 578 hcd->poll_pending = 0;
567 if (urb->status == -EINPROGRESS) { 579 hcd->status_urb = NULL;
568 hcd->poll_pending = 0; 580 urb->actual_length = length;
569 hcd->status_urb = NULL; 581 memcpy(urb->transfer_buffer, buffer, length);
570 urb->status = 0;
571 urb->hcpriv = NULL;
572 urb->actual_length = length;
573 memcpy(urb->transfer_buffer, buffer, length);
574 } else /* urb has been unlinked */
575 length = 0;
576 spin_unlock(&urb->lock);
577 } else
578 length = 0;
579 spin_unlock(&hcd_root_hub_lock);
580 582
581 /* local irqs are always blocked in completions */ 583 usb_hcd_unlink_urb_from_ep(hcd, urb);
582 if (length > 0) 584 spin_unlock(&hcd_root_hub_lock);
583 usb_hcd_giveback_urb (hcd, urb); 585 usb_hcd_giveback_urb(hcd, urb, 0);
584 else 586 spin_lock(&hcd_root_hub_lock);
587 } else {
588 length = 0;
585 hcd->poll_pending = 1; 589 hcd->poll_pending = 1;
586 local_irq_restore (flags); 590 }
591 spin_unlock_irqrestore(&hcd_root_hub_lock, flags);
587 } 592 }
588 593
589 /* The USB 2.0 spec says 256 ms. This is close enough and won't 594 /* The USB 2.0 spec says 256 ms. This is close enough and won't
@@ -611,33 +616,35 @@ static int rh_queue_status (struct usb_hcd *hcd, struct urb *urb)
611 int len = 1 + (urb->dev->maxchild / 8); 616 int len = 1 + (urb->dev->maxchild / 8);
612 617
613 spin_lock_irqsave (&hcd_root_hub_lock, flags); 618 spin_lock_irqsave (&hcd_root_hub_lock, flags);
614 if (urb->status != -EINPROGRESS) /* already unlinked */ 619 if (hcd->status_urb || urb->transfer_buffer_length < len) {
615 retval = urb->status;
616 else if (hcd->status_urb || urb->transfer_buffer_length < len) {
617 dev_dbg (hcd->self.controller, "not queuing rh status urb\n"); 620 dev_dbg (hcd->self.controller, "not queuing rh status urb\n");
618 retval = -EINVAL; 621 retval = -EINVAL;
619 } else { 622 goto done;
620 hcd->status_urb = urb; 623 }
621 urb->hcpriv = hcd; /* indicate it's queued */
622 624
623 if (!hcd->uses_new_polling) 625 retval = usb_hcd_link_urb_to_ep(hcd, urb);
624 mod_timer (&hcd->rh_timer, 626 if (retval)
625 (jiffies/(HZ/4) + 1) * (HZ/4)); 627 goto done;
626 628
627 /* If a status change has already occurred, report it ASAP */ 629 hcd->status_urb = urb;
628 else if (hcd->poll_pending) 630 urb->hcpriv = hcd; /* indicate it's queued */
629 mod_timer (&hcd->rh_timer, jiffies); 631 if (!hcd->uses_new_polling)
630 retval = 0; 632 mod_timer(&hcd->rh_timer, (jiffies/(HZ/4) + 1) * (HZ/4));
631 } 633
634 /* If a status change has already occurred, report it ASAP */
635 else if (hcd->poll_pending)
636 mod_timer(&hcd->rh_timer, jiffies);
637 retval = 0;
638 done:
632 spin_unlock_irqrestore (&hcd_root_hub_lock, flags); 639 spin_unlock_irqrestore (&hcd_root_hub_lock, flags);
633 return retval; 640 return retval;
634} 641}
635 642
636static int rh_urb_enqueue (struct usb_hcd *hcd, struct urb *urb) 643static int rh_urb_enqueue (struct usb_hcd *hcd, struct urb *urb)
637{ 644{
638 if (usb_pipeint (urb->pipe)) 645 if (usb_endpoint_xfer_int(&urb->ep->desc))
639 return rh_queue_status (hcd, urb); 646 return rh_queue_status (hcd, urb);
640 if (usb_pipecontrol (urb->pipe)) 647 if (usb_endpoint_xfer_control(&urb->ep->desc))
641 return rh_call_control (hcd, urb); 648 return rh_call_control (hcd, urb);
642 return -EINVAL; 649 return -EINVAL;
643} 650}
@@ -647,32 +654,96 @@ static int rh_urb_enqueue (struct usb_hcd *hcd, struct urb *urb)
647/* Unlinks of root-hub control URBs are legal, but they don't do anything 654/* Unlinks of root-hub control URBs are legal, but they don't do anything
648 * since these URBs always execute synchronously. 655 * since these URBs always execute synchronously.
649 */ 656 */
650static int usb_rh_urb_dequeue (struct usb_hcd *hcd, struct urb *urb) 657static int usb_rh_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
651{ 658{
652 unsigned long flags; 659 unsigned long flags;
660 int rc;
661
662 spin_lock_irqsave(&hcd_root_hub_lock, flags);
663 rc = usb_hcd_check_unlink_urb(hcd, urb, status);
664 if (rc)
665 goto done;
653 666
654 if (usb_pipeendpoint(urb->pipe) == 0) { /* Control URB */ 667 if (usb_endpoint_num(&urb->ep->desc) == 0) { /* Control URB */
655 ; /* Do nothing */ 668 ; /* Do nothing */
656 669
657 } else { /* Status URB */ 670 } else { /* Status URB */
658 if (!hcd->uses_new_polling) 671 if (!hcd->uses_new_polling)
659 del_timer (&hcd->rh_timer); 672 del_timer (&hcd->rh_timer);
660 local_irq_save (flags);
661 spin_lock (&hcd_root_hub_lock);
662 if (urb == hcd->status_urb) { 673 if (urb == hcd->status_urb) {
663 hcd->status_urb = NULL; 674 hcd->status_urb = NULL;
664 urb->hcpriv = NULL; 675 usb_hcd_unlink_urb_from_ep(hcd, urb);
665 } else 676
666 urb = NULL; /* wasn't fully queued */ 677 spin_unlock(&hcd_root_hub_lock);
667 spin_unlock (&hcd_root_hub_lock); 678 usb_hcd_giveback_urb(hcd, urb, status);
668 if (urb) 679 spin_lock(&hcd_root_hub_lock);
669 usb_hcd_giveback_urb (hcd, urb); 680 }
670 local_irq_restore (flags);
671 } 681 }
682 done:
683 spin_unlock_irqrestore(&hcd_root_hub_lock, flags);
684 return rc;
685}
672 686
673 return 0; 687
688
689/*
690 * Show & store the current value of authorized_default
691 */
692static ssize_t usb_host_authorized_default_show(struct device *dev,
693 struct device_attribute *attr,
694 char *buf)
695{
696 struct usb_device *rh_usb_dev = to_usb_device(dev);
697 struct usb_bus *usb_bus = rh_usb_dev->bus;
698 struct usb_hcd *usb_hcd;
699
700 if (usb_bus == NULL) /* FIXME: not sure if this case is possible */
701 return -ENODEV;
702 usb_hcd = bus_to_hcd(usb_bus);
703 return snprintf(buf, PAGE_SIZE, "%u\n", usb_hcd->authorized_default);
704}
705
706static ssize_t usb_host_authorized_default_store(struct device *dev,
707 struct device_attribute *attr,
708 const char *buf, size_t size)
709{
710 ssize_t result;
711 unsigned val;
712 struct usb_device *rh_usb_dev = to_usb_device(dev);
713 struct usb_bus *usb_bus = rh_usb_dev->bus;
714 struct usb_hcd *usb_hcd;
715
716 if (usb_bus == NULL) /* FIXME: not sure if this case is possible */
717 return -ENODEV;
718 usb_hcd = bus_to_hcd(usb_bus);
719 result = sscanf(buf, "%u\n", &val);
720 if (result == 1) {
721 usb_hcd->authorized_default = val? 1 : 0;
722 result = size;
723 }
724 else
725 result = -EINVAL;
726 return result;
674} 727}
675 728
729static DEVICE_ATTR(authorized_default, 0644,
730 usb_host_authorized_default_show,
731 usb_host_authorized_default_store);
732
733
734/* Group all the USB bus attributes */
735static struct attribute *usb_bus_attrs[] = {
736 &dev_attr_authorized_default.attr,
737 NULL,
738};
739
740static struct attribute_group usb_bus_attr_group = {
741 .name = NULL, /* we want them in the same directory */
742 .attrs = usb_bus_attrs,
743};
744
745
746
676/*-------------------------------------------------------------------------*/ 747/*-------------------------------------------------------------------------*/
677 748
678static struct class *usb_host_class; 749static struct class *usb_host_class;
@@ -726,27 +797,23 @@ static void usb_bus_init (struct usb_bus *bus)
726 */ 797 */
727static int usb_register_bus(struct usb_bus *bus) 798static int usb_register_bus(struct usb_bus *bus)
728{ 799{
800 int result = -E2BIG;
729 int busnum; 801 int busnum;
730 802
731 mutex_lock(&usb_bus_list_lock); 803 mutex_lock(&usb_bus_list_lock);
732 busnum = find_next_zero_bit (busmap.busmap, USB_MAXBUS, 1); 804 busnum = find_next_zero_bit (busmap.busmap, USB_MAXBUS, 1);
733 if (busnum < USB_MAXBUS) { 805 if (busnum >= USB_MAXBUS) {
734 set_bit (busnum, busmap.busmap);
735 bus->busnum = busnum;
736 } else {
737 printk (KERN_ERR "%s: too many buses\n", usbcore_name); 806 printk (KERN_ERR "%s: too many buses\n", usbcore_name);
738 mutex_unlock(&usb_bus_list_lock); 807 goto error_find_busnum;
739 return -E2BIG;
740 } 808 }
741 809 set_bit (busnum, busmap.busmap);
810 bus->busnum = busnum;
742 bus->class_dev = class_device_create(usb_host_class, NULL, MKDEV(0,0), 811 bus->class_dev = class_device_create(usb_host_class, NULL, MKDEV(0,0),
743 bus->controller, "usb_host%d", busnum); 812 bus->controller, "usb_host%d",
744 if (IS_ERR(bus->class_dev)) { 813 busnum);
745 clear_bit(busnum, busmap.busmap); 814 result = PTR_ERR(bus->class_dev);
746 mutex_unlock(&usb_bus_list_lock); 815 if (IS_ERR(bus->class_dev))
747 return PTR_ERR(bus->class_dev); 816 goto error_create_class_dev;
748 }
749
750 class_set_devdata(bus->class_dev, bus); 817 class_set_devdata(bus->class_dev, bus);
751 818
752 /* Add it to the local list of buses */ 819 /* Add it to the local list of buses */
@@ -755,8 +822,15 @@ static int usb_register_bus(struct usb_bus *bus)
755 822
756 usb_notify_add_bus(bus); 823 usb_notify_add_bus(bus);
757 824
758 dev_info (bus->controller, "new USB bus registered, assigned bus number %d\n", bus->busnum); 825 dev_info (bus->controller, "new USB bus registered, assigned bus "
826 "number %d\n", bus->busnum);
759 return 0; 827 return 0;
828
829error_create_class_dev:
830 clear_bit(busnum, busmap.busmap);
831error_find_busnum:
832 mutex_unlock(&usb_bus_list_lock);
833 return result;
760} 834}
761 835
762/** 836/**
@@ -908,103 +982,145 @@ EXPORT_SYMBOL (usb_calc_bus_time);
908 982
909/*-------------------------------------------------------------------------*/ 983/*-------------------------------------------------------------------------*/
910 984
911static void urb_unlink(struct usb_hcd *hcd, struct urb *urb) 985/**
986 * usb_hcd_link_urb_to_ep - add an URB to its endpoint queue
987 * @hcd: host controller to which @urb was submitted
988 * @urb: URB being submitted
989 *
990 * Host controller drivers should call this routine in their enqueue()
991 * method. The HCD's private spinlock must be held and interrupts must
992 * be disabled. The actions carried out here are required for URB
993 * submission, as well as for endpoint shutdown and for usb_kill_urb.
994 *
995 * Returns 0 for no error, otherwise a negative error code (in which case
996 * the enqueue() method must fail). If no error occurs but enqueue() fails
997 * anyway, it must call usb_hcd_unlink_urb_from_ep() before releasing
998 * the private spinlock and returning.
999 */
1000int usb_hcd_link_urb_to_ep(struct usb_hcd *hcd, struct urb *urb)
912{ 1001{
913 unsigned long flags; 1002 int rc = 0;
914 1003
915 /* clear all state linking urb to this dev (and hcd) */ 1004 spin_lock(&hcd_urb_list_lock);
916 spin_lock_irqsave(&hcd_urb_list_lock, flags);
917 list_del_init (&urb->urb_list);
918 spin_unlock_irqrestore(&hcd_urb_list_lock, flags);
919 1005
920 if (hcd->self.uses_dma && !is_root_hub(urb->dev)) { 1006 /* Check that the URB isn't being killed */
921 if (usb_pipecontrol (urb->pipe) 1007 if (unlikely(urb->reject)) {
922 && !(urb->transfer_flags & URB_NO_SETUP_DMA_MAP)) 1008 rc = -EPERM;
923 dma_unmap_single (hcd->self.controller, urb->setup_dma, 1009 goto done;
924 sizeof (struct usb_ctrlrequest),
925 DMA_TO_DEVICE);
926 if (urb->transfer_buffer_length != 0
927 && !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP))
928 dma_unmap_single (hcd->self.controller,
929 urb->transfer_dma,
930 urb->transfer_buffer_length,
931 usb_pipein (urb->pipe)
932 ? DMA_FROM_DEVICE
933 : DMA_TO_DEVICE);
934 } 1010 }
935}
936
937/* may be called in any context with a valid urb->dev usecount
938 * caller surrenders "ownership" of urb
939 * expects usb_submit_urb() to have sanity checked and conditioned all
940 * inputs in the urb
941 */
942int usb_hcd_submit_urb (struct urb *urb, gfp_t mem_flags)
943{
944 int status;
945 struct usb_hcd *hcd = bus_to_hcd(urb->dev->bus);
946 struct usb_host_endpoint *ep;
947 unsigned long flags;
948 1011
949 if (!hcd) 1012 if (unlikely(!urb->ep->enabled)) {
950 return -ENODEV; 1013 rc = -ENOENT;
1014 goto done;
1015 }
951 1016
952 usbmon_urb_submit(&hcd->self, urb); 1017 if (unlikely(!urb->dev->can_submit)) {
1018 rc = -EHOSTUNREACH;
1019 goto done;
1020 }
953 1021
954 /* 1022 /*
955 * Atomically queue the urb, first to our records, then to the HCD. 1023 * Check the host controller's state and add the URB to the
956 * Access to urb->status is controlled by urb->lock ... changes on 1024 * endpoint's queue.
957 * i/o completion (normal or fault) or unlinking.
958 */ 1025 */
959 1026 switch (hcd->state) {
960 // FIXME: verify that quiescing hc works right (RH cleans up)
961
962 spin_lock_irqsave(&hcd_urb_list_lock, flags);
963 ep = (usb_pipein(urb->pipe) ? urb->dev->ep_in : urb->dev->ep_out)
964 [usb_pipeendpoint(urb->pipe)];
965 if (unlikely (!ep))
966 status = -ENOENT;
967 else if (unlikely (urb->reject))
968 status = -EPERM;
969 else switch (hcd->state) {
970 case HC_STATE_RUNNING: 1027 case HC_STATE_RUNNING:
971 case HC_STATE_RESUMING: 1028 case HC_STATE_RESUMING:
972 list_add_tail (&urb->urb_list, &ep->urb_list); 1029 urb->unlinked = 0;
973 status = 0; 1030 list_add_tail(&urb->urb_list, &urb->ep->urb_list);
974 break; 1031 break;
975 default: 1032 default:
976 status = -ESHUTDOWN; 1033 rc = -ESHUTDOWN;
977 break; 1034 goto done;
978 } 1035 }
979 spin_unlock_irqrestore(&hcd_urb_list_lock, flags); 1036 done:
980 if (status) { 1037 spin_unlock(&hcd_urb_list_lock);
981 INIT_LIST_HEAD (&urb->urb_list); 1038 return rc;
982 usbmon_urb_submit_error(&hcd->self, urb, status); 1039}
983 return status; 1040EXPORT_SYMBOL_GPL(usb_hcd_link_urb_to_ep);
1041
1042/**
1043 * usb_hcd_check_unlink_urb - check whether an URB may be unlinked
1044 * @hcd: host controller to which @urb was submitted
1045 * @urb: URB being checked for unlinkability
1046 * @status: error code to store in @urb if the unlink succeeds
1047 *
1048 * Host controller drivers should call this routine in their dequeue()
1049 * method. The HCD's private spinlock must be held and interrupts must
1050 * be disabled. The actions carried out here are required for making
1051 * sure than an unlink is valid.
1052 *
1053 * Returns 0 for no error, otherwise a negative error code (in which case
1054 * the dequeue() method must fail). The possible error codes are:
1055 *
1056 * -EIDRM: @urb was not submitted or has already completed.
1057 * The completion function may not have been called yet.
1058 *
1059 * -EBUSY: @urb has already been unlinked.
1060 */
1061int usb_hcd_check_unlink_urb(struct usb_hcd *hcd, struct urb *urb,
1062 int status)
1063{
1064 struct list_head *tmp;
1065
1066 /* insist the urb is still queued */
1067 list_for_each(tmp, &urb->ep->urb_list) {
1068 if (tmp == &urb->urb_list)
1069 break;
984 } 1070 }
1071 if (tmp != &urb->urb_list)
1072 return -EIDRM;
985 1073
986 /* increment urb's reference count as part of giving it to the HCD 1074 /* Any status except -EINPROGRESS means something already started to
987 * (which now controls it). HCD guarantees that it either returns 1075 * unlink this URB from the hardware. So there's no more work to do.
988 * an error or calls giveback(), but not both.
989 */ 1076 */
990 urb = usb_get_urb (urb); 1077 if (urb->unlinked)
991 atomic_inc (&urb->use_count); 1078 return -EBUSY;
992 1079 urb->unlinked = status;
993 if (is_root_hub(urb->dev)) { 1080
994 /* NOTE: requirement on hub callers (usbfs and the hub 1081 /* IRQ setup can easily be broken so that USB controllers
995 * driver, for now) that URBs' urb->transfer_buffer be 1082 * never get completion IRQs ... maybe even the ones we need to
996 * valid and usb_buffer_{sync,unmap}() not be needed, since 1083 * finish unlinking the initial failed usb_set_address()
997 * they could clobber root hub response data. 1084 * or device descriptor fetch.
998 */ 1085 */
999 status = rh_urb_enqueue (hcd, urb); 1086 if (!test_bit(HCD_FLAG_SAW_IRQ, &hcd->flags) &&
1000 goto done; 1087 !is_root_hub(urb->dev)) {
1088 dev_warn(hcd->self.controller, "Unlink after no-IRQ? "
1089 "Controller is probably using the wrong IRQ.\n");
1090 set_bit(HCD_FLAG_SAW_IRQ, &hcd->flags);
1001 } 1091 }
1002 1092
1003 /* lower level hcd code should use *_dma exclusively, 1093 return 0;
1094}
1095EXPORT_SYMBOL_GPL(usb_hcd_check_unlink_urb);
1096
1097/**
1098 * usb_hcd_unlink_urb_from_ep - remove an URB from its endpoint queue
1099 * @hcd: host controller to which @urb was submitted
1100 * @urb: URB being unlinked
1101 *
1102 * Host controller drivers should call this routine before calling
1103 * usb_hcd_giveback_urb(). The HCD's private spinlock must be held and
1104 * interrupts must be disabled. The actions carried out here are required
1105 * for URB completion.
1106 */
1107void usb_hcd_unlink_urb_from_ep(struct usb_hcd *hcd, struct urb *urb)
1108{
1109 /* clear all state linking urb to this dev (and hcd) */
1110 spin_lock(&hcd_urb_list_lock);
1111 list_del_init(&urb->urb_list);
1112 spin_unlock(&hcd_urb_list_lock);
1113}
1114EXPORT_SYMBOL_GPL(usb_hcd_unlink_urb_from_ep);
1115
1116static void map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb)
1117{
1118 /* Map the URB's buffers for DMA access.
1119 * Lower level HCD code should use *_dma exclusively,
1004 * unless it uses pio or talks to another transport. 1120 * unless it uses pio or talks to another transport.
1005 */ 1121 */
1006 if (hcd->self.uses_dma) { 1122 if (hcd->self.uses_dma && !is_root_hub(urb->dev)) {
1007 if (usb_pipecontrol (urb->pipe) 1123 if (usb_endpoint_xfer_control(&urb->ep->desc)
1008 && !(urb->transfer_flags & URB_NO_SETUP_DMA_MAP)) 1124 && !(urb->transfer_flags & URB_NO_SETUP_DMA_MAP))
1009 urb->setup_dma = dma_map_single ( 1125 urb->setup_dma = dma_map_single (
1010 hcd->self.controller, 1126 hcd->self.controller,
@@ -1017,20 +1133,75 @@ int usb_hcd_submit_urb (struct urb *urb, gfp_t mem_flags)
1017 hcd->self.controller, 1133 hcd->self.controller,
1018 urb->transfer_buffer, 1134 urb->transfer_buffer,
1019 urb->transfer_buffer_length, 1135 urb->transfer_buffer_length,
1020 usb_pipein (urb->pipe) 1136 usb_urb_dir_in(urb)
1021 ? DMA_FROM_DEVICE 1137 ? DMA_FROM_DEVICE
1022 : DMA_TO_DEVICE); 1138 : DMA_TO_DEVICE);
1023 } 1139 }
1140}
1024 1141
1025 status = hcd->driver->urb_enqueue (hcd, ep, urb, mem_flags); 1142static void unmap_urb_for_dma(struct usb_hcd *hcd, struct urb *urb)
1026done: 1143{
1027 if (unlikely (status)) { 1144 if (hcd->self.uses_dma && !is_root_hub(urb->dev)) {
1028 urb_unlink(hcd, urb); 1145 if (usb_endpoint_xfer_control(&urb->ep->desc)
1029 atomic_dec (&urb->use_count); 1146 && !(urb->transfer_flags & URB_NO_SETUP_DMA_MAP))
1030 if (urb->reject) 1147 dma_unmap_single(hcd->self.controller, urb->setup_dma,
1031 wake_up (&usb_kill_urb_queue); 1148 sizeof(struct usb_ctrlrequest),
1149 DMA_TO_DEVICE);
1150 if (urb->transfer_buffer_length != 0
1151 && !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP))
1152 dma_unmap_single(hcd->self.controller,
1153 urb->transfer_dma,
1154 urb->transfer_buffer_length,
1155 usb_urb_dir_in(urb)
1156 ? DMA_FROM_DEVICE
1157 : DMA_TO_DEVICE);
1158 }
1159}
1160
1161/*-------------------------------------------------------------------------*/
1162
1163/* may be called in any context with a valid urb->dev usecount
1164 * caller surrenders "ownership" of urb
1165 * expects usb_submit_urb() to have sanity checked and conditioned all
1166 * inputs in the urb
1167 */
1168int usb_hcd_submit_urb (struct urb *urb, gfp_t mem_flags)
1169{
1170 int status;
1171 struct usb_hcd *hcd = bus_to_hcd(urb->dev->bus);
1172
1173 /* increment urb's reference count as part of giving it to the HCD
1174 * (which will control it). HCD guarantees that it either returns
1175 * an error or calls giveback(), but not both.
1176 */
1177 usb_get_urb(urb);
1178 atomic_inc(&urb->use_count);
1179 atomic_inc(&urb->dev->urbnum);
1180 usbmon_urb_submit(&hcd->self, urb);
1181
1182 /* NOTE requirements on root-hub callers (usbfs and the hub
1183 * driver, for now): URBs' urb->transfer_buffer must be
1184 * valid and usb_buffer_{sync,unmap}() not be needed, since
1185 * they could clobber root hub response data. Also, control
1186 * URBs must be submitted in process context with interrupts
1187 * enabled.
1188 */
1189 map_urb_for_dma(hcd, urb);
1190 if (is_root_hub(urb->dev))
1191 status = rh_urb_enqueue(hcd, urb);
1192 else
1193 status = hcd->driver->urb_enqueue(hcd, urb, mem_flags);
1194
1195 if (unlikely(status)) {
1032 usbmon_urb_submit_error(&hcd->self, urb, status); 1196 usbmon_urb_submit_error(&hcd->self, urb, status);
1033 usb_put_urb (urb); 1197 unmap_urb_for_dma(hcd, urb);
1198 urb->hcpriv = NULL;
1199 INIT_LIST_HEAD(&urb->urb_list);
1200 atomic_dec(&urb->use_count);
1201 atomic_dec(&urb->dev->urbnum);
1202 if (urb->reject)
1203 wake_up(&usb_kill_urb_queue);
1204 usb_put_urb(urb);
1034 } 1205 }
1035 return status; 1206 return status;
1036} 1207}
@@ -1042,24 +1213,19 @@ done:
1042 * soon as practical. we've already set up the urb's return status, 1213 * soon as practical. we've already set up the urb's return status,
1043 * but we can't know if the callback completed already. 1214 * but we can't know if the callback completed already.
1044 */ 1215 */
1045static int 1216static int unlink1(struct usb_hcd *hcd, struct urb *urb, int status)
1046unlink1 (struct usb_hcd *hcd, struct urb *urb)
1047{ 1217{
1048 int value; 1218 int value;
1049 1219
1050 if (is_root_hub(urb->dev)) 1220 if (is_root_hub(urb->dev))
1051 value = usb_rh_urb_dequeue (hcd, urb); 1221 value = usb_rh_urb_dequeue(hcd, urb, status);
1052 else { 1222 else {
1053 1223
1054 /* The only reason an HCD might fail this call is if 1224 /* The only reason an HCD might fail this call is if
1055 * it has not yet fully queued the urb to begin with. 1225 * it has not yet fully queued the urb to begin with.
1056 * Such failures should be harmless. */ 1226 * Such failures should be harmless. */
1057 value = hcd->driver->urb_dequeue (hcd, urb); 1227 value = hcd->driver->urb_dequeue(hcd, urb, status);
1058 } 1228 }
1059
1060 if (value != 0)
1061 dev_dbg (hcd->self.controller, "dequeue %p --> %d\n",
1062 urb, value);
1063 return value; 1229 return value;
1064} 1230}
1065 1231
@@ -1071,88 +1237,17 @@ unlink1 (struct usb_hcd *hcd, struct urb *urb)
1071 */ 1237 */
1072int usb_hcd_unlink_urb (struct urb *urb, int status) 1238int usb_hcd_unlink_urb (struct urb *urb, int status)
1073{ 1239{
1074 struct usb_host_endpoint *ep; 1240 struct usb_hcd *hcd;
1075 struct usb_hcd *hcd = NULL; 1241 int retval;
1076 struct device *sys = NULL;
1077 unsigned long flags;
1078 struct list_head *tmp;
1079 int retval;
1080
1081 if (!urb)
1082 return -EINVAL;
1083 if (!urb->dev || !urb->dev->bus)
1084 return -ENODEV;
1085 ep = (usb_pipein(urb->pipe) ? urb->dev->ep_in : urb->dev->ep_out)
1086 [usb_pipeendpoint(urb->pipe)];
1087 if (!ep)
1088 return -ENODEV;
1089
1090 /*
1091 * we contend for urb->status with the hcd core,
1092 * which changes it while returning the urb.
1093 *
1094 * Caller guaranteed that the urb pointer hasn't been freed, and
1095 * that it was submitted. But as a rule it can't know whether or
1096 * not it's already been unlinked ... so we respect the reversed
1097 * lock sequence needed for the usb_hcd_giveback_urb() code paths
1098 * (urb lock, then hcd_urb_list_lock) in case some other CPU is now
1099 * unlinking it.
1100 */
1101 spin_lock_irqsave (&urb->lock, flags);
1102 spin_lock(&hcd_urb_list_lock);
1103 1242
1104 sys = &urb->dev->dev;
1105 hcd = bus_to_hcd(urb->dev->bus); 1243 hcd = bus_to_hcd(urb->dev->bus);
1106 if (hcd == NULL) { 1244 retval = unlink1(hcd, urb, status);
1107 retval = -ENODEV;
1108 goto done;
1109 }
1110 1245
1111 /* insist the urb is still queued */
1112 list_for_each(tmp, &ep->urb_list) {
1113 if (tmp == &urb->urb_list)
1114 break;
1115 }
1116 if (tmp != &urb->urb_list) {
1117 retval = -EIDRM;
1118 goto done;
1119 }
1120
1121 /* Any status except -EINPROGRESS means something already started to
1122 * unlink this URB from the hardware. So there's no more work to do.
1123 */
1124 if (urb->status != -EINPROGRESS) {
1125 retval = -EBUSY;
1126 goto done;
1127 }
1128
1129 /* IRQ setup can easily be broken so that USB controllers
1130 * never get completion IRQs ... maybe even the ones we need to
1131 * finish unlinking the initial failed usb_set_address()
1132 * or device descriptor fetch.
1133 */
1134 if (!test_bit(HCD_FLAG_SAW_IRQ, &hcd->flags) &&
1135 !is_root_hub(urb->dev)) {
1136 dev_warn (hcd->self.controller, "Unlink after no-IRQ? "
1137 "Controller is probably using the wrong IRQ.\n");
1138 set_bit(HCD_FLAG_SAW_IRQ, &hcd->flags);
1139 }
1140
1141 urb->status = status;
1142
1143 spin_unlock(&hcd_urb_list_lock);
1144 spin_unlock_irqrestore (&urb->lock, flags);
1145
1146 retval = unlink1 (hcd, urb);
1147 if (retval == 0) 1246 if (retval == 0)
1148 retval = -EINPROGRESS; 1247 retval = -EINPROGRESS;
1149 return retval; 1248 else if (retval != -EIDRM && retval != -EBUSY)
1150 1249 dev_dbg(&urb->dev->dev, "hcd_unlink_urb %p fail %d\n",
1151done: 1250 urb, retval);
1152 spin_unlock(&hcd_urb_list_lock);
1153 spin_unlock_irqrestore (&urb->lock, flags);
1154 if (retval != -EIDRM && sys && sys->driver)
1155 dev_dbg (sys, "hcd_unlink_urb %p fail %d\n", urb, retval);
1156 return retval; 1251 return retval;
1157} 1252}
1158 1253
@@ -1162,6 +1257,7 @@ done:
1162 * usb_hcd_giveback_urb - return URB from HCD to device driver 1257 * usb_hcd_giveback_urb - return URB from HCD to device driver
1163 * @hcd: host controller returning the URB 1258 * @hcd: host controller returning the URB
1164 * @urb: urb being returned to the USB device driver. 1259 * @urb: urb being returned to the USB device driver.
1260 * @status: completion status code for the URB.
1165 * Context: in_interrupt() 1261 * Context: in_interrupt()
1166 * 1262 *
1167 * This hands the URB from HCD to its USB device driver, using its 1263 * This hands the URB from HCD to its USB device driver, using its
@@ -1169,14 +1265,27 @@ done:
1169 * (and is done using urb->hcpriv). It also released all HCD locks; 1265 * (and is done using urb->hcpriv). It also released all HCD locks;
1170 * the device driver won't cause problems if it frees, modifies, 1266 * the device driver won't cause problems if it frees, modifies,
1171 * or resubmits this URB. 1267 * or resubmits this URB.
1268 *
1269 * If @urb was unlinked, the value of @status will be overridden by
1270 * @urb->unlinked. Erroneous short transfers are detected in case
1271 * the HCD hasn't checked for them.
1172 */ 1272 */
1173void usb_hcd_giveback_urb (struct usb_hcd *hcd, struct urb *urb) 1273void usb_hcd_giveback_urb(struct usb_hcd *hcd, struct urb *urb, int status)
1174{ 1274{
1175 urb_unlink(hcd, urb); 1275 urb->hcpriv = NULL;
1176 usbmon_urb_complete (&hcd->self, urb); 1276 if (unlikely(urb->unlinked))
1277 status = urb->unlinked;
1278 else if (unlikely((urb->transfer_flags & URB_SHORT_NOT_OK) &&
1279 urb->actual_length < urb->transfer_buffer_length &&
1280 !status))
1281 status = -EREMOTEIO;
1282
1283 unmap_urb_for_dma(hcd, urb);
1284 usbmon_urb_complete(&hcd->self, urb, status);
1177 usb_unanchor_urb(urb); 1285 usb_unanchor_urb(urb);
1178 1286
1179 /* pass ownership to the completion handler */ 1287 /* pass ownership to the completion handler */
1288 urb->status = status;
1180 urb->complete (urb); 1289 urb->complete (urb);
1181 atomic_dec (&urb->use_count); 1290 atomic_dec (&urb->use_count);
1182 if (unlikely (urb->reject)) 1291 if (unlikely (urb->reject))
@@ -1187,78 +1296,61 @@ EXPORT_SYMBOL (usb_hcd_giveback_urb);
1187 1296
1188/*-------------------------------------------------------------------------*/ 1297/*-------------------------------------------------------------------------*/
1189 1298
1190/* disables the endpoint: cancels any pending urbs, then synchronizes with 1299/* Cancel all URBs pending on this endpoint and wait for the endpoint's
1191 * the hcd to make sure all endpoint state is gone from hardware, and then 1300 * queue to drain completely. The caller must first insure that no more
1192 * waits until the endpoint's queue is completely drained. use for 1301 * URBs can be submitted for this endpoint.
1193 * set_configuration, set_interface, driver removal, physical disconnect.
1194 *
1195 * example: a qh stored in ep->hcpriv, holding state related to endpoint
1196 * type, maxpacket size, toggle, halt status, and scheduling.
1197 */ 1302 */
1198void usb_hcd_endpoint_disable (struct usb_device *udev, 1303void usb_hcd_flush_endpoint(struct usb_device *udev,
1199 struct usb_host_endpoint *ep) 1304 struct usb_host_endpoint *ep)
1200{ 1305{
1201 struct usb_hcd *hcd; 1306 struct usb_hcd *hcd;
1202 struct urb *urb; 1307 struct urb *urb;
1203 1308
1309 if (!ep)
1310 return;
1311 might_sleep();
1204 hcd = bus_to_hcd(udev->bus); 1312 hcd = bus_to_hcd(udev->bus);
1205 local_irq_disable ();
1206 1313
1207 /* ep is already gone from udev->ep_{in,out}[]; no more submits */ 1314 /* No more submits can occur */
1208rescan: 1315rescan:
1209 spin_lock(&hcd_urb_list_lock); 1316 spin_lock_irq(&hcd_urb_list_lock);
1210 list_for_each_entry (urb, &ep->urb_list, urb_list) { 1317 list_for_each_entry (urb, &ep->urb_list, urb_list) {
1211 int tmp; 1318 int is_in;
1212 1319
1213 /* the urb may already have been unlinked */ 1320 if (urb->unlinked)
1214 if (urb->status != -EINPROGRESS)
1215 continue; 1321 continue;
1216 usb_get_urb (urb); 1322 usb_get_urb (urb);
1323 is_in = usb_urb_dir_in(urb);
1217 spin_unlock(&hcd_urb_list_lock); 1324 spin_unlock(&hcd_urb_list_lock);
1218 1325
1219 spin_lock (&urb->lock); 1326 /* kick hcd */
1220 tmp = urb->status; 1327 unlink1(hcd, urb, -ESHUTDOWN);
1221 if (tmp == -EINPROGRESS) 1328 dev_dbg (hcd->self.controller,
1222 urb->status = -ESHUTDOWN; 1329 "shutdown urb %p ep%d%s%s\n",
1223 spin_unlock (&urb->lock); 1330 urb, usb_endpoint_num(&ep->desc),
1224 1331 is_in ? "in" : "out",
1225 /* kick hcd unless it's already returning this */ 1332 ({ char *s;
1226 if (tmp == -EINPROGRESS) { 1333
1227 tmp = urb->pipe; 1334 switch (usb_endpoint_type(&ep->desc)) {
1228 unlink1 (hcd, urb); 1335 case USB_ENDPOINT_XFER_CONTROL:
1229 dev_dbg (hcd->self.controller, 1336 s = ""; break;
1230 "shutdown urb %p pipe %08x ep%d%s%s\n", 1337 case USB_ENDPOINT_XFER_BULK:
1231 urb, tmp, usb_pipeendpoint (tmp), 1338 s = "-bulk"; break;
1232 (tmp & USB_DIR_IN) ? "in" : "out", 1339 case USB_ENDPOINT_XFER_INT:
1233 ({ char *s; \ 1340 s = "-intr"; break;
1234 switch (usb_pipetype (tmp)) { \ 1341 default:
1235 case PIPE_CONTROL: s = ""; break; \ 1342 s = "-iso"; break;
1236 case PIPE_BULK: s = "-bulk"; break; \ 1343 };
1237 case PIPE_INTERRUPT: s = "-intr"; break; \ 1344 s;
1238 default: s = "-iso"; break; \ 1345 }));
1239 }; s;}));
1240 }
1241 usb_put_urb (urb); 1346 usb_put_urb (urb);
1242 1347
1243 /* list contents may have changed */ 1348 /* list contents may have changed */
1244 goto rescan; 1349 goto rescan;
1245 } 1350 }
1246 spin_unlock(&hcd_urb_list_lock); 1351 spin_unlock_irq(&hcd_urb_list_lock);
1247 local_irq_enable ();
1248
1249 /* synchronize with the hardware, so old configuration state
1250 * clears out immediately (and will be freed).
1251 */
1252 might_sleep ();
1253 if (hcd->driver->endpoint_disable)
1254 hcd->driver->endpoint_disable (hcd, ep);
1255 1352
1256 /* Wait until the endpoint queue is completely empty. Most HCDs 1353 /* Wait until the endpoint queue is completely empty */
1257 * will have done this already in their endpoint_disable method,
1258 * but some might not. And there could be root-hub control URBs
1259 * still pending since they aren't affected by the HCDs'
1260 * endpoint_disable methods.
1261 */
1262 while (!list_empty (&ep->urb_list)) { 1354 while (!list_empty (&ep->urb_list)) {
1263 spin_lock_irq(&hcd_urb_list_lock); 1355 spin_lock_irq(&hcd_urb_list_lock);
1264 1356
@@ -1278,6 +1370,25 @@ rescan:
1278 } 1370 }
1279} 1371}
1280 1372
1373/* Disables the endpoint: synchronizes with the hcd to make sure all
1374 * endpoint state is gone from hardware. usb_hcd_flush_endpoint() must
1375 * have been called previously. Use for set_configuration, set_interface,
1376 * driver removal, physical disconnect.
1377 *
1378 * example: a qh stored in ep->hcpriv, holding state related to endpoint
1379 * type, maxpacket size, toggle, halt status, and scheduling.
1380 */
1381void usb_hcd_disable_endpoint(struct usb_device *udev,
1382 struct usb_host_endpoint *ep)
1383{
1384 struct usb_hcd *hcd;
1385
1386 might_sleep();
1387 hcd = bus_to_hcd(udev->bus);
1388 if (hcd->driver->endpoint_disable)
1389 hcd->driver->endpoint_disable(hcd, ep);
1390}
1391
1281/*-------------------------------------------------------------------------*/ 1392/*-------------------------------------------------------------------------*/
1282 1393
1283/* called in any context */ 1394/* called in any context */
@@ -1525,7 +1636,6 @@ struct usb_hcd *usb_create_hcd (const struct hc_driver *driver,
1525 hcd->driver = driver; 1636 hcd->driver = driver;
1526 hcd->product_desc = (driver->product_desc) ? driver->product_desc : 1637 hcd->product_desc = (driver->product_desc) ? driver->product_desc :
1527 "USB Host Controller"; 1638 "USB Host Controller";
1528
1529 return hcd; 1639 return hcd;
1530} 1640}
1531EXPORT_SYMBOL (usb_create_hcd); 1641EXPORT_SYMBOL (usb_create_hcd);
@@ -1570,6 +1680,7 @@ int usb_add_hcd(struct usb_hcd *hcd,
1570 1680
1571 dev_info(hcd->self.controller, "%s\n", hcd->product_desc); 1681 dev_info(hcd->self.controller, "%s\n", hcd->product_desc);
1572 1682
1683 hcd->authorized_default = hcd->wireless? 0 : 1;
1573 set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags); 1684 set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
1574 1685
1575 /* HC is in reset state, but accessible. Now do the one-time init, 1686 /* HC is in reset state, but accessible. Now do the one-time init,
@@ -1646,10 +1757,20 @@ int usb_add_hcd(struct usb_hcd *hcd,
1646 if ((retval = register_root_hub(hcd)) != 0) 1757 if ((retval = register_root_hub(hcd)) != 0)
1647 goto err_register_root_hub; 1758 goto err_register_root_hub;
1648 1759
1760 retval = sysfs_create_group(&rhdev->dev.kobj, &usb_bus_attr_group);
1761 if (retval < 0) {
1762 printk(KERN_ERR "Cannot register USB bus sysfs attributes: %d\n",
1763 retval);
1764 goto error_create_attr_group;
1765 }
1649 if (hcd->uses_new_polling && hcd->poll_rh) 1766 if (hcd->uses_new_polling && hcd->poll_rh)
1650 usb_hcd_poll_rh_status(hcd); 1767 usb_hcd_poll_rh_status(hcd);
1651 return retval; 1768 return retval;
1652 1769
1770error_create_attr_group:
1771 mutex_lock(&usb_bus_list_lock);
1772 usb_disconnect(&hcd->self.root_hub);
1773 mutex_unlock(&usb_bus_list_lock);
1653err_register_root_hub: 1774err_register_root_hub:
1654 hcd->driver->stop(hcd); 1775 hcd->driver->stop(hcd);
1655err_hcd_driver_start: 1776err_hcd_driver_start:
@@ -1691,6 +1812,7 @@ void usb_remove_hcd(struct usb_hcd *hcd)
1691 cancel_work_sync(&hcd->wakeup_work); 1812 cancel_work_sync(&hcd->wakeup_work);
1692#endif 1813#endif
1693 1814
1815 sysfs_remove_group(&hcd->self.root_hub->dev.kobj, &usb_bus_attr_group);
1694 mutex_lock(&usb_bus_list_lock); 1816 mutex_lock(&usb_bus_list_lock);
1695 usb_disconnect(&hcd->self.root_hub); 1817 usb_disconnect(&hcd->self.root_hub);
1696 mutex_unlock(&usb_bus_list_lock); 1818 mutex_unlock(&usb_bus_list_lock);
diff --git a/drivers/usb/core/hcd.h b/drivers/usb/core/hcd.h
index b5ebb73c233..98e24194a4a 100644
--- a/drivers/usb/core/hcd.h
+++ b/drivers/usb/core/hcd.h
@@ -19,6 +19,8 @@
19 19
20#ifdef __KERNEL__ 20#ifdef __KERNEL__
21 21
22#include <linux/rwsem.h>
23
22/* This file contains declarations of usbcore internals that are mostly 24/* This file contains declarations of usbcore internals that are mostly
23 * used or exposed by Host Controller Drivers. 25 * used or exposed by Host Controller Drivers.
24 */ 26 */
@@ -51,6 +53,12 @@
51 * 53 *
52 * Since "struct usb_bus" is so thin, you can't share much code in it. 54 * Since "struct usb_bus" is so thin, you can't share much code in it.
53 * This framework is a layer over that, and should be more sharable. 55 * This framework is a layer over that, and should be more sharable.
56 *
57 * @authorized_default: Specifies if new devices are authorized to
58 * connect by default or they require explicit
59 * user space authorization; this bit is settable
60 * through /sys/class/usb_host/X/authorized_default.
61 * For the rest is RO, so we don't lock to r/w it.
54 */ 62 */
55 63
56/*-------------------------------------------------------------------------*/ 64/*-------------------------------------------------------------------------*/
@@ -90,6 +98,7 @@ struct usb_hcd {
90 unsigned poll_rh:1; /* poll for rh status? */ 98 unsigned poll_rh:1; /* poll for rh status? */
91 unsigned poll_pending:1; /* status has changed? */ 99 unsigned poll_pending:1; /* status has changed? */
92 unsigned wireless:1; /* Wireless USB HCD */ 100 unsigned wireless:1; /* Wireless USB HCD */
101 unsigned authorized_default:1;
93 102
94 int irq; /* irq allocated */ 103 int irq; /* irq allocated */
95 void __iomem *regs; /* device memory/io */ 104 void __iomem *regs; /* device memory/io */
@@ -182,11 +191,10 @@ struct hc_driver {
182 int (*get_frame_number) (struct usb_hcd *hcd); 191 int (*get_frame_number) (struct usb_hcd *hcd);
183 192
184 /* manage i/o requests, device state */ 193 /* manage i/o requests, device state */
185 int (*urb_enqueue) (struct usb_hcd *hcd, 194 int (*urb_enqueue)(struct usb_hcd *hcd,
186 struct usb_host_endpoint *ep, 195 struct urb *urb, gfp_t mem_flags);
187 struct urb *urb, 196 int (*urb_dequeue)(struct usb_hcd *hcd,
188 gfp_t mem_flags); 197 struct urb *urb, int status);
189 int (*urb_dequeue) (struct usb_hcd *hcd, struct urb *urb);
190 198
191 /* hw synch, freeing endpoint resources that urb_dequeue can't */ 199 /* hw synch, freeing endpoint resources that urb_dequeue can't */
192 void (*endpoint_disable)(struct usb_hcd *hcd, 200 void (*endpoint_disable)(struct usb_hcd *hcd,
@@ -204,10 +212,18 @@ struct hc_driver {
204 /* Needed only if port-change IRQs are level-triggered */ 212 /* Needed only if port-change IRQs are level-triggered */
205}; 213};
206 214
215extern int usb_hcd_link_urb_to_ep(struct usb_hcd *hcd, struct urb *urb);
216extern int usb_hcd_check_unlink_urb(struct usb_hcd *hcd, struct urb *urb,
217 int status);
218extern void usb_hcd_unlink_urb_from_ep(struct usb_hcd *hcd, struct urb *urb);
219
207extern int usb_hcd_submit_urb (struct urb *urb, gfp_t mem_flags); 220extern int usb_hcd_submit_urb (struct urb *urb, gfp_t mem_flags);
208extern int usb_hcd_unlink_urb (struct urb *urb, int status); 221extern int usb_hcd_unlink_urb (struct urb *urb, int status);
209extern void usb_hcd_giveback_urb (struct usb_hcd *hcd, struct urb *urb); 222extern void usb_hcd_giveback_urb(struct usb_hcd *hcd, struct urb *urb,
210extern void usb_hcd_endpoint_disable (struct usb_device *udev, 223 int status);
224extern void usb_hcd_flush_endpoint(struct usb_device *udev,
225 struct usb_host_endpoint *ep);
226extern void usb_hcd_disable_endpoint(struct usb_device *udev,
211 struct usb_host_endpoint *ep); 227 struct usb_host_endpoint *ep);
212extern int usb_hcd_get_frame_number (struct usb_device *udev); 228extern int usb_hcd_get_frame_number (struct usb_device *udev);
213 229
@@ -402,7 +418,7 @@ static inline void usbfs_cleanup(void) { }
402struct usb_mon_operations { 418struct usb_mon_operations {
403 void (*urb_submit)(struct usb_bus *bus, struct urb *urb); 419 void (*urb_submit)(struct usb_bus *bus, struct urb *urb);
404 void (*urb_submit_error)(struct usb_bus *bus, struct urb *urb, int err); 420 void (*urb_submit_error)(struct usb_bus *bus, struct urb *urb, int err);
405 void (*urb_complete)(struct usb_bus *bus, struct urb *urb); 421 void (*urb_complete)(struct usb_bus *bus, struct urb *urb, int status);
406 /* void (*urb_unlink)(struct usb_bus *bus, struct urb *urb); */ 422 /* void (*urb_unlink)(struct usb_bus *bus, struct urb *urb); */
407}; 423};
408 424
@@ -421,10 +437,11 @@ static inline void usbmon_urb_submit_error(struct usb_bus *bus, struct urb *urb,
421 (*mon_ops->urb_submit_error)(bus, urb, error); 437 (*mon_ops->urb_submit_error)(bus, urb, error);
422} 438}
423 439
424static inline void usbmon_urb_complete(struct usb_bus *bus, struct urb *urb) 440static inline void usbmon_urb_complete(struct usb_bus *bus, struct urb *urb,
441 int status)
425{ 442{
426 if (bus->monitored) 443 if (bus->monitored)
427 (*mon_ops->urb_complete)(bus, urb); 444 (*mon_ops->urb_complete)(bus, urb, status);
428} 445}
429 446
430int usb_mon_register(struct usb_mon_operations *ops); 447int usb_mon_register(struct usb_mon_operations *ops);
@@ -435,7 +452,8 @@ void usb_mon_deregister(void);
435static inline void usbmon_urb_submit(struct usb_bus *bus, struct urb *urb) {} 452static inline void usbmon_urb_submit(struct usb_bus *bus, struct urb *urb) {}
436static inline void usbmon_urb_submit_error(struct usb_bus *bus, struct urb *urb, 453static inline void usbmon_urb_submit_error(struct usb_bus *bus, struct urb *urb,
437 int error) {} 454 int error) {}
438static inline void usbmon_urb_complete(struct usb_bus *bus, struct urb *urb) {} 455static inline void usbmon_urb_complete(struct usb_bus *bus, struct urb *urb,
456 int status) {}
439 457
440#endif /* CONFIG_USB_MON */ 458#endif /* CONFIG_USB_MON */
441 459
@@ -454,5 +472,9 @@ static inline void usbmon_urb_complete(struct usb_bus *bus, struct urb *urb) {}
454 : (in_interrupt () ? "in_interrupt" : "can sleep")) 472 : (in_interrupt () ? "in_interrupt" : "can sleep"))
455 473
456 474
457#endif /* __KERNEL__ */ 475/* This rwsem is for use only by the hub driver and ehci-hcd.
476 * Nobody else should touch it.
477 */
478extern struct rw_semaphore ehci_cf_port_reset_rwsem;
458 479
480#endif /* __KERNEL__ */
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index f7b337feb3e..d20cb545a6e 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -125,6 +125,12 @@ MODULE_PARM_DESC(use_both_schemes,
125 "try the other device initialization scheme if the " 125 "try the other device initialization scheme if the "
126 "first one fails"); 126 "first one fails");
127 127
128/* Mutual exclusion for EHCI CF initialization. This interferes with
129 * port reset on some companion controllers.
130 */
131DECLARE_RWSEM(ehci_cf_port_reset_rwsem);
132EXPORT_SYMBOL_GPL(ehci_cf_port_reset_rwsem);
133
128 134
129static inline char *portspeed(int portstatus) 135static inline char *portspeed(int portstatus)
130{ 136{
@@ -347,11 +353,11 @@ void usb_kick_khubd(struct usb_device *hdev)
347static void hub_irq(struct urb *urb) 353static void hub_irq(struct urb *urb)
348{ 354{
349 struct usb_hub *hub = urb->context; 355 struct usb_hub *hub = urb->context;
350 int status; 356 int status = urb->status;
351 int i; 357 int i;
352 unsigned long bits; 358 unsigned long bits;
353 359
354 switch (urb->status) { 360 switch (status) {
355 case -ENOENT: /* synchronous unlink */ 361 case -ENOENT: /* synchronous unlink */
356 case -ECONNRESET: /* async unlink */ 362 case -ECONNRESET: /* async unlink */
357 case -ESHUTDOWN: /* hardware going away */ 363 case -ESHUTDOWN: /* hardware going away */
@@ -359,10 +365,10 @@ static void hub_irq(struct urb *urb)
359 365
360 default: /* presumably an error */ 366 default: /* presumably an error */
361 /* Cause a hub reset after 10 consecutive errors */ 367 /* Cause a hub reset after 10 consecutive errors */
362 dev_dbg (hub->intfdev, "transfer --> %d\n", urb->status); 368 dev_dbg (hub->intfdev, "transfer --> %d\n", status);
363 if ((++hub->nerrors < 10) || hub->error) 369 if ((++hub->nerrors < 10) || hub->error)
364 goto resubmit; 370 goto resubmit;
365 hub->error = urb->status; 371 hub->error = status;
366 /* FALL THROUGH */ 372 /* FALL THROUGH */
367 373
368 /* let khubd handle things */ 374 /* let khubd handle things */
@@ -1220,54 +1226,14 @@ static inline void show_string(struct usb_device *udev, char *id, char *string)
1220#endif 1226#endif
1221 1227
1222/** 1228/**
1223 * usb_new_device - perform initial device setup (usbcore-internal) 1229 * usb_configure_device_otg - FIXME (usbcore-internal)
1224 * @udev: newly addressed device (in ADDRESS state) 1230 * @udev: newly addressed device (in ADDRESS state)
1225 * 1231 *
1226 * This is called with devices which have been enumerated, but not yet 1232 * Do configuration for On-The-Go devices
1227 * configured. The device descriptor is available, but not descriptors
1228 * for any device configuration. The caller must have locked either
1229 * the parent hub (if udev is a normal device) or else the
1230 * usb_bus_list_lock (if udev is a root hub). The parent's pointer to
1231 * udev has already been installed, but udev is not yet visible through
1232 * sysfs or other filesystem code.
1233 *
1234 * It will return if the device is configured properly or not. Zero if
1235 * the interface was registered with the driver core; else a negative
1236 * errno value.
1237 *
1238 * This call is synchronous, and may not be used in an interrupt context.
1239 *
1240 * Only the hub driver or root-hub registrar should ever call this.
1241 */ 1233 */
1242int usb_new_device(struct usb_device *udev) 1234static int usb_configure_device_otg(struct usb_device *udev)
1243{ 1235{
1244 int err; 1236 int err = 0;
1245
1246 /* Determine quirks */
1247 usb_detect_quirks(udev);
1248
1249 err = usb_get_configuration(udev);
1250 if (err < 0) {
1251 dev_err(&udev->dev, "can't read configurations, error %d\n",
1252 err);
1253 goto fail;
1254 }
1255
1256 /* read the standard strings and cache them if present */
1257 udev->product = usb_cache_string(udev, udev->descriptor.iProduct);
1258 udev->manufacturer = usb_cache_string(udev,
1259 udev->descriptor.iManufacturer);
1260 udev->serial = usb_cache_string(udev, udev->descriptor.iSerialNumber);
1261
1262 /* Tell the world! */
1263 dev_dbg(&udev->dev, "new device strings: Mfr=%d, Product=%d, "
1264 "SerialNumber=%d\n",
1265 udev->descriptor.iManufacturer,
1266 udev->descriptor.iProduct,
1267 udev->descriptor.iSerialNumber);
1268 show_string(udev, "Product", udev->product);
1269 show_string(udev, "Manufacturer", udev->manufacturer);
1270 show_string(udev, "SerialNumber", udev->serial);
1271 1237
1272#ifdef CONFIG_USB_OTG 1238#ifdef CONFIG_USB_OTG
1273 /* 1239 /*
@@ -1329,8 +1295,82 @@ int usb_new_device(struct usb_device *udev)
1329 err = -ENOTSUPP; 1295 err = -ENOTSUPP;
1330 goto fail; 1296 goto fail;
1331 } 1297 }
1298fail:
1332#endif 1299#endif
1300 return err;
1301}
1302
1303
1304/**
1305 * usb_configure_device - Detect and probe device intfs/otg (usbcore-internal)
1306 * @udev: newly addressed device (in ADDRESS state)
1307 *
1308 * This is only called by usb_new_device() and usb_authorize_device()
1309 * and FIXME -- all comments that apply to them apply here wrt to
1310 * environment.
1311 *
1312 * If the device is WUSB and not authorized, we don't attempt to read
1313 * the string descriptors, as they will be errored out by the device
1314 * until it has been authorized.
1315 */
1316static int usb_configure_device(struct usb_device *udev)
1317{
1318 int err;
1333 1319
1320 if (udev->config == NULL) {
1321 err = usb_get_configuration(udev);
1322 if (err < 0) {
1323 dev_err(&udev->dev, "can't read configurations, error %d\n",
1324 err);
1325 goto fail;
1326 }
1327 }
1328 if (udev->wusb == 1 && udev->authorized == 0) {
1329 udev->product = kstrdup("n/a (unauthorized)", GFP_KERNEL);
1330 udev->manufacturer = kstrdup("n/a (unauthorized)", GFP_KERNEL);
1331 udev->serial = kstrdup("n/a (unauthorized)", GFP_KERNEL);
1332 }
1333 else {
1334 /* read the standard strings and cache them if present */
1335 udev->product = usb_cache_string(udev, udev->descriptor.iProduct);
1336 udev->manufacturer = usb_cache_string(udev,
1337 udev->descriptor.iManufacturer);
1338 udev->serial = usb_cache_string(udev, udev->descriptor.iSerialNumber);
1339 }
1340 err = usb_configure_device_otg(udev);
1341fail:
1342 return err;
1343}
1344
1345
1346/**
1347 * usb_new_device - perform initial device setup (usbcore-internal)
1348 * @udev: newly addressed device (in ADDRESS state)
1349 *
1350 * This is called with devices which have been enumerated, but not yet
1351 * configured. The device descriptor is available, but not descriptors
1352 * for any device configuration. The caller must have locked either
1353 * the parent hub (if udev is a normal device) or else the
1354 * usb_bus_list_lock (if udev is a root hub). The parent's pointer to
1355 * udev has already been installed, but udev is not yet visible through
1356 * sysfs or other filesystem code.
1357 *
1358 * It will return if the device is configured properly or not. Zero if
1359 * the interface was registered with the driver core; else a negative
1360 * errno value.
1361 *
1362 * This call is synchronous, and may not be used in an interrupt context.
1363 *
1364 * Only the hub driver or root-hub registrar should ever call this.
1365 */
1366int usb_new_device(struct usb_device *udev)
1367{
1368 int err;
1369
1370 usb_detect_quirks(udev); /* Determine quirks */
1371 err = usb_configure_device(udev); /* detect & probe dev/intfs */
1372 if (err < 0)
1373 goto fail;
1334 /* export the usbdev device-node for libusb */ 1374 /* export the usbdev device-node for libusb */
1335 udev->dev.devt = MKDEV(USB_DEVICE_MAJOR, 1375 udev->dev.devt = MKDEV(USB_DEVICE_MAJOR,
1336 (((udev->bus->busnum-1) * 128) + (udev->devnum-1))); 1376 (((udev->bus->busnum-1) * 128) + (udev->devnum-1)));
@@ -1346,19 +1386,106 @@ int usb_new_device(struct usb_device *udev)
1346 err = device_add(&udev->dev); 1386 err = device_add(&udev->dev);
1347 if (err) { 1387 if (err) {
1348 dev_err(&udev->dev, "can't device_add, error %d\n", err); 1388 dev_err(&udev->dev, "can't device_add, error %d\n", err);
1349 if (udev->parent)
1350 usb_autosuspend_device(udev->parent);
1351 goto fail; 1389 goto fail;
1352 } 1390 }
1353 1391
1354exit: 1392 /* Tell the world! */
1393 dev_dbg(&udev->dev, "new device strings: Mfr=%d, Product=%d, "
1394 "SerialNumber=%d\n",
1395 udev->descriptor.iManufacturer,
1396 udev->descriptor.iProduct,
1397 udev->descriptor.iSerialNumber);
1398 show_string(udev, "Product", udev->product);
1399 show_string(udev, "Manufacturer", udev->manufacturer);
1400 show_string(udev, "SerialNumber", udev->serial);
1355 return err; 1401 return err;
1356 1402
1357fail: 1403fail:
1358 usb_set_device_state(udev, USB_STATE_NOTATTACHED); 1404 usb_set_device_state(udev, USB_STATE_NOTATTACHED);
1359 goto exit; 1405 return err;
1360} 1406}
1361 1407
1408
1409/**
1410 * Similar to usb_disconnect()
1411 *
1412 * We share a lock (that we have) with device_del(), so we need to
1413 * defer its call.
1414 */
1415int usb_deauthorize_device(struct usb_device *usb_dev)
1416{
1417 unsigned cnt;
1418 usb_lock_device(usb_dev);
1419 if (usb_dev->authorized == 0)
1420 goto out_unauthorized;
1421 usb_dev->authorized = 0;
1422 usb_set_configuration(usb_dev, -1);
1423 usb_dev->product = kstrdup("n/a (unauthorized)", GFP_KERNEL);
1424 usb_dev->manufacturer = kstrdup("n/a (unauthorized)", GFP_KERNEL);
1425 usb_dev->serial = kstrdup("n/a (unauthorized)", GFP_KERNEL);
1426 kfree(usb_dev->config);
1427 usb_dev->config = NULL;
1428 for (cnt = 0; cnt < usb_dev->descriptor.bNumConfigurations; cnt++)
1429 kfree(usb_dev->rawdescriptors[cnt]);
1430 usb_dev->descriptor.bNumConfigurations = 0;
1431 kfree(usb_dev->rawdescriptors);
1432out_unauthorized:
1433 usb_unlock_device(usb_dev);
1434 return 0;
1435}
1436
1437
1438int usb_authorize_device(struct usb_device *usb_dev)
1439{
1440 int result = 0, c;
1441 usb_lock_device(usb_dev);
1442 if (usb_dev->authorized == 1)
1443 goto out_authorized;
1444 kfree(usb_dev->product);
1445 usb_dev->product = NULL;
1446 kfree(usb_dev->manufacturer);
1447 usb_dev->manufacturer = NULL;
1448 kfree(usb_dev->serial);
1449 usb_dev->serial = NULL;
1450 result = usb_autoresume_device(usb_dev);
1451 if (result < 0) {
1452 dev_err(&usb_dev->dev,
1453 "can't autoresume for authorization: %d\n", result);
1454 goto error_autoresume;
1455 }
1456 result = usb_get_device_descriptor(usb_dev, sizeof(usb_dev->descriptor));
1457 if (result < 0) {
1458 dev_err(&usb_dev->dev, "can't re-read device descriptor for "
1459 "authorization: %d\n", result);
1460 goto error_device_descriptor;
1461 }
1462 usb_dev->authorized = 1;
1463 result = usb_configure_device(usb_dev);
1464 if (result < 0)
1465 goto error_configure;
1466 /* Choose and set the configuration. This registers the interfaces
1467 * with the driver core and lets interface drivers bind to them.
1468 */
1469 c = usb_choose_configuration(usb_dev);
1470 if (c >= 0) {
1471 result = usb_set_configuration(usb_dev, c);
1472 if (result) {
1473 dev_err(&usb_dev->dev,
1474 "can't set config #%d, error %d\n", c, result);
1475 /* This need not be fatal. The user can try to
1476 * set other configurations. */
1477 }
1478 }
1479 dev_info(&usb_dev->dev, "authorized to connect\n");
1480error_configure:
1481error_device_descriptor:
1482error_autoresume:
1483out_authorized:
1484 usb_unlock_device(usb_dev); // complements locktree
1485 return result;
1486}
1487
1488
1362static int hub_port_status(struct usb_hub *hub, int port1, 1489static int hub_port_status(struct usb_hub *hub, int port1,
1363 u16 *status, u16 *change) 1490 u16 *status, u16 *change)
1364{ 1491{
@@ -1460,6 +1587,11 @@ static int hub_port_reset(struct usb_hub *hub, int port1,
1460{ 1587{
1461 int i, status; 1588 int i, status;
1462 1589
1590 /* Block EHCI CF initialization during the port reset.
1591 * Some companion controllers don't like it when they mix.
1592 */
1593 down_read(&ehci_cf_port_reset_rwsem);
1594
1463 /* Reset the port */ 1595 /* Reset the port */
1464 for (i = 0; i < PORT_RESET_TRIES; i++) { 1596 for (i = 0; i < PORT_RESET_TRIES; i++) {
1465 status = set_port_feature(hub->hdev, 1597 status = set_port_feature(hub->hdev,
@@ -1481,6 +1613,7 @@ static int hub_port_reset(struct usb_hub *hub, int port1,
1481 case 0: 1613 case 0:
1482 /* TRSTRCY = 10 ms; plus some extra */ 1614 /* TRSTRCY = 10 ms; plus some extra */
1483 msleep(10 + 40); 1615 msleep(10 + 40);
1616 udev->devnum = 0; /* Device now at address 0 */
1484 /* FALL THROUGH */ 1617 /* FALL THROUGH */
1485 case -ENOTCONN: 1618 case -ENOTCONN:
1486 case -ENODEV: 1619 case -ENODEV:
@@ -1490,7 +1623,7 @@ static int hub_port_reset(struct usb_hub *hub, int port1,
1490 usb_set_device_state(udev, status 1623 usb_set_device_state(udev, status
1491 ? USB_STATE_NOTATTACHED 1624 ? USB_STATE_NOTATTACHED
1492 : USB_STATE_DEFAULT); 1625 : USB_STATE_DEFAULT);
1493 return status; 1626 goto done;
1494 } 1627 }
1495 1628
1496 dev_dbg (hub->intfdev, 1629 dev_dbg (hub->intfdev,
@@ -1503,6 +1636,8 @@ static int hub_port_reset(struct usb_hub *hub, int port1,
1503 "Cannot enable port %i. Maybe the USB cable is bad?\n", 1636 "Cannot enable port %i. Maybe the USB cable is bad?\n",
1504 port1); 1637 port1);
1505 1638
1639 done:
1640 up_read(&ehci_cf_port_reset_rwsem);
1506 return status; 1641 return status;
1507} 1642}
1508 1643
@@ -1833,14 +1968,7 @@ static int hub_suspend(struct usb_interface *intf, pm_message_t msg)
1833 struct usb_device *udev; 1968 struct usb_device *udev;
1834 1969
1835 udev = hdev->children [port1-1]; 1970 udev = hdev->children [port1-1];
1836 if (udev && msg.event == PM_EVENT_SUSPEND && 1971 if (udev && udev->can_submit) {
1837#ifdef CONFIG_USB_SUSPEND
1838 udev->state != USB_STATE_SUSPENDED
1839#else
1840 udev->dev.power.power_state.event
1841 == PM_EVENT_ON
1842#endif
1843 ) {
1844 if (!hdev->auto_pm) 1972 if (!hdev->auto_pm)
1845 dev_dbg(&intf->dev, "port %d nyet suspended\n", 1973 dev_dbg(&intf->dev, "port %d nyet suspended\n",
1846 port1); 1974 port1);
@@ -1999,26 +2127,27 @@ static void ep0_reinit(struct usb_device *udev)
1999{ 2127{
2000 usb_disable_endpoint(udev, 0 + USB_DIR_IN); 2128 usb_disable_endpoint(udev, 0 + USB_DIR_IN);
2001 usb_disable_endpoint(udev, 0 + USB_DIR_OUT); 2129 usb_disable_endpoint(udev, 0 + USB_DIR_OUT);
2002 udev->ep_in[0] = udev->ep_out[0] = &udev->ep0; 2130 usb_enable_endpoint(udev, &udev->ep0);
2003} 2131}
2004 2132
2005#define usb_sndaddr0pipe() (PIPE_CONTROL << 30) 2133#define usb_sndaddr0pipe() (PIPE_CONTROL << 30)
2006#define usb_rcvaddr0pipe() ((PIPE_CONTROL << 30) | USB_DIR_IN) 2134#define usb_rcvaddr0pipe() ((PIPE_CONTROL << 30) | USB_DIR_IN)
2007 2135
2008static int hub_set_address(struct usb_device *udev) 2136static int hub_set_address(struct usb_device *udev, int devnum)
2009{ 2137{
2010 int retval; 2138 int retval;
2011 2139
2012 if (udev->devnum == 0) 2140 if (devnum <= 1)
2013 return -EINVAL; 2141 return -EINVAL;
2014 if (udev->state == USB_STATE_ADDRESS) 2142 if (udev->state == USB_STATE_ADDRESS)
2015 return 0; 2143 return 0;
2016 if (udev->state != USB_STATE_DEFAULT) 2144 if (udev->state != USB_STATE_DEFAULT)
2017 return -EINVAL; 2145 return -EINVAL;
2018 retval = usb_control_msg(udev, usb_sndaddr0pipe(), 2146 retval = usb_control_msg(udev, usb_sndaddr0pipe(),
2019 USB_REQ_SET_ADDRESS, 0, udev->devnum, 0, 2147 USB_REQ_SET_ADDRESS, 0, devnum, 0,
2020 NULL, 0, USB_CTRL_SET_TIMEOUT); 2148 NULL, 0, USB_CTRL_SET_TIMEOUT);
2021 if (retval == 0) { 2149 if (retval == 0) {
2150 udev->devnum = devnum; /* Device now using proper address */
2022 usb_set_device_state(udev, USB_STATE_ADDRESS); 2151 usb_set_device_state(udev, USB_STATE_ADDRESS);
2023 ep0_reinit(udev); 2152 ep0_reinit(udev);
2024 } 2153 }
@@ -2045,6 +2174,7 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
2045 unsigned delay = HUB_SHORT_RESET_TIME; 2174 unsigned delay = HUB_SHORT_RESET_TIME;
2046 enum usb_device_speed oldspeed = udev->speed; 2175 enum usb_device_speed oldspeed = udev->speed;
2047 char *speed, *type; 2176 char *speed, *type;
2177 int devnum = udev->devnum;
2048 2178
2049 /* root hub ports have a slightly longer reset period 2179 /* root hub ports have a slightly longer reset period
2050 * (from USB 2.0 spec, section 7.1.7.5) 2180 * (from USB 2.0 spec, section 7.1.7.5)
@@ -2074,7 +2204,7 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
2074 goto fail; 2204 goto fail;
2075 } 2205 }
2076 oldspeed = udev->speed; 2206 oldspeed = udev->speed;
2077 2207
2078 /* USB 2.0 section 5.5.3 talks about ep0 maxpacket ... 2208 /* USB 2.0 section 5.5.3 talks about ep0 maxpacket ...
2079 * it's fixed size except for full speed devices. 2209 * it's fixed size except for full speed devices.
2080 * For Wireless USB devices, ep0 max packet is always 512 (tho 2210 * For Wireless USB devices, ep0 max packet is always 512 (tho
@@ -2115,7 +2245,7 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
2115 dev_info (&udev->dev, 2245 dev_info (&udev->dev,
2116 "%s %s speed %sUSB device using %s and address %d\n", 2246 "%s %s speed %sUSB device using %s and address %d\n",
2117 (udev->config) ? "reset" : "new", speed, type, 2247 (udev->config) ? "reset" : "new", speed, type,
2118 udev->bus->controller->driver->name, udev->devnum); 2248 udev->bus->controller->driver->name, devnum);
2119 2249
2120 /* Set up TT records, if needed */ 2250 /* Set up TT records, if needed */
2121 if (hdev->tt) { 2251 if (hdev->tt) {
@@ -2202,7 +2332,7 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
2202 } 2332 }
2203 2333
2204 for (j = 0; j < SET_ADDRESS_TRIES; ++j) { 2334 for (j = 0; j < SET_ADDRESS_TRIES; ++j) {
2205 retval = hub_set_address(udev); 2335 retval = hub_set_address(udev, devnum);
2206 if (retval >= 0) 2336 if (retval >= 0)
2207 break; 2337 break;
2208 msleep(200); 2338 msleep(200);
@@ -2210,7 +2340,7 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
2210 if (retval < 0) { 2340 if (retval < 0) {
2211 dev_err(&udev->dev, 2341 dev_err(&udev->dev,
2212 "device not accepting address %d, error %d\n", 2342 "device not accepting address %d, error %d\n",
2213 udev->devnum, retval); 2343 devnum, retval);
2214 goto fail; 2344 goto fail;
2215 } 2345 }
2216 2346
@@ -2263,8 +2393,10 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
2263 retval = 0; 2393 retval = 0;
2264 2394
2265fail: 2395fail:
2266 if (retval) 2396 if (retval) {
2267 hub_port_disable(hub, port1, 0); 2397 hub_port_disable(hub, port1, 0);
2398 udev->devnum = devnum; /* for disconnect processing */
2399 }
2268 mutex_unlock(&usb_address0_mutex); 2400 mutex_unlock(&usb_address0_mutex);
2269 return retval; 2401 return retval;
2270} 2402}
@@ -2699,9 +2831,9 @@ static void hub_events(void)
2699 clear_hub_feature(hdev, C_HUB_LOCAL_POWER); 2831 clear_hub_feature(hdev, C_HUB_LOCAL_POWER);
2700 if (hubstatus & HUB_STATUS_LOCAL_POWER) 2832 if (hubstatus & HUB_STATUS_LOCAL_POWER)
2701 /* FIXME: Is this always true? */ 2833 /* FIXME: Is this always true? */
2702 hub->limited_power = 0;
2703 else
2704 hub->limited_power = 1; 2834 hub->limited_power = 1;
2835 else
2836 hub->limited_power = 0;
2705 } 2837 }
2706 if (hubchange & HUB_CHANGE_OVERCURRENT) { 2838 if (hubchange & HUB_CHANGE_OVERCURRENT) {
2707 dev_dbg (hub_dev, "overcurrent change\n"); 2839 dev_dbg (hub_dev, "overcurrent change\n");
diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c
index d8f7b089a8f..98fcddba690 100644
--- a/drivers/usb/core/message.c
+++ b/drivers/usb/core/message.c
@@ -59,8 +59,8 @@ static int usb_start_wait_urb(struct urb *urb, int timeout, int *actual_length)
59 dev_dbg(&urb->dev->dev, 59 dev_dbg(&urb->dev->dev,
60 "%s timed out on ep%d%s len=%d/%d\n", 60 "%s timed out on ep%d%s len=%d/%d\n",
61 current->comm, 61 current->comm,
62 usb_pipeendpoint(urb->pipe), 62 usb_endpoint_num(&urb->ep->desc),
63 usb_pipein(urb->pipe) ? "in" : "out", 63 usb_urb_dir_in(urb) ? "in" : "out",
64 urb->actual_length, 64 urb->actual_length,
65 urb->transfer_buffer_length); 65 urb->transfer_buffer_length);
66 } else 66 } else
@@ -250,7 +250,8 @@ static void sg_clean (struct usb_sg_request *io)
250 io->urbs = NULL; 250 io->urbs = NULL;
251 } 251 }
252 if (io->dev->dev.dma_mask != NULL) 252 if (io->dev->dev.dma_mask != NULL)
253 usb_buffer_unmap_sg (io->dev, io->pipe, io->sg, io->nents); 253 usb_buffer_unmap_sg (io->dev, usb_pipein(io->pipe),
254 io->sg, io->nents);
254 io->dev = NULL; 255 io->dev = NULL;
255} 256}
256 257
@@ -278,8 +279,8 @@ static void sg_complete (struct urb *urb)
278 dev_err (io->dev->bus->controller, 279 dev_err (io->dev->bus->controller,
279 "dev %s ep%d%s scatterlist error %d/%d\n", 280 "dev %s ep%d%s scatterlist error %d/%d\n",
280 io->dev->devpath, 281 io->dev->devpath,
281 usb_pipeendpoint (urb->pipe), 282 usb_endpoint_num(&urb->ep->desc),
282 usb_pipein (urb->pipe) ? "in" : "out", 283 usb_urb_dir_in(urb) ? "in" : "out",
283 status, io->status); 284 status, io->status);
284 // BUG (); 285 // BUG ();
285 } 286 }
@@ -379,7 +380,8 @@ int usb_sg_init (
379 */ 380 */
380 dma = (dev->dev.dma_mask != NULL); 381 dma = (dev->dev.dma_mask != NULL);
381 if (dma) 382 if (dma)
382 io->entries = usb_buffer_map_sg (dev, pipe, sg, nents); 383 io->entries = usb_buffer_map_sg(dev, usb_pipein(pipe),
384 sg, nents);
383 else 385 else
384 io->entries = nents; 386 io->entries = nents;
385 387
@@ -1013,8 +1015,11 @@ void usb_disable_endpoint(struct usb_device *dev, unsigned int epaddr)
1013 ep = dev->ep_in[epnum]; 1015 ep = dev->ep_in[epnum];
1014 dev->ep_in[epnum] = NULL; 1016 dev->ep_in[epnum] = NULL;
1015 } 1017 }
1016 if (ep && dev->bus) 1018 if (ep) {
1017 usb_hcd_endpoint_disable(dev, ep); 1019 ep->enabled = 0;
1020 usb_hcd_flush_endpoint(dev, ep);
1021 usb_hcd_disable_endpoint(dev, ep);
1022 }
1018} 1023}
1019 1024
1020/** 1025/**
@@ -1096,23 +1101,21 @@ void usb_disable_device(struct usb_device *dev, int skip_ep0)
1096 * Resets the endpoint toggle, and sets dev->ep_{in,out} pointers. 1101 * Resets the endpoint toggle, and sets dev->ep_{in,out} pointers.
1097 * For control endpoints, both the input and output sides are handled. 1102 * For control endpoints, both the input and output sides are handled.
1098 */ 1103 */
1099static void 1104void usb_enable_endpoint(struct usb_device *dev, struct usb_host_endpoint *ep)
1100usb_enable_endpoint(struct usb_device *dev, struct usb_host_endpoint *ep)
1101{ 1105{
1102 unsigned int epaddr = ep->desc.bEndpointAddress; 1106 int epnum = usb_endpoint_num(&ep->desc);
1103 unsigned int epnum = epaddr & USB_ENDPOINT_NUMBER_MASK; 1107 int is_out = usb_endpoint_dir_out(&ep->desc);
1104 int is_control; 1108 int is_control = usb_endpoint_xfer_control(&ep->desc);
1105 1109
1106 is_control = ((ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) 1110 if (is_out || is_control) {
1107 == USB_ENDPOINT_XFER_CONTROL);
1108 if (usb_endpoint_out(epaddr) || is_control) {
1109 usb_settoggle(dev, epnum, 1, 0); 1111 usb_settoggle(dev, epnum, 1, 0);
1110 dev->ep_out[epnum] = ep; 1112 dev->ep_out[epnum] = ep;
1111 } 1113 }
1112 if (!usb_endpoint_out(epaddr) || is_control) { 1114 if (!is_out || is_control) {
1113 usb_settoggle(dev, epnum, 0, 0); 1115 usb_settoggle(dev, epnum, 0, 0);
1114 dev->ep_in[epnum] = ep; 1116 dev->ep_in[epnum] = ep;
1115 } 1117 }
1118 ep->enabled = 1;
1116} 1119}
1117 1120
1118/* 1121/*
@@ -1171,6 +1174,7 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate)
1171 struct usb_host_interface *alt; 1174 struct usb_host_interface *alt;
1172 int ret; 1175 int ret;
1173 int manual = 0; 1176 int manual = 0;
1177 int changed;
1174 1178
1175 if (dev->state == USB_STATE_SUSPENDED) 1179 if (dev->state == USB_STATE_SUSPENDED)
1176 return -EHOSTUNREACH; 1180 return -EHOSTUNREACH;
@@ -1210,7 +1214,8 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate)
1210 */ 1214 */
1211 1215
1212 /* prevent submissions using previous endpoint settings */ 1216 /* prevent submissions using previous endpoint settings */
1213 if (device_is_registered(&iface->dev)) 1217 changed = (iface->cur_altsetting != alt);
1218 if (changed && device_is_registered(&iface->dev))
1214 usb_remove_sysfs_intf_files(iface); 1219 usb_remove_sysfs_intf_files(iface);
1215 usb_disable_interface(dev, iface); 1220 usb_disable_interface(dev, iface);
1216 1221
@@ -1247,7 +1252,7 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate)
1247 * (Likewise, EP0 never "halts" on well designed devices.) 1252 * (Likewise, EP0 never "halts" on well designed devices.)
1248 */ 1253 */
1249 usb_enable_interface(dev, iface); 1254 usb_enable_interface(dev, iface);
1250 if (device_is_registered(&iface->dev)) 1255 if (changed && device_is_registered(&iface->dev))
1251 usb_create_sysfs_intf_files(iface); 1256 usb_create_sysfs_intf_files(iface);
1252 1257
1253 return 0; 1258 return 0;
@@ -1328,7 +1333,7 @@ int usb_reset_configuration(struct usb_device *dev)
1328 return 0; 1333 return 0;
1329} 1334}
1330 1335
1331void usb_release_interface(struct device *dev) 1336static void usb_release_interface(struct device *dev)
1332{ 1337{
1333 struct usb_interface *intf = to_usb_interface(dev); 1338 struct usb_interface *intf = to_usb_interface(dev);
1334 struct usb_interface_cache *intfc = 1339 struct usb_interface_cache *intfc =
@@ -1481,6 +1486,9 @@ static struct usb_interface_assoc_descriptor *find_iad(struct usb_device *dev,
1481 * channels are available independently; and choosing between open 1486 * channels are available independently; and choosing between open
1482 * standard device protocols (like CDC) or proprietary ones. 1487 * standard device protocols (like CDC) or proprietary ones.
1483 * 1488 *
1489 * Note that a non-authorized device (dev->authorized == 0) will only
1490 * be put in unconfigured mode.
1491 *
1484 * Note that USB has an additional level of device configurability, 1492 * Note that USB has an additional level of device configurability,
1485 * associated with interfaces. That configurability is accessed using 1493 * associated with interfaces. That configurability is accessed using
1486 * usb_set_interface(). 1494 * usb_set_interface().
@@ -1502,7 +1510,7 @@ int usb_set_configuration(struct usb_device *dev, int configuration)
1502 struct usb_interface **new_interfaces = NULL; 1510 struct usb_interface **new_interfaces = NULL;
1503 int n, nintf; 1511 int n, nintf;
1504 1512
1505 if (configuration == -1) 1513 if (dev->authorized == 0 || configuration == -1)
1506 configuration = 0; 1514 configuration = 0;
1507 else { 1515 else {
1508 for (i = 0; i < dev->descriptor.bNumConfigurations; i++) { 1516 for (i = 0; i < dev->descriptor.bNumConfigurations; i++) {
diff --git a/drivers/usb/core/quirks.c b/drivers/usb/core/quirks.c
index ebf3dc20110..d42c561c75f 100644
--- a/drivers/usb/core/quirks.c
+++ b/drivers/usb/core/quirks.c
@@ -32,52 +32,6 @@ static const struct usb_device_id usb_quirk_list[] = {
32 { USB_DEVICE(0x0204, 0x6025), .driver_info = USB_QUIRK_RESET_RESUME }, 32 { USB_DEVICE(0x0204, 0x6025), .driver_info = USB_QUIRK_RESET_RESUME },
33 /* HP 5300/5370C scanner */ 33 /* HP 5300/5370C scanner */
34 { USB_DEVICE(0x03f0, 0x0701), .driver_info = USB_QUIRK_STRING_FETCH_255 }, 34 { USB_DEVICE(0x03f0, 0x0701), .driver_info = USB_QUIRK_STRING_FETCH_255 },
35 /* Hewlett-Packard PhotoSmart 720 / PhotoSmart 935 (storage) */
36 { USB_DEVICE(0x03f0, 0x4002), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
37
38 /* SGS Thomson Microelectronics 4in1 card reader */
39 { USB_DEVICE(0x0483, 0x0321), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
40
41 /* Acer Peripherals Inc. (now BenQ Corp.) Prisa 640BU */
42 { USB_DEVICE(0x04a5, 0x207e), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
43 /* Benq S2W 3300U */
44 { USB_DEVICE(0x04a5, 0x20b0), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
45 /* Canon, Inc. CanoScan N1240U/LiDE30 */
46 { USB_DEVICE(0x04a9, 0x220e), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
47 /* Canon, Inc. CanoScan N650U/N656U */
48 { USB_DEVICE(0x04a9, 0x2206), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
49 /* Canon, Inc. CanoScan 1220U */
50 { USB_DEVICE(0x04a9, 0x2207), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
51 /* Canon, Inc. CanoScan N670U/N676U/LiDE 20 */
52 { USB_DEVICE(0x04a9, 0x220d), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
53 /* old Cannon scanner */
54 { USB_DEVICE(0x04a9, 0x2220), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
55 /* Seiko Epson Corp. Perfection 1200 */
56 { USB_DEVICE(0x04b8, 0x0104), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
57 /* Seiko Epson Corp. Perfection 660 */
58 { USB_DEVICE(0x04b8, 0x0114), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
59 /* Epson Perfection 1260 Photo */
60 { USB_DEVICE(0x04b8, 0x011d), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
61 /* Seiko Epson Corp - Perfection 1670 */
62 { USB_DEVICE(0x04b8, 0x011f), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
63 /* EPSON Perfection 2480 */
64 { USB_DEVICE(0x04b8, 0x0121), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
65 /* Seiko Epson Corp.*/
66 { USB_DEVICE(0x04b8, 0x0122), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
67 /* Samsung ML-2010 printer */
68 { USB_DEVICE(0x04e8, 0x326c), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
69 /* Samsung ML-2510 Series printer */
70 { USB_DEVICE(0x04e8, 0x327e), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
71 /* Elsa MicroLink 56k (V.250) */
72 { USB_DEVICE(0x05cc, 0x2267), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
73 /* Ultima Electronics Corp.*/
74 { USB_DEVICE(0x05d8, 0x4005), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
75
76 /* Genesys USB-to-IDE */
77 { USB_DEVICE(0x0503, 0x0702), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
78
79 /* USB Graphical LCD - EEH Datalink GmbH */
80 { USB_DEVICE(0x060c, 0x04eb), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
81 35
82 /* INTEL VALUE SSD */ 36 /* INTEL VALUE SSD */
83 { USB_DEVICE(0x8086, 0xf1a5), .driver_info = USB_QUIRK_RESET_RESUME }, 37 { USB_DEVICE(0x8086, 0xf1a5), .driver_info = USB_QUIRK_RESET_RESUME },
@@ -85,44 +39,15 @@ static const struct usb_device_id usb_quirk_list[] = {
85 /* M-Systems Flash Disk Pioneers */ 39 /* M-Systems Flash Disk Pioneers */
86 { USB_DEVICE(0x08ec, 0x1000), .driver_info = USB_QUIRK_RESET_RESUME }, 40 { USB_DEVICE(0x08ec, 0x1000), .driver_info = USB_QUIRK_RESET_RESUME },
87 41
88 /* Agfa Snapscan1212u */
89 { USB_DEVICE(0x06bd, 0x2061), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
90 /* Seagate RSS LLC */
91 { USB_DEVICE(0x0bc2, 0x3000), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
92 /* Umax [hex] Astra 3400U */
93 { USB_DEVICE(0x1606, 0x0060), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
94
95 /* Philips PSC805 audio device */ 42 /* Philips PSC805 audio device */
96 { USB_DEVICE(0x0471, 0x0155), .driver_info = USB_QUIRK_RESET_RESUME }, 43 { USB_DEVICE(0x0471, 0x0155), .driver_info = USB_QUIRK_RESET_RESUME },
97 44
98 /* Alcor multi-card reader */
99 { USB_DEVICE(0x058f, 0x6366), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
100
101 /* Canon EOS 5D in PC Connection mode */
102 { USB_DEVICE(0x04a9, 0x3101), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
103
104 /* RIM Blackberry */
105 { USB_DEVICE(0x0fca, 0x0001), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
106 { USB_DEVICE(0x0fca, 0x0004), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
107 { USB_DEVICE(0x0fca, 0x0006), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
108
109 /* Apple iPhone */
110 { USB_DEVICE(0x05ac, 0x1290), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
111
112 /* SKYMEDI USB_DRIVE */ 45 /* SKYMEDI USB_DRIVE */
113 { USB_DEVICE(0x1516, 0x8628), .driver_info = USB_QUIRK_RESET_RESUME }, 46 { USB_DEVICE(0x1516, 0x8628), .driver_info = USB_QUIRK_RESET_RESUME },
114 47
115 { } /* terminating entry must be last */ 48 { } /* terminating entry must be last */
116}; 49};
117 50
118static void usb_autosuspend_quirk(struct usb_device *udev)
119{
120#ifdef CONFIG_USB_SUSPEND
121 /* disable autosuspend, but allow the user to re-enable it via sysfs */
122 udev->autosuspend_disabled = 1;
123#endif
124}
125
126static const struct usb_device_id *find_id(struct usb_device *udev) 51static const struct usb_device_id *find_id(struct usb_device *udev)
127{ 52{
128 const struct usb_device_id *id = usb_quirk_list; 53 const struct usb_device_id *id = usb_quirk_list;
@@ -149,13 +74,9 @@ void usb_detect_quirks(struct usb_device *udev)
149 dev_dbg(&udev->dev, "USB quirks for this device: %x\n", 74 dev_dbg(&udev->dev, "USB quirks for this device: %x\n",
150 udev->quirks); 75 udev->quirks);
151 76
152 /* do any special quirk handling here if needed */
153 if (udev->quirks & USB_QUIRK_NO_AUTOSUSPEND)
154 usb_autosuspend_quirk(udev);
155
156 /* By default, disable autosuspend for all non-hubs */ 77 /* By default, disable autosuspend for all non-hubs */
157#ifdef CONFIG_USB_SUSPEND 78#ifdef CONFIG_USB_SUSPEND
158 if (udev->descriptor.bDeviceClass != USB_CLASS_HUB) 79 if (udev->descriptor.bDeviceClass != USB_CLASS_HUB)
159 udev->autosuspend_delay = -1; 80 udev->autosuspend_disabled = 1;
160#endif 81#endif
161} 82}
diff --git a/drivers/usb/core/sysfs.c b/drivers/usb/core/sysfs.c
index 2ab222be8fd..b04afd06e50 100644
--- a/drivers/usb/core/sysfs.c
+++ b/drivers/usb/core/sysfs.c
@@ -169,6 +169,16 @@ show_quirks(struct device *dev, struct device_attribute *attr, char *buf)
169} 169}
170static DEVICE_ATTR(quirks, S_IRUGO, show_quirks, NULL); 170static DEVICE_ATTR(quirks, S_IRUGO, show_quirks, NULL);
171 171
172static ssize_t
173show_urbnum(struct device *dev, struct device_attribute *attr, char *buf)
174{
175 struct usb_device *udev;
176
177 udev = to_usb_device(dev);
178 return sprintf(buf, "%d\n", atomic_read(&udev->urbnum));
179}
180static DEVICE_ATTR(urbnum, S_IRUGO, show_urbnum, NULL);
181
172 182
173#if defined(CONFIG_USB_PERSIST) || defined(CONFIG_USB_SUSPEND) 183#if defined(CONFIG_USB_PERSIST) || defined(CONFIG_USB_SUSPEND)
174static const char power_group[] = "power"; 184static const char power_group[] = "power";
@@ -413,6 +423,44 @@ usb_descriptor_attr(bDeviceProtocol, "%02x\n")
413usb_descriptor_attr(bNumConfigurations, "%d\n") 423usb_descriptor_attr(bNumConfigurations, "%d\n")
414usb_descriptor_attr(bMaxPacketSize0, "%d\n") 424usb_descriptor_attr(bMaxPacketSize0, "%d\n")
415 425
426
427
428/* show if the device is authorized (1) or not (0) */
429static ssize_t usb_dev_authorized_show(struct device *dev,
430 struct device_attribute *attr,
431 char *buf)
432{
433 struct usb_device *usb_dev = to_usb_device(dev);
434 return snprintf(buf, PAGE_SIZE, "%u\n", usb_dev->authorized);
435}
436
437
438/*
439 * Authorize a device to be used in the system
440 *
441 * Writing a 0 deauthorizes the device, writing a 1 authorizes it.
442 */
443static ssize_t usb_dev_authorized_store(struct device *dev,
444 struct device_attribute *attr,
445 const char *buf, size_t size)
446{
447 ssize_t result;
448 struct usb_device *usb_dev = to_usb_device(dev);
449 unsigned val;
450 result = sscanf(buf, "%u\n", &val);
451 if (result != 1)
452 result = -EINVAL;
453 else if (val == 0)
454 result = usb_deauthorize_device(usb_dev);
455 else
456 result = usb_authorize_device(usb_dev);
457 return result < 0? result : size;
458}
459
460static DEVICE_ATTR(authorized, 0644,
461 usb_dev_authorized_show, usb_dev_authorized_store);
462
463
416static struct attribute *dev_attrs[] = { 464static struct attribute *dev_attrs[] = {
417 /* current configuration's attributes */ 465 /* current configuration's attributes */
418 &dev_attr_configuration.attr, 466 &dev_attr_configuration.attr,
@@ -420,6 +468,7 @@ static struct attribute *dev_attrs[] = {
420 &dev_attr_bConfigurationValue.attr, 468 &dev_attr_bConfigurationValue.attr,
421 &dev_attr_bmAttributes.attr, 469 &dev_attr_bmAttributes.attr,
422 &dev_attr_bMaxPower.attr, 470 &dev_attr_bMaxPower.attr,
471 &dev_attr_urbnum.attr,
423 /* device attributes */ 472 /* device attributes */
424 &dev_attr_idVendor.attr, 473 &dev_attr_idVendor.attr,
425 &dev_attr_idProduct.attr, 474 &dev_attr_idProduct.attr,
@@ -435,6 +484,7 @@ static struct attribute *dev_attrs[] = {
435 &dev_attr_version.attr, 484 &dev_attr_version.attr,
436 &dev_attr_maxchild.attr, 485 &dev_attr_maxchild.attr,
437 &dev_attr_quirks.attr, 486 &dev_attr_quirks.attr,
487 &dev_attr_authorized.attr,
438 NULL, 488 NULL,
439}; 489};
440static struct attribute_group dev_attr_grp = { 490static struct attribute_group dev_attr_grp = {
diff --git a/drivers/usb/core/urb.c b/drivers/usb/core/urb.c
index be630228461..c20c03aaf01 100644
--- a/drivers/usb/core/urb.c
+++ b/drivers/usb/core/urb.c
@@ -3,6 +3,7 @@
3#include <linux/bitops.h> 3#include <linux/bitops.h>
4#include <linux/slab.h> 4#include <linux/slab.h>
5#include <linux/init.h> 5#include <linux/init.h>
6#include <linux/log2.h>
6#include <linux/usb.h> 7#include <linux/usb.h>
7#include <linux/wait.h> 8#include <linux/wait.h>
8#include "hcd.h" 9#include "hcd.h"
@@ -38,7 +39,6 @@ void usb_init_urb(struct urb *urb)
38 if (urb) { 39 if (urb) {
39 memset(urb, 0, sizeof(*urb)); 40 memset(urb, 0, sizeof(*urb));
40 kref_init(&urb->kref); 41 kref_init(&urb->kref);
41 spin_lock_init(&urb->lock);
42 INIT_LIST_HEAD(&urb->anchor_list); 42 INIT_LIST_HEAD(&urb->anchor_list);
43 } 43 }
44} 44}
@@ -277,44 +277,58 @@ EXPORT_SYMBOL_GPL(usb_unanchor_urb);
277 */ 277 */
278int usb_submit_urb(struct urb *urb, gfp_t mem_flags) 278int usb_submit_urb(struct urb *urb, gfp_t mem_flags)
279{ 279{
280 int pipe, temp, max; 280 int xfertype, max;
281 struct usb_device *dev; 281 struct usb_device *dev;
282 int is_out; 282 struct usb_host_endpoint *ep;
283 int is_out;
283 284
284 if (!urb || urb->hcpriv || !urb->complete) 285 if (!urb || urb->hcpriv || !urb->complete)
285 return -EINVAL; 286 return -EINVAL;
286 if (!(dev = urb->dev) || 287 if (!(dev = urb->dev) || dev->state < USB_STATE_DEFAULT)
287 (dev->state < USB_STATE_DEFAULT) ||
288 (!dev->bus) || (dev->devnum <= 0))
289 return -ENODEV; 288 return -ENODEV;
290 if (dev->bus->controller->power.power_state.event != PM_EVENT_ON
291 || dev->state == USB_STATE_SUSPENDED)
292 return -EHOSTUNREACH;
293 289
290 /* For now, get the endpoint from the pipe. Eventually drivers
291 * will be required to set urb->ep directly and we will eliminate
292 * urb->pipe.
293 */
294 ep = (usb_pipein(urb->pipe) ? dev->ep_in : dev->ep_out)
295 [usb_pipeendpoint(urb->pipe)];
296 if (!ep)
297 return -ENOENT;
298
299 urb->ep = ep;
294 urb->status = -EINPROGRESS; 300 urb->status = -EINPROGRESS;
295 urb->actual_length = 0; 301 urb->actual_length = 0;
296 302
297 /* Lots of sanity checks, so HCDs can rely on clean data 303 /* Lots of sanity checks, so HCDs can rely on clean data
298 * and don't need to duplicate tests 304 * and don't need to duplicate tests
299 */ 305 */
300 pipe = urb->pipe; 306 xfertype = usb_endpoint_type(&ep->desc);
301 temp = usb_pipetype(pipe); 307 if (xfertype == USB_ENDPOINT_XFER_CONTROL) {
302 is_out = usb_pipeout(pipe); 308 struct usb_ctrlrequest *setup =
309 (struct usb_ctrlrequest *) urb->setup_packet;
310
311 if (!setup)
312 return -ENOEXEC;
313 is_out = !(setup->bRequestType & USB_DIR_IN) ||
314 !setup->wLength;
315 } else {
316 is_out = usb_endpoint_dir_out(&ep->desc);
317 }
303 318
304 if (!usb_pipecontrol(pipe) && dev->state < USB_STATE_CONFIGURED) 319 /* Cache the direction for later use */
305 return -ENODEV; 320 urb->transfer_flags = (urb->transfer_flags & ~URB_DIR_MASK) |
321 (is_out ? URB_DIR_OUT : URB_DIR_IN);
306 322
307 /* FIXME there should be a sharable lock protecting us against 323 if (xfertype != USB_ENDPOINT_XFER_CONTROL &&
308 * config/altsetting changes and disconnects, kicking in here. 324 dev->state < USB_STATE_CONFIGURED)
309 * (here == before maxpacket, and eventually endpoint type, 325 return -ENODEV;
310 * checks get made.)
311 */
312 326
313 max = usb_maxpacket(dev, pipe, is_out); 327 max = le16_to_cpu(ep->desc.wMaxPacketSize);
314 if (max <= 0) { 328 if (max <= 0) {
315 dev_dbg(&dev->dev, 329 dev_dbg(&dev->dev,
316 "bogus endpoint ep%d%s in %s (bad maxpacket %d)\n", 330 "bogus endpoint ep%d%s in %s (bad maxpacket %d)\n",
317 usb_pipeendpoint(pipe), is_out ? "out" : "in", 331 usb_endpoint_num(&ep->desc), is_out ? "out" : "in",
318 __FUNCTION__, max); 332 __FUNCTION__, max);
319 return -EMSGSIZE; 333 return -EMSGSIZE;
320 } 334 }
@@ -323,7 +337,7 @@ int usb_submit_urb(struct urb *urb, gfp_t mem_flags)
323 * but drivers only control those sizes for ISO. 337 * but drivers only control those sizes for ISO.
324 * while we're checking, initialize return status. 338 * while we're checking, initialize return status.
325 */ 339 */
326 if (temp == PIPE_ISOCHRONOUS) { 340 if (xfertype == USB_ENDPOINT_XFER_ISOC) {
327 int n, len; 341 int n, len;
328 342
329 /* "high bandwidth" mode, 1-3 packets/uframe? */ 343 /* "high bandwidth" mode, 1-3 packets/uframe? */
@@ -358,20 +372,20 @@ int usb_submit_urb(struct urb *urb, gfp_t mem_flags)
358 372
359 /* enforce simple/standard policy */ 373 /* enforce simple/standard policy */
360 allowed = (URB_NO_TRANSFER_DMA_MAP | URB_NO_SETUP_DMA_MAP | 374 allowed = (URB_NO_TRANSFER_DMA_MAP | URB_NO_SETUP_DMA_MAP |
361 URB_NO_INTERRUPT); 375 URB_NO_INTERRUPT | URB_DIR_MASK);
362 switch (temp) { 376 switch (xfertype) {
363 case PIPE_BULK: 377 case USB_ENDPOINT_XFER_BULK:
364 if (is_out) 378 if (is_out)
365 allowed |= URB_ZERO_PACKET; 379 allowed |= URB_ZERO_PACKET;
366 /* FALLTHROUGH */ 380 /* FALLTHROUGH */
367 case PIPE_CONTROL: 381 case USB_ENDPOINT_XFER_CONTROL:
368 allowed |= URB_NO_FSBR; /* only affects UHCI */ 382 allowed |= URB_NO_FSBR; /* only affects UHCI */
369 /* FALLTHROUGH */ 383 /* FALLTHROUGH */
370 default: /* all non-iso endpoints */ 384 default: /* all non-iso endpoints */
371 if (!is_out) 385 if (!is_out)
372 allowed |= URB_SHORT_NOT_OK; 386 allowed |= URB_SHORT_NOT_OK;
373 break; 387 break;
374 case PIPE_ISOCHRONOUS: 388 case USB_ENDPOINT_XFER_ISOC:
375 allowed |= URB_ISO_ASAP; 389 allowed |= URB_ISO_ASAP;
376 break; 390 break;
377 } 391 }
@@ -393,9 +407,9 @@ int usb_submit_urb(struct urb *urb, gfp_t mem_flags)
393 * supports different values... this uses EHCI/UHCI defaults (and 407 * supports different values... this uses EHCI/UHCI defaults (and
394 * EHCI can use smaller non-default values). 408 * EHCI can use smaller non-default values).
395 */ 409 */
396 switch (temp) { 410 switch (xfertype) {
397 case PIPE_ISOCHRONOUS: 411 case USB_ENDPOINT_XFER_ISOC:
398 case PIPE_INTERRUPT: 412 case USB_ENDPOINT_XFER_INT:
399 /* too small? */ 413 /* too small? */
400 if (urb->interval <= 0) 414 if (urb->interval <= 0)
401 return -EINVAL; 415 return -EINVAL;
@@ -405,29 +419,27 @@ int usb_submit_urb(struct urb *urb, gfp_t mem_flags)
405 // NOTE usb handles 2^15 419 // NOTE usb handles 2^15
406 if (urb->interval > (1024 * 8)) 420 if (urb->interval > (1024 * 8))
407 urb->interval = 1024 * 8; 421 urb->interval = 1024 * 8;
408 temp = 1024 * 8; 422 max = 1024 * 8;
409 break; 423 break;
410 case USB_SPEED_FULL: /* units are frames/msec */ 424 case USB_SPEED_FULL: /* units are frames/msec */
411 case USB_SPEED_LOW: 425 case USB_SPEED_LOW:
412 if (temp == PIPE_INTERRUPT) { 426 if (xfertype == USB_ENDPOINT_XFER_INT) {
413 if (urb->interval > 255) 427 if (urb->interval > 255)
414 return -EINVAL; 428 return -EINVAL;
415 // NOTE ohci only handles up to 32 429 // NOTE ohci only handles up to 32
416 temp = 128; 430 max = 128;
417 } else { 431 } else {
418 if (urb->interval > 1024) 432 if (urb->interval > 1024)
419 urb->interval = 1024; 433 urb->interval = 1024;
420 // NOTE usb and ohci handle up to 2^15 434 // NOTE usb and ohci handle up to 2^15
421 temp = 1024; 435 max = 1024;
422 } 436 }
423 break; 437 break;
424 default: 438 default:
425 return -EINVAL; 439 return -EINVAL;
426 } 440 }
427 /* power of two? */ 441 /* Round down to a power of 2, no more than max */
428 while (temp > urb->interval) 442 urb->interval = min(max, 1 << ilog2(urb->interval));
429 temp >>= 1;
430 urb->interval = temp;
431 } 443 }
432 444
433 return usb_hcd_submit_urb(urb, mem_flags); 445 return usb_hcd_submit_urb(urb, mem_flags);
@@ -496,8 +508,10 @@ int usb_unlink_urb(struct urb *urb)
496{ 508{
497 if (!urb) 509 if (!urb)
498 return -EINVAL; 510 return -EINVAL;
499 if (!(urb->dev && urb->dev->bus)) 511 if (!urb->dev)
500 return -ENODEV; 512 return -ENODEV;
513 if (!urb->ep)
514 return -EIDRM;
501 return usb_hcd_unlink_urb(urb, -ECONNRESET); 515 return usb_hcd_unlink_urb(urb, -ECONNRESET);
502} 516}
503 517
@@ -523,19 +537,21 @@ int usb_unlink_urb(struct urb *urb)
523 */ 537 */
524void usb_kill_urb(struct urb *urb) 538void usb_kill_urb(struct urb *urb)
525{ 539{
540 static DEFINE_MUTEX(reject_mutex);
541
526 might_sleep(); 542 might_sleep();
527 if (!(urb && urb->dev && urb->dev->bus)) 543 if (!(urb && urb->dev && urb->ep))
528 return; 544 return;
529 spin_lock_irq(&urb->lock); 545 mutex_lock(&reject_mutex);
530 ++urb->reject; 546 ++urb->reject;
531 spin_unlock_irq(&urb->lock); 547 mutex_unlock(&reject_mutex);
532 548
533 usb_hcd_unlink_urb(urb, -ENOENT); 549 usb_hcd_unlink_urb(urb, -ENOENT);
534 wait_event(usb_kill_urb_queue, atomic_read(&urb->use_count) == 0); 550 wait_event(usb_kill_urb_queue, atomic_read(&urb->use_count) == 0);
535 551
536 spin_lock_irq(&urb->lock); 552 mutex_lock(&reject_mutex);
537 --urb->reject; 553 --urb->reject;
538 spin_unlock_irq(&urb->lock); 554 mutex_unlock(&reject_mutex);
539} 555}
540 556
541/** 557/**
diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c
index 0fee5c66fd6..c99938d5f78 100644
--- a/drivers/usb/core/usb.c
+++ b/drivers/usb/core/usb.c
@@ -223,6 +223,15 @@ static void ksuspend_usb_cleanup(void)
223 223
224#endif /* CONFIG_PM */ 224#endif /* CONFIG_PM */
225 225
226
227/* Returns 1 if @usb_bus is WUSB, 0 otherwise */
228static unsigned usb_bus_is_wusb(struct usb_bus *bus)
229{
230 struct usb_hcd *hcd = container_of(bus, struct usb_hcd, self);
231 return hcd->wireless;
232}
233
234
226/** 235/**
227 * usb_alloc_dev - usb device constructor (usbcore-internal) 236 * usb_alloc_dev - usb device constructor (usbcore-internal)
228 * @parent: hub to which device is connected; null to allocate a root hub 237 * @parent: hub to which device is connected; null to allocate a root hub
@@ -239,6 +248,8 @@ struct usb_device *
239usb_alloc_dev(struct usb_device *parent, struct usb_bus *bus, unsigned port1) 248usb_alloc_dev(struct usb_device *parent, struct usb_bus *bus, unsigned port1)
240{ 249{
241 struct usb_device *dev; 250 struct usb_device *dev;
251 struct usb_hcd *usb_hcd = container_of(bus, struct usb_hcd, self);
252 unsigned root_hub = 0;
242 253
243 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 254 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
244 if (!dev) 255 if (!dev)
@@ -255,12 +266,14 @@ usb_alloc_dev(struct usb_device *parent, struct usb_bus *bus, unsigned port1)
255 dev->dev.dma_mask = bus->controller->dma_mask; 266 dev->dev.dma_mask = bus->controller->dma_mask;
256 set_dev_node(&dev->dev, dev_to_node(bus->controller)); 267 set_dev_node(&dev->dev, dev_to_node(bus->controller));
257 dev->state = USB_STATE_ATTACHED; 268 dev->state = USB_STATE_ATTACHED;
269 atomic_set(&dev->urbnum, 0);
258 270
259 INIT_LIST_HEAD(&dev->ep0.urb_list); 271 INIT_LIST_HEAD(&dev->ep0.urb_list);
260 dev->ep0.desc.bLength = USB_DT_ENDPOINT_SIZE; 272 dev->ep0.desc.bLength = USB_DT_ENDPOINT_SIZE;
261 dev->ep0.desc.bDescriptorType = USB_DT_ENDPOINT; 273 dev->ep0.desc.bDescriptorType = USB_DT_ENDPOINT;
262 /* ep0 maxpacket comes later, from device descriptor */ 274 /* ep0 maxpacket comes later, from device descriptor */
263 dev->ep_in[0] = dev->ep_out[0] = &dev->ep0; 275 usb_enable_endpoint(dev, &dev->ep0);
276 dev->can_submit = 1;
264 277
265 /* Save readable and stable topology id, distinguishing devices 278 /* Save readable and stable topology id, distinguishing devices
266 * by location for diagnostics, tools, driver model, etc. The 279 * by location for diagnostics, tools, driver model, etc. The
@@ -275,6 +288,7 @@ usb_alloc_dev(struct usb_device *parent, struct usb_bus *bus, unsigned port1)
275 288
276 dev->dev.parent = bus->controller; 289 dev->dev.parent = bus->controller;
277 sprintf(&dev->dev.bus_id[0], "usb%d", bus->busnum); 290 sprintf(&dev->dev.bus_id[0], "usb%d", bus->busnum);
291 root_hub = 1;
278 } else { 292 } else {
279 /* match any labeling on the hubs; it's one-based */ 293 /* match any labeling on the hubs; it's one-based */
280 if (parent->devpath[0] == '0') 294 if (parent->devpath[0] == '0')
@@ -301,6 +315,12 @@ usb_alloc_dev(struct usb_device *parent, struct usb_bus *bus, unsigned port1)
301 INIT_DELAYED_WORK(&dev->autosuspend, usb_autosuspend_work); 315 INIT_DELAYED_WORK(&dev->autosuspend, usb_autosuspend_work);
302 dev->autosuspend_delay = usb_autosuspend_delay * HZ; 316 dev->autosuspend_delay = usb_autosuspend_delay * HZ;
303#endif 317#endif
318 if (root_hub) /* Root hub always ok [and always wired] */
319 dev->authorized = 1;
320 else {
321 dev->authorized = usb_hcd->authorized_default;
322 dev->wusb = usb_bus_is_wusb(bus)? 1 : 0;
323 }
304 return dev; 324 return dev;
305} 325}
306 326
@@ -748,7 +768,7 @@ void usb_buffer_unmap(struct urb *urb)
748/** 768/**
749 * usb_buffer_map_sg - create scatterlist DMA mapping(s) for an endpoint 769 * usb_buffer_map_sg - create scatterlist DMA mapping(s) for an endpoint
750 * @dev: device to which the scatterlist will be mapped 770 * @dev: device to which the scatterlist will be mapped
751 * @pipe: endpoint defining the mapping direction 771 * @is_in: mapping transfer direction
752 * @sg: the scatterlist to map 772 * @sg: the scatterlist to map
753 * @nents: the number of entries in the scatterlist 773 * @nents: the number of entries in the scatterlist
754 * 774 *
@@ -771,14 +791,13 @@ void usb_buffer_unmap(struct urb *urb)
771 * 791 *
772 * Reverse the effect of this call with usb_buffer_unmap_sg(). 792 * Reverse the effect of this call with usb_buffer_unmap_sg().
773 */ 793 */
774int usb_buffer_map_sg(const struct usb_device *dev, unsigned pipe, 794int usb_buffer_map_sg(const struct usb_device *dev, int is_in,
775 struct scatterlist *sg, int nents) 795 struct scatterlist *sg, int nents)
776{ 796{
777 struct usb_bus *bus; 797 struct usb_bus *bus;
778 struct device *controller; 798 struct device *controller;
779 799
780 if (!dev 800 if (!dev
781 || usb_pipecontrol(pipe)
782 || !(bus = dev->bus) 801 || !(bus = dev->bus)
783 || !(controller = bus->controller) 802 || !(controller = bus->controller)
784 || !controller->dma_mask) 803 || !controller->dma_mask)
@@ -786,7 +805,7 @@ int usb_buffer_map_sg(const struct usb_device *dev, unsigned pipe,
786 805
787 // FIXME generic api broken like pci, can't report errors 806 // FIXME generic api broken like pci, can't report errors
788 return dma_map_sg(controller, sg, nents, 807 return dma_map_sg(controller, sg, nents,
789 usb_pipein(pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 808 is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
790} 809}
791 810
792/* XXX DISABLED, no users currently. If you wish to re-enable this 811/* XXX DISABLED, no users currently. If you wish to re-enable this
@@ -799,14 +818,14 @@ int usb_buffer_map_sg(const struct usb_device *dev, unsigned pipe,
799/** 818/**
800 * usb_buffer_dmasync_sg - synchronize DMA and CPU view of scatterlist buffer(s) 819 * usb_buffer_dmasync_sg - synchronize DMA and CPU view of scatterlist buffer(s)
801 * @dev: device to which the scatterlist will be mapped 820 * @dev: device to which the scatterlist will be mapped
802 * @pipe: endpoint defining the mapping direction 821 * @is_in: mapping transfer direction
803 * @sg: the scatterlist to synchronize 822 * @sg: the scatterlist to synchronize
804 * @n_hw_ents: the positive return value from usb_buffer_map_sg 823 * @n_hw_ents: the positive return value from usb_buffer_map_sg
805 * 824 *
806 * Use this when you are re-using a scatterlist's data buffers for 825 * Use this when you are re-using a scatterlist's data buffers for
807 * another USB request. 826 * another USB request.
808 */ 827 */
809void usb_buffer_dmasync_sg(const struct usb_device *dev, unsigned pipe, 828void usb_buffer_dmasync_sg(const struct usb_device *dev, int is_in,
810 struct scatterlist *sg, int n_hw_ents) 829 struct scatterlist *sg, int n_hw_ents)
811{ 830{
812 struct usb_bus *bus; 831 struct usb_bus *bus;
@@ -819,20 +838,20 @@ void usb_buffer_dmasync_sg(const struct usb_device *dev, unsigned pipe,
819 return; 838 return;
820 839
821 dma_sync_sg(controller, sg, n_hw_ents, 840 dma_sync_sg(controller, sg, n_hw_ents,
822 usb_pipein(pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 841 is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
823} 842}
824#endif 843#endif
825 844
826/** 845/**
827 * usb_buffer_unmap_sg - free DMA mapping(s) for a scatterlist 846 * usb_buffer_unmap_sg - free DMA mapping(s) for a scatterlist
828 * @dev: device to which the scatterlist will be mapped 847 * @dev: device to which the scatterlist will be mapped
829 * @pipe: endpoint defining the mapping direction 848 * @is_in: mapping transfer direction
830 * @sg: the scatterlist to unmap 849 * @sg: the scatterlist to unmap
831 * @n_hw_ents: the positive return value from usb_buffer_map_sg 850 * @n_hw_ents: the positive return value from usb_buffer_map_sg
832 * 851 *
833 * Reverses the effect of usb_buffer_map_sg(). 852 * Reverses the effect of usb_buffer_map_sg().
834 */ 853 */
835void usb_buffer_unmap_sg(const struct usb_device *dev, unsigned pipe, 854void usb_buffer_unmap_sg(const struct usb_device *dev, int is_in,
836 struct scatterlist *sg, int n_hw_ents) 855 struct scatterlist *sg, int n_hw_ents)
837{ 856{
838 struct usb_bus *bus; 857 struct usb_bus *bus;
@@ -845,7 +864,7 @@ void usb_buffer_unmap_sg(const struct usb_device *dev, unsigned pipe,
845 return; 864 return;
846 865
847 dma_unmap_sg(controller, sg, n_hw_ents, 866 dma_unmap_sg(controller, sg, n_hw_ents,
848 usb_pipein(pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 867 is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
849} 868}
850 869
851/* format to disable USB on kernel command line is: nousb */ 870/* format to disable USB on kernel command line is: nousb */
diff --git a/drivers/usb/core/usb.h b/drivers/usb/core/usb.h
index ad5fa0338f4..c52626c51f7 100644
--- a/drivers/usb/core/usb.h
+++ b/drivers/usb/core/usb.h
@@ -8,17 +8,22 @@ extern int usb_create_ep_files(struct device *parent, struct usb_host_endpoint *
8 struct usb_device *udev); 8 struct usb_device *udev);
9extern void usb_remove_ep_files(struct usb_host_endpoint *endpoint); 9extern void usb_remove_ep_files(struct usb_host_endpoint *endpoint);
10 10
11extern void usb_enable_endpoint(struct usb_device *dev,
12 struct usb_host_endpoint *ep);
11extern void usb_disable_endpoint (struct usb_device *dev, unsigned int epaddr); 13extern void usb_disable_endpoint (struct usb_device *dev, unsigned int epaddr);
12extern void usb_disable_interface (struct usb_device *dev, 14extern void usb_disable_interface (struct usb_device *dev,
13 struct usb_interface *intf); 15 struct usb_interface *intf);
14extern void usb_release_interface_cache(struct kref *ref); 16extern void usb_release_interface_cache(struct kref *ref);
15extern void usb_disable_device (struct usb_device *dev, int skip_ep0); 17extern void usb_disable_device (struct usb_device *dev, int skip_ep0);
18extern int usb_deauthorize_device (struct usb_device *);
19extern int usb_authorize_device (struct usb_device *);
16extern void usb_detect_quirks(struct usb_device *udev); 20extern void usb_detect_quirks(struct usb_device *udev);
17 21
18extern int usb_get_device_descriptor(struct usb_device *dev, 22extern int usb_get_device_descriptor(struct usb_device *dev,
19 unsigned int size); 23 unsigned int size);
20extern char *usb_cache_string(struct usb_device *udev, int index); 24extern char *usb_cache_string(struct usb_device *udev, int index);
21extern int usb_set_configuration(struct usb_device *dev, int configuration); 25extern int usb_set_configuration(struct usb_device *dev, int configuration);
26extern int usb_choose_configuration(struct usb_device *udev);
22 27
23extern void usb_kick_khubd(struct usb_device *dev); 28extern void usb_kick_khubd(struct usb_device *dev);
24extern int usb_match_device(struct usb_device *dev, 29extern int usb_match_device(struct usb_device *dev,
generated by cgit v1.2.2 (git 2.25.0) at 2025-01-02 04:15:20 -0500