SVN maintenance:
authorHervé Poussineau <hpoussin@reactos.org>
Fri, 20 May 2005 21:53:08 +0000 (21:53 +0000)
committerHervé Poussineau <hpoussin@reactos.org>
Fri, 20 May 2005 21:53:08 +0000 (21:53 +0000)
Set svn:eol-style and svn:keywords for files
Set svn:ignore for directories

svn path=/trunk/; revision=15440

59 files changed:
reactos/drivers/usb/cromwell/Makefile
reactos/drivers/usb/cromwell/core/buffer_simple.c
reactos/drivers/usb/cromwell/core/config.c
reactos/drivers/usb/cromwell/core/hcd-pci.c
reactos/drivers/usb/cromwell/core/hcd.c
reactos/drivers/usb/cromwell/core/hcd.h
reactos/drivers/usb/cromwell/core/hub.c
reactos/drivers/usb/cromwell/core/hub.h
reactos/drivers/usb/cromwell/core/makefile
reactos/drivers/usb/cromwell/core/makefile.crom
reactos/drivers/usb/cromwell/core/message.c
reactos/drivers/usb/cromwell/core/urb.c
reactos/drivers/usb/cromwell/core/usb-debug.c
reactos/drivers/usb/cromwell/core/usb.c
reactos/drivers/usb/cromwell/core/usb.h
reactos/drivers/usb/cromwell/core/usbcore.c
reactos/drivers/usb/cromwell/core/usbcore.def
reactos/drivers/usb/cromwell/core/usbcore.rc
reactos/drivers/usb/cromwell/host/makefile
reactos/drivers/usb/cromwell/host/makefile.crom
reactos/drivers/usb/cromwell/host/ohci-dbg.c
reactos/drivers/usb/cromwell/host/ohci-hcd.c
reactos/drivers/usb/cromwell/host/ohci-hub.c
reactos/drivers/usb/cromwell/host/ohci-mem.c
reactos/drivers/usb/cromwell/host/ohci-pci.c
reactos/drivers/usb/cromwell/host/ohci-q.c
reactos/drivers/usb/cromwell/host/ohci.def
reactos/drivers/usb/cromwell/host/ohci.h
reactos/drivers/usb/cromwell/host/ohci.rc
reactos/drivers/usb/cromwell/host/ohci_config.h
reactos/drivers/usb/cromwell/host/ohci_main.c
reactos/drivers/usb/cromwell/host/ohci_main.h
reactos/drivers/usb/cromwell/linux/asm/bitops.h
reactos/drivers/usb/cromwell/linux/bitops.h
reactos/drivers/usb/cromwell/linux/boot.h
reactos/drivers/usb/cromwell/linux/consts.h
reactos/drivers/usb/cromwell/linux/cromwell_types.h
reactos/drivers/usb/cromwell/linux/errno.h
reactos/drivers/usb/cromwell/linux/linux_wrapper.h
reactos/drivers/usb/cromwell/linux/list.h
reactos/drivers/usb/cromwell/linux/pci_hal.c
reactos/drivers/usb/cromwell/linux/pci_ids.h
reactos/drivers/usb/cromwell/linux/usb.h
reactos/drivers/usb/cromwell/linux/usb_ch9.h
reactos/drivers/usb/cromwell/sys/BootUSB.c
reactos/drivers/usb/cromwell/sys/Makefile
reactos/drivers/usb/cromwell/sys/linuxwrapper.c
reactos/drivers/usb/cromwell/sys/risefall.c
reactos/drivers/usb/cromwell/sys/ros_wrapper.c
reactos/drivers/usb/cromwell/sys/usbkey.c
reactos/drivers/usb/cromwell/sys/usbwrapper.c
reactos/drivers/usb/cromwell/sys/xpad.c
reactos/drivers/usb/cromwell/sys/xremote.c
reactos/drivers/usb/cromwell/uhci/makefile
reactos/drivers/usb/cromwell/uhci/uhci.def
reactos/drivers/usb/cromwell/uhci/uhci.rc
reactos/drivers/usb/cromwell/uhci/uhci_config.h
reactos/drivers/usb/cromwell/uhci/uhci_main.c
reactos/drivers/usb/cromwell/usb_wrapper.h

index 1f12473..f2d4bf0 100644 (file)
@@ -1,50 +1,50 @@
-#\r
-# ReactOS USB-Cromwell Drivers\r
-#\r
-\r
-PATH_TO_TOP = ../../..\r
-\r
-include $(PATH_TO_TOP)/rules.mak\r
-\r
-DRIVERS = core host uhci\r
-\r
-all: $(DRIVERS)\r
-\r
-depends: \r
-\r
-implib: $(DRIVERS:%=%_implib)\r
-\r
-clean:         $(DRIVERS:%=%_clean)\r
-\r
-install: $(DRIVERS:%=%_install)\r
-\r
-bootcd: $(DRIVERS:%=%_bootcd)\r
-\r
-.PHONY: all depends implib clean install bootcd\r
-\r
-\r
-#\r
-# USB DRIVERS\r
-#\r
-$(DRIVERS): %:\r
-       $(MAKE) -C $*\r
-\r
-$(DRIVERS:%=%_implib): %_implib:\r
-       $(MAKE) -C $* implib\r
-\r
-$(DRIVERS:%=%_clean): %_clean:\r
-       $(MAKE) -C $* clean\r
-\r
-$(DRIVERS:%=%_install): %_install:\r
-       $(MAKE) -C $* install\r
-\r
-$(DRIVERS:%=%_bootcd): %_bootcd:\r
-       $(MAKE) -C $* bootcd\r
-\r
-.PHONY: $(DRIVERS) $(DRIVERS:%=%_implib) $(DRIVERS:%=%_clean) $(DRIVERS:%=%_install) $(DRIVERS:%=%_bootcd)\r
-\r
-\r
-etags:\r
-       find . -name "*.[ch]" -print | etags --language=c -\r
-\r
-# EOF\r
+#
+# ReactOS USB-Cromwell Drivers
+#
+
+PATH_TO_TOP = ../../..
+
+include $(PATH_TO_TOP)/rules.mak
+
+DRIVERS = core host uhci
+
+all: $(DRIVERS)
+
+depends: 
+
+implib: $(DRIVERS:%=%_implib)
+
+clean:         $(DRIVERS:%=%_clean)
+
+install: $(DRIVERS:%=%_install)
+
+bootcd: $(DRIVERS:%=%_bootcd)
+
+.PHONY: all depends implib clean install bootcd
+
+
+#
+# USB DRIVERS
+#
+$(DRIVERS): %:
+       $(MAKE) -C $*
+
+$(DRIVERS:%=%_implib): %_implib:
+       $(MAKE) -C $* implib
+
+$(DRIVERS:%=%_clean): %_clean:
+       $(MAKE) -C $* clean
+
+$(DRIVERS:%=%_install): %_install:
+       $(MAKE) -C $* install
+
+$(DRIVERS:%=%_bootcd): %_bootcd:
+       $(MAKE) -C $* bootcd
+
+.PHONY: $(DRIVERS) $(DRIVERS:%=%_implib) $(DRIVERS:%=%_clean) $(DRIVERS:%=%_install) $(DRIVERS:%=%_bootcd)
+
+
+etags:
+       find . -name "*.[ch]" -print | etags --language=c -
+
+# EOF
index 7ac70ce..b0c0470 100644 (file)
@@ -1,42 +1,42 @@
-/* \r
- * buffer_simple.c -- replacement for usb/core/buffer.c\r
- *\r
- * (c) Georg Acher, georg@acher.org\r
- *\r
- */\r
-\r
-#include "../usb_wrapper.h"\r
-#define __KERNEL__\r
-#define CONFIG_PCI\r
-#include "hcd.h"\r
-\r
-/*------------------------------------------------------------------------*/ \r
-int hcd_buffer_create (struct usb_hcd *hcd)\r
-{\r
-       return 0;\r
-}\r
-/*------------------------------------------------------------------------*/ \r
-void hcd_buffer_destroy (struct usb_hcd *hcd)\r
-{\r
-}\r
-/*------------------------------------------------------------------------*/ \r
-void *hcd_buffer_alloc (\r
-        struct usb_bus          *bus,\r
-        size_t                  size,\r
-        int                     mem_flags,\r
-        dma_addr_t              *dma\r
-)\r
-{\r
-       return kmalloc(size,0);\r
-}\r
-/*------------------------------------------------------------------------*/ \r
-void hcd_buffer_free (\r
-        struct usb_bus          *bus,\r
-        size_t                  size,\r
-        void                    *addr,\r
-        dma_addr_t              dma\r
-)\r
-{\r
-       kfree(addr);\r
-}\r
-\r
+/* 
+ * buffer_simple.c -- replacement for usb/core/buffer.c
+ *
+ * (c) Georg Acher, georg@acher.org
+ *
+ */
+
+#include "../usb_wrapper.h"
+#define __KERNEL__
+#define CONFIG_PCI
+#include "hcd.h"
+
+/*------------------------------------------------------------------------*/ 
+int hcd_buffer_create (struct usb_hcd *hcd)
+{
+       return 0;
+}
+/*------------------------------------------------------------------------*/ 
+void hcd_buffer_destroy (struct usb_hcd *hcd)
+{
+}
+/*------------------------------------------------------------------------*/ 
+void *hcd_buffer_alloc (
+        struct usb_bus          *bus,
+        size_t                  size,
+        int                     mem_flags,
+        dma_addr_t              *dma
+)
+{
+       return kmalloc(size,0);
+}
+/*------------------------------------------------------------------------*/ 
+void hcd_buffer_free (
+        struct usb_bus          *bus,
+        size_t                  size,
+        void                    *addr,
+        dma_addr_t              dma
+)
+{
+       kfree(addr);
+}
+
index 7d400e9..1c40bbd 100644 (file)
-#if 0\r
-#include <linux/usb.h>\r
-#include <linux/module.h>\r
-#include <linux/init.h>\r
-#include <linux/slab.h>\r
-#include <asm/byteorder.h>\r
-#else\r
-#include "../usb_wrapper.h"\r
-#endif\r
-\r
-#define USB_MAXALTSETTING              128     /* Hard limit */\r
-#define USB_MAXENDPOINTS               30      /* Hard limit */\r
-\r
-/* these maximums are arbitrary */\r
-#define USB_MAXCONFIG                  8\r
-#define USB_ALTSETTINGALLOC            4\r
-#define USB_MAXINTERFACES              32\r
-\r
-static int usb_parse_endpoint(struct usb_host_endpoint *endpoint, unsigned char *buffer, int size)\r
-{\r
-       struct usb_descriptor_header *header;\r
-       unsigned char *begin;\r
-       int parsed = 0, len, numskipped;\r
-\r
-       header = (struct usb_descriptor_header *)buffer;\r
-\r
-       /* Everything should be fine being passed into here, but we sanity */\r
-       /*  check JIC */\r
-       if (header->bLength > size) {\r
-               err("ran out of descriptors parsing");\r
-               return -1;\r
-       }\r
-               \r
-       if (header->bDescriptorType != USB_DT_ENDPOINT) {\r
-               warn("unexpected descriptor 0x%X, expecting endpoint, 0x%X",\r
-                       header->bDescriptorType, USB_DT_ENDPOINT);\r
-               return parsed;\r
-       }\r
-\r
-       if (header->bLength == USB_DT_ENDPOINT_AUDIO_SIZE)\r
-               memcpy(&endpoint->desc, buffer, USB_DT_ENDPOINT_AUDIO_SIZE);\r
-       else\r
-               memcpy(&endpoint->desc, buffer, USB_DT_ENDPOINT_SIZE);\r
-       \r
-       le16_to_cpus(&endpoint->desc.wMaxPacketSize);\r
-\r
-       buffer += header->bLength;\r
-       size -= header->bLength;\r
-       parsed += header->bLength;\r
-\r
-       /* Skip over the rest of the Class Specific or Vendor Specific */\r
-       /*  descriptors */\r
-       begin = buffer;\r
-       numskipped = 0;\r
-       while (size >= sizeof(struct usb_descriptor_header)) {\r
-               header = (struct usb_descriptor_header *)buffer;\r
-\r
-               if (header->bLength < 2) {\r
-                       err("invalid descriptor length of %d", header->bLength);\r
-                       return -1;\r
-               }\r
-\r
-               /* If we find another "proper" descriptor then we're done  */\r
-               if ((header->bDescriptorType == USB_DT_ENDPOINT) ||\r
-                   (header->bDescriptorType == USB_DT_INTERFACE) ||\r
-                   (header->bDescriptorType == USB_DT_CONFIG) ||\r
-                   (header->bDescriptorType == USB_DT_DEVICE))\r
-                       break;\r
-\r
-               dbg("skipping descriptor 0x%X",\r
-                       header->bDescriptorType);\r
-               numskipped++;\r
-\r
-               buffer += header->bLength;\r
-               size -= header->bLength;\r
-               parsed += header->bLength;\r
-       }\r
-       if (numskipped)\r
-               dbg("skipped %d class/vendor specific endpoint descriptors", numskipped);\r
-\r
-       /* Copy any unknown descriptors into a storage area for drivers */\r
-       /*  to later parse */\r
-       len = (int)(buffer - begin);\r
-       if (!len) {\r
-               endpoint->extra = NULL;\r
-               endpoint->extralen = 0;\r
-               return parsed;\r
-       }\r
-\r
-       endpoint->extra = kmalloc(len, GFP_KERNEL);\r
-\r
-       if (!endpoint->extra) {\r
-               err("couldn't allocate memory for endpoint extra descriptors");\r
-               endpoint->extralen = 0;\r
-               return parsed;\r
-       }\r
-\r
-       memcpy(endpoint->extra, begin, len);\r
-       endpoint->extralen = len;\r
-\r
-       return parsed;\r
-}\r
-\r
-static int usb_parse_interface(struct usb_interface *interface, unsigned char *buffer, int size)\r
-{\r
-       int i, len, numskipped, retval, parsed = 0;\r
-       struct usb_descriptor_header *header;\r
-       struct usb_host_interface *ifp;\r
-       unsigned char *begin;\r
-\r
-       interface->act_altsetting = 0;\r
-       interface->num_altsetting = 0;\r
-       interface->max_altsetting = USB_ALTSETTINGALLOC;\r
-       device_initialize(&interface->dev);\r
-\r
-       interface->altsetting = kmalloc(sizeof(*interface->altsetting) * interface->max_altsetting,\r
-                                       GFP_KERNEL);\r
-       \r
-       if (!interface->altsetting) {\r
-               err("couldn't kmalloc interface->altsetting");\r
-               return -1;\r
-       }\r
-\r
-       while (size > 0) {\r
-               struct usb_interface_descriptor *d;\r
-       \r
-               if (interface->num_altsetting >= interface->max_altsetting) {\r
-                       struct usb_host_interface *ptr;\r
-                       int oldmas;\r
-\r
-                       oldmas = interface->max_altsetting;\r
-                       interface->max_altsetting += USB_ALTSETTINGALLOC;\r
-                       if (interface->max_altsetting > USB_MAXALTSETTING) {\r
-                               warn("too many alternate settings (incr %d max %d)\n",\r
-                                       USB_ALTSETTINGALLOC, USB_MAXALTSETTING);\r
-                               return -1;\r
-                       }\r
-\r
-                       ptr = kmalloc(sizeof(*ptr) * interface->max_altsetting, GFP_KERNEL);\r
-                       if (ptr == NULL) {\r
-                               err("couldn't kmalloc interface->altsetting");\r
-                               return -1;\r
-                       }\r
-                       memcpy(ptr, interface->altsetting, sizeof(*interface->altsetting) * oldmas);\r
-                       kfree(interface->altsetting);\r
-                       interface->altsetting = ptr;\r
-               }\r
-\r
-               ifp = interface->altsetting + interface->num_altsetting;\r
-               ifp->endpoint = NULL;\r
-               ifp->extra = NULL;\r
-               ifp->extralen = 0;\r
-               interface->num_altsetting++;\r
-\r
-               memcpy(ifp, buffer, USB_DT_INTERFACE_SIZE);\r
-\r
-               /* Skip over the interface */\r
-               buffer += ifp->desc.bLength;\r
-               parsed += ifp->desc.bLength;\r
-               size -= ifp->desc.bLength;\r
-\r
-               begin = buffer;\r
-               numskipped = 0;\r
-\r
-               /* Skip over any interface, class or vendor descriptors */\r
-               while (size >= sizeof(struct usb_descriptor_header)) {\r
-                       header = (struct usb_descriptor_header *)buffer;\r
-\r
-                       if (header->bLength < 2) {\r
-                               err("invalid descriptor length of %d", header->bLength);\r
-                               return -1;\r
-                       }\r
-\r
-                       /* If we find another "proper" descriptor then we're done  */\r
-                       if ((header->bDescriptorType == USB_DT_INTERFACE) ||\r
-                           (header->bDescriptorType == USB_DT_ENDPOINT) ||\r
-                           (header->bDescriptorType == USB_DT_CONFIG) ||\r
-                           (header->bDescriptorType == USB_DT_DEVICE))\r
-                               break;\r
-\r
-                       numskipped++;\r
-\r
-                       buffer += header->bLength;\r
-                       parsed += header->bLength;\r
-                       size -= header->bLength;\r
-               }\r
-\r
-               if (numskipped)\r
-                       dbg("skipped %d class/vendor specific interface descriptors", numskipped);\r
-\r
-               /* Copy any unknown descriptors into a storage area for */\r
-               /*  drivers to later parse */\r
-               len = (int)(buffer - begin);\r
-               if (len) {\r
-                       ifp->extra = kmalloc(len, GFP_KERNEL);\r
-\r
-                       if (!ifp->extra) {\r
-                               err("couldn't allocate memory for interface extra descriptors");\r
-                               ifp->extralen = 0;\r
-                               return -1;\r
-                       }\r
-                       memcpy(ifp->extra, begin, len);\r
-                       ifp->extralen = len;\r
-               }\r
-\r
-               /* Did we hit an unexpected descriptor? */\r
-               header = (struct usb_descriptor_header *)buffer;\r
-               if ((size >= sizeof(struct usb_descriptor_header)) &&\r
-                   ((header->bDescriptorType == USB_DT_CONFIG) ||\r
-                    (header->bDescriptorType == USB_DT_DEVICE)))\r
-                       return parsed;\r
-\r
-               if (ifp->desc.bNumEndpoints > USB_MAXENDPOINTS) {\r
-                       warn("too many endpoints");\r
-                       return -1;\r
-               }\r
-\r
-               ifp->endpoint = (struct usb_host_endpoint *)\r
-                       kmalloc(ifp->desc.bNumEndpoints *\r
-                       sizeof(struct usb_host_endpoint), GFP_KERNEL);\r
-               if (!ifp->endpoint) {\r
-                       err("out of memory");\r
-                       return -1;      \r
-               }\r
-\r
-               memset(ifp->endpoint, 0, ifp->desc.bNumEndpoints *\r
-                       sizeof(struct usb_host_endpoint));\r
-       \r
-               for (i = 0; i < ifp->desc.bNumEndpoints; i++) {\r
-                       header = (struct usb_descriptor_header *)buffer;\r
-\r
-                       if (header->bLength > size) {\r
-                               err("ran out of descriptors parsing");\r
-                               return -1;\r
-                       }\r
-               \r
-                       retval = usb_parse_endpoint(ifp->endpoint + i, buffer, size);\r
-                       if (retval < 0)\r
-                               return retval;\r
-\r
-                       buffer += retval;\r
-                       parsed += retval;\r
-                       size -= retval;\r
-               }\r
-\r
-               /* We check to see if it's an alternate to this one */\r
-               d = (struct usb_interface_descriptor *)buffer;\r
-               if (size < USB_DT_INTERFACE_SIZE\r
-                               || d->bDescriptorType != USB_DT_INTERFACE\r
-                               || !d->bAlternateSetting)\r
-                       return parsed;\r
-       }\r
-\r
-       return parsed;\r
-}\r
-\r
-int usb_parse_configuration(struct usb_host_config *config, char *buffer)\r
-{\r
-       int i, retval, size;\r
-       struct usb_descriptor_header *header;\r
-\r
-       memcpy(&config->desc, buffer, USB_DT_CONFIG_SIZE);\r
-       le16_to_cpus(&config->desc.wTotalLength);\r
-       size = config->desc.wTotalLength;\r
-\r
-       if (config->desc.bNumInterfaces > USB_MAXINTERFACES) {\r
-               warn("too many interfaces");\r
-               return -1;\r
-       }\r
-\r
-       config->interface = (struct usb_interface *)\r
-               kmalloc(config->desc.bNumInterfaces *\r
-               sizeof(struct usb_interface), GFP_KERNEL);\r
-       dbg("kmalloc IF %p, numif %i", config->interface, config->desc.bNumInterfaces);\r
-       if (!config->interface) {\r
-               err("out of memory");\r
-               return -1;      \r
-       }\r
-\r
-       memset(config->interface, 0,\r
-              config->desc.bNumInterfaces * sizeof(struct usb_interface));\r
-\r
-       buffer += config->desc.bLength;\r
-       size -= config->desc.bLength;\r
-       \r
-       config->extra = NULL;\r
-       config->extralen = 0;\r
-\r
-       for (i = 0; i < config->desc.bNumInterfaces; i++) {\r
-               int numskipped, len;\r
-               char *begin;\r
-\r
-               /* Skip over the rest of the Class Specific or Vendor */\r
-               /*  Specific descriptors */\r
-               begin = buffer;\r
-               numskipped = 0;\r
-               while (size >= sizeof(struct usb_descriptor_header)) {\r
-                       header = (struct usb_descriptor_header *)buffer;\r
-\r
-                       if ((header->bLength > size) || (header->bLength < 2)) {\r
-                               err("invalid descriptor length of %d", header->bLength);\r
-                               return -1;\r
-                       }\r
-\r
-                       /* If we find another "proper" descriptor then we're done  */\r
-                       if ((header->bDescriptorType == USB_DT_ENDPOINT) ||\r
-                           (header->bDescriptorType == USB_DT_INTERFACE) ||\r
-                           (header->bDescriptorType == USB_DT_CONFIG) ||\r
-                           (header->bDescriptorType == USB_DT_DEVICE))\r
-                               break;\r
-\r
-                       dbg("skipping descriptor 0x%X", header->bDescriptorType);\r
-                       numskipped++;\r
-\r
-                       buffer += header->bLength;\r
-                       size -= header->bLength;\r
-               }\r
-               if (numskipped)\r
-                       dbg("skipped %d class/vendor specific endpoint descriptors", numskipped);\r
-\r
-               /* Copy any unknown descriptors into a storage area for */\r
-               /*  drivers to later parse */\r
-               len = (int)(buffer - begin);\r
-               if (len) {\r
-                       if (config->extralen) {\r
-                               warn("extra config descriptor");\r
-                       } else {\r
-                               config->extra = kmalloc(len, GFP_KERNEL);\r
-                               if (!config->extra) {\r
-                                       err("couldn't allocate memory for config extra descriptors");\r
-                                       config->extralen = 0;\r
-                                       return -1;\r
-                               }\r
-\r
-                               memcpy(config->extra, begin, len);\r
-                               config->extralen = len;\r
-                       }\r
-               }\r
-\r
-               retval = usb_parse_interface(config->interface + i, buffer, size);\r
-               if (retval < 0)\r
-                       return retval;\r
-\r
-               buffer += retval;\r
-               size -= retval;\r
-       }\r
-\r
-       return size;\r
-}\r
-\r
-// hub-only!! ... and only exported for reset/reinit path.\r
-// otherwise used internally on disconnect/destroy path\r
-void usb_destroy_configuration(struct usb_device *dev)\r
-{\r
-       int c, i, j, k;\r
-       \r
-       if (!dev->config)\r
-               return;\r
-\r
-       if (dev->rawdescriptors) {\r
-               for (i = 0; i < dev->descriptor.bNumConfigurations; i++)\r
-                       kfree(dev->rawdescriptors[i]);\r
-\r
-               kfree(dev->rawdescriptors);\r
-       }\r
-\r
-       for (c = 0; c < dev->descriptor.bNumConfigurations; c++) {\r
-               struct usb_host_config *cf = &dev->config[c];\r
-\r
-               if (!cf->interface)\r
-                       break;\r
-\r
-               for (i = 0; i < cf->desc.bNumInterfaces; i++) {\r
-                       struct usb_interface *ifp =\r
-                               &cf->interface[i];\r
-                               \r
-                       if (!ifp->altsetting)\r
-                               break;\r
-\r
-                       for (j = 0; j < ifp->num_altsetting; j++) {\r
-                               struct usb_host_interface *as =\r
-                                       &ifp->altsetting[j];\r
-                                       \r
-                               if(as->extra) {\r
-                                       kfree(as->extra);\r
-                               }\r
-\r
-                               if (!as->endpoint)\r
-                                       break;\r
-                                       \r
-                               for(k = 0; k < as->desc.bNumEndpoints; k++) {\r
-                                       if(as->endpoint[k].extra) {\r
-                                               kfree(as->endpoint[k].extra);\r
-                                       }\r
-                               }       \r
-                               kfree(as->endpoint);\r
-                       }\r
-\r
-                       kfree(ifp->altsetting);\r
-               }\r
-               kfree(cf->interface);\r
-       }\r
-       kfree(dev->config);\r
-}\r
-\r
-\r
-// hub-only!! ... and only in reset path, or usb_new_device()\r
-// (used by real hubs and virtual root hubs)\r
-int usb_get_configuration(struct usb_device *dev)\r
-{\r
-       int result;\r
-       unsigned int cfgno, length;\r
-       unsigned char *buffer;\r
-       unsigned char *bigbuffer;\r
-       struct usb_config_descriptor *desc;\r
-\r
-       if (dev->descriptor.bNumConfigurations > USB_MAXCONFIG) {\r
-               warn("too many configurations");\r
-               return -EINVAL;\r
-       }\r
-\r
-       if (dev->descriptor.bNumConfigurations < 1) {\r
-               warn("not enough configurations");\r
-               return -EINVAL;\r
-       }\r
-\r
-       dev->config = (struct usb_host_config *)\r
-               kmalloc(dev->descriptor.bNumConfigurations *\r
-               sizeof(struct usb_host_config), GFP_KERNEL);\r
-       if (!dev->config) {\r
-               err("out of memory");\r
-               return -ENOMEM; \r
-       }\r
-       memset(dev->config, 0, dev->descriptor.bNumConfigurations *\r
-               sizeof(struct usb_host_config));\r
-\r
-       dev->rawdescriptors = (char **)kmalloc(sizeof(char *) *\r
-               dev->descriptor.bNumConfigurations, GFP_KERNEL);\r
-       if (!dev->rawdescriptors) {\r
-               err("out of memory");\r
-               return -ENOMEM;\r
-       }\r
-\r
-       buffer = kmalloc(8, GFP_KERNEL);\r
-       if (!buffer) {\r
-               err("unable to allocate memory for configuration descriptors");\r
-               return -ENOMEM;\r
-       }\r
-       desc = (struct usb_config_descriptor *)buffer;\r
-\r
-       for (cfgno = 0; cfgno < dev->descriptor.bNumConfigurations; cfgno++) {\r
-               /* We grab the first 8 bytes so we know how long the whole */\r
-               /*  configuration is */\r
-               result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, buffer, 8);\r
-               if (result < 8) {\r
-                       if (result < 0)\r
-                               err("unable to get descriptor");\r
-                       else {\r
-                               err("config descriptor too short (expected %i, got %i)", 8, result);\r
-                               result = -EINVAL;\r
-                       }\r
-                       goto err;\r
-               }\r
-\r
-               /* Get the full buffer */\r
-               length = le16_to_cpu(desc->wTotalLength);\r
-\r
-               bigbuffer = kmalloc(length, GFP_KERNEL);\r
-               if (!bigbuffer) {\r
-                       err("unable to allocate memory for configuration descriptors");\r
-                       result = -ENOMEM;\r
-                       goto err;\r
-               }\r
-\r
-               /* Now that we know the length, get the whole thing */\r
-               result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, bigbuffer, length);\r
-               if (result < 0) {\r
-                       err("couldn't get all of config descriptors");\r
-                       kfree(bigbuffer);\r
-                       goto err;\r
-               }       \r
-       \r
-               if (result < length) {\r
-                       err("config descriptor too short (expected %i, got %i)", length, result);\r
-                       result = -EINVAL;\r
-                       kfree(bigbuffer);\r
-                       goto err;\r
-               }\r
-\r
-               dev->rawdescriptors[cfgno] = bigbuffer;\r
-\r
-               result = usb_parse_configuration(&dev->config[cfgno], bigbuffer);\r
-               if (result > 0)\r
-                       dbg("descriptor data left");\r
-               else if (result < 0) {\r
-                       result = -EINVAL;\r
-                       goto err;\r
-               }\r
-       }\r
-\r
-       kfree(buffer);\r
-       return 0;\r
-err:\r
-       kfree(buffer);\r
-       dev->descriptor.bNumConfigurations = cfgno;\r
-       return result;\r
-}\r
-\r
+#if 0
+#include <linux/usb.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <asm/byteorder.h>
+#else
+#include "../usb_wrapper.h"
+#endif
+
+#define USB_MAXALTSETTING              128     /* Hard limit */
+#define USB_MAXENDPOINTS               30      /* Hard limit */
+
+/* these maximums are arbitrary */
+#define USB_MAXCONFIG                  8
+#define USB_ALTSETTINGALLOC            4
+#define USB_MAXINTERFACES              32
+
+static int usb_parse_endpoint(struct usb_host_endpoint *endpoint, unsigned char *buffer, int size)
+{
+       struct usb_descriptor_header *header;
+       unsigned char *begin;
+       int parsed = 0, len, numskipped;
+
+       header = (struct usb_descriptor_header *)buffer;
+
+       /* Everything should be fine being passed into here, but we sanity */
+       /*  check JIC */
+       if (header->bLength > size) {
+               err("ran out of descriptors parsing");
+               return -1;
+       }
+               
+       if (header->bDescriptorType != USB_DT_ENDPOINT) {
+               warn("unexpected descriptor 0x%X, expecting endpoint, 0x%X",
+                       header->bDescriptorType, USB_DT_ENDPOINT);
+               return parsed;
+       }
+
+       if (header->bLength == USB_DT_ENDPOINT_AUDIO_SIZE)
+               memcpy(&endpoint->desc, buffer, USB_DT_ENDPOINT_AUDIO_SIZE);
+       else
+               memcpy(&endpoint->desc, buffer, USB_DT_ENDPOINT_SIZE);
+       
+       le16_to_cpus(&endpoint->desc.wMaxPacketSize);
+
+       buffer += header->bLength;
+       size -= header->bLength;
+       parsed += header->bLength;
+
+       /* Skip over the rest of the Class Specific or Vendor Specific */
+       /*  descriptors */
+       begin = buffer;
+       numskipped = 0;
+       while (size >= sizeof(struct usb_descriptor_header)) {
+               header = (struct usb_descriptor_header *)buffer;
+
+               if (header->bLength < 2) {
+                       err("invalid descriptor length of %d", header->bLength);
+                       return -1;
+               }
+
+               /* If we find another "proper" descriptor then we're done  */
+               if ((header->bDescriptorType == USB_DT_ENDPOINT) ||
+                   (header->bDescriptorType == USB_DT_INTERFACE) ||
+                   (header->bDescriptorType == USB_DT_CONFIG) ||
+                   (header->bDescriptorType == USB_DT_DEVICE))
+                       break;
+
+               dbg("skipping descriptor 0x%X",
+                       header->bDescriptorType);
+               numskipped++;
+
+               buffer += header->bLength;
+               size -= header->bLength;
+               parsed += header->bLength;
+       }
+       if (numskipped)
+               dbg("skipped %d class/vendor specific endpoint descriptors", numskipped);
+
+       /* Copy any unknown descriptors into a storage area for drivers */
+       /*  to later parse */
+       len = (int)(buffer - begin);
+       if (!len) {
+               endpoint->extra = NULL;
+               endpoint->extralen = 0;
+               return parsed;
+       }
+
+       endpoint->extra = kmalloc(len, GFP_KERNEL);
+
+       if (!endpoint->extra) {
+               err("couldn't allocate memory for endpoint extra descriptors");
+               endpoint->extralen = 0;
+               return parsed;
+       }
+
+       memcpy(endpoint->extra, begin, len);
+       endpoint->extralen = len;
+
+       return parsed;
+}
+
+static int usb_parse_interface(struct usb_interface *interface, unsigned char *buffer, int size)
+{
+       int i, len, numskipped, retval, parsed = 0;
+       struct usb_descriptor_header *header;
+       struct usb_host_interface *ifp;
+       unsigned char *begin;
+
+       interface->act_altsetting = 0;
+       interface->num_altsetting = 0;
+       interface->max_altsetting = USB_ALTSETTINGALLOC;
+       device_initialize(&interface->dev);
+
+       interface->altsetting = kmalloc(sizeof(*interface->altsetting) * interface->max_altsetting,
+                                       GFP_KERNEL);
+       
+       if (!interface->altsetting) {
+               err("couldn't kmalloc interface->altsetting");
+               return -1;
+       }
+
+       while (size > 0) {
+               struct usb_interface_descriptor *d;
+       
+               if (interface->num_altsetting >= interface->max_altsetting) {
+                       struct usb_host_interface *ptr;
+                       int oldmas;
+
+                       oldmas = interface->max_altsetting;
+                       interface->max_altsetting += USB_ALTSETTINGALLOC;
+                       if (interface->max_altsetting > USB_MAXALTSETTING) {
+                               warn("too many alternate settings (incr %d max %d)\n",
+                                       USB_ALTSETTINGALLOC, USB_MAXALTSETTING);
+                               return -1;
+                       }
+
+                       ptr = kmalloc(sizeof(*ptr) * interface->max_altsetting, GFP_KERNEL);
+                       if (ptr == NULL) {
+                               err("couldn't kmalloc interface->altsetting");
+                               return -1;
+                       }
+                       memcpy(ptr, interface->altsetting, sizeof(*interface->altsetting) * oldmas);
+                       kfree(interface->altsetting);
+                       interface->altsetting = ptr;
+               }
+
+               ifp = interface->altsetting + interface->num_altsetting;
+               ifp->endpoint = NULL;
+               ifp->extra = NULL;
+               ifp->extralen = 0;
+               interface->num_altsetting++;
+
+               memcpy(ifp, buffer, USB_DT_INTERFACE_SIZE);
+
+               /* Skip over the interface */
+               buffer += ifp->desc.bLength;
+               parsed += ifp->desc.bLength;
+               size -= ifp->desc.bLength;
+
+               begin = buffer;
+               numskipped = 0;
+
+               /* Skip over any interface, class or vendor descriptors */
+               while (size >= sizeof(struct usb_descriptor_header)) {
+                       header = (struct usb_descriptor_header *)buffer;
+
+                       if (header->bLength < 2) {
+                               err("invalid descriptor length of %d", header->bLength);
+                               return -1;
+                       }
+
+                       /* If we find another "proper" descriptor then we're done  */
+                       if ((header->bDescriptorType == USB_DT_INTERFACE) ||
+                           (header->bDescriptorType == USB_DT_ENDPOINT) ||
+                           (header->bDescriptorType == USB_DT_CONFIG) ||
+                           (header->bDescriptorType == USB_DT_DEVICE))
+                               break;
+
+                       numskipped++;
+
+                       buffer += header->bLength;
+                       parsed += header->bLength;
+                       size -= header->bLength;
+               }
+
+               if (numskipped)
+                       dbg("skipped %d class/vendor specific interface descriptors", numskipped);
+
+               /* Copy any unknown descriptors into a storage area for */
+               /*  drivers to later parse */
+               len = (int)(buffer - begin);
+               if (len) {
+                       ifp->extra = kmalloc(len, GFP_KERNEL);
+
+                       if (!ifp->extra) {
+                               err("couldn't allocate memory for interface extra descriptors");
+                               ifp->extralen = 0;
+                               return -1;
+                       }
+                       memcpy(ifp->extra, begin, len);
+                       ifp->extralen = len;
+               }
+
+               /* Did we hit an unexpected descriptor? */
+               header = (struct usb_descriptor_header *)buffer;
+               if ((size >= sizeof(struct usb_descriptor_header)) &&
+                   ((header->bDescriptorType == USB_DT_CONFIG) ||
+                    (header->bDescriptorType == USB_DT_DEVICE)))
+                       return parsed;
+
+               if (ifp->desc.bNumEndpoints > USB_MAXENDPOINTS) {
+                       warn("too many endpoints");
+                       return -1;
+               }
+
+               ifp->endpoint = (struct usb_host_endpoint *)
+                       kmalloc(ifp->desc.bNumEndpoints *
+                       sizeof(struct usb_host_endpoint), GFP_KERNEL);
+               if (!ifp->endpoint) {
+                       err("out of memory");
+                       return -1;      
+               }
+
+               memset(ifp->endpoint, 0, ifp->desc.bNumEndpoints *
+                       sizeof(struct usb_host_endpoint));
+       
+               for (i = 0; i < ifp->desc.bNumEndpoints; i++) {
+                       header = (struct usb_descriptor_header *)buffer;
+
+                       if (header->bLength > size) {
+                               err("ran out of descriptors parsing");
+                               return -1;
+                       }
+               
+                       retval = usb_parse_endpoint(ifp->endpoint + i, buffer, size);
+                       if (retval < 0)
+                               return retval;
+
+                       buffer += retval;
+                       parsed += retval;
+                       size -= retval;
+               }
+
+               /* We check to see if it's an alternate to this one */
+               d = (struct usb_interface_descriptor *)buffer;
+               if (size < USB_DT_INTERFACE_SIZE
+                               || d->bDescriptorType != USB_DT_INTERFACE
+                               || !d->bAlternateSetting)
+                       return parsed;
+       }
+
+       return parsed;
+}
+
+int usb_parse_configuration(struct usb_host_config *config, char *buffer)
+{
+       int i, retval, size;
+       struct usb_descriptor_header *header;
+
+       memcpy(&config->desc, buffer, USB_DT_CONFIG_SIZE);
+       le16_to_cpus(&config->desc.wTotalLength);
+       size = config->desc.wTotalLength;
+
+       if (config->desc.bNumInterfaces > USB_MAXINTERFACES) {
+               warn("too many interfaces");
+               return -1;
+       }
+
+       config->interface = (struct usb_interface *)
+               kmalloc(config->desc.bNumInterfaces *
+               sizeof(struct usb_interface), GFP_KERNEL);
+       dbg("kmalloc IF %p, numif %i", config->interface, config->desc.bNumInterfaces);
+       if (!config->interface) {
+               err("out of memory");
+               return -1;      
+       }
+
+       memset(config->interface, 0,
+              config->desc.bNumInterfaces * sizeof(struct usb_interface));
+
+       buffer += config->desc.bLength;
+       size -= config->desc.bLength;
+       
+       config->extra = NULL;
+       config->extralen = 0;
+
+       for (i = 0; i < config->desc.bNumInterfaces; i++) {
+               int numskipped, len;
+               char *begin;
+
+               /* Skip over the rest of the Class Specific or Vendor */
+               /*  Specific descriptors */
+               begin = buffer;
+               numskipped = 0;
+               while (size >= sizeof(struct usb_descriptor_header)) {
+                       header = (struct usb_descriptor_header *)buffer;
+
+                       if ((header->bLength > size) || (header->bLength < 2)) {
+                               err("invalid descriptor length of %d", header->bLength);
+                               return -1;
+                       }
+
+                       /* If we find another "proper" descriptor then we're done  */
+                       if ((header->bDescriptorType == USB_DT_ENDPOINT) ||
+                           (header->bDescriptorType == USB_DT_INTERFACE) ||
+                           (header->bDescriptorType == USB_DT_CONFIG) ||
+                           (header->bDescriptorType == USB_DT_DEVICE))
+                               break;
+
+                       dbg("skipping descriptor 0x%X", header->bDescriptorType);
+                       numskipped++;
+
+                       buffer += header->bLength;
+                       size -= header->bLength;
+               }
+               if (numskipped)
+                       dbg("skipped %d class/vendor specific endpoint descriptors", numskipped);
+
+               /* Copy any unknown descriptors into a storage area for */
+               /*  drivers to later parse */
+               len = (int)(buffer - begin);
+               if (len) {
+                       if (config->extralen) {
+                               warn("extra config descriptor");
+                       } else {
+                               config->extra = kmalloc(len, GFP_KERNEL);
+                               if (!config->extra) {
+                                       err("couldn't allocate memory for config extra descriptors");
+                                       config->extralen = 0;
+                                       return -1;
+                               }
+
+                               memcpy(config->extra, begin, len);
+                               config->extralen = len;
+                       }
+               }
+
+               retval = usb_parse_interface(config->interface + i, buffer, size);
+               if (retval < 0)
+                       return retval;
+
+               buffer += retval;
+               size -= retval;
+       }
+
+       return size;
+}
+
+// hub-only!! ... and only exported for reset/reinit path.
+// otherwise used internally on disconnect/destroy path
+void usb_destroy_configuration(struct usb_device *dev)
+{
+       int c, i, j, k;
+       
+       if (!dev->config)
+               return;
+
+       if (dev->rawdescriptors) {
+               for (i = 0; i < dev->descriptor.bNumConfigurations; i++)
+                       kfree(dev->rawdescriptors[i]);
+
+               kfree(dev->rawdescriptors);
+       }
+
+       for (c = 0; c < dev->descriptor.bNumConfigurations; c++) {
+               struct usb_host_config *cf = &dev->config[c];
+
+               if (!cf->interface)
+                       break;
+
+               for (i = 0; i < cf->desc.bNumInterfaces; i++) {
+                       struct usb_interface *ifp =
+                               &cf->interface[i];
+                               
+                       if (!ifp->altsetting)
+                               break;
+
+                       for (j = 0; j < ifp->num_altsetting; j++) {
+                               struct usb_host_interface *as =
+                                       &ifp->altsetting[j];
+                                       
+                               if(as->extra) {
+                                       kfree(as->extra);
+                               }
+
+                               if (!as->endpoint)
+                                       break;
+                                       
+                               for(k = 0; k < as->desc.bNumEndpoints; k++) {
+                                       if(as->endpoint[k].extra) {
+                                               kfree(as->endpoint[k].extra);
+                                       }
+                               }       
+                               kfree(as->endpoint);
+                       }
+
+                       kfree(ifp->altsetting);
+               }
+               kfree(cf->interface);
+       }
+       kfree(dev->config);
+}
+
+
+// hub-only!! ... and only in reset path, or usb_new_device()
+// (used by real hubs and virtual root hubs)
+int usb_get_configuration(struct usb_device *dev)
+{
+       int result;
+       unsigned int cfgno, length;
+       unsigned char *buffer;
+       unsigned char *bigbuffer;
+       struct usb_config_descriptor *desc;
+
+       if (dev->descriptor.bNumConfigurations > USB_MAXCONFIG) {
+               warn("too many configurations");
+               return -EINVAL;
+       }
+
+       if (dev->descriptor.bNumConfigurations < 1) {
+               warn("not enough configurations");
+               return -EINVAL;
+       }
+
+       dev->config = (struct usb_host_config *)
+               kmalloc(dev->descriptor.bNumConfigurations *
+               sizeof(struct usb_host_config), GFP_KERNEL);
+       if (!dev->config) {
+               err("out of memory");
+               return -ENOMEM; 
+       }
+       memset(dev->config, 0, dev->descriptor.bNumConfigurations *
+               sizeof(struct usb_host_config));
+
+       dev->rawdescriptors = (char **)kmalloc(sizeof(char *) *
+               dev->descriptor.bNumConfigurations, GFP_KERNEL);
+       if (!dev->rawdescriptors) {
+               err("out of memory");
+               return -ENOMEM;
+       }
+
+       buffer = kmalloc(8, GFP_KERNEL);
+       if (!buffer) {
+               err("unable to allocate memory for configuration descriptors");
+               return -ENOMEM;
+       }
+       desc = (struct usb_config_descriptor *)buffer;
+
+       for (cfgno = 0; cfgno < dev->descriptor.bNumConfigurations; cfgno++) {
+               /* We grab the first 8 bytes so we know how long the whole */
+               /*  configuration is */
+               result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, buffer, 8);
+               if (result < 8) {
+                       if (result < 0)
+                               err("unable to get descriptor");
+                       else {
+                               err("config descriptor too short (expected %i, got %i)", 8, result);
+                               result = -EINVAL;
+                       }
+                       goto err;
+               }
+
+               /* Get the full buffer */
+               length = le16_to_cpu(desc->wTotalLength);
+
+               bigbuffer = kmalloc(length, GFP_KERNEL);
+               if (!bigbuffer) {
+                       err("unable to allocate memory for configuration descriptors");
+                       result = -ENOMEM;
+                       goto err;
+               }
+
+               /* Now that we know the length, get the whole thing */
+               result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, bigbuffer, length);
+               if (result < 0) {
+                       err("couldn't get all of config descriptors");
+                       kfree(bigbuffer);
+                       goto err;
+               }       
+       
+               if (result < length) {
+                       err("config descriptor too short (expected %i, got %i)", length, result);
+                       result = -EINVAL;
+                       kfree(bigbuffer);
+                       goto err;
+               }
+
+               dev->rawdescriptors[cfgno] = bigbuffer;
+
+               result = usb_parse_configuration(&dev->config[cfgno], bigbuffer);
+               if (result > 0)
+                       dbg("descriptor data left");
+               else if (result < 0) {
+                       result = -EINVAL;
+                       goto err;
+               }
+       }
+
+       kfree(buffer);
+       return 0;
+err:
+       kfree(buffer);
+       dev->descriptor.bNumConfigurations = cfgno;
+       return result;
+}
+
index 148cf85..42afc27 100644 (file)
-/*\r
- * (C) Copyright David Brownell 2000-2002\r
- * \r
- * This program is free software; you can redistribute it and/or modify it\r
- * under the terms of the GNU General Public License as published by the\r
- * Free Software Foundation; either version 2 of the License, or (at your\r
- * option) any later version.\r
- *\r
- * This program is distributed in the hope that it will be useful, but\r
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\r
- * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License\r
- * for more details.\r
- *\r
- * You should have received a copy of the GNU General Public License\r
- * along with this program; if not, write to the Free Software Foundation,\r
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\r
- */\r
-\r
-#if 0\r
-#include <linux/config.h>\r
-\r
-#ifdef CONFIG_USB_DEBUG\r
-       #define DEBUG\r
-#else\r
-       #undef DEBUG\r
-#endif\r
-\r
-#include <linux/kernel.h>\r
-#include <linux/module.h>\r
-#include <linux/pci.h>\r
-#include <asm/io.h>\r
-#include <asm/irq.h>\r
-#include <linux/usb.h>\r
-#include "hcd.h"\r
-#else\r
-#define DEBUG\r
-#include "../usb_wrapper.h"\r
-#include "hcd.h"\r
-#endif\r
-\r
-\r
-/* PCI-based HCs are normal, but custom bus glue should be ok */\r
-\r
-\r
-/*-------------------------------------------------------------------------*/\r
-\r
-/* configure so an HC device and id are always provided */\r
-/* always called with process context; sleeping is OK */\r
-\r
-/**\r
- * usb_hcd_pci_probe - initialize PCI-based HCDs\r
- * @dev: USB Host Controller being probed\r
- * @id: pci hotplug id connecting controller to HCD framework\r
- * Context: !in_interrupt()\r
- *\r
- * Allocates basic PCI resources for this USB host controller, and\r
- * then invokes the start() method for the HCD associated with it\r
- * through the hotplug entry's driver_data.\r
- *\r
- * Store this function in the HCD's struct pci_driver as probe().\r
- */\r
-int STDCALL usb_hcd_pci_probe (struct pci_dev *dev, const struct pci_device_id *id)\r
-{\r
-       struct hc_driver        *driver;\r
-       PHYSICAL_ADDRESS        resource;\r
-       unsigned long           len;\r
-       void                    *base;\r
-       struct usb_hcd          *hcd;\r
-       int                     retval, region;\r
-       char                    buf [8];\r
-       //char                  *bufp = buf;\r
-\r
-       printk("usbcore: usb_hcd_pci_probe() called\n");\r
-\r
-       if (usb_disabled())\r
-               return -ENODEV;\r
-\r
-       if (!id || !(driver = (struct hc_driver *) id->driver_data))\r
-               return -EINVAL;\r
-\r
-       if (pci_enable_device (dev) < 0)\r
-               return -ENODEV;\r
-\r
-        if (!dev->irq) {\r
-               err ("Found HC with no IRQ.  Check BIOS/PCI %s setup!",\r
-                       dev->slot_name);\r
-               return -ENODEV;\r
-        }\r
-\r
-       if (driver->flags & HCD_MEMORY) {       // EHCI, OHCI\r
-               region = 0;\r
-               resource = pci_resource_start (dev, 0);\r
-               len = pci_resource_len (dev, 0);\r
-               if (!request_mem_region (resource, len, driver->description)) {\r
-                       dbg ("controller already in use");\r
-                       return -EBUSY;\r
-               }\r
-               base = ioremap_nocache (resource, len);\r
-               if (base == NULL) {\r
-                       dbg ("error mapping memory");\r
-                       retval = -EFAULT;\r
-clean_1:\r
-                       release_mem_region (resource, len);\r
-                       err ("init %s fail, %d", dev->slot_name, retval);\r
-                       return retval;\r
-               }\r
-\r
-       } else {                                // UHCI\r
-               //resource = 0;\r
-               len = 0;\r
-               for (region = 0; region < PCI_ROM_RESOURCE; region++) {\r
-                       if (!(pci_resource_flags (dev, region) & IORESOURCE_IO))\r
-                               continue;\r
-\r
-                       resource = pci_resource_start (dev, region);\r
-                       len = pci_resource_len (dev, region);\r
-                       if (request_region (resource, len,\r
-                                       driver->description))\r
-                               break;\r
-               }\r
-               if (region == PCI_ROM_RESOURCE) {\r
-                       dbg ("no i/o regions available");\r
-                       return -EBUSY;\r
-               }\r
-               base = (void *) (ULONG_PTR)resource.u.LowPart;\r
-       }\r
-\r
-       // driver->start(), later on, will transfer device from\r
-       // control by SMM/BIOS to control by Linux (if needed)\r
-\r
-       pci_set_master (dev);\r
-\r
-       hcd = driver->hcd_alloc ();\r
-       if (hcd == NULL){\r
-               dbg ("hcd alloc fail");\r
-               retval = -ENOMEM;\r
-clean_2:\r
-               if (driver->flags & HCD_MEMORY) {\r
-                       iounmap (base);\r
-                       goto clean_1;\r
-               } else {\r
-                       release_region (resource, len);\r
-                       err ("init %s fail, %d", dev->slot_name, retval);\r
-                       return retval;\r
-               }\r
-       }\r
-       pci_set_drvdata (dev, hcd);\r
-       hcd->driver = driver;\r
-       hcd->description = driver->description;\r
-       hcd->pdev = dev;\r
-       hcd->self.bus_name = dev->slot_name;\r
-       hcd->product_desc = dev->dev.name;\r
-       hcd->self.controller = &dev->dev;\r
-       hcd->controller = hcd->self.controller;\r
-\r
-       if ((retval = hcd_buffer_create (hcd)) != 0) {\r
-clean_3:\r
-               driver->hcd_free (hcd);\r
-               goto clean_2;\r
-       }\r
-\r
-       dev_info (hcd->controller, "%s\n", hcd->product_desc);\r
-\r
-#ifndef __sparc__\r
-       sprintf (buf, "%d", dev->irq);\r
-#else\r
-       bufp = __irq_itoa(dev->irq);\r
-#endif\r
-       if (request_irq (dev->irq, usb_hcd_irq, SA_SHIRQ, hcd->description, hcd)\r
-                       != 0) {\r
-               dev_err (hcd->controller,\r
-                               "request interrupt %s failed\n", buf);\r
-               retval = -EBUSY;\r
-               goto clean_3;\r
-       }\r
-       hcd->irq = dev->irq;\r
-\r
-       hcd->regs = base;\r
-       hcd->region = region;\r
-       dev_info (hcd->controller, "irq %s, %s %p\n", buf,\r
-               (driver->flags & HCD_MEMORY) ? "pci mem" : "io base",\r
-               base);\r
-\r
-       usb_bus_init (&hcd->self);\r
-       hcd->self.op = &usb_hcd_operations;\r
-       hcd->self.hcpriv = (void *) hcd;\r
-\r
-       INIT_LIST_HEAD (&hcd->dev_list);\r
-\r
-       usb_register_bus (&hcd->self);\r
-\r
-       if ((retval = driver->start (hcd)) < 0)\r
-               usb_hcd_pci_remove (dev);\r
-\r
-       return retval;\r
-} \r
-EXPORT_SYMBOL (usb_hcd_pci_probe);\r
-\r
-\r
-/* may be called without controller electrically present */\r
-/* may be called with controller, bus, and devices active */\r
-\r
-/**\r
- * usb_hcd_pci_remove - shutdown processing for PCI-based HCDs\r
- * @dev: USB Host Controller being removed\r
- * Context: !in_interrupt()\r
- *\r
- * Reverses the effect of usb_hcd_pci_probe(), first invoking\r
- * the HCD's stop() method.  It is always called from a thread\r
- * context, normally "rmmod", "apmd", or something similar.\r
- *\r
- * Store this function in the HCD's struct pci_driver as remove().\r
- */\r
-void STDCALL usb_hcd_pci_remove (struct pci_dev *dev)\r
-{\r
-       struct usb_hcd          *hcd;\r
-       struct usb_device       *hub;\r
-\r
-       hcd = pci_get_drvdata(dev);\r
-       if (!hcd)\r
-               return;\r
-       dev_info (hcd->controller, "remove, state %x\n", hcd->state);\r
-\r
-       if (in_interrupt ())\r
-               BUG ();\r
-\r
-       hub = hcd->self.root_hub;\r
-       hcd->state = USB_STATE_QUIESCING;\r
-\r
-       dev_dbg (hcd->controller, "roothub graceful disconnect\n");\r
-       usb_disconnect (&hub);\r
-\r
-       hcd->driver->stop (hcd);\r
-       hcd_buffer_destroy (hcd);\r
-       hcd->state = USB_STATE_HALT;\r
-       pci_set_drvdata (dev, 0);\r
-\r
-       free_irq (hcd->irq, hcd);\r
-       if (hcd->driver->flags & HCD_MEMORY) {\r
-               iounmap (hcd->regs);\r
-               release_mem_region (pci_resource_start (dev, 0),\r
-                       pci_resource_len (dev, 0));\r
-       } else {\r
-               release_region (pci_resource_start (dev, hcd->region),\r
-                       pci_resource_len (dev, hcd->region));\r
-       }\r
-\r
-       usb_deregister_bus (&hcd->self);\r
-       if (atomic_read (&hcd->self.refcnt) != 1) {\r
-               dev_warn (hcd->controller,\r
-                       "dangling refs (%d) to bus %d!\n",\r
-                       atomic_read (&hcd->self.refcnt) - 1,\r
-                       hcd->self.busnum);\r
-       }\r
-       hcd->driver->hcd_free (hcd);\r
-}\r
-EXPORT_SYMBOL (usb_hcd_pci_remove);\r
-\r
-\r
-#ifdef CONFIG_PM\r
-\r
-/*\r
- * Some "sleep" power levels imply updating struct usb_driver\r
- * to include a callback asking hcds to do their bit by checking\r
- * if all the drivers can suspend.  Gets involved with remote wakeup.\r
- *\r
- * If there are pending urbs, then HCs will need to access memory,\r
- * causing extra power drain.  New sleep()/wakeup() PM calls might\r
- * be needed, beyond PCI suspend()/resume().  The root hub timer\r
- * still be accessing memory though ...\r
- *\r
- * FIXME:  USB should have some power budgeting support working with\r
- * all kinds of hubs.\r
- *\r
- * FIXME:  This assumes only D0->D3 suspend and D3->D0 resume.\r
- * D1 and D2 states should do something, yes?\r
- *\r
- * FIXME:  Should provide generic enable_wake(), calling pci_enable_wake()\r
- * for all supported states, so that USB remote wakeup can work for any\r
- * devices that support it (and are connected via powered hubs).\r
- *\r
- * FIXME:  resume doesn't seem to work right any more...\r
- */\r
-\r
-\r
-// 2.4 kernels have issued concurrent resumes (w/APM)\r
-// we defend against that error; PCI doesn't yet.\r
-\r
-/**\r
- * usb_hcd_pci_suspend - power management suspend of a PCI-based HCD\r
- * @dev: USB Host Controller being suspended\r
- *\r
- * Store this function in the HCD's struct pci_driver as suspend().\r
- */\r
-int usb_hcd_pci_suspend (struct pci_dev *dev, u32 state)\r
-{\r
-       struct usb_hcd          *hcd;\r
-       int                     retval;\r
-\r
-       hcd = pci_get_drvdata(dev);\r
-       dev_info (hcd->controller, "suspend to state %d\n", state);\r
-\r
-       pci_save_state (dev, hcd->pci_state);\r
-\r
-       // FIXME for all connected devices, leaf-to-root:\r
-       // driver->suspend()\r
-       // proposed "new 2.5 driver model" will automate that\r
-\r
-       /* driver may want to disable DMA etc */\r
-       retval = hcd->driver->suspend (hcd, state);\r
-       hcd->state = USB_STATE_SUSPENDED;\r
-\r
-       pci_set_power_state (dev, state);\r
-       return retval;\r
-}\r
-EXPORT_SYMBOL (usb_hcd_pci_suspend);\r
-\r
-/**\r
- * usb_hcd_pci_resume - power management resume of a PCI-based HCD\r
- * @dev: USB Host Controller being resumed\r
- *\r
- * Store this function in the HCD's struct pci_driver as resume().\r
- */\r
-int usb_hcd_pci_resume (struct pci_dev *dev)\r
-{\r
-       struct usb_hcd          *hcd;\r
-       int                     retval;\r
-\r
-       hcd = pci_get_drvdata(dev);\r
-       dev_info (hcd->controller, "resume\n");\r
-\r
-       /* guard against multiple resumes (APM bug?) */\r
-       atomic_inc (&hcd->resume_count);\r
-       if (atomic_read (&hcd->resume_count) != 1) {\r
-               dev_err (hcd->controller, "concurrent PCI resumes\n");\r
-               retval = 0;\r
-               goto done;\r
-       }\r
-\r
-       retval = -EBUSY;\r
-       if (hcd->state != USB_STATE_SUSPENDED) {\r
-               dev_dbg (hcd->controller, "can't resume, not suspended!\n");\r
-               goto done;\r
-       }\r
-       hcd->state = USB_STATE_RESUMING;\r
-\r
-       pci_set_power_state (dev, 0);\r
-       pci_restore_state (dev, hcd->pci_state);\r
-\r
-       retval = hcd->driver->resume (hcd);\r
-       if (!HCD_IS_RUNNING (hcd->state)) {\r
-               dev_dbg (hcd->controller, "resume fail, retval %d\n", retval);\r
-               usb_hc_died (hcd);\r
-// FIXME:  recover, reset etc.\r
-       } else {\r
-               // FIXME for all connected devices, root-to-leaf:\r
-               // driver->resume ();\r
-               // proposed "new 2.5 driver model" will automate that\r
-       }\r
-\r
-done:\r
-       atomic_dec (&hcd->resume_count);\r
-       return retval;\r
-}\r
-EXPORT_SYMBOL (usb_hcd_pci_resume);\r
-\r
-#endif /* CONFIG_PM */\r
-\r
-\r
+/*
+ * (C) Copyright David Brownell 2000-2002
+ * 
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#if 0
+#include <linux/config.h>
+
+#ifdef CONFIG_USB_DEBUG
+       #define DEBUG
+#else
+       #undef DEBUG
+#endif
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <asm/io.h>
+#include <asm/irq.h>
+#include <linux/usb.h>
+#include "hcd.h"
+#else
+#define DEBUG
+#include "../usb_wrapper.h"
+#include "hcd.h"
+#endif
+
+
+/* PCI-based HCs are normal, but custom bus glue should be ok */
+
+
+/*-------------------------------------------------------------------------*/
+
+/* configure so an HC device and id are always provided */
+/* always called with process context; sleeping is OK */
+
+/**
+ * usb_hcd_pci_probe - initialize PCI-based HCDs
+ * @dev: USB Host Controller being probed
+ * @id: pci hotplug id connecting controller to HCD framework
+ * Context: !in_interrupt()
+ *
+ * Allocates basic PCI resources for this USB host controller, and
+ * then invokes the start() method for the HCD associated with it
+ * through the hotplug entry's driver_data.
+ *
+ * Store this function in the HCD's struct pci_driver as probe().
+ */
+int STDCALL usb_hcd_pci_probe (struct pci_dev *dev, const struct pci_device_id *id)
+{
+       struct hc_driver        *driver;
+       PHYSICAL_ADDRESS        resource;
+       unsigned long           len;
+       void                    *base;
+       struct usb_hcd          *hcd;
+       int                     retval, region;
+       char                    buf [8];
+       //char                  *bufp = buf;
+
+       printk("usbcore: usb_hcd_pci_probe() called\n");
+
+       if (usb_disabled())
+               return -ENODEV;
+
+       if (!id || !(driver = (struct hc_driver *) id->driver_data))
+               return -EINVAL;
+
+       if (pci_enable_device (dev) < 0)
+               return -ENODEV;
+
+        if (!dev->irq) {
+               err ("Found HC with no IRQ.  Check BIOS/PCI %s setup!",
+                       dev->slot_name);
+               return -ENODEV;
+        }
+
+       if (driver->flags & HCD_MEMORY) {       // EHCI, OHCI
+               region = 0;
+               resource = pci_resource_start (dev, 0);
+               len = pci_resource_len (dev, 0);
+               if (!request_mem_region (resource, len, driver->description)) {
+                       dbg ("controller already in use");
+                       return -EBUSY;
+               }
+               base = ioremap_nocache (resource, len);
+               if (base == NULL) {
+                       dbg ("error mapping memory");
+                       retval = -EFAULT;
+clean_1:
+                       release_mem_region (resource, len);
+                       err ("init %s fail, %d", dev->slot_name, retval);
+                       return retval;
+               }
+
+       } else {                                // UHCI
+               //resource = 0;
+               len = 0;
+               for (region = 0; region < PCI_ROM_RESOURCE; region++) {
+                       if (!(pci_resource_flags (dev, region) & IORESOURCE_IO))
+                               continue;
+
+                       resource = pci_resource_start (dev, region);
+                       len = pci_resource_len (dev, region);
+                       if (request_region (resource, len,
+                                       driver->description))
+                               break;
+               }
+               if (region == PCI_ROM_RESOURCE) {
+                       dbg ("no i/o regions available");
+                       return -EBUSY;
+               }
+               base = (void *) (ULONG_PTR)resource.u.LowPart;
+       }
+
+       // driver->start(), later on, will transfer device from
+       // control by SMM/BIOS to control by Linux (if needed)
+
+       pci_set_master (dev);
+
+       hcd = driver->hcd_alloc ();
+       if (hcd == NULL){
+               dbg ("hcd alloc fail");
+               retval = -ENOMEM;
+clean_2:
+               if (driver->flags & HCD_MEMORY) {
+                       iounmap (base);
+                       goto clean_1;
+               } else {
+                       release_region (resource, len);
+                       err ("init %s fail, %d", dev->slot_name, retval);
+                       return retval;
+               }
+       }
+       pci_set_drvdata (dev, hcd);
+       hcd->driver = driver;
+       hcd->description = driver->description;
+       hcd->pdev = dev;
+       hcd->self.bus_name = dev->slot_name;
+       hcd->product_desc = dev->dev.name;
+       hcd->self.controller = &dev->dev;
+       hcd->controller = hcd->self.controller;
+
+       if ((retval = hcd_buffer_create (hcd)) != 0) {
+clean_3:
+               driver->hcd_free (hcd);
+               goto clean_2;
+       }
+
+       dev_info (hcd->controller, "%s\n", hcd->product_desc);
+
+#ifndef __sparc__
+       sprintf (buf, "%d", dev->irq);
+#else
+       bufp = __irq_itoa(dev->irq);
+#endif
+       if (request_irq (dev->irq, usb_hcd_irq, SA_SHIRQ, hcd->description, hcd)
+                       != 0) {
+               dev_err (hcd->controller,
+                               "request interrupt %s failed\n", buf);
+               retval = -EBUSY;
+               goto clean_3;
+       }
+       hcd->irq = dev->irq;
+
+       hcd->regs = base;
+       hcd->region = region;
+       dev_info (hcd->controller, "irq %s, %s %p\n", buf,
+               (driver->flags & HCD_MEMORY) ? "pci mem" : "io base",
+               base);
+
+       usb_bus_init (&hcd->self);
+       hcd->self.op = &usb_hcd_operations;
+       hcd->self.hcpriv = (void *) hcd;
+
+       INIT_LIST_HEAD (&hcd->dev_list);
+
+       usb_register_bus (&hcd->self);
+
+       if ((retval = driver->start (hcd)) < 0)
+               usb_hcd_pci_remove (dev);
+
+       return retval;
+} 
+EXPORT_SYMBOL (usb_hcd_pci_probe);
+
+
+/* may be called without controller electrically present */
+/* may be called with controller, bus, and devices active */
+
+/**
+ * usb_hcd_pci_remove - shutdown processing for PCI-based HCDs
+ * @dev: USB Host Controller being removed
+ * Context: !in_interrupt()
+ *
+ * Reverses the effect of usb_hcd_pci_probe(), first invoking
+ * the HCD's stop() method.  It is always called from a thread
+ * context, normally "rmmod", "apmd", or something similar.
+ *
+ * Store this function in the HCD's struct pci_driver as remove().
+ */
+void STDCALL usb_hcd_pci_remove (struct pci_dev *dev)
+{
+       struct usb_hcd          *hcd;
+       struct usb_device       *hub;
+
+       hcd = pci_get_drvdata(dev);
+       if (!hcd)
+               return;
+       dev_info (hcd->controller, "remove, state %x\n", hcd->state);
+
+       if (in_interrupt ())
+               BUG ();
+
+       hub = hcd->self.root_hub;
+       hcd->state = USB_STATE_QUIESCING;
+
+       dev_dbg (hcd->controller, "roothub graceful disconnect\n");
+       usb_disconnect (&hub);
+
+       hcd->driver->stop (hcd);
+       hcd_buffer_destroy (hcd);
+       hcd->state = USB_STATE_HALT;
+       pci_set_drvdata (dev, 0);
+
+       free_irq (hcd->irq, hcd);
+       if (hcd->driver->flags & HCD_MEMORY) {
+               iounmap (hcd->regs);
+               release_mem_region (pci_resource_start (dev, 0),
+                       pci_resource_len (dev, 0));
+       } else {
+               release_region (pci_resource_start (dev, hcd->region),
+                       pci_resource_len (dev, hcd->region));
+       }
+
+       usb_deregister_bus (&hcd->self);
+       if (atomic_read (&hcd->self.refcnt) != 1) {
+               dev_warn (hcd->controller,
+                       "dangling refs (%d) to bus %d!\n",
+                       atomic_read (&hcd->self.refcnt) - 1,
+                       hcd->self.busnum);
+       }
+       hcd->driver->hcd_free (hcd);
+}
+EXPORT_SYMBOL (usb_hcd_pci_remove);
+
+
+#ifdef CONFIG_PM
+
+/*
+ * Some "sleep" power levels imply updating struct usb_driver
+ * to include a callback asking hcds to do their bit by checking
+ * if all the drivers can suspend.  Gets involved with remote wakeup.
+ *
+ * If there are pending urbs, then HCs will need to access memory,
+ * causing extra power drain.  New sleep()/wakeup() PM calls might
+ * be needed, beyond PCI suspend()/resume().  The root hub timer
+ * still be accessing memory though ...
+ *
+ * FIXME:  USB should have some power budgeting support working with
+ * all kinds of hubs.
+ *
+ * FIXME:  This assumes only D0->D3 suspend and D3->D0 resume.
+ * D1 and D2 states should do something, yes?
+ *
+ * FIXME:  Should provide generic enable_wake(), calling pci_enable_wake()
+ * for all supported states, so that USB remote wakeup can work for any
+ * devices that support it (and are connected via powered hubs).
+ *
+ * FIXME:  resume doesn't seem to work right any more...
+ */
+
+
+// 2.4 kernels have issued concurrent resumes (w/APM)
+// we defend against that error; PCI doesn't yet.
+
+/**
+ * usb_hcd_pci_suspend - power management suspend of a PCI-based HCD
+ * @dev: USB Host Controller being suspended
+ *
+ * Store this function in the HCD's struct pci_driver as suspend().
+ */
+int usb_hcd_pci_suspend (struct pci_dev *dev, u32 state)
+{
+       struct usb_hcd          *hcd;
+       int                     retval;
+
+       hcd = pci_get_drvdata(dev);
+       dev_info (hcd->controller, "suspend to state %d\n", state);
+
+       pci_save_state (dev, hcd->pci_state);
+
+       // FIXME for all connected devices, leaf-to-root:
+       // driver->suspend()
+       // proposed "new 2.5 driver model" will automate that
+
+       /* driver may want to disable DMA etc */
+       retval = hcd->driver->suspend (hcd, state);
+       hcd->state = USB_STATE_SUSPENDED;
+
+       pci_set_power_state (dev, state);
+       return retval;
+}
+EXPORT_SYMBOL (usb_hcd_pci_suspend);
+
+/**
+ * usb_hcd_pci_resume - power management resume of a PCI-based HCD
+ * @dev: USB Host Controller being resumed
+ *
+ * Store this function in the HCD's struct pci_driver as resume().
+ */
+int usb_hcd_pci_resume (struct pci_dev *dev)
+{
+       struct usb_hcd          *hcd;
+       int                     retval;
+
+       hcd = pci_get_drvdata(dev);
+       dev_info (hcd->controller, "resume\n");
+
+       /* guard against multiple resumes (APM bug?) */
+       atomic_inc (&hcd->resume_count);
+       if (atomic_read (&hcd->resume_count) != 1) {
+               dev_err (hcd->controller, "concurrent PCI resumes\n");
+               retval = 0;
+               goto done;
+       }
+
+       retval = -EBUSY;
+       if (hcd->state != USB_STATE_SUSPENDED) {
+               dev_dbg (hcd->controller, "can't resume, not suspended!\n");
+               goto done;
+       }
+       hcd->state = USB_STATE_RESUMING;
+
+       pci_set_power_state (dev, 0);
+       pci_restore_state (dev, hcd->pci_state);
+
+       retval = hcd->driver->resume (hcd);
+       if (!HCD_IS_RUNNING (hcd->state)) {
+               dev_dbg (hcd->controller, "resume fail, retval %d\n", retval);
+               usb_hc_died (hcd);
+// FIXME:  recover, reset etc.
+       } else {
+               // FIXME for all connected devices, root-to-leaf:
+               // driver->resume ();
+               // proposed "new 2.5 driver model" will automate that
+       }
+
+done:
+       atomic_dec (&hcd->resume_count);
+       return retval;
+}
+EXPORT_SYMBOL (usb_hcd_pci_resume);
+
+#endif /* CONFIG_PM */
+
+
index a9efdf7..e594362 100644 (file)
-/*\r
- * (C) Copyright Linus Torvalds 1999\r
- * (C) Copyright Johannes Erdfelt 1999-2001\r
- * (C) Copyright Andreas Gal 1999\r
- * (C) Copyright Gregory P. Smith 1999\r
- * (C) Copyright Deti Fliegl 1999\r
- * (C) Copyright Randy Dunlap 2000\r
- * (C) Copyright David Brownell 2000-2002\r
- * \r
- * This program is free software; you can redistribute it and/or modify it\r
- * under the terms of the GNU General Public License as published by the\r
- * Free Software Foundation; either version 2 of the License, or (at your\r
- * option) any later version.\r
- *\r
- * This program is distributed in the hope that it will be useful, but\r
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\r
- * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License\r
- * for more details.\r
- *\r
- * You should have received a copy of the GNU General Public License\r
- * along with this program; if not, write to the Free Software Foundation,\r
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\r
- */\r
-\r
-#if 0\r
-#include <linux/config.h>\r
-\r
-#ifdef CONFIG_USB_DEBUG\r
-#define DEBUG\r
-#endif\r
-\r
-#include <linux/module.h>\r
-#include <linux/version.h>\r
-#include <linux/kernel.h>\r
-#include <linux/slab.h>\r
-#include <linux/completion.h>\r
-#include <linux/uts.h>                 /* for UTS_SYSNAME */\r
-#include <linux/pci.h>                 /* for hcd->pdev and dma addressing */\r
-#include <linux/dma-mapping.h>\r
-#include <asm/byteorder.h>\r
-\r
-#include <linux/usb.h>\r
-#else\r
-#include "../usb_wrapper.h"\r
-//#define DEBUG\r
-#endif\r
-\r
-#include "hcd.h"\r
-\r
-// #define USB_BANDWIDTH_MESSAGES\r
-\r
-/*-------------------------------------------------------------------------*/\r
-\r
-/*\r
- * USB Host Controller Driver framework\r
- *\r
- * Plugs into usbcore (usb_bus) and lets HCDs share code, minimizing\r
- * HCD-specific behaviors/bugs.\r
- *\r
- * This does error checks, tracks devices and urbs, and delegates to a\r
- * "hc_driver" only for code (and data) that really needs to know about\r
- * hardware differences.  That includes root hub registers, i/o queues,\r
- * and so on ... but as little else as possible.\r
- *\r
- * Shared code includes most of the "root hub" code (these are emulated,\r
- * though each HC's hardware works differently) and PCI glue, plus request\r
- * tracking overhead.  The HCD code should only block on spinlocks or on\r
- * hardware handshaking; blocking on software events (such as other kernel\r
- * threads releasing resources, or completing actions) is all generic.\r
- *\r
- * Happens the USB 2.0 spec says this would be invisible inside the "USBD",\r
- * and includes mostly a "HCDI" (HCD Interface) along with some APIs used\r
- * only by the hub driver ... and that neither should be seen or used by\r
- * usb client device drivers.\r
- *\r
- * Contributors of ideas or unattributed patches include: David Brownell,\r
- * Roman Weissgaerber, Rory Bolt, Greg Kroah-Hartman, ...\r
- *\r
- * HISTORY:\r
- * 2002-02-21  Pull in most of the usb_bus support from usb.c; some\r
- *             associated cleanup.  "usb_hcd" still != "usb_bus".\r
- * 2001-12-12  Initial patch version for Linux 2.5.1 kernel.\r
- */\r
-\r
-/*-------------------------------------------------------------------------*/\r
-\r
-/* host controllers we manage */\r
-LIST_HEAD (usb_bus_list);\r
-EXPORT_SYMBOL_GPL (usb_bus_list);\r
-\r
-/* used when allocating bus numbers */\r
-#define USB_MAXBUS             64\r
-struct usb_busmap {\r
-       unsigned long busmap [USB_MAXBUS / (8*sizeof (unsigned long))];\r
-};\r
-static struct usb_busmap busmap;\r
-\r
-/* used when updating list of hcds */\r
-DECLARE_MUTEX (usb_bus_list_lock);     /* exported only for usbfs */\r
-EXPORT_SYMBOL_GPL (usb_bus_list_lock);\r
-\r
-/* used when updating hcd data */\r
-static spinlock_t hcd_data_lock = SPIN_LOCK_UNLOCKED;\r
-\r
-/*-------------------------------------------------------------------------*/\r
-\r
-/*\r
- * Sharable chunks of root hub code.\r
- */\r
-\r
-/*-------------------------------------------------------------------------*/\r
-\r
-#define KERNEL_REL     ((LINUX_VERSION_CODE >> 16) & 0x0ff)\r
-#define KERNEL_VER     ((LINUX_VERSION_CODE >> 8) & 0x0ff)\r
-\r
-/* usb 2.0 root hub device descriptor */\r
-static const u8 usb2_rh_dev_descriptor [18] = {\r
-       0x12,       /*  __u8  bLength; */\r
-       0x01,       /*  __u8  bDescriptorType; Device */\r
-       0x00, 0x02, /*  __u16 bcdUSB; v2.0 */\r
-\r
-       0x09,       /*  __u8  bDeviceClass; HUB_CLASSCODE */\r
-       0x00,       /*  __u8  bDeviceSubClass; */\r
-       0x01,       /*  __u8  bDeviceProtocol; [ usb 2.0 single TT ]*/\r
-       0x08,       /*  __u8  bMaxPacketSize0; 8 Bytes */\r
-\r
-       0x00, 0x00, /*  __u16 idVendor; */\r
-       0x00, 0x00, /*  __u16 idProduct; */\r
-       KERNEL_VER, KERNEL_REL, /*  __u16 bcdDevice */\r
-\r
-       0x03,       /*  __u8  iManufacturer; */\r
-       0x02,       /*  __u8  iProduct; */\r
-       0x01,       /*  __u8  iSerialNumber; */\r
-       0x01        /*  __u8  bNumConfigurations; */\r
-};\r
-\r
-/* no usb 2.0 root hub "device qualifier" descriptor: one speed only */\r
-\r
-/* usb 1.1 root hub device descriptor */\r
-static const u8 usb11_rh_dev_descriptor [18] = {\r
-       0x12,       /*  __u8  bLength; */\r
-       0x01,       /*  __u8  bDescriptorType; Device */\r
-       0x10, 0x01, /*  __u16 bcdUSB; v1.1 */\r
-\r
-       0x09,       /*  __u8  bDeviceClass; HUB_CLASSCODE */\r
-       0x00,       /*  __u8  bDeviceSubClass; */\r
-       0x00,       /*  __u8  bDeviceProtocol; [ low/full speeds only ] */\r
-       0x08,       /*  __u8  bMaxPacketSize0; 8 Bytes */\r
-\r
-       0x00, 0x00, /*  __u16 idVendor; */\r
-       0x00, 0x00, /*  __u16 idProduct; */\r
-       KERNEL_VER, KERNEL_REL, /*  __u16 bcdDevice */\r
-\r
-       0x03,       /*  __u8  iManufacturer; */\r
-       0x02,       /*  __u8  iProduct; */\r
-       0x01,       /*  __u8  iSerialNumber; */\r
-       0x01        /*  __u8  bNumConfigurations; */\r
-};\r
-\r
-\r
-/*-------------------------------------------------------------------------*/\r
-\r
-/* Configuration descriptors for our root hubs */\r
-\r
-static const u8 fs_rh_config_descriptor [] = {\r
-\r
-       /* one configuration */\r
-       0x09,       /*  __u8  bLength; */\r
-       0x02,       /*  __u8  bDescriptorType; Configuration */\r
-       0x19, 0x00, /*  __u16 wTotalLength; */\r
-       0x01,       /*  __u8  bNumInterfaces; (1) */\r
-       0x01,       /*  __u8  bConfigurationValue; */\r
-       0x00,       /*  __u8  iConfiguration; */\r
-       0x40,       /*  __u8  bmAttributes; \r
-                                Bit 7: Bus-powered,\r
-                                    6: Self-powered,\r
-                                    5 Remote-wakwup,\r
-                                    4..0: resvd */\r
-       0x00,       /*  __u8  MaxPower; */\r
-      \r
-       /* USB 1.1:\r
-        * USB 2.0, single TT organization (mandatory):\r
-        *      one interface, protocol 0\r
-        *\r
-        * USB 2.0, multiple TT organization (optional):\r
-        *      two interfaces, protocols 1 (like single TT)\r
-        *      and 2 (multiple TT mode) ... config is\r
-        *      sometimes settable\r
-        *      NOT IMPLEMENTED\r
-        */\r
-\r
-       /* one interface */\r
-       0x09,       /*  __u8  if_bLength; */\r
-       0x04,       /*  __u8  if_bDescriptorType; Interface */\r
-       0x00,       /*  __u8  if_bInterfaceNumber; */\r
-       0x00,       /*  __u8  if_bAlternateSetting; */\r
-       0x01,       /*  __u8  if_bNumEndpoints; */\r
-       0x09,       /*  __u8  if_bInterfaceClass; HUB_CLASSCODE */\r
-       0x00,       /*  __u8  if_bInterfaceSubClass; */\r
-       0x00,       /*  __u8  if_bInterfaceProtocol; [usb1.1 or single tt] */\r
-       0x00,       /*  __u8  if_iInterface; */\r
-     \r
-       /* one endpoint (status change endpoint) */\r
-       0x07,       /*  __u8  ep_bLength; */\r
-       0x05,       /*  __u8  ep_bDescriptorType; Endpoint */\r
-       0x81,       /*  __u8  ep_bEndpointAddress; IN Endpoint 1 */\r
-       0x03,       /*  __u8  ep_bmAttributes; Interrupt */\r
-       0x02, 0x00, /*  __u16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8) */\r
-       0xff        /*  __u8  ep_bInterval; (255ms -- usb 2.0 spec) */\r
-};\r
-\r
-static const u8 hs_rh_config_descriptor [] = {\r
-\r
-       /* one configuration */\r
-       0x09,       /*  __u8  bLength; */\r
-       0x02,       /*  __u8  bDescriptorType; Configuration */\r
-       0x19, 0x00, /*  __u16 wTotalLength; */\r
-       0x01,       /*  __u8  bNumInterfaces; (1) */\r
-       0x01,       /*  __u8  bConfigurationValue; */\r
-       0x00,       /*  __u8  iConfiguration; */\r
-       0x40,       /*  __u8  bmAttributes; \r
-                                Bit 7: Bus-powered,\r
-                                    6: Self-powered,\r
-                                    5 Remote-wakwup,\r
-                                    4..0: resvd */\r
-       0x00,       /*  __u8  MaxPower; */\r
-      \r
-       /* USB 1.1:\r
-        * USB 2.0, single TT organization (mandatory):\r
-        *      one interface, protocol 0\r
-        *\r
-        * USB 2.0, multiple TT organization (optional):\r
-        *      two interfaces, protocols 1 (like single TT)\r
-        *      and 2 (multiple TT mode) ... config is\r
-        *      sometimes settable\r
-        *      NOT IMPLEMENTED\r
-        */\r
-\r
-       /* one interface */\r
-       0x09,       /*  __u8  if_bLength; */\r
-       0x04,       /*  __u8  if_bDescriptorType; Interface */\r
-       0x00,       /*  __u8  if_bInterfaceNumber; */\r
-       0x00,       /*  __u8  if_bAlternateSetting; */\r
-       0x01,       /*  __u8  if_bNumEndpoints; */\r
-       0x09,       /*  __u8  if_bInterfaceClass; HUB_CLASSCODE */\r
-       0x00,       /*  __u8  if_bInterfaceSubClass; */\r
-       0x00,       /*  __u8  if_bInterfaceProtocol; [usb1.1 or single tt] */\r
-       0x00,       /*  __u8  if_iInterface; */\r
-     \r
-       /* one endpoint (status change endpoint) */\r
-       0x07,       /*  __u8  ep_bLength; */\r
-       0x05,       /*  __u8  ep_bDescriptorType; Endpoint */\r
-       0x81,       /*  __u8  ep_bEndpointAddress; IN Endpoint 1 */\r
-       0x03,       /*  __u8  ep_bmAttributes; Interrupt */\r
-       0x02, 0x00, /*  __u16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8) */\r
-       0x0c        /*  __u8  ep_bInterval; (256ms -- usb 2.0 spec) */\r
-};\r
-\r
-/*-------------------------------------------------------------------------*/\r
-\r
-/*\r
- * helper routine for returning string descriptors in UTF-16LE\r
- * input can actually be ISO-8859-1; ASCII is its 7-bit subset\r
- */\r
-static int ascii2utf (char *s, u8 *utf, int utfmax)\r
-{\r
-       int retval;\r
-\r
-       for (retval = 0; *s && utfmax > 1; utfmax -= 2, retval += 2) {\r
-               *utf++ = *s++;\r
-               *utf++ = 0;\r
-       }\r
-       return retval;\r
-}\r
-\r
-/*\r
- * rh_string - provides manufacturer, product and serial strings for root hub\r
- * @id: the string ID number (1: serial number, 2: product, 3: vendor)\r
- * @hcd: the host controller for this root hub\r
- * @type: string describing our driver \r
- * @data: return packet in UTF-16 LE\r
- * @len: length of the return packet\r
- *\r
- * Produces either a manufacturer, product or serial number string for the\r
- * virtual root hub device.\r
- */\r
-static int rh_string (\r
-       int             id,\r
-       struct usb_hcd  *hcd,\r
-       u8              *data,\r
-       int             len\r
-) {\r
-       char buf [100];\r
-\r
-       // language ids\r
-       if (id == 0) {\r
-               *data++ = 4; *data++ = 3;       /* 4 bytes string data */\r
-               *data++ = 0x09; *data++ = 0x04; /* MSFT-speak for "en-us" */\r
-               return 4;\r
-\r
-       // serial number\r
-       } else if (id == 1) {\r
-               strcpy (buf, hcd->self.bus_name);\r
-\r
-       // product description\r
-       } else if (id == 2) {\r
-                strcpy (buf, hcd->product_desc);\r
-\r
-       // id 3 == vendor description\r
-       } else if (id == 3) {\r
-                sprintf (buf, "%s %s %s", UTS_SYSNAME, UTS_RELEASE,\r
-                       hcd->description);\r
-\r
-       // unsupported IDs --> "protocol stall"\r
-       } else\r
-           return 0;\r
-\r
-       data [0] = 2 * (strlen (buf) + 1);\r
-       data [1] = 3;   /* type == string */\r
-       return 2 + ascii2utf (buf, data + 2, len - 2);\r
-}\r
-\r
-\r
-/* Root hub control transfers execute synchronously */\r
-static int rh_call_control (struct usb_hcd *hcd, struct urb *urb)\r
-{\r
-       struct usb_ctrlrequest *cmd = (struct usb_ctrlrequest *) urb->setup_packet;\r
-       u16             typeReq, wValue, wIndex, wLength;\r
-       const u8        *bufp = 0;\r
-       u8              *ubuf = urb->transfer_buffer;\r
-       int             len = 0;\r
-       //unsigned long flags;\r
-\r
-       typeReq  = (cmd->bRequestType << 8) | cmd->bRequest;\r
-       wValue   = le16_to_cpu (cmd->wValue);\r
-       wIndex   = le16_to_cpu (cmd->wIndex);\r
-       wLength  = le16_to_cpu (cmd->wLength);\r
-\r
-       if (wLength > urb->transfer_buffer_length)\r
-               goto error;\r
-\r
-       /* set up for success */\r
-       urb->status = 0;\r
-       urb->actual_length = wLength;\r
-       switch (typeReq) {\r
-\r
-       /* DEVICE REQUESTS */\r
-\r
-       case DeviceRequest | USB_REQ_GET_STATUS:\r
-               // DEVICE_REMOTE_WAKEUP\r
-               ubuf [0] = 1; // selfpowered\r
-               ubuf [1] = 0;\r
-                       /* FALLTHROUGH */\r
-       case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:\r
-       case DeviceOutRequest | USB_REQ_SET_FEATURE:\r
-               dev_dbg (hcd->controller, "no device features yet yet\n");\r
-               break;\r
-       case DeviceRequest | USB_REQ_GET_CONFIGURATION:\r
-               ubuf [0] = 1;\r
-                       /* FALLTHROUGH */\r
-       case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:\r
-               break;\r
-       case DeviceRequest | USB_REQ_GET_DESCRIPTOR:\r
-               switch (wValue & 0xff00) {\r
-               case USB_DT_DEVICE << 8:\r
-                       if (hcd->driver->flags & HCD_USB2)\r
-                               bufp = usb2_rh_dev_descriptor;\r
-                       else if (hcd->driver->flags & HCD_USB11)\r
-                               bufp = usb11_rh_dev_descriptor;\r
-                       else\r
-                               goto error;\r
-                       len = 18;\r
-                       break;\r
-               case USB_DT_CONFIG << 8:\r
-                       if (hcd->driver->flags & HCD_USB2) {\r
-                               bufp = hs_rh_config_descriptor;\r
-                               len = sizeof hs_rh_config_descriptor;\r
-                       } else {\r
-                               bufp = fs_rh_config_descriptor;\r
-                               len = sizeof fs_rh_config_descriptor;\r
-                       }\r
-                       break;\r
-               case USB_DT_STRING << 8:\r
-                       urb->actual_length = rh_string (\r
-                               wValue & 0xff, hcd,\r
-                               ubuf, wLength);\r
-                       break;\r
-               default:\r
-                       goto error;\r
-               }\r
-               break;\r
-       case DeviceRequest | USB_REQ_GET_INTERFACE:\r
-               ubuf [0] = 0;\r
-                       /* FALLTHROUGH */\r
-       case DeviceOutRequest | USB_REQ_SET_INTERFACE:\r
-               break;\r
-       case DeviceOutRequest | USB_REQ_SET_ADDRESS:\r
-               // wValue == urb->dev->devaddr\r
-               dev_dbg (hcd->controller, "root hub device address %d\n",\r
-                       wValue);\r
-               break;\r
-\r
-       /* INTERFACE REQUESTS (no defined feature/status flags) */\r
-\r
-       /* ENDPOINT REQUESTS */\r
-\r
-       case EndpointRequest | USB_REQ_GET_STATUS:\r
-               // ENDPOINT_HALT flag\r
-               ubuf [0] = 0;\r
-               ubuf [1] = 0;\r
-                       /* FALLTHROUGH */\r
-       case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:\r
-       case EndpointOutRequest | USB_REQ_SET_FEATURE:\r
-               dev_dbg (hcd->controller, "no endpoint features yet\n");\r
-               break;\r
-\r
-       /* CLASS REQUESTS (and errors) */\r
-\r
-       default:\r
-               /* non-generic request */\r
-               urb->status = hcd->driver->hub_control (hcd,\r
-                       typeReq, wValue, wIndex,\r
-                       ubuf, wLength);\r
-               break;\r
-error:\r
-               /* "protocol stall" on error */\r
-               urb->status = -EPIPE;\r
-               dev_dbg (hcd->controller, "unsupported hub control message (maxchild %d)\n",\r
-                               urb->dev->maxchild);\r
-       }\r
-       if (urb->status) {\r
-               urb->actual_length = 0;\r
-               dev_dbg (hcd->controller, "CTRL: TypeReq=0x%x val=0x%x idx=0x%x len=%d ==> %d\n",\r
-                       typeReq, wValue, wIndex, wLength, urb->status);\r
-       }\r
-       if (bufp) {\r
-               if (urb->transfer_buffer_length < len)\r
-                       len = urb->transfer_buffer_length;\r
-               urb->actual_length = len;\r
-               // always USB_DIR_IN, toward host\r
-               memcpy (ubuf, bufp, len);\r
-       }\r
-\r
-       /* any errors get returned through the urb completion */\r
-       local_irq_save (flags);\r
-       usb_hcd_giveback_urb (hcd, urb, NULL);\r
-       local_irq_restore (flags);\r
-       return 0;\r
-}\r
-\r
-/*-------------------------------------------------------------------------*/\r
-\r
-/*\r
- * Root Hub interrupt transfers are synthesized with a timer.\r
- * Completions are called in_interrupt() but not in_irq().\r
- */\r
-\r
-static void rh_report_status (unsigned long ptr);\r
-\r
-static int rh_status_urb (struct usb_hcd *hcd, struct urb *urb) \r
-{\r
-       int     len = 1 + (urb->dev->maxchild / 8);\r
-\r
-       /* rh_timer protected by hcd_data_lock */\r
-       if (hcd->rh_timer.data\r
-                       || urb->status != -EINPROGRESS\r
-                       || urb->transfer_buffer_length < len) {\r
-               dev_dbg (hcd->controller,\r
-                               "not queuing rh status urb, stat %d\n",\r
-                               urb->status);\r
-               return -EINVAL;\r
-       }\r
-\r
-       init_timer (&hcd->rh_timer);\r
-\r
-       hcd->rh_timer.function = rh_report_status;\r
-       hcd->rh_timer.data = (unsigned long) urb;\r
-       /* USB 2.0 spec says 256msec; this is close enough */\r
-       hcd->rh_timer.expires = jiffies + HZ/4;\r
-       add_timer (&hcd->rh_timer);\r
-       urb->hcpriv = hcd;      /* nonzero to indicate it's queued */\r
-       return 0;\r
-}\r
-\r
-/* timer callback */\r
-\r
-static void rh_report_status (unsigned long ptr)\r
-{\r
-       struct urb      *urb;\r
-       struct usb_hcd  *hcd;\r
-       int             length;\r
-       //unsigned long flags;\r
-\r
-       urb = (struct urb *) ptr;\r
-       local_irq_save (flags);\r
-       spin_lock (&urb->lock);\r
-\r
-       /* do nothing if the hc is gone or the urb's been unlinked */\r
-       if (!urb->dev\r
-                       || urb->status != -EINPROGRESS\r
-                       || (hcd = urb->dev->bus->hcpriv) == 0\r
-                       || !HCD_IS_RUNNING (hcd->state)) {\r
-               spin_unlock (&urb->lock);\r
-               local_irq_restore (flags);\r
-               return;\r
-       }\r
-\r
-       length = hcd->driver->hub_status_data (hcd, urb->transfer_buffer);\r
-\r
-       /* complete the status urb, or retrigger the timer */\r
-       spin_lock (&hcd_data_lock);\r
-       if (length > 0) {\r
-               hcd->rh_timer.data = 0;\r
-               urb->actual_length = length;\r
-               urb->status = 0;\r
-               urb->hcpriv = 0;\r
-       } else\r
-               mod_timer (&hcd->rh_timer, jiffies + HZ/4);\r
-       spin_unlock (&hcd_data_lock);\r
-       spin_unlock (&urb->lock);\r
-\r
-       /* local irqs are always blocked in completions */\r
-       if (length > 0)\r
-               usb_hcd_giveback_urb (hcd, urb, NULL);\r
-       local_irq_restore (flags);\r
-}\r
-\r
-/*-------------------------------------------------------------------------*/\r
-\r
-static int rh_urb_enqueue (struct usb_hcd *hcd, struct urb *urb)\r
-{\r
-       if (usb_pipeint (urb->pipe)) {\r
-               int             retval;\r
-               unsigned long   flags;\r
-\r
-               spin_lock_irqsave (&hcd_data_lock, flags);\r
-               retval = rh_status_urb (hcd, urb);\r
-               spin_unlock_irqrestore (&hcd_data_lock, flags);\r
-               return retval;\r
-       }\r
-       if (usb_pipecontrol (urb->pipe))\r
-               return rh_call_control (hcd, urb);\r
-       else\r
-               return -EINVAL;\r
-}\r
-\r
-/*-------------------------------------------------------------------------*/\r
-\r
-void usb_rh_status_dequeue (struct usb_hcd *hcd, struct urb *urb)\r
-{\r
-       //unsigned long flags;\r
-\r
-       /* note:  always a synchronous unlink */\r
-       del_timer_sync (&hcd->rh_timer);\r
-       hcd->rh_timer.data = 0;\r
-\r
-       local_irq_save (flags);\r
-       urb->hcpriv = 0;\r
-       usb_hcd_giveback_urb (hcd, urb, NULL);\r
-       local_irq_restore (flags);\r
-}\r
-\r
-/*-------------------------------------------------------------------------*/\r
-\r
-/* exported only within usbcore */\r
-void usb_bus_get (struct usb_bus *bus)\r
-{\r
-       atomic_inc (&bus->refcnt);\r
-}\r
-\r
-/* exported only within usbcore */\r
-void usb_bus_put (struct usb_bus *bus)\r
-{\r
-       if (atomic_dec_and_test (&bus->refcnt))\r
-               kfree (bus);\r
-}\r
-\r
-/*-------------------------------------------------------------------------*/\r
-\r
-/**\r
- * usb_bus_init - shared initialization code\r
- * @bus: the bus structure being initialized\r
- *\r
- * This code is used to initialize a usb_bus structure, memory for which is\r
- * separately managed.\r
- */\r
-void STDCALL usb_bus_init (struct usb_bus *bus)\r
-{\r
-       memset (&bus->devmap, 0, sizeof(struct usb_devmap));\r
-\r
-       bus->devnum_next = 1;\r
-\r
-       bus->root_hub = NULL;\r
-       bus->hcpriv = NULL;\r
-       bus->busnum = -1;\r
-       bus->bandwidth_allocated = 0;\r
-       bus->bandwidth_int_reqs  = 0;\r
-       bus->bandwidth_isoc_reqs = 0;\r
-\r
-       INIT_LIST_HEAD (&bus->bus_list);\r
-\r
-       atomic_set (&bus->refcnt, 1);\r
-}\r
-\r
-/**\r
- * usb_alloc_bus - creates a new USB host controller structure\r
- * @op: pointer to a struct usb_operations that this bus structure should use\r
- * Context: !in_interrupt()\r
- *\r
- * Creates a USB host controller bus structure with the specified \r
- * usb_operations and initializes all the necessary internal objects.\r
- *\r
- * If no memory is available, NULL is returned.\r
- *\r
- * The caller should call usb_free_bus() when it is finished with the structure.\r
- */\r
-struct usb_bus STDCALL *usb_alloc_bus (struct usb_operations *op)\r
-{\r
-       struct usb_bus *bus;\r
-\r
-       bus = kmalloc (sizeof *bus, GFP_KERNEL);\r
-       if (!bus)\r
-               return NULL;\r
-       usb_bus_init (bus);\r
-       bus->op = op;\r
-       return bus;\r
-}\r
-\r
-/**\r
- * usb_free_bus - frees the memory used by a bus structure\r
- * @bus: pointer to the bus to free\r
- *\r
- * To be invoked by a HCD, only as the last step of decoupling from\r
- * hardware.  It is an error to call this if the reference count is\r
- * anything but one.  That would indicate that some system component\r
- * did not correctly shut down, and thought the hardware was still\r
- * accessible.\r
- */\r
-void STDCALL usb_free_bus (struct usb_bus *bus)\r
-{\r
-       if (!bus)\r
-               return;\r
-       if (atomic_read (&bus->refcnt) != 1)\r
-               err ("usb_free_bus #%d, count != 1", bus->busnum);\r
-       usb_bus_put (bus);\r
-}\r
-\r
-/*-------------------------------------------------------------------------*/\r
-\r
-/**\r
- * usb_register_bus - registers the USB host controller with the usb core\r
- * @bus: pointer to the bus to register\r
- * Context: !in_interrupt()\r
- *\r
- * Assigns a bus number, and links the controller into usbcore data\r
- * structures so that it can be seen by scanning the bus list.\r
- */\r
-void STDCALL usb_register_bus(struct usb_bus *bus)\r
-{\r
-       int busnum;\r
-\r
-       down (&usb_bus_list_lock);\r
-       busnum = find_next_zero_bit (busmap.busmap, USB_MAXBUS, 1);\r
-       if (busnum < USB_MAXBUS) {\r
-               set_bit (busnum, busmap.busmap);\r
-               bus->busnum = busnum;\r
-       } else\r
-               warn ("too many buses");\r
-\r
-       usb_bus_get (bus);\r
-\r
-       /* Add it to the list of buses */\r
-       list_add (&bus->bus_list, &usb_bus_list);\r
-       up (&usb_bus_list_lock);\r
-\r
-       usbfs_add_bus (bus);\r
-\r
-       dev_info (bus->controller, "new USB bus registered, assigned bus number %d\n", bus->busnum);\r
-}\r
-\r
-/**\r
- * usb_deregister_bus - deregisters the USB host controller\r
- * @bus: pointer to the bus to deregister\r
- * Context: !in_interrupt()\r
- *\r
- * Recycles the bus number, and unlinks the controller from usbcore data\r
- * structures so that it won't be seen by scanning the bus list.\r
- */\r
-void STDCALL usb_deregister_bus (struct usb_bus *bus)\r
-{\r
-       dev_info (bus->controller, "USB bus %d deregistered\n", bus->busnum);\r
-\r
-       /*\r
-        * NOTE: make sure that all the devices are removed by the\r
-        * controller code, as well as having it call this when cleaning\r
-        * itself up\r
-        */\r
-       down (&usb_bus_list_lock);\r
-       list_del (&bus->bus_list);\r
-       up (&usb_bus_list_lock);\r
-\r
-       usbfs_remove_bus (bus);\r
-\r
-       clear_bit (bus->busnum, busmap.busmap);\r
-\r
-       usb_bus_put (bus);\r
-}\r
-\r
-/**\r
- * usb_register_root_hub - called by HCD to register its root hub \r
- * @usb_dev: the usb root hub device to be registered.\r
- * @parent_dev: the parent device of this root hub.\r
- *\r
- * The USB host controller calls this function to register the root hub\r
- * properly with the USB subsystem.  It sets up the device properly in\r
- * the driverfs tree, and then calls usb_new_device() to register the\r
- * usb device.\r
- */\r
-int STDCALL usb_register_root_hub (struct usb_device *usb_dev, struct device *parent_dev)\r
-{\r
-       int retval;\r
-\r
-       sprintf (&usb_dev->dev.bus_id[0], "usb%d", usb_dev->bus->busnum);\r
-       usb_dev->state = USB_STATE_DEFAULT;\r
-       retval = usb_new_device (usb_dev, parent_dev);\r
-       if (retval)\r
-               dev_err (parent_dev, "can't register root hub for %s, %d\n",\r
-                               usb_dev->dev.bus_id, retval);\r
-       return retval;\r
-}\r
-\r
-\r
-/*-------------------------------------------------------------------------*/\r
-\r
-/**\r
- * usb_calc_bus_time - approximate periodic transaction time in nanoseconds\r
- * @speed: from dev->speed; USB_SPEED_{LOW,FULL,HIGH}\r
- * @is_input: true iff the transaction sends data to the host\r
- * @isoc: true for isochronous transactions, false for interrupt ones\r
- * @bytecount: how many bytes in the transaction.\r
- *\r
- * Returns approximate bus time in nanoseconds for a periodic transaction.\r
- * See USB 2.0 spec section 5.11.3; only periodic transfers need to be\r
- * scheduled in software, this function is only used for such scheduling.\r
- */\r
-long STDCALL usb_calc_bus_time (int speed, int is_input, int isoc, int bytecount)\r
-{\r
-       unsigned long   tmp;\r
-\r
-       switch (speed) {\r
-       case USB_SPEED_LOW:     /* INTR only */\r
-               if (is_input) {\r
-                       tmp = (67667L * (31L + 10L * BitTime (bytecount))) / 1000L;\r
-                       return (64060L + (2 * BW_HUB_LS_SETUP) + BW_HOST_DELAY + tmp);\r
-               } else {\r
-                       tmp = (66700L * (31L + 10L * BitTime (bytecount))) / 1000L;\r
-                       return (64107L + (2 * BW_HUB_LS_SETUP) + BW_HOST_DELAY + tmp);\r
-               }\r
-       case USB_SPEED_FULL:    /* ISOC or INTR */\r
-               if (isoc) {\r
-                       tmp = (8354L * (31L + 10L * BitTime (bytecount))) / 1000L;\r
-                       return (((is_input) ? 7268L : 6265L) + BW_HOST_DELAY + tmp);\r
-               } else {\r
-                       tmp = (8354L * (31L + 10L * BitTime (bytecount))) / 1000L;\r
-                       return (9107L + BW_HOST_DELAY + tmp);\r
-               }\r
-       case USB_SPEED_HIGH:    /* ISOC or INTR */\r
-               // FIXME adjust for input vs output\r
-               if (isoc)\r
-                       tmp = HS_USECS (bytecount);\r
-               else\r
-                       tmp = HS_USECS_ISO (bytecount);\r
-               return tmp;\r
-       default:\r
-               dbg ("bogus device speed!");\r
-               return -1;\r
-       }\r
-}\r
-\r
-/*\r
- * usb_check_bandwidth():\r
- *\r
- * old_alloc is from host_controller->bandwidth_allocated in microseconds;\r
- * bustime is from calc_bus_time(), but converted to microseconds.\r
- *\r
- * returns <bustime in us> if successful,\r
- * or -ENOSPC if bandwidth request fails.\r
- *\r
- * FIXME:\r
- * This initial implementation does not use Endpoint.bInterval\r
- * in managing bandwidth allocation.\r
- * It probably needs to be expanded to use Endpoint.bInterval.\r
- * This can be done as a later enhancement (correction).\r
- *\r
- * This will also probably require some kind of\r
- * frame allocation tracking...meaning, for example,\r
- * that if multiple drivers request interrupts every 10 USB frames,\r
- * they don't all have to be allocated at\r
- * frame numbers N, N+10, N+20, etc.  Some of them could be at\r
- * N+11, N+21, N+31, etc., and others at\r
- * N+12, N+22, N+32, etc.\r
- *\r
- * Similarly for isochronous transfers...\r
- *\r
- * Individual HCDs can schedule more directly ... this logic\r
- * is not correct for high speed transfers.\r
- */\r
-int STDCALL usb_check_bandwidth (struct usb_device *dev, struct urb *urb)\r
-{\r
-       unsigned int    pipe = urb->pipe;\r
-       long            bustime;\r
-       int             is_in = usb_pipein (pipe);\r
-       int             is_iso = usb_pipeisoc (pipe);\r
-       int             old_alloc = dev->bus->bandwidth_allocated;\r
-       int             new_alloc;\r
-\r
-\r
-       bustime = NS_TO_US (usb_calc_bus_time (dev->speed, is_in, is_iso,\r
-                       usb_maxpacket (dev, pipe, !is_in)));\r
-       if (is_iso)\r
-               bustime /= urb->number_of_packets;\r
-\r
-       new_alloc = old_alloc + (int) bustime;\r
-       if (new_alloc > FRAME_TIME_MAX_USECS_ALLOC) {\r
-#ifdef DEBUG\r
-               char    *mode = \r
-#ifdef CONFIG_USB_BANDWIDTH\r
-                       "";\r
-#else\r
-                       "would have ";\r
-#endif\r
-               dev_dbg (&dev->dev, "usb_check_bandwidth %sFAILED: %d + %ld = %d usec\n",\r
-                       mode, old_alloc, bustime, new_alloc);\r
-#endif\r
-#ifdef CONFIG_USB_BANDWIDTH\r
-               bustime = -ENOSPC;      /* report error */\r
-#endif\r
-       }\r
-\r
-       return bustime;\r
-}\r
-\r
-\r
-/**\r
- * usb_claim_bandwidth - records bandwidth for a periodic transfer\r
- * @dev: source/target of request\r
- * @urb: request (urb->dev == dev)\r
- * @bustime: bandwidth consumed, in (average) microseconds per frame\r
- * @isoc: true iff the request is isochronous\r
- *\r
- * Bus bandwidth reservations are recorded purely for diagnostic purposes.\r
- * HCDs are expected not to overcommit periodic bandwidth, and to record such\r
- * reservations whenever endpoints are added to the periodic schedule.\r
- *\r
- * FIXME averaging per-frame is suboptimal.  Better to sum over the HCD's\r
- * entire periodic schedule ... 32 frames for OHCI, 1024 for UHCI, settable\r
- * for EHCI (256/512/1024 frames, default 1024) and have the bus expose how\r
- * large its periodic schedule is.\r
- */\r
-void STDCALL usb_claim_bandwidth (struct usb_device *dev, struct urb *urb, int bustime, int isoc)\r
-{\r
-       dev->bus->bandwidth_allocated += bustime;\r
-       if (isoc)\r
-               dev->bus->bandwidth_isoc_reqs++;\r
-       else\r
-               dev->bus->bandwidth_int_reqs++;\r
-       urb->bandwidth = bustime;\r
-\r
-#ifdef USB_BANDWIDTH_MESSAGES\r
-       dev_dbg (&dev->dev, "bandwidth alloc increased by %d (%s) to %d for %d requesters\n",\r
-               bustime,\r
-               isoc ? "ISOC" : "INTR",\r
-               dev->bus->bandwidth_allocated,\r
-               dev->bus->bandwidth_int_reqs + dev->bus->bandwidth_isoc_reqs);\r
-#endif\r
-}\r
-\r
-\r
-/**\r
- * usb_release_bandwidth - reverses effect of usb_claim_bandwidth()\r
- * @dev: source/target of request\r
- * @urb: request (urb->dev == dev)\r
- * @isoc: true iff the request is isochronous\r
- *\r
- * This records that previously allocated bandwidth has been released.\r
- * Bandwidth is released when endpoints are removed from the host controller's\r
- * periodic schedule.\r
- */\r
-void STDCALL usb_release_bandwidth (struct usb_device *dev, struct urb *urb, int isoc)\r
-{\r
-       dev->bus->bandwidth_allocated -= urb->bandwidth;\r
-       if (isoc)\r
-               dev->bus->bandwidth_isoc_reqs--;\r
-       else\r
-               dev->bus->bandwidth_int_reqs--;\r
-\r
-#ifdef USB_BANDWIDTH_MESSAGES\r
-       dev_dbg (&dev->dev, "bandwidth alloc reduced by %d (%s) to %d for %d requesters\n",\r
-               urb->bandwidth,\r
-               isoc ? "ISOC" : "INTR",\r
-               dev->bus->bandwidth_allocated,\r
-               dev->bus->bandwidth_int_reqs + dev->bus->bandwidth_isoc_reqs);\r
-#endif\r
-       urb->bandwidth = 0;\r
-}\r
-\r
-\r
-/*-------------------------------------------------------------------------*/\r
-\r
-/*\r
- * Generic HC operations.\r
- */\r
-\r
-/*-------------------------------------------------------------------------*/\r
-\r
-/* called from khubd, or root hub init threads for hcd-private init */\r
-static int hcd_alloc_dev (struct usb_device *udev)\r
-{\r
-       struct hcd_dev          *dev;\r
-       struct usb_hcd          *hcd;\r
-       unsigned long           flags;\r
-\r
-       if (!udev || udev->hcpriv)\r
-               return -EINVAL;\r
-       if (!udev->bus || !udev->bus->hcpriv)\r
-               return -ENODEV;\r
-       hcd = udev->bus->hcpriv;\r
-       if (hcd->state == USB_STATE_QUIESCING)\r
-               return -ENOLINK;\r
-\r
-       dev = (struct hcd_dev *) kmalloc (sizeof *dev, GFP_KERNEL);\r
-       if (dev == NULL)\r
-               return -ENOMEM;\r
-       memset (dev, 0, sizeof *dev);\r
-\r
-       INIT_LIST_HEAD (&dev->dev_list);\r
-       INIT_LIST_HEAD (&dev->urb_list);\r
-\r
-       spin_lock_irqsave (&hcd_data_lock, flags);\r
-       list_add (&dev->dev_list, &hcd->dev_list);\r
-       // refcount is implicit\r
-       udev->hcpriv = dev;\r
-       spin_unlock_irqrestore (&hcd_data_lock, flags);\r
-\r
-       return 0;\r
-}\r
-\r
-/*-------------------------------------------------------------------------*/\r
-\r
-static void urb_unlink (struct urb *urb)\r
-{\r
-       unsigned long           flags;\r
-       struct usb_device       *dev;\r
-\r
-       /* Release any periodic transfer bandwidth */\r
-       if (urb->bandwidth)\r
-               usb_release_bandwidth (urb->dev, urb,\r
-                       usb_pipeisoc (urb->pipe));\r
-\r
-       /* clear all state linking urb to this dev (and hcd) */\r
-\r
-       spin_lock_irqsave (&hcd_data_lock, flags);\r
-       list_del_init (&urb->urb_list);\r
-       dev = urb->dev;\r
-       spin_unlock_irqrestore (&hcd_data_lock, flags);\r
-       usb_put_dev (dev);\r
-}\r
-\r
-\r
-/* may be called in any context with a valid urb->dev usecount\r
- * caller surrenders "ownership" of urb\r
- * expects usb_submit_urb() to have sanity checked and conditioned all\r
- * inputs in the urb\r
- */\r
-static int hcd_submit_urb (struct urb *urb, int mem_flags)\r
-{\r
-       int                     status;\r
-       struct usb_hcd          *hcd = urb->dev->bus->hcpriv;\r
-       struct hcd_dev          *dev = urb->dev->hcpriv;\r
-       unsigned long           flags;\r
-       \r
-\r
-       if (!hcd || !dev)\r
-               return -ENODEV;\r
-//     printk("submit_urb %p, # %i, t %i\n",urb,urb->dev->devnum,usb_pipetype(urb->pipe));\r
-       /*\r
-        * FIXME:  make urb timeouts be generic, keeping the HCD cores\r
-        * as simple as possible.\r
-        */\r
-\r
-       // NOTE:  a generic device/urb monitoring hook would go here.\r
-       // hcd_monitor_hook(MONITOR_URB_SUBMIT, urb)\r
-       // It would catch submission paths for all urbs.\r
-\r
-       /*\r
-        * Atomically queue the urb,  first to our records, then to the HCD.\r
-        * Access to urb->status is controlled by urb->lock ... changes on\r
-        * i/o completion (normal or fault) or unlinking.\r
-        */\r
-\r
-       // FIXME:  verify that quiescing hc works right (RH cleans up)\r
-\r
-       spin_lock_irqsave (&hcd_data_lock, flags);\r
-       if (HCD_IS_RUNNING (hcd->state) && hcd->state != USB_STATE_QUIESCING) {\r
-               usb_get_dev (urb->dev);\r
-               list_add_tail (&urb->urb_list, &dev->urb_list);\r
-               status = 0;\r
-       } else {\r
-               INIT_LIST_HEAD (&urb->urb_list);\r
-               status = -ESHUTDOWN;\r
-       }\r
-       spin_unlock_irqrestore (&hcd_data_lock, flags);\r
-       if (status)\r
-               return status;\r
-\r
-       /* increment urb's reference count as part of giving it to the HCD\r
-        * (which now controls it).  HCD guarantees that it either returns\r
-        * an error or calls giveback(), but not both.\r
-        */\r
-\r
-       urb = usb_get_urb (urb);\r
-       if (urb->dev == hcd->self.root_hub) {\r
-               /* NOTE:  requirement on hub callers (usbfs and the hub\r
-                * driver, for now) that URBs' urb->transfer_buffer be\r
-                * valid and usb_buffer_{sync,unmap}() not be needed, since\r
-                * they could clobber root hub response data.\r
-                */\r
-               urb->transfer_flags |= URB_NO_DMA_MAP;\r
-               status = rh_urb_enqueue (hcd, urb);\r
-               goto done;\r
-       }\r
-\r
-       /* lower level hcd code should use *_dma exclusively,\r
-        * unless it uses pio or talks to another transport.\r
-        */\r
-       if (!(urb->transfer_flags & URB_NO_DMA_MAP)\r
-                       && hcd->controller->dma_mask) {\r
-               if (usb_pipecontrol (urb->pipe))\r
-                       urb->setup_dma = dma_map_single (\r
-                                       hcd->controller,\r
-                                       urb->setup_packet,\r
-                                       sizeof (struct usb_ctrlrequest),\r
-                                       DMA_TO_DEVICE);\r
-               if (urb->transfer_buffer_length != 0)\r
-                       urb->transfer_dma = dma_map_single (\r
-                                       hcd->controller,\r
-                                       urb->transfer_buffer,\r
-                                       urb->transfer_buffer_length,\r
-                                       usb_pipein (urb->pipe)\r
-                                           ? DMA_FROM_DEVICE\r
-                                           : DMA_TO_DEVICE);\r
-       }\r
-\r
-       status = hcd->driver->urb_enqueue (hcd, urb, mem_flags);\r
-done:\r
-       if (status) {\r
-               usb_put_urb (urb);\r
-               urb_unlink (urb);\r
-       }\r
-       return status;\r
-}\r
-\r
-/*-------------------------------------------------------------------------*/\r
-\r
-/* called in any context */\r
-static int hcd_get_frame_number (struct usb_device *udev)\r
-{\r
-       struct usb_hcd  *hcd = (struct usb_hcd *)udev->bus->hcpriv;\r
-       return hcd->driver->get_frame_number (hcd);\r
-}\r
-\r
-/*-------------------------------------------------------------------------*/\r
-\r
-/* this makes the hcd giveback() the urb more quickly, by kicking it\r
- * off hardware queues (which may take a while) and returning it as\r
- * soon as practical.  we've already set up the urb's return status,\r
- * but we can't know if the callback completed already.\r
- */\r
-static void\r
-unlink1 (struct usb_hcd *hcd, struct urb *urb)\r
-{\r
-       if (urb == (struct urb *) hcd->rh_timer.data)\r
-               usb_rh_status_dequeue (hcd, urb);\r
-       else {\r
-               int             value;\r
-\r
-               /* failures "should" be harmless */\r
-               value = hcd->driver->urb_dequeue (hcd, urb);\r
-               if (value != 0)\r
-                       dev_dbg (hcd->controller,\r
-                               "dequeue %p --> %d\n",\r
-                               urb, value);\r
-       }\r
-}\r
-\r
-struct completion_splice {             // modified urb context:\r
-       /* did we complete? */\r
-       struct completion       done;\r
-\r
-       /* original urb data */\r
-       usb_complete_t          complete;\r
-       void                    *context;\r
-};\r
-\r
-static void unlink_complete (struct urb *urb, struct pt_regs *regs)\r
-{\r
-       struct completion_splice        *splice;\r
-\r
-       splice = (struct completion_splice *) urb->context;\r
-\r
-       /* issue original completion call */\r
-       urb->complete = splice->complete;\r
-       urb->context = splice->context;\r
-       urb->complete (urb, regs);\r
-\r
-       /* then let the synchronous unlink call complete */\r
-       complete (&splice->done);\r
-}\r
-\r
-/*\r
- * called in any context; note ASYNC_UNLINK restrictions\r
- *\r
- * caller guarantees urb won't be recycled till both unlink()\r
- * and the urb's completion function return\r
- */\r
-static int hcd_unlink_urb (struct urb *urb)\r
-{\r
-       struct hcd_dev                  *dev;\r
-       struct usb_hcd                  *hcd = 0;\r
-       struct device                   *sys = 0;\r
-       unsigned long                   flags;\r
-       struct completion_splice        splice;\r
-       int                             retval;\r
-\r
-       if (!urb)\r
-               return -EINVAL;\r
-\r
-       /*\r
-        * we contend for urb->status with the hcd core,\r
-        * which changes it while returning the urb.\r
-        *\r
-        * Caller guaranteed that the urb pointer hasn't been freed, and\r
-        * that it was submitted.  But as a rule it can't know whether or\r
-        * not it's already been unlinked ... so we respect the reversed\r
-        * lock sequence needed for the usb_hcd_giveback_urb() code paths\r
-        * (urb lock, then hcd_data_lock) in case some other CPU is now\r
-        * unlinking it.\r
-        */\r
-       spin_lock_irqsave (&urb->lock, flags);\r
-       spin_lock (&hcd_data_lock);\r
-\r
-       if (!urb->dev || !urb->dev->bus) {\r
-               retval = -ENODEV;\r
-               goto done;\r
-       }\r
-\r
-       dev = urb->dev->hcpriv;\r
-       sys = &urb->dev->dev;\r
-       hcd = urb->dev->bus->hcpriv;\r
-       if (!dev || !hcd) {\r
-               retval = -ENODEV;\r
-               goto done;\r
-       }\r
-\r
-       if (!urb->hcpriv) {\r
-               retval = -EINVAL;\r
-               goto done;\r
-       }\r
-\r
-       /* Any status except -EINPROGRESS means something already started to\r
-        * unlink this URB from the hardware.  So there's no more work to do.\r
-        *\r
-        * FIXME use better explicit urb state\r
-        */\r
-       if (urb->status != -EINPROGRESS) {\r
-               retval = -EBUSY;\r
-               goto done;\r
-       }\r
-\r
-       /* maybe set up to block until the urb's completion fires.  the\r
-        * lower level hcd code is always async, locking on urb->status\r
-        * updates; an intercepted completion unblocks us.\r
-        */\r
-       if (!(urb->transfer_flags & URB_ASYNC_UNLINK)) {\r
-               if (in_interrupt ()) {\r
-                       dev_dbg (hcd->controller, "non-async unlink in_interrupt");\r
-                       retval = -EWOULDBLOCK;\r
-                       goto done;\r
-               }\r
-               /* synchronous unlink: block till we see the completion */\r
-               init_completion (&splice.done);\r
-               splice.complete = urb->complete;\r
-               splice.context = urb->context;\r
-               urb->complete = unlink_complete;\r
-               urb->context = &splice;\r
-               urb->status = -ENOENT;\r
-       } else {\r
-               /* asynchronous unlink */\r
-               urb->status = -ECONNRESET;\r
-       }\r
-       spin_unlock (&hcd_data_lock);\r
-       spin_unlock_irqrestore (&urb->lock, flags);\r
-\r
-       // FIXME remove splicing, so this becomes unlink1 (hcd, urb);\r
-       if (urb == (struct urb *) hcd->rh_timer.data) {\r
-               usb_rh_status_dequeue (hcd, urb);\r
-               retval = 0;\r
-       } else {\r
-               retval = hcd->driver->urb_dequeue (hcd, urb);\r
-\r
-               /* hcds shouldn't really fail these calls, but... */\r
-               if (retval) {\r
-                       dev_dbg (sys, "dequeue %p --> %d\n", urb, retval);\r
-                       if (!(urb->transfer_flags & URB_ASYNC_UNLINK)) {\r
-                               spin_lock_irqsave (&urb->lock, flags);\r
-                               urb->complete = splice.complete;\r
-                               urb->context = splice.context;\r
-                               spin_unlock_irqrestore (&urb->lock, flags);\r
-                       }\r
-                       goto bye;\r
-               }\r
-       }\r
-\r
-       /* block till giveback, if needed */\r
-       if (urb->transfer_flags & URB_ASYNC_UNLINK)\r
-               return -EINPROGRESS;\r
-\r
-       wait_for_completion (&splice.done);\r
-       return 0;\r
-\r
-done:\r
-       spin_unlock (&hcd_data_lock);\r
-       spin_unlock_irqrestore (&urb->lock, flags);\r
-bye:\r
-       if (retval && sys && sys->driver)\r
-               dev_dbg (sys, "hcd_unlink_urb %p fail %d\n", urb, retval);\r
-       return retval;\r
-}\r
-\r
-/*-------------------------------------------------------------------------*/\r
-\r
-/* disables the endpoint: cancels any pending urbs, then synchronizes with\r
- * the hcd to make sure all endpoint state is gone from hardware. use for\r
- * set_configuration, set_interface, driver removal, physical disconnect.\r
- *\r
- * example:  a qh stored in hcd_dev.ep[], holding state related to endpoint\r
- * type, maxpacket size, toggle, halt status, and scheduling.\r
- */\r
-static void hcd_endpoint_disable (struct usb_device *udev, int endpoint)\r
-{\r
-       unsigned long   flags;\r
-       struct hcd_dev  *dev;\r
-       struct usb_hcd  *hcd;\r
-       struct urb      *urb;\r
-       unsigned        epnum = endpoint & USB_ENDPOINT_NUMBER_MASK;\r
-\r
-       dev = udev->hcpriv;\r
-       hcd = udev->bus->hcpriv;\r
-\r
-rescan:\r
-       /* (re)block new requests, as best we can */\r
-       if (endpoint & USB_DIR_IN) {\r
-               usb_endpoint_halt (udev, epnum, 0);\r
-               udev->epmaxpacketin [epnum] = 0;\r
-       } else {\r
-               usb_endpoint_halt (udev, epnum, 1);\r
-               udev->epmaxpacketout [epnum] = 0;\r
-       }\r
-\r
-       /* then kill any current requests */\r
-       spin_lock_irqsave (&hcd_data_lock, flags);\r
-       list_for_each_entry (urb, &dev->urb_list, urb_list) {\r
-               int     tmp = urb->pipe;\r
-\r
-               /* ignore urbs for other endpoints */\r
-               if (usb_pipeendpoint (tmp) != epnum)\r
-                       continue;\r
-               if ((tmp ^ endpoint) & USB_DIR_IN)\r
-                       continue;\r
-\r
-               /* another cpu may be in hcd, spinning on hcd_data_lock\r
-                * to giveback() this urb.  the races here should be\r
-                * small, but a full fix needs a new "can't submit"\r
-                * urb state.\r
-                */\r
-               if (urb->status != -EINPROGRESS)\r
-                       continue;\r
-               usb_get_urb (urb);\r
-               spin_unlock_irqrestore (&hcd_data_lock, flags);\r
-\r
-               spin_lock_irqsave (&urb->lock, flags);\r
-               tmp = urb->status;\r
-               if (tmp == -EINPROGRESS)\r
-                       urb->status = -ESHUTDOWN;\r
-               spin_unlock_irqrestore (&urb->lock, flags);\r
-\r
-               /* kick hcd unless it's already returning this */\r
-               if (tmp == -EINPROGRESS) {\r
-                       tmp = urb->pipe;\r
-                       unlink1 (hcd, urb);\r
-                       dev_dbg (hcd->controller,\r
-                               "shutdown urb %p pipe %08x ep%d%s%s\n",\r
-                               urb, tmp, usb_pipeendpoint (tmp),\r
-                               (tmp & USB_DIR_IN) ? "in" : "out",\r
-                               ({ char *s; \\r
-                                switch (usb_pipetype (tmp)) { \\r
-                                case PIPE_CONTROL:     s = ""; break; \\r
-                                case PIPE_BULK:        s = "-bulk"; break; \\r
-                                case PIPE_INTERRUPT:   s = "-intr"; break; \\r
-                                default:               s = "-iso"; break; \\r
-                               }; s;}));\r
-               }\r
-               usb_put_urb (urb);\r
-\r
-               /* list contents may have changed */\r
-               goto rescan;\r
-       }\r
-       spin_unlock_irqrestore (&hcd_data_lock, flags);\r
-\r
-       /* synchronize with the hardware, so old configuration state\r
-        * clears out immediately (and will be freed).\r
-        */\r
-       might_sleep ();\r
-       if (hcd->driver->endpoint_disable)\r
-               hcd->driver->endpoint_disable (hcd, dev, endpoint);\r
-}\r
-\r
-/*-------------------------------------------------------------------------*/\r
-\r
-/* called by khubd, rmmod, apmd, or other thread for hcd-private cleanup.\r
- * we're guaranteed that the device is fully quiesced.  also, that each\r
- * endpoint has been hcd_endpoint_disabled.\r
- */\r
-\r
-static int hcd_free_dev (struct usb_device *udev)\r
-{\r
-       struct hcd_dev          *dev;\r
-       struct usb_hcd          *hcd;\r
-       unsigned long           flags;\r
-\r
-       if (!udev || !udev->hcpriv)\r
-               return -EINVAL;\r
-\r
-       if (!udev->bus || !udev->bus->hcpriv)\r
-               return -ENODEV;\r
-\r
-       // should udev->devnum == -1 ??\r
-\r
-       dev = udev->hcpriv;\r
-       hcd = udev->bus->hcpriv;\r
-\r
-       /* device driver problem with refcounts? */\r
-       if (!list_empty (&dev->urb_list)) {\r
-               dev_dbg (hcd->controller, "free busy dev, %s devnum %d (bug!)\n",\r
-                       hcd->self.bus_name, udev->devnum);\r
-               return -EINVAL;\r
-       }\r
-\r
-       spin_lock_irqsave (&hcd_data_lock, flags);\r
-       list_del (&dev->dev_list);\r
-       udev->hcpriv = NULL;\r
-       spin_unlock_irqrestore (&hcd_data_lock, flags);\r
-\r
-       kfree (dev);\r
-       return 0;\r
-}\r
-\r
-/*\r
- * usb_hcd_operations - adapts usb_bus framework to HCD framework (bus glue)\r
- *\r
- * When registering a USB bus through the HCD framework code, use this\r
- * usb_operations vector.  The PCI glue layer does so automatically; only\r
- * bus glue for non-PCI system busses will need to use this.\r
- */\r
-struct usb_operations usb_hcd_operations = {\r
-       .allocate =             hcd_alloc_dev,\r
-       .get_frame_number =     hcd_get_frame_number,\r
-       .submit_urb =           hcd_submit_urb,\r
-       .unlink_urb =           hcd_unlink_urb,\r
-       .deallocate =           hcd_free_dev,\r
-       .buffer_alloc =         hcd_buffer_alloc,\r
-       .buffer_free =          hcd_buffer_free,\r
-       .disable =              hcd_endpoint_disable,\r
-};\r
-EXPORT_SYMBOL (usb_hcd_operations);\r
-\r
-/*-------------------------------------------------------------------------*/\r
-\r
-/**\r
- * usb_hcd_giveback_urb - return URB from HCD to device driver\r
- * @hcd: host controller returning the URB\r
- * @urb: urb being returned to the USB device driver.\r
- * @regs: pt_regs, passed down to the URB completion handler\r
- * Context: in_interrupt()\r
- *\r
- * This hands the URB from HCD to its USB device driver, using its\r
- * completion function.  The HCD has freed all per-urb resources\r
- * (and is done using urb->hcpriv).  It also released all HCD locks;\r
- * the device driver won't cause problems if it frees, modifies,\r
- * or resubmits this URB.\r
- */\r
-void STDCALL usb_hcd_giveback_urb (struct usb_hcd *hcd, struct urb *urb, struct pt_regs *regs)\r
-{\r
-       urb_unlink (urb);\r
-\r
-       // NOTE:  a generic device/urb monitoring hook would go here.\r
-       // hcd_monitor_hook(MONITOR_URB_FINISH, urb, dev)\r
-       // It would catch exit/unlink paths for all urbs.\r
-\r
-       /* lower level hcd code should use *_dma exclusively */\r
-       if (!(urb->transfer_flags & URB_NO_DMA_MAP)) {\r
-               if (usb_pipecontrol (urb->pipe))\r
-                       pci_unmap_single (hcd->pdev, urb->setup_dma,\r
-                                       sizeof (struct usb_ctrlrequest),\r
-                                       PCI_DMA_TODEVICE);\r
-               if (urb->transfer_buffer_length != 0)\r
-                       pci_unmap_single (hcd->pdev, urb->transfer_dma,\r
-                                       urb->transfer_buffer_length,\r
-                                       usb_pipein (urb->pipe)\r
-                                           ? PCI_DMA_FROMDEVICE\r
-                                           : PCI_DMA_TODEVICE);\r
-       }\r
-\r
-       /* pass ownership to the completion handler */\r
-       urb->complete (urb, regs);\r
-       usb_put_urb (urb);\r
-}\r
-\r
-/*-------------------------------------------------------------------------*/\r
-\r
-/**\r
- * usb_hcd_irq - hook IRQs to HCD framework (bus glue)\r
- * @irq: the IRQ being raised\r
- * @__hcd: pointer to the HCD whose IRQ is beinng signaled\r
- * @r: saved hardware registers\r
- *\r
- * When registering a USB bus through the HCD framework code, use this\r
- * to handle interrupts.  The PCI glue layer does so automatically; only\r
- * bus glue for non-PCI system busses will need to use this.\r
- */\r
-irqreturn_t usb_hcd_irq (int irq, void *__hcd, struct pt_regs * r)\r
-{\r
-       struct usb_hcd          *hcd = __hcd;\r
-       int                     start = hcd->state;\r
-\r
-       if (unlikely (hcd->state == USB_STATE_HALT))    /* irq sharing? */\r
-               return IRQ_NONE;\r
-\r
-       hcd->driver->irq (hcd, r);\r
-       if (hcd->state != start && hcd->state == USB_STATE_HALT)\r
-               usb_hc_died (hcd);\r
-       return IRQ_HANDLED;\r
-}\r
-\r
-/*-------------------------------------------------------------------------*/\r
-\r
-static void hcd_panic (void *_hcd)\r
-{\r
-       struct usb_hcd *hcd = _hcd;\r
-       hcd->driver->stop (hcd);\r
-}\r
-\r
-/**\r
- * usb_hc_died - report abnormal shutdown of a host controller (bus glue)\r
- * @hcd: pointer to the HCD representing the controller\r
- *\r
- * This is called by bus glue to report a USB host controller that died\r
- * while operations may still have been pending.  It's called automatically\r
- * by the PCI glue, so only glue for non-PCI busses should need to call it. \r
- */\r
-void STDCALL usb_hc_died (struct usb_hcd *hcd)\r
-{\r
-       struct list_head        *devlist, *urblist;\r
-       struct hcd_dev          *dev;\r
-       struct urb              *urb;\r
-       unsigned long           flags;\r
-       \r
-       /* flag every pending urb as done */\r
-       spin_lock_irqsave (&hcd_data_lock, flags);\r
-       list_for_each (devlist, &hcd->dev_list) {\r
-               dev = list_entry (devlist, struct hcd_dev, dev_list);\r
-               list_for_each (urblist, &dev->urb_list) {\r
-                       urb = list_entry (urblist, struct urb, urb_list);\r
-                       dev_dbg (hcd->controller, "shutdown %s urb %p pipe %x, current status %d\n",\r
-                               hcd->self.bus_name, urb, urb->pipe, urb->status);\r
-                       if (urb->status == -EINPROGRESS)\r
-                               urb->status = -ESHUTDOWN;\r
-               }\r
-       }\r
-       urb = (struct urb *) hcd->rh_timer.data;\r
-       if (urb)\r
-               urb->status = -ESHUTDOWN;\r
-       spin_unlock_irqrestore (&hcd_data_lock, flags);\r
-\r
-       /* hcd->stop() needs a task context */\r
-       INIT_WORK (&hcd->work, hcd_panic, hcd);\r
-       (void) schedule_work (&hcd->work);\r
-}\r
-\r
+/*
+ * (C) Copyright Linus Torvalds 1999
+ * (C) Copyright Johannes Erdfelt 1999-2001
+ * (C) Copyright Andreas Gal 1999
+ * (C) Copyright Gregory P. Smith 1999
+ * (C) Copyright Deti Fliegl 1999
+ * (C) Copyright Randy Dunlap 2000
+ * (C) Copyright David Brownell 2000-2002
+ * 
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#if 0
+#include <linux/config.h>
+
+#ifdef CONFIG_USB_DEBUG
+#define DEBUG
+#endif
+
+#include <linux/module.h>
+#include <linux/version.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/completion.h>
+#include <linux/uts.h>                 /* for UTS_SYSNAME */
+#include <linux/pci.h>                 /* for hcd->pdev and dma addressing */
+#include <linux/dma-mapping.h>
+#include <asm/byteorder.h>
+
+#include <linux/usb.h>
+#else
+#include "../usb_wrapper.h"
+//#define DEBUG
+#endif
+
+#include "hcd.h"
+
+// #define USB_BANDWIDTH_MESSAGES
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * USB Host Controller Driver framework
+ *
+ * Plugs into usbcore (usb_bus) and lets HCDs share code, minimizing
+ * HCD-specific behaviors/bugs.
+ *
+ * This does error checks, tracks devices and urbs, and delegates to a
+ * "hc_driver" only for code (and data) that really needs to know about
+ * hardware differences.  That includes root hub registers, i/o queues,
+ * and so on ... but as little else as possible.
+ *
+ * Shared code includes most of the "root hub" code (these are emulated,
+ * though each HC's hardware works differently) and PCI glue, plus request
+ * tracking overhead.  The HCD code should only block on spinlocks or on
+ * hardware handshaking; blocking on software events (such as other kernel
+ * threads releasing resources, or completing actions) is all generic.
+ *
+ * Happens the USB 2.0 spec says this would be invisible inside the "USBD",
+ * and includes mostly a "HCDI" (HCD Interface) along with some APIs used
+ * only by the hub driver ... and that neither should be seen or used by
+ * usb client device drivers.
+ *
+ * Contributors of ideas or unattributed patches include: David Brownell,
+ * Roman Weissgaerber, Rory Bolt, Greg Kroah-Hartman, ...
+ *
+ * HISTORY:
+ * 2002-02-21  Pull in most of the usb_bus support from usb.c; some
+ *             associated cleanup.  "usb_hcd" still != "usb_bus".
+ * 2001-12-12  Initial patch version for Linux 2.5.1 kernel.
+ */
+
+/*-------------------------------------------------------------------------*/
+
+/* host controllers we manage */
+LIST_HEAD (usb_bus_list);
+EXPORT_SYMBOL_GPL (usb_bus_list);
+
+/* used when allocating bus numbers */
+#define USB_MAXBUS             64
+struct usb_busmap {
+       unsigned long busmap [USB_MAXBUS / (8*sizeof (unsigned long))];
+};
+static struct usb_busmap busmap;
+
+/* used when updating list of hcds */
+DECLARE_MUTEX (usb_bus_list_lock);     /* exported only for usbfs */
+EXPORT_SYMBOL_GPL (usb_bus_list_lock);
+
+/* used when updating hcd data */
+static spinlock_t hcd_data_lock = SPIN_LOCK_UNLOCKED;
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * Sharable chunks of root hub code.
+ */
+
+/*-------------------------------------------------------------------------*/
+
+#define KERNEL_REL     ((LINUX_VERSION_CODE >> 16) & 0x0ff)
+#define KERNEL_VER     ((LINUX_VERSION_CODE >> 8) & 0x0ff)
+
+/* usb 2.0 root hub device descriptor */
+static const u8 usb2_rh_dev_descriptor [18] = {
+       0x12,       /*  __u8  bLength; */
+       0x01,       /*  __u8  bDescriptorType; Device */
+       0x00, 0x02, /*  __u16 bcdUSB; v2.0 */
+
+       0x09,       /*  __u8  bDeviceClass; HUB_CLASSCODE */
+       0x00,       /*  __u8  bDeviceSubClass; */
+       0x01,       /*  __u8  bDeviceProtocol; [ usb 2.0 single TT ]*/
+       0x08,       /*  __u8  bMaxPacketSize0; 8 Bytes */
+
+       0x00, 0x00, /*  __u16 idVendor; */
+       0x00, 0x00, /*  __u16 idProduct; */
+       KERNEL_VER, KERNEL_REL, /*  __u16 bcdDevice */
+
+       0x03,       /*  __u8  iManufacturer; */
+       0x02,       /*  __u8  iProduct; */
+       0x01,       /*  __u8  iSerialNumber; */
+       0x01        /*  __u8  bNumConfigurations; */
+};
+
+/* no usb 2.0 root hub "device qualifier" descriptor: one speed only */
+
+/* usb 1.1 root hub device descriptor */
+static const u8 usb11_rh_dev_descriptor [18] = {
+       0x12,       /*  __u8  bLength; */
+       0x01,       /*  __u8  bDescriptorType; Device */
+       0x10, 0x01, /*  __u16 bcdUSB; v1.1 */
+
+       0x09,       /*  __u8  bDeviceClass; HUB_CLASSCODE */
+       0x00,       /*  __u8  bDeviceSubClass; */
+       0x00,       /*  __u8  bDeviceProtocol; [ low/full speeds only ] */
+       0x08,       /*  __u8  bMaxPacketSize0; 8 Bytes */
+
+       0x00, 0x00, /*  __u16 idVendor; */
+       0x00, 0x00, /*  __u16 idProduct; */
+       KERNEL_VER, KERNEL_REL, /*  __u16 bcdDevice */
+
+       0x03,       /*  __u8  iManufacturer; */
+       0x02,       /*  __u8  iProduct; */
+       0x01,       /*  __u8  iSerialNumber; */
+       0x01        /*  __u8  bNumConfigurations; */
+};
+
+
+/*-------------------------------------------------------------------------*/
+
+/* Configuration descriptors for our root hubs */
+
+static const u8 fs_rh_config_descriptor [] = {
+
+       /* one configuration */
+       0x09,       /*  __u8  bLength; */
+       0x02,       /*  __u8  bDescriptorType; Configuration */
+       0x19, 0x00, /*  __u16 wTotalLength; */
+       0x01,       /*  __u8  bNumInterfaces; (1) */
+       0x01,       /*  __u8  bConfigurationValue; */
+       0x00,       /*  __u8  iConfiguration; */
+       0x40,       /*  __u8  bmAttributes; 
+                                Bit 7: Bus-powered,
+                                    6: Self-powered,
+                                    5 Remote-wakwup,
+                                    4..0: resvd */
+       0x00,       /*  __u8  MaxPower; */
+      
+       /* USB 1.1:
+        * USB 2.0, single TT organization (mandatory):
+        *      one interface, protocol 0
+        *
+        * USB 2.0, multiple TT organization (optional):
+        *      two interfaces, protocols 1 (like single TT)
+        *      and 2 (multiple TT mode) ... config is
+        *      sometimes settable
+        *      NOT IMPLEMENTED
+        */
+
+       /* one interface */
+       0x09,       /*  __u8  if_bLength; */
+       0x04,       /*  __u8  if_bDescriptorType; Interface */
+       0x00,       /*  __u8  if_bInterfaceNumber; */
+       0x00,       /*  __u8  if_bAlternateSetting; */
+       0x01,       /*  __u8  if_bNumEndpoints; */
+       0x09,       /*  __u8  if_bInterfaceClass; HUB_CLASSCODE */
+       0x00,       /*  __u8  if_bInterfaceSubClass; */
+       0x00,       /*  __u8  if_bInterfaceProtocol; [usb1.1 or single tt] */
+       0x00,       /*  __u8  if_iInterface; */
+     
+       /* one endpoint (status change endpoint) */
+       0x07,       /*  __u8  ep_bLength; */
+       0x05,       /*  __u8  ep_bDescriptorType; Endpoint */
+       0x81,       /*  __u8  ep_bEndpointAddress; IN Endpoint 1 */
+       0x03,       /*  __u8  ep_bmAttributes; Interrupt */
+       0x02, 0x00, /*  __u16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8) */
+       0xff        /*  __u8  ep_bInterval; (255ms -- usb 2.0 spec) */
+};
+
+static const u8 hs_rh_config_descriptor [] = {
+
+       /* one configuration */
+       0x09,       /*  __u8  bLength; */
+       0x02,       /*  __u8  bDescriptorType; Configuration */
+       0x19, 0x00, /*  __u16 wTotalLength; */
+       0x01,       /*  __u8  bNumInterfaces; (1) */
+       0x01,       /*  __u8  bConfigurationValue; */
+       0x00,       /*  __u8  iConfiguration; */
+       0x40,       /*  __u8  bmAttributes; 
+                                Bit 7: Bus-powered,
+                                    6: Self-powered,
+                                    5 Remote-wakwup,
+                                    4..0: resvd */
+       0x00,       /*  __u8  MaxPower; */
+      
+       /* USB 1.1:
+        * USB 2.0, single TT organization (mandatory):
+        *      one interface, protocol 0
+        *
+        * USB 2.0, multiple TT organization (optional):
+        *      two interfaces, protocols 1 (like single TT)
+        *      and 2 (multiple TT mode) ... config is
+        *      sometimes settable
+        *      NOT IMPLEMENTED
+        */
+
+       /* one interface */
+       0x09,       /*  __u8  if_bLength; */
+       0x04,       /*  __u8  if_bDescriptorType; Interface */
+       0x00,       /*  __u8  if_bInterfaceNumber; */
+       0x00,       /*  __u8  if_bAlternateSetting; */
+       0x01,       /*  __u8  if_bNumEndpoints; */
+       0x09,       /*  __u8  if_bInterfaceClass; HUB_CLASSCODE */
+       0x00,       /*  __u8  if_bInterfaceSubClass; */
+       0x00,       /*  __u8  if_bInterfaceProtocol; [usb1.1 or single tt] */
+       0x00,       /*  __u8  if_iInterface; */
+     
+       /* one endpoint (status change endpoint) */
+       0x07,       /*  __u8  ep_bLength; */
+       0x05,       /*  __u8  ep_bDescriptorType; Endpoint */
+       0x81,       /*  __u8  ep_bEndpointAddress; IN Endpoint 1 */
+       0x03,       /*  __u8  ep_bmAttributes; Interrupt */
+       0x02, 0x00, /*  __u16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8) */
+       0x0c        /*  __u8  ep_bInterval; (256ms -- usb 2.0 spec) */
+};
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * helper routine for returning string descriptors in UTF-16LE
+ * input can actually be ISO-8859-1; ASCII is its 7-bit subset
+ */
+static int ascii2utf (char *s, u8 *utf, int utfmax)
+{
+       int retval;
+
+       for (retval = 0; *s && utfmax > 1; utfmax -= 2, retval += 2) {
+               *utf++ = *s++;
+               *utf++ = 0;
+       }
+       return retval;
+}
+
+/*
+ * rh_string - provides manufacturer, product and serial strings for root hub
+ * @id: the string ID number (1: serial number, 2: product, 3: vendor)
+ * @hcd: the host controller for this root hub
+ * @type: string describing our driver 
+ * @data: return packet in UTF-16 LE
+ * @len: length of the return packet
+ *
+ * Produces either a manufacturer, product or serial number string for the
+ * virtual root hub device.
+ */
+static int rh_string (
+       int             id,
+       struct usb_hcd  *hcd,
+       u8              *data,
+       int             len
+) {
+       char buf [100];
+
+       // language ids
+       if (id == 0) {
+               *data++ = 4; *data++ = 3;       /* 4 bytes string data */
+               *data++ = 0x09; *data++ = 0x04; /* MSFT-speak for "en-us" */
+               return 4;
+
+       // serial number
+       } else if (id == 1) {
+               strcpy (buf, hcd->self.bus_name);
+
+       // product description
+       } else if (id == 2) {
+                strcpy (buf, hcd->product_desc);
+
+       // id 3 == vendor description
+       } else if (id == 3) {
+                sprintf (buf, "%s %s %s", UTS_SYSNAME, UTS_RELEASE,
+                       hcd->description);
+
+       // unsupported IDs --> "protocol stall"
+       } else
+           return 0;
+
+       data [0] = 2 * (strlen (buf) + 1);
+       data [1] = 3;   /* type == string */
+       return 2 + ascii2utf (buf, data + 2, len - 2);
+}
+
+
+/* Root hub control transfers execute synchronously */
+static int rh_call_control (struct usb_hcd *hcd, struct urb *urb)
+{
+       struct usb_ctrlrequest *cmd = (struct usb_ctrlrequest *) urb->setup_packet;
+       u16             typeReq, wValue, wIndex, wLength;
+       const u8        *bufp = 0;
+       u8              *ubuf = urb->transfer_buffer;
+       int             len = 0;
+       //unsigned long flags;
+
+       typeReq  = (cmd->bRequestType << 8) | cmd->bRequest;
+       wValue   = le16_to_cpu (cmd->wValue);
+       wIndex   = le16_to_cpu (cmd->wIndex);
+       wLength  = le16_to_cpu (cmd->wLength);
+
+       if (wLength > urb->transfer_buffer_length)
+               goto error;
+
+       /* set up for success */
+       urb->status = 0;
+       urb->actual_length = wLength;
+       switch (typeReq) {
+
+       /* DEVICE REQUESTS */
+
+       case DeviceRequest | USB_REQ_GET_STATUS:
+               // DEVICE_REMOTE_WAKEUP
+               ubuf [0] = 1; // selfpowered
+               ubuf [1] = 0;
+                       /* FALLTHROUGH */
+       case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
+       case DeviceOutRequest | USB_REQ_SET_FEATURE:
+               dev_dbg (hcd->controller, "no device features yet yet\n");
+               break;
+       case DeviceRequest | USB_REQ_GET_CONFIGURATION:
+               ubuf [0] = 1;
+                       /* FALLTHROUGH */
+       case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
+               break;
+       case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
+               switch (wValue & 0xff00) {
+               case USB_DT_DEVICE << 8:
+                       if (hcd->driver->flags & HCD_USB2)
+                               bufp = usb2_rh_dev_descriptor;
+                       else if (hcd->driver->flags & HCD_USB11)
+                               bufp = usb11_rh_dev_descriptor;
+                       else
+                               goto error;
+                       len = 18;
+                       break;
+               case USB_DT_CONFIG << 8:
+                       if (hcd->driver->flags & HCD_USB2) {
+                               bufp = hs_rh_config_descriptor;
+                               len = sizeof hs_rh_config_descriptor;
+                       } else {
+                               bufp = fs_rh_config_descriptor;
+                               len = sizeof fs_rh_config_descriptor;
+                       }
+                       break;
+               case USB_DT_STRING << 8:
+                       urb->actual_length = rh_string (
+                               wValue & 0xff, hcd,
+                               ubuf, wLength);
+                       break;
+               default:
+                       goto error;
+               }
+               break;
+       case DeviceRequest | USB_REQ_GET_INTERFACE:
+               ubuf [0] = 0;
+                       /* FALLTHROUGH */
+       case DeviceOutRequest | USB_REQ_SET_INTERFACE:
+               break;
+       case DeviceOutRequest | USB_REQ_SET_ADDRESS:
+               // wValue == urb->dev->devaddr
+               dev_dbg (hcd->controller, "root hub device address %d\n",
+                       wValue);
+               break;
+
+       /* INTERFACE REQUESTS (no defined feature/status flags) */
+
+       /* ENDPOINT REQUESTS */
+
+       case EndpointRequest | USB_REQ_GET_STATUS:
+               // ENDPOINT_HALT flag
+               ubuf [0] = 0;
+               ubuf [1] = 0;
+                       /* FALLTHROUGH */
+       case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
+       case EndpointOutRequest | USB_REQ_SET_FEATURE:
+               dev_dbg (hcd->controller, "no endpoint features yet\n");
+               break;
+
+       /* CLASS REQUESTS (and errors) */
+
+       default:
+               /* non-generic request */
+               urb->status = hcd->driver->hub_control (hcd,
+                       typeReq, wValue, wIndex,
+                       ubuf, wLength);
+               break;
+error:
+               /* "protocol stall" on error */
+               urb->status = -EPIPE;
+               dev_dbg (hcd->controller, "unsupported hub control message (maxchild %d)\n",
+                               urb->dev->maxchild);
+       }
+       if (urb->status) {
+               urb->actual_length = 0;
+               dev_dbg (hcd->controller, "CTRL: TypeReq=0x%x val=0x%x idx=0x%x len=%d ==> %d\n",
+                       typeReq, wValue, wIndex, wLength, urb->status);
+       }
+       if (bufp) {
+               if (urb->transfer_buffer_length < len)
+                       len = urb->transfer_buffer_length;
+               urb->actual_length = len;
+               // always USB_DIR_IN, toward host
+               memcpy (ubuf, bufp, len);
+       }
+
+       /* any errors get returned through the urb completion */
+       local_irq_save (flags);
+       usb_hcd_giveback_urb (hcd, urb, NULL);
+       local_irq_restore (flags);
+       return 0;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * Root Hub interrupt transfers are synthesized with a timer.
+ * Completions are called in_interrupt() but not in_irq().
+ */
+
+static void rh_report_status (unsigned long ptr);
+
+static int rh_status_urb (struct usb_hcd *hcd, struct urb *urb) 
+{
+       int     len = 1 + (urb->dev->maxchild / 8);
+
+       /* rh_timer protected by hcd_data_lock */
+       if (hcd->rh_timer.data
+                       || urb->status != -EINPROGRESS
+                       || urb->transfer_buffer_length < len) {
+               dev_dbg (hcd->controller,
+                               "not queuing rh status urb, stat %d\n",
+                               urb->status);
+               return -EINVAL;
+       }
+
+       init_timer (&hcd->rh_timer);
+
+       hcd->rh_timer.function = rh_report_status;
+       hcd->rh_timer.data = (unsigned long) urb;
+       /* USB 2.0 spec says 256msec; this is close enough */
+       hcd->rh_timer.expires = jiffies + HZ/4;
+       add_timer (&hcd->rh_timer);
+       urb->hcpriv = hcd;      /* nonzero to indicate it's queued */
+       return 0;
+}
+
+/* timer callback */
+
+static void rh_report_status (unsigned long ptr)
+{
+       struct urb      *urb;
+       struct usb_hcd  *hcd;
+       int             length;
+       //unsigned long flags;
+
+       urb = (struct urb *) ptr;
+       local_irq_save (flags);
+       spin_lock (&urb->lock);
+
+       /* do nothing if the hc is gone or the urb's been unlinked */
+       if (!urb->dev
+                       || urb->status != -EINPROGRESS
+                       || (hcd = urb->dev->bus->hcpriv) == 0
+                       || !HCD_IS_RUNNING (hcd->state)) {
+               spin_unlock (&urb->lock);
+               local_irq_restore (flags);
+               return;
+       }
+
+       length = hcd->driver->hub_status_data (hcd, urb->transfer_buffer);
+
+       /* complete the status urb, or retrigger the timer */
+       spin_lock (&hcd_data_lock);
+       if (length > 0) {
+               hcd->rh_timer.data = 0;
+               urb->actual_length = length;
+               urb->status = 0;
+               urb->hcpriv = 0;
+       } else
+               mod_timer (&hcd->rh_timer, jiffies + HZ/4);
+       spin_unlock (&hcd_data_lock);
+       spin_unlock (&urb->lock);
+
+       /* local irqs are always blocked in completions */
+       if (length > 0)
+               usb_hcd_giveback_urb (hcd, urb, NULL);
+       local_irq_restore (flags);
+}
+
+/*-------------------------------------------------------------------------*/
+
+static int rh_urb_enqueue (struct usb_hcd *hcd, struct urb *urb)
+{
+       if (usb_pipeint (urb->pipe)) {
+               int             retval;
+               unsigned long   flags;
+
+               spin_lock_irqsave (&hcd_data_lock, flags);
+               retval = rh_status_urb (hcd, urb);
+               spin_unlock_irqrestore (&hcd_data_lock, flags);
+               return retval;
+       }
+       if (usb_pipecontrol (urb->pipe))
+               return rh_call_control (hcd, urb);
+       else
+               return -EINVAL;
+}
+
+/*-------------------------------------------------------------------------*/
+
+void usb_rh_status_dequeue (struct usb_hcd *hcd, struct urb *urb)
+{
+       //unsigned long flags;
+
+       /* note:  always a synchronous unlink */
+       del_timer_sync (&hcd->rh_timer);
+       hcd->rh_timer.data = 0;
+
+       local_irq_save (flags);
+       urb->hcpriv = 0;
+       usb_hcd_giveback_urb (hcd, urb, NULL);
+       local_irq_restore (flags);
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* exported only within usbcore */
+void usb_bus_get (struct usb_bus *bus)
+{
+       atomic_inc (&bus->refcnt);
+}
+
+/* exported only within usbcore */
+void usb_bus_put (struct usb_bus *bus)
+{
+       if (atomic_dec_and_test (&bus->refcnt))
+               kfree (bus);
+}
+
+/*-------------------------------------------------------------------------*/
+
+/**
+ * usb_bus_init - shared initialization code
+ * @bus: the bus structure being initialized
+ *
+ * This code is used to initialize a usb_bus structure, memory for which is
+ * separately managed.
+ */
+void STDCALL usb_bus_init (struct usb_bus *bus)
+{
+       memset (&bus->devmap, 0, sizeof(struct usb_devmap));
+
+       bus->devnum_next = 1;
+
+       bus->root_hub = NULL;
+       bus->hcpriv = NULL;
+       bus->busnum = -1;
+       bus->bandwidth_allocated = 0;
+       bus->bandwidth_int_reqs  = 0;
+       bus->bandwidth_isoc_reqs = 0;
+
+       INIT_LIST_HEAD (&bus->bus_list);
+
+       atomic_set (&bus->refcnt, 1);
+}
+
+/**
+ * usb_alloc_bus - creates a new USB host controller structure
+ * @op: pointer to a struct usb_operations that this bus structure should use
+ * Context: !in_interrupt()
+ *
+ * Creates a USB host controller bus structure with the specified 
+ * usb_operations and initializes all the necessary internal objects.
+ *
+ * If no memory is available, NULL is returned.
+ *
+ * The caller should call usb_free_bus() when it is finished with the structure.
+ */
+struct usb_bus STDCALL *usb_alloc_bus (struct usb_operations *op)
+{
+       struct usb_bus *bus;
+
+       bus = kmalloc (sizeof *bus, GFP_KERNEL);
+       if (!bus)
+               return NULL;
+       usb_bus_init (bus);
+       bus->op = op;
+       return bus;
+}
+
+/**
+ * usb_free_bus - frees the memory used by a bus structure
+ * @bus: pointer to the bus to free
+ *
+ * To be invoked by a HCD, only as the last step of decoupling from
+ * hardware.  It is an error to call this if the reference count is
+ * anything but one.  That would indicate that some system component
+ * did not correctly shut down, and thought the hardware was still
+ * accessible.
+ */
+void STDCALL usb_free_bus (struct usb_bus *bus)
+{
+       if (!bus)
+               return;
+       if (atomic_read (&bus->refcnt) != 1)
+               err ("usb_free_bus #%d, count != 1", bus->busnum);
+       usb_bus_put (bus);
+}
+
+/*-------------------------------------------------------------------------*/
+
+/**
+ * usb_register_bus - registers the USB host controller with the usb core
+ * @bus: pointer to the bus to register
+ * Context: !in_interrupt()
+ *
+ * Assigns a bus number, and links the controller into usbcore data
+ * structures so that it can be seen by scanning the bus list.
+ */
+void STDCALL usb_register_bus(struct usb_bus *bus)
+{
+       int busnum;
+
+       down (&usb_bus_list_lock);
+       busnum = find_next_zero_bit (busmap.busmap, USB_MAXBUS, 1);
+       if (busnum < USB_MAXBUS) {
+               set_bit (busnum, busmap.busmap);
+               bus->busnum = busnum;
+       } else
+               warn ("too many buses");
+
+       usb_bus_get (bus);
+
+       /* Add it to the list of buses */
+       list_add (&bus->bus_list, &usb_bus_list);
+       up (&usb_bus_list_lock);
+
+       usbfs_add_bus (bus);
+
+       dev_info (bus->controller, "new USB bus registered, assigned bus number %d\n", bus->busnum);
+}
+
+/**
+ * usb_deregister_bus - deregisters the USB host controller
+ * @bus: pointer to the bus to deregister
+ * Context: !in_interrupt()
+ *
+ * Recycles the bus number, and unlinks the controller from usbcore data
+ * structures so that it won't be seen by scanning the bus list.
+ */
+void STDCALL usb_deregister_bus (struct usb_bus *bus)
+{
+       dev_info (bus->controller, "USB bus %d deregistered\n", bus->busnum);
+
+       /*
+        * NOTE: make sure that all the devices are removed by the
+        * controller code, as well as having it call this when cleaning
+        * itself up
+        */
+       down (&usb_bus_list_lock);
+       list_del (&bus->bus_list);
+       up (&usb_bus_list_lock);
+
+       usbfs_remove_bus (bus);
+
+       clear_bit (bus->busnum, busmap.busmap);
+
+       usb_bus_put (bus);
+}
+
+/**
+ * usb_register_root_hub - called by HCD to register its root hub 
+ * @usb_dev: the usb root hub device to be registered.
+ * @parent_dev: the parent device of this root hub.
+ *
+ * The USB host controller calls this function to register the root hub
+ * properly with the USB subsystem.  It sets up the device properly in
+ * the driverfs tree, and then calls usb_new_device() to register the
+ * usb device.
+ */
+int STDCALL usb_register_root_hub (struct usb_device *usb_dev, struct device *parent_dev)
+{
+       int retval;
+
+       sprintf (&usb_dev->dev.bus_id[0], "usb%d", usb_dev->bus->busnum);
+       usb_dev->state = USB_STATE_DEFAULT;
+       retval = usb_new_device (usb_dev, parent_dev);
+       if (retval)
+               dev_err (parent_dev, "can't register root hub for %s, %d\n",
+                               usb_dev->dev.bus_id, retval);
+       return retval;
+}
+
+
+/*-------------------------------------------------------------------------*/
+
+/**
+ * usb_calc_bus_time - approximate periodic transaction time in nanoseconds
+ * @speed: from dev->speed; USB_SPEED_{LOW,FULL,HIGH}
+ * @is_input: true iff the transaction sends data to the host
+ * @isoc: true for isochronous transactions, false for interrupt ones
+ * @bytecount: how many bytes in the transaction.
+ *
+ * Returns approximate bus time in nanoseconds for a periodic transaction.
+ * See USB 2.0 spec section 5.11.3; only periodic transfers need to be
+ * scheduled in software, this function is only used for such scheduling.
+ */
+long STDCALL usb_calc_bus_time (int speed, int is_input, int isoc, int bytecount)
+{
+       unsigned long   tmp;
+
+       switch (speed) {
+       case USB_SPEED_LOW:     /* INTR only */
+               if (is_input) {
+                       tmp = (67667L * (31L + 10L * BitTime (bytecount))) / 1000L;
+                       return (64060L + (2 * BW_HUB_LS_SETUP) + BW_HOST_DELAY + tmp);
+               } else {
+                       tmp = (66700L * (31L + 10L * BitTime (bytecount))) / 1000L;
+                       return (64107L + (2 * BW_HUB_LS_SETUP) + BW_HOST_DELAY + tmp);
+               }
+       case USB_SPEED_FULL:    /* ISOC or INTR */
+               if (isoc) {
+                       tmp = (8354L * (31L + 10L * BitTime (bytecount))) / 1000L;
+                       return (((is_input) ? 7268L : 6265L) + BW_HOST_DELAY + tmp);
+               } else {
+                       tmp = (8354L * (31L + 10L * BitTime (bytecount))) / 1000L;
+                       return (9107L + BW_HOST_DELAY + tmp);
+               }
+       case USB_SPEED_HIGH:    /* ISOC or INTR */
+               // FIXME adjust for input vs output
+               if (isoc)
+                       tmp = HS_USECS (bytecount);
+               else
+                       tmp = HS_USECS_ISO (bytecount);
+               return tmp;
+       default:
+               dbg ("bogus device speed!");
+               return -1;
+       }
+}
+
+/*
+ * usb_check_bandwidth():
+ *
+ * old_alloc is from host_controller->bandwidth_allocated in microseconds;
+ * bustime is from calc_bus_time(), but converted to microseconds.
+ *
+ * returns <bustime in us> if successful,
+ * or -ENOSPC if bandwidth request fails.
+ *
+ * FIXME:
+ * This initial implementation does not use Endpoint.bInterval
+ * in managing bandwidth allocation.
+ * It probably needs to be expanded to use Endpoint.bInterval.
+ * This can be done as a later enhancement (correction).
+ *
+ * This will also probably require some kind of
+ * frame allocation tracking...meaning, for example,
+ * that if multiple drivers request interrupts every 10 USB frames,
+ * they don't all have to be allocated at
+ * frame numbers N, N+10, N+20, etc.  Some of them could be at
+ * N+11, N+21, N+31, etc., and others at
+ * N+12, N+22, N+32, etc.
+ *
+ * Similarly for isochronous transfers...
+ *
+ * Individual HCDs can schedule more directly ... this logic
+ * is not correct for high speed transfers.
+ */
+int STDCALL usb_check_bandwidth (struct usb_device *dev, struct urb *urb)
+{
+       unsigned int    pipe = urb->pipe;
+       long            bustime;
+       int             is_in = usb_pipein (pipe);
+       int             is_iso = usb_pipeisoc (pipe);
+       int             old_alloc = dev->bus->bandwidth_allocated;
+       int             new_alloc;
+
+
+       bustime = NS_TO_US (usb_calc_bus_time (dev->speed, is_in, is_iso,
+                       usb_maxpacket (dev, pipe, !is_in)));
+       if (is_iso)
+               bustime /= urb->number_of_packets;
+
+       new_alloc = old_alloc + (int) bustime;
+       if (new_alloc > FRAME_TIME_MAX_USECS_ALLOC) {
+#ifdef DEBUG
+               char    *mode = 
+#ifdef CONFIG_USB_BANDWIDTH
+                       "";
+#else
+                       "would have ";
+#endif
+               dev_dbg (&dev->dev, "usb_check_bandwidth %sFAILED: %d + %ld = %d usec\n",
+                       mode, old_alloc, bustime, new_alloc);
+#endif
+#ifdef CONFIG_USB_BANDWIDTH
+               bustime = -ENOSPC;      /* report error */
+#endif
+       }
+
+       return bustime;
+}
+
+
+/**
+ * usb_claim_bandwidth - records bandwidth for a periodic transfer
+ * @dev: source/target of request
+ * @urb: request (urb->dev == dev)
+ * @bustime: bandwidth consumed, in (average) microseconds per frame
+ * @isoc: true iff the request is isochronous
+ *
+ * Bus bandwidth reservations are recorded purely for diagnostic purposes.
+ * HCDs are expected not to overcommit periodic bandwidth, and to record such
+ * reservations whenever endpoints are added to the periodic schedule.
+ *
+ * FIXME averaging per-frame is suboptimal.  Better to sum over the HCD's
+ * entire periodic schedule ... 32 frames for OHCI, 1024 for UHCI, settable
+ * for EHCI (256/512/1024 frames, default 1024) and have the bus expose how
+ * large its periodic schedule is.
+ */
+void STDCALL usb_claim_bandwidth (struct usb_device *dev, struct urb *urb, int bustime, int isoc)
+{
+       dev->bus->bandwidth_allocated += bustime;
+       if (isoc)
+               dev->bus->bandwidth_isoc_reqs++;
+       else
+               dev->bus->bandwidth_int_reqs++;
+       urb->bandwidth = bustime;
+
+#ifdef USB_BANDWIDTH_MESSAGES
+       dev_dbg (&dev->dev, "bandwidth alloc increased by %d (%s) to %d for %d requesters\n",
+               bustime,
+               isoc ? "ISOC" : "INTR",
+               dev->bus->bandwidth_allocated,
+               dev->bus->bandwidth_int_reqs + dev->bus->bandwidth_isoc_reqs);
+#endif
+}
+
+
+/**
+ * usb_release_bandwidth - reverses effect of usb_claim_bandwidth()
+ * @dev: source/target of request
+ * @urb: request (urb->dev == dev)
+ * @isoc: true iff the request is isochronous
+ *
+ * This records that previously allocated bandwidth has been released.
+ * Bandwidth is released when endpoints are removed from the host controller's
+ * periodic schedule.
+ */
+void STDCALL usb_release_bandwidth (struct usb_device *dev, struct urb *urb, int isoc)
+{
+       dev->bus->bandwidth_allocated -= urb->bandwidth;
+       if (isoc)
+               dev->bus->bandwidth_isoc_reqs--;
+       else
+               dev->bus->bandwidth_int_reqs--;
+
+#ifdef USB_BANDWIDTH_MESSAGES
+       dev_dbg (&dev->dev, "bandwidth alloc reduced by %d (%s) to %d for %d requesters\n",
+               urb->bandwidth,
+               isoc ? "ISOC" : "INTR",
+               dev->bus->bandwidth_allocated,
+               dev->bus->bandwidth_int_reqs + dev->bus->bandwidth_isoc_reqs);
+#endif
+       urb->bandwidth = 0;
+}
+
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * Generic HC operations.
+ */
+
+/*-------------------------------------------------------------------------*/
+
+/* called from khubd, or root hub init threads for hcd-private init */
+static int hcd_alloc_dev (struct usb_device *udev)
+{
+       struct hcd_dev          *dev;
+       struct usb_hcd          *hcd;
+       unsigned long           flags;
+
+       if (!udev || udev->hcpriv)
+               return -EINVAL;
+       if (!udev->bus || !udev->bus->hcpriv)
+               return -ENODEV;
+       hcd = udev->bus->hcpriv;
+       if (hcd->state == USB_STATE_QUIESCING)
+               return -ENOLINK;
+
+       dev = (struct hcd_dev *) kmalloc (sizeof *dev, GFP_KERNEL);
+       if (dev == NULL)
+               return -ENOMEM;
+       memset (dev, 0, sizeof *dev);
+
+       INIT_LIST_HEAD (&dev->dev_list);
+       INIT_LIST_HEAD (&dev->urb_list);
+
+       spin_lock_irqsave (&hcd_data_lock, flags);
+       list_add (&dev->dev_list, &hcd->dev_list);
+       // refcount is implicit
+       udev->hcpriv = dev;
+       spin_unlock_irqrestore (&hcd_data_lock, flags);
+
+       return 0;
+}
+
+/*-------------------------------------------------------------------------*/
+
+static void urb_unlink (struct urb *urb)
+{
+       unsigned long           flags;
+       struct usb_device       *dev;
+
+       /* Release any periodic transfer bandwidth */
+       if (urb->bandwidth)
+               usb_release_bandwidth (urb->dev, urb,
+                       usb_pipeisoc (urb->pipe));
+
+       /* clear all state linking urb to this dev (and hcd) */
+
+       spin_lock_irqsave (&hcd_data_lock, flags);
+       list_del_init (&urb->urb_list);
+       dev = urb->dev;
+       spin_unlock_irqrestore (&hcd_data_lock, flags);
+       usb_put_dev (dev);
+}
+
+
+/* may be called in any context with a valid urb->dev usecount
+ * caller surrenders "ownership" of urb
+ * expects usb_submit_urb() to have sanity checked and conditioned all
+ * inputs in the urb
+ */
+static int hcd_submit_urb (struct urb *urb, int mem_flags)
+{
+       int                     status;
+       struct usb_hcd          *hcd = urb->dev->bus->hcpriv;
+       struct hcd_dev          *dev = urb->dev->hcpriv;
+       unsigned long           flags;
+       
+
+       if (!hcd || !dev)
+               return -ENODEV;
+//     printk("submit_urb %p, # %i, t %i\n",urb,urb->dev->devnum,usb_pipetype(urb->pipe));
+       /*
+        * FIXME:  make urb timeouts be generic, keeping the HCD cores
+        * as simple as possible.
+        */
+
+       // NOTE:  a generic device/urb monitoring hook would go here.
+       // hcd_monitor_hook(MONITOR_URB_SUBMIT, urb)
+       // It would catch submission paths for all urbs.
+
+       /*
+        * Atomically queue the urb,  first to our records, then to the HCD.
+        * Access to urb->status is controlled by urb->lock ... changes on
+        * i/o completion (normal or fault) or unlinking.
+        */
+
+       // FIXME:  verify that quiescing hc works right (RH cleans up)
+
+       spin_lock_irqsave (&hcd_data_lock, flags);
+       if (HCD_IS_RUNNING (hcd->state) && hcd->state != USB_STATE_QUIESCING) {
+               usb_get_dev (urb->dev);
+               list_add_tail (&urb->urb_list, &dev->urb_list);
+               status = 0;
+       } else {
+               INIT_LIST_HEAD (&urb->urb_list);
+               status = -ESHUTDOWN;
+       }
+       spin_unlock_irqrestore (&hcd_data_lock, flags);
+       if (status)
+               return status;
+
+       /* increment urb's reference count as part of giving it to the HCD
+        * (which now controls it).  HCD guarantees that it either returns
+        * an error or calls giveback(), but not both.
+        */
+
+       urb = usb_get_urb (urb);
+       if (urb->dev == hcd->self.root_hub) {
+               /* NOTE:  requirement on hub callers (usbfs and the hub
+                * driver, for now) that URBs' urb->transfer_buffer be
+                * valid and usb_buffer_{sync,unmap}() not be needed, since
+                * they could clobber root hub response data.
+                */
+               urb->transfer_flags |= URB_NO_DMA_MAP;
+               status = rh_urb_enqueue (hcd, urb);
+               goto done;
+       }
+
+       /* lower level hcd code should use *_dma exclusively,
+        * unless it uses pio or talks to another transport.
+        */
+       if (!(urb->transfer_flags & URB_NO_DMA_MAP)
+                       && hcd->controller->dma_mask) {
+               if (usb_pipecontrol (urb->pipe))
+                       urb->setup_dma = dma_map_single (
+                                       hcd->controller,
+                                       urb->setup_packet,
+                                       sizeof (struct usb_ctrlrequest),
+                                       DMA_TO_DEVICE);
+               if (urb->transfer_buffer_length != 0)
+                       urb->transfer_dma = dma_map_single (
+                                       hcd->controller,
+                                       urb->transfer_buffer,
+                                       urb->transfer_buffer_length,
+                                       usb_pipein (urb->pipe)
+                                           ? DMA_FROM_DEVICE
+                                           : DMA_TO_DEVICE);
+       }
+
+       status = hcd->driver->urb_enqueue (hcd, urb, mem_flags);
+done:
+       if (status) {
+               usb_put_urb (urb);
+               urb_unlink (urb);
+       }
+       return status;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* called in any context */
+static int hcd_get_frame_number (struct usb_device *udev)
+{
+       struct usb_hcd  *hcd = (struct usb_hcd *)udev->bus->hcpriv;
+       return hcd->driver->get_frame_number (hcd);
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* this makes the hcd giveback() the urb more quickly, by kicking it
+ * off hardware queues (which may take a while) and returning it as
+ * soon as practical.  we've already set up the urb's return status,
+ * but we can't know if the callback completed already.
+ */
+static void
+unlink1 (struct usb_hcd *hcd, struct urb *urb)
+{
+       if (urb == (struct urb *) hcd->rh_timer.data)
+               usb_rh_status_dequeue (hcd, urb);
+       else {
+               int             value;
+
+               /* failures "should" be harmless */
+               value = hcd->driver->urb_dequeue (hcd, urb);
+               if (value != 0)
+                       dev_dbg (hcd->controller,
+                               "dequeue %p --> %d\n",
+                               urb, value);
+       }
+}
+
+struct completion_splice {             // modified urb context:
+       /* did we complete? */
+       struct completion       done;
+
+       /* original urb data */
+       usb_complete_t          complete;
+       void                    *context;
+};
+
+static void unlink_complete (struct urb *urb, struct pt_regs *regs)
+{
+       struct completion_splice        *splice;
+
+       splice = (struct completion_splice *) urb->context;
+
+       /* issue original completion call */
+       urb->complete = splice->complete;
+       urb->context = splice->context;
+       urb->complete (urb, regs);
+
+       /* then let the synchronous unlink call complete */
+       complete (&splice->done);
+}
+
+/*
+ * called in any context; note ASYNC_UNLINK restrictions
+ *
+ * caller guarantees urb won't be recycled till both unlink()
+ * and the urb's completion function return
+ */
+static int hcd_unlink_urb (struct urb *urb)
+{
+       struct hcd_dev                  *dev;
+       struct usb_hcd                  *hcd = 0;
+       struct device                   *sys = 0;
+       unsigned long                   flags;
+       struct completion_splice        splice;
+       int                             retval;
+
+       if (!urb)
+               return -EINVAL;
+
+       /*
+        * we contend for urb->status with the hcd core,
+        * which changes it while returning the urb.
+        *
+        * Caller guaranteed that the urb pointer hasn't been freed, and
+        * that it was submitted.  But as a rule it can't know whether or
+        * not it's already been unlinked ... so we respect the reversed
+        * lock sequence needed for the usb_hcd_giveback_urb() code paths
+        * (urb lock, then hcd_data_lock) in case some other CPU is now
+        * unlinking it.
+        */
+       spin_lock_irqsave (&urb->lock, flags);
+       spin_lock (&hcd_data_lock);
+
+       if (!urb->dev || !urb->dev->bus) {
+               retval = -ENODEV;
+               goto done;
+       }
+
+       dev = urb->dev->hcpriv;
+       sys = &urb->dev->dev;
+       hcd = urb->dev->bus->hcpriv;
+       if (!dev || !hcd) {
+               retval = -ENODEV;
+               goto done;
+       }
+
+       if (!urb->hcpriv) {
+               retval = -EINVAL;
+               goto done;
+       }
+
+       /* Any status except -EINPROGRESS means something already started to
+        * unlink this URB from the hardware.  So there's no more work to do.
+        *
+        * FIXME use better explicit urb state
+        */
+       if (urb->status != -EINPROGRESS) {
+               retval = -EBUSY;
+               goto done;
+       }
+
+       /* maybe set up to block until the urb's completion fires.  the
+        * lower level hcd code is always async, locking on urb->status
+        * updates; an intercepted completion unblocks us.
+        */
+       if (!(urb->transfer_flags & URB_ASYNC_UNLINK)) {
+               if (in_interrupt ()) {
+                       dev_dbg (hcd->controller, "non-async unlink in_interrupt");
+                       retval = -EWOULDBLOCK;
+                       goto done;
+               }
+               /* synchronous unlink: block till we see the completion */
+               init_completion (&splice.done);
+               splice.complete = urb->complete;
+               splice.context = urb->context;
+               urb->complete = unlink_complete;
+               urb->context = &splice;
+               urb->status = -ENOENT;
+       } else {
+               /* asynchronous unlink */
+               urb->status = -ECONNRESET;
+       }
+       spin_unlock (&hcd_data_lock);
+       spin_unlock_irqrestore (&urb->lock, flags);
+
+       // FIXME remove splicing, so this becomes unlink1 (hcd, urb);
+       if (urb == (struct urb *) hcd->rh_timer.data) {
+               usb_rh_status_dequeue (hcd, urb);
+               retval = 0;
+       } else {
+               retval = hcd->driver->urb_dequeue (hcd, urb);
+
+               /* hcds shouldn't really fail these calls, but... */
+               if (retval) {
+                       dev_dbg (sys, "dequeue %p --> %d\n", urb, retval);
+                       if (!(urb->transfer_flags & URB_ASYNC_UNLINK)) {
+                               spin_lock_irqsave (&urb->lock, flags);
+                               urb->complete = splice.complete;
+                               urb->context = splice.context;
+                               spin_unlock_irqrestore (&urb->lock, flags);
+                       }
+                       goto bye;
+               }
+       }
+
+       /* block till giveback, if needed */
+       if (urb->transfer_flags & URB_ASYNC_UNLINK)
+               return -EINPROGRESS;
+
+       wait_for_completion (&splice.done);
+       return 0;
+
+done:
+       spin_unlock (&hcd_data_lock);
+       spin_unlock_irqrestore (&urb->lock, flags);
+bye:
+       if (retval && sys && sys->driver)
+               dev_dbg (sys, "hcd_unlink_urb %p fail %d\n", urb, retval);
+       return retval;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* disables the endpoint: cancels any pending urbs, then synchronizes with
+ * the hcd to make sure all endpoint state is gone from hardware. use for
+ * set_configuration, set_interface, driver removal, physical disconnect.
+ *
+ * example:  a qh stored in hcd_dev.ep[], holding state related to endpoint
+ * type, maxpacket size, toggle, halt status, and scheduling.
+ */
+static void hcd_endpoint_disable (struct usb_device *udev, int endpoint)
+{
+       unsigned long   flags;
+       struct hcd_dev  *dev;
+       struct usb_hcd  *hcd;
+       struct urb      *urb;
+       unsigned        epnum = endpoint & USB_ENDPOINT_NUMBER_MASK;
+
+       dev = udev->hcpriv;
+       hcd = udev->bus->hcpriv;
+
+rescan:
+       /* (re)block new requests, as best we can */
+       if (endpoint & USB_DIR_IN) {
+               usb_endpoint_halt (udev, epnum, 0);
+               udev->epmaxpacketin [epnum] = 0;
+       } else {
+               usb_endpoint_halt (udev, epnum, 1);
+               udev->epmaxpacketout [epnum] = 0;
+       }
+
+       /* then kill any current requests */
+       spin_lock_irqsave (&hcd_data_lock, flags);
+       list_for_each_entry (urb, &dev->urb_list, urb_list) {
+               int     tmp = urb->pipe;
+
+               /* ignore urbs for other endpoints */
+               if (usb_pipeendpoint (tmp) != epnum)
+                       continue;
+               if ((tmp ^ endpoint) & USB_DIR_IN)
+                       continue;
+
+               /* another cpu may be in hcd, spinning on hcd_data_lock
+                * to giveback() this urb.  the races here should be
+                * small, but a full fix needs a new "can't submit"
+                * urb state.
+                */
+               if (urb->status != -EINPROGRESS)
+                       continue;
+               usb_get_urb (urb);
+               spin_unlock_irqrestore (&hcd_data_lock, flags);
+
+               spin_lock_irqsave (&urb->lock, flags);
+               tmp = urb->status;
+               if (tmp == -EINPROGRESS)
+                       urb->status = -ESHUTDOWN;
+               spin_unlock_irqrestore (&urb->lock, flags);
+
+               /* kick hcd unless it's already returning this */
+               if (tmp == -EINPROGRESS) {
+                       tmp = urb->pipe;
+                       unlink1 (hcd, urb);
+                       dev_dbg (hcd->controller,
+                               "shutdown urb %p pipe %08x ep%d%s%s\n",
+                               urb, tmp, usb_pipeendpoint (tmp),
+                               (tmp & USB_DIR_IN) ? "in" : "out",
+                               ({ char *s; \
+                                switch (usb_pipetype (tmp)) { \
+                                case PIPE_CONTROL:     s = ""; break; \
+                                case PIPE_BULK:        s = "-bulk"; break; \
+                                case PIPE_INTERRUPT:   s = "-intr"; break; \
+                                default:               s = "-iso"; break; \
+                               }; s;}));
+               }
+               usb_put_urb (urb);
+
+               /* list contents may have changed */
+               goto rescan;
+       }
+       spin_unlock_irqrestore (&hcd_data_lock, flags);
+
+       /* synchronize with the hardware, so old configuration state
+        * clears out immediately (and will be freed).
+        */
+       might_sleep ();
+       if (hcd->driver->endpoint_disable)
+               hcd->driver->endpoint_disable (hcd, dev, endpoint);
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* called by khubd, rmmod, apmd, or other thread for hcd-private cleanup.
+ * we're guaranteed that the device is fully quiesced.  also, that each
+ * endpoint has been hcd_endpoint_disabled.
+ */
+
+static int hcd_free_dev (struct usb_device *udev)
+{
+       struct hcd_dev          *dev;
+       struct usb_hcd          *hcd;
+       unsigned long           flags;
+
+       if (!udev || !udev->hcpriv)
+               return -EINVAL;
+
+       if (!udev->bus || !udev->bus->hcpriv)
+               return -ENODEV;
+
+       // should udev->devnum == -1 ??
+
+       dev = udev->hcpriv;
+       hcd = udev->bus->hcpriv;
+
+       /* device driver problem with refcounts? */
+       if (!list_empty (&dev->urb_list)) {
+               dev_dbg (hcd->controller, "free busy dev, %s devnum %d (bug!)\n",
+                       hcd->self.bus_name, udev->devnum);
+               return -EINVAL;
+       }
+
+       spin_lock_irqsave (&hcd_data_lock, flags);
+       list_del (&dev->dev_list);
+       udev->hcpriv = NULL;
+       spin_unlock_irqrestore (&hcd_data_lock, flags);
+
+       kfree (dev);
+       return 0;
+}
+
+/*
+ * usb_hcd_operations - adapts usb_bus framework to HCD framework (bus glue)
+ *
+ * When registering a USB bus through the HCD framework code, use this
+ * usb_operations vector.  The PCI glue layer does so automatically; only
+ * bus glue for non-PCI system busses will need to use this.
+ */
+struct usb_operations usb_hcd_operations = {
+       .allocate =             hcd_alloc_dev,
+       .get_frame_number =     hcd_get_frame_number,
+       .submit_urb =           hcd_submit_urb,
+       .unlink_urb =           hcd_unlink_urb,
+       .deallocate =           hcd_free_dev,
+       .buffer_alloc =         hcd_buffer_alloc,
+       .buffer_free =          hcd_buffer_free,
+       .disable =              hcd_endpoint_disable,
+};
+EXPORT_SYMBOL (usb_hcd_operations);
+
+/*-------------------------------------------------------------------------*/
+
+/**
+ * usb_hcd_giveback_urb - return URB from HCD to device driver
+ * @hcd: host controller returning the URB
+ * @urb: urb being returned to the USB device driver.
+ * @regs: pt_regs, passed down to the URB completion handler
+ * Context: in_interrupt()
+ *
+ * This hands the URB from HCD to its USB device driver, using its
+ * completion function.  The HCD has freed all per-urb resources
+ * (and is done using urb->hcpriv).  It also released all HCD locks;
+ * the device driver won't cause problems if it frees, modifies,
+ * or resubmits this URB.
+ */
+void STDCALL usb_hcd_giveback_urb (struct usb_hcd *hcd, struct urb *urb, struct pt_regs *regs)
+{
+       urb_unlink (urb);
+
+       // NOTE:  a generic device/urb monitoring hook would go here.
+       // hcd_monitor_hook(MONITOR_URB_FINISH, urb, dev)
+       // It would catch exit/unlink paths for all urbs.
+
+       /* lower level hcd code should use *_dma exclusively */
+       if (!(urb->transfer_flags & URB_NO_DMA_MAP)) {
+               if (usb_pipecontrol (urb->pipe))
+                       pci_unmap_single (hcd->pdev, urb->setup_dma,
+                                       sizeof (struct usb_ctrlrequest),
+                                       PCI_DMA_TODEVICE);
+               if (urb->transfer_buffer_length != 0)
+                       pci_unmap_single (hcd->pdev, urb->transfer_dma,
+                                       urb->transfer_buffer_length,
+                                       usb_pipein (urb->pipe)
+                                           ? PCI_DMA_FROMDEVICE
+                                           : PCI_DMA_TODEVICE);
+       }
+
+       /* pass ownership to the completion handler */
+       urb->complete (urb, regs);
+       usb_put_urb (urb);
+}
+
+/*-------------------------------------------------------------------------*/
+
+/**
+ * usb_hcd_irq - hook IRQs to HCD framework (bus glue)
+ * @irq: the IRQ being raised
+ * @__hcd: pointer to the HCD whose IRQ is beinng signaled
+ * @r: saved hardware registers
+ *
+ * When registering a USB bus through the HCD framework code, use this
+ * to handle interrupts.  The PCI glue layer does so automatically; only
+ * bus glue for non-PCI system busses will need to use this.
+ */
+irqreturn_t usb_hcd_irq (int irq, void *__hcd, struct pt_regs * r)
+{
+       struct usb_hcd          *hcd = __hcd;
+       int                     start = hcd->state;
+
+       if (unlikely (hcd->state == USB_STATE_HALT))    /* irq sharing? */
+               return IRQ_NONE;
+
+       hcd->driver->irq (hcd, r);
+       if (hcd->state != start && hcd->state == USB_STATE_HALT)
+               usb_hc_died (hcd);
+       return IRQ_HANDLED;
+}
+
+/*-------------------------------------------------------------------------*/
+
+static void hcd_panic (void *_hcd)
+{
+       struct usb_hcd *hcd = _hcd;
+       hcd->driver->stop (hcd);
+}
+
+/**
+ * usb_hc_died - report abnormal shutdown of a host controller (bus glue)
+ * @hcd: pointer to the HCD representing the controller
+ *
+ * This is called by bus glue to report a USB host controller that died
+ * while operations may still have been pending.  It's called automatically
+ * by the PCI glue, so only glue for non-PCI busses should need to call it. 
+ */
+void STDCALL usb_hc_died (struct usb_hcd *hcd)
+{
+       struct list_head        *devlist, *urblist;
+       struct hcd_dev          *dev;
+       struct urb              *urb;
+       unsigned long           flags;
+       
+       /* flag every pending urb as done */
+       spin_lock_irqsave (&hcd_data_lock, flags);
+       list_for_each (devlist, &hcd->dev_list) {
+               dev = list_entry (devlist, struct hcd_dev, dev_list);
+               list_for_each (urblist, &dev->urb_list) {
+                       urb = list_entry (urblist, struct urb, urb_list);
+                       dev_dbg (hcd->controller, "shutdown %s urb %p pipe %x, current status %d\n",
+                               hcd->self.bus_name, urb, urb->pipe, urb->status);
+                       if (urb->status == -EINPROGRESS)
+                               urb->status = -ESHUTDOWN;
+               }
+       }
+       urb = (struct urb *) hcd->rh_timer.data;
+       if (urb)
+               urb->status = -ESHUTDOWN;
+       spin_unlock_irqrestore (&hcd_data_lock, flags);
+
+       /* hcd->stop() needs a task context */
+       INIT_WORK (&hcd->work, hcd_panic, hcd);
+       (void) schedule_work (&hcd->work);
+}
+
index 266324d..a5b3859 100644 (file)
-/*\r
- * Copyright (c) 2001-2002 by David Brownell\r
- *\r
- * This program is free software; you can redistribute it and/or modify it\r
- * under the terms of the GNU General Public License as published by the\r
- * Free Software Foundation; either version 2 of the License, or (at your\r
- * option) any later version.\r
- *\r
- * This program is distributed in the hope that it will be useful, but\r
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\r
- * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License\r
- * for more details.\r
- *\r
- * You should have received a copy of the GNU General Public License\r
- * along with this program; if not, write to the Free Software Foundation,\r
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\r
- */\r
-\r
-\r
-#ifdef __KERNEL__\r
-\r
-/* This file contains declarations of usbcore internals that are mostly\r
- * used or exposed by Host Controller Drivers.\r
- */\r
-\r
-/*\r
- * USB Packet IDs (PIDs)\r
- */\r
-#define USB_PID_UNDEF_0                        0xf0\r
-#define USB_PID_OUT                    0xe1\r
-#define USB_PID_ACK                    0xd2\r
-#define USB_PID_DATA0                  0xc3\r
-#define USB_PID_PING                   0xb4    /* USB 2.0 */\r
-#define USB_PID_SOF                    0xa5\r
-#define USB_PID_NYET                   0x96    /* USB 2.0 */\r
-#define USB_PID_DATA2                  0x87    /* USB 2.0 */\r
-#define USB_PID_SPLIT                  0x78    /* USB 2.0 */\r
-#define USB_PID_IN                     0x69\r
-#define USB_PID_NAK                    0x5a\r
-#define USB_PID_DATA1                  0x4b\r
-#define USB_PID_PREAMBLE               0x3c    /* Token mode */\r
-#define USB_PID_ERR                    0x3c    /* USB 2.0: handshake mode */\r
-#define USB_PID_SETUP                  0x2d\r
-#define USB_PID_STALL                  0x1e\r
-#define USB_PID_MDATA                  0x0f    /* USB 2.0 */\r
-\r
-/*-------------------------------------------------------------------------*/\r
-\r
-/*\r
- * USB Host Controller Driver (usb_hcd) framework\r
- *\r
- * Since "struct usb_bus" is so thin, you can't share much code in it.\r
- * This framework is a layer over that, and should be more sharable.\r
- */\r
-\r
-/*-------------------------------------------------------------------------*/\r
-\r
-struct usb_hcd {       /* usb_bus.hcpriv points to this */\r
-\r
-       /*\r
-        * housekeeping\r
-        */\r
-       struct usb_bus          self;           /* hcd is-a bus */\r
-\r
-       const char              *product_desc;  /* product/vendor string */\r
-       const char              *description;   /* "ehci-hcd" etc */\r
-\r
-       struct timer_list       rh_timer;       /* drives root hub */\r
-       struct list_head        dev_list;       /* devices on this bus */\r
-       struct work_struct      work;\r
-\r
-       /*\r
-        * hardware info/state\r
-        */\r
-       struct hc_driver        *driver;        /* hw-specific hooks */\r
-       int                     irq;            /* irq allocated */\r
-       void                    *regs;          /* device memory/io */\r
-       struct device           *controller;    /* handle to hardware */\r
-\r
-       /* a few non-PCI controllers exist, mostly for OHCI */\r
-       struct pci_dev          *pdev;          /* pci is typical */\r
-#ifdef CONFIG_PCI\r
-       int                     region;         /* pci region for regs */\r
-       u32                     pci_state [16]; /* for PM state save */\r
-       atomic_t                resume_count;   /* multiple resumes issue */\r
-#endif\r
-\r
-#define HCD_BUFFER_POOLS       4\r
-       struct pci_pool         *pool [HCD_BUFFER_POOLS];\r
-\r
-       int                     state;\r
-#      define  __ACTIVE                0x01\r
-#      define  __SLEEPY                0x02\r
-#      define  __SUSPEND               0x04\r
-#      define  __TRANSIENT             0x80\r
-\r
-#      define  USB_STATE_HALT          0\r
-#      define  USB_STATE_RUNNING       (__ACTIVE)\r
-#      define  USB_STATE_READY         (__ACTIVE|__SLEEPY)\r
-#      define  USB_STATE_QUIESCING     (__SUSPEND|__TRANSIENT|__ACTIVE)\r
-#      define  USB_STATE_RESUMING      (__SUSPEND|__TRANSIENT)\r
-#      define  USB_STATE_SUSPENDED     (__SUSPEND)\r
-\r
-#define        HCD_IS_RUNNING(state) ((state) & __ACTIVE)\r
-#define        HCD_IS_SUSPENDED(state) ((state) & __SUSPEND)\r
-\r
-       /* more shared queuing code would be good; it should support\r
-        * smarter scheduling, handle transaction translators, etc;\r
-        * input size of periodic table to an interrupt scheduler. \r
-        * (ohci 32, uhci 1024, ehci 256/512/1024).\r
-        */\r
-};\r
-\r
-/* 2.4 does this a bit differently ... */\r
-static inline struct usb_bus *hcd_to_bus (struct usb_hcd *hcd)\r
-{\r
-       return &hcd->self;\r
-}\r
-\r
-\r
-struct hcd_dev {       /* usb_device.hcpriv points to this */\r
-       struct list_head        dev_list;       /* on this hcd */\r
-       struct list_head        urb_list;       /* pending on this dev */\r
-\r
-       /* per-configuration HC/HCD state, such as QH or ED */\r
-       void                    *ep[32];\r
-};\r
-\r
-// urb.hcpriv is really hardware-specific\r
-\r
-struct hcd_timeout {   /* timeouts we allocate */\r
-       struct list_head        timeout_list;\r
-       struct timer_list       timer;\r
-};\r
-\r
-/*-------------------------------------------------------------------------*/\r
-\r
-/*\r
- * FIXME usb_operations should vanish or become hc_driver,\r
- * when usb_bus and usb_hcd become the same thing.\r
- */\r
-\r
-struct usb_operations {\r
-       int (*allocate)(struct usb_device *);\r
-       int (*deallocate)(struct usb_device *);\r
-       int (*get_frame_number) (struct usb_device *usb_dev);\r
-       int (*submit_urb) (struct urb *urb, int mem_flags);\r
-       int (*unlink_urb) (struct urb *urb);\r
-\r
-       /* allocate dma-consistent buffer for URB_DMA_NOMAPPING */\r
-       void *(*buffer_alloc)(struct usb_bus *bus, size_t size,\r
-                       int mem_flags,\r
-                       dma_addr_t *dma);\r
-       void (*buffer_free)(struct usb_bus *bus, size_t size,\r
-                       void *addr, dma_addr_t dma);\r
-\r
-       void (*disable)(struct usb_device *udev, int bEndpointAddress);\r
-};\r
-\r
-/* each driver provides one of these, and hardware init support */\r
-\r
-struct pt_regs;\r
-\r
-// new struct from 2.6\r
-struct hc_driver {\r
-       const char      *description;   /* "ehci-hcd" etc */\r
-\r
-       /* irq handler */\r
-       irqreturn_t     (*irq) (struct usb_hcd *hcd, struct pt_regs *regs);\r
-\r
-       int     flags;\r
-#define        HCD_MEMORY      0x0001          /* HC regs use memory (else I/O) */\r
-#define        HCD_USB11       0x0010          /* USB 1.1 */\r
-#define        HCD_USB2        0x0020          /* USB 2.0 */\r
-\r
-       /* called to init HCD and root hub */\r
-       int     (*reset) (struct usb_hcd *hcd);\r
-       int     (*start) (struct usb_hcd *hcd);\r
-\r
-       /* called after all devices were suspended */\r
-       int     (*suspend) (struct usb_hcd *hcd, u32 state);\r
-\r
-       /* called before any devices get resumed */\r
-       int     (*resume) (struct usb_hcd *hcd);\r
-\r
-       /* cleanly make HCD stop writing memory and doing I/O */\r
-       void    (*stop) (struct usb_hcd *hcd);\r
-\r
-       /* return current frame number */\r
-       int     (*get_frame_number) (struct usb_hcd *hcd);\r
-\r
-       /* memory lifecycle */\r
-       struct usb_hcd  *(*hcd_alloc) (void);\r
-       void            (*hcd_free) (struct usb_hcd *hcd);\r
-\r
-       /* manage i/o requests, device state */\r
-       int     (*urb_enqueue) (struct usb_hcd *hcd, struct urb *urb,\r
-                                       int mem_flags);\r
-       int     (*urb_dequeue) (struct usb_hcd *hcd, struct urb *urb);\r
-\r
-       /* hw synch, freeing endpoint resources that urb_dequeue can't */\r
-       void    (*endpoint_disable)(struct usb_hcd *hcd,\r
-                       struct hcd_dev *dev, int bEndpointAddress);\r
-\r
-       /* root hub support */\r
-       int             (*hub_status_data) (struct usb_hcd *hcd, char *buf);\r
-       int             (*hub_control) (struct usb_hcd *hcd,\r
-                               u16 typeReq, u16 wValue, u16 wIndex,\r
-                               char *buf, u16 wLength);\r
-};\r
-\r
-// old version, "just in case"\r
-#if 0\r
-struct hc_driver {\r
-       const char      *description;   /* "ehci-hcd" etc */\r
-\r
-       /* irq handler */\r
-       void    (*irq) (struct usb_hcd *hcd, struct pt_regs *regs);\r
-\r
-       int     flags;\r
-#define        HCD_MEMORY      0x0001          /* HC regs use memory (else I/O) */\r
-#define        HCD_USB11       0x0010          /* USB 1.1 */\r
-#define        HCD_USB2        0x0020          /* USB 2.0 */\r
-\r
-       /* called to init HCD and root hub */\r
-       int     (*start) (struct usb_hcd *hcd);\r
-\r
-       /* called after all devices were suspended */\r
-       int     (*suspend) (struct usb_hcd *hcd, u32 state);\r
-\r
-       /* called before any devices get resumed */\r
-       int     (*resume) (struct usb_hcd *hcd);\r
-\r
-       /* cleanly make HCD stop writing memory and doing I/O */\r
-       void    (*stop) (struct usb_hcd *hcd);\r
-\r
-       /* return current frame number */\r
-       int     (*get_frame_number) (struct usb_hcd *hcd);\r
-\r
-       /* memory lifecycle */\r
-       struct usb_hcd  *(*hcd_alloc) (void);\r
-       void            (*hcd_free) (struct usb_hcd *hcd);\r
-\r
-       /* manage i/o requests, device state */\r
-       int     (*urb_enqueue) (struct usb_hcd *hcd, struct urb *urb,\r
-                                       int mem_flags);\r
-       int     (*urb_dequeue) (struct usb_hcd *hcd, struct urb *urb);\r
-\r
-       /* hw synch, freeing endpoint resources that urb_dequeue can't */\r
-       void    (*endpoint_disable)(struct usb_hcd *hcd,\r
-                       struct hcd_dev *dev, int bEndpointAddress);\r
-\r
-       /* root hub support */\r
-       int             (*hub_status_data) (struct usb_hcd *hcd, char *buf);\r
-       int             (*hub_control) (struct usb_hcd *hcd,\r
-                               u16 typeReq, u16 wValue, u16 wIndex,\r
-                               char *buf, u16 wLength);\r
-};\r
-#endif\r
-\r
-extern void STDCALL usb_hcd_giveback_urb (struct usb_hcd *hcd, struct urb *urb, struct pt_regs *regs);\r
-extern void STDCALL usb_bus_init (struct usb_bus *bus);\r
-extern void usb_rh_status_dequeue (struct usb_hcd *hcd, struct urb *urb);\r
-\r
-#ifdef CONFIG_PCI\r
-struct pci_dev;\r
-struct pci_device_id;\r
-extern int STDCALL usb_hcd_pci_probe (struct pci_dev *dev,\r
-                               const struct pci_device_id *id);\r
-extern void STDCALL usb_hcd_pci_remove (struct pci_dev *dev);\r
-\r
-#ifdef CONFIG_PM\r
-// FIXME:  see Documentation/power/pci.txt (2.4.6 and later?)\r
-// extern int usb_hcd_pci_save_state (struct pci_dev *dev, u32 state);\r
-extern int usb_hcd_pci_suspend (struct pci_dev *dev, u32 state);\r
-extern int usb_hcd_pci_resume (struct pci_dev *dev);\r
-// extern int usb_hcd_pci_enable_wake (struct pci_dev *dev, u32 state, int flg);\r
-#endif /* CONFIG_PM */\r
-\r
-#endif /* CONFIG_PCI */\r
-\r
-/* pci-ish (pdev null is ok) buffer alloc/mapping support */\r
-int hcd_buffer_create (struct usb_hcd *hcd);\r
-void hcd_buffer_destroy (struct usb_hcd *hcd);\r
-\r
-void *hcd_buffer_alloc (struct usb_bus *bus, size_t size,\r
-       int mem_flags, dma_addr_t *dma);\r
-void hcd_buffer_free (struct usb_bus *bus, size_t size,\r
-       void *addr, dma_addr_t dma);\r
-\r
-/* generic bus glue, needed for host controllers that don't use PCI */\r
-extern struct usb_operations usb_hcd_operations;\r
-extern irqreturn_t usb_hcd_irq (int irq, void *__hcd, struct pt_regs *r);\r
-extern void STDCALL usb_hc_died (struct usb_hcd *hcd);\r
-\r
-/* -------------------------------------------------------------------------- */\r
-\r
-/* Enumeration is only for the hub driver, or HCD virtual root hubs */\r
-extern int usb_new_device(struct usb_device *dev, struct device *parent);\r
-extern void STDCALL usb_connect(struct usb_device *dev);\r
-extern void usb_disconnect(struct usb_device **);\r
-\r
-/* exported to hub driver ONLY to support usb_reset_device () */\r
-extern int usb_get_configuration(struct usb_device *dev);\r
-extern void usb_set_maxpacket(struct usb_device *dev);\r
-extern void usb_destroy_configuration(struct usb_device *dev);\r
-extern int usb_set_address(struct usb_device *dev);\r
-\r
-/* use these only before the device's address has been set */\r
-#define usb_snddefctrl(dev)            ((PIPE_CONTROL << 30))\r
-#define usb_rcvdefctrl(dev)            ((PIPE_CONTROL << 30) | USB_DIR_IN)\r
-\r
-/*-------------------------------------------------------------------------*/\r
-\r
-/*\r
- * HCD Root Hub support\r
- */\r
-\r
-#include "hub.h"\r
-\r
-/* (shifted) direction/type/recipient from the USB 2.0 spec, table 9.2 */\r
-#define DeviceRequest \\r
-       ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE)<<8)\r
-#define DeviceOutRequest \\r
-       ((USB_DIR_OUT|USB_TYPE_STANDARD|USB_RECIP_DEVICE)<<8)\r
-\r
-#define InterfaceRequest \\r
-       ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_INTERFACE)<<8)\r
-\r
-#define EndpointRequest \\r
-       ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_INTERFACE)<<8)\r
-#define EndpointOutRequest \\r
-       ((USB_DIR_OUT|USB_TYPE_STANDARD|USB_RECIP_INTERFACE)<<8)\r
-\r
-/* table 9.6 standard features */\r
-#define DEVICE_REMOTE_WAKEUP   1\r
-#define ENDPOINT_HALT          0\r
-\r
-/* class requests from the USB 2.0 hub spec, table 11-15 */\r
-/* GetBusState and SetHubDescriptor are optional, omitted */\r
-#define ClearHubFeature                (0x2000 | USB_REQ_CLEAR_FEATURE)\r
-#define ClearPortFeature       (0x2300 | USB_REQ_CLEAR_FEATURE)\r
-#define GetHubDescriptor       (0xa000 | USB_REQ_GET_DESCRIPTOR)\r
-#define GetHubStatus           (0xa000 | USB_REQ_GET_STATUS)\r
-#define GetPortStatus          (0xa300 | USB_REQ_GET_STATUS)\r
-#define SetHubFeature          (0x2000 | USB_REQ_SET_FEATURE)\r
-#define SetPortFeature         (0x2300 | USB_REQ_SET_FEATURE)\r
-\r
-\r
-/*-------------------------------------------------------------------------*/\r
-\r
-/*\r
- * Generic bandwidth allocation constants/support\r
- */\r
-#define FRAME_TIME_USECS       1000L\r
-#define BitTime(bytecount)  (7 * 8 * bytecount / 6)  /* with integer truncation */\r
-               /* Trying not to use worst-case bit-stuffing\r
-                   of (7/6 * 8 * bytecount) = 9.33 * bytecount */\r
-               /* bytecount = data payload byte count */\r
-\r
-#define NS_TO_US(ns)   ((ns + 500L) / 1000L)\r
-                       /* convert & round nanoseconds to microseconds */\r
-\r
-extern void STDCALL usb_claim_bandwidth (struct usb_device *dev, struct urb *urb,\r
-               int bustime, int isoc);\r
-extern void STDCALL usb_release_bandwidth (struct usb_device *dev, struct urb *urb,\r
-               int isoc);\r
-\r
-/*\r
- * Full/low speed bandwidth allocation constants/support.\r
- */\r
-#define BW_HOST_DELAY  1000L           /* nanoseconds */\r
-#define BW_HUB_LS_SETUP        333L            /* nanoseconds */\r
-                        /* 4 full-speed bit times (est.) */\r
-\r
-#define FRAME_TIME_BITS         12000L         /* frame = 1 millisecond */\r
-#define FRAME_TIME_MAX_BITS_ALLOC      (90L * FRAME_TIME_BITS / 100L)\r
-#define FRAME_TIME_MAX_USECS_ALLOC     (90L * FRAME_TIME_USECS / 100L)\r
-\r
-extern int STDCALL usb_check_bandwidth (struct usb_device *dev, struct urb *urb);\r
-\r
-/*\r
- * Ceiling microseconds (typical) for that many bytes at high speed\r
- * ISO is a bit less, no ACK ... from USB 2.0 spec, 5.11.3 (and needed\r
- * to preallocate bandwidth)\r
- */\r
-#define USB2_HOST_DELAY        5       /* nsec, guess */\r
-#define HS_USECS(bytes) NS_TO_US ( ((55 * 8 * 2083)/1000) \\r
-       + ((2083UL * (3167 + BitTime (bytes)))/1000) \\r
-       + USB2_HOST_DELAY)\r
-#define HS_USECS_ISO(bytes) NS_TO_US ( ((long)(38 * 8 * 2.083)) \\r
-       + ((2083UL * (3167 + BitTime (bytes)))/1000) \\r
-       + USB2_HOST_DELAY)\r
-\r
-extern long STDCALL usb_calc_bus_time (int speed, int is_input,\r
-                       int isoc, int bytecount);\r
-\r
-/*-------------------------------------------------------------------------*/\r
-\r
-extern struct usb_bus STDCALL *usb_alloc_bus (struct usb_operations *);\r
-extern void STDCALL usb_free_bus (struct usb_bus *);\r
-\r
-extern void STDCALL usb_register_bus (struct usb_bus *);\r
-extern void STDCALL usb_deregister_bus (struct usb_bus *);\r
-\r
-extern int STDCALL usb_register_root_hub (struct usb_device *usb_dev,\r
-               struct device *parent_dev);\r
-\r
-/* for portability to 2.4, hcds should call this */\r
-static inline int hcd_register_root (struct usb_hcd *hcd)\r
-{\r
-       return usb_register_root_hub (\r
-               hcd_to_bus (hcd)->root_hub, hcd->controller);\r
-}\r
-\r
-/*-------------------------------------------------------------------------*/\r
-\r
-/* exported only within usbcore */\r
-\r
-extern struct list_head usb_bus_list;\r
-extern struct semaphore usb_bus_list_lock;\r
-\r
-extern void usb_bus_get (struct usb_bus *bus);\r
-extern void usb_bus_put (struct usb_bus *bus);\r
-\r
-extern int usb_find_interface_driver (struct usb_device *dev,\r
-       struct usb_interface *interface);\r
-\r
-#define usb_endpoint_halt(dev, ep, out) ((dev)->halted[out] |= (1 << (ep)))\r
-\r
-#define usb_endpoint_out(ep_dir)       (!((ep_dir) & USB_DIR_IN))\r
-\r
-/*\r
- * USB device fs stuff\r
- */\r
-\r
-#ifdef CONFIG_USB_DEVICEFS\r
-\r
-/*\r
- * these are expected to be called from the USB core/hub thread\r
- * with the kernel lock held\r
- */\r
-extern void usbfs_add_bus(struct usb_bus *bus);\r
-extern void usbfs_remove_bus(struct usb_bus *bus);\r
-extern void usbfs_add_device(struct usb_device *dev);\r
-extern void usbfs_remove_device(struct usb_device *dev);\r
-extern void usbfs_update_special (void);\r
-\r
-extern int usbfs_init(void);\r
-extern void usbfs_cleanup(void);\r
-\r
-#else /* CONFIG_USB_DEVICEFS */\r
-\r
-static inline void usbfs_add_bus(struct usb_bus *bus) {}\r
-static inline void usbfs_remove_bus(struct usb_bus *bus) {}\r
-static inline void usbfs_add_device(struct usb_device *dev) {}\r
-static inline void usbfs_remove_device(struct usb_device *dev) {}\r
-static inline void usbfs_update_special (void) {}\r
-\r
-static inline int usbfs_init(void) { return 0; }\r
-static inline void usbfs_cleanup(void) { }\r
-\r
-#endif /* CONFIG_USB_DEVICEFS */\r
-\r
-/*-------------------------------------------------------------------------*/\r
-\r
-/* hub.h ... DeviceRemovable in 2.4.2-ac11, gone in 2.4.10 */\r
-// bleech -- resurfaced in 2.4.11 or 2.4.12\r
-#define bitmap         DeviceRemovable\r
-\r
-\r
-/*-------------------------------------------------------------------------*/\r
-\r
-/* random stuff */\r
-\r
-#define        RUN_CONTEXT (in_irq () ? "in_irq" \\r
-               : (in_interrupt () ? "in_interrupt" : "can sleep"))\r
-\r
-\r
-#endif /* __KERNEL__ */\r
-\r
+/*
+ * Copyright (c) 2001-2002 by David Brownell
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#ifdef __KERNEL__
+
+/* This file contains declarations of usbcore internals that are mostly
+ * used or exposed by Host Controller Drivers.
+ */
+
+/*
+ * USB Packet IDs (PIDs)
+ */
+#define USB_PID_UNDEF_0                        0xf0
+#define USB_PID_OUT                    0xe1
+#define USB_PID_ACK                    0xd2
+#define USB_PID_DATA0                  0xc3
+#define USB_PID_PING                   0xb4    /* USB 2.0 */
+#define USB_PID_SOF                    0xa5
+#define USB_PID_NYET                   0x96    /* USB 2.0 */
+#define USB_PID_DATA2                  0x87    /* USB 2.0 */
+#define USB_PID_SPLIT                  0x78    /* USB 2.0 */
+#define USB_PID_IN                     0x69
+#define USB_PID_NAK                    0x5a
+#define USB_PID_DATA1                  0x4b
+#define USB_PID_PREAMBLE               0x3c    /* Token mode */
+#define USB_PID_ERR                    0x3c    /* USB 2.0: handshake mode */
+#define USB_PID_SETUP                  0x2d
+#define USB_PID_STALL                  0x1e
+#define USB_PID_MDATA                  0x0f    /* USB 2.0 */
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * USB Host Controller Driver (usb_hcd) framework
+ *
+ * Since "struct usb_bus" is so thin, you can't share much code in it.
+ * This framework is a layer over that, and should be more sharable.
+ */
+
+/*-------------------------------------------------------------------------*/
+
+struct usb_hcd {       /* usb_bus.hcpriv points to this */
+
+       /*
+        * housekeeping
+        */
+       struct usb_bus          self;           /* hcd is-a bus */
+
+       const char              *product_desc;  /* product/vendor string */
+       const char              *description;   /* "ehci-hcd" etc */
+
+       struct timer_list       rh_timer;       /* drives root hub */
+       struct list_head        dev_list;       /* devices on this bus */
+       struct work_struct      work;
+
+       /*
+        * hardware info/state
+        */
+       struct hc_driver        *driver;        /* hw-specific hooks */
+       int                     irq;            /* irq allocated */
+       void                    *regs;          /* device memory/io */
+       struct device           *controller;    /* handle to hardware */
+
+       /* a few non-PCI controllers exist, mostly for OHCI */
+       struct pci_dev          *pdev;          /* pci is typical */
+#ifdef CONFIG_PCI
+       int                     region;         /* pci region for regs */
+       u32                     pci_state [16]; /* for PM state save */
+       atomic_t                resume_count;   /* multiple resumes issue */
+#endif
+
+#define HCD_BUFFER_POOLS       4
+       struct pci_pool         *pool [HCD_BUFFER_POOLS];
+
+       int                     state;
+#      define  __ACTIVE                0x01
+#      define  __SLEEPY                0x02
+#      define  __SUSPEND               0x04
+#      define  __TRANSIENT             0x80
+
+#      define  USB_STATE_HALT          0
+#      define  USB_STATE_RUNNING       (__ACTIVE)
+#      define  USB_STATE_READY         (__ACTIVE|__SLEEPY)
+#      define  USB_STATE_QUIESCING     (__SUSPEND|__TRANSIENT|__ACTIVE)
+#      define  USB_STATE_RESUMING      (__SUSPEND|__TRANSIENT)
+#      define  USB_STATE_SUSPENDED     (__SUSPEND)
+
+#define        HCD_IS_RUNNING(state) ((state) & __ACTIVE)
+#define        HCD_IS_SUSPENDED(state) ((state) & __SUSPEND)
+
+       /* more shared queuing code would be good; it should support
+        * smarter scheduling, handle transaction translators, etc;
+        * input size of periodic table to an interrupt scheduler. 
+        * (ohci 32, uhci 1024, ehci 256/512/1024).
+        */
+};
+
+/* 2.4 does this a bit differently ... */
+static inline struct usb_bus *hcd_to_bus (struct usb_hcd *hcd)
+{
+       return &hcd->self;
+}
+
+
+struct hcd_dev {       /* usb_device.hcpriv points to this */
+       struct list_head        dev_list;       /* on this hcd */
+       struct list_head        urb_list;       /* pending on this dev */
+
+       /* per-configuration HC/HCD state, such as QH or ED */
+       void                    *ep[32];
+};
+
+// urb.hcpriv is really hardware-specific
+
+struct hcd_timeout {   /* timeouts we allocate */
+       struct list_head        timeout_list;
+       struct timer_list       timer;
+};
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * FIXME usb_operations should vanish or become hc_driver,
+ * when usb_bus and usb_hcd become the same thing.
+ */
+
+struct usb_operations {
+       int (*allocate)(struct usb_device *);
+       int (*deallocate)(struct usb_device *);
+       int (*get_frame_number) (struct usb_device *usb_dev);
+       int (*submit_urb) (struct urb *urb, int mem_flags);
+       int (*unlink_urb) (struct urb *urb);
+
+       /* allocate dma-consistent buffer for URB_DMA_NOMAPPING */
+       void *(*buffer_alloc)(struct usb_bus *bus, size_t size,
+                       int mem_flags,
+                       dma_addr_t *dma);
+       void (*buffer_free)(struct usb_bus *bus, size_t size,
+                       void *addr, dma_addr_t dma);
+
+       void (*disable)(struct usb_device *udev, int bEndpointAddress);
+};
+
+/* each driver provides one of these, and hardware init support */
+
+struct pt_regs;
+
+// new struct from 2.6
+struct hc_driver {
+       const char      *description;   /* "ehci-hcd" etc */
+
+       /* irq handler */
+       irqreturn_t     (*irq) (struct usb_hcd *hcd, struct pt_regs *regs);
+
+       int     flags;
+#define        HCD_MEMORY      0x0001          /* HC regs use memory (else I/O) */
+#define        HCD_USB11       0x0010          /* USB 1.1 */
+#define        HCD_USB2        0x0020          /* USB 2.0 */
+
+       /* called to init HCD and root hub */
+       int     (*reset) (struct usb_hcd *hcd);
+       int     (*start) (struct usb_hcd *hcd);
+
+       /* called after all devices were suspended */
+       int     (*suspend) (struct usb_hcd *hcd, u32 state);
+
+       /* called before any devices get resumed */
+       int     (*resume) (struct usb_hcd *hcd);
+
+       /* cleanly make HCD stop writing memory and doing I/O */
+       void    (*stop) (struct usb_hcd *hcd);
+
+       /* return current frame number */
+       int     (*get_frame_number) (struct usb_hcd *hcd);
+
+       /* memory lifecycle */
+       struct usb_hcd  *(*hcd_alloc) (void);
+       void            (*hcd_free) (struct usb_hcd *hcd);
+
+       /* manage i/o requests, device state */
+       int     (*urb_enqueue) (struct usb_hcd *hcd, struct urb *urb,
+                                       int mem_flags);
+       int     (*urb_dequeue) (struct usb_hcd *hcd, struct urb *urb);
+
+       /* hw synch, freeing endpoint resources that urb_dequeue can't */
+       void    (*endpoint_disable)(struct usb_hcd *hcd,
+                       struct hcd_dev *dev, int bEndpointAddress);
+
+       /* root hub support */
+       int             (*hub_status_data) (struct usb_hcd *hcd, char *buf);
+       int             (*hub_control) (struct usb_hcd *hcd,
+                               u16 typeReq, u16 wValue, u16 wIndex,
+                               char *buf, u16 wLength);
+};
+
+// old version, "just in case"
+#if 0
+struct hc_driver {
+       const char      *description;   /* "ehci-hcd" etc */
+
+       /* irq handler */
+       void    (*irq) (struct usb_hcd *hcd, struct pt_regs *regs);
+
+       int     flags;
+#define        HCD_MEMORY      0x0001          /* HC regs use memory (else I/O) */
+#define        HCD_USB11       0x0010          /* USB 1.1 */
+#define        HCD_USB2        0x0020          /* USB 2.0 */
+
+       /* called to init HCD and root hub */
+       int     (*start) (struct usb_hcd *hcd);
+
+       /* called after all devices were suspended */
+       int     (*suspend) (struct usb_hcd *hcd, u32 state);
+
+       /* called before any devices get resumed */
+       int     (*resume) (struct usb_hcd *hcd);
+
+       /* cleanly make HCD stop writing memory and doing I/O */
+       void    (*stop) (struct usb_hcd *hcd);
+
+       /* return current frame number */
+       int     (*get_frame_number) (struct usb_hcd *hcd);
+
+       /* memory lifecycle */
+       struct usb_hcd  *(*hcd_alloc) (void);
+       void            (*hcd_free) (struct usb_hcd *hcd);
+
+       /* manage i/o requests, device state */
+       int     (*urb_enqueue) (struct usb_hcd *hcd, struct urb *urb,
+                                       int mem_flags);
+       int     (*urb_dequeue) (struct usb_hcd *hcd, struct urb *urb);
+
+       /* hw synch, freeing endpoint resources that urb_dequeue can't */
+       void    (*endpoint_disable)(struct usb_hcd *hcd,
+                       struct hcd_dev *dev, int bEndpointAddress);
+
+       /* root hub support */
+       int             (*hub_status_data) (struct usb_hcd *hcd, char *buf);
+       int             (*hub_control) (struct usb_hcd *hcd,
+                               u16 typeReq, u16 wValue, u16 wIndex,
+                               char *buf, u16 wLength);
+};
+#endif
+
+extern void STDCALL usb_hcd_giveback_urb (struct usb_hcd *hcd, struct urb *urb, struct pt_regs *regs);
+extern void STDCALL usb_bus_init (struct usb_bus *bus);
+extern void usb_rh_status_dequeue (struct usb_hcd *hcd, struct urb *urb);
+
+#ifdef CONFIG_PCI
+struct pci_dev;
+struct pci_device_id;
+extern int STDCALL usb_hcd_pci_probe (struct pci_dev *dev,
+                               const struct pci_device_id *id);
+extern void STDCALL usb_hcd_pci_remove (struct pci_dev *dev);
+
+#ifdef CONFIG_PM
+// FIXME:  see Documentation/power/pci.txt (2.4.6 and later?)
+// extern int usb_hcd_pci_save_state (struct pci_dev *dev, u32 state);
+extern int usb_hcd_pci_suspend (struct pci_dev *dev, u32 state);
+extern int usb_hcd_pci_resume (struct pci_dev *dev);
+// extern int usb_hcd_pci_enable_wake (struct pci_dev *dev, u32 state, int flg);
+#endif /* CONFIG_PM */
+
+#endif /* CONFIG_PCI */
+
+/* pci-ish (pdev null is ok) buffer alloc/mapping support */
+int hcd_buffer_create (struct usb_hcd *hcd);
+void hcd_buffer_destroy (struct usb_hcd *hcd);
+
+void *hcd_buffer_alloc (struct usb_bus *bus, size_t size,
+       int mem_flags, dma_addr_t *dma);
+void hcd_buffer_free (struct usb_bus *bus, size_t size,
+       void *addr, dma_addr_t dma);
+
+/* generic bus glue, needed for host controllers that don't use PCI */
+extern struct usb_operations usb_hcd_operations;
+extern irqreturn_t usb_hcd_irq (int irq, void *__hcd, struct pt_regs *r);
+extern void STDCALL usb_hc_died (struct usb_hcd *hcd);
+
+/* -------------------------------------------------------------------------- */
+
+/* Enumeration is only for the hub driver, or HCD virtual root hubs */
+extern int usb_new_device(struct usb_device *dev, struct device *parent);
+extern void STDCALL usb_connect(struct usb_device *dev);
+extern void usb_disconnect(struct usb_device **);
+
+/* exported to hub driver ONLY to support usb_reset_device () */
+extern int usb_get_configuration(struct usb_device *dev);
+extern void usb_set_maxpacket(struct usb_device *dev);
+extern void usb_destroy_configuration(struct usb_device *dev);
+extern int usb_set_address(struct usb_device *dev);
+
+/* use these only before the device's address has been set */
+#define usb_snddefctrl(dev)            ((PIPE_CONTROL << 30))
+#define usb_rcvdefctrl(dev)            ((PIPE_CONTROL << 30) | USB_DIR_IN)
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * HCD Root Hub support
+ */
+
+#include "hub.h"
+
+/* (shifted) direction/type/recipient from the USB 2.0 spec, table 9.2 */
+#define DeviceRequest \
+       ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE)<<8)
+#define DeviceOutRequest \
+       ((USB_DIR_OUT|USB_TYPE_STANDARD|USB_RECIP_DEVICE)<<8)
+
+#define InterfaceRequest \
+       ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_INTERFACE)<<8)
+
+#define EndpointRequest \
+       ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_INTERFACE)<<8)
+#define EndpointOutRequest \
+       ((USB_DIR_OUT|USB_TYPE_STANDARD|USB_RECIP_INTERFACE)<<8)
+
+/* table 9.6 standard features */
+#define DEVICE_REMOTE_WAKEUP   1
+#define ENDPOINT_HALT          0
+
+/* class requests from the USB 2.0 hub spec, table 11-15 */
+/* GetBusState and SetHubDescriptor are optional, omitted */
+#define ClearHubFeature                (0x2000 | USB_REQ_CLEAR_FEATURE)
+#define ClearPortFeature       (0x2300 | USB_REQ_CLEAR_FEATURE)
+#define GetHubDescriptor       (0xa000 | USB_REQ_GET_DESCRIPTOR)
+#define GetHubStatus           (0xa000 | USB_REQ_GET_STATUS)
+#define GetPortStatus          (0xa300 | USB_REQ_GET_STATUS)
+#define SetHubFeature          (0x2000 | USB_REQ_SET_FEATURE)
+#define SetPortFeature         (0x2300 | USB_REQ_SET_FEATURE)
+
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * Generic bandwidth allocation constants/support
+ */
+#define FRAME_TIME_USECS       1000L
+#define BitTime(bytecount)  (7 * 8 * bytecount / 6)  /* with integer truncation */
+               /* Trying not to use worst-case bit-stuffing
+                   of (7/6 * 8 * bytecount) = 9.33 * bytecount */
+               /* bytecount = data payload byte count */
+
+#define NS_TO_US(ns)   ((ns + 500L) / 1000L)
+                       /* convert & round nanoseconds to microseconds */
+
+extern void STDCALL usb_claim_bandwidth (struct usb_device *dev, struct urb *urb,
+               int bustime, int isoc);
+extern void STDCALL usb_release_bandwidth (struct usb_device *dev, struct urb *urb,
+               int isoc);
+
+/*
+ * Full/low speed bandwidth allocation constants/support.
+ */
+#define BW_HOST_DELAY  1000L           /* nanoseconds */
+#define BW_HUB_LS_SETUP        333L            /* nanoseconds */
+                        /* 4 full-speed bit times (est.) */
+
+#define FRAME_TIME_BITS         12000L         /* frame = 1 millisecond */
+#define FRAME_TIME_MAX_BITS_ALLOC      (90L * FRAME_TIME_BITS / 100L)
+#define FRAME_TIME_MAX_USECS_ALLOC     (90L * FRAME_TIME_USECS / 100L)
+
+extern int STDCALL usb_check_bandwidth (struct usb_device *dev, struct urb *urb);
+
+/*
+ * Ceiling microseconds (typical) for that many bytes at high speed
+ * ISO is a bit less, no ACK ... from USB 2.0 spec, 5.11.3 (and needed
+ * to preallocate bandwidth)
+ */
+#define USB2_HOST_DELAY        5       /* nsec, guess */
+#define HS_USECS(bytes) NS_TO_US ( ((55 * 8 * 2083)/1000) \
+       + ((2083UL * (3167 + BitTime (bytes)))/1000) \
+       + USB2_HOST_DELAY)
+#define HS_USECS_ISO(bytes) NS_TO_US ( ((long)(38 * 8 * 2.083)) \
+       + ((2083UL * (3167 + BitTime (bytes)))/1000) \
+       + USB2_HOST_DELAY)
+
+extern long STDCALL usb_calc_bus_time (int speed, int is_input,
+                       int isoc, int bytecount);
+
+/*-------------------------------------------------------------------------*/
+
+extern struct usb_bus STDCALL *usb_alloc_bus (struct usb_operations *);
+extern void STDCALL usb_free_bus (struct usb_bus *);
+
+extern void STDCALL usb_register_bus (struct usb_bus *);
+extern void STDCALL usb_deregister_bus (struct usb_bus *);
+
+extern int STDCALL usb_register_root_hub (struct usb_device *usb_dev,
+               struct device *parent_dev);
+
+/* for portability to 2.4, hcds should call this */
+static inline int hcd_register_root (struct usb_hcd *hcd)
+{
+       return usb_register_root_hub (
+               hcd_to_bus (hcd)->root_hub, hcd->controller);
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* exported only within usbcore */
+
+extern struct list_head usb_bus_list;
+extern struct semaphore usb_bus_list_lock;
+
+extern void usb_bus_get (struct usb_bus *bus);
+extern void usb_bus_put (struct usb_bus *bus);
+
+extern int usb_find_interface_driver (struct usb_device *dev,
+       struct usb_interface *interface);
+
+#define usb_endpoint_halt(dev, ep, out) ((dev)->halted[out] |= (1 << (ep)))
+
+#define usb_endpoint_out(ep_dir)       (!((ep_dir) & USB_DIR_IN))
+
+/*
+ * USB device fs stuff
+ */
+
+#ifdef CONFIG_USB_DEVICEFS
+
+/*
+ * these are expected to be called from the USB core/hub thread
+ * with the kernel lock held
+ */
+extern void usbfs_add_bus(struct usb_bus *bus);
+extern void usbfs_remove_bus(struct usb_bus *bus);
+extern void usbfs_add_device(struct usb_device *dev);
+extern void usbfs_remove_device(struct usb_device *dev);
+extern void usbfs_update_special (void);
+
+extern int usbfs_init(void);
+extern void usbfs_cleanup(void);
+
+#else /* CONFIG_USB_DEVICEFS */
+
+static inline void usbfs_add_bus(struct usb_bus *bus) {}
+static inline void usbfs_remove_bus(struct usb_bus *bus) {}
+static inline void usbfs_add_device(struct usb_device *dev) {}
+static inline void usbfs_remove_device(struct usb_device *dev) {}
+static inline void usbfs_update_special (void) {}
+
+static inline int usbfs_init(void) { return 0; }
+static inline void usbfs_cleanup(void) { }
+
+#endif /* CONFIG_USB_DEVICEFS */
+
+/*-------------------------------------------------------------------------*/
+
+/* hub.h ... DeviceRemovable in 2.4.2-ac11, gone in 2.4.10 */
+// bleech -- resurfaced in 2.4.11 or 2.4.12
+#define bitmap         DeviceRemovable
+
+
+/*-------------------------------------------------------------------------*/
+
+/* random stuff */
+
+#define        RUN_CONTEXT (in_irq () ? "in_irq" \
+               : (in_interrupt () ? "in_interrupt" : "can sleep"))
+
+
+#endif /* __KERNEL__ */
+
index 1b7e820..8efb82d 100644 (file)
-/*\r
- * USB hub driver.\r
- *\r
- * (C) Copyright 1999 Linus Torvalds\r
- * (C) Copyright 1999 Johannes Erdfelt\r
- * (C) Copyright 1999 Gregory P. Smith\r
- * (C) Copyright 2001 Brad Hards (bhards@bigpond.net.au)\r
- *\r
- */\r
-#define DEBUG\r
-#if 0\r
-#include <linux/config.h>\r
-#include <linux/kernel.h>\r
-#include <linux/errno.h>\r
-#include <linux/module.h>\r
-#include <linux/completion.h>\r
-#include <linux/sched.h>\r
-#include <linux/list.h>\r
-#include <linux/slab.h>\r
-#include <linux/smp_lock.h>\r
-#include <linux/ioctl.h>\r
-#ifdef CONFIG_USB_DEBUG\r
-       #define DEBUG\r
-#else\r
-       #undef DEBUG\r
-#endif\r
-#include <linux/usb.h>\r
-#include <linux/usbdevice_fs.h>\r
-#include <linux/suspend.h>\r
-\r
-#include <asm/semaphore.h>\r
-#include <asm/uaccess.h>\r
-#include <asm/byteorder.h>\r
-\r
-#include "hcd.h"\r
-#include "hub.h"\r
-#else\r
-#include "../usb_wrapper.h"\r
-#include "hcd.h"\r
-#include "hub.h"\r
-#define DEBUG\r
-#endif\r
-\r
-/* Wakes up khubd */\r
-static spinlock_t hub_event_lock = SPIN_LOCK_UNLOCKED;\r
-static DECLARE_MUTEX(usb_address0_sem);\r
-\r
-static LIST_HEAD(hub_event_list);      /* List of hubs needing servicing */\r
-static LIST_HEAD(hub_list);            /* List of all hubs (for cleanup) */\r
-\r
-static DECLARE_WAIT_QUEUE_HEAD(khubd_wait);\r
-static pid_t khubd_pid = 0;                    /* PID of khubd */\r
-static DECLARE_COMPLETION(khubd_exited);\r
-\r
-#ifdef DEBUG\r
-static inline char *portspeed (int portstatus)\r
-{\r
-       if (portstatus & (1 << USB_PORT_FEAT_HIGHSPEED))\r
-               return "480 Mb/s";\r
-       else if (portstatus & (1 << USB_PORT_FEAT_LOWSPEED))\r
-               return "1.5 Mb/s";\r
-       else\r
-               return "12 Mb/s";\r
-}\r
-#endif\r
-\r
-/* for dev_info, dev_dbg, etc */\r
-static inline struct device *hubdev (struct usb_device *dev)\r
-{\r
-       return &dev->actconfig->interface [0].dev;\r
-}\r
-\r
-/* USB 2.0 spec Section 11.24.4.5 */\r
-static int get_hub_descriptor(struct usb_device *dev, void *data, int size)\r
-{\r
-       return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),\r
-               USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB,\r
-               USB_DT_HUB << 8, 0, data, size, HZ * USB_CTRL_GET_TIMEOUT);\r
-}\r
-\r
-/*\r
- * USB 2.0 spec Section 11.24.2.1\r
- */\r
-static int clear_hub_feature(struct usb_device *dev, int feature)\r
-{\r
-       return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),\r
-               USB_REQ_CLEAR_FEATURE, USB_RT_HUB, feature, 0, NULL, 0, HZ);\r
-}\r
-\r
-/*\r
- * USB 2.0 spec Section 11.24.2.2\r
- * BUG: doesn't handle port indicator selector in high byte of wIndex\r
- */\r
-static int clear_port_feature(struct usb_device *dev, int port, int feature)\r
-{\r
-       return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),\r
-               USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature, port, NULL, 0, HZ);\r
-}\r
-\r
-/*\r
- * USB 2.0 spec Section 11.24.2.13\r
- * BUG: doesn't handle port indicator selector in high byte of wIndex\r
- */\r
-static int set_port_feature(struct usb_device *dev, int port, int feature)\r
-{\r
-       return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),\r
-               USB_REQ_SET_FEATURE, USB_RT_PORT, feature, port, NULL, 0, HZ);\r
-}\r
-\r
-/*\r
- * USB 2.0 spec Section 11.24.2.6\r
- */\r
-static int get_hub_status(struct usb_device *dev,\r
-               struct usb_hub_status *data)\r
-{\r
-       return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),\r
-               USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_HUB, 0, 0,\r
-               data, sizeof(*data), HZ * USB_CTRL_GET_TIMEOUT);\r
-}\r
-\r
-/*\r
- * USB 2.0 spec Section 11.24.2.7\r
- */\r
-static int get_port_status(struct usb_device *dev, int port,\r
-               struct usb_port_status *data)\r
-{\r
-       return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),\r
-               USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, 0, port,\r
-               data, sizeof(*data), HZ * USB_CTRL_GET_TIMEOUT);\r
-}\r
-\r
-/* completion function, fires on port status changes and various faults */\r
-static void hub_irq(struct urb *urb, struct pt_regs *regs)\r
-{\r
-       struct usb_hub *hub = (struct usb_hub *)urb->context;\r
-       unsigned long flags;\r
-       int status;\r
-\r
-       switch (urb->status) {\r
-       case -ENOENT:           /* synchronous unlink */\r
-       case -ECONNRESET:       /* async unlink */\r
-       case -ESHUTDOWN:        /* hardware going away */\r
-               return;\r
-\r
-       default:                /* presumably an error */\r
-               /* Cause a hub reset after 10 consecutive errors */\r
-               dev_dbg (&hub->intf->dev, "transfer --> %d\n", urb->status);\r
-               if ((++hub->nerrors < 10) || hub->error)\r
-                       goto resubmit;\r
-               hub->error = urb->status;\r
-               /* FALL THROUGH */\r
-       \r
-       /* let khubd handle things */\r
-       case 0:                 /* we got data:  port status changed */\r
-               break;\r
-       }\r
-\r
-       hub->nerrors = 0;\r
-\r
-       /* Something happened, let khubd figure it out */\r
-       spin_lock_irqsave(&hub_event_lock, flags);\r
-       if (list_empty(&hub->event_list)) {\r
-               list_add(&hub->event_list, &hub_event_list);\r
-               wake_up(&khubd_wait);\r
-       }\r
-       spin_unlock_irqrestore(&hub_event_lock, flags);\r
-\r
-resubmit:\r
-       if ((status = usb_submit_urb (hub->urb, GFP_ATOMIC)) != 0\r
-                       /* ENODEV means we raced disconnect() */\r
-                       && status != -ENODEV)\r
-               dev_err (&hub->intf->dev, "resubmit --> %d\n", urb->status);\r
-}\r
-\r
-/* USB 2.0 spec Section 11.24.2.3 */\r
-static inline int\r
-hub_clear_tt_buffer (struct usb_device *hub, u16 devinfo, u16 tt)\r
-{\r
-       return usb_control_msg (hub, usb_rcvctrlpipe (hub, 0),\r
-               HUB_CLEAR_TT_BUFFER, USB_DIR_IN | USB_RECIP_OTHER,\r
-               devinfo, tt, 0, 0, HZ);\r
-}\r
-\r
-/*\r
- * enumeration blocks khubd for a long time. we use keventd instead, since\r
- * long blocking there is the exception, not the rule.  accordingly, HCDs\r
- * talking to TTs must queue control transfers (not just bulk and iso), so\r
- * both can talk to the same hub concurrently.\r
- */\r
-static void hub_tt_kevent (void *arg)\r
-{\r
-       struct usb_hub          *hub = arg;\r
-       unsigned long           flags;\r
-\r
-       spin_lock_irqsave (&hub->tt.lock, flags);\r
-       while (!list_empty (&hub->tt.clear_list)) {\r
-               struct list_head        *temp;\r
-               struct usb_tt_clear     *clear;\r
-               struct usb_device       *dev;\r
-               int                     status;\r
-\r
-               temp = hub->tt.clear_list.next;\r
-               clear = list_entry (temp, struct usb_tt_clear, clear_list);\r
-               list_del (&clear->clear_list);\r
-\r
-               /* drop lock so HCD can concurrently report other TT errors */\r
-               spin_unlock_irqrestore (&hub->tt.lock, flags);\r
-               dev = interface_to_usbdev (hub->intf);\r
-               status = hub_clear_tt_buffer (dev, clear->devinfo, clear->tt);\r
-               spin_lock_irqsave (&hub->tt.lock, flags);\r
-\r
-               if (status)\r
-                       err ("usb-%s-%s clear tt %d (%04x) error %d",\r
-                               dev->bus->bus_name, dev->devpath,\r
-                               clear->tt, clear->devinfo, status);\r
-               kfree (clear);\r
-       }\r
-       spin_unlock_irqrestore (&hub->tt.lock, flags);\r
-}\r
-\r
-/**\r
- * usb_hub_tt_clear_buffer - clear control/bulk TT state in high speed hub\r
- * @dev: the device whose split transaction failed\r
- * @pipe: identifies the endpoint of the failed transaction\r
- *\r
- * High speed HCDs use this to tell the hub driver that some split control or\r
- * bulk transaction failed in a way that requires clearing internal state of\r
- * a transaction translator.  This is normally detected (and reported) from\r
- * interrupt context.\r
- *\r
- * It may not be possible for that hub to handle additional full (or low)\r
- * speed transactions until that state is fully cleared out.\r
- */\r
-void usb_hub_tt_clear_buffer (struct usb_device *dev, int pipe)\r
-{\r
-       struct usb_tt           *tt = dev->tt;\r
-       unsigned long           flags;\r
-       struct usb_tt_clear     *clear;\r
-\r
-       /* we've got to cope with an arbitrary number of pending TT clears,\r
-        * since each TT has "at least two" buffers that can need it (and\r
-        * there can be many TTs per hub).  even if they're uncommon.\r
-        */\r
-       if ((clear = kmalloc (sizeof *clear, SLAB_ATOMIC)) == 0) {\r
-               err ("can't save CLEAR_TT_BUFFER state for hub at usb-%s-%s",\r
-                       dev->bus->bus_name, tt->hub->devpath);\r
-               /* FIXME recover somehow ... RESET_TT? */\r
-               return;\r
-       }\r
-\r
-       /* info that CLEAR_TT_BUFFER needs */\r
-       clear->tt = tt->multi ? dev->ttport : 1;\r
-       clear->devinfo = usb_pipeendpoint (pipe);\r
-       clear->devinfo |= dev->devnum << 4;\r
-       clear->devinfo |= usb_pipecontrol (pipe)\r
-                       ? (USB_ENDPOINT_XFER_CONTROL << 11)\r
-                       : (USB_ENDPOINT_XFER_BULK << 11);\r
-       if (usb_pipein (pipe))\r
-               clear->devinfo |= 1 << 15;\r
-       \r
-       /* tell keventd to clear state for this TT */\r
-       spin_lock_irqsave (&tt->lock, flags);\r
-       list_add_tail (&clear->clear_list, &tt->clear_list);\r
-       schedule_work (&tt->kevent);\r
-       spin_unlock_irqrestore (&tt->lock, flags);\r
-}\r
-\r
-static void hub_power_on(struct usb_hub *hub)\r
-{\r
-       struct usb_device *dev;\r
-       int i;\r
-\r
-       /* Enable power to the ports */\r
-       dev_dbg(hubdev(interface_to_usbdev(hub->intf)),\r
-               "enabling power on all ports\n");\r
-       dev = interface_to_usbdev(hub->intf);\r
-\r
-       for (i = 0; i < hub->descriptor->bNbrPorts; i++)\r
-               set_port_feature(dev, i + 1, USB_PORT_FEAT_POWER);\r
-\r
-       /* Wait for power to be enabled */\r
-       wait_ms(hub->descriptor->bPwrOn2PwrGood * 2);\r
-}\r
-\r
-static int hub_hub_status(struct usb_hub *hub,\r
-               u16 *status, u16 *change)\r
-{\r
-       struct usb_device *dev = interface_to_usbdev (hub->intf);\r
-       int ret;\r
-\r
-       ret = get_hub_status(dev, &hub->status->hub);\r
-       if (ret < 0)\r
-               dev_err (hubdev (dev),\r
-                       "%s failed (err = %d)\n", __FUNCTION__, ret);\r
-       else {\r
-               *status = le16_to_cpu(hub->status->hub.wHubStatus);\r
-               *change = le16_to_cpu(hub->status->hub.wHubChange); \r
-               ret = 0;\r
-       }\r
-       return ret;\r
-}\r
-\r
-static int hub_configure(struct usb_hub *hub,\r
-       struct usb_endpoint_descriptor *endpoint)\r
-{\r
-       struct usb_device *dev = interface_to_usbdev (hub->intf);\r
-       struct device *hub_dev;\r
-       u16 hubstatus, hubchange;\r
-       unsigned int pipe;\r
-       int maxp, ret;\r
-       char *message;\r
-\r
-       hub->buffer = usb_buffer_alloc(dev, sizeof(*hub->buffer), GFP_KERNEL,\r
-                       &hub->buffer_dma);\r
-       if (!hub->buffer) {\r
-               message = "can't allocate hub irq buffer";\r
-               ret = -ENOMEM;\r
-               goto fail;\r
-       }\r
-\r
-       hub->status = kmalloc(sizeof(*hub->status), GFP_KERNEL);\r
-       if (!hub->status) {\r
-               message = "can't kmalloc hub status buffer";\r
-               ret = -ENOMEM;\r
-               goto fail;\r
-       }\r
-\r
-       hub->descriptor = kmalloc(sizeof(*hub->descriptor), GFP_KERNEL);\r
-       if (!hub->descriptor) {\r
-               message = "can't kmalloc hub descriptor";\r
-               ret = -ENOMEM;\r
-               goto fail;\r
-       }\r
-\r
-       /* Request the entire hub descriptor.\r
-        * hub->descriptor can handle USB_MAXCHILDREN ports,\r
-        * but the hub can/will return fewer bytes here.\r
-        */\r
-       ret = get_hub_descriptor(dev, hub->descriptor,\r
-                       sizeof(*hub->descriptor));\r
-       if (ret < 0) {\r
-               message = "can't read hub descriptor";\r
-               goto fail;\r
-       } else if (hub->descriptor->bNbrPorts > USB_MAXCHILDREN) {\r
-               message = "hub has too many ports!";\r
-               ret = -ENODEV;\r
-               goto fail;\r
-       }\r
-\r
-       hub_dev = hubdev(dev);\r
-       dev->maxchild = hub->descriptor->bNbrPorts;\r
-       dev_info (hub_dev, "%d port%s detected\n", dev->maxchild,\r
-               (dev->maxchild == 1) ? "" : "s");\r
-\r
-       le16_to_cpus(&hub->descriptor->wHubCharacteristics);\r
-\r
-       if (hub->descriptor->wHubCharacteristics & HUB_CHAR_COMPOUND) {\r
-               int     i;\r
-               char    portstr [USB_MAXCHILDREN + 1];\r
-\r
-               for (i = 0; i < dev->maxchild; i++)\r
-                       portstr[i] = hub->descriptor->DeviceRemovable\r
-                                   [((i + 1) / 8)] & (1 << ((i + 1) % 8))\r
-                               ? 'F' : 'R';\r
-               portstr[dev->maxchild] = 0;\r
-               dev_dbg(hub_dev, "compound device; port removable status: %s\n", portstr);\r
-       } else\r
-               dev_dbg(hub_dev, "standalone hub\n");\r
-\r
-       switch (hub->descriptor->wHubCharacteristics & HUB_CHAR_LPSM) {\r
-               case 0x00:\r
-                       dev_dbg(hub_dev, "ganged power switching\n");\r
-                       break;\r
-               case 0x01:\r
-                       dev_dbg(hub_dev, "individual port power switching\n");\r
-                       break;\r
-               case 0x02:\r
-               case 0x03:\r
-                       dev_dbg(hub_dev, "unknown reserved power switching mode\n");\r
-                       break;\r
-       }\r
-\r
-       switch (hub->descriptor->wHubCharacteristics & HUB_CHAR_OCPM) {\r
-               case 0x00:\r
-                       dev_dbg(hub_dev, "global over-current protection\n");\r
-                       break;\r
-               case 0x08:\r
-                       dev_dbg(hub_dev, "individual port over-current protection\n");\r
-                       break;\r
-               case 0x10:\r
-               case 0x18:\r
-                       dev_dbg(hub_dev, "no over-current protection\n");\r
-                        break;\r
-       }\r
-\r
-       spin_lock_init (&hub->tt.lock);\r
-       INIT_LIST_HEAD (&hub->tt.clear_list);\r
-       INIT_WORK (&hub->tt.kevent, hub_tt_kevent, hub);\r
-       switch (dev->descriptor.bDeviceProtocol) {\r
-               case 0:\r
-                       break;\r
-               case 1:\r
-                       dev_dbg(hub_dev, "Single TT\n");\r
-                       hub->tt.hub = dev;\r
-                       break;\r
-               case 2:\r
-                       dev_dbg(hub_dev, "TT per port\n");\r
-                       hub->tt.hub = dev;\r
-                       hub->tt.multi = 1;\r
-                       break;\r
-               default:\r
-                       dev_dbg(hub_dev, "Unrecognized hub protocol %d\n",\r
-                               dev->descriptor.bDeviceProtocol);\r
-                       break;\r
-       }\r
-\r
-       switch (hub->descriptor->wHubCharacteristics & HUB_CHAR_TTTT) {\r
-               case 0x00:\r
-                       if (dev->descriptor.bDeviceProtocol != 0)\r
-                               dev_dbg(hub_dev, "TT requires at most 8 FS bit times\n");\r
-                       break;\r
-               case 0x20:\r
-                       dev_dbg(hub_dev, "TT requires at most 16 FS bit times\n");\r
-                       break;\r
-               case 0x40:\r
-                       dev_dbg(hub_dev, "TT requires at most 24 FS bit times\n");\r
-                       break;\r
-               case 0x60:\r
-                       dev_dbg(hub_dev, "TT requires at most 32 FS bit times\n");\r
-                       break;\r
-       }\r
-\r
-       dev_dbg(hub_dev, "Port indicators are %s supported\n", \r
-           (hub->descriptor->wHubCharacteristics & HUB_CHAR_PORTIND)\r
-               ? "" : "not");\r
-\r
-       dev_dbg(hub_dev, "power on to power good time: %dms\n",\r
-               hub->descriptor->bPwrOn2PwrGood * 2);\r
-       dev_dbg(hub_dev, "hub controller current requirement: %dmA\n",\r
-               hub->descriptor->bHubContrCurrent);\r
-\r
-       ret = hub_hub_status(hub, &hubstatus, &hubchange);\r
-       if (ret < 0) {\r
-               message = "can't get hub status";\r
-               goto fail;\r
-       }\r
-\r
-       dev_dbg(hub_dev, "local power source is %s\n",\r
-               (hubstatus & HUB_STATUS_LOCAL_POWER)\r
-               ? "lost (inactive)" : "good");\r
-\r
-       dev_dbg(hub_dev, "%sover-current condition exists\n",\r
-               (hubstatus & HUB_STATUS_OVERCURRENT) ? "" : "no ");\r
-\r
-       /* Start the interrupt endpoint */\r
-       pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);\r
-       maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));\r
-\r
-       if (maxp > sizeof(*hub->buffer))\r
-               maxp = sizeof(*hub->buffer);\r
-\r
-       hub->urb = usb_alloc_urb(0, GFP_KERNEL);\r
-       if (!hub->urb) {\r
-               message = "couldn't allocate interrupt urb";\r
-               ret = -ENOMEM;\r
-               goto fail;\r
-       }\r
-\r
-       usb_fill_int_urb(hub->urb, dev, pipe, *hub->buffer, maxp, hub_irq,\r
-               hub, endpoint->bInterval);\r
-       hub->urb->transfer_dma = hub->buffer_dma;\r
-       hub->urb->transfer_flags |= URB_NO_DMA_MAP;\r
-       ret = usb_submit_urb(hub->urb, GFP_KERNEL);\r
-       if (ret) {\r
-               message = "couldn't submit status urb";\r
-               goto fail;\r
-       }\r
-\r
-       /* Wake up khubd */\r
-       wake_up(&khubd_wait);\r
-\r
-       hub_power_on(hub);\r
-\r
-       return 0;\r
-\r
-fail:\r
-       dev_err (&hub->intf->dev, "config failed, %s (err %d)\n",\r
-                       message, ret);\r
-       /* hub_disconnect() frees urb and descriptor */\r
-       return ret;\r
-}\r
-\r
-static void hub_disconnect(struct usb_interface *intf)\r
-{\r
-       struct usb_hub *hub = usb_get_intfdata (intf);\r
-       unsigned long flags;\r
-\r
-       if (!hub)\r
-               return;\r
-\r
-       usb_set_intfdata (intf, NULL);\r
-       spin_lock_irqsave(&hub_event_lock, flags);\r
-\r
-       /* Delete it and then reset it */\r
-       list_del(&hub->event_list);\r
-       INIT_LIST_HEAD(&hub->event_list);\r
-       list_del(&hub->hub_list);\r
-       INIT_LIST_HEAD(&hub->hub_list);\r
-\r
-       spin_unlock_irqrestore(&hub_event_lock, flags);\r
-\r
-       down(&hub->khubd_sem); /* Wait for khubd to leave this hub alone. */\r
-       up(&hub->khubd_sem);\r
-\r
-       /* assuming we used keventd, it must quiesce too */\r
-       if (hub->tt.hub)\r
-               flush_scheduled_work ();\r
-\r
-       if (hub->urb) {\r
-               usb_unlink_urb(hub->urb);\r
-               usb_free_urb(hub->urb);\r
-               hub->urb = NULL;\r
-       }\r
-\r
-       if (hub->descriptor) {\r
-               kfree(hub->descriptor);\r
-               hub->descriptor = NULL;\r
-       }\r
-\r
-       if (hub->status) {\r
-               kfree(hub->status);\r
-               hub->status = NULL;\r
-       }\r
-\r
-       if (hub->buffer) {\r
-               usb_buffer_free(interface_to_usbdev(intf),\r
-                               sizeof(*hub->buffer), hub->buffer,\r
-                               hub->buffer_dma);\r
-               hub->buffer = NULL;\r
-       }\r
-\r
-       /* Free the memory */\r
-       kfree(hub);\r
-}\r
-\r
-static int hub_probe(struct usb_interface *intf, const struct usb_device_id *id)\r
-{\r
-       struct usb_host_interface *desc;\r
-       struct usb_endpoint_descriptor *endpoint;\r
-       struct usb_device *dev;\r
-       struct usb_hub *hub;\r
-       unsigned long flags;\r
-\r
-       desc = intf->altsetting + intf->act_altsetting;\r
-       dev = interface_to_usbdev(intf);\r
-\r
-       /* Some hubs have a subclass of 1, which AFAICT according to the */\r
-       /*  specs is not defined, but it works */\r
-       if ((desc->desc.bInterfaceSubClass != 0) &&\r
-           (desc->desc.bInterfaceSubClass != 1)) {\r
-descriptor_error:\r
-               dev_err (&intf->dev, "bad descriptor, ignoring hub\n");\r
-               return -EIO;\r
-       }\r
-\r
-       /* Multiple endpoints? What kind of mutant ninja-hub is this? */\r
-       if (desc->desc.bNumEndpoints != 1) {\r
-               goto descriptor_error;\r
-       }\r
-\r
-       endpoint = &desc->endpoint[0].desc;\r
-\r
-       /* Output endpoint? Curiouser and curiouser.. */\r
-       if (!(endpoint->bEndpointAddress & USB_DIR_IN)) {\r
-               goto descriptor_error;\r
-       }\r
-\r
-       /* If it's not an interrupt endpoint, we'd better punt! */\r
-       if ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)\r
-                       != USB_ENDPOINT_XFER_INT) {\r
-               goto descriptor_error;\r
-               return -EIO;\r
-       }\r
-\r
-       /* We found a hub */\r
-       dev_info (hubdev (dev), "USB hub found\n");\r
-\r
-       hub = kmalloc(sizeof(*hub), GFP_KERNEL);\r
-       if (!hub) {\r
-               err("couldn't kmalloc hub struct");\r
-               return -ENOMEM;\r
-       }\r
-\r
-       memset(hub, 0, sizeof(*hub));\r
-\r
-       INIT_LIST_HEAD(&hub->event_list);\r
-       hub->intf = intf;\r
-       init_MUTEX(&hub->khubd_sem);\r
-\r
-       /* Record the new hub's existence */\r
-       spin_lock_irqsave(&hub_event_lock, flags);\r
-       INIT_LIST_HEAD(&hub->hub_list);\r
-       list_add(&hub->hub_list, &hub_list);\r
-       spin_unlock_irqrestore(&hub_event_lock, flags);\r
-\r
-       usb_set_intfdata (intf, hub);\r
-\r
-       if (hub_configure(hub, endpoint) >= 0) {\r
-               strcpy (intf->dev.name, "Hub");\r
-               return 0;\r
-       }\r
-\r
-       hub_disconnect (intf);\r
-       return -ENODEV;\r
-}\r
-\r
-static int\r
-hub_ioctl(struct usb_interface *intf, unsigned int code, void *user_data)\r
-{\r
-       struct usb_device *hub = interface_to_usbdev (intf);\r
-\r
-       /* assert ifno == 0 (part of hub spec) */\r
-       switch (code) {\r
-       case USBDEVFS_HUB_PORTINFO: {\r
-               struct usbdevfs_hub_portinfo *info = user_data;\r
-               unsigned long flags;\r
-               int i;\r
-\r
-               spin_lock_irqsave(&hub_event_lock, flags);\r
-               if (hub->devnum <= 0)\r
-                       info->nports = 0;\r
-               else {\r
-                       info->nports = hub->maxchild;\r
-                       for (i = 0; i < info->nports; i++) {\r
-                               if (hub->children[i] == NULL)\r
-                                       info->port[i] = 0;\r
-                               else\r
-                                       info->port[i] =\r
-                                               hub->children[i]->devnum;\r
-                       }\r
-               }\r
-               spin_unlock_irqrestore(&hub_event_lock, flags);\r
-\r
-               return info->nports + 1;\r
-               }\r
-\r
-       default:\r
-               return -ENOSYS;\r
-       }\r
-}\r
-\r
-static int hub_reset(struct usb_hub *hub)\r
-{\r
-       struct usb_device *dev = interface_to_usbdev(hub->intf);\r
-       int i;\r
-\r
-       /* Disconnect any attached devices */\r
-       for (i = 0; i < hub->descriptor->bNbrPorts; i++) {\r
-               if (dev->children[i])\r
-                       usb_disconnect(&dev->children[i]);\r
-       }\r
-\r
-       /* Attempt to reset the hub */\r
-       if (hub->urb)\r
-               usb_unlink_urb(hub->urb);\r
-       else\r
-               return -1;\r
-\r
-       if (usb_reset_device(dev))\r
-               return -1;\r
-\r
-       hub->urb->dev = dev;                                                    \r
-       if (usb_submit_urb(hub->urb, GFP_KERNEL))\r
-               return -1;\r
-\r
-       hub_power_on(hub);\r
-\r
-       return 0;\r
-}\r
-\r
-static void hub_start_disconnect(struct usb_device *dev)\r
-{\r
-       struct usb_device *parent = dev->parent;\r
-       int i;\r
-\r
-       /* Find the device pointer to disconnect */\r
-       if (parent) {\r
-               for (i = 0; i < parent->maxchild; i++) {\r
-                       if (parent->children[i] == dev) {\r
-                               usb_disconnect(&parent->children[i]);\r
-                               return;\r
-                       }\r
-               }\r
-       }\r
-\r
-       err("cannot disconnect hub %s", dev->devpath);\r
-}\r
-\r
-static int hub_port_status(struct usb_device *dev, int port,\r
-                              u16 *status, u16 *change)\r
-{\r
-       struct usb_hub *hub = usb_get_intfdata (dev->actconfig->interface);\r
-       int ret;\r
-\r
-       ret = get_port_status(dev, port + 1, &hub->status->port);\r
-       if (ret < 0)\r
-               dev_err (hubdev (dev),\r
-                       "%s failed (err = %d)\n", __FUNCTION__, ret);\r
-       else {\r
-               *status = le16_to_cpu(hub->status->port.wPortStatus);\r
-               *change = le16_to_cpu(hub->status->port.wPortChange); \r
-               ret = 0;\r
-       }\r
-       return ret;\r
-}\r
-\r
-#define HUB_RESET_TRIES                5\r
-#define HUB_PROBE_TRIES                2\r
-#define HUB_SHORT_RESET_TIME   10\r
-#define HUB_LONG_RESET_TIME    200\r
-#define HUB_RESET_TIMEOUT      500\r
-\r
-/* return: -1 on error, 0 on success, 1 on disconnect.  */\r
-static int hub_port_wait_reset(struct usb_device *hub, int port,\r
-                               struct usb_device *dev, unsigned int delay)\r
-{\r
-       int delay_time, ret;\r
-       u16 portstatus;\r
-       u16 portchange;\r
-\r
-       for (delay_time = 0;\r
-                       delay_time < HUB_RESET_TIMEOUT;\r
-                       delay_time += delay) {\r
-               /* wait to give the device a chance to reset */\r
-               wait_ms(delay);\r
-\r
-               /* read and decode port status */\r
-               ret = hub_port_status(hub, port, &portstatus, &portchange);\r
-               if (ret < 0) {\r
-                       return -1;\r
-               }\r
-\r
-               /* Device went away? */\r
-               if (!(portstatus & USB_PORT_STAT_CONNECTION))\r
-                       return 1;\r
-\r
-               /* bomb out completely if something weird happened */\r
-               if ((portchange &&