Eric Lee / smarc-ti-linux-kernel | Embedian Git Server

Commit 8ee7a330fbb78344802cc6c3cc8be023b6d05aa0

Authored by Linus Torvalds 2014-06-03 07:56:42 +0800

Exists in ti-lsk-linux-4.1.y and in 12 other branches

Merge tag 'usb-3.15-rc8' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb

Pull USB fixes from Greg KH:
 "Here are some fixes for 3.15-rc8 that resolve a number of tiny USB
  issues that have been reported, and there are some new device ids as
  well.

  All have been tested in linux-next"

* tag 'usb-3.15-rc8' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb:
  xhci: delete endpoints from bandwidth list before freeing whole device
  usb: pci-quirks: Prevent Sony VAIO t-series from switching usb ports
  USB: cdc-wdm: properly include types.h
  usb: cdc-wdm: export cdc-wdm uapi header
  USB: serial: option: add support for Novatel E371 PCIe card
  USB: ftdi_sio: add NovaTech OrionLXm product ID
  USB: io_ti: fix firmware download on big-endian machines (part 2)
  USB: Avoid runtime suspend loops for HCDs that can't handle suspend/resume

Showing 11 changed files Inline Diff

drivers/usb/core/driver.c
drivers/usb/core/hub.c
drivers/usb/host/pci-quirks.c
drivers/usb/host/xhci-mem.c
drivers/usb/serial/ftdi_sio.c
drivers/usb/serial/ftdi_sio_ids.h
drivers/usb/serial/io_ti.c
drivers/usb/serial/io_usbvend.h
drivers/usb/serial/option.c
include/uapi/linux/usb/Kbuild
include/uapi/linux/usb/cdc-wdm.h

drivers/usb/core/driver.c

Diff comments View file @ 8ee7a33

 /*
  * drivers/usb/driver.c - most of the driver model stuff for usb
  *
  * (C) Copyright 2005 Greg Kroah-Hartman <gregkh@suse.de>
  *
  * based on drivers/usb/usb.c which had the following copyrights:
  *	(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 (new USB architecture)
  *	(C) Copyright Randy Dunlap 2000
  *	(C) Copyright David Brownell 2000-2004
  *	(C) Copyright Yggdrasil Computing, Inc. 2000
  *		(usb_device_id matching changes by Adam J. Richter)
  *	(C) Copyright Greg Kroah-Hartman 2002-2003
  *
  * NOTE! This is not actually a driver at all, rather this is
  * just a collection of helper routines that implement the
  * matching, probing, releasing, suspending and resuming for
  * real drivers.
  *
  */
 #include <linux/device.h>
 #include <linux/slab.h>
 #include <linux/export.h>
 #include <linux/usb.h>
 #include <linux/usb/quirks.h>
 #include <linux/usb/hcd.h>
 #include "usb.h"
 /*
  * Adds a new dynamic USBdevice ID to this driver,
  * and cause the driver to probe for all devices again.
  */
 ssize_t usb_store_new_id(struct usb_dynids *dynids,
 			 const struct usb_device_id *id_table,
 			 struct device_driver *driver,
 			 const char *buf, size_t count)
 {
 	struct usb_dynid *dynid;
 	u32 idVendor = 0;
 	u32 idProduct = 0;
 	unsigned int bInterfaceClass = 0;
 	u32 refVendor, refProduct;
 	int fields = 0;
 	int retval = 0;
 	fields = sscanf(buf, "%x %x %x %x %x", &idVendor, &idProduct,
 			&bInterfaceClass, &refVendor, &refProduct);
 	if (fields < 2)
 		return -EINVAL;
 	dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
 	if (!dynid)
 		return -ENOMEM;
 	INIT_LIST_HEAD(&dynid->node);
 	dynid->id.idVendor = idVendor;
 	dynid->id.idProduct = idProduct;
 	dynid->id.match_flags = USB_DEVICE_ID_MATCH_DEVICE;
 	if (fields > 2 && bInterfaceClass) {
 		if (bInterfaceClass > 255) {
 			retval = -EINVAL;
 			goto fail;
 		}
 		dynid->id.bInterfaceClass = (u8)bInterfaceClass;
 		dynid->id.match_flags |= USB_DEVICE_ID_MATCH_INT_CLASS;
 	}
 	if (fields > 4) {
 		const struct usb_device_id *id = id_table;
 		if (!id) {
 			retval = -ENODEV;
 			goto fail;
 		}
 		for (; id->match_flags; id++)
 			if (id->idVendor == refVendor && id->idProduct == refProduct)
 				break;
 		if (id->match_flags) {
 			dynid->id.driver_info = id->driver_info;
 		} else {
 			retval = -ENODEV;
 			goto fail;
 		}
 	}
 	spin_lock(&dynids->lock);
 	list_add_tail(&dynid->node, &dynids->list);
 	spin_unlock(&dynids->lock);
 	retval = driver_attach(driver);
 	if (retval)
 		return retval;
 	return count;
 fail:
 	kfree(dynid);
 	return retval;
 }
 EXPORT_SYMBOL_GPL(usb_store_new_id);
 ssize_t usb_show_dynids(struct usb_dynids *dynids, char *buf)
 {
 	struct usb_dynid *dynid;
 	size_t count = 0;
 	list_for_each_entry(dynid, &dynids->list, node)
 		if (dynid->id.bInterfaceClass != 0)
 			count += scnprintf(&buf[count], PAGE_SIZE - count, "%04x %04x %02x\n",
 					   dynid->id.idVendor, dynid->id.idProduct,
 					   dynid->id.bInterfaceClass);
 		else
 			count += scnprintf(&buf[count], PAGE_SIZE - count, "%04x %04x\n",
 					   dynid->id.idVendor, dynid->id.idProduct);
 	return count;
 }
 EXPORT_SYMBOL_GPL(usb_show_dynids);
 static ssize_t new_id_show(struct device_driver *driver, char *buf)
 {
 	struct usb_driver *usb_drv = to_usb_driver(driver);
 	return usb_show_dynids(&usb_drv->dynids, buf);
 }
 static ssize_t new_id_store(struct device_driver *driver,
 			    const char *buf, size_t count)
 {
 	struct usb_driver *usb_drv = to_usb_driver(driver);
 	return usb_store_new_id(&usb_drv->dynids, usb_drv->id_table, driver, buf, count);
 }
 static DRIVER_ATTR_RW(new_id);
 /*
  * Remove a USB device ID from this driver
  */
 static ssize_t remove_id_store(struct device_driver *driver, const char *buf,
 			       size_t count)
 {
 	struct usb_dynid *dynid, *n;
 	struct usb_driver *usb_driver = to_usb_driver(driver);
 	u32 idVendor;
 	u32 idProduct;
 	int fields;
 	fields = sscanf(buf, "%x %x", &idVendor, &idProduct);
 	if (fields < 2)
 		return -EINVAL;
 	spin_lock(&usb_driver->dynids.lock);
 	list_for_each_entry_safe(dynid, n, &usb_driver->dynids.list, node) {
 		struct usb_device_id *id = &dynid->id;
 		if ((id->idVendor == idVendor) &&
 		    (id->idProduct == idProduct)) {
 			list_del(&dynid->node);
 			kfree(dynid);
 			break;
 		}
 	}
 	spin_unlock(&usb_driver->dynids.lock);
 	return count;
 }
 static ssize_t remove_id_show(struct device_driver *driver, char *buf)
 {
 	return new_id_show(driver, buf);
 }
 static DRIVER_ATTR_RW(remove_id);
 static int usb_create_newid_files(struct usb_driver *usb_drv)
 {
 	int error = 0;
 	if (usb_drv->no_dynamic_id)
 		goto exit;
 	if (usb_drv->probe != NULL) {
 		error = driver_create_file(&usb_drv->drvwrap.driver,
 					   &driver_attr_new_id);
 		if (error == 0) {
 			error = driver_create_file(&usb_drv->drvwrap.driver,
 					&driver_attr_remove_id);
 			if (error)
 				driver_remove_file(&usb_drv->drvwrap.driver,
 						&driver_attr_new_id);
 		}
 	}
 exit:
 	return error;
 }
 static void usb_remove_newid_files(struct usb_driver *usb_drv)
 {
 	if (usb_drv->no_dynamic_id)
 		return;
 	if (usb_drv->probe != NULL) {
 		driver_remove_file(&usb_drv->drvwrap.driver,
 				&driver_attr_remove_id);
 		driver_remove_file(&usb_drv->drvwrap.driver,
 				   &driver_attr_new_id);
 	}
 }
 static void usb_free_dynids(struct usb_driver *usb_drv)
 {
 	struct usb_dynid *dynid, *n;
 	spin_lock(&usb_drv->dynids.lock);
 	list_for_each_entry_safe(dynid, n, &usb_drv->dynids.list, node) {
 		list_del(&dynid->node);
 		kfree(dynid);
 	}
 	spin_unlock(&usb_drv->dynids.lock);
 }
 static const struct usb_device_id *usb_match_dynamic_id(struct usb_interface *intf,
 							struct usb_driver *drv)
 {
 	struct usb_dynid *dynid;
 	spin_lock(&drv->dynids.lock);
 	list_for_each_entry(dynid, &drv->dynids.list, node) {
 		if (usb_match_one_id(intf, &dynid->id)) {
 			spin_unlock(&drv->dynids.lock);
 			return &dynid->id;
 		}
 	}
 	spin_unlock(&drv->dynids.lock);
 	return NULL;
 }
 /* called from driver core with dev locked */
 static int usb_probe_device(struct device *dev)
 {
 	struct usb_device_driver *udriver = to_usb_device_driver(dev->driver);
 	struct usb_device *udev = to_usb_device(dev);
 	int error = 0;
 	dev_dbg(dev, "%s\n", __func__);
 	/* TODO: Add real matching code */
 	/* The device should always appear to be in use
 	 * unless the driver supports autosuspend.
 	 */
 	if (!udriver->supports_autosuspend)
 		error = usb_autoresume_device(udev);
 	if (!error)
 		error = udriver->probe(udev);
 	return error;
 }
 /* called from driver core with dev locked */
 static int usb_unbind_device(struct device *dev)
 {
 	struct usb_device *udev = to_usb_device(dev);
 	struct usb_device_driver *udriver = to_usb_device_driver(dev->driver);
 	udriver->disconnect(udev);
 	if (!udriver->supports_autosuspend)
 		usb_autosuspend_device(udev);
 	return 0;
 }
 /*
  * Cancel any pending scheduled resets
  *
  * [see usb_queue_reset_device()]
  *
  * Called after unconfiguring / when releasing interfaces. See
  * comments in __usb_queue_reset_device() regarding
  * udev->reset_running.
  */
 static void usb_cancel_queued_reset(struct usb_interface *iface)
 {
 	if (iface->reset_running == 0)
 		cancel_work_sync(&iface->reset_ws);
 }
 /* called from driver core with dev locked */
 static int usb_probe_interface(struct device *dev)
 {
 	struct usb_driver *driver = to_usb_driver(dev->driver);
 	struct usb_interface *intf = to_usb_interface(dev);
 	struct usb_device *udev = interface_to_usbdev(intf);
 	const struct usb_device_id *id;
 	int error = -ENODEV;
 	int lpm_disable_error;
 	dev_dbg(dev, "%s\n", __func__);
 	intf->needs_binding = 0;
 	if (usb_device_is_owned(udev))
 		return error;
 	if (udev->authorized == 0) {
 		dev_err(&intf->dev, "Device is not authorized for usage\n");
 		return error;
 	}
 	id = usb_match_dynamic_id(intf, driver);
 	if (!id)
 		id = usb_match_id(intf, driver->id_table);
 	if (!id)
 		return error;
 	dev_dbg(dev, "%s - got id\n", __func__);
 	error = usb_autoresume_device(udev);
 	if (error)
 		return error;
 	intf->condition = USB_INTERFACE_BINDING;
 	/* Probed interfaces are initially active.  They are
 	 * runtime-PM-enabled only if the driver has autosuspend support.
 	 * They are sensitive to their children's power states.
 	 */
 	pm_runtime_set_active(dev);
 	pm_suspend_ignore_children(dev, false);
 	if (driver->supports_autosuspend)
 		pm_runtime_enable(dev);
 	/* If the new driver doesn't allow hub-initiated LPM, and we can't
 	 * disable hub-initiated LPM, then fail the probe.
 	 *
 	 * Otherwise, leaving LPM enabled should be harmless, because the
 	 * endpoint intervals should remain the same, and the U1/U2 timeouts
 	 * should remain the same.
 	 *
 	 * If we need to install alt setting 0 before probe, or another alt
 	 * setting during probe, that should also be fine.  usb_set_interface()
 	 * will attempt to disable LPM, and fail if it can't disable it.
 	 */
 	lpm_disable_error = usb_unlocked_disable_lpm(udev);
 	if (lpm_disable_error && driver->disable_hub_initiated_lpm) {
 		dev_err(&intf->dev, "%s Failed to disable LPM for driver %s\n.",
 				__func__, driver->name);
 		error = lpm_disable_error;
 		goto err;
 	}
 	/* Carry out a deferred switch to altsetting 0 */
 	if (intf->needs_altsetting0) {
 		error = usb_set_interface(udev, intf->altsetting[0].
 				desc.bInterfaceNumber, 0);
 		if (error < 0)
 			goto err;
 		intf->needs_altsetting0 = 0;
 	}
 	error = driver->probe(intf, id);
 	if (error)
 		goto err;
 	intf->condition = USB_INTERFACE_BOUND;
 	/* If the LPM disable succeeded, balance the ref counts. */
 	if (!lpm_disable_error)
 		usb_unlocked_enable_lpm(udev);
 	usb_autosuspend_device(udev);
 	return error;
  err:
 	usb_set_intfdata(intf, NULL);
 	intf->needs_remote_wakeup = 0;
 	intf->condition = USB_INTERFACE_UNBOUND;
 	usb_cancel_queued_reset(intf);
 	/* If the LPM disable succeeded, balance the ref counts. */
 	if (!lpm_disable_error)
 		usb_unlocked_enable_lpm(udev);
 	/* Unbound interfaces are always runtime-PM-disabled and -suspended */
 	if (driver->supports_autosuspend)
 		pm_runtime_disable(dev);
 	pm_runtime_set_suspended(dev);
 	usb_autosuspend_device(udev);
 	return error;
 }
 /* called from driver core with dev locked */
 static int usb_unbind_interface(struct device *dev)
 {
 	struct usb_driver *driver = to_usb_driver(dev->driver);
 	struct usb_interface *intf = to_usb_interface(dev);
 	struct usb_host_endpoint *ep, **eps = NULL;
 	struct usb_device *udev;
 	int i, j, error, r, lpm_disable_error;
 	intf->condition = USB_INTERFACE_UNBINDING;
 	/* Autoresume for set_interface call below */
 	udev = interface_to_usbdev(intf);
 	error = usb_autoresume_device(udev);
 	/* Hub-initiated LPM policy may change, so attempt to disable LPM until
 	 * the driver is unbound.  If LPM isn't disabled, that's fine because it
 	 * wouldn't be enabled unless all the bound interfaces supported
 	 * hub-initiated LPM.
 	 */
 	lpm_disable_error = usb_unlocked_disable_lpm(udev);
 	/* Terminate all URBs for this interface unless the driver
 	 * supports "soft" unbinding.
 	 */
 	if (!driver->soft_unbind)
 		usb_disable_interface(udev, intf, false);
 	driver->disconnect(intf);
 	usb_cancel_queued_reset(intf);
 	/* Free streams */
 	for (i = 0, j = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
 		ep = &intf->cur_altsetting->endpoint[i];
 		if (ep->streams == 0)
 			continue;
 		if (j == 0) {
 			eps = kmalloc(USB_MAXENDPOINTS * sizeof(void *),
 				      GFP_KERNEL);
 			if (!eps) {
 				dev_warn(dev, "oom, leaking streams\n");
 				break;
 			}
 		}
 		eps[j++] = ep;
 	}
 	if (j) {
 		usb_free_streams(intf, eps, j, GFP_KERNEL);
 		kfree(eps);
 	}
 	/* Reset other interface state.
 	 * We cannot do a Set-Interface if the device is suspended or
 	 * if it is prepared for a system sleep (since installing a new
 	 * altsetting means creating new endpoint device entries).
 	 * When either of these happens, defer the Set-Interface.
 	 */
 	if (intf->cur_altsetting->desc.bAlternateSetting == 0) {
 		/* Already in altsetting 0 so skip Set-Interface.
 		 * Just re-enable it without affecting the endpoint toggles.
 		 */
 		usb_enable_interface(udev, intf, false);
 	} else if (!error && !intf->dev.power.is_prepared) {
 		r = usb_set_interface(udev, intf->altsetting[0].
 				desc.bInterfaceNumber, 0);
 		if (r < 0)
 			intf->needs_altsetting0 = 1;
 	} else {
 		intf->needs_altsetting0 = 1;
 	}
 	usb_set_intfdata(intf, NULL);
 	intf->condition = USB_INTERFACE_UNBOUND;
 	intf->needs_remote_wakeup = 0;
 	/* Attempt to re-enable USB3 LPM, if the disable succeeded. */
 	if (!lpm_disable_error)
 		usb_unlocked_enable_lpm(udev);
 	/* Unbound interfaces are always runtime-PM-disabled and -suspended */
 	if (driver->supports_autosuspend)
 		pm_runtime_disable(dev);
 	pm_runtime_set_suspended(dev);
 	/* Undo any residual pm_autopm_get_interface_* calls */
 	for (r = atomic_read(&intf->pm_usage_cnt); r > 0; --r)
 		usb_autopm_put_interface_no_suspend(intf);
 	atomic_set(&intf->pm_usage_cnt, 0);
 	if (!error)
 		usb_autosuspend_device(udev);
 	return 0;
 }
 /**
  * usb_driver_claim_interface - bind a driver to an interface
  * @driver: the driver to be bound
  * @iface: the interface to which it will be bound; must be in the
  *	usb device's active configuration
  * @priv: driver data associated with that interface
  *
  * This is used by usb device drivers that need to claim more than one
  * interface on a device when probing (audio and acm are current examples).
  * No device driver should directly modify internal usb_interface or
  * usb_device structure members.
  *
  * Few drivers should need to use this routine, since the most natural
  * way to bind to an interface is to return the private data from
  * the driver's probe() method.
  *
  * Callers must own the device lock, so driver probe() entries don't need
  * extra locking, but other call contexts may need to explicitly claim that
  * lock.
  *
  * Return: 0 on success.
  */
 int usb_driver_claim_interface(struct usb_driver *driver,
 				struct usb_interface *iface, void *priv)
 {
 	struct device *dev = &iface->dev;
 	struct usb_device *udev;
 	int retval = 0;
 	int lpm_disable_error;
 	if (dev->driver)
 		return -EBUSY;
 	udev = interface_to_usbdev(iface);
 	dev->driver = &driver->drvwrap.driver;
 	usb_set_intfdata(iface, priv);
 	iface->needs_binding = 0;
 	iface->condition = USB_INTERFACE_BOUND;
 	/* Disable LPM until this driver is bound. */
 	lpm_disable_error = usb_unlocked_disable_lpm(udev);
 	if (lpm_disable_error && driver->disable_hub_initiated_lpm) {
 		dev_err(&iface->dev, "%s Failed to disable LPM for driver %s\n.",
 				__func__, driver->name);
 		return -ENOMEM;
 	}
 	/* Claimed interfaces are initially inactive (suspended) and
 	 * runtime-PM-enabled, but only if the driver has autosuspend
 	 * support.  Otherwise they are marked active, to prevent the
 	 * device from being autosuspended, but left disabled.  In either
 	 * case they are sensitive to their children's power states.
 	 */
 	pm_suspend_ignore_children(dev, false);
 	if (driver->supports_autosuspend)
 		pm_runtime_enable(dev);
 	else
 		pm_runtime_set_active(dev);
 	/* if interface was already added, bind now; else let
 	 * the future device_add() bind it, bypassing probe()
 	 */
 	if (device_is_registered(dev))
 		retval = device_bind_driver(dev);
 	/* Attempt to re-enable USB3 LPM, if the disable was successful. */
 	if (!lpm_disable_error)
 		usb_unlocked_enable_lpm(udev);
 	return retval;
 }
 EXPORT_SYMBOL_GPL(usb_driver_claim_interface);
 /**
  * usb_driver_release_interface - unbind a driver from an interface
  * @driver: the driver to be unbound
  * @iface: the interface from which it will be unbound
  *
  * This can be used by drivers to release an interface without waiting
  * for their disconnect() methods to be called.  In typical cases this
  * also causes the driver disconnect() method to be called.
  *
  * This call is synchronous, and may not be used in an interrupt context.
  * Callers must own the device lock, so driver disconnect() entries don't
  * need extra locking, but other call contexts may need to explicitly claim
  * that lock.
  */
 void usb_driver_release_interface(struct usb_driver *driver,
 					struct usb_interface *iface)
 {
 	struct device *dev = &iface->dev;
 	/* this should never happen, don't release something that's not ours */
 	if (!dev->driver || dev->driver != &driver->drvwrap.driver)
 		return;
 	/* don't release from within disconnect() */
 	if (iface->condition != USB_INTERFACE_BOUND)
 		return;
 	iface->condition = USB_INTERFACE_UNBINDING;
 	/* Release via the driver core only if the interface
 	 * has already been registered
 	 */
 	if (device_is_registered(dev)) {
 		device_release_driver(dev);
 	} else {
 		device_lock(dev);
 		usb_unbind_interface(dev);
 		dev->driver = NULL;
 		device_unlock(dev);
 	}
 }
 EXPORT_SYMBOL_GPL(usb_driver_release_interface);
 /* returns 0 if no match, 1 if match */
 int usb_match_device(struct usb_device *dev, const struct usb_device_id *id)
 {
 	if ((id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
 	    id->idVendor != le16_to_cpu(dev->descriptor.idVendor))
 		return 0;
 	if ((id->match_flags & USB_DEVICE_ID_MATCH_PRODUCT) &&
 	    id->idProduct != le16_to_cpu(dev->descriptor.idProduct))
 		return 0;
 	/* No need to test id->bcdDevice_lo != 0, since 0 is never
 	   greater than any unsigned number. */
 	if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_LO) &&
 	    (id->bcdDevice_lo > le16_to_cpu(dev->descriptor.bcdDevice)))
 		return 0;
 	if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_HI) &&
 	    (id->bcdDevice_hi < le16_to_cpu(dev->descriptor.bcdDevice)))
 		return 0;
 	if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_CLASS) &&
 	    (id->bDeviceClass != dev->descriptor.bDeviceClass))
 		return 0;
 	if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_SUBCLASS) &&
 	    (id->bDeviceSubClass != dev->descriptor.bDeviceSubClass))
 		return 0;
 	if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_PROTOCOL) &&
 	    (id->bDeviceProtocol != dev->descriptor.bDeviceProtocol))
 		return 0;
 	return 1;
 }
 /* returns 0 if no match, 1 if match */
 int usb_match_one_id_intf(struct usb_device *dev,
 			  struct usb_host_interface *intf,
 			  const struct usb_device_id *id)
 {
 	/* The interface class, subclass, protocol and number should never be
 	 * checked for a match if the device class is Vendor Specific,
 	 * unless the match record specifies the Vendor ID. */
 	if (dev->descriptor.bDeviceClass == USB_CLASS_VENDOR_SPEC &&
 			!(id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
 			(id->match_flags & (USB_DEVICE_ID_MATCH_INT_CLASS |
 				USB_DEVICE_ID_MATCH_INT_SUBCLASS |
 				USB_DEVICE_ID_MATCH_INT_PROTOCOL |
 				USB_DEVICE_ID_MATCH_INT_NUMBER)))
 		return 0;
 	if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_CLASS) &&
 	    (id->bInterfaceClass != intf->desc.bInterfaceClass))
 		return 0;
 	if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_SUBCLASS) &&
 	    (id->bInterfaceSubClass != intf->desc.bInterfaceSubClass))
 		return 0;
 	if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_PROTOCOL) &&
 	    (id->bInterfaceProtocol != intf->desc.bInterfaceProtocol))
 		return 0;
 	if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_NUMBER) &&
 	    (id->bInterfaceNumber != intf->desc.bInterfaceNumber))
 		return 0;
 	return 1;
 }
 /* returns 0 if no match, 1 if match */
 int usb_match_one_id(struct usb_interface *interface,
 		     const struct usb_device_id *id)
 {
 	struct usb_host_interface *intf;
 	struct usb_device *dev;
 	/* proc_connectinfo in devio.c may call us with id == NULL. */
 	if (id == NULL)
 		return 0;
 	intf = interface->cur_altsetting;
 	dev = interface_to_usbdev(interface);
 	if (!usb_match_device(dev, id))
 		return 0;
 	return usb_match_one_id_intf(dev, intf, id);
 }
 EXPORT_SYMBOL_GPL(usb_match_one_id);
 /**
  * usb_match_id - find first usb_device_id matching device or interface
  * @interface: the interface of interest
  * @id: array of usb_device_id structures, terminated by zero entry
  *
  * usb_match_id searches an array of usb_device_id's and returns
  * the first one matching the device or interface, or null.
  * This is used when binding (or rebinding) a driver to an interface.
  * Most USB device drivers will use this indirectly, through the usb core,
  * but some layered driver frameworks use it directly.
  * These device tables are exported with MODULE_DEVICE_TABLE, through
  * modutils, to support the driver loading functionality of USB hotplugging.
  *
  * Return: The first matching usb_device_id, or %NULL.
  *
  * What Matches:
  *
  * The "match_flags" element in a usb_device_id controls which
  * members are used.  If the corresponding bit is set, the
  * value in the device_id must match its corresponding member
  * in the device or interface descriptor, or else the device_id
  * does not match.
  *
  * "driver_info" is normally used only by device drivers,
  * but you can create a wildcard "matches anything" usb_device_id
  * as a driver's "modules.usbmap" entry if you provide an id with
  * only a nonzero "driver_info" field.  If you do this, the USB device
  * driver's probe() routine should use additional intelligence to
  * decide whether to bind to the specified interface.
  *
  * What Makes Good usb_device_id Tables:
  *
  * The match algorithm is very simple, so that intelligence in
  * driver selection must come from smart driver id records.
  * Unless you have good reasons to use another selection policy,
  * provide match elements only in related groups, and order match
  * specifiers from specific to general.  Use the macros provided
  * for that purpose if you can.
  *
  * The most specific match specifiers use device descriptor
  * data.  These are commonly used with product-specific matches;
  * the USB_DEVICE macro lets you provide vendor and product IDs,
  * and you can also match against ranges of product revisions.
  * These are widely used for devices with application or vendor
  * specific bDeviceClass values.
  *
  * Matches based on device class/subclass/protocol specifications
  * are slightly more general; use the USB_DEVICE_INFO macro, or
  * its siblings.  These are used with single-function devices
  * where bDeviceClass doesn't specify that each interface has
  * its own class.
  *
  * Matches based on interface class/subclass/protocol are the
  * most general; they let drivers bind to any interface on a
  * multiple-function device.  Use the USB_INTERFACE_INFO
  * macro, or its siblings, to match class-per-interface style
  * devices (as recorded in bInterfaceClass).
  *
  * Note that an entry created by USB_INTERFACE_INFO won't match
  * any interface if the device class is set to Vendor-Specific.
  * This is deliberate; according to the USB spec the meanings of
  * the interface class/subclass/protocol for these devices are also
  * vendor-specific, and hence matching against a standard product
  * class wouldn't work anyway.  If you really want to use an
  * interface-based match for such a device, create a match record
  * that also specifies the vendor ID.  (Unforunately there isn't a
  * standard macro for creating records like this.)
  *
  * Within those groups, remember that not all combinations are
  * meaningful.  For example, don't give a product version range
  * without vendor and product IDs; or specify a protocol without
  * its associated class and subclass.
  */
 const struct usb_device_id *usb_match_id(struct usb_interface *interface,
 					 const struct usb_device_id *id)
 {
 	/* proc_connectinfo in devio.c may call us with id == NULL. */
 	if (id == NULL)
 		return NULL;
 	/* It is important to check that id->driver_info is nonzero,
 	   since an entry that is all zeroes except for a nonzero
 	   id->driver_info is the way to create an entry that
 	   indicates that the driver want to examine every
 	   device and interface. */
 	for (; id->idVendor || id->idProduct || id->bDeviceClass ||
 	       id->bInterfaceClass || id->driver_info; id++) {
 		if (usb_match_one_id(interface, id))
 			return id;
 	}
 	return NULL;
 }
 EXPORT_SYMBOL_GPL(usb_match_id);
 static int usb_device_match(struct device *dev, struct device_driver *drv)
 {
 	/* devices and interfaces are handled separately */
 	if (is_usb_device(dev)) {
 		/* interface drivers never match devices */
 		if (!is_usb_device_driver(drv))
 			return 0;
 		/* TODO: Add real matching code */
 		return 1;
 	} else if (is_usb_interface(dev)) {
 		struct usb_interface *intf;
 		struct usb_driver *usb_drv;
 		const struct usb_device_id *id;
 		/* device drivers never match interfaces */
 		if (is_usb_device_driver(drv))
 			return 0;
 		intf = to_usb_interface(dev);
 		usb_drv = to_usb_driver(drv);
 		id = usb_match_id(intf, usb_drv->id_table);
 		if (id)
 			return 1;
 		id = usb_match_dynamic_id(intf, usb_drv);
 		if (id)
 			return 1;
 	}
 	return 0;
 }
 static int usb_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
 	struct usb_device *usb_dev;
 	if (is_usb_device(dev)) {
 		usb_dev = to_usb_device(dev);
 	} else if (is_usb_interface(dev)) {
 		struct usb_interface *intf = to_usb_interface(dev);
 		usb_dev = interface_to_usbdev(intf);
 	} else {
 		return 0;
 	}
 	if (usb_dev->devnum < 0) {
 		/* driver is often null here; dev_dbg() would oops */
 		pr_debug("usb %s: already deleted?\n", dev_name(dev));
 		return -ENODEV;
 	}
 	if (!usb_dev->bus) {
 		pr_debug("usb %s: bus removed?\n", dev_name(dev));
 		return -ENODEV;
 	}
 	/* per-device configurations are common */
 	if (add_uevent_var(env, "PRODUCT=%x/%x/%x",
 			   le16_to_cpu(usb_dev->descriptor.idVendor),
 			   le16_to_cpu(usb_dev->descriptor.idProduct),
 			   le16_to_cpu(usb_dev->descriptor.bcdDevice)))
 		return -ENOMEM;
 	/* class-based driver binding models */
 	if (add_uevent_var(env, "TYPE=%d/%d/%d",
 			   usb_dev->descriptor.bDeviceClass,
 			   usb_dev->descriptor.bDeviceSubClass,
 			   usb_dev->descriptor.bDeviceProtocol))
 		return -ENOMEM;
 	return 0;
 }
 /**
  * usb_register_device_driver - register a USB device (not interface) driver
  * @new_udriver: USB operations for the device driver
  * @owner: module owner of this driver.
  *
  * Registers a USB device driver with the USB core.  The list of
  * unattached devices will be rescanned whenever a new driver is
  * added, allowing the new driver to attach to any recognized devices.
  *
  * Return: A negative error code on failure and 0 on success.
  */
 int usb_register_device_driver(struct usb_device_driver *new_udriver,
 		struct module *owner)
 {
 	int retval = 0;
 	if (usb_disabled())
 		return -ENODEV;
 	new_udriver->drvwrap.for_devices = 1;
 	new_udriver->drvwrap.driver.name = new_udriver->name;
 	new_udriver->drvwrap.driver.bus = &usb_bus_type;
 	new_udriver->drvwrap.driver.probe = usb_probe_device;
 	new_udriver->drvwrap.driver.remove = usb_unbind_device;
 	new_udriver->drvwrap.driver.owner = owner;
 	retval = driver_register(&new_udriver->drvwrap.driver);
 	if (!retval)
 		pr_info("%s: registered new device driver %s\n",
 			usbcore_name, new_udriver->name);
 	else
 		printk(KERN_ERR "%s: error %d registering device "
 			"	driver %s\n",
 			usbcore_name, retval, new_udriver->name);
 	return retval;
 }
 EXPORT_SYMBOL_GPL(usb_register_device_driver);
 /**
  * usb_deregister_device_driver - unregister a USB device (not interface) driver
  * @udriver: USB operations of the device driver to unregister
  * Context: must be able to sleep
  *
  * Unlinks the specified driver from the internal USB driver list.
  */
 void usb_deregister_device_driver(struct usb_device_driver *udriver)
 {
 	pr_info("%s: deregistering device driver %s\n",
 			usbcore_name, udriver->name);
 	driver_unregister(&udriver->drvwrap.driver);
 }
 EXPORT_SYMBOL_GPL(usb_deregister_device_driver);
 /**
  * usb_register_driver - register a USB interface driver
  * @new_driver: USB operations for the interface driver
  * @owner: module owner of this driver.
  * @mod_name: module name string
  *
  * Registers a USB interface driver with the USB core.  The list of
  * unattached interfaces will be rescanned whenever a new driver is
  * added, allowing the new driver to attach to any recognized interfaces.
  *
  * Return: A negative error code on failure and 0 on success.
  *
  * NOTE: if you want your driver to use the USB major number, you must call
  * usb_register_dev() to enable that functionality.  This function no longer
  * takes care of that.
  */
 int usb_register_driver(struct usb_driver *new_driver, struct module *owner,
 			const char *mod_name)
 {
 	int retval = 0;
 	if (usb_disabled())
 		return -ENODEV;
 	new_driver->drvwrap.for_devices = 0;
 	new_driver->drvwrap.driver.name = new_driver->name;
 	new_driver->drvwrap.driver.bus = &usb_bus_type;
 	new_driver->drvwrap.driver.probe = usb_probe_interface;
 	new_driver->drvwrap.driver.remove = usb_unbind_interface;
 	new_driver->drvwrap.driver.owner = owner;
 	new_driver->drvwrap.driver.mod_name = mod_name;
 	spin_lock_init(&new_driver->dynids.lock);
 	INIT_LIST_HEAD(&new_driver->dynids.list);
 	retval = driver_register(&new_driver->drvwrap.driver);
 	if (retval)
 		goto out;
 	retval = usb_create_newid_files(new_driver);
 	if (retval)
 		goto out_newid;
 	pr_info("%s: registered new interface driver %s\n",
 			usbcore_name, new_driver->name);
 out:
 	return retval;
 out_newid:
 	driver_unregister(&new_driver->drvwrap.driver);
 	printk(KERN_ERR "%s: error %d registering interface "
 			"	driver %s\n",
 			usbcore_name, retval, new_driver->name);
 	goto out;
 }
 EXPORT_SYMBOL_GPL(usb_register_driver);
 /**
  * usb_deregister - unregister a USB interface driver
  * @driver: USB operations of the interface driver to unregister
  * Context: must be able to sleep
  *
  * Unlinks the specified driver from the internal USB driver list.
  *
  * NOTE: If you called usb_register_dev(), you still need to call
  * usb_deregister_dev() to clean up your driver's allocated minor numbers,
  * this * call will no longer do it for you.
  */
 void usb_deregister(struct usb_driver *driver)
 {
 	pr_info("%s: deregistering interface driver %s\n",
 			usbcore_name, driver->name);
 	usb_remove_newid_files(driver);
 	driver_unregister(&driver->drvwrap.driver);
 	usb_free_dynids(driver);
 }
 EXPORT_SYMBOL_GPL(usb_deregister);
 /* Forced unbinding of a USB interface driver, either because
  * it doesn't support pre_reset/post_reset/reset_resume or
  * because it doesn't support suspend/resume.
  *
  * The caller must hold @intf's device's lock, but not @intf's lock.
  */
 void usb_forced_unbind_intf(struct usb_interface *intf)
 {
 	struct usb_driver *driver = to_usb_driver(intf->dev.driver);
 	dev_dbg(&intf->dev, "forced unbind\n");
 	usb_driver_release_interface(driver, intf);
 	/* Mark the interface for later rebinding */
 	intf->needs_binding = 1;
 }
 /*
  * Unbind drivers for @udev's marked interfaces.  These interfaces have
  * the needs_binding flag set, for example by usb_resume_interface().
  *
  * The caller must hold @udev's device lock.
  */
 static void unbind_marked_interfaces(struct usb_device *udev)
 {
 	struct usb_host_config	*config;
 	int			i;
 	struct usb_interface	*intf;
 	config = udev->actconfig;
 	if (config) {
 		for (i = 0; i < config->desc.bNumInterfaces; ++i) {
 			intf = config->interface[i];
 			if (intf->dev.driver && intf->needs_binding)
 				usb_forced_unbind_intf(intf);
 		}
 	}
 }
 /* Delayed forced unbinding of a USB interface driver and scan
  * for rebinding.
  *
  * The caller must hold @intf's device's lock, but not @intf's lock.
  *
  * Note: Rebinds will be skipped if a system sleep transition is in
  * progress and the PM "complete" callback hasn't occurred yet.
  */
 static void usb_rebind_intf(struct usb_interface *intf)
 {
 	int rc;
 	/* Delayed unbind of an existing driver */
 	if (intf->dev.driver)
 		usb_forced_unbind_intf(intf);
 	/* Try to rebind the interface */
 	if (!intf->dev.power.is_prepared) {
 		intf->needs_binding = 0;
 		rc = device_attach(&intf->dev);
 		if (rc < 0)
 			dev_warn(&intf->dev, "rebind failed: %d\n", rc);
 	}
 }
 /*
  * Rebind drivers to @udev's marked interfaces.  These interfaces have
  * the needs_binding flag set.
  *
  * The caller must hold @udev's device lock.
  */
 static void rebind_marked_interfaces(struct usb_device *udev)
 {
 	struct usb_host_config	*config;
 	int			i;
 	struct usb_interface	*intf;
 	config = udev->actconfig;
 	if (config) {
 		for (i = 0; i < config->desc.bNumInterfaces; ++i) {
 			intf = config->interface[i];
 			if (intf->needs_binding)
 				usb_rebind_intf(intf);
 		}
 	}
 }
 /*
  * Unbind all of @udev's marked interfaces and then rebind all of them.
  * This ordering is necessary because some drivers claim several interfaces
  * when they are first probed.
  *
  * The caller must hold @udev's device lock.
  */
 void usb_unbind_and_rebind_marked_interfaces(struct usb_device *udev)
 {
 	unbind_marked_interfaces(udev);
 	rebind_marked_interfaces(udev);
 }
 #ifdef CONFIG_PM
 /* Unbind drivers for @udev's interfaces that don't support suspend/resume
  * There is no check for reset_resume here because it can be determined
  * only during resume whether reset_resume is needed.
  *
  * The caller must hold @udev's device lock.
  */
 static void unbind_no_pm_drivers_interfaces(struct usb_device *udev)
 {
 	struct usb_host_config	*config;
 	int			i;
 	struct usb_interface	*intf;
 	struct usb_driver	*drv;
 	config = udev->actconfig;
 	if (config) {
 		for (i = 0; i < config->desc.bNumInterfaces; ++i) {
 			intf = config->interface[i];
 			if (intf->dev.driver) {
 				drv = to_usb_driver(intf->dev.driver);
 				if (!drv->suspend || !drv->resume)
 					usb_forced_unbind_intf(intf);
 			}
 		}
 	}
 }
 static int usb_suspend_device(struct usb_device *udev, pm_message_t msg)
 {
 	struct usb_device_driver	*udriver;
 	int				status = 0;
 	if (udev->state == USB_STATE_NOTATTACHED ||
 			udev->state == USB_STATE_SUSPENDED)
 		goto done;
 	/* For devices that don't have a driver, we do a generic suspend. */
 	if (udev->dev.driver)
 		udriver = to_usb_device_driver(udev->dev.driver);
 	else {
 		udev->do_remote_wakeup = 0;
 		udriver = &usb_generic_driver;
 	}
 	status = udriver->suspend(udev, msg);
  done:
 	dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
 	return status;
 }
 static int usb_resume_device(struct usb_device *udev, pm_message_t msg)
 {
 	struct usb_device_driver	*udriver;
 	int				status = 0;
 	if (udev->state == USB_STATE_NOTATTACHED)
 		goto done;
 	/* Can't resume it if it doesn't have a driver. */
 	if (udev->dev.driver == NULL) {
 		status = -ENOTCONN;
 		goto done;
 	}
 	/* Non-root devices on a full/low-speed bus must wait for their
 	 * companion high-speed root hub, in case a handoff is needed.
 	 */
 	if (!PMSG_IS_AUTO(msg) && udev->parent && udev->bus->hs_companion)
 		device_pm_wait_for_dev(&udev->dev,
 				&udev->bus->hs_companion->root_hub->dev);
 	if (udev->quirks & USB_QUIRK_RESET_RESUME)
 		udev->reset_resume = 1;
 	udriver = to_usb_device_driver(udev->dev.driver);
 	status = udriver->resume(udev, msg);
  done:
 	dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
 	return status;
 }
 static int usb_suspend_interface(struct usb_device *udev,
 		struct usb_interface *intf, pm_message_t msg)
 {
 	struct usb_driver	*driver;
 	int			status = 0;
 	if (udev->state == USB_STATE_NOTATTACHED ||
 			intf->condition == USB_INTERFACE_UNBOUND)
 		goto done;
 	driver = to_usb_driver(intf->dev.driver);
 	/* at this time we know the driver supports suspend */
 	status = driver->suspend(intf, msg);
 	if (status && !PMSG_IS_AUTO(msg))
 		dev_err(&intf->dev, "suspend error %d\n", status);
  done:
 	dev_vdbg(&intf->dev, "%s: status %d\n", __func__, status);
 	return status;
 }
 static int usb_resume_interface(struct usb_device *udev,
 		struct usb_interface *intf, pm_message_t msg, int reset_resume)
 {
 	struct usb_driver	*driver;
 	int			status = 0;
 	if (udev->state == USB_STATE_NOTATTACHED)
 		goto done;
 	/* Don't let autoresume interfere with unbinding */
 	if (intf->condition == USB_INTERFACE_UNBINDING)
 		goto done;
 	/* Can't resume it if it doesn't have a driver. */
 	if (intf->condition == USB_INTERFACE_UNBOUND) {
 		/* Carry out a deferred switch to altsetting 0 */
 		if (intf->needs_altsetting0 && !intf->dev.power.is_prepared) {
 			usb_set_interface(udev, intf->altsetting[0].
 					desc.bInterfaceNumber, 0);
 			intf->needs_altsetting0 = 0;
 		}
 		goto done;
 	}
 	/* Don't resume if the interface is marked for rebinding */
 	if (intf->needs_binding)
 		goto done;
 	driver = to_usb_driver(intf->dev.driver);
 	if (reset_resume) {
 		if (driver->reset_resume) {
 			status = driver->reset_resume(intf);
 			if (status)
 				dev_err(&intf->dev, "%s error %d\n",
 						"reset_resume", status);
 		} else {
 			intf->needs_binding = 1;
 			dev_dbg(&intf->dev, "no reset_resume for driver %s?\n",
 					driver->name);
 		}
 	} else {
 		status = driver->resume(intf);
 		if (status)
 			dev_err(&intf->dev, "resume error %d\n", status);
 	}
 done:
 	dev_vdbg(&intf->dev, "%s: status %d\n", __func__, status);
 	/* Later we will unbind the driver and/or reprobe, if necessary */
 	return status;
 }
 /**
  * usb_suspend_both - suspend a USB device and its interfaces
  * @udev: the usb_device to suspend
  * @msg: Power Management message describing this state transition
  *
  * This is the central routine for suspending USB devices.  It calls the
  * suspend methods for all the interface drivers in @udev and then calls
  * the suspend method for @udev itself.  When the routine is called in
  * autosuspend, if an error occurs at any stage, all the interfaces
  * which were suspended are resumed so that they remain in the same
  * state as the device, but when called from system sleep, all error
  * from suspend methods of interfaces and the non-root-hub device itself
  * are simply ignored, so all suspended interfaces are only resumed
  * to the device's state when @udev is root-hub and its suspend method
  * returns failure.
  *
  * Autosuspend requests originating from a child device or an interface
  * driver may be made without the protection of @udev's device lock, but
  * all other suspend calls will hold the lock.  Usbcore will insure that
  * method calls do not arrive during bind, unbind, or reset operations.
  * However drivers must be prepared to handle suspend calls arriving at
  * unpredictable times.
  *
  * This routine can run only in process context.
  *
  * Return: 0 if the suspend succeeded.
  */
 static int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
 {
 	int			status = 0;
 	int			i = 0, n = 0;
 	struct usb_interface	*intf;
 	if (udev->state == USB_STATE_NOTATTACHED ||
 			udev->state == USB_STATE_SUSPENDED)
 		goto done;
 	/* Suspend all the interfaces and then udev itself */
 	if (udev->actconfig) {
 		n = udev->actconfig->desc.bNumInterfaces;
 		for (i = n - 1; i >= 0; --i) {
 			intf = udev->actconfig->interface[i];
 			status = usb_suspend_interface(udev, intf, msg);
 			/* Ignore errors during system sleep transitions */
 			if (!PMSG_IS_AUTO(msg))
 				status = 0;
 			if (status != 0)
 				break;
 		}
 	}
 	if (status == 0) {
 		status = usb_suspend_device(udev, msg);
 		/*
 		 * Ignore errors from non-root-hub devices during
 		 * system sleep transitions.  For the most part,
 		 * these devices should go to low power anyway when
 		 * the entire bus is suspended.
 		 */
 		if (udev->parent && !PMSG_IS_AUTO(msg))
 			status = 0;
 	}
 	/* If the suspend failed, resume interfaces that did get suspended */
 	if (status != 0) {
 		if (udev->actconfig) {
 			msg.event ^= (PM_EVENT_SUSPEND | PM_EVENT_RESUME);
 			while (++i < n) {
 				intf = udev->actconfig->interface[i];
 				usb_resume_interface(udev, intf, msg, 0);
 			}
 		}
 	/* If the suspend succeeded then prevent any more URB submissions
 	 * and flush any outstanding URBs.
 	 */
 	} else {
 		udev->can_submit = 0;
 		for (i = 0; i < 16; ++i) {
 			usb_hcd_flush_endpoint(udev, udev->ep_out[i]);
 			usb_hcd_flush_endpoint(udev, udev->ep_in[i]);
 		}
 	}
  done:
 	dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
 	return status;
 }
 /**
  * usb_resume_both - resume a USB device and its interfaces
  * @udev: the usb_device to resume
  * @msg: Power Management message describing this state transition
  *
  * This is the central routine for resuming USB devices.  It calls the
  * the resume method for @udev and then calls the resume methods for all
  * the interface drivers in @udev.
  *
  * Autoresume requests originating from a child device or an interface
  * driver may be made without the protection of @udev's device lock, but
  * all other resume calls will hold the lock.  Usbcore will insure that
  * method calls do not arrive during bind, unbind, or reset operations.
  * However drivers must be prepared to handle resume calls arriving at
  * unpredictable times.
  *
  * This routine can run only in process context.
  *
  * Return: 0 on success.
  */
 static int usb_resume_both(struct usb_device *udev, pm_message_t msg)
 {
 	int			status = 0;
 	int			i;
 	struct usb_interface	*intf;
 	if (udev->state == USB_STATE_NOTATTACHED) {
 		status = -ENODEV;
 		goto done;
 	}
 	udev->can_submit = 1;
 	/* Resume the device */
 	if (udev->state == USB_STATE_SUSPENDED || udev->reset_resume)
 		status = usb_resume_device(udev, msg);
 	/* Resume the interfaces */
 	if (status == 0 && udev->actconfig) {
 		for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
 			intf = udev->actconfig->interface[i];
 			usb_resume_interface(udev, intf, msg,
 					udev->reset_resume);
 		}
 	}
 	usb_mark_last_busy(udev);
  done:
 	dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
 	if (!status)
 		udev->reset_resume = 0;
 	return status;
 }
 static void choose_wakeup(struct usb_device *udev, pm_message_t msg)
 {
 	int	w;
 	/* Remote wakeup is needed only when we actually go to sleep.
 	 * For things like FREEZE and QUIESCE, if the device is already
 	 * autosuspended then its current wakeup setting is okay.
 	 */
 	if (msg.event == PM_EVENT_FREEZE || msg.event == PM_EVENT_QUIESCE) {
 		if (udev->state != USB_STATE_SUSPENDED)
 			udev->do_remote_wakeup = 0;
 		return;
 	}
 	/* Enable remote wakeup if it is allowed, even if no interface drivers
 	 * actually want it.
 	 */
 	w = device_may_wakeup(&udev->dev);
 	/* If the device is autosuspended with the wrong wakeup setting,
 	 * autoresume now so the setting can be changed.
 	 */
 	if (udev->state == USB_STATE_SUSPENDED && w != udev->do_remote_wakeup)
 		pm_runtime_resume(&udev->dev);
 	udev->do_remote_wakeup = w;
 }
 /* The device lock is held by the PM core */
 int usb_suspend(struct device *dev, pm_message_t msg)
 {
 	struct usb_device	*udev = to_usb_device(dev);
 	unbind_no_pm_drivers_interfaces(udev);
 	/* From now on we are sure all drivers support suspend/resume
 	 * but not necessarily reset_resume()
 	 * so we may still need to unbind and rebind upon resume
 	 */
 	choose_wakeup(udev, msg);
 	return usb_suspend_both(udev, msg);
 }
 /* The device lock is held by the PM core */
 int usb_resume_complete(struct device *dev)
 {
 	struct usb_device *udev = to_usb_device(dev);
 	/* For PM complete calls, all we do is rebind interfaces
 	 * whose needs_binding flag is set
 	 */
 	if (udev->state != USB_STATE_NOTATTACHED)
 		rebind_marked_interfaces(udev);
 	return 0;
 }
 /* The device lock is held by the PM core */
 int usb_resume(struct device *dev, pm_message_t msg)
 {
 	struct usb_device	*udev = to_usb_device(dev);
 	int			status;
 	/* For all calls, take the device back to full power and
 	 * tell the PM core in case it was autosuspended previously.
 	 * Unbind the interfaces that will need rebinding later,
 	 * because they fail to support reset_resume.
 	 * (This can't be done in usb_resume_interface()
 	 * above because it doesn't own the right set of locks.)
 	 */
 	status = usb_resume_both(udev, msg);
 	if (status == 0) {
 		pm_runtime_disable(dev);
 		pm_runtime_set_active(dev);
 		pm_runtime_enable(dev);
 		unbind_marked_interfaces(udev);
 	}
 	/* Avoid PM error messages for devices disconnected while suspended
 	 * as we'll display regular disconnect messages just a bit later.
 	 */
 	if (status == -ENODEV || status == -ESHUTDOWN)
 		status = 0;
 	return status;
 }
 #endif /* CONFIG_PM */
 #ifdef CONFIG_PM_RUNTIME
 /**
  * usb_enable_autosuspend - allow a USB device to be autosuspended
  * @udev: the USB device which may be autosuspended
  *
  * This routine allows @udev to be autosuspended.  An autosuspend won't
  * take place until the autosuspend_delay has elapsed and all the other
  * necessary conditions are satisfied.
  *
  * The caller must hold @udev's device lock.
  */
 void usb_enable_autosuspend(struct usb_device *udev)
 {
 	pm_runtime_allow(&udev->dev);
 }
 EXPORT_SYMBOL_GPL(usb_enable_autosuspend);
 /**
  * usb_disable_autosuspend - prevent a USB device from being autosuspended
  * @udev: the USB device which may not be autosuspended
  *
  * This routine prevents @udev from being autosuspended and wakes it up
  * if it is already autosuspended.
  *
  * The caller must hold @udev's device lock.
  */
 void usb_disable_autosuspend(struct usb_device *udev)
 {
 	pm_runtime_forbid(&udev->dev);
 }
 EXPORT_SYMBOL_GPL(usb_disable_autosuspend);
 /**
  * usb_autosuspend_device - delayed autosuspend of a USB device and its interfaces
  * @udev: the usb_device to autosuspend
  *
  * This routine should be called when a core subsystem is finished using
  * @udev and wants to allow it to autosuspend.  Examples would be when
  * @udev's device file in usbfs is closed or after a configuration change.
  *
  * @udev's usage counter is decremented; if it drops to 0 and all the
  * interfaces are inactive then a delayed autosuspend will be attempted.
  * The attempt may fail (see autosuspend_check()).
  *
  * The caller must hold @udev's device lock.
  *
  * This routine can run only in process context.
  */
 void usb_autosuspend_device(struct usb_device *udev)
 {
 	int	status;
 	usb_mark_last_busy(udev);
 	status = pm_runtime_put_sync_autosuspend(&udev->dev);
 	dev_vdbg(&udev->dev, "%s: cnt %d -> %d\n",
 			__func__, atomic_read(&udev->dev.power.usage_count),
 			status);
 }
 /**
  * usb_autoresume_device - immediately autoresume a USB device and its interfaces
  * @udev: the usb_device to autoresume
  *
  * This routine should be called when a core subsystem wants to use @udev
  * and needs to guarantee that it is not suspended.  No autosuspend will
  * occur until usb_autosuspend_device() is called.  (Note that this will
  * not prevent suspend events originating in the PM core.)  Examples would
  * be when @udev's device file in usbfs is opened or when a remote-wakeup
  * request is received.
  *
  * @udev's usage counter is incremented to prevent subsequent autosuspends.
  * However if the autoresume fails then the usage counter is re-decremented.
  *
  * The caller must hold @udev's device lock.
  *
  * This routine can run only in process context.
  *
  * Return: 0 on success. A negative error code otherwise.
  */
 int usb_autoresume_device(struct usb_device *udev)
 {
 	int	status;
 	status = pm_runtime_get_sync(&udev->dev);
 	if (status < 0)
 		pm_runtime_put_sync(&udev->dev);
 	dev_vdbg(&udev->dev, "%s: cnt %d -> %d\n",
 			__func__, atomic_read(&udev->dev.power.usage_count),
 			status);
 	if (status > 0)
 		status = 0;
 	return status;
 }
 /**
  * usb_autopm_put_interface - decrement a USB interface's PM-usage counter
  * @intf: the usb_interface whose counter should be decremented
  *
  * This routine should be called by an interface driver when it is
  * finished using @intf and wants to allow it to autosuspend.  A typical
  * example would be a character-device driver when its device file is
  * closed.
  *
  * The routine decrements @intf's usage counter.  When the counter reaches
  * 0, a delayed autosuspend request for @intf's device is attempted.  The
  * attempt may fail (see autosuspend_check()).
  *
  * This routine can run only in process context.
  */
 void usb_autopm_put_interface(struct usb_interface *intf)
 {
 	struct usb_device	*udev = interface_to_usbdev(intf);
 	int			status;
 	usb_mark_last_busy(udev);
 	atomic_dec(&intf->pm_usage_cnt);
 	status = pm_runtime_put_sync(&intf->dev);
 	dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
 			__func__, atomic_read(&intf->dev.power.usage_count),
 			status);
 }
 EXPORT_SYMBOL_GPL(usb_autopm_put_interface);
 /**
  * usb_autopm_put_interface_async - decrement a USB interface's PM-usage counter
  * @intf: the usb_interface whose counter should be decremented
  *
  * This routine does much the same thing as usb_autopm_put_interface():
  * It decrements @intf's usage counter and schedules a delayed
  * autosuspend request if the counter is <= 0.  The difference is that it
  * does not perform any synchronization; callers should hold a private
  * lock and handle all synchronization issues themselves.
  *
  * Typically a driver would call this routine during an URB's completion
  * handler, if no more URBs were pending.
  *
  * This routine can run in atomic context.
  */
 void usb_autopm_put_interface_async(struct usb_interface *intf)
 {
 	struct usb_device	*udev = interface_to_usbdev(intf);
 	int			status;
 	usb_mark_last_busy(udev);
 	atomic_dec(&intf->pm_usage_cnt);
 	status = pm_runtime_put(&intf->dev);
 	dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
 			__func__, atomic_read(&intf->dev.power.usage_count),
 			status);
 }
 EXPORT_SYMBOL_GPL(usb_autopm_put_interface_async);
 /**
  * usb_autopm_put_interface_no_suspend - decrement a USB interface's PM-usage counter
  * @intf: the usb_interface whose counter should be decremented
  *
  * This routine decrements @intf's usage counter but does not carry out an
  * autosuspend.
  *
  * This routine can run in atomic context.
  */
 void usb_autopm_put_interface_no_suspend(struct usb_interface *intf)
 {
 	struct usb_device	*udev = interface_to_usbdev(intf);
 	usb_mark_last_busy(udev);
 	atomic_dec(&intf->pm_usage_cnt);
 	pm_runtime_put_noidle(&intf->dev);
 }
 EXPORT_SYMBOL_GPL(usb_autopm_put_interface_no_suspend);
 /**
  * usb_autopm_get_interface - increment a USB interface's PM-usage counter
  * @intf: the usb_interface whose counter should be incremented
  *
  * This routine should be called by an interface driver when it wants to
  * use @intf and needs to guarantee that it is not suspended.  In addition,
  * the routine prevents @intf from being autosuspended subsequently.  (Note
  * that this will not prevent suspend events originating in the PM core.)
  * This prevention will persist until usb_autopm_put_interface() is called
  * or @intf is unbound.  A typical example would be a character-device
  * driver when its device file is opened.
  *
  * @intf's usage counter is incremented to prevent subsequent autosuspends.
  * However if the autoresume fails then the counter is re-decremented.
  *
  * This routine can run only in process context.
  *
  * Return: 0 on success.
  */
 int usb_autopm_get_interface(struct usb_interface *intf)
 {
 	int	status;
 	status = pm_runtime_get_sync(&intf->dev);
 	if (status < 0)
 		pm_runtime_put_sync(&intf->dev);
 	else
 		atomic_inc(&intf->pm_usage_cnt);
 	dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
 			__func__, atomic_read(&intf->dev.power.usage_count),
 			status);
 	if (status > 0)
 		status = 0;
 	return status;
 }
 EXPORT_SYMBOL_GPL(usb_autopm_get_interface);
 /**
  * usb_autopm_get_interface_async - increment a USB interface's PM-usage counter
  * @intf: the usb_interface whose counter should be incremented
  *
  * This routine does much the same thing as
  * usb_autopm_get_interface(): It increments @intf's usage counter and
  * queues an autoresume request if the device is suspended.  The
  * differences are that it does not perform any synchronization (callers
  * should hold a private lock and handle all synchronization issues
  * themselves), and it does not autoresume the device directly (it only
  * queues a request).  After a successful call, the device may not yet be
  * resumed.
  *
  * This routine can run in atomic context.
  *
  * Return: 0 on success. A negative error code otherwise.
  */
 int usb_autopm_get_interface_async(struct usb_interface *intf)
 {
 	int	status;
 	status = pm_runtime_get(&intf->dev);
 	if (status < 0 && status != -EINPROGRESS)
 		pm_runtime_put_noidle(&intf->dev);
 	else
 		atomic_inc(&intf->pm_usage_cnt);
 	dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
 			__func__, atomic_read(&intf->dev.power.usage_count),
 			status);
 	if (status > 0 || status == -EINPROGRESS)
 		status = 0;
 	return status;
 }
 EXPORT_SYMBOL_GPL(usb_autopm_get_interface_async);
 /**
  * usb_autopm_get_interface_no_resume - increment a USB interface's PM-usage counter
  * @intf: the usb_interface whose counter should be incremented
  *
  * This routine increments @intf's usage counter but does not carry out an
  * autoresume.
  *
  * This routine can run in atomic context.
  */
 void usb_autopm_get_interface_no_resume(struct usb_interface *intf)
 {
 	struct usb_device	*udev = interface_to_usbdev(intf);
 	usb_mark_last_busy(udev);
 	atomic_inc(&intf->pm_usage_cnt);
 	pm_runtime_get_noresume(&intf->dev);
 }
 EXPORT_SYMBOL_GPL(usb_autopm_get_interface_no_resume);
 /* Internal routine to check whether we may autosuspend a device. */
 static int autosuspend_check(struct usb_device *udev)
 {
 	int			w, i;
 	struct usb_interface	*intf;
 	/* Fail if autosuspend is disabled, or any interfaces are in use, or
 	 * any interface drivers require remote wakeup but it isn't available.
 	 */
 	w = 0;
 	if (udev->actconfig) {
 		for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
 			intf = udev->actconfig->interface[i];
 			/* We don't need to check interfaces that are
 			 * disabled for runtime PM.  Either they are unbound
 			 * or else their drivers don't support autosuspend
 			 * and so they are permanently active.
 			 */
 			if (intf->dev.power.disable_depth)
 				continue;
 			if (atomic_read(&intf->dev.power.usage_count) > 0)
 				return -EBUSY;
 			w |= intf->needs_remote_wakeup;
 			/* Don't allow autosuspend if the device will need
 			 * a reset-resume and any of its interface drivers
 			 * doesn't include support or needs remote wakeup.
 			 */
 			if (udev->quirks & USB_QUIRK_RESET_RESUME) {
 				struct usb_driver *driver;
 				driver = to_usb_driver(intf->dev.driver);
 				if (!driver->reset_resume ||
 						intf->needs_remote_wakeup)
 					return -EOPNOTSUPP;
 			}
 		}
 	}
 	if (w && !device_can_wakeup(&udev->dev)) {
 		dev_dbg(&udev->dev, "remote wakeup needed for autosuspend\n");
 		return -EOPNOTSUPP;
 	}
 	udev->do_remote_wakeup = w;
 	return 0;
 }
 int usb_runtime_suspend(struct device *dev)
 {
 	struct usb_device	*udev = to_usb_device(dev);
 	int			status;
 	/* A USB device can be suspended if it passes the various autosuspend
 	 * checks.  Runtime suspend for a USB device means suspending all the
 	 * interfaces and then the device itself.
 	 */
 	if (autosuspend_check(udev) != 0)
 		return -EAGAIN;
 	status = usb_suspend_both(udev, PMSG_AUTO_SUSPEND);
 	/* Allow a retry if autosuspend failed temporarily */
 	if (status == -EAGAIN || status == -EBUSY)
 		usb_mark_last_busy(udev);
-	/* The PM core reacts badly unless the return code is 0,
+	/*
-	 * -EAGAIN, or -EBUSY, so always return -EBUSY on an error.
+	 * The PM core reacts badly unless the return code is 0,
+	 * -EAGAIN, or -EBUSY, so always return -EBUSY on an error
+	 * (except for root hubs, because they don't suspend through
+	 * an upstream port like other USB devices).
 	 */
-	if (status != 0)
+	if (status != 0 && udev->parent)
 		return -EBUSY;
 	return status;
 }
 int usb_runtime_resume(struct device *dev)
 {
 	struct usb_device	*udev = to_usb_device(dev);
 	int			status;
 	/* Runtime resume for a USB device means resuming both the device
 	 * and all its interfaces.
 	 */
 	status = usb_resume_both(udev, PMSG_AUTO_RESUME);
 	return status;
 }
 int usb_runtime_idle(struct device *dev)
 {
 	struct usb_device	*udev = to_usb_device(dev);
 	/* An idle USB device can be suspended if it passes the various
 	 * autosuspend checks.
 	 */
 	if (autosuspend_check(udev) == 0)
 		pm_runtime_autosuspend(dev);
 	/* Tell the core not to suspend it, though. */
 	return -EBUSY;
 }
 int usb_set_usb2_hardware_lpm(struct usb_device *udev, int enable)
 {
 	struct usb_hcd *hcd = bus_to_hcd(udev->bus);
 	int ret = -EPERM;
 	if (enable && !udev->usb2_hw_lpm_allowed)
 		return 0;
 	if (hcd->driver->set_usb2_hw_lpm) {
 		ret = hcd->driver->set_usb2_hw_lpm(hcd, udev, enable);
 		if (!ret)
 			udev->usb2_hw_lpm_enabled = enable;
 	}
 	return ret;
 }
 #endif /* CONFIG_PM_RUNTIME */
 struct bus_type usb_bus_type = {
 	.name =		"usb",
 	.match =	usb_device_match,
 	.uevent =	usb_uevent,
 };

drivers/usb/core/hub.c

Diff comments View file @ 8ee7a33

 /*
  * USB hub driver.
  *
  * (C) Copyright 1999 Linus Torvalds
  * (C) Copyright 1999 Johannes Erdfelt
  * (C) Copyright 1999 Gregory P. Smith
  * (C) Copyright 2001 Brad Hards (bhards@bigpond.net.au)
  *
  */
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/completion.h>
 #include <linux/sched.h>
 #include <linux/list.h>
 #include <linux/slab.h>
 #include <linux/ioctl.h>
 #include <linux/usb.h>
 #include <linux/usbdevice_fs.h>
 #include <linux/usb/hcd.h>
 #include <linux/usb/otg.h>
 #include <linux/usb/quirks.h>
 #include <linux/kthread.h>
 #include <linux/mutex.h>
 #include <linux/freezer.h>
 #include <linux/random.h>
 #include <linux/pm_qos.h>
 #include <asm/uaccess.h>
 #include <asm/byteorder.h>
 #include "hub.h"
 #define USB_VENDOR_GENESYS_LOGIC		0x05e3
 #define HUB_QUIRK_CHECK_PORT_AUTOSUSPEND	0x01
 static inline int hub_is_superspeed(struct usb_device *hdev)
 {
 	return (hdev->descriptor.bDeviceProtocol == USB_HUB_PR_SS);
 }
 /* Protect struct usb_device->state and ->children members
  * Note: Both are also protected by ->dev.sem, except that ->state can
  * change to USB_STATE_NOTATTACHED even when the semaphore isn't held. */
 static DEFINE_SPINLOCK(device_state_lock);
 /* khubd's worklist and its lock */
 static DEFINE_SPINLOCK(hub_event_lock);
 static LIST_HEAD(hub_event_list);	/* List of hubs needing servicing */
 /* Wakes up khubd */
 static DECLARE_WAIT_QUEUE_HEAD(khubd_wait);
 static struct task_struct *khubd_task;
 /* cycle leds on hubs that aren't blinking for attention */
 static bool blinkenlights = 0;
 module_param (blinkenlights, bool, S_IRUGO);
 MODULE_PARM_DESC (blinkenlights, "true to cycle leds on hubs");
 /*
  * Device SATA8000 FW1.0 from DATAST0R Technology Corp requires about
  * 10 seconds to send reply for the initial 64-byte descriptor request.
  */
 /* define initial 64-byte descriptor request timeout in milliseconds */
 static int initial_descriptor_timeout = USB_CTRL_GET_TIMEOUT;
 module_param(initial_descriptor_timeout, int, S_IRUGO|S_IWUSR);
 MODULE_PARM_DESC(initial_descriptor_timeout,
 		"initial 64-byte descriptor request timeout in milliseconds "
 		"(default 5000 - 5.0 seconds)");
 /*
  * As of 2.6.10 we introduce a new USB device initialization scheme which
  * closely resembles the way Windows works.  Hopefully it will be compatible
  * with a wider range of devices than the old scheme.  However some previously
  * working devices may start giving rise to "device not accepting address"
  * errors; if that happens the user can try the old scheme by adjusting the
  * following module parameters.
  *
  * For maximum flexibility there are two boolean parameters to control the
  * hub driver's behavior.  On the first initialization attempt, if the
  * "old_scheme_first" parameter is set then the old scheme will be used,
  * otherwise the new scheme is used.  If that fails and "use_both_schemes"
  * is set, then the driver will make another attempt, using the other scheme.
  */
 static bool old_scheme_first = 0;
 module_param(old_scheme_first, bool, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(old_scheme_first,
 		 "start with the old device initialization scheme");
 static bool use_both_schemes = 1;
 module_param(use_both_schemes, bool, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(use_both_schemes,
 		"try the other device initialization scheme if the "
 		"first one fails");
 /* Mutual exclusion for EHCI CF initialization.  This interferes with
  * port reset on some companion controllers.
  */
 DECLARE_RWSEM(ehci_cf_port_reset_rwsem);
 EXPORT_SYMBOL_GPL(ehci_cf_port_reset_rwsem);
 #define HUB_DEBOUNCE_TIMEOUT	2000
 #define HUB_DEBOUNCE_STEP	  25
 #define HUB_DEBOUNCE_STABLE	 100
 static int usb_reset_and_verify_device(struct usb_device *udev);
 static inline char *portspeed(struct usb_hub *hub, int portstatus)
 {
 	if (hub_is_superspeed(hub->hdev))
 		return "5.0 Gb/s";
 	if (portstatus & USB_PORT_STAT_HIGH_SPEED)
 		return "480 Mb/s";
 	else if (portstatus & USB_PORT_STAT_LOW_SPEED)
 		return "1.5 Mb/s";
 	else
 		return "12 Mb/s";
 }
 /* Note that hdev or one of its children must be locked! */
 struct usb_hub *usb_hub_to_struct_hub(struct usb_device *hdev)
 {
 	if (!hdev || !hdev->actconfig || !hdev->maxchild)
 		return NULL;
 	return usb_get_intfdata(hdev->actconfig->interface[0]);
 }
 static int usb_device_supports_lpm(struct usb_device *udev)
 {
 	/* USB 2.1 (and greater) devices indicate LPM support through
 	 * their USB 2.0 Extended Capabilities BOS descriptor.
 	 */
 	if (udev->speed == USB_SPEED_HIGH) {
 		if (udev->bos->ext_cap &&
 			(USB_LPM_SUPPORT &
 			 le32_to_cpu(udev->bos->ext_cap->bmAttributes)))
 			return 1;
 		return 0;
 	}
 	/*
 	 * According to the USB 3.0 spec, all USB 3.0 devices must support LPM.
 	 * However, there are some that don't, and they set the U1/U2 exit
 	 * latencies to zero.
 	 */
 	if (!udev->bos->ss_cap) {
 		dev_info(&udev->dev, "No LPM exit latency info found, disabling LPM.\n");
 		return 0;
 	}
 	if (udev->bos->ss_cap->bU1devExitLat == 0 &&
 			udev->bos->ss_cap->bU2DevExitLat == 0) {
 		if (udev->parent)
 			dev_info(&udev->dev, "LPM exit latency is zeroed, disabling LPM.\n");
 		else
 			dev_info(&udev->dev, "We don't know the algorithms for LPM for this host, disabling LPM.\n");
 		return 0;
 	}
 	if (!udev->parent || udev->parent->lpm_capable)
 		return 1;
 	return 0;
 }
 /*
  * Set the Maximum Exit Latency (MEL) for the host to initiate a transition from
  * either U1 or U2.
  */
 static void usb_set_lpm_mel(struct usb_device *udev,
 		struct usb3_lpm_parameters *udev_lpm_params,
 		unsigned int udev_exit_latency,
 		struct usb_hub *hub,
 		struct usb3_lpm_parameters *hub_lpm_params,
 		unsigned int hub_exit_latency)
 {
 	unsigned int total_mel;
 	unsigned int device_mel;
 	unsigned int hub_mel;
 	/*
 	 * Calculate the time it takes to transition all links from the roothub
 	 * to the parent hub into U0.  The parent hub must then decode the
 	 * packet (hub header decode latency) to figure out which port it was
 	 * bound for.
 	 *
 	 * The Hub Header decode latency is expressed in 0.1us intervals (0x1
 	 * means 0.1us).  Multiply that by 100 to get nanoseconds.
 	 */
 	total_mel = hub_lpm_params->mel +
 		(hub->descriptor->u.ss.bHubHdrDecLat * 100);
 	/*
 	 * How long will it take to transition the downstream hub's port into
 	 * U0?  The greater of either the hub exit latency or the device exit
 	 * latency.
 	 *
 	 * The BOS U1/U2 exit latencies are expressed in 1us intervals.
 	 * Multiply that by 1000 to get nanoseconds.
 	 */
 	device_mel = udev_exit_latency * 1000;
 	hub_mel = hub_exit_latency * 1000;
 	if (device_mel > hub_mel)
 		total_mel += device_mel;
 	else
 		total_mel += hub_mel;
 	udev_lpm_params->mel = total_mel;
 }
 /*
  * Set the maximum Device to Host Exit Latency (PEL) for the device to initiate
  * a transition from either U1 or U2.
  */
 static void usb_set_lpm_pel(struct usb_device *udev,
 		struct usb3_lpm_parameters *udev_lpm_params,
 		unsigned int udev_exit_latency,
 		struct usb_hub *hub,
 		struct usb3_lpm_parameters *hub_lpm_params,
 		unsigned int hub_exit_latency,
 		unsigned int port_to_port_exit_latency)
 {
 	unsigned int first_link_pel;
 	unsigned int hub_pel;
 	/*
 	 * First, the device sends an LFPS to transition the link between the
 	 * device and the parent hub into U0.  The exit latency is the bigger of
 	 * the device exit latency or the hub exit latency.
 	 */
 	if (udev_exit_latency > hub_exit_latency)
 		first_link_pel = udev_exit_latency * 1000;
 	else
 		first_link_pel = hub_exit_latency * 1000;
 	/*
 	 * When the hub starts to receive the LFPS, there is a slight delay for
 	 * it to figure out that one of the ports is sending an LFPS.  Then it
 	 * will forward the LFPS to its upstream link.  The exit latency is the
 	 * delay, plus the PEL that we calculated for this hub.
 	 */
 	hub_pel = port_to_port_exit_latency * 1000 + hub_lpm_params->pel;
 	/*
 	 * According to figure C-7 in the USB 3.0 spec, the PEL for this device
 	 * is the greater of the two exit latencies.
 	 */
 	if (first_link_pel > hub_pel)
 		udev_lpm_params->pel = first_link_pel;
 	else
 		udev_lpm_params->pel = hub_pel;
 }
 /*
  * Set the System Exit Latency (SEL) to indicate the total worst-case time from
  * when a device initiates a transition to U0, until when it will receive the
  * first packet from the host controller.
  *
  * Section C.1.5.1 describes the four components to this:
  *  - t1: device PEL
  *  - t2: time for the ERDY to make it from the device to the host.
  *  - t3: a host-specific delay to process the ERDY.
  *  - t4: time for the packet to make it from the host to the device.
  *
  * t3 is specific to both the xHCI host and the platform the host is integrated
  * into.  The Intel HW folks have said it's negligible, FIXME if a different
  * vendor says otherwise.
  */
 static void usb_set_lpm_sel(struct usb_device *udev,
 		struct usb3_lpm_parameters *udev_lpm_params)
 {
 	struct usb_device *parent;
 	unsigned int num_hubs;
 	unsigned int total_sel;
 	/* t1 = device PEL */
 	total_sel = udev_lpm_params->pel;
 	/* How many external hubs are in between the device & the root port. */
 	for (parent = udev->parent, num_hubs = 0; parent->parent;
 			parent = parent->parent)
 		num_hubs++;
 	/* t2 = 2.1us + 250ns * (num_hubs - 1) */
 	if (num_hubs > 0)
 		total_sel += 2100 + 250 * (num_hubs - 1);
 	/* t4 = 250ns * num_hubs */
 	total_sel += 250 * num_hubs;
 	udev_lpm_params->sel = total_sel;
 }
 static void usb_set_lpm_parameters(struct usb_device *udev)
 {
 	struct usb_hub *hub;
 	unsigned int port_to_port_delay;
 	unsigned int udev_u1_del;
 	unsigned int udev_u2_del;
 	unsigned int hub_u1_del;
 	unsigned int hub_u2_del;
 	if (!udev->lpm_capable || udev->speed != USB_SPEED_SUPER)
 		return;
 	hub = usb_hub_to_struct_hub(udev->parent);
 	/* It doesn't take time to transition the roothub into U0, since it
 	 * doesn't have an upstream link.
 	 */
 	if (!hub)
 		return;
 	udev_u1_del = udev->bos->ss_cap->bU1devExitLat;
 	udev_u2_del = le16_to_cpu(udev->bos->ss_cap->bU2DevExitLat);
 	hub_u1_del = udev->parent->bos->ss_cap->bU1devExitLat;
 	hub_u2_del = le16_to_cpu(udev->parent->bos->ss_cap->bU2DevExitLat);
 	usb_set_lpm_mel(udev, &udev->u1_params, udev_u1_del,
 			hub, &udev->parent->u1_params, hub_u1_del);
 	usb_set_lpm_mel(udev, &udev->u2_params, udev_u2_del,
 			hub, &udev->parent->u2_params, hub_u2_del);
 	/*
 	 * Appendix C, section C.2.2.2, says that there is a slight delay from
 	 * when the parent hub notices the downstream port is trying to
 	 * transition to U0 to when the hub initiates a U0 transition on its
 	 * upstream port.  The section says the delays are tPort2PortU1EL and
 	 * tPort2PortU2EL, but it doesn't define what they are.
 	 *
 	 * The hub chapter, sections 10.4.2.4 and 10.4.2.5 seem to be talking
 	 * about the same delays.  Use the maximum delay calculations from those
 	 * sections.  For U1, it's tHubPort2PortExitLat, which is 1us max.  For
 	 * U2, it's tHubPort2PortExitLat + U2DevExitLat - U1DevExitLat.  I
 	 * assume the device exit latencies they are talking about are the hub
 	 * exit latencies.
 	 *
 	 * What do we do if the U2 exit latency is less than the U1 exit
 	 * latency?  It's possible, although not likely...
 	 */
 	port_to_port_delay = 1;
 	usb_set_lpm_pel(udev, &udev->u1_params, udev_u1_del,
 			hub, &udev->parent->u1_params, hub_u1_del,
 			port_to_port_delay);
 	if (hub_u2_del > hub_u1_del)
 		port_to_port_delay = 1 + hub_u2_del - hub_u1_del;
 	else
 		port_to_port_delay = 1 + hub_u1_del;
 	usb_set_lpm_pel(udev, &udev->u2_params, udev_u2_del,
 			hub, &udev->parent->u2_params, hub_u2_del,
 			port_to_port_delay);
 	/* Now that we've got PEL, calculate SEL. */
 	usb_set_lpm_sel(udev, &udev->u1_params);
 	usb_set_lpm_sel(udev, &udev->u2_params);
 }
 /* USB 2.0 spec Section 11.24.4.5 */
 static int get_hub_descriptor(struct usb_device *hdev, void *data)
 {
 	int i, ret, size;
 	unsigned dtype;
 	if (hub_is_superspeed(hdev)) {
 		dtype = USB_DT_SS_HUB;
 		size = USB_DT_SS_HUB_SIZE;
 	} else {
 		dtype = USB_DT_HUB;
 		size = sizeof(struct usb_hub_descriptor);
 	}
 	for (i = 0; i < 3; i++) {
 		ret = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
 			USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB,
 			dtype << 8, 0, data, size,
 			USB_CTRL_GET_TIMEOUT);
 		if (ret >= (USB_DT_HUB_NONVAR_SIZE + 2))
 			return ret;
 	}
 	return -EINVAL;
 }
 /*
  * USB 2.0 spec Section 11.24.2.1
  */
 static int clear_hub_feature(struct usb_device *hdev, int feature)
 {
 	return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
 		USB_REQ_CLEAR_FEATURE, USB_RT_HUB, feature, 0, NULL, 0, 1000);
 }
 /*
  * USB 2.0 spec Section 11.24.2.2
  */
 int usb_clear_port_feature(struct usb_device *hdev, int port1, int feature)
 {
 	return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
 		USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature, port1,
 		NULL, 0, 1000);
 }
 /*
  * USB 2.0 spec Section 11.24.2.13
  */
 static int set_port_feature(struct usb_device *hdev, int port1, int feature)
 {
 	return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
 		USB_REQ_SET_FEATURE, USB_RT_PORT, feature, port1,
 		NULL, 0, 1000);
 }
 /*
  * USB 2.0 spec Section 11.24.2.7.1.10 and table 11-7
  * for info about using port indicators
  */
 static void set_port_led(
 	struct usb_hub *hub,
 	int port1,
 	int selector
 )
 {
 	int status = set_port_feature(hub->hdev, (selector << 8) | port1,
 			USB_PORT_FEAT_INDICATOR);
 	if (status < 0)
 		dev_dbg (hub->intfdev,
 			"port %d indicator %s status %d\n",
 			port1,
 			({ char *s; switch (selector) {
 			case HUB_LED_AMBER: s = "amber"; break;
 			case HUB_LED_GREEN: s = "green"; break;
 			case HUB_LED_OFF: s = "off"; break;
 			case HUB_LED_AUTO: s = "auto"; break;
 			default: s = "??"; break;
 			} s; }),
 			status);
 }
 #define	LED_CYCLE_PERIOD	((2*HZ)/3)
 static void led_work (struct work_struct *work)
 {
 	struct usb_hub		*hub =
 		container_of(work, struct usb_hub, leds.work);
 	struct usb_device	*hdev = hub->hdev;
 	unsigned		i;
 	unsigned		changed = 0;
 	int			cursor = -1;
 	if (hdev->state != USB_STATE_CONFIGURED || hub->quiescing)
 		return;
 	for (i = 0; i < hdev->maxchild; i++) {
 		unsigned	selector, mode;
 		/* 30%-50% duty cycle */
 		switch (hub->indicator[i]) {
 		/* cycle marker */
 		case INDICATOR_CYCLE:
 			cursor = i;
 			selector = HUB_LED_AUTO;
 			mode = INDICATOR_AUTO;
 			break;
 		/* blinking green = sw attention */
 		case INDICATOR_GREEN_BLINK:
 			selector = HUB_LED_GREEN;
 			mode = INDICATOR_GREEN_BLINK_OFF;
 			break;
 		case INDICATOR_GREEN_BLINK_OFF:
 			selector = HUB_LED_OFF;
 			mode = INDICATOR_GREEN_BLINK;
 			break;
 		/* blinking amber = hw attention */
 		case INDICATOR_AMBER_BLINK:
 			selector = HUB_LED_AMBER;
 			mode = INDICATOR_AMBER_BLINK_OFF;
 			break;
 		case INDICATOR_AMBER_BLINK_OFF:
 			selector = HUB_LED_OFF;
 			mode = INDICATOR_AMBER_BLINK;
 			break;
 		/* blink green/amber = reserved */
 		case INDICATOR_ALT_BLINK:
 			selector = HUB_LED_GREEN;
 			mode = INDICATOR_ALT_BLINK_OFF;
 			break;
 		case INDICATOR_ALT_BLINK_OFF:
 			selector = HUB_LED_AMBER;
 			mode = INDICATOR_ALT_BLINK;
 			break;
 		default:
 			continue;
 		}
 		if (selector != HUB_LED_AUTO)
 			changed = 1;
 		set_port_led(hub, i + 1, selector);
 		hub->indicator[i] = mode;
 	}
 	if (!changed && blinkenlights) {
 		cursor++;
 		cursor %= hdev->maxchild;
 		set_port_led(hub, cursor + 1, HUB_LED_GREEN);
 		hub->indicator[cursor] = INDICATOR_CYCLE;
 		changed++;
 	}
 	if (changed)
 		queue_delayed_work(system_power_efficient_wq,
 				&hub->leds, LED_CYCLE_PERIOD);
 }
 /* use a short timeout for hub/port status fetches */
 #define	USB_STS_TIMEOUT		1000
 #define	USB_STS_RETRIES		5
 /*
  * USB 2.0 spec Section 11.24.2.6
  */
 static int get_hub_status(struct usb_device *hdev,
 		struct usb_hub_status *data)
 {
 	int i, status = -ETIMEDOUT;
 	for (i = 0; i < USB_STS_RETRIES &&
 			(status == -ETIMEDOUT || status == -EPIPE); i++) {
 		status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
 			USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_HUB, 0, 0,
 			data, sizeof(*data), USB_STS_TIMEOUT);
 	}
 	return status;
 }
 /*
  * USB 2.0 spec Section 11.24.2.7
  */
 static int get_port_status(struct usb_device *hdev, int port1,
 		struct usb_port_status *data)
 {
 	int i, status = -ETIMEDOUT;
 	for (i = 0; i < USB_STS_RETRIES &&
 			(status == -ETIMEDOUT || status == -EPIPE); i++) {
 		status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
 			USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, 0, port1,
 			data, sizeof(*data), USB_STS_TIMEOUT);
 	}
 	return status;
 }
 static int hub_port_status(struct usb_hub *hub, int port1,
 		u16 *status, u16 *change)
 {
 	int ret;
 	mutex_lock(&hub->status_mutex);
 	ret = get_port_status(hub->hdev, port1, &hub->status->port);
 	if (ret < 4) {
 		if (ret != -ENODEV)
 			dev_err(hub->intfdev,
 				"%s failed (err = %d)\n", __func__, ret);
 		if (ret >= 0)
 			ret = -EIO;
 	} else {
 		*status = le16_to_cpu(hub->status->port.wPortStatus);
 		*change = le16_to_cpu(hub->status->port.wPortChange);
 		ret = 0;
 	}
 	mutex_unlock(&hub->status_mutex);
 	return ret;
 }
 static void kick_khubd(struct usb_hub *hub)
 {
 	unsigned long	flags;
 	spin_lock_irqsave(&hub_event_lock, flags);
 	if (!hub->disconnected && list_empty(&hub->event_list)) {
 		list_add_tail(&hub->event_list, &hub_event_list);
 		/* Suppress autosuspend until khubd runs */
 		usb_autopm_get_interface_no_resume(
 				to_usb_interface(hub->intfdev));
 		wake_up(&khubd_wait);
 	}
 	spin_unlock_irqrestore(&hub_event_lock, flags);
 }
 void usb_kick_khubd(struct usb_device *hdev)
 {
 	struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
 	if (hub)
 		kick_khubd(hub);
 }
 /*
  * Let the USB core know that a USB 3.0 device has sent a Function Wake Device
  * Notification, which indicates it had initiated remote wakeup.
  *
  * USB 3.0 hubs do not report the port link state change from U3 to U0 when the
  * device initiates resume, so the USB core will not receive notice of the
  * resume through the normal hub interrupt URB.
  */
 void usb_wakeup_notification(struct usb_device *hdev,
 		unsigned int portnum)
 {
 	struct usb_hub *hub;
 	if (!hdev)
 		return;
 	hub = usb_hub_to_struct_hub(hdev);
 	if (hub) {
 		set_bit(portnum, hub->wakeup_bits);
 		kick_khubd(hub);
 	}
 }
 EXPORT_SYMBOL_GPL(usb_wakeup_notification);
 /* completion function, fires on port status changes and various faults */
 static void hub_irq(struct urb *urb)
 {
 	struct usb_hub *hub = urb->context;
 	int status = urb->status;
 	unsigned i;
 	unsigned long bits;
 	switch (status) {
 	case -ENOENT:		/* synchronous unlink */
 	case -ECONNRESET:	/* async unlink */
 	case -ESHUTDOWN:	/* hardware going away */
 		return;
 	default:		/* presumably an error */
 		/* Cause a hub reset after 10 consecutive errors */
 		dev_dbg (hub->intfdev, "transfer --> %d\n", status);
 		if ((++hub->nerrors < 10) || hub->error)
 			goto resubmit;
 		hub->error = status;
 		/* FALL THROUGH */
 	/* let khubd handle things */
 	case 0:			/* we got data:  port status changed */
 		bits = 0;
 		for (i = 0; i < urb->actual_length; ++i)
 			bits |= ((unsigned long) ((*hub->buffer)[i]))
 					<< (i*8);
 		hub->event_bits[0] = bits;
 		break;
 	}
 	hub->nerrors = 0;
 	/* Something happened, let khubd figure it out */
 	kick_khubd(hub);
 resubmit:
 	if (hub->quiescing)
 		return;
 	if ((status = usb_submit_urb (hub->urb, GFP_ATOMIC)) != 0
 			&& status != -ENODEV && status != -EPERM)
 		dev_err (hub->intfdev, "resubmit --> %d\n", status);
 }
 /* USB 2.0 spec Section 11.24.2.3 */
 static inline int
 hub_clear_tt_buffer (struct usb_device *hdev, u16 devinfo, u16 tt)
 {
 	/* Need to clear both directions for control ep */
 	if (((devinfo >> 11) & USB_ENDPOINT_XFERTYPE_MASK) ==
 			USB_ENDPOINT_XFER_CONTROL) {
 		int status = usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
 				HUB_CLEAR_TT_BUFFER, USB_RT_PORT,
 				devinfo ^ 0x8000, tt, NULL, 0, 1000);
 		if (status)
 			return status;
 	}
 	return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
 			       HUB_CLEAR_TT_BUFFER, USB_RT_PORT, devinfo,
 			       tt, NULL, 0, 1000);
 }
 /*
  * enumeration blocks khubd for a long time. we use keventd instead, since
  * long blocking there is the exception, not the rule.  accordingly, HCDs
  * talking to TTs must queue control transfers (not just bulk and iso), so
  * both can talk to the same hub concurrently.
  */
 static void hub_tt_work(struct work_struct *work)
 {
 	struct usb_hub		*hub =
 		container_of(work, struct usb_hub, tt.clear_work);
 	unsigned long		flags;
 	spin_lock_irqsave (&hub->tt.lock, flags);
 	while (!list_empty(&hub->tt.clear_list)) {
 		struct list_head	*next;
 		struct usb_tt_clear	*clear;
 		struct usb_device	*hdev = hub->hdev;
 		const struct hc_driver	*drv;
 		int			status;
 		next = hub->tt.clear_list.next;
 		clear = list_entry (next, struct usb_tt_clear, clear_list);
 		list_del (&clear->clear_list);
 		/* drop lock so HCD can concurrently report other TT errors */
 		spin_unlock_irqrestore (&hub->tt.lock, flags);
 		status = hub_clear_tt_buffer (hdev, clear->devinfo, clear->tt);
 		if (status && status != -ENODEV)
 			dev_err (&hdev->dev,
 				"clear tt %d (%04x) error %d\n",
 				clear->tt, clear->devinfo, status);
 		/* Tell the HCD, even if the operation failed */
 		drv = clear->hcd->driver;
 		if (drv->clear_tt_buffer_complete)
 			(drv->clear_tt_buffer_complete)(clear->hcd, clear->ep);
 		kfree(clear);
 		spin_lock_irqsave(&hub->tt.lock, flags);
 	}
 	spin_unlock_irqrestore (&hub->tt.lock, flags);
 }
 /**
  * usb_hub_set_port_power - control hub port's power state
  * @hdev: USB device belonging to the usb hub
  * @hub: target hub
  * @port1: port index
  * @set: expected status
  *
  * call this function to control port's power via setting or
  * clearing the port's PORT_POWER feature.
  *
  * Return: 0 if successful. A negative error code otherwise.
  */
 int usb_hub_set_port_power(struct usb_device *hdev, struct usb_hub *hub,
 			   int port1, bool set)
 {
 	int ret;
 	struct usb_port *port_dev = hub->ports[port1 - 1];
 	if (set)
 		ret = set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
 	else
 		ret = usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
 	if (!ret)
 		port_dev->power_is_on = set;
 	return ret;
 }
 /**
  * usb_hub_clear_tt_buffer - clear control/bulk TT state in high speed hub
  * @urb: an URB associated with the failed or incomplete split transaction
  *
  * High speed HCDs use this to tell the hub driver that some split control or
  * bulk transaction failed in a way that requires clearing internal state of
  * a transaction translator.  This is normally detected (and reported) from
  * interrupt context.
  *
  * It may not be possible for that hub to handle additional full (or low)
  * speed transactions until that state is fully cleared out.
  *
  * Return: 0 if successful. A negative error code otherwise.
  */
 int usb_hub_clear_tt_buffer(struct urb *urb)
 {
 	struct usb_device	*udev = urb->dev;
 	int			pipe = urb->pipe;
 	struct usb_tt		*tt = udev->tt;
 	unsigned long		flags;
 	struct usb_tt_clear	*clear;
 	/* we've got to cope with an arbitrary number of pending TT clears,
 	 * since each TT has "at least two" buffers that can need it (and
 	 * there can be many TTs per hub).  even if they're uncommon.
 	 */
 	if ((clear = kmalloc (sizeof *clear, GFP_ATOMIC)) == NULL) {
 		dev_err (&udev->dev, "can't save CLEAR_TT_BUFFER state\n");
 		/* FIXME recover somehow ... RESET_TT? */
 		return -ENOMEM;
 	}
 	/* info that CLEAR_TT_BUFFER needs */
 	clear->tt = tt->multi ? udev->ttport : 1;
 	clear->devinfo = usb_pipeendpoint (pipe);
 	clear->devinfo |= udev->devnum << 4;
 	clear->devinfo |= usb_pipecontrol (pipe)
 			? (USB_ENDPOINT_XFER_CONTROL << 11)
 			: (USB_ENDPOINT_XFER_BULK << 11);
 	if (usb_pipein (pipe))
 		clear->devinfo |= 1 << 15;
 	/* info for completion callback */
 	clear->hcd = bus_to_hcd(udev->bus);
 	clear->ep = urb->ep;
 	/* tell keventd to clear state for this TT */
 	spin_lock_irqsave (&tt->lock, flags);
 	list_add_tail (&clear->clear_list, &tt->clear_list);
 	schedule_work(&tt->clear_work);
 	spin_unlock_irqrestore (&tt->lock, flags);
 	return 0;
 }
 EXPORT_SYMBOL_GPL(usb_hub_clear_tt_buffer);
 /* If do_delay is false, return the number of milliseconds the caller
  * needs to delay.
  */
 static unsigned hub_power_on(struct usb_hub *hub, bool do_delay)
 {
 	int port1;
 	unsigned pgood_delay = hub->descriptor->bPwrOn2PwrGood * 2;
 	unsigned delay;
 	u16 wHubCharacteristics =
 			le16_to_cpu(hub->descriptor->wHubCharacteristics);
 	/* Enable power on each port.  Some hubs have reserved values
 	 * of LPSM (> 2) in their descriptors, even though they are
 	 * USB 2.0 hubs.  Some hubs do not implement port-power switching
 	 * but only emulate it.  In all cases, the ports won't work
 	 * unless we send these messages to the hub.
 	 */
 	if ((wHubCharacteristics & HUB_CHAR_LPSM) < 2)
 		dev_dbg(hub->intfdev, "enabling power on all ports\n");
 	else
 		dev_dbg(hub->intfdev, "trying to enable port power on "
 				"non-switchable hub\n");
 	for (port1 = 1; port1 <= hub->hdev->maxchild; port1++)
 		if (hub->ports[port1 - 1]->power_is_on)
 			set_port_feature(hub->hdev, port1, USB_PORT_FEAT_POWER);
 		else
 			usb_clear_port_feature(hub->hdev, port1,
 						USB_PORT_FEAT_POWER);
 	/* Wait at least 100 msec for power to become stable */
 	delay = max(pgood_delay, (unsigned) 100);
 	if (do_delay)
 		msleep(delay);
 	return delay;
 }
 static int hub_hub_status(struct usb_hub *hub,
 		u16 *status, u16 *change)
 {
 	int ret;
 	mutex_lock(&hub->status_mutex);
 	ret = get_hub_status(hub->hdev, &hub->status->hub);
 	if (ret < 0) {
 		if (ret != -ENODEV)
 			dev_err(hub->intfdev,
 				"%s failed (err = %d)\n", __func__, ret);
 	} else {
 		*status = le16_to_cpu(hub->status->hub.wHubStatus);
 		*change = le16_to_cpu(hub->status->hub.wHubChange);
 		ret = 0;
 	}
 	mutex_unlock(&hub->status_mutex);
 	return ret;
 }
 static int hub_set_port_link_state(struct usb_hub *hub, int port1,
 			unsigned int link_status)
 {
 	return set_port_feature(hub->hdev,
 			port1 | (link_status << 3),
 			USB_PORT_FEAT_LINK_STATE);
 }
 /*
  * If USB 3.0 ports are placed into the Disabled state, they will no longer
  * detect any device connects or disconnects.  This is generally not what the
  * USB core wants, since it expects a disabled port to produce a port status
  * change event when a new device connects.
  *
  * Instead, set the link state to Disabled, wait for the link to settle into
  * that state, clear any change bits, and then put the port into the RxDetect
  * state.
  */
 static int hub_usb3_port_disable(struct usb_hub *hub, int port1)
 {
 	int ret;
 	int total_time;
 	u16 portchange, portstatus;
 	if (!hub_is_superspeed(hub->hdev))
 		return -EINVAL;
 	ret = hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_SS_DISABLED);
 	if (ret)
 		return ret;
 	/* Wait for the link to enter the disabled state. */
 	for (total_time = 0; ; total_time += HUB_DEBOUNCE_STEP) {
 		ret = hub_port_status(hub, port1, &portstatus, &portchange);
 		if (ret < 0)
 			return ret;
 		if ((portstatus & USB_PORT_STAT_LINK_STATE) ==
 				USB_SS_PORT_LS_SS_DISABLED)
 			break;
 		if (total_time >= HUB_DEBOUNCE_TIMEOUT)
 			break;
 		msleep(HUB_DEBOUNCE_STEP);
 	}
 	if (total_time >= HUB_DEBOUNCE_TIMEOUT)
 		dev_warn(hub->intfdev, "Could not disable port %d after %d ms\n",
 				port1, total_time);
 	return hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_RX_DETECT);
 }
 static int hub_port_disable(struct usb_hub *hub, int port1, int set_state)
 {
 	struct usb_device *hdev = hub->hdev;
 	int ret = 0;
 	if (hub->ports[port1 - 1]->child && set_state)
 		usb_set_device_state(hub->ports[port1 - 1]->child,
 				USB_STATE_NOTATTACHED);
 	if (!hub->error) {
 		if (hub_is_superspeed(hub->hdev))
 			ret = hub_usb3_port_disable(hub, port1);
 		else
 			ret = usb_clear_port_feature(hdev, port1,
 					USB_PORT_FEAT_ENABLE);
 	}
 	if (ret && ret != -ENODEV)
 		dev_err(hub->intfdev, "cannot disable port %d (err = %d)\n",
 				port1, ret);
 	return ret;
 }
 /*
  * Disable a port and mark a logical connect-change event, so that some
  * time later khubd will disconnect() any existing usb_device on the port
  * and will re-enumerate if there actually is a device attached.
  */
 static void hub_port_logical_disconnect(struct usb_hub *hub, int port1)
 {
 	dev_dbg(hub->intfdev, "logical disconnect on port %d\n", port1);
 	hub_port_disable(hub, port1, 1);
 	/* FIXME let caller ask to power down the port:
 	 *  - some devices won't enumerate without a VBUS power cycle
 	 *  - SRP saves power that way
 	 *  - ... new call, TBD ...
 	 * That's easy if this hub can switch power per-port, and
 	 * khubd reactivates the port later (timer, SRP, etc).
 	 * Powerdown must be optional, because of reset/DFU.
 	 */
 	set_bit(port1, hub->change_bits);
 	kick_khubd(hub);
 }
 /**
  * usb_remove_device - disable a device's port on its parent hub
  * @udev: device to be disabled and removed
  * Context: @udev locked, must be able to sleep.
  *
  * After @udev's port has been disabled, khubd is notified and it will
  * see that the device has been disconnected.  When the device is
  * physically unplugged and something is plugged in, the events will
  * be received and processed normally.
  *
  * Return: 0 if successful. A negative error code otherwise.
  */
 int usb_remove_device(struct usb_device *udev)
 {
 	struct usb_hub *hub;
 	struct usb_interface *intf;
 	if (!udev->parent)	/* Can't remove a root hub */
 		return -EINVAL;
 	hub = usb_hub_to_struct_hub(udev->parent);
 	intf = to_usb_interface(hub->intfdev);
 	usb_autopm_get_interface(intf);
 	set_bit(udev->portnum, hub->removed_bits);
 	hub_port_logical_disconnect(hub, udev->portnum);
 	usb_autopm_put_interface(intf);
 	return 0;
 }
 enum hub_activation_type {
 	HUB_INIT, HUB_INIT2, HUB_INIT3,		/* INITs must come first */
 	HUB_POST_RESET, HUB_RESUME, HUB_RESET_RESUME,
 };
 static void hub_init_func2(struct work_struct *ws);
 static void hub_init_func3(struct work_struct *ws);
 static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
 {
 	struct usb_device *hdev = hub->hdev;
 	struct usb_hcd *hcd;
 	int ret;
 	int port1;
 	int status;
 	bool need_debounce_delay = false;
 	unsigned delay;
 	/* Continue a partial initialization */
 	if (type == HUB_INIT2)
 		goto init2;
 	if (type == HUB_INIT3)
 		goto init3;
 	/* The superspeed hub except for root hub has to use Hub Depth
 	 * value as an offset into the route string to locate the bits
 	 * it uses to determine the downstream port number. So hub driver
 	 * should send a set hub depth request to superspeed hub after
 	 * the superspeed hub is set configuration in initialization or
 	 * reset procedure.
 	 *
 	 * After a resume, port power should still be on.
 	 * For any other type of activation, turn it on.
 	 */
 	if (type != HUB_RESUME) {
 		if (hdev->parent && hub_is_superspeed(hdev)) {
 			ret = usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
 					HUB_SET_DEPTH, USB_RT_HUB,
 					hdev->level - 1, 0, NULL, 0,
 					USB_CTRL_SET_TIMEOUT);
 			if (ret < 0)
 				dev_err(hub->intfdev,
 						"set hub depth failed\n");
 		}
 		/* Speed up system boot by using a delayed_work for the
 		 * hub's initial power-up delays.  This is pretty awkward
 		 * and the implementation looks like a home-brewed sort of
 		 * setjmp/longjmp, but it saves at least 100 ms for each
 		 * root hub (assuming usbcore is compiled into the kernel
 		 * rather than as a module).  It adds up.
 		 *
 		 * This can't be done for HUB_RESUME or HUB_RESET_RESUME
 		 * because for those activation types the ports have to be
 		 * operational when we return.  In theory this could be done
 		 * for HUB_POST_RESET, but it's easier not to.
 		 */
 		if (type == HUB_INIT) {
 			delay = hub_power_on(hub, false);
 			INIT_DELAYED_WORK(&hub->init_work, hub_init_func2);
 			queue_delayed_work(system_power_efficient_wq,
 					&hub->init_work,
 					msecs_to_jiffies(delay));
 			/* Suppress autosuspend until init is done */
 			usb_autopm_get_interface_no_resume(
 					to_usb_interface(hub->intfdev));
 			return;		/* Continues at init2: below */
 		} else if (type == HUB_RESET_RESUME) {
 			/* The internal host controller state for the hub device
 			 * may be gone after a host power loss on system resume.
 			 * Update the device's info so the HW knows it's a hub.
 			 */
 			hcd = bus_to_hcd(hdev->bus);
 			if (hcd->driver->update_hub_device) {
 				ret = hcd->driver->update_hub_device(hcd, hdev,
 						&hub->tt, GFP_NOIO);
 				if (ret < 0) {
 					dev_err(hub->intfdev, "Host not "
 							"accepting hub info "
 							"update.\n");
 					dev_err(hub->intfdev, "LS/FS devices "
 							"and hubs may not work "
 							"under this hub\n.");
 				}
 			}
 			hub_power_on(hub, true);
 		} else {
 			hub_power_on(hub, true);
 		}
 	}
  init2:
 	/* Check each port and set hub->change_bits to let khubd know
 	 * which ports need attention.
 	 */
 	for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
 		struct usb_device *udev = hub->ports[port1 - 1]->child;
 		u16 portstatus, portchange;
 		portstatus = portchange = 0;
 		status = hub_port_status(hub, port1, &portstatus, &portchange);
 		if (udev || (portstatus & USB_PORT_STAT_CONNECTION))
 			dev_dbg(hub->intfdev,
 					"port %d: status %04x change %04x\n",
 					port1, portstatus, portchange);
 		/* After anything other than HUB_RESUME (i.e., initialization
 		 * or any sort of reset), every port should be disabled.
 		 * Unconnected ports should likewise be disabled (paranoia),
 		 * and so should ports for which we have no usb_device.
 		 */
 		if ((portstatus & USB_PORT_STAT_ENABLE) && (
 				type != HUB_RESUME ||
 				!(portstatus & USB_PORT_STAT_CONNECTION) ||
 				!udev ||
 				udev->state == USB_STATE_NOTATTACHED)) {
 			/*
 			 * USB3 protocol ports will automatically transition
 			 * to Enabled state when detect an USB3.0 device attach.
 			 * Do not disable USB3 protocol ports, just pretend
 			 * power was lost
 			 */
 			portstatus &= ~USB_PORT_STAT_ENABLE;
 			if (!hub_is_superspeed(hdev))
 				usb_clear_port_feature(hdev, port1,
 						   USB_PORT_FEAT_ENABLE);
 		}
 		/* Clear status-change flags; we'll debounce later */
 		if (portchange & USB_PORT_STAT_C_CONNECTION) {
 			need_debounce_delay = true;
 			usb_clear_port_feature(hub->hdev, port1,
 					USB_PORT_FEAT_C_CONNECTION);
 		}
 		if (portchange & USB_PORT_STAT_C_ENABLE) {
 			need_debounce_delay = true;
 			usb_clear_port_feature(hub->hdev, port1,
 					USB_PORT_FEAT_C_ENABLE);
 		}
 		if (portchange & USB_PORT_STAT_C_RESET) {
 			need_debounce_delay = true;
 			usb_clear_port_feature(hub->hdev, port1,
 					USB_PORT_FEAT_C_RESET);
 		}
 		if ((portchange & USB_PORT_STAT_C_BH_RESET) &&
 				hub_is_superspeed(hub->hdev)) {
 			need_debounce_delay = true;
 			usb_clear_port_feature(hub->hdev, port1,
 					USB_PORT_FEAT_C_BH_PORT_RESET);
 		}
 		/* We can forget about a "removed" device when there's a
 		 * physical disconnect or the connect status changes.
 		 */
 		if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
 				(portchange & USB_PORT_STAT_C_CONNECTION))
 			clear_bit(port1, hub->removed_bits);
 		if (!udev || udev->state == USB_STATE_NOTATTACHED) {
 			/* Tell khubd to disconnect the device or
 			 * check for a new connection
 			 */
 			if (udev || (portstatus & USB_PORT_STAT_CONNECTION) ||
 			    (portstatus & USB_PORT_STAT_OVERCURRENT))
 				set_bit(port1, hub->change_bits);
 		} else if (portstatus & USB_PORT_STAT_ENABLE) {
 			bool port_resumed = (portstatus &
 					USB_PORT_STAT_LINK_STATE) ==
 				USB_SS_PORT_LS_U0;
 			/* The power session apparently survived the resume.
 			 * If there was an overcurrent or suspend change
 			 * (i.e., remote wakeup request), have khubd
 			 * take care of it.  Look at the port link state
 			 * for USB 3.0 hubs, since they don't have a suspend
 			 * change bit, and they don't set the port link change
 			 * bit on device-initiated resume.
 			 */
 			if (portchange || (hub_is_superspeed(hub->hdev) &&
 						port_resumed))
 				set_bit(port1, hub->change_bits);
 		} else if (udev->persist_enabled) {
 			struct usb_port *port_dev = hub->ports[port1 - 1];
 #ifdef CONFIG_PM
 			udev->reset_resume = 1;
 #endif
 			/* Don't set the change_bits when the device
 			 * was powered off.
 			 */
 			if (port_dev->power_is_on)
 				set_bit(port1, hub->change_bits);
 		} else {
 			/* The power session is gone; tell khubd */
 			usb_set_device_state(udev, USB_STATE_NOTATTACHED);
 			set_bit(port1, hub->change_bits);
 		}
 	}
 	/* If no port-status-change flags were set, we don't need any
 	 * debouncing.  If flags were set we can try to debounce the
 	 * ports all at once right now, instead of letting khubd do them
 	 * one at a time later on.
 	 *
 	 * If any port-status changes do occur during this delay, khubd
 	 * will see them later and handle them normally.
 	 */
 	if (need_debounce_delay) {
 		delay = HUB_DEBOUNCE_STABLE;
 		/* Don't do a long sleep inside a workqueue routine */
 		if (type == HUB_INIT2) {
 			INIT_DELAYED_WORK(&hub->init_work, hub_init_func3);
 			queue_delayed_work(system_power_efficient_wq,
 					&hub->init_work,
 					msecs_to_jiffies(delay));
 			return;		/* Continues at init3: below */
 		} else {
 			msleep(delay);
 		}
 	}
  init3:
 	hub->quiescing = 0;
 	status = usb_submit_urb(hub->urb, GFP_NOIO);
 	if (status < 0)
 		dev_err(hub->intfdev, "activate --> %d\n", status);
 	if (hub->has_indicators && blinkenlights)
 		queue_delayed_work(system_power_efficient_wq,
 				&hub->leds, LED_CYCLE_PERIOD);
 	/* Scan all ports that need attention */
 	kick_khubd(hub);
 	/* Allow autosuspend if it was suppressed */
 	if (type <= HUB_INIT3)
 		usb_autopm_put_interface_async(to_usb_interface(hub->intfdev));
 }
 /* Implement the continuations for the delays above */
 static void hub_init_func2(struct work_struct *ws)
 {
 	struct usb_hub *hub = container_of(ws, struct usb_hub, init_work.work);
 	hub_activate(hub, HUB_INIT2);
 }
 static void hub_init_func3(struct work_struct *ws)
 {
 	struct usb_hub *hub = container_of(ws, struct usb_hub, init_work.work);
 	hub_activate(hub, HUB_INIT3);
 }
 enum hub_quiescing_type {
 	HUB_DISCONNECT, HUB_PRE_RESET, HUB_SUSPEND
 };
 static void hub_quiesce(struct usb_hub *hub, enum hub_quiescing_type type)
 {
 	struct usb_device *hdev = hub->hdev;
 	int i;
 	cancel_delayed_work_sync(&hub->init_work);
 	/* khubd and related activity won't re-trigger */
 	hub->quiescing = 1;
 	if (type != HUB_SUSPEND) {
 		/* Disconnect all the children */
 		for (i = 0; i < hdev->maxchild; ++i) {
 			if (hub->ports[i]->child)
 				usb_disconnect(&hub->ports[i]->child);
 		}
 	}
 	/* Stop khubd and related activity */
 	usb_kill_urb(hub->urb);
 	if (hub->has_indicators)
 		cancel_delayed_work_sync(&hub->leds);
 	if (hub->tt.hub)
 		flush_work(&hub->tt.clear_work);
 }
 /* caller has locked the hub device */
 static int hub_pre_reset(struct usb_interface *intf)
 {
 	struct usb_hub *hub = usb_get_intfdata(intf);
 	hub_quiesce(hub, HUB_PRE_RESET);
 	return 0;
 }
 /* caller has locked the hub device */
 static int hub_post_reset(struct usb_interface *intf)
 {
 	struct usb_hub *hub = usb_get_intfdata(intf);
 	hub_activate(hub, HUB_POST_RESET);
 	return 0;
 }
 static int hub_configure(struct usb_hub *hub,
 	struct usb_endpoint_descriptor *endpoint)
 {
 	struct usb_hcd *hcd;
 	struct usb_device *hdev = hub->hdev;
 	struct device *hub_dev = hub->intfdev;
 	u16 hubstatus, hubchange;
 	u16 wHubCharacteristics;
 	unsigned int pipe;
 	int maxp, ret, i;
 	char *message = "out of memory";
 	unsigned unit_load;
 	unsigned full_load;
 	hub->buffer = kmalloc(sizeof(*hub->buffer), GFP_KERNEL);
 	if (!hub->buffer) {
 		ret = -ENOMEM;
 		goto fail;
 	}
 	hub->status = kmalloc(sizeof(*hub->status), GFP_KERNEL);
 	if (!hub->status) {
 		ret = -ENOMEM;
 		goto fail;
 	}
 	mutex_init(&hub->status_mutex);
 	hub->descriptor = kmalloc(sizeof(*hub->descriptor), GFP_KERNEL);
 	if (!hub->descriptor) {
 		ret = -ENOMEM;
 		goto fail;
 	}
 	/* Request the entire hub descriptor.
 	 * hub->descriptor can handle USB_MAXCHILDREN ports,
 	 * but the hub can/will return fewer bytes here.
 	 */
 	ret = get_hub_descriptor(hdev, hub->descriptor);
 	if (ret < 0) {
 		message = "can't read hub descriptor";
 		goto fail;
 	} else if (hub->descriptor->bNbrPorts > USB_MAXCHILDREN) {
 		message = "hub has too many ports!";
 		ret = -ENODEV;
 		goto fail;
 	} else if (hub->descriptor->bNbrPorts == 0) {
 		message = "hub doesn't have any ports!";
 		ret = -ENODEV;
 		goto fail;
 	}
 	hdev->maxchild = hub->descriptor->bNbrPorts;
 	dev_info (hub_dev, "%d port%s detected\n", hdev->maxchild,
 		(hdev->maxchild == 1) ? "" : "s");
 	hub->ports = kzalloc(hdev->maxchild * sizeof(struct usb_port *),
 			     GFP_KERNEL);
 	if (!hub->ports) {
 		ret = -ENOMEM;
 		goto fail;
 	}
 	wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);
 	if (hub_is_superspeed(hdev)) {
 		unit_load = 150;
 		full_load = 900;
 	} else {
 		unit_load = 100;
 		full_load = 500;
 	}
 	/* FIXME for USB 3.0, skip for now */
 	if ((wHubCharacteristics & HUB_CHAR_COMPOUND) &&
 			!(hub_is_superspeed(hdev))) {
 		int	i;
 		char	portstr[USB_MAXCHILDREN + 1];
 		for (i = 0; i < hdev->maxchild; i++)
 			portstr[i] = hub->descriptor->u.hs.DeviceRemovable
 				    [((i + 1) / 8)] & (1 << ((i + 1) % 8))
 				? 'F' : 'R';
 		portstr[hdev->maxchild] = 0;
 		dev_dbg(hub_dev, "compound device; port removable status: %s\n", portstr);
 	} else
 		dev_dbg(hub_dev, "standalone hub\n");
 	switch (wHubCharacteristics & HUB_CHAR_LPSM) {
 	case HUB_CHAR_COMMON_LPSM:
 		dev_dbg(hub_dev, "ganged power switching\n");
 		break;
 	case HUB_CHAR_INDV_PORT_LPSM:
 		dev_dbg(hub_dev, "individual port power switching\n");
 		break;
 	case HUB_CHAR_NO_LPSM:
 	case HUB_CHAR_LPSM:
 		dev_dbg(hub_dev, "no power switching (usb 1.0)\n");
 		break;
 	}
 	switch (wHubCharacteristics & HUB_CHAR_OCPM) {
 	case HUB_CHAR_COMMON_OCPM:
 		dev_dbg(hub_dev, "global over-current protection\n");
 		break;
 	case HUB_CHAR_INDV_PORT_OCPM:
 		dev_dbg(hub_dev, "individual port over-current protection\n");
 		break;
 	case HUB_CHAR_NO_OCPM:
 	case HUB_CHAR_OCPM:
 		dev_dbg(hub_dev, "no over-current protection\n");
 		break;
 	}
 	spin_lock_init (&hub->tt.lock);
 	INIT_LIST_HEAD (&hub->tt.clear_list);
 	INIT_WORK(&hub->tt.clear_work, hub_tt_work);
 	switch (hdev->descriptor.bDeviceProtocol) {
 	case USB_HUB_PR_FS:
 		break;
 	case USB_HUB_PR_HS_SINGLE_TT:
 		dev_dbg(hub_dev, "Single TT\n");
 		hub->tt.hub = hdev;
 		break;
 	case USB_HUB_PR_HS_MULTI_TT:
 		ret = usb_set_interface(hdev, 0, 1);
 		if (ret == 0) {
 			dev_dbg(hub_dev, "TT per port\n");
 			hub->tt.multi = 1;
 		} else
 			dev_err(hub_dev, "Using single TT (err %d)\n",
 				ret);
 		hub->tt.hub = hdev;
 		break;
 	case USB_HUB_PR_SS:
 		/* USB 3.0 hubs don't have a TT */
 		break;
 	default:
 		dev_dbg(hub_dev, "Unrecognized hub protocol %d\n",
 			hdev->descriptor.bDeviceProtocol);
 		break;
 	}
 	/* Note 8 FS bit times == (8 bits / 12000000 bps) ~= 666ns */
 	switch (wHubCharacteristics & HUB_CHAR_TTTT) {
 	case HUB_TTTT_8_BITS:
 		if (hdev->descriptor.bDeviceProtocol != 0) {
 			hub->tt.think_time = 666;
 			dev_dbg(hub_dev, "TT requires at most %d "
 					"FS bit times (%d ns)\n",
 				8, hub->tt.think_time);
 		}
 		break;
 	case HUB_TTTT_16_BITS:
 		hub->tt.think_time = 666 * 2;
 		dev_dbg(hub_dev, "TT requires at most %d "
 				"FS bit times (%d ns)\n",
 			16, hub->tt.think_time);
 		break;
 	case HUB_TTTT_24_BITS:
 		hub->tt.think_time = 666 * 3;
 		dev_dbg(hub_dev, "TT requires at most %d "
 				"FS bit times (%d ns)\n",
 			24, hub->tt.think_time);
 		break;
 	case HUB_TTTT_32_BITS:
 		hub->tt.think_time = 666 * 4;
 		dev_dbg(hub_dev, "TT requires at most %d "
 				"FS bit times (%d ns)\n",
 			32, hub->tt.think_time);
 		break;
 	}
 	/* probe() zeroes hub->indicator[] */
 	if (wHubCharacteristics & HUB_CHAR_PORTIND) {
 		hub->has_indicators = 1;
 		dev_dbg(hub_dev, "Port indicators are supported\n");
 	}
 	dev_dbg(hub_dev, "power on to power good time: %dms\n",
 		hub->descriptor->bPwrOn2PwrGood * 2);
 	/* power budgeting mostly matters with bus-powered hubs,
 	 * and battery-powered root hubs (may provide just 8 mA).
 	 */
 	ret = usb_get_status(hdev, USB_RECIP_DEVICE, 0, &hubstatus);
 	if (ret) {
 		message = "can't get hub status";
 		goto fail;
 	}
 	hcd = bus_to_hcd(hdev->bus);
 	if (hdev == hdev->bus->root_hub) {
 		if (hcd->power_budget > 0)
 			hdev->bus_mA = hcd->power_budget;
 		else
 			hdev->bus_mA = full_load * hdev->maxchild;
 		if (hdev->bus_mA >= full_load)
 			hub->mA_per_port = full_load;
 		else {
 			hub->mA_per_port = hdev->bus_mA;
 			hub->limited_power = 1;
 		}
 	} else if ((hubstatus & (1 << USB_DEVICE_SELF_POWERED)) == 0) {
 		int remaining = hdev->bus_mA -
 			hub->descriptor->bHubContrCurrent;
 		dev_dbg(hub_dev, "hub controller current requirement: %dmA\n",
 			hub->descriptor->bHubContrCurrent);
 		hub->limited_power = 1;
 		if (remaining < hdev->maxchild * unit_load)
 			dev_warn(hub_dev,
 					"insufficient power available "
 					"to use all downstream ports\n");
 		hub->mA_per_port = unit_load;	/* 7.2.1 */
 	} else {	/* Self-powered external hub */
 		/* FIXME: What about battery-powered external hubs that
 		 * provide less current per port? */
 		hub->mA_per_port = full_load;
 	}
 	if (hub->mA_per_port < full_load)
 		dev_dbg(hub_dev, "%umA bus power budget for each child\n",
 				hub->mA_per_port);
 	/* Update the HCD's internal representation of this hub before khubd
 	 * starts getting port status changes for devices under the hub.
 	 */
 	if (hcd->driver->update_hub_device) {
 		ret = hcd->driver->update_hub_device(hcd, hdev,
 				&hub->tt, GFP_KERNEL);
 		if (ret < 0) {
 			message = "can't update HCD hub info";
 			goto fail;
 		}
 	}
 	ret = hub_hub_status(hub, &hubstatus, &hubchange);
 	if (ret < 0) {
 		message = "can't get hub status";
 		goto fail;
 	}
 	/* local power status reports aren't always correct */
 	if (hdev->actconfig->desc.bmAttributes & USB_CONFIG_ATT_SELFPOWER)
 		dev_dbg(hub_dev, "local power source is %s\n",
 			(hubstatus & HUB_STATUS_LOCAL_POWER)
 			? "lost (inactive)" : "good");
 	if ((wHubCharacteristics & HUB_CHAR_OCPM) == 0)
 		dev_dbg(hub_dev, "%sover-current condition exists\n",
 			(hubstatus & HUB_STATUS_OVERCURRENT) ? "" : "no ");
 	/* set up the interrupt endpoint
 	 * We use the EP's maxpacket size instead of (PORTS+1+7)/8
 	 * bytes as USB2.0[11.12.3] says because some hubs are known
 	 * to send more data (and thus cause overflow). For root hubs,
 	 * maxpktsize is defined in hcd.c's fake endpoint descriptors
 	 * to be big enough for at least USB_MAXCHILDREN ports. */
 	pipe = usb_rcvintpipe(hdev, endpoint->bEndpointAddress);
 	maxp = usb_maxpacket(hdev, pipe, usb_pipeout(pipe));
 	if (maxp > sizeof(*hub->buffer))
 		maxp = sizeof(*hub->buffer);
 	hub->urb = usb_alloc_urb(0, GFP_KERNEL);
 	if (!hub->urb) {
 		ret = -ENOMEM;
 		goto fail;
 	}
 	usb_fill_int_urb(hub->urb, hdev, pipe, *hub->buffer, maxp, hub_irq,
 		hub, endpoint->bInterval);
 	/* maybe cycle the hub leds */
 	if (hub->has_indicators && blinkenlights)
 		hub->indicator[0] = INDICATOR_CYCLE;
 	for (i = 0; i < hdev->maxchild; i++) {
 		ret = usb_hub_create_port_device(hub, i + 1);
 		if (ret < 0) {
 			dev_err(hub->intfdev,
 				"couldn't create port%d device.\n", i + 1);
 			hdev->maxchild = i;
 			goto fail_keep_maxchild;
 		}
 	}
 	usb_hub_adjust_deviceremovable(hdev, hub->descriptor);
 	hub_activate(hub, HUB_INIT);
 	return 0;
 fail:
 	hdev->maxchild = 0;
 fail_keep_maxchild:
 	dev_err (hub_dev, "config failed, %s (err %d)\n",
 			message, ret);
 	/* hub_disconnect() frees urb and descriptor */
 	return ret;
 }
 static void hub_release(struct kref *kref)
 {
 	struct usb_hub *hub = container_of(kref, struct usb_hub, kref);
 	usb_put_intf(to_usb_interface(hub->intfdev));
 	kfree(hub);
 }
 static unsigned highspeed_hubs;
 static void hub_disconnect(struct usb_interface *intf)
 {
 	struct usb_hub *hub = usb_get_intfdata(intf);
 	struct usb_device *hdev = interface_to_usbdev(intf);
 	int port1;
 	/* Take the hub off the event list and don't let it be added again */
 	spin_lock_irq(&hub_event_lock);
 	if (!list_empty(&hub->event_list)) {
 		list_del_init(&hub->event_list);
 		usb_autopm_put_interface_no_suspend(intf);
 	}
 	hub->disconnected = 1;
 	spin_unlock_irq(&hub_event_lock);
 	/* Disconnect all children and quiesce the hub */
 	hub->error = 0;
 	hub_quiesce(hub, HUB_DISCONNECT);
 	/* Avoid races with recursively_mark_NOTATTACHED() */
 	spin_lock_irq(&device_state_lock);
 	port1 = hdev->maxchild;
 	hdev->maxchild = 0;
 	usb_set_intfdata(intf, NULL);
 	spin_unlock_irq(&device_state_lock);
 	for (; port1 > 0; --port1)
 		usb_hub_remove_port_device(hub, port1);
 	if (hub->hdev->speed == USB_SPEED_HIGH)
 		highspeed_hubs--;
 	usb_free_urb(hub->urb);
 	kfree(hub->ports);
 	kfree(hub->descriptor);
 	kfree(hub->status);
 	kfree(hub->buffer);
 	pm_suspend_ignore_children(&intf->dev, false);
 	kref_put(&hub->kref, hub_release);
 }
 static int hub_probe(struct usb_interface *intf, const struct usb_device_id *id)
 {
 	struct usb_host_interface *desc;
 	struct usb_endpoint_descriptor *endpoint;
 	struct usb_device *hdev;
 	struct usb_hub *hub;
 	desc = intf->cur_altsetting;
 	hdev = interface_to_usbdev(intf);
 	/*
 	 * Set default autosuspend delay as 0 to speedup bus suspend,
 	 * based on the below considerations:
 	 *
 	 * - Unlike other drivers, the hub driver does not rely on the
 	 *   autosuspend delay to provide enough time to handle a wakeup
 	 *   event, and the submitted status URB is just to check future
 	 *   change on hub downstream ports, so it is safe to do it.
 	 *
 	 * - The patch might cause one or more auto supend/resume for
 	 *   below very rare devices when they are plugged into hub
 	 *   first time:
 	 *
 	 *   	devices having trouble initializing, and disconnect
 	 *   	themselves from the bus and then reconnect a second
 	 *   	or so later
 	 *
 	 *   	devices just for downloading firmware, and disconnects
 	 *   	themselves after completing it
 	 *
 	 *   For these quite rare devices, their drivers may change the
 	 *   autosuspend delay of their parent hub in the probe() to one
 	 *   appropriate value to avoid the subtle problem if someone
 	 *   does care it.
 	 *
 	 * - The patch may cause one or more auto suspend/resume on
 	 *   hub during running 'lsusb', but it is probably too
 	 *   infrequent to worry about.
 	 *
 	 * - Change autosuspend delay of hub can avoid unnecessary auto
 	 *   suspend timer for hub, also may decrease power consumption
 	 *   of USB bus.
 	 */
 	pm_runtime_set_autosuspend_delay(&hdev->dev, 0);
-	/* Hubs have proper suspend/resume support. */
+	/*
-	usb_enable_autosuspend(hdev);
+	 * Hubs have proper suspend/resume support, except for root hubs
+	 * where the controller driver doesn't have bus_suspend and
+	 * bus_resume methods.
+	 */
+	if (hdev->parent) {		/* normal device */
+		usb_enable_autosuspend(hdev);
+	} else {			/* root hub */
+		const struct hc_driver *drv = bus_to_hcd(hdev->bus)->driver;
+		if (drv->bus_suspend && drv->bus_resume)
+			usb_enable_autosuspend(hdev);
+	}
 	if (hdev->level == MAX_TOPO_LEVEL) {
 		dev_err(&intf->dev,
 			"Unsupported bus topology: hub nested too deep\n");
 		return -E2BIG;
 	}
 #ifdef	CONFIG_USB_OTG_BLACKLIST_HUB
 	if (hdev->parent) {
 		dev_warn(&intf->dev, "ignoring external hub\n");
 		return -ENODEV;
 	}
 #endif
 	/* Some hubs have a subclass of 1, which AFAICT according to the */
 	/*  specs is not defined, but it works */
 	if ((desc->desc.bInterfaceSubClass != 0) &&
 	    (desc->desc.bInterfaceSubClass != 1)) {
 descriptor_error:
 		dev_err (&intf->dev, "bad descriptor, ignoring hub\n");
 		return -EIO;
 	}
 	/* Multiple endpoints? What kind of mutant ninja-hub is this? */
 	if (desc->desc.bNumEndpoints != 1)
 		goto descriptor_error;
 	endpoint = &desc->endpoint[0].desc;
 	/* If it's not an interrupt in endpoint, we'd better punt! */
 	if (!usb_endpoint_is_int_in(endpoint))
 		goto descriptor_error;
 	/* We found a hub */
 	dev_info (&intf->dev, "USB hub found\n");
 	hub = kzalloc(sizeof(*hub), GFP_KERNEL);
 	if (!hub) {
 		dev_dbg (&intf->dev, "couldn't kmalloc hub struct\n");
 		return -ENOMEM;
 	}
 	kref_init(&hub->kref);
 	INIT_LIST_HEAD(&hub->event_list);
 	hub->intfdev = &intf->dev;
 	hub->hdev = hdev;
 	INIT_DELAYED_WORK(&hub->leds, led_work);
 	INIT_DELAYED_WORK(&hub->init_work, NULL);
 	usb_get_intf(intf);
 	usb_set_intfdata (intf, hub);
 	intf->needs_remote_wakeup = 1;
 	pm_suspend_ignore_children(&intf->dev, true);
 	if (hdev->speed == USB_SPEED_HIGH)
 		highspeed_hubs++;
 	if (id->driver_info & HUB_QUIRK_CHECK_PORT_AUTOSUSPEND)
 		hub->quirk_check_port_auto_suspend = 1;
 	if (hub_configure(hub, endpoint) >= 0)
 		return 0;
 	hub_disconnect (intf);
 	return -ENODEV;
 }
 static int
 hub_ioctl(struct usb_interface *intf, unsigned int code, void *user_data)
 {
 	struct usb_device *hdev = interface_to_usbdev (intf);
 	struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
 	/* assert ifno == 0 (part of hub spec) */
 	switch (code) {
 	case USBDEVFS_HUB_PORTINFO: {
 		struct usbdevfs_hub_portinfo *info = user_data;
 		int i;
 		spin_lock_irq(&device_state_lock);
 		if (hdev->devnum <= 0)
 			info->nports = 0;
 		else {
 			info->nports = hdev->maxchild;
 			for (i = 0; i < info->nports; i++) {
 				if (hub->ports[i]->child == NULL)
 					info->port[i] = 0;
 				else
 					info->port[i] =
 						hub->ports[i]->child->devnum;
 			}
 		}
 		spin_unlock_irq(&device_state_lock);
 		return info->nports + 1;
 		}
 	default:
 		return -ENOSYS;
 	}
 }
 /*
  * Allow user programs to claim ports on a hub.  When a device is attached
  * to one of these "claimed" ports, the program will "own" the device.
  */
 static int find_port_owner(struct usb_device *hdev, unsigned port1,
 		struct usb_dev_state ***ppowner)
 {
 	struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
 	if (hdev->state == USB_STATE_NOTATTACHED)
 		return -ENODEV;
 	if (port1 == 0 || port1 > hdev->maxchild)
 		return -EINVAL;
 	/* Devices not managed by the hub driver
 	 * will always have maxchild equal to 0.
 	 */
 	*ppowner = &(hub->ports[port1 - 1]->port_owner);
 	return 0;
 }
 /* In the following three functions, the caller must hold hdev's lock */
 int usb_hub_claim_port(struct usb_device *hdev, unsigned port1,
 		       struct usb_dev_state *owner)
 {
 	int rc;
 	struct usb_dev_state **powner;
 	rc = find_port_owner(hdev, port1, &powner);
 	if (rc)
 		return rc;
 	if (*powner)
 		return -EBUSY;
 	*powner = owner;
 	return rc;
 }
 EXPORT_SYMBOL_GPL(usb_hub_claim_port);
 int usb_hub_release_port(struct usb_device *hdev, unsigned port1,
 			 struct usb_dev_state *owner)
 {
 	int rc;
 	struct usb_dev_state **powner;
 	rc = find_port_owner(hdev, port1, &powner);
 	if (rc)
 		return rc;
 	if (*powner != owner)
 		return -ENOENT;
 	*powner = NULL;
 	return rc;
 }
 EXPORT_SYMBOL_GPL(usb_hub_release_port);
 void usb_hub_release_all_ports(struct usb_device *hdev, struct usb_dev_state *owner)
 {
 	struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
 	int n;
 	for (n = 0; n < hdev->maxchild; n++) {
 		if (hub->ports[n]->port_owner == owner)
 			hub->ports[n]->port_owner = NULL;
 	}
 }
 /* The caller must hold udev's lock */
 bool usb_device_is_owned(struct usb_device *udev)
 {
 	struct usb_hub *hub;
 	if (udev->state == USB_STATE_NOTATTACHED || !udev->parent)
 		return false;
 	hub = usb_hub_to_struct_hub(udev->parent);
 	return !!hub->ports[udev->portnum - 1]->port_owner;
 }
 static void recursively_mark_NOTATTACHED(struct usb_device *udev)
 {
 	struct usb_hub *hub = usb_hub_to_struct_hub(udev);
 	int i;
 	for (i = 0; i < udev->maxchild; ++i) {
 		if (hub->ports[i]->child)
 			recursively_mark_NOTATTACHED(hub->ports[i]->child);
 	}
 	if (udev->state == USB_STATE_SUSPENDED)
 		udev->active_duration -= jiffies;
 	udev->state = USB_STATE_NOTATTACHED;
 }
 /**
  * usb_set_device_state - change a device's current state (usbcore, hcds)
  * @udev: pointer to device whose state should be changed
  * @new_state: new state value to be stored
  *
  * udev->state is _not_ fully protected by the device lock.  Although
  * most transitions are made only while holding the lock, the state can
  * can change to USB_STATE_NOTATTACHED at almost any time.  This
  * is so that devices can be marked as disconnected as soon as possible,
  * without having to wait for any semaphores to be released.  As a result,
  * all changes to any device's state must be protected by the
  * device_state_lock spinlock.
  *
  * Once a device has been added to the device tree, all changes to its state
  * should be made using this routine.  The state should _not_ be set directly.
  *
  * If udev->state is already USB_STATE_NOTATTACHED then no change is made.
  * Otherwise udev->state is set to new_state, and if new_state is
  * USB_STATE_NOTATTACHED then all of udev's descendants' states are also set
  * to USB_STATE_NOTATTACHED.
  */
 void usb_set_device_state(struct usb_device *udev,
 		enum usb_device_state new_state)
 {
 	unsigned long flags;
 	int wakeup = -1;
 	spin_lock_irqsave(&device_state_lock, flags);
 	if (udev->state == USB_STATE_NOTATTACHED)
 		;	/* do nothing */
 	else if (new_state != USB_STATE_NOTATTACHED) {
 		/* root hub wakeup capabilities are managed out-of-band
 		 * and may involve silicon errata ... ignore them here.
 		 */
 		if (udev->parent) {
 			if (udev->state == USB_STATE_SUSPENDED
 					|| new_state == USB_STATE_SUSPENDED)
 				;	/* No change to wakeup settings */
 			else if (new_state == USB_STATE_CONFIGURED)
 				wakeup = udev->actconfig->desc.bmAttributes
 					 & USB_CONFIG_ATT_WAKEUP;
 			else
 				wakeup = 0;
 		}
 		if (udev->state == USB_STATE_SUSPENDED &&
 			new_state != USB_STATE_SUSPENDED)
 			udev->active_duration -= jiffies;
 		else if (new_state == USB_STATE_SUSPENDED &&
 				udev->state != USB_STATE_SUSPENDED)
 			udev->active_duration += jiffies;
 		udev->state = new_state;
 	} else
 		recursively_mark_NOTATTACHED(udev);
 	spin_unlock_irqrestore(&device_state_lock, flags);
 	if (wakeup >= 0)
 		device_set_wakeup_capable(&udev->dev, wakeup);
 }
 EXPORT_SYMBOL_GPL(usb_set_device_state);
 /*
  * Choose a device number.
  *
  * Device numbers are used as filenames in usbfs.  On USB-1.1 and
  * USB-2.0 buses they are also used as device addresses, however on
  * USB-3.0 buses the address is assigned by the controller hardware
  * and it usually is not the same as the device number.
  *
  * WUSB devices are simple: they have no hubs behind, so the mapping
  * device <-> virtual port number becomes 1:1. Why? to simplify the
  * life of the device connection logic in
  * drivers/usb/wusbcore/devconnect.c. When we do the initial secret
  * handshake we need to assign a temporary address in the unauthorized
  * space. For simplicity we use the first virtual port number found to
  * be free [drivers/usb/wusbcore/devconnect.c:wusbhc_devconnect_ack()]
  * and that becomes it's address [X < 128] or its unauthorized address
  * [X | 0x80].
  *
  * We add 1 as an offset to the one-based USB-stack port number
  * (zero-based wusb virtual port index) for two reasons: (a) dev addr
  * 0 is reserved by USB for default address; (b) Linux's USB stack
  * uses always #1 for the root hub of the controller. So USB stack's
  * port #1, which is wusb virtual-port #0 has address #2.
  *
  * Devices connected under xHCI are not as simple.  The host controller
  * supports virtualization, so the hardware assigns device addresses and
  * the HCD must setup data structures before issuing a set address
  * command to the hardware.
  */
 static void choose_devnum(struct usb_device *udev)
 {
 	int		devnum;
 	struct usb_bus	*bus = udev->bus;
 	/* If khubd ever becomes multithreaded, this will need a lock */
 	if (udev->wusb) {
 		devnum = udev->portnum + 1;
 		BUG_ON(test_bit(devnum, bus->devmap.devicemap));
 	} else {
 		/* Try to allocate the next devnum beginning at
 		 * bus->devnum_next. */
 		devnum = find_next_zero_bit(bus->devmap.devicemap, 128,
 					    bus->devnum_next);
 		if (devnum >= 128)
 			devnum = find_next_zero_bit(bus->devmap.devicemap,
 						    128, 1);
 		bus->devnum_next = (devnum >= 127 ? 1 : devnum + 1);
 	}
 	if (devnum < 128) {
 		set_bit(devnum, bus->devmap.devicemap);
 		udev->devnum = devnum;
 	}
 }
 static void release_devnum(struct usb_device *udev)
 {
 	if (udev->devnum > 0) {
 		clear_bit(udev->devnum, udev->bus->devmap.devicemap);
 		udev->devnum = -1;
 	}
 }
 static void update_devnum(struct usb_device *udev, int devnum)
 {
 	/* The address for a WUSB device is managed by wusbcore. */
 	if (!udev->wusb)
 		udev->devnum = devnum;
 }
 static void hub_free_dev(struct usb_device *udev)
 {
 	struct usb_hcd *hcd = bus_to_hcd(udev->bus);
 	/* Root hubs aren't real devices, so don't free HCD resources */
 	if (hcd->driver->free_dev && udev->parent)
 		hcd->driver->free_dev(hcd, udev);
 }
 /**
  * usb_disconnect - disconnect a device (usbcore-internal)
  * @pdev: pointer to device being disconnected
  * Context: !in_interrupt ()
  *
  * Something got disconnected. Get rid of it and all of its children.
  *
  * If *pdev is a normal device then the parent hub must already be locked.
  * If *pdev is a root hub then the caller must hold the usb_bus_list_lock,
  * which protects the set of root hubs as well as the list of buses.
  *
  * Only hub drivers (including virtual root hub drivers for host
  * controllers) should ever call this.
  *
  * This call is synchronous, and may not be used in an interrupt context.
  */
 void usb_disconnect(struct usb_device **pdev)
 {
 	struct usb_device	*udev = *pdev;
 	struct usb_hub		*hub = usb_hub_to_struct_hub(udev);
 	int			i;
 	/* mark the device as inactive, so any further urb submissions for
 	 * this device (and any of its children) will fail immediately.
 	 * this quiesces everything except pending urbs.
 	 */
 	usb_set_device_state(udev, USB_STATE_NOTATTACHED);
 	dev_info(&udev->dev, "USB disconnect, device number %d\n",
 			udev->devnum);
 	usb_lock_device(udev);
 	/* Free up all the children before we remove this device */
 	for (i = 0; i < udev->maxchild; i++) {
 		if (hub->ports[i]->child)
 			usb_disconnect(&hub->ports[i]->child);
 	}
 	/* deallocate hcd/hardware state ... nuking all pending urbs and
 	 * cleaning up all state associated with the current configuration
 	 * so that the hardware is now fully quiesced.
 	 */
 	dev_dbg (&udev->dev, "unregistering device\n");
 	usb_disable_device(udev, 0);
 	usb_hcd_synchronize_unlinks(udev);
 	if (udev->parent) {
 		struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
 		struct usb_port	*port_dev = hub->ports[udev->portnum - 1];
 		sysfs_remove_link(&udev->dev.kobj, "port");
 		sysfs_remove_link(&port_dev->dev.kobj, "device");
 		if (!port_dev->did_runtime_put)
 			pm_runtime_put(&port_dev->dev);
 		else
 			port_dev->did_runtime_put = false;
 	}
 	usb_remove_ep_devs(&udev->ep0);
 	usb_unlock_device(udev);
 	/* Unregister the device.  The device driver is responsible
 	 * for de-configuring the device and invoking the remove-device
 	 * notifier chain (used by usbfs and possibly others).
 	 */
 	device_del(&udev->dev);
 	/* Free the device number and delete the parent's children[]
 	 * (or root_hub) pointer.
 	 */
 	release_devnum(udev);
 	/* Avoid races with recursively_mark_NOTATTACHED() */
 	spin_lock_irq(&device_state_lock);
 	*pdev = NULL;
 	spin_unlock_irq(&device_state_lock);
 	hub_free_dev(udev);
 	put_device(&udev->dev);
 }
 #ifdef CONFIG_USB_ANNOUNCE_NEW_DEVICES
 static void show_string(struct usb_device *udev, char *id, char *string)
 {
 	if (!string)
 		return;
 	dev_info(&udev->dev, "%s: %s\n", id, string);
 }
 static void announce_device(struct usb_device *udev)
 {
 	dev_info(&udev->dev, "New USB device found, idVendor=%04x, idProduct=%04x\n",
 		le16_to_cpu(udev->descriptor.idVendor),
 		le16_to_cpu(udev->descriptor.idProduct));
 	dev_info(&udev->dev,
 		"New USB device strings: Mfr=%d, Product=%d, SerialNumber=%d\n",
 		udev->descriptor.iManufacturer,
 		udev->descriptor.iProduct,
 		udev->descriptor.iSerialNumber);
 	show_string(udev, "Product", udev->product);
 	show_string(udev, "Manufacturer", udev->manufacturer);
 	show_string(udev, "SerialNumber", udev->serial);
 }
 #else
 static inline void announce_device(struct usb_device *udev) { }
 #endif
 #ifdef	CONFIG_USB_OTG
 #include "otg_whitelist.h"
 #endif
 /**
  * usb_enumerate_device_otg - FIXME (usbcore-internal)
  * @udev: newly addressed device (in ADDRESS state)
  *
  * Finish enumeration for On-The-Go devices
  *
  * Return: 0 if successful. A negative error code otherwise.
  */
 static int usb_enumerate_device_otg(struct usb_device *udev)
 {
 	int err = 0;
 #ifdef	CONFIG_USB_OTG
 	/*
 	 * OTG-aware devices on OTG-capable root hubs may be able to use SRP,
 	 * to wake us after we've powered off VBUS; and HNP, switching roles
 	 * "host" to "peripheral".  The OTG descriptor helps figure this out.
 	 */
 	if (!udev->bus->is_b_host
 			&& udev->config
 			&& udev->parent == udev->bus->root_hub) {
 		struct usb_otg_descriptor	*desc = NULL;
 		struct usb_bus			*bus = udev->bus;
 		/* descriptor may appear anywhere in config */
 		if (__usb_get_extra_descriptor (udev->rawdescriptors[0],
 					le16_to_cpu(udev->config[0].desc.wTotalLength),
 					USB_DT_OTG, (void **) &desc) == 0) {
 			if (desc->bmAttributes & USB_OTG_HNP) {
 				unsigned		port1 = udev->portnum;
 				dev_info(&udev->dev,
 					"Dual-Role OTG device on %sHNP port\n",
 					(port1 == bus->otg_port)
 						? "" : "non-");
 				/* enable HNP before suspend, it's simpler */
 				if (port1 == bus->otg_port)
 					bus->b_hnp_enable = 1;
 				err = usb_control_msg(udev,
 					usb_sndctrlpipe(udev, 0),
 					USB_REQ_SET_FEATURE, 0,
 					bus->b_hnp_enable
 						? USB_DEVICE_B_HNP_ENABLE
 						: USB_DEVICE_A_ALT_HNP_SUPPORT,
 					0, NULL, 0, USB_CTRL_SET_TIMEOUT);
 				if (err < 0) {
 					/* OTG MESSAGE: report errors here,
 					 * customize to match your product.
 					 */
 					dev_info(&udev->dev,
 						"can't set HNP mode: %d\n",
 						err);
 					bus->b_hnp_enable = 0;
 				}
 			}
 		}
 	}
 	if (!is_targeted(udev)) {
 		/* Maybe it can talk to us, though we can't talk to it.
 		 * (Includes HNP test device.)
 		 */
 		if (udev->bus->b_hnp_enable || udev->bus->is_b_host) {
 			err = usb_port_suspend(udev, PMSG_SUSPEND);
 			if (err < 0)
 				dev_dbg(&udev->dev, "HNP fail, %d\n", err);
 		}
 		err = -ENOTSUPP;
 		goto fail;
 	}
 fail:
 #endif
 	return err;
 }
 /**
  * usb_enumerate_device - Read device configs/intfs/otg (usbcore-internal)
  * @udev: newly addressed device (in ADDRESS state)
  *
  * This is only called by usb_new_device() and usb_authorize_device()
  * and FIXME -- all comments that apply to them apply here wrt to
  * environment.
  *
  * If the device is WUSB and not authorized, we don't attempt to read
  * the string descriptors, as they will be errored out by the device
  * until it has been authorized.
  *
  * Return: 0 if successful. A negative error code otherwise.
  */
 static int usb_enumerate_device(struct usb_device *udev)
 {
 	int err;
 	if (udev->config == NULL) {
 		err = usb_get_configuration(udev);
 		if (err < 0) {
 			if (err != -ENODEV)
 				dev_err(&udev->dev, "can't read configurations, error %d\n",
 						err);
 			return err;
 		}
 	}
 	/* read the standard strings and cache them if present */
 	udev->product = usb_cache_string(udev, udev->descriptor.iProduct);
 	udev->manufacturer = usb_cache_string(udev,
 					      udev->descriptor.iManufacturer);
 	udev->serial = usb_cache_string(udev, udev->descriptor.iSerialNumber);
 	err = usb_enumerate_device_otg(udev);
 	if (err < 0)
 		return err;
 	usb_detect_interface_quirks(udev);
 	return 0;
 }
 static void set_usb_port_removable(struct usb_device *udev)
 {
 	struct usb_device *hdev = udev->parent;
 	struct usb_hub *hub;
 	u8 port = udev->portnum;
 	u16 wHubCharacteristics;
 	bool removable = true;
 	if (!hdev)
 		return;
 	hub = usb_hub_to_struct_hub(udev->parent);
 	wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);
 	if (!(wHubCharacteristics & HUB_CHAR_COMPOUND))
 		return;
 	if (hub_is_superspeed(hdev)) {
 		if (le16_to_cpu(hub->descriptor->u.ss.DeviceRemovable)
 				& (1 << port))
 			removable = false;
 	} else {
 		if (hub->descriptor->u.hs.DeviceRemovable[port / 8] & (1 << (port % 8)))
 			removable = false;
 	}
 	if (removable)
 		udev->removable = USB_DEVICE_REMOVABLE;
 	else
 		udev->removable = USB_DEVICE_FIXED;
 }
 /**
  * usb_new_device - perform initial device setup (usbcore-internal)
  * @udev: newly addressed device (in ADDRESS state)
  *
  * This is called with devices which have been detected but not fully
  * enumerated.  The device descriptor is available, but not descriptors
  * for any device configuration.  The caller must have locked either
  * the parent hub (if udev is a normal device) or else the
  * usb_bus_list_lock (if udev is a root hub).  The parent's pointer to
  * udev has already been installed, but udev is not yet visible through
  * sysfs or other filesystem code.
  *
  * This call is synchronous, and may not be used in an interrupt context.
  *
  * Only the hub driver or root-hub registrar should ever call this.
  *
  * Return: Whether the device is configured properly or not. Zero if the
  * interface was registered with the driver core; else a negative errno
  * value.
  *
  */
 int usb_new_device(struct usb_device *udev)
 {
 	int err;
 	if (udev->parent) {
 		/* Initialize non-root-hub device wakeup to disabled;
 		 * device (un)configuration controls wakeup capable
 		 * sysfs power/wakeup controls wakeup enabled/disabled
 		 */
 		device_init_wakeup(&udev->dev, 0);
 	}
 	/* Tell the runtime-PM framework the device is active */
 	pm_runtime_set_active(&udev->dev);
 	pm_runtime_get_noresume(&udev->dev);
 	pm_runtime_use_autosuspend(&udev->dev);
 	pm_runtime_enable(&udev->dev);
 	/* By default, forbid autosuspend for all devices.  It will be
 	 * allowed for hubs during binding.
 	 */
 	usb_disable_autosuspend(udev);
 	err = usb_enumerate_device(udev);	/* Read descriptors */
 	if (err < 0)
 		goto fail;
 	dev_dbg(&udev->dev, "udev %d, busnum %d, minor = %d\n",
 			udev->devnum, udev->bus->busnum,
 			(((udev->bus->busnum-1) * 128) + (udev->devnum-1)));
 	/* export the usbdev device-node for libusb */
 	udev->dev.devt = MKDEV(USB_DEVICE_MAJOR,
 			(((udev->bus->busnum-1) * 128) + (udev->devnum-1)));
 	/* Tell the world! */
 	announce_device(udev);
 	if (udev->serial)
 		add_device_randomness(udev->serial, strlen(udev->serial));
 	if (udev->product)
 		add_device_randomness(udev->product, strlen(udev->product));
 	if (udev->manufacturer)
 		add_device_randomness(udev->manufacturer,
 				      strlen(udev->manufacturer));
 	device_enable_async_suspend(&udev->dev);
 	/*
 	 * check whether the hub marks this port as non-removable. Do it
 	 * now so that platform-specific data can override it in
 	 * device_add()
 	 */
 	if (udev->parent)
 		set_usb_port_removable(udev);
 	/* Register the device.  The device driver is responsible
 	 * for configuring the device and invoking the add-device
 	 * notifier chain (used by usbfs and possibly others).
 	 */
 	err = device_add(&udev->dev);
 	if (err) {
 		dev_err(&udev->dev, "can't device_add, error %d\n", err);
 		goto fail;
 	}
 	/* Create link files between child device and usb port device. */
 	if (udev->parent) {
 		struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
 		struct usb_port	*port_dev = hub->ports[udev->portnum - 1];
 		err = sysfs_create_link(&udev->dev.kobj,
 				&port_dev->dev.kobj, "port");
 		if (err)
 			goto fail;
 		err = sysfs_create_link(&port_dev->dev.kobj,
 				&udev->dev.kobj, "device");
 		if (err) {
 			sysfs_remove_link(&udev->dev.kobj, "port");
 			goto fail;
 		}
 		pm_runtime_get_sync(&port_dev->dev);
 	}
 	(void) usb_create_ep_devs(&udev->dev, &udev->ep0, udev);
 	usb_mark_last_busy(udev);
 	pm_runtime_put_sync_autosuspend(&udev->dev);
 	return err;
 fail:
 	usb_set_device_state(udev, USB_STATE_NOTATTACHED);
 	pm_runtime_disable(&udev->dev);
 	pm_runtime_set_suspended(&udev->dev);
 	return err;
 }
 /**
  * usb_deauthorize_device - deauthorize a device (usbcore-internal)
  * @usb_dev: USB device
  *
  * Move the USB device to a very basic state where interfaces are disabled
  * and the device is in fact unconfigured and unusable.
  *
  * We share a lock (that we have) with device_del(), so we need to
  * defer its call.
  *
  * Return: 0.
  */
 int usb_deauthorize_device(struct usb_device *usb_dev)
 {
 	usb_lock_device(usb_dev);
 	if (usb_dev->authorized == 0)
 		goto out_unauthorized;
 	usb_dev->authorized = 0;
 	usb_set_configuration(usb_dev, -1);
 out_unauthorized:
 	usb_unlock_device(usb_dev);
 	return 0;
 }
 int usb_authorize_device(struct usb_device *usb_dev)
 {
 	int result = 0, c;
 	usb_lock_device(usb_dev);
 	if (usb_dev->authorized == 1)
 		goto out_authorized;
 	result = usb_autoresume_device(usb_dev);
 	if (result < 0) {
 		dev_err(&usb_dev->dev,
 			"can't autoresume for authorization: %d\n", result);
 		goto error_autoresume;
 	}
 	result = usb_get_device_descriptor(usb_dev, sizeof(usb_dev->descriptor));
 	if (result < 0) {
 		dev_err(&usb_dev->dev, "can't re-read device descriptor for "
 			"authorization: %d\n", result);
 		goto error_device_descriptor;
 	}
 	usb_dev->authorized = 1;
 	/* Choose and set the configuration.  This registers the interfaces
 	 * with the driver core and lets interface drivers bind to them.
 	 */
 	c = usb_choose_configuration(usb_dev);
 	if (c >= 0) {
 		result = usb_set_configuration(usb_dev, c);
 		if (result) {
 			dev_err(&usb_dev->dev,
 				"can't set config #%d, error %d\n", c, result);
 			/* This need not be fatal.  The user can try to
 			 * set other configurations. */
 		}
 	}
 	dev_info(&usb_dev->dev, "authorized to connect\n");
 error_device_descriptor:
 	usb_autosuspend_device(usb_dev);
 error_autoresume:
 out_authorized:
 	usb_unlock_device(usb_dev);	/* complements locktree */
 	return result;
 }
 /* Returns 1 if @hub is a WUSB root hub, 0 otherwise */
 static unsigned hub_is_wusb(struct usb_hub *hub)
 {
 	struct usb_hcd *hcd;
 	if (hub->hdev->parent != NULL)  /* not a root hub? */
 		return 0;
 	hcd = container_of(hub->hdev->bus, struct usb_hcd, self);
 	return hcd->wireless;
 }
 #define PORT_RESET_TRIES	5
 #define SET_ADDRESS_TRIES	2
 #define GET_DESCRIPTOR_TRIES	2
 #define SET_CONFIG_TRIES	(2 * (use_both_schemes + 1))
 #define USE_NEW_SCHEME(i)	((i) / 2 == (int)old_scheme_first)
 #define HUB_ROOT_RESET_TIME	50	/* times are in msec */
 #define HUB_SHORT_RESET_TIME	10
 #define HUB_BH_RESET_TIME	50
 #define HUB_LONG_RESET_TIME	200
 #define HUB_RESET_TIMEOUT	800
 /*
  * "New scheme" enumeration causes an extra state transition to be
  * exposed to an xhci host and causes USB3 devices to receive control
  * commands in the default state.  This has been seen to cause
  * enumeration failures, so disable this enumeration scheme for USB3
  * devices.
  */
 static bool use_new_scheme(struct usb_device *udev, int retry)
 {
 	if (udev->speed == USB_SPEED_SUPER)
 		return false;
 	return USE_NEW_SCHEME(retry);
 }
 static int hub_port_reset(struct usb_hub *hub, int port1,
 			struct usb_device *udev, unsigned int delay, bool warm);
 /* Is a USB 3.0 port in the Inactive or Compliance Mode state?
  * Port worm reset is required to recover
  */
 static bool hub_port_warm_reset_required(struct usb_hub *hub, u16 portstatus)
 {
 	return hub_is_superspeed(hub->hdev) &&
 		(((portstatus & USB_PORT_STAT_LINK_STATE) ==
 		  USB_SS_PORT_LS_SS_INACTIVE) ||
 		 ((portstatus & USB_PORT_STAT_LINK_STATE) ==
 		  USB_SS_PORT_LS_COMP_MOD)) ;
 }
 static int hub_port_wait_reset(struct usb_hub *hub, int port1,
 			struct usb_device *udev, unsigned int delay, bool warm)
 {
 	int delay_time, ret;
 	u16 portstatus;
 	u16 portchange;
 	for (delay_time = 0;
 			delay_time < HUB_RESET_TIMEOUT;
 			delay_time += delay) {
 		/* wait to give the device a chance to reset */
 		msleep(delay);
 		/* read and decode port status */
 		ret = hub_port_status(hub, port1, &portstatus, &portchange);
 		if (ret < 0)
 			return ret;
 		/* The port state is unknown until the reset completes. */
 		if (!(portstatus & USB_PORT_STAT_RESET))
 			break;
 		/* switch to the long delay after two short delay failures */
 		if (delay_time >= 2 * HUB_SHORT_RESET_TIME)
 			delay = HUB_LONG_RESET_TIME;
 		dev_dbg (hub->intfdev,
 			"port %d not %sreset yet, waiting %dms\n",
 			port1, warm ? "warm " : "", delay);
 	}
 	if ((portstatus & USB_PORT_STAT_RESET))
 		return -EBUSY;
 	if (hub_port_warm_reset_required(hub, portstatus))
 		return -ENOTCONN;
 	/* Device went away? */
 	if (!(portstatus & USB_PORT_STAT_CONNECTION))
 		return -ENOTCONN;
 	/* bomb out completely if the connection bounced.  A USB 3.0
 	 * connection may bounce if multiple warm resets were issued,
 	 * but the device may have successfully re-connected. Ignore it.
 	 */
 	if (!hub_is_superspeed(hub->hdev) &&
 			(portchange & USB_PORT_STAT_C_CONNECTION))
 		return -ENOTCONN;
 	if (!(portstatus & USB_PORT_STAT_ENABLE))
 		return -EBUSY;
 	if (!udev)
 		return 0;
 	if (hub_is_wusb(hub))
 		udev->speed = USB_SPEED_WIRELESS;
 	else if (hub_is_superspeed(hub->hdev))
 		udev->speed = USB_SPEED_SUPER;
 	else if (portstatus & USB_PORT_STAT_HIGH_SPEED)
 		udev->speed = USB_SPEED_HIGH;
 	else if (portstatus & USB_PORT_STAT_LOW_SPEED)
 		udev->speed = USB_SPEED_LOW;
 	else
 		udev->speed = USB_SPEED_FULL;
 	return 0;
 }
 static void hub_port_finish_reset(struct usb_hub *hub, int port1,
 			struct usb_device *udev, int *status)
 {
 	switch (*status) {
 	case 0:
 		/* TRSTRCY = 10 ms; plus some extra */
 		msleep(10 + 40);
 		if (udev) {
 			struct usb_hcd *hcd = bus_to_hcd(udev->bus);
 			update_devnum(udev, 0);
 			/* The xHC may think the device is already reset,
 			 * so ignore the status.
 			 */
 			if (hcd->driver->reset_device)
 				hcd->driver->reset_device(hcd, udev);
 		}
 		/* FALL THROUGH */
 	case -ENOTCONN:
 	case -ENODEV:
 		usb_clear_port_feature(hub->hdev,
 				port1, USB_PORT_FEAT_C_RESET);
 		if (hub_is_superspeed(hub->hdev)) {
 			usb_clear_port_feature(hub->hdev, port1,
 					USB_PORT_FEAT_C_BH_PORT_RESET);
 			usb_clear_port_feature(hub->hdev, port1,
 					USB_PORT_FEAT_C_PORT_LINK_STATE);
 			usb_clear_port_feature(hub->hdev, port1,
 					USB_PORT_FEAT_C_CONNECTION);
 		}
 		if (udev)
 			usb_set_device_state(udev, *status
 					? USB_STATE_NOTATTACHED
 					: USB_STATE_DEFAULT);
 		break;
 	}
 }
 /* Handle port reset and port warm(BH) reset (for USB3 protocol ports) */
 static int hub_port_reset(struct usb_hub *hub, int port1,
 			struct usb_device *udev, unsigned int delay, bool warm)
 {
 	int i, status;
 	u16 portchange, portstatus;
 	if (!hub_is_superspeed(hub->hdev)) {
 		if (warm) {
 			dev_err(hub->intfdev, "only USB3 hub support "
 						"warm reset\n");
 			return -EINVAL;
 		}
 		/* Block EHCI CF initialization during the port reset.
 		 * Some companion controllers don't like it when they mix.
 		 */
 		down_read(&ehci_cf_port_reset_rwsem);
 	} else if (!warm) {
 		/*
 		 * If the caller hasn't explicitly requested a warm reset,
 		 * double check and see if one is needed.
 		 */
 		status = hub_port_status(hub, port1,
 					&portstatus, &portchange);
 		if (status < 0)
 			goto done;
 		if (hub_port_warm_reset_required(hub, portstatus))
 			warm = true;
 	}
 	/* Reset the port */
 	for (i = 0; i < PORT_RESET_TRIES; i++) {
 		status = set_port_feature(hub->hdev, port1, (warm ?
 					USB_PORT_FEAT_BH_PORT_RESET :
 					USB_PORT_FEAT_RESET));
 		if (status == -ENODEV) {
 			;	/* The hub is gone */
 		} else if (status) {
 			dev_err(hub->intfdev,
 					"cannot %sreset port %d (err = %d)\n",
 					warm ? "warm " : "", port1, status);
 		} else {
 			status = hub_port_wait_reset(hub, port1, udev, delay,
 								warm);
 			if (status && status != -ENOTCONN && status != -ENODEV)
 				dev_dbg(hub->intfdev,
 						"port_wait_reset: err = %d\n",
 						status);
 		}
 		/* Check for disconnect or reset */
 		if (status == 0 || status == -ENOTCONN || status == -ENODEV) {
 			hub_port_finish_reset(hub, port1, udev, &status);
 			if (!hub_is_superspeed(hub->hdev))
 				goto done;
 			/*
 			 * If a USB 3.0 device migrates from reset to an error
 			 * state, re-issue the warm reset.
 			 */
 			if (hub_port_status(hub, port1,
 					&portstatus, &portchange) < 0)
 				goto done;
 			if (!hub_port_warm_reset_required(hub, portstatus))
 				goto done;
 			/*
 			 * If the port is in SS.Inactive or Compliance Mode, the
 			 * hot or warm reset failed.  Try another warm reset.
 			 */
 			if (!warm) {
 				dev_dbg(hub->intfdev, "hot reset failed, warm reset port %d\n",
 						port1);
 				warm = true;
 			}
 		}
 		dev_dbg (hub->intfdev,
 			"port %d not enabled, trying %sreset again...\n",
 			port1, warm ? "warm " : "");
 		delay = HUB_LONG_RESET_TIME;
 	}
 	dev_err (hub->intfdev,
 		"Cannot enable port %i.  Maybe the USB cable is bad?\n",
 		port1);
 done:
 	if (!hub_is_superspeed(hub->hdev))
 		up_read(&ehci_cf_port_reset_rwsem);
 	return status;
 }
 /* Check if a port is power on */
 static int port_is_power_on(struct usb_hub *hub, unsigned portstatus)
 {
 	int ret = 0;
 	if (hub_is_superspeed(hub->hdev)) {
 		if (portstatus & USB_SS_PORT_STAT_POWER)
 			ret = 1;
 	} else {
 		if (portstatus & USB_PORT_STAT_POWER)
 			ret = 1;
 	}
 	return ret;
 }
 #ifdef	CONFIG_PM
 /* Check if a port is suspended(USB2.0 port) or in U3 state(USB3.0 port) */
 static int port_is_suspended(struct usb_hub *hub, unsigned portstatus)
 {
 	int ret = 0;
 	if (hub_is_superspeed(hub->hdev)) {
 		if ((portstatus & USB_PORT_STAT_LINK_STATE)
 				== USB_SS_PORT_LS_U3)
 			ret = 1;
 	} else {
 		if (portstatus & USB_PORT_STAT_SUSPEND)
 			ret = 1;
 	}
 	return ret;
 }
 /* Determine whether the device on a port is ready for a normal resume,
  * is ready for a reset-resume, or should be disconnected.
  */
 static int check_port_resume_type(struct usb_device *udev,
 		struct usb_hub *hub, int port1,
 		int status, unsigned portchange, unsigned portstatus)
 {
 	/* Is the device still present? */
 	if (status || port_is_suspended(hub, portstatus) ||
 			!port_is_power_on(hub, portstatus) ||
 			!(portstatus & USB_PORT_STAT_CONNECTION)) {
 		if (status >= 0)
 			status = -ENODEV;
 	}
 	/* Can't do a normal resume if the port isn't enabled,
 	 * so try a reset-resume instead.
 	 */
 	else if (!(portstatus & USB_PORT_STAT_ENABLE) && !udev->reset_resume) {
 		if (udev->persist_enabled)
 			udev->reset_resume = 1;
 		else
 			status = -ENODEV;
 	}
 	if (status) {
 		dev_dbg(hub->intfdev,
 				"port %d status %04x.%04x after resume, %d\n",
 				port1, portchange, portstatus, status);
 	} else if (udev->reset_resume) {
 		/* Late port handoff can set status-change bits */
 		if (portchange & USB_PORT_STAT_C_CONNECTION)
 			usb_clear_port_feature(hub->hdev, port1,
 					USB_PORT_FEAT_C_CONNECTION);
 		if (portchange & USB_PORT_STAT_C_ENABLE)
 			usb_clear_port_feature(hub->hdev, port1,
 					USB_PORT_FEAT_C_ENABLE);
 	}
 	return status;
 }
 int usb_disable_ltm(struct usb_device *udev)
 {
 	struct usb_hcd *hcd = bus_to_hcd(udev->bus);
 	/* Check if the roothub and device supports LTM. */
 	if (!usb_device_supports_ltm(hcd->self.root_hub) ||
 			!usb_device_supports_ltm(udev))
 		return 0;
 	/* Clear Feature LTM Enable can only be sent if the device is
 	 * configured.
 	 */
 	if (!udev->actconfig)
 		return 0;
 	return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
 			USB_REQ_CLEAR_FEATURE, USB_RECIP_DEVICE,
 			USB_DEVICE_LTM_ENABLE, 0, NULL, 0,
 			USB_CTRL_SET_TIMEOUT);
 }
 EXPORT_SYMBOL_GPL(usb_disable_ltm);
 void usb_enable_ltm(struct usb_device *udev)
 {
 	struct usb_hcd *hcd = bus_to_hcd(udev->bus);
 	/* Check if the roothub and device supports LTM. */
 	if (!usb_device_supports_ltm(hcd->self.root_hub) ||
 			!usb_device_supports_ltm(udev))
 		return;
 	/* Set Feature LTM Enable can only be sent if the device is
 	 * configured.
 	 */
 	if (!udev->actconfig)
 		return;
 	usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
 			USB_REQ_SET_FEATURE, USB_RECIP_DEVICE,
 			USB_DEVICE_LTM_ENABLE, 0, NULL, 0,
 			USB_CTRL_SET_TIMEOUT);
 }
 EXPORT_SYMBOL_GPL(usb_enable_ltm);
 /*
  * usb_enable_remote_wakeup - enable remote wakeup for a device
  * @udev: target device
  *
  * For USB-2 devices: Set the device's remote wakeup feature.
  *
  * For USB-3 devices: Assume there's only one function on the device and
  * enable remote wake for the first interface.  FIXME if the interface
  * association descriptor shows there's more than one function.
  */
 static int usb_enable_remote_wakeup(struct usb_device *udev)
 {
 	if (udev->speed < USB_SPEED_SUPER)
 		return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
 				USB_REQ_SET_FEATURE, USB_RECIP_DEVICE,
 				USB_DEVICE_REMOTE_WAKEUP, 0, NULL, 0,
 				USB_CTRL_SET_TIMEOUT);
 	else
 		return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
 				USB_REQ_SET_FEATURE, USB_RECIP_INTERFACE,
 				USB_INTRF_FUNC_SUSPEND,
 				USB_INTRF_FUNC_SUSPEND_RW |
 					USB_INTRF_FUNC_SUSPEND_LP,
 				NULL, 0, USB_CTRL_SET_TIMEOUT);
 }
 /*
  * usb_disable_remote_wakeup - disable remote wakeup for a device
  * @udev: target device
  *
  * For USB-2 devices: Clear the device's remote wakeup feature.
  *
  * For USB-3 devices: Assume there's only one function on the device and
  * disable remote wake for the first interface.  FIXME if the interface
  * association descriptor shows there's more than one function.
  */
 static int usb_disable_remote_wakeup(struct usb_device *udev)
 {
 	if (udev->speed < USB_SPEED_SUPER)
 		return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
 				USB_REQ_CLEAR_FEATURE, USB_RECIP_DEVICE,
 				USB_DEVICE_REMOTE_WAKEUP, 0, NULL, 0,
 				USB_CTRL_SET_TIMEOUT);
 	else
 		return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
 				USB_REQ_CLEAR_FEATURE, USB_RECIP_INTERFACE,
 				USB_INTRF_FUNC_SUSPEND,	0, NULL, 0,
 				USB_CTRL_SET_TIMEOUT);
 }
 /* Count of wakeup-enabled devices at or below udev */
 static unsigned wakeup_enabled_descendants(struct usb_device *udev)
 {
 	struct usb_hub *hub = usb_hub_to_struct_hub(udev);
 	return udev->do_remote_wakeup +
 			(hub ? hub->wakeup_enabled_descendants : 0);
 }
 /*
  * usb_port_suspend - suspend a usb device's upstream port
  * @udev: device that's no longer in active use, not a root hub
  * Context: must be able to sleep; device not locked; pm locks held
  *
  * Suspends a USB device that isn't in active use, conserving power.
  * Devices may wake out of a suspend, if anything important happens,
  * using the remote wakeup mechanism.  They may also be taken out of
  * suspend by the host, using usb_port_resume().  It's also routine
  * to disconnect devices while they are suspended.
  *
  * This only affects the USB hardware for a device; its interfaces
  * (and, for hubs, child devices) must already have been suspended.
  *
  * Selective port suspend reduces power; most suspended devices draw
  * less than 500 uA.  It's also used in OTG, along with remote wakeup.
  * All devices below the suspended port are also suspended.
  *
  * Devices leave suspend state when the host wakes them up.  Some devices
  * also support "remote wakeup", where the device can activate the USB
  * tree above them to deliver data, such as a keypress or packet.  In
  * some cases, this wakes the USB host.
  *
  * Suspending OTG devices may trigger HNP, if that's been enabled
  * between a pair of dual-role devices.  That will change roles, such
  * as from A-Host to A-Peripheral or from B-Host back to B-Peripheral.
  *
  * Devices on USB hub ports have only one "suspend" state, corresponding
  * to ACPI D2, "may cause the device to lose some context".
  * State transitions include:
  *
  *   - suspend, resume ... when the VBUS power link stays live
  *   - suspend, disconnect ... VBUS lost
  *
  * Once VBUS drop breaks the circuit, the port it's using has to go through
  * normal re-enumeration procedures, starting with enabling VBUS power.
  * Other than re-initializing the hub (plug/unplug, except for root hubs),
  * Linux (2.6) currently has NO mechanisms to initiate that:  no khubd
  * timer, no SRP, no requests through sysfs.
  *
  * If Runtime PM isn't enabled or used, non-SuperSpeed devices may not get
  * suspended until their bus goes into global suspend (i.e., the root
  * hub is suspended).  Nevertheless, we change @udev->state to
  * USB_STATE_SUSPENDED as this is the device's "logical" state.  The actual
  * upstream port setting is stored in @udev->port_is_suspended.
  *
  * Returns 0 on success, else negative errno.
  */
 int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
 {
 	struct usb_hub	*hub = usb_hub_to_struct_hub(udev->parent);
 	struct usb_port *port_dev = hub->ports[udev->portnum - 1];
 	int		port1 = udev->portnum;
 	int		status;
 	bool		really_suspend = true;
 	/* enable remote wakeup when appropriate; this lets the device
 	 * wake up the upstream hub (including maybe the root hub).
 	 *
 	 * NOTE:  OTG devices may issue remote wakeup (or SRP) even when
 	 * we don't explicitly enable it here.
 	 */
 	if (udev->do_remote_wakeup) {
 		status = usb_enable_remote_wakeup(udev);
 		if (status) {
 			dev_dbg(&udev->dev, "won't remote wakeup, status %d\n",
 					status);
 			/* bail if autosuspend is requested */
 			if (PMSG_IS_AUTO(msg))
 				goto err_wakeup;
 		}
 	}
 	/* disable USB2 hardware LPM */
 	if (udev->usb2_hw_lpm_enabled == 1)
 		usb_set_usb2_hardware_lpm(udev, 0);
 	if (usb_disable_ltm(udev)) {
 		dev_err(&udev->dev, "Failed to disable LTM before suspend\n.");
 		status = -ENOMEM;
 		if (PMSG_IS_AUTO(msg))
 			goto err_ltm;
 	}
 	if (usb_unlocked_disable_lpm(udev)) {
 		dev_err(&udev->dev, "Failed to disable LPM before suspend\n.");
 		status = -ENOMEM;
 		if (PMSG_IS_AUTO(msg))
 			goto err_lpm3;
 	}
 	/* see 7.1.7.6 */
 	if (hub_is_superspeed(hub->hdev))
 		status = hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_U3);
 	/*
 	 * For system suspend, we do not need to enable the suspend feature
 	 * on individual USB-2 ports.  The devices will automatically go
 	 * into suspend a few ms after the root hub stops sending packets.
 	 * The USB 2.0 spec calls this "global suspend".
 	 *
 	 * However, many USB hubs have a bug: They don't relay wakeup requests
 	 * from a downstream port if the port's suspend feature isn't on.
 	 * Therefore we will turn on the suspend feature if udev or any of its
 	 * descendants is enabled for remote wakeup.
 	 */
 	else if (PMSG_IS_AUTO(msg) || wakeup_enabled_descendants(udev) > 0)
 		status = set_port_feature(hub->hdev, port1,
 				USB_PORT_FEAT_SUSPEND);
 	else {
 		really_suspend = false;
 		status = 0;
 	}
 	if (status) {
 		dev_dbg(hub->intfdev, "can't suspend port %d, status %d\n",
 				port1, status);
 		/* Try to enable USB3 LPM and LTM again */
 		usb_unlocked_enable_lpm(udev);
  err_lpm3:
 		usb_enable_ltm(udev);
  err_ltm:
 		/* Try to enable USB2 hardware LPM again */
 		if (udev->usb2_hw_lpm_capable == 1)
 			usb_set_usb2_hardware_lpm(udev, 1);
 		if (udev->do_remote_wakeup)
 			(void) usb_disable_remote_wakeup(udev);
  err_wakeup:
 		/* System sleep transitions should never fail */
 		if (!PMSG_IS_AUTO(msg))
 			status = 0;
 	} else {
 		dev_dbg(&udev->dev, "usb %ssuspend, wakeup %d\n",
 				(PMSG_IS_AUTO(msg) ? "auto-" : ""),
 				udev->do_remote_wakeup);
 		if (really_suspend) {
 			udev->port_is_suspended = 1;
 			/* device has up to 10 msec to fully suspend */
 			msleep(10);
 		}
 		usb_set_device_state(udev, USB_STATE_SUSPENDED);
 	}
 	if (status == 0 && !udev->do_remote_wakeup && udev->persist_enabled) {
 		pm_runtime_put_sync(&port_dev->dev);
 		port_dev->did_runtime_put = true;
 	}
 	usb_mark_last_busy(hub->hdev);
 	return status;
 }
 /*
  * If the USB "suspend" state is in use (rather than "global suspend"),
  * many devices will be individually taken out of suspend state using
  * special "resume" signaling.  This routine kicks in shortly after
  * hardware resume signaling is finished, either because of selective
  * resume (by host) or remote wakeup (by device) ... now see what changed
  * in the tree that's rooted at this device.
  *
  * If @udev->reset_resume is set then the device is reset before the
  * status check is done.
  */
 static int finish_port_resume(struct usb_device *udev)
 {
 	int	status = 0;
 	u16	devstatus = 0;
 	/* caller owns the udev device lock */
 	dev_dbg(&udev->dev, "%s\n",
 		udev->reset_resume ? "finish reset-resume" : "finish resume");
 	/* usb ch9 identifies four variants of SUSPENDED, based on what
 	 * state the device resumes to.  Linux currently won't see the
 	 * first two on the host side; they'd be inside hub_port_init()
 	 * during many timeouts, but khubd can't suspend until later.
 	 */
 	usb_set_device_state(udev, udev->actconfig
 			? USB_STATE_CONFIGURED
 			: USB_STATE_ADDRESS);
 	/* 10.5.4.5 says not to reset a suspended port if the attached
 	 * device is enabled for remote wakeup.  Hence the reset
 	 * operation is carried out here, after the port has been
 	 * resumed.
 	 */
 	if (udev->reset_resume) {
 		/*
 		 * If the device morphs or switches modes when it is reset,
 		 * we don't want to perform a reset-resume.  We'll fail the
 		 * resume, which will cause a logical disconnect, and then
 		 * the device will be rediscovered.
 		 */
  retry_reset_resume:
 		if (udev->quirks & USB_QUIRK_RESET)
 			status = -ENODEV;
 		else
 			status = usb_reset_and_verify_device(udev);
 	}
 	/* 10.5.4.5 says be sure devices in the tree are still there.
 	 * For now let's assume the device didn't go crazy on resume,
 	 * and device drivers will know about any resume quirks.
 	 */
 	if (status == 0) {
 		devstatus = 0;
 		status = usb_get_status(udev, USB_RECIP_DEVICE, 0, &devstatus);
 		/* If a normal resume failed, try doing a reset-resume */
 		if (status && !udev->reset_resume && udev->persist_enabled) {
 			dev_dbg(&udev->dev, "retry with reset-resume\n");
 			udev->reset_resume = 1;
 			goto retry_reset_resume;
 		}
 	}
 	if (status) {
 		dev_dbg(&udev->dev, "gone after usb resume? status %d\n",
 				status);
 	/*
 	 * There are a few quirky devices which violate the standard
 	 * by claiming to have remote wakeup enabled after a reset,
 	 * which crash if the feature is cleared, hence check for
 	 * udev->reset_resume
 	 */
 	} else if (udev->actconfig && !udev->reset_resume) {
 		if (udev->speed < USB_SPEED_SUPER) {
 			if (devstatus & (1 << USB_DEVICE_REMOTE_WAKEUP))
 				status = usb_disable_remote_wakeup(udev);
 		} else {
 			status = usb_get_status(udev, USB_RECIP_INTERFACE, 0,
 					&devstatus);
 			if (!status && devstatus & (USB_INTRF_STAT_FUNC_RW_CAP
 					| USB_INTRF_STAT_FUNC_RW))
 				status = usb_disable_remote_wakeup(udev);
 		}
 		if (status)
 			dev_dbg(&udev->dev,
 				"disable remote wakeup, status %d\n",
 				status);
 		status = 0;
 	}
 	return status;
 }
 /*
  * usb_port_resume - re-activate a suspended usb device's upstream port
  * @udev: device to re-activate, not a root hub
  * Context: must be able to sleep; device not locked; pm locks held
  *
  * This will re-activate the suspended device, increasing power usage
  * while letting drivers communicate again with its endpoints.
  * USB resume explicitly guarantees that the power session between
  * the host and the device is the same as it was when the device
  * suspended.
  *
  * If @udev->reset_resume is set then this routine won't check that the
  * port is still enabled.  Furthermore, finish_port_resume() above will
  * reset @udev.  The end result is that a broken power session can be
  * recovered and @udev will appear to persist across a loss of VBUS power.
  *
  * For example, if a host controller doesn't maintain VBUS suspend current
  * during a system sleep or is reset when the system wakes up, all the USB
  * power sessions below it will be broken.  This is especially troublesome
  * for mass-storage devices containing mounted filesystems, since the
  * device will appear to have disconnected and all the memory mappings
  * to it will be lost.  Using the USB_PERSIST facility, the device can be
  * made to appear as if it had not disconnected.
  *
  * This facility can be dangerous.  Although usb_reset_and_verify_device() makes
  * every effort to insure that the same device is present after the
  * reset as before, it cannot provide a 100% guarantee.  Furthermore it's
  * quite possible for a device to remain unaltered but its media to be
  * changed.  If the user replaces a flash memory card while the system is
  * asleep, he will have only himself to blame when the filesystem on the
  * new card is corrupted and the system crashes.
  *
  * Returns 0 on success, else negative errno.
  */
 int usb_port_resume(struct usb_device *udev, pm_message_t msg)
 {
 	struct usb_hub	*hub = usb_hub_to_struct_hub(udev->parent);
 	struct usb_port *port_dev = hub->ports[udev->portnum  - 1];
 	int		port1 = udev->portnum;
 	int		status;
 	u16		portchange, portstatus;
 	if (port_dev->did_runtime_put) {
 		status = pm_runtime_get_sync(&port_dev->dev);
 		port_dev->did_runtime_put = false;
 		if (status < 0) {
 			dev_dbg(&udev->dev, "can't resume usb port, status %d\n",
 					status);
 			return status;
 		}
 	}
 	/* Skip the initial Clear-Suspend step for a remote wakeup */
 	status = hub_port_status(hub, port1, &portstatus, &portchange);
 	if (status == 0 && !port_is_suspended(hub, portstatus))
 		goto SuspendCleared;
 	/* dev_dbg(hub->intfdev, "resume port %d\n", port1); */
 	set_bit(port1, hub->busy_bits);
 	/* see 7.1.7.7; affects power usage, but not budgeting */
 	if (hub_is_superspeed(hub->hdev))
 		status = hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_U0);
 	else
 		status = usb_clear_port_feature(hub->hdev,
 				port1, USB_PORT_FEAT_SUSPEND);
 	if (status) {
 		dev_dbg(hub->intfdev, "can't resume port %d, status %d\n",
 				port1, status);
 	} else {
 		/* drive resume for at least 20 msec */
 		dev_dbg(&udev->dev, "usb %sresume\n",
 				(PMSG_IS_AUTO(msg) ? "auto-" : ""));
 		msleep(25);
 		/* Virtual root hubs can trigger on GET_PORT_STATUS to
 		 * stop resume signaling.  Then finish the resume
 		 * sequence.
 		 */
 		status = hub_port_status(hub, port1, &portstatus, &portchange);
 		/* TRSMRCY = 10 msec */
 		msleep(10);
 	}
  SuspendCleared:
 	if (status == 0) {
 		udev->port_is_suspended = 0;
 		if (hub_is_superspeed(hub->hdev)) {
 			if (portchange & USB_PORT_STAT_C_LINK_STATE)
 				usb_clear_port_feature(hub->hdev, port1,
 					USB_PORT_FEAT_C_PORT_LINK_STATE);
 		} else {
 			if (portchange & USB_PORT_STAT_C_SUSPEND)
 				usb_clear_port_feature(hub->hdev, port1,
 						USB_PORT_FEAT_C_SUSPEND);
 		}
 	}
 	clear_bit(port1, hub->busy_bits);
 	status = check_port_resume_type(udev,
 			hub, port1, status, portchange, portstatus);
 	if (status == 0)
 		status = finish_port_resume(udev);
 	if (status < 0) {
 		dev_dbg(&udev->dev, "can't resume, status %d\n", status);
 		hub_port_logical_disconnect(hub, port1);
 	} else  {
 		/* Try to enable USB2 hardware LPM */
 		if (udev->usb2_hw_lpm_capable == 1)
 			usb_set_usb2_hardware_lpm(udev, 1);
 		/* Try to enable USB3 LTM and LPM */
 		usb_enable_ltm(udev);
 		usb_unlocked_enable_lpm(udev);
 	}
 	return status;
 }
 #ifdef	CONFIG_PM_RUNTIME
 /* caller has locked udev */
 int usb_remote_wakeup(struct usb_device *udev)
 {
 	int	status = 0;
 	if (udev->state == USB_STATE_SUSPENDED) {
 		dev_dbg(&udev->dev, "usb %sresume\n", "wakeup-");
 		status = usb_autoresume_device(udev);
 		if (status == 0) {
 			/* Let the drivers do their thing, then... */
 			usb_autosuspend_device(udev);
 		}
 	}
 	return status;
 }
 #endif
 static int check_ports_changed(struct usb_hub *hub)
 {
 	int port1;
 	for (port1 = 1; port1 <= hub->hdev->maxchild; ++port1) {
 		u16 portstatus, portchange;
 		int status;
 		status = hub_port_status(hub, port1, &portstatus, &portchange);
 		if (!status && portchange)
 			return 1;
 	}
 	return 0;
 }
 static int hub_suspend(struct usb_interface *intf, pm_message_t msg)
 {
 	struct usb_hub		*hub = usb_get_intfdata (intf);
 	struct usb_device	*hdev = hub->hdev;
 	unsigned		port1;
 	int			status;
 	/*
 	 * Warn if children aren't already suspended.
 	 * Also, add up the number of wakeup-enabled descendants.
 	 */
 	hub->wakeup_enabled_descendants = 0;
 	for (port1 = 1; port1 <= hdev->maxchild; port1++) {
 		struct usb_device	*udev;
 		udev = hub->ports[port1 - 1]->child;
 		if (udev && udev->can_submit) {
 			dev_warn(&intf->dev, "port %d not suspended yet\n",
 					port1);
 			if (PMSG_IS_AUTO(msg))
 				return -EBUSY;
 		}
 		if (udev)
 			hub->wakeup_enabled_descendants +=
 					wakeup_enabled_descendants(udev);
 	}
 	if (hdev->do_remote_wakeup && hub->quirk_check_port_auto_suspend) {
 		/* check if there are changes pending on hub ports */
 		if (check_ports_changed(hub)) {
 			if (PMSG_IS_AUTO(msg))
 				return -EBUSY;
 			pm_wakeup_event(&hdev->dev, 2000);
 		}
 	}
 	if (hub_is_superspeed(hdev) && hdev->do_remote_wakeup) {
 		/* Enable hub to send remote wakeup for all ports. */
 		for (port1 = 1; port1 <= hdev->maxchild; port1++) {
 			status = set_port_feature(hdev,
 					port1 |
 					USB_PORT_FEAT_REMOTE_WAKE_CONNECT |
 					USB_PORT_FEAT_REMOTE_WAKE_DISCONNECT |
 					USB_PORT_FEAT_REMOTE_WAKE_OVER_CURRENT,
 					USB_PORT_FEAT_REMOTE_WAKE_MASK);
 		}
 	}
 	dev_dbg(&intf->dev, "%s\n", __func__);
 	/* stop khubd and related activity */
 	hub_quiesce(hub, HUB_SUSPEND);
 	return 0;
 }
 static int hub_resume(struct usb_interface *intf)
 {
 	struct usb_hub *hub = usb_get_intfdata(intf);
 	dev_dbg(&intf->dev, "%s\n", __func__);
 	hub_activate(hub, HUB_RESUME);
 	return 0;
 }
 static int hub_reset_resume(struct usb_interface *intf)
 {
 	struct usb_hub *hub = usb_get_intfdata(intf);
 	dev_dbg(&intf->dev, "%s\n", __func__);
 	hub_activate(hub, HUB_RESET_RESUME);
 	return 0;
 }
 /**
  * usb_root_hub_lost_power - called by HCD if the root hub lost Vbus power
  * @rhdev: struct usb_device for the root hub
  *
  * The USB host controller driver calls this function when its root hub
  * is resumed and Vbus power has been interrupted or the controller
  * has been reset.  The routine marks @rhdev as having lost power.
  * When the hub driver is resumed it will take notice and carry out
  * power-session recovery for all the "USB-PERSIST"-enabled child devices;
  * the others will be disconnected.
  */
 void usb_root_hub_lost_power(struct usb_device *rhdev)
 {
 	dev_warn(&rhdev->dev, "root hub lost power or was reset\n");
 	rhdev->reset_resume = 1;
 }
 EXPORT_SYMBOL_GPL(usb_root_hub_lost_power);
 static const char * const usb3_lpm_names[]  = {
 	"U0",
 	"U1",
 	"U2",
 	"U3",
 };
 /*
  * Send a Set SEL control transfer to the device, prior to enabling
  * device-initiated U1 or U2.  This lets the device know the exit latencies from
  * the time the device initiates a U1 or U2 exit, to the time it will receive a
  * packet from the host.
  *
  * This function will fail if the SEL or PEL values for udev are greater than
  * the maximum allowed values for the link state to be enabled.
  */
 static int usb_req_set_sel(struct usb_device *udev, enum usb3_link_state state)
 {
 	struct usb_set_sel_req *sel_values;
 	unsigned long long u1_sel;
 	unsigned long long u1_pel;
 	unsigned long long u2_sel;
 	unsigned long long u2_pel;
 	int ret;
 	if (udev->state != USB_STATE_CONFIGURED)
 		return 0;
 	/* Convert SEL and PEL stored in ns to us */
 	u1_sel = DIV_ROUND_UP(udev->u1_params.sel, 1000);
 	u1_pel = DIV_ROUND_UP(udev->u1_params.pel, 1000);
 	u2_sel = DIV_ROUND_UP(udev->u2_params.sel, 1000);
 	u2_pel = DIV_ROUND_UP(udev->u2_params.pel, 1000);
 	/*
 	 * Make sure that the calculated SEL and PEL values for the link
 	 * state we're enabling aren't bigger than the max SEL/PEL
 	 * value that will fit in the SET SEL control transfer.
 	 * Otherwise the device would get an incorrect idea of the exit
 	 * latency for the link state, and could start a device-initiated
 	 * U1/U2 when the exit latencies are too high.
 	 */
 	if ((state == USB3_LPM_U1 &&
 				(u1_sel > USB3_LPM_MAX_U1_SEL_PEL ||
 				 u1_pel > USB3_LPM_MAX_U1_SEL_PEL)) ||
 			(state == USB3_LPM_U2 &&
 			 (u2_sel > USB3_LPM_MAX_U2_SEL_PEL ||
 			  u2_pel > USB3_LPM_MAX_U2_SEL_PEL))) {
 		dev_dbg(&udev->dev, "Device-initiated %s disabled due to long SEL %llu us or PEL %llu us\n",
 				usb3_lpm_names[state], u1_sel, u1_pel);
 		return -EINVAL;
 	}
 	/*
 	 * If we're enabling device-initiated LPM for one link state,
 	 * but the other link state has a too high SEL or PEL value,
 	 * just set those values to the max in the Set SEL request.
 	 */
 	if (u1_sel > USB3_LPM_MAX_U1_SEL_PEL)
 		u1_sel = USB3_LPM_MAX_U1_SEL_PEL;
 	if (u1_pel > USB3_LPM_MAX_U1_SEL_PEL)
 		u1_pel = USB3_LPM_MAX_U1_SEL_PEL;
 	if (u2_sel > USB3_LPM_MAX_U2_SEL_PEL)
 		u2_sel = USB3_LPM_MAX_U2_SEL_PEL;
 	if (u2_pel > USB3_LPM_MAX_U2_SEL_PEL)
 		u2_pel = USB3_LPM_MAX_U2_SEL_PEL;
 	/*
 	 * usb_enable_lpm() can be called as part of a failed device reset,
 	 * which may be initiated by an error path of a mass storage driver.
 	 * Therefore, use GFP_NOIO.
 	 */
 	sel_values = kmalloc(sizeof *(sel_values), GFP_NOIO);
 	if (!sel_values)
 		return -ENOMEM;
 	sel_values->u1_sel = u1_sel;
 	sel_values->u1_pel = u1_pel;
 	sel_values->u2_sel = cpu_to_le16(u2_sel);
 	sel_values->u2_pel = cpu_to_le16(u2_pel);
 	ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
 			USB_REQ_SET_SEL,
 			USB_RECIP_DEVICE,
 			0, 0,
 			sel_values, sizeof *(sel_values),
 			USB_CTRL_SET_TIMEOUT);
 	kfree(sel_values);
 	return ret;
 }
 /*
  * Enable or disable device-initiated U1 or U2 transitions.
  */
 static int usb_set_device_initiated_lpm(struct usb_device *udev,
 		enum usb3_link_state state, bool enable)
 {
 	int ret;
 	int feature;
 	switch (state) {
 	case USB3_LPM_U1:
 		feature = USB_DEVICE_U1_ENABLE;
 		break;
 	case USB3_LPM_U2:
 		feature = USB_DEVICE_U2_ENABLE;
 		break;
 	default:
 		dev_warn(&udev->dev, "%s: Can't %s non-U1 or U2 state.\n",
 				__func__, enable ? "enable" : "disable");
 		return -EINVAL;
 	}
 	if (udev->state != USB_STATE_CONFIGURED) {
 		dev_dbg(&udev->dev, "%s: Can't %s %s state "
 				"for unconfigured device.\n",
 				__func__, enable ? "enable" : "disable",
 				usb3_lpm_names[state]);
 		return 0;
 	}
 	if (enable) {
 		/*
 		 * Now send the control transfer to enable device-initiated LPM
 		 * for either U1 or U2.
 		 */
 		ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
 				USB_REQ_SET_FEATURE,
 				USB_RECIP_DEVICE,
 				feature,
 				0, NULL, 0,
 				USB_CTRL_SET_TIMEOUT);
 	} else {
 		ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
 				USB_REQ_CLEAR_FEATURE,
 				USB_RECIP_DEVICE,
 				feature,
 				0, NULL, 0,
 				USB_CTRL_SET_TIMEOUT);
 	}
 	if (ret < 0) {
 		dev_warn(&udev->dev, "%s of device-initiated %s failed.\n",
 				enable ? "Enable" : "Disable",
 				usb3_lpm_names[state]);
 		return -EBUSY;
 	}
 	return 0;
 }
 static int usb_set_lpm_timeout(struct usb_device *udev,
 		enum usb3_link_state state, int timeout)
 {
 	int ret;
 	int feature;
 	switch (state) {
 	case USB3_LPM_U1:
 		feature = USB_PORT_FEAT_U1_TIMEOUT;
 		break;
 	case USB3_LPM_U2:
 		feature = USB_PORT_FEAT_U2_TIMEOUT;
 		break;
 	default:
 		dev_warn(&udev->dev, "%s: Can't set timeout for non-U1 or U2 state.\n",
 				__func__);
 		return -EINVAL;
 	}
 	if (state == USB3_LPM_U1 && timeout > USB3_LPM_U1_MAX_TIMEOUT &&
 			timeout != USB3_LPM_DEVICE_INITIATED) {
 		dev_warn(&udev->dev, "Failed to set %s timeout to 0x%x, "
 				"which is a reserved value.\n",
 				usb3_lpm_names[state], timeout);
 		return -EINVAL;
 	}
 	ret = set_port_feature(udev->parent,
 			USB_PORT_LPM_TIMEOUT(timeout) | udev->portnum,
 			feature);
 	if (ret < 0) {
 		dev_warn(&udev->dev, "Failed to set %s timeout to 0x%x,"
 				"error code %i\n", usb3_lpm_names[state],
 				timeout, ret);
 		return -EBUSY;
 	}
 	if (state == USB3_LPM_U1)
 		udev->u1_params.timeout = timeout;
 	else
 		udev->u2_params.timeout = timeout;
 	return 0;
 }
 /*
  * Enable the hub-initiated U1/U2 idle timeouts, and enable device-initiated
  * U1/U2 entry.
  *
  * We will attempt to enable U1 or U2, but there are no guarantees that the
  * control transfers to set the hub timeout or enable device-initiated U1/U2
  * will be successful.
  *
  * If we cannot set the parent hub U1/U2 timeout, we attempt to let the xHCI
  * driver know about it.  If that call fails, it should be harmless, and just
  * take up more slightly more bus bandwidth for unnecessary U1/U2 exit latency.
  */
 static void usb_enable_link_state(struct usb_hcd *hcd, struct usb_device *udev,
 		enum usb3_link_state state)
 {
 	int timeout, ret;
 	__u8 u1_mel = udev->bos->ss_cap->bU1devExitLat;
 	__le16 u2_mel = udev->bos->ss_cap->bU2DevExitLat;
 	/* If the device says it doesn't have *any* exit latency to come out of
 	 * U1 or U2, it's probably lying.  Assume it doesn't implement that link
 	 * state.
 	 */
 	if ((state == USB3_LPM_U1 && u1_mel == 0) ||
 			(state == USB3_LPM_U2 && u2_mel == 0))
 		return;
 	/*
 	 * First, let the device know about the exit latencies
 	 * associated with the link state we're about to enable.
 	 */
 	ret = usb_req_set_sel(udev, state);
 	if (ret < 0) {
 		dev_warn(&udev->dev, "Set SEL for device-initiated %s failed.\n",
 				usb3_lpm_names[state]);
 		return;
 	}
 	/* We allow the host controller to set the U1/U2 timeout internally
 	 * first, so that it can change its schedule to account for the
 	 * additional latency to send data to a device in a lower power
 	 * link state.
 	 */
 	timeout = hcd->driver->enable_usb3_lpm_timeout(hcd, udev, state);
 	/* xHCI host controller doesn't want to enable this LPM state. */
 	if (timeout == 0)
 		return;
 	if (timeout < 0) {
 		dev_warn(&udev->dev, "Could not enable %s link state, "
 				"xHCI error %i.\n", usb3_lpm_names[state],
 				timeout);
 		return;
 	}
 	if (usb_set_lpm_timeout(udev, state, timeout))
 		/* If we can't set the parent hub U1/U2 timeout,
 		 * device-initiated LPM won't be allowed either, so let the xHCI
 		 * host know that this link state won't be enabled.
 		 */
 		hcd->driver->disable_usb3_lpm_timeout(hcd, udev, state);
 	/* Only a configured device will accept the Set Feature U1/U2_ENABLE */
 	else if (udev->actconfig)
 		usb_set_device_initiated_lpm(udev, state, true);
 }
 /*
  * Disable the hub-initiated U1/U2 idle timeouts, and disable device-initiated
  * U1/U2 entry.
  *
  * If this function returns -EBUSY, the parent hub will still allow U1/U2 entry.
  * If zero is returned, the parent will not allow the link to go into U1/U2.
  *
  * If zero is returned, device-initiated U1/U2 entry may still be enabled, but
  * it won't have an effect on the bus link state because the parent hub will
  * still disallow device-initiated U1/U2 entry.
  *
  * If zero is returned, the xHCI host controller may still think U1/U2 entry is
  * possible.  The result will be slightly more bus bandwidth will be taken up
  * (to account for U1/U2 exit latency), but it should be harmless.
  */
 static int usb_disable_link_state(struct usb_hcd *hcd, struct usb_device *udev,
 		enum usb3_link_state state)
 {
 	int feature;
 	switch (state) {
 	case USB3_LPM_U1:
 		feature = USB_PORT_FEAT_U1_TIMEOUT;
 		break;
 	case USB3_LPM_U2:
 		feature = USB_PORT_FEAT_U2_TIMEOUT;
 		break;
 	default:
 		dev_warn(&udev->dev, "%s: Can't disable non-U1 or U2 state.\n",
 				__func__);
 		return -EINVAL;
 	}
 	if (usb_set_lpm_timeout(udev, state, 0))
 		return -EBUSY;
 	usb_set_device_initiated_lpm(udev, state, false);
 	if (hcd->driver->disable_usb3_lpm_timeout(hcd, udev, state))
 		dev_warn(&udev->dev, "Could not disable xHCI %s timeout, "
 				"bus schedule bandwidth may be impacted.\n",
 				usb3_lpm_names[state]);
 	return 0;
 }
 /*
  * Disable hub-initiated and device-initiated U1 and U2 entry.
  * Caller must own the bandwidth_mutex.
  *
  * This will call usb_enable_lpm() on failure, which will decrement
  * lpm_disable_count, and will re-enable LPM if lpm_disable_count reaches zero.
  */
 int usb_disable_lpm(struct usb_device *udev)
 {
 	struct usb_hcd *hcd;
 	if (!udev || !udev->parent ||
 			udev->speed != USB_SPEED_SUPER ||
 			!udev->lpm_capable)
 		return 0;
 	hcd = bus_to_hcd(udev->bus);
 	if (!hcd || !hcd->driver->disable_usb3_lpm_timeout)
 		return 0;
 	udev->lpm_disable_count++;
 	if ((udev->u1_params.timeout == 0 && udev->u2_params.timeout == 0))
 		return 0;
 	/* If LPM is enabled, attempt to disable it. */
 	if (usb_disable_link_state(hcd, udev, USB3_LPM_U1))
 		goto enable_lpm;
 	if (usb_disable_link_state(hcd, udev, USB3_LPM_U2))
 		goto enable_lpm;
 	return 0;
 enable_lpm:
 	usb_enable_lpm(udev);
 	return -EBUSY;
 }
 EXPORT_SYMBOL_GPL(usb_disable_lpm);
 /* Grab the bandwidth_mutex before calling usb_disable_lpm() */
 int usb_unlocked_disable_lpm(struct usb_device *udev)
 {
 	struct usb_hcd *hcd = bus_to_hcd(udev->bus);
 	int ret;
 	if (!hcd)
 		return -EINVAL;
 	mutex_lock(hcd->bandwidth_mutex);
 	ret = usb_disable_lpm(udev);
 	mutex_unlock(hcd->bandwidth_mutex);
 	return ret;
 }
 EXPORT_SYMBOL_GPL(usb_unlocked_disable_lpm);
 /*
  * Attempt to enable device-initiated and hub-initiated U1 and U2 entry.  The
  * xHCI host policy may prevent U1 or U2 from being enabled.
  *
  * Other callers may have disabled link PM, so U1 and U2 entry will be disabled
  * until the lpm_disable_count drops to zero.  Caller must own the
  * bandwidth_mutex.
  */
 void usb_enable_lpm(struct usb_device *udev)
 {
 	struct usb_hcd *hcd;
 	if (!udev || !udev->parent ||
 			udev->speed != USB_SPEED_SUPER ||
 			!udev->lpm_capable)
 		return;
 	udev->lpm_disable_count--;
 	hcd = bus_to_hcd(udev->bus);
 	/* Double check that we can both enable and disable LPM.
 	 * Device must be configured to accept set feature U1/U2 timeout.
 	 */
 	if (!hcd || !hcd->driver->enable_usb3_lpm_timeout ||
 			!hcd->driver->disable_usb3_lpm_timeout)
 		return;
 	if (udev->lpm_disable_count > 0)
 		return;
 	usb_enable_link_state(hcd, udev, USB3_LPM_U1);
 	usb_enable_link_state(hcd, udev, USB3_LPM_U2);
 }
 EXPORT_SYMBOL_GPL(usb_enable_lpm);
 /* Grab the bandwidth_mutex before calling usb_enable_lpm() */
 void usb_unlocked_enable_lpm(struct usb_device *udev)
 {
 	struct usb_hcd *hcd = bus_to_hcd(udev->bus);
 	if (!hcd)
 		return;
 	mutex_lock(hcd->bandwidth_mutex);
 	usb_enable_lpm(udev);
 	mutex_unlock(hcd->bandwidth_mutex);
 }
 EXPORT_SYMBOL_GPL(usb_unlocked_enable_lpm);
 #else	/* CONFIG_PM */
 #define hub_suspend		NULL
 #define hub_resume		NULL
 #define hub_reset_resume	NULL
 int usb_disable_lpm(struct usb_device *udev)
 {
 	return 0;
 }
 EXPORT_SYMBOL_GPL(usb_disable_lpm);
 void usb_enable_lpm(struct usb_device *udev) { }
 EXPORT_SYMBOL_GPL(usb_enable_lpm);
 int usb_unlocked_disable_lpm(struct usb_device *udev)
 {
 	return 0;
 }
 EXPORT_SYMBOL_GPL(usb_unlocked_disable_lpm);
 void usb_unlocked_enable_lpm(struct usb_device *udev) { }
 EXPORT_SYMBOL_GPL(usb_unlocked_enable_lpm);
 int usb_disable_ltm(struct usb_device *udev)
 {
 	return 0;
 }
 EXPORT_SYMBOL_GPL(usb_disable_ltm);
 void usb_enable_ltm(struct usb_device *udev) { }
 EXPORT_SYMBOL_GPL(usb_enable_ltm);
 #endif	/* CONFIG_PM */
 /* USB 2.0 spec, 7.1.7.3 / fig 7-29:
  *
  * Between connect detection and reset signaling there must be a delay
  * of 100ms at least for debounce and power-settling.  The corresponding
  * timer shall restart whenever the downstream port detects a disconnect.
  *
  * Apparently there are some bluetooth and irda-dongles and a number of
  * low-speed devices for which this debounce period may last over a second.
  * Not covered by the spec - but easy to deal with.
  *
  * This implementation uses a 1500ms total debounce timeout; if the
  * connection isn't stable by then it returns -ETIMEDOUT.  It checks
  * every 25ms for transient disconnects.  When the port status has been
  * unchanged for 100ms it returns the port status.
  */
 int hub_port_debounce(struct usb_hub *hub, int port1, bool must_be_connected)
 {
 	int ret;
 	int total_time, stable_time = 0;
 	u16 portchange, portstatus;
 	unsigned connection = 0xffff;
 	for (total_time = 0; ; total_time += HUB_DEBOUNCE_STEP) {
 		ret = hub_port_status(hub, port1, &portstatus, &portchange);
 		if (ret < 0)
 			return ret;
 		if (!(portchange & USB_PORT_STAT_C_CONNECTION) &&
 		     (portstatus & USB_PORT_STAT_CONNECTION) == connection) {
 			if (!must_be_connected ||
 			     (connection == USB_PORT_STAT_CONNECTION))
 				stable_time += HUB_DEBOUNCE_STEP;
 			if (stable_time >= HUB_DEBOUNCE_STABLE)
 				break;
 		} else {
 			stable_time = 0;
 			connection = portstatus & USB_PORT_STAT_CONNECTION;
 		}
 		if (portchange & USB_PORT_STAT_C_CONNECTION) {
 			usb_clear_port_feature(hub->hdev, port1,
 					USB_PORT_FEAT_C_CONNECTION);
 		}
 		if (total_time >= HUB_DEBOUNCE_TIMEOUT)
 			break;
 		msleep(HUB_DEBOUNCE_STEP);
 	}
 	dev_dbg (hub->intfdev,
 		"debounce: port %d: total %dms stable %dms status 0x%x\n",
 		port1, total_time, stable_time, portstatus);
 	if (stable_time < HUB_DEBOUNCE_STABLE)
 		return -ETIMEDOUT;
 	return portstatus;
 }
 void usb_ep0_reinit(struct usb_device *udev)
 {
 	usb_disable_endpoint(udev, 0 + USB_DIR_IN, true);
 	usb_disable_endpoint(udev, 0 + USB_DIR_OUT, true);
 	usb_enable_endpoint(udev, &udev->ep0, true);
 }
 EXPORT_SYMBOL_GPL(usb_ep0_reinit);
 #define usb_sndaddr0pipe()	(PIPE_CONTROL << 30)
 #define usb_rcvaddr0pipe()	((PIPE_CONTROL << 30) | USB_DIR_IN)
 static int hub_set_address(struct usb_device *udev, int devnum)
 {
 	int retval;
 	struct usb_hcd *hcd = bus_to_hcd(udev->bus);
 	/*
 	 * The host controller will choose the device address,
 	 * instead of the core having chosen it earlier
 	 */
 	if (!hcd->driver->address_device && devnum <= 1)
 		return -EINVAL;
 	if (udev->state == USB_STATE_ADDRESS)
 		return 0;
 	if (udev->state != USB_STATE_DEFAULT)
 		return -EINVAL;
 	if (hcd->driver->address_device)
 		retval = hcd->driver->address_device(hcd, udev);
 	else
 		retval = usb_control_msg(udev, usb_sndaddr0pipe(),
 				USB_REQ_SET_ADDRESS, 0, devnum, 0,
 				NULL, 0, USB_CTRL_SET_TIMEOUT);
 	if (retval == 0) {
 		update_devnum(udev, devnum);
 		/* Device now using proper address. */
 		usb_set_device_state(udev, USB_STATE_ADDRESS);
 		usb_ep0_reinit(udev);
 	}
 	return retval;
 }
 /*
  * There are reports of USB 3.0 devices that say they support USB 2.0 Link PM
  * when they're plugged into a USB 2.0 port, but they don't work when LPM is
  * enabled.
  *
  * Only enable USB 2.0 Link PM if the port is internal (hardwired), or the
  * device says it supports the new USB 2.0 Link PM errata by setting the BESL
  * support bit in the BOS descriptor.
  */
 static void hub_set_initial_usb2_lpm_policy(struct usb_device *udev)
 {
 	int connect_type;
 	if (!udev->usb2_hw_lpm_capable)
 		return;
 	connect_type = usb_get_hub_port_connect_type(udev->parent,
 			udev->portnum);
 	if ((udev->bos->ext_cap->bmAttributes & cpu_to_le32(USB_BESL_SUPPORT)) ||
 			connect_type == USB_PORT_CONNECT_TYPE_HARD_WIRED) {
 		udev->usb2_hw_lpm_allowed = 1;
 		usb_set_usb2_hardware_lpm(udev, 1);
 	}
 }
 static int hub_enable_device(struct usb_device *udev)
 {
 	struct usb_hcd *hcd = bus_to_hcd(udev->bus);
 	if (!hcd->driver->enable_device)
 		return 0;
 	if (udev->state == USB_STATE_ADDRESS)
 		return 0;
 	if (udev->state != USB_STATE_DEFAULT)
 		return -EINVAL;
 	return hcd->driver->enable_device(hcd, udev);
 }
 /* Reset device, (re)assign address, get device descriptor.
  * Device connection must be stable, no more debouncing needed.
  * Returns device in USB_STATE_ADDRESS, except on error.
  *
  * If this is called for an already-existing device (as part of
  * usb_reset_and_verify_device), the caller must own the device lock.  For a
  * newly detected device that is not accessible through any global
  * pointers, it's not necessary to lock the device.
  */
 static int
 hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
 		int retry_counter)
 {
 	static DEFINE_MUTEX(usb_address0_mutex);
 	struct usb_device	*hdev = hub->hdev;
 	struct usb_hcd		*hcd = bus_to_hcd(hdev->bus);
 	int			i, j, retval;
 	unsigned		delay = HUB_SHORT_RESET_TIME;
 	enum usb_device_speed	oldspeed = udev->speed;
 	const char		*speed;
 	int			devnum = udev->devnum;
 	/* root hub ports have a slightly longer reset period
 	 * (from USB 2.0 spec, section 7.1.7.5)
 	 */
 	if (!hdev->parent) {
 		delay = HUB_ROOT_RESET_TIME;
 		if (port1 == hdev->bus->otg_port)
 			hdev->bus->b_hnp_enable = 0;
 	}
 	/* Some low speed devices have problems with the quick delay, so */
 	/*  be a bit pessimistic with those devices. RHbug #23670 */
 	if (oldspeed == USB_SPEED_LOW)
 		delay = HUB_LONG_RESET_TIME;
 	mutex_lock(&usb_address0_mutex);
 	/* Reset the device; full speed may morph to high speed */
 	/* FIXME a USB 2.0 device may morph into SuperSpeed on reset. */
 	retval = hub_port_reset(hub, port1, udev, delay, false);
 	if (retval < 0)		/* error or disconnect */
 		goto fail;
 	/* success, speed is known */
 	retval = -ENODEV;
 	if (oldspeed != USB_SPEED_UNKNOWN && oldspeed != udev->speed) {
 		dev_dbg(&udev->dev, "device reset changed speed!\n");
 		goto fail;
 	}
 	oldspeed = udev->speed;
 	/* USB 2.0 section 5.5.3 talks about ep0 maxpacket ...
 	 * it's fixed size except for full speed devices.
 	 * For Wireless USB devices, ep0 max packet is always 512 (tho
 	 * reported as 0xff in the device descriptor). WUSB1.0[4.8.1].
 	 */
 	switch (udev->speed) {
 	case USB_SPEED_SUPER:
 	case USB_SPEED_WIRELESS:	/* fixed at 512 */
 		udev->ep0.desc.wMaxPacketSize = cpu_to_le16(512);
 		break;
 	case USB_SPEED_HIGH:		/* fixed at 64 */
 		udev->ep0.desc.wMaxPacketSize = cpu_to_le16(64);
 		break;
 	case USB_SPEED_FULL:		/* 8, 16, 32, or 64 */
 		/* to determine the ep0 maxpacket size, try to read
 		 * the device descriptor to get bMaxPacketSize0 and
 		 * then correct our initial guess.
 		 */
 		udev->ep0.desc.wMaxPacketSize = cpu_to_le16(64);
 		break;
 	case USB_SPEED_LOW:		/* fixed at 8 */
 		udev->ep0.desc.wMaxPacketSize = cpu_to_le16(8);
 		break;
 	default:
 		goto fail;
 	}
 	if (udev->speed == USB_SPEED_WIRELESS)
 		speed = "variable speed Wireless";
 	else
 		speed = usb_speed_string(udev->speed);
 	if (udev->speed != USB_SPEED_SUPER)
 		dev_info(&udev->dev,
 				"%s %s USB device number %d using %s\n",
 				(udev->config) ? "reset" : "new", speed,
 				devnum, udev->bus->controller->driver->name);
 	/* Set up TT records, if needed  */
 	if (hdev->tt) {
 		udev->tt = hdev->tt;
 		udev->ttport = hdev->ttport;
 	} else if (udev->speed != USB_SPEED_HIGH
 			&& hdev->speed == USB_SPEED_HIGH) {
 		if (!hub->tt.hub) {
 			dev_err(&udev->dev, "parent hub has no TT\n");
 			retval = -EINVAL;
 			goto fail;
 		}
 		udev->tt = &hub->tt;
 		udev->ttport = port1;
 	}
 	/* Why interleave GET_DESCRIPTOR and SET_ADDRESS this way?
 	 * Because device hardware and firmware is sometimes buggy in
 	 * this area, and this is how Linux has done it for ages.
 	 * Change it cautiously.
 	 *
 	 * NOTE:  If use_new_scheme() is true we will start by issuing
 	 * a 64-byte GET_DESCRIPTOR request.  This is what Windows does,
 	 * so it may help with some non-standards-compliant devices.
 	 * Otherwise we start with SET_ADDRESS and then try to read the
 	 * first 8 bytes of the device descriptor to get the ep0 maxpacket
 	 * value.
 	 */
 	for (i = 0; i < GET_DESCRIPTOR_TRIES; (++i, msleep(100))) {
 		bool did_new_scheme = false;
 		if (use_new_scheme(udev, retry_counter)) {
 			struct usb_device_descriptor *buf;
 			int r = 0;
 			did_new_scheme = true;
 			retval = hub_enable_device(udev);
 			if (retval < 0) {
 				dev_err(&udev->dev,
 					"hub failed to enable device, error %d\n",
 					retval);
 				goto fail;
 			}
 #define GET_DESCRIPTOR_BUFSIZE	64
 			buf = kmalloc(GET_DESCRIPTOR_BUFSIZE, GFP_NOIO);
 			if (!buf) {
 				retval = -ENOMEM;
 				continue;
 			}
 			/* Retry on all errors; some devices are flakey.
 			 * 255 is for WUSB devices, we actually need to use
 			 * 512 (WUSB1.0[4.8.1]).
 			 */
 			for (j = 0; j < 3; ++j) {
 				buf->bMaxPacketSize0 = 0;
 				r = usb_control_msg(udev, usb_rcvaddr0pipe(),
 					USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
 					USB_DT_DEVICE << 8, 0,
 					buf, GET_DESCRIPTOR_BUFSIZE,
 					initial_descriptor_timeout);
 				switch (buf->bMaxPacketSize0) {
 				case 8: case 16: case 32: case 64: case 255:
 					if (buf->bDescriptorType ==
 							USB_DT_DEVICE) {
 						r = 0;
 						break;
 					}
 					/* FALL THROUGH */
 				default:
 					if (r == 0)
 						r = -EPROTO;
 					break;
 				}
 				if (r == 0)
 					break;
 			}
 			udev->descriptor.bMaxPacketSize0 =
 					buf->bMaxPacketSize0;
 			kfree(buf);
 			retval = hub_port_reset(hub, port1, udev, delay, false);
 			if (retval < 0)		/* error or disconnect */
 				goto fail;
 			if (oldspeed != udev->speed) {
 				dev_dbg(&udev->dev,
 					"device reset changed speed!\n");
 				retval = -ENODEV;
 				goto fail;
 			}
 			if (r) {
 				if (r != -ENODEV)
 					dev_err(&udev->dev, "device descriptor read/64, error %d\n",
 							r);
 				retval = -EMSGSIZE;
 				continue;
 			}
 #undef GET_DESCRIPTOR_BUFSIZE
 		}
 		/*
 		 * If device is WUSB, we already assigned an
 		 * unauthorized address in the Connect Ack sequence;
 		 * authorization will assign the final address.
 		 */
 		if (udev->wusb == 0) {
 			for (j = 0; j < SET_ADDRESS_TRIES; ++j) {
 				retval = hub_set_address(udev, devnum);
 				if (retval >= 0)
 					break;
 				msleep(200);
 			}
 			if (retval < 0) {
 				if (retval != -ENODEV)
 					dev_err(&udev->dev, "device not accepting address %d, error %d\n",
 							devnum, retval);
 				goto fail;
 			}
 			if (udev->speed == USB_SPEED_SUPER) {
 				devnum = udev->devnum;
 				dev_info(&udev->dev,
 						"%s SuperSpeed USB device number %d using %s\n",
 						(udev->config) ? "reset" : "new",
 						devnum, udev->bus->controller->driver->name);
 			}
 			/* cope with hardware quirkiness:
 			 *  - let SET_ADDRESS settle, some device hardware wants it
 			 *  - read ep0 maxpacket even for high and low speed,
 			 */
 			msleep(10);
 			/* use_new_scheme() checks the speed which may have
 			 * changed since the initial look so we cache the result
 			 * in did_new_scheme
 			 */
 			if (did_new_scheme)
 				break;
 		}
 		retval = usb_get_device_descriptor(udev, 8);
 		if (retval < 8) {
 			if (retval != -ENODEV)
 				dev_err(&udev->dev,
 					"device descriptor read/8, error %d\n",
 					retval);
 			if (retval >= 0)
 				retval = -EMSGSIZE;
 		} else {
 			retval = 0;
 			break;
 		}
 	}
 	if (retval)
 		goto fail;
 	if (hcd->phy && !hdev->parent)
 		usb_phy_notify_connect(hcd->phy, udev->speed);
 	/*
 	 * Some superspeed devices have finished the link training process
 	 * and attached to a superspeed hub port, but the device descriptor
 	 * got from those devices show they aren't superspeed devices. Warm
 	 * reset the port attached by the devices can fix them.
 	 */
 	if ((udev->speed == USB_SPEED_SUPER) &&
 			(le16_to_cpu(udev->descriptor.bcdUSB) < 0x0300)) {
 		dev_err(&udev->dev, "got a wrong device descriptor, "
 				"warm reset device\n");
 		hub_port_reset(hub, port1, udev,
 				HUB_BH_RESET_TIME, true);
 		retval = -EINVAL;
 		goto fail;
 	}
 	if (udev->descriptor.bMaxPacketSize0 == 0xff ||
 			udev->speed == USB_SPEED_SUPER)
 		i = 512;
 	else
 		i = udev->descriptor.bMaxPacketSize0;
 	if (usb_endpoint_maxp(&udev->ep0.desc) != i) {
 		if (udev->speed == USB_SPEED_LOW ||
 				!(i == 8 || i == 16 || i == 32 || i == 64)) {
 			dev_err(&udev->dev, "Invalid ep0 maxpacket: %d\n", i);
 			retval = -EMSGSIZE;
 			goto fail;
 		}
 		if (udev->speed == USB_SPEED_FULL)
 			dev_dbg(&udev->dev, "ep0 maxpacket = %d\n", i);
 		else
 			dev_warn(&udev->dev, "Using ep0 maxpacket: %d\n", i);
 		udev->ep0.desc.wMaxPacketSize = cpu_to_le16(i);
 		usb_ep0_reinit(udev);
 	}
 	retval = usb_get_device_descriptor(udev, USB_DT_DEVICE_SIZE);
 	if (retval < (signed)sizeof(udev->descriptor)) {
 		if (retval != -ENODEV)
 			dev_err(&udev->dev, "device descriptor read/all, error %d\n",
 					retval);
 		if (retval >= 0)
 			retval = -ENOMSG;
 		goto fail;
 	}
 	if (udev->wusb == 0 && le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0201) {
 		retval = usb_get_bos_descriptor(udev);
 		if (!retval) {
 			udev->lpm_capable = usb_device_supports_lpm(udev);
 			usb_set_lpm_parameters(udev);
 		}
 	}
 	retval = 0;
 	/* notify HCD that we have a device connected and addressed */
 	if (hcd->driver->update_device)
 		hcd->driver->update_device(hcd, udev);
 	hub_set_initial_usb2_lpm_policy(udev);
 fail:
 	if (retval) {
 		hub_port_disable(hub, port1, 0);
 		update_devnum(udev, devnum);	/* for disconnect processing */
 	}
 	mutex_unlock(&usb_address0_mutex);
 	return retval;
 }
 static void
 check_highspeed (struct usb_hub *hub, struct usb_device *udev, int port1)
 {
 	struct usb_qualifier_descriptor	*qual;
 	int				status;
 	qual = kmalloc (sizeof *qual, GFP_KERNEL);
 	if (qual == NULL)
 		return;
 	status = usb_get_descriptor (udev, USB_DT_DEVICE_QUALIFIER, 0,
 			qual, sizeof *qual);
 	if (status == sizeof *qual) {
 		dev_info(&udev->dev, "not running at top speed; "
 			"connect to a high speed hub\n");
 		/* hub LEDs are probably harder to miss than syslog */
 		if (hub->has_indicators) {
 			hub->indicator[port1-1] = INDICATOR_GREEN_BLINK;
 			queue_delayed_work(system_power_efficient_wq,
 					&hub->leds, 0);
 		}
 	}
 	kfree(qual);
 }
 static unsigned
 hub_power_remaining (struct usb_hub *hub)
 {
 	struct usb_device *hdev = hub->hdev;
 	int remaining;
 	int port1;
 	if (!hub->limited_power)
 		return 0;
 	remaining = hdev->bus_mA - hub->descriptor->bHubContrCurrent;
 	for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
 		struct usb_device	*udev = hub->ports[port1 - 1]->child;
 		int			delta;
 		unsigned		unit_load;
 		if (!udev)
 			continue;
 		if (hub_is_superspeed(udev))
 			unit_load = 150;
 		else
 			unit_load = 100;
 		/*
 		 * Unconfigured devices may not use more than one unit load,
 		 * or 8mA for OTG ports
 		 */
 		if (udev->actconfig)
 			delta = usb_get_max_power(udev, udev->actconfig);
 		else if (port1 != udev->bus->otg_port || hdev->parent)
 			delta = unit_load;
 		else
 			delta = 8;
 		if (delta > hub->mA_per_port)
 			dev_warn(&udev->dev,
 				 "%dmA is over %umA budget for port %d!\n",
 				 delta, hub->mA_per_port, port1);
 		remaining -= delta;
 	}
 	if (remaining < 0) {
 		dev_warn(hub->intfdev, "%dmA over power budget!\n",
 			-remaining);
 		remaining = 0;
 	}
 	return remaining;
 }
 /* Handle physical or logical connection change events.
  * This routine is called when:
  * 	a port connection-change occurs;
  *	a port enable-change occurs (often caused by EMI);
  *	usb_reset_and_verify_device() encounters changed descriptors (as from
  *		a firmware download)
  * caller already locked the hub
  */
 static void hub_port_connect_change(struct usb_hub *hub, int port1,
 					u16 portstatus, u16 portchange)
 {
 	struct usb_device *hdev = hub->hdev;
 	struct device *hub_dev = hub->intfdev;
 	struct usb_hcd *hcd = bus_to_hcd(hdev->bus);
 	unsigned wHubCharacteristics =
 			le16_to_cpu(hub->descriptor->wHubCharacteristics);
 	struct usb_device *udev;
 	int status, i;
 	unsigned unit_load;
 	dev_dbg (hub_dev,
 		"port %d, status %04x, change %04x, %s\n",
 		port1, portstatus, portchange, portspeed(hub, portstatus));
 	if (hub->has_indicators) {
 		set_port_led(hub, port1, HUB_LED_AUTO);
 		hub->indicator[port1-1] = INDICATOR_AUTO;
 	}
 #ifdef	CONFIG_USB_OTG
 	/* during HNP, don't repeat the debounce */
 	if (hdev->bus->is_b_host)
 		portchange &= ~(USB_PORT_STAT_C_CONNECTION |
 				USB_PORT_STAT_C_ENABLE);
 #endif
 	/* Try to resuscitate an existing device */
 	udev = hub->ports[port1 - 1]->child;
 	if ((portstatus & USB_PORT_STAT_CONNECTION) && udev &&
 			udev->state != USB_STATE_NOTATTACHED) {
 		usb_lock_device(udev);
 		if (portstatus & USB_PORT_STAT_ENABLE) {
 			status = 0;		/* Nothing to do */
 #ifdef CONFIG_PM_RUNTIME
 		} else if (udev->state == USB_STATE_SUSPENDED &&
 				udev->persist_enabled) {
 			/* For a suspended device, treat this as a
 			 * remote wakeup event.
 			 */
 			status = usb_remote_wakeup(udev);
 #endif
 		} else {
 			status = -ENODEV;	/* Don't resuscitate */
 		}
 		usb_unlock_device(udev);
 		if (status == 0) {
 			clear_bit(port1, hub->change_bits);
 			return;
 		}
 	}
 	/* Disconnect any existing devices under this port */
 	if (udev) {
 		if (hcd->phy && !hdev->parent &&
 				!(portstatus & USB_PORT_STAT_CONNECTION))
 			usb_phy_notify_disconnect(hcd->phy, udev->speed);
 		usb_disconnect(&hub->ports[port1 - 1]->child);
 	}
 	clear_bit(port1, hub->change_bits);
 	/* We can forget about a "removed" device when there's a physical
 	 * disconnect or the connect status changes.
 	 */
 	if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
 			(portchange & USB_PORT_STAT_C_CONNECTION))
 		clear_bit(port1, hub->removed_bits);
 	if (portchange & (USB_PORT_STAT_C_CONNECTION |
 				USB_PORT_STAT_C_ENABLE)) {
 		status = hub_port_debounce_be_stable(hub, port1);
 		if (status < 0) {
 			if (status != -ENODEV && printk_ratelimit())
 				dev_err(hub_dev, "connect-debounce failed, "
 						"port %d disabled\n", port1);
 			portstatus &= ~USB_PORT_STAT_CONNECTION;
 		} else {
 			portstatus = status;
 		}
 	}
 	/* Return now if debouncing failed or nothing is connected or
 	 * the device was "removed".
 	 */
 	if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
 			test_bit(port1, hub->removed_bits)) {
 		/* maybe switch power back on (e.g. root hub was reset) */
 		if ((wHubCharacteristics & HUB_CHAR_LPSM) < 2
 				&& !port_is_power_on(hub, portstatus))
 			set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
 		if (portstatus & USB_PORT_STAT_ENABLE)
 			goto done;
 		return;
 	}
 	if (hub_is_superspeed(hub->hdev))
 		unit_load = 150;
 	else
 		unit_load = 100;
 	status = 0;
 	for (i = 0; i < SET_CONFIG_TRIES; i++) {
 		/* reallocate for each attempt, since references
 		 * to the previous one can escape in various ways
 		 */
 		udev = usb_alloc_dev(hdev, hdev->bus, port1);
 		if (!udev) {
 			dev_err (hub_dev,
 				"couldn't allocate port %d usb_device\n",
 				port1);
 			goto done;
 		}
 		usb_set_device_state(udev, USB_STATE_POWERED);
 		udev->bus_mA = hub->mA_per_port;
 		udev->level = hdev->level + 1;
 		udev->wusb = hub_is_wusb(hub);
 		/* Only USB 3.0 devices are connected to SuperSpeed hubs. */
 		if (hub_is_superspeed(hub->hdev))
 			udev->speed = USB_SPEED_SUPER;
 		else
 			udev->speed = USB_SPEED_UNKNOWN;
 		choose_devnum(udev);
 		if (udev->devnum <= 0) {
 			status = -ENOTCONN;	/* Don't retry */
 			goto loop;
 		}
 		/* reset (non-USB 3.0 devices) and get descriptor */
 		status = hub_port_init(hub, udev, port1, i);
 		if (status < 0)
 			goto loop;
 		usb_detect_quirks(udev);
 		if (udev->quirks & USB_QUIRK_DELAY_INIT)
 			msleep(1000);
 		/* consecutive bus-powered hubs aren't reliable; they can
 		 * violate the voltage drop budget.  if the new child has
 		 * a "powered" LED, users should notice we didn't enable it
 		 * (without reading syslog), even without per-port LEDs
 		 * on the parent.
 		 */
 		if (udev->descriptor.bDeviceClass == USB_CLASS_HUB
 				&& udev->bus_mA <= unit_load) {
 			u16	devstat;
 			status = usb_get_status(udev, USB_RECIP_DEVICE, 0,
 					&devstat);
 			if (status) {
 				dev_dbg(&udev->dev, "get status %d ?\n", status);
 				goto loop_disable;
 			}
 			if ((devstat & (1 << USB_DEVICE_SELF_POWERED)) == 0) {
 				dev_err(&udev->dev,
 					"can't connect bus-powered hub "
 					"to this port\n");
 				if (hub->has_indicators) {
 					hub->indicator[port1-1] =
 						INDICATOR_AMBER_BLINK;
 					queue_delayed_work(
 						system_power_efficient_wq,
 						&hub->leds, 0);
 				}
 				status = -ENOTCONN;	/* Don't retry */
 				goto loop_disable;
 			}
 		}
 		/* check for devices running slower than they could */
 		if (le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0200
 				&& udev->speed == USB_SPEED_FULL
 				&& highspeed_hubs != 0)
 			check_highspeed (hub, udev, port1);
 		/* Store the parent's children[] pointer.  At this point
 		 * udev becomes globally accessible, although presumably
 		 * no one will look at it until hdev is unlocked.
 		 */
 		status = 0;
 		/* We mustn't add new devices if the parent hub has
 		 * been disconnected; we would race with the
 		 * recursively_mark_NOTATTACHED() routine.
 		 */
 		spin_lock_irq(&device_state_lock);
 		if (hdev->state == USB_STATE_NOTATTACHED)
 			status = -ENOTCONN;
 		else
 			hub->ports[port1 - 1]->child = udev;
 		spin_unlock_irq(&device_state_lock);
 		/* Run it through the hoops (find a driver, etc) */
 		if (!status) {
 			status = usb_new_device(udev);
 			if (status) {
 				spin_lock_irq(&device_state_lock);
 				hub->ports[port1 - 1]->child = NULL;
 				spin_unlock_irq(&device_state_lock);
 			}
 		}
 		if (status)
 			goto loop_disable;
 		status = hub_power_remaining(hub);
 		if (status)
 			dev_dbg(hub_dev, "%dmA power budget left\n", status);
 		return;
 loop_disable:
 		hub_port_disable(hub, port1, 1);
 loop:
 		usb_ep0_reinit(udev);
 		release_devnum(udev);
 		hub_free_dev(udev);
 		usb_put_dev(udev);
 		if ((status == -ENOTCONN) || (status == -ENOTSUPP))
 			break;
 	}
 	if (hub->hdev->parent ||
 			!hcd->driver->port_handed_over ||
 			!(hcd->driver->port_handed_over)(hcd, port1)) {
 		if (status != -ENOTCONN && status != -ENODEV)
 			dev_err(hub_dev, "unable to enumerate USB device on port %d\n",
 					port1);
 	}
 done:
 	hub_port_disable(hub, port1, 1);
 	if (hcd->driver->relinquish_port && !hub->hdev->parent)
 		hcd->driver->relinquish_port(hcd, port1);
 }
 /* Returns 1 if there was a remote wakeup and a connect status change. */
 static int hub_handle_remote_wakeup(struct usb_hub *hub, unsigned int port,
 		u16 portstatus, u16 portchange)
 {
 	struct usb_device *hdev;
 	struct usb_device *udev;
 	int connect_change = 0;
 	int ret;
 	hdev = hub->hdev;
 	udev = hub->ports[port - 1]->child;
 	if (!hub_is_superspeed(hdev)) {
 		if (!(portchange & USB_PORT_STAT_C_SUSPEND))
 			return 0;
 		usb_clear_port_feature(hdev, port, USB_PORT_FEAT_C_SUSPEND);
 	} else {
 		if (!udev || udev->state != USB_STATE_SUSPENDED ||
 				 (portstatus & USB_PORT_STAT_LINK_STATE) !=
 				 USB_SS_PORT_LS_U0)
 			return 0;
 	}
 	if (udev) {
 		/* TRSMRCY = 10 msec */
 		msleep(10);
 		usb_lock_device(udev);
 		ret = usb_remote_wakeup(udev);
 		usb_unlock_device(udev);
 		if (ret < 0)
 			connect_change = 1;
 	} else {
 		ret = -ENODEV;
 		hub_port_disable(hub, port, 1);
 	}
 	dev_dbg(hub->intfdev, "resume on port %d, status %d\n",
 			port, ret);
 	return connect_change;
 }
 static void hub_events(void)
 {
 	struct list_head *tmp;
 	struct usb_device *hdev;
 	struct usb_interface *intf;
 	struct usb_hub *hub;
 	struct device *hub_dev;
 	u16 hubstatus;
 	u16 hubchange;
 	u16 portstatus;
 	u16 portchange;
 	int i, ret;
 	int connect_change, wakeup_change;
 	/*
 	 *  We restart the list every time to avoid a deadlock with
 	 * deleting hubs downstream from this one. This should be
 	 * safe since we delete the hub from the event list.
 	 * Not the most efficient, but avoids deadlocks.
 	 */
 	while (1) {
 		/* Grab the first entry at the beginning of the list */
 		spin_lock_irq(&hub_event_lock);
 		if (list_empty(&hub_event_list)) {
 			spin_unlock_irq(&hub_event_lock);
 			break;
 		}
 		tmp = hub_event_list.next;
 		list_del_init(tmp);
 		hub = list_entry(tmp, struct usb_hub, event_list);
 		kref_get(&hub->kref);
 		spin_unlock_irq(&hub_event_lock);
 		hdev = hub->hdev;
 		hub_dev = hub->intfdev;
 		intf = to_usb_interface(hub_dev);
 		dev_dbg(hub_dev, "state %d ports %d chg %04x evt %04x\n",
 				hdev->state, hdev->maxchild,
 				/* NOTE: expects max 15 ports... */
 				(u16) hub->change_bits[0],
 				(u16) hub->event_bits[0]);
 		/* Lock the device, then check to see if we were
 		 * disconnected while waiting for the lock to succeed. */
 		usb_lock_device(hdev);
 		if (unlikely(hub->disconnected))
 			goto loop_disconnected;
 		/* If the hub has died, clean up after it */
 		if (hdev->state == USB_STATE_NOTATTACHED) {
 			hub->error = -ENODEV;
 			hub_quiesce(hub, HUB_DISCONNECT);
 			goto loop;
 		}
 		/* Autoresume */
 		ret = usb_autopm_get_interface(intf);
 		if (ret) {
 			dev_dbg(hub_dev, "Can't autoresume: %d\n", ret);
 			goto loop;
 		}
 		/* If this is an inactive hub, do nothing */
 		if (hub->quiescing)
 			goto loop_autopm;
 		if (hub->error) {
 			dev_dbg (hub_dev, "resetting for error %d\n",
 				hub->error);
 			ret = usb_reset_device(hdev);
 			if (ret) {
 				dev_dbg (hub_dev,
 					"error resetting hub: %d\n", ret);
 				goto loop_autopm;
 			}
 			hub->nerrors = 0;
 			hub->error = 0;
 		}
 		/* deal with port status changes */
 		for (i = 1; i <= hdev->maxchild; i++) {
 			struct usb_device *udev = hub->ports[i - 1]->child;
 			if (test_bit(i, hub->busy_bits))
 				continue;
 			connect_change = test_bit(i, hub->change_bits);
 			wakeup_change = test_and_clear_bit(i, hub->wakeup_bits);
 			if (!test_and_clear_bit(i, hub->event_bits) &&
 					!connect_change && !wakeup_change)
 				continue;
 			ret = hub_port_status(hub, i,
 					&portstatus, &portchange);
 			if (ret < 0)
 				continue;
 			if (portchange & USB_PORT_STAT_C_CONNECTION) {
 				usb_clear_port_feature(hdev, i,
 					USB_PORT_FEAT_C_CONNECTION);
 				connect_change = 1;
 			}
 			if (portchange & USB_PORT_STAT_C_ENABLE) {
 				if (!connect_change)
 					dev_dbg (hub_dev,
 						"port %d enable change, "
 						"status %08x\n",
 						i, portstatus);
 				usb_clear_port_feature(hdev, i,
 					USB_PORT_FEAT_C_ENABLE);
 				/*
 				 * EM interference sometimes causes badly
 				 * shielded USB devices to be shutdown by
 				 * the hub, this hack enables them again.
 				 * Works at least with mouse driver.
 				 */
 				if (!(portstatus & USB_PORT_STAT_ENABLE)
 				    && !connect_change
 				    && hub->ports[i - 1]->child) {
 					dev_err (hub_dev,
 					    "port %i "
 					    "disabled by hub (EMI?), "
 					    "re-enabling...\n",
 						i);
 					connect_change = 1;
 				}
 			}
 			if (hub_handle_remote_wakeup(hub, i,
 						portstatus, portchange))
 				connect_change = 1;
 			if (portchange & USB_PORT_STAT_C_OVERCURRENT) {
 				u16 status = 0;
 				u16 unused;
 				dev_dbg(hub_dev, "over-current change on port "
 					"%d\n", i);
 				usb_clear_port_feature(hdev, i,
 					USB_PORT_FEAT_C_OVER_CURRENT);
 				msleep(100);	/* Cool down */
 				hub_power_on(hub, true);
 				hub_port_status(hub, i, &status, &unused);
 				if (status & USB_PORT_STAT_OVERCURRENT)
 					dev_err(hub_dev, "over-current "
 						"condition on port %d\n", i);
 			}
 			if (portchange & USB_PORT_STAT_C_RESET) {
 				dev_dbg (hub_dev,
 					"reset change on port %d\n",
 					i);
 				usb_clear_port_feature(hdev, i,
 					USB_PORT_FEAT_C_RESET);
 			}
 			if ((portchange & USB_PORT_STAT_C_BH_RESET) &&
 					hub_is_superspeed(hub->hdev)) {
 				dev_dbg(hub_dev,
 					"warm reset change on port %d\n",
 					i);
 				usb_clear_port_feature(hdev, i,
 					USB_PORT_FEAT_C_BH_PORT_RESET);
 			}
 			if (portchange & USB_PORT_STAT_C_LINK_STATE) {
 				usb_clear_port_feature(hub->hdev, i,
 						USB_PORT_FEAT_C_PORT_LINK_STATE);
 			}
 			if (portchange & USB_PORT_STAT_C_CONFIG_ERROR) {
 				dev_warn(hub_dev,
 					"config error on port %d\n",
 					i);
 				usb_clear_port_feature(hub->hdev, i,
 						USB_PORT_FEAT_C_PORT_CONFIG_ERROR);
 			}
 			/* Warm reset a USB3 protocol port if it's in
 			 * SS.Inactive state.
 			 */
 			if (hub_port_warm_reset_required(hub, portstatus)) {
 				int status;
 				dev_dbg(hub_dev, "warm reset port %d\n", i);
 				if (!udev ||
 				    !(portstatus & USB_PORT_STAT_CONNECTION) ||
 				    udev->state == USB_STATE_NOTATTACHED) {
 					status = hub_port_reset(hub, i,
 							NULL, HUB_BH_RESET_TIME,
 							true);
 					if (status < 0)
 						hub_port_disable(hub, i, 1);
 				} else {
 					usb_lock_device(udev);
 					status = usb_reset_device(udev);
 					usb_unlock_device(udev);
 					connect_change = 0;
 				}
 			/*
 			 * On disconnect USB3 protocol ports transit from U0 to
 			 * SS.Inactive to Rx.Detect. If this happens a warm-
 			 * reset is not needed, but a (re)connect may happen
 			 * before khubd runs and sees the disconnect, and the
 			 * device may be an unknown state.
 			 *
 			 * If the port went through SS.Inactive without khubd
 			 * seeing it the C_LINK_STATE change flag will be set,
 			 * and we reset the dev to put it in a known state.
 			 */
 			} else if (udev && hub_is_superspeed(hub->hdev) &&
 				   (portchange & USB_PORT_STAT_C_LINK_STATE) &&
 				   (portstatus & USB_PORT_STAT_CONNECTION)) {
 				usb_lock_device(udev);
 				usb_reset_device(udev);
 				usb_unlock_device(udev);
 				connect_change = 0;
 			}
 			if (connect_change)
 				hub_port_connect_change(hub, i,
 						portstatus, portchange);
 		} /* end for i */
 		/* deal with hub status changes */
 		if (test_and_clear_bit(0, hub->event_bits) == 0)
 			;	/* do nothing */
 		else if (hub_hub_status(hub, &hubstatus, &hubchange) < 0)
 			dev_err (hub_dev, "get_hub_status failed\n");
 		else {
 			if (hubchange & HUB_CHANGE_LOCAL_POWER) {
 				dev_dbg (hub_dev, "power change\n");
 				clear_hub_feature(hdev, C_HUB_LOCAL_POWER);
 				if (hubstatus & HUB_STATUS_LOCAL_POWER)
 					/* FIXME: Is this always true? */
 					hub->limited_power = 1;
 				else
 					hub->limited_power = 0;
 			}
 			if (hubchange & HUB_CHANGE_OVERCURRENT) {
 				u16 status = 0;
 				u16 unused;
 				dev_dbg(hub_dev, "over-current change\n");
 				clear_hub_feature(hdev, C_HUB_OVER_CURRENT);
 				msleep(500);	/* Cool down */
 				hub_power_on(hub, true);
 				hub_hub_status(hub, &status, &unused);
 				if (status & HUB_STATUS_OVERCURRENT)
 					dev_err(hub_dev, "over-current "
 						"condition\n");
 			}
 		}
  loop_autopm:
 		/* Balance the usb_autopm_get_interface() above */
 		usb_autopm_put_interface_no_suspend(intf);
  loop:
 		/* Balance the usb_autopm_get_interface_no_resume() in
 		 * kick_khubd() and allow autosuspend.
 		 */
 		usb_autopm_put_interface(intf);
  loop_disconnected:
 		usb_unlock_device(hdev);
 		kref_put(&hub->kref, hub_release);
 	} /* end while (1) */
 }
 static int hub_thread(void *__unused)
 {
 	/* khubd needs to be freezable to avoid interfering with USB-PERSIST
 	 * port handover.  Otherwise it might see that a full-speed device
 	 * was gone before the EHCI controller had handed its port over to
 	 * the companion full-speed controller.
 	 */
 	set_freezable();
 	do {
 		hub_events();
 		wait_event_freezable(khubd_wait,
 				!list_empty(&hub_event_list) ||
 				kthread_should_stop());
 	} while (!kthread_should_stop() || !list_empty(&hub_event_list));
 	pr_debug("%s: khubd exiting\n", usbcore_name);
 	return 0;
 }
 static const struct usb_device_id hub_id_table[] = {
     { .match_flags = USB_DEVICE_ID_MATCH_VENDOR
 			| USB_DEVICE_ID_MATCH_INT_CLASS,
       .idVendor = USB_VENDOR_GENESYS_LOGIC,
       .bInterfaceClass = USB_CLASS_HUB,
       .driver_info = HUB_QUIRK_CHECK_PORT_AUTOSUSPEND},
     { .match_flags = USB_DEVICE_ID_MATCH_DEV_CLASS,
       .bDeviceClass = USB_CLASS_HUB},
     { .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS,
       .bInterfaceClass = USB_CLASS_HUB},
     { }						/* Terminating entry */
 };
 MODULE_DEVICE_TABLE (usb, hub_id_table);
 static struct usb_driver hub_driver = {
 	.name =		"hub",
 	.probe =	hub_probe,
 	.disconnect =	hub_disconnect,
 	.suspend =	hub_suspend,
 	.resume =	hub_resume,
 	.reset_resume =	hub_reset_resume,
 	.pre_reset =	hub_pre_reset,
 	.post_reset =	hub_post_reset,
 	.unlocked_ioctl = hub_ioctl,
 	.id_table =	hub_id_table,
 	.supports_autosuspend =	1,
 };
 int usb_hub_init(void)
 {
 	if (usb_register(&hub_driver) < 0) {
 		printk(KERN_ERR "%s: can't register hub driver\n",
 			usbcore_name);
 		return -1;
 	}
 	khubd_task = kthread_run(hub_thread, NULL, "khubd");
 	if (!IS_ERR(khubd_task))
 		return 0;
 	/* Fall through if kernel_thread failed */
 	usb_deregister(&hub_driver);
 	printk(KERN_ERR "%s: can't start khubd\n", usbcore_name);
 	return -1;
 }
 void usb_hub_cleanup(void)
 {
 	kthread_stop(khubd_task);
 	/*
 	 * Hub resources are freed for us by usb_deregister. It calls
 	 * usb_driver_purge on every device which in turn calls that
 	 * devices disconnect function if it is using this driver.
 	 * The hub_disconnect function takes care of releasing the
 	 * individual hub resources. -greg
 	 */
 	usb_deregister(&hub_driver);
 } /* usb_hub_cleanup() */
 static int descriptors_changed(struct usb_device *udev,
 		struct usb_device_descriptor *old_device_descriptor,
 		struct usb_host_bos *old_bos)
 {
 	int		changed = 0;
 	unsigned	index;
 	unsigned	serial_len = 0;
 	unsigned	len;
 	unsigned	old_length;
 	int		length;
 	char		*buf;
 	if (memcmp(&udev->descriptor, old_device_descriptor,
 			sizeof(*old_device_descriptor)) != 0)
 		return 1;
 	if ((old_bos && !udev->bos) || (!old_bos && udev->bos))
 		return 1;
 	if (udev->bos) {
 		len = le16_to_cpu(udev->bos->desc->wTotalLength);
 		if (len != le16_to_cpu(old_bos->desc->wTotalLength))
 			return 1;
 		if (memcmp(udev->bos->desc, old_bos->desc, len))
 			return 1;
 	}
 	/* Since the idVendor, idProduct, and bcdDevice values in the
 	 * device descriptor haven't changed, we will assume the
 	 * Manufacturer and Product strings haven't changed either.
 	 * But the SerialNumber string could be different (e.g., a
 	 * different flash card of the same brand).
 	 */
 	if (udev->serial)
 		serial_len = strlen(udev->serial) + 1;
 	len = serial_len;
 	for (index = 0; index < udev->descriptor.bNumConfigurations; index++) {
 		old_length = le16_to_cpu(udev->config[index].desc.wTotalLength);
 		len = max(len, old_length);
 	}
 	buf = kmalloc(len, GFP_NOIO);
 	if (buf == NULL) {
 		dev_err(&udev->dev, "no mem to re-read configs after reset\n");
 		/* assume the worst */
 		return 1;
 	}
 	for (index = 0; index < udev->descriptor.bNumConfigurations; index++) {
 		old_length = le16_to_cpu(udev->config[index].desc.wTotalLength);
 		length = usb_get_descriptor(udev, USB_DT_CONFIG, index, buf,
 				old_length);
 		if (length != old_length) {
 			dev_dbg(&udev->dev, "config index %d, error %d\n",
 					index, length);
 			changed = 1;
 			break;
 		}
 		if (memcmp (buf, udev->rawdescriptors[index], old_length)
 				!= 0) {
 			dev_dbg(&udev->dev, "config index %d changed (#%d)\n",
 				index,
 				((struct usb_config_descriptor *) buf)->
 					bConfigurationValue);
 			changed = 1;
 			break;
 		}
 	}
 	if (!changed && serial_len) {
 		length = usb_string(udev, udev->descriptor.iSerialNumber,
 				buf, serial_len);
 		if (length + 1 != serial_len) {
 			dev_dbg(&udev->dev, "serial string error %d\n",
 					length);
 			changed = 1;
 		} else if (memcmp(buf, udev->serial, length) != 0) {
 			dev_dbg(&udev->dev, "serial string changed\n");
 			changed = 1;
 		}
 	}
 	kfree(buf);
 	return changed;
 }
 /**
  * usb_reset_and_verify_device - perform a USB port reset to reinitialize a device
  * @udev: device to reset (not in SUSPENDED or NOTATTACHED state)
  *
  * WARNING - don't use this routine to reset a composite device
  * (one with multiple interfaces owned by separate drivers)!
  * Use usb_reset_device() instead.
  *
  * Do a port reset, reassign the device's address, and establish its
  * former operating configuration.  If the reset fails, or the device's
  * descriptors change from their values before the reset, or the original
  * configuration and altsettings cannot be restored, a flag will be set
  * telling khubd to pretend the device has been disconnected and then
  * re-connected.  All drivers will be unbound, and the device will be
  * re-enumerated and probed all over again.
  *
  * Return: 0 if the reset succeeded, -ENODEV if the device has been
  * flagged for logical disconnection, or some other negative error code
  * if the reset wasn't even attempted.
  *
  * Note:
  * The caller must own the device lock.  For example, it's safe to use
  * this from a driver probe() routine after downloading new firmware.
  * For calls that might not occur during probe(), drivers should lock
  * the device using usb_lock_device_for_reset().
  *
  * Locking exception: This routine may also be called from within an
  * autoresume handler.  Such usage won't conflict with other tasks
  * holding the device lock because these tasks should always call
  * usb_autopm_resume_device(), thereby preventing any unwanted autoresume.
  */
 static int usb_reset_and_verify_device(struct usb_device *udev)
 {
 	struct usb_device		*parent_hdev = udev->parent;
 	struct usb_hub			*parent_hub;
 	struct usb_hcd			*hcd = bus_to_hcd(udev->bus);
 	struct usb_device_descriptor	descriptor = udev->descriptor;
 	struct usb_host_bos		*bos;
 	int				i, j, ret = 0;
 	int				port1 = udev->portnum;
 	if (udev->state == USB_STATE_NOTATTACHED ||
 			udev->state == USB_STATE_SUSPENDED) {
 		dev_dbg(&udev->dev, "device reset not allowed in state %d\n",
 				udev->state);
 		return -EINVAL;
 	}
 	if (!parent_hdev) {
 		/* this requires hcd-specific logic; see ohci_restart() */
 		dev_dbg(&udev->dev, "%s for root hub!\n", __func__);
 		return -EISDIR;
 	}
 	parent_hub = usb_hub_to_struct_hub(parent_hdev);
 	/* Disable USB2 hardware LPM.
 	 * It will be re-enabled by the enumeration process.
 	 */
 	if (udev->usb2_hw_lpm_enabled == 1)
 		usb_set_usb2_hardware_lpm(udev, 0);
 	bos = udev->bos;
 	udev->bos = NULL;
 	/* Disable LPM and LTM while we reset the device and reinstall the alt
 	 * settings.  Device-initiated LPM settings, and system exit latency
 	 * settings are cleared when the device is reset, so we have to set
 	 * them up again.
 	 */
 	ret = usb_unlocked_disable_lpm(udev);
 	if (ret) {
 		dev_err(&udev->dev, "%s Failed to disable LPM\n.", __func__);
 		goto re_enumerate;
 	}
 	ret = usb_disable_ltm(udev);
 	if (ret) {
 		dev_err(&udev->dev, "%s Failed to disable LTM\n.",
 				__func__);
 		goto re_enumerate;
 	}
 	set_bit(port1, parent_hub->busy_bits);
 	for (i = 0; i < SET_CONFIG_TRIES; ++i) {
 		/* ep0 maxpacket size may change; let the HCD know about it.
 		 * Other endpoints will be handled by re-enumeration. */
 		usb_ep0_reinit(udev);
 		ret = hub_port_init(parent_hub, udev, port1, i);
 		if (ret >= 0 || ret == -ENOTCONN || ret == -ENODEV)
 			break;
 	}
 	clear_bit(port1, parent_hub->busy_bits);
 	if (ret < 0)
 		goto re_enumerate;
 	/* Device might have changed firmware (DFU or similar) */
 	if (descriptors_changed(udev, &descriptor, bos)) {
 		dev_info(&udev->dev, "device firmware changed\n");
 		udev->descriptor = descriptor;	/* for disconnect() calls */
 		goto re_enumerate;
 	}
 	/* Restore the device's previous configuration */
 	if (!udev->actconfig)
 		goto done;
 	mutex_lock(hcd->bandwidth_mutex);
 	ret = usb_hcd_alloc_bandwidth(udev, udev->actconfig, NULL, NULL);
 	if (ret < 0) {
 		dev_warn(&udev->dev,
 				"Busted HC?  Not enough HCD resources for "
 				"old configuration.\n");
 		mutex_unlock(hcd->bandwidth_mutex);
 		goto re_enumerate;
 	}
 	ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
 			USB_REQ_SET_CONFIGURATION, 0,
 			udev->actconfig->desc.bConfigurationValue, 0,
 			NULL, 0, USB_CTRL_SET_TIMEOUT);
 	if (ret < 0) {
 		dev_err(&udev->dev,
 			"can't restore configuration #%d (error=%d)\n",
 			udev->actconfig->desc.bConfigurationValue, ret);
 		mutex_unlock(hcd->bandwidth_mutex);
 		goto re_enumerate;
 	}
 	mutex_unlock(hcd->bandwidth_mutex);
 	usb_set_device_state(udev, USB_STATE_CONFIGURED);
 	/* Put interfaces back into the same altsettings as before.
 	 * Don't bother to send the Set-Interface request for interfaces
 	 * that were already in altsetting 0; besides being unnecessary,
 	 * many devices can't handle it.  Instead just reset the host-side
 	 * endpoint state.
 	 */
 	for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
 		struct usb_host_config *config = udev->actconfig;
 		struct usb_interface *intf = config->interface[i];
 		struct usb_interface_descriptor *desc;
 		desc = &intf->cur_altsetting->desc;
 		if (desc->bAlternateSetting == 0) {
 			usb_disable_interface(udev, intf, true);
 			usb_enable_interface(udev, intf, true);
 			ret = 0;
 		} else {
 			/* Let the bandwidth allocation function know that this
 			 * device has been reset, and it will have to use
 			 * alternate setting 0 as the current alternate setting.
 			 */
 			intf->resetting_device = 1;
 			ret = usb_set_interface(udev, desc->bInterfaceNumber,
 					desc->bAlternateSetting);
 			intf->resetting_device = 0;
 		}
 		if (ret < 0) {
 			dev_err(&udev->dev, "failed to restore interface %d "
 				"altsetting %d (error=%d)\n",
 				desc->bInterfaceNumber,
 				desc->bAlternateSetting,
 				ret);
 			goto re_enumerate;
 		}
 		/* Resetting also frees any allocated streams */
 		for (j = 0; j < intf->cur_altsetting->desc.bNumEndpoints; j++)
 			intf->cur_altsetting->endpoint[j].streams = 0;
 	}
 done:
 	/* Now that the alt settings are re-installed, enable LTM and LPM. */
 	usb_set_usb2_hardware_lpm(udev, 1);
 	usb_unlocked_enable_lpm(udev);
 	usb_enable_ltm(udev);
 	usb_release_bos_descriptor(udev);
 	udev->bos = bos;
 	return 0;
 re_enumerate:
 	/* LPM state doesn't matter when we're about to destroy the device. */
 	hub_port_logical_disconnect(parent_hub, port1);
 	usb_release_bos_descriptor(udev);
 	udev->bos = bos;
 	return -ENODEV;
 }
 /**
  * usb_reset_device - warn interface drivers and perform a USB port reset
  * @udev: device to reset (not in SUSPENDED or NOTATTACHED state)
  *
  * Warns all drivers bound to registered interfaces (using their pre_reset
  * method), performs the port reset, and then lets the drivers know that
  * the reset is over (using their post_reset method).
  *
  * Return: The same as for usb_reset_and_verify_device().
  *
  * Note:
  * The caller must own the device lock.  For example, it's safe to use
  * this from a driver probe() routine after downloading new firmware.
  * For calls that might not occur during probe(), drivers should lock
  * the device using usb_lock_device_for_reset().
  *
  * If an interface is currently being probed or disconnected, we assume
  * its driver knows how to handle resets.  For all other interfaces,
  * if the driver doesn't have pre_reset and post_reset methods then
  * we attempt to unbind it and rebind afterward.
  */
 int usb_reset_device(struct usb_device *udev)
 {
 	int ret;
 	int i;
 	unsigned int noio_flag;
 	struct usb_host_config *config = udev->actconfig;
 	if (udev->state == USB_STATE_NOTATTACHED ||
 			udev->state == USB_STATE_SUSPENDED) {
 		dev_dbg(&udev->dev, "device reset not allowed in state %d\n",
 				udev->state);
 		return -EINVAL;
 	}
 	/*
 	 * Don't allocate memory with GFP_KERNEL in current
 	 * context to avoid possible deadlock if usb mass
 	 * storage interface or usbnet interface(iSCSI case)
 	 * is included in current configuration. The easist
 	 * approach is to do it for every device reset,
 	 * because the device 'memalloc_noio' flag may have
 	 * not been set before reseting the usb device.
 	 */
 	noio_flag = memalloc_noio_save();
 	/* Prevent autosuspend during the reset */
 	usb_autoresume_device(udev);
 	if (config) {
 		for (i = 0; i < config->desc.bNumInterfaces; ++i) {
 			struct usb_interface *cintf = config->interface[i];
 			struct usb_driver *drv;
 			int unbind = 0;
 			if (cintf->dev.driver) {
 				drv = to_usb_driver(cintf->dev.driver);
 				if (drv->pre_reset && drv->post_reset)
 					unbind = (drv->pre_reset)(cintf);
 				else if (cintf->condition ==
 						USB_INTERFACE_BOUND)
 					unbind = 1;
 				if (unbind)
 					usb_forced_unbind_intf(cintf);
 			}
 		}
 	}
 	ret = usb_reset_and_verify_device(udev);
 	if (config) {
 		for (i = config->desc.bNumInterfaces - 1; i >= 0; --i) {
 			struct usb_interface *cintf = config->interface[i];
 			struct usb_driver *drv;
 			int rebind = cintf->needs_binding;
 			if (!rebind && cintf->dev.driver) {
 				drv = to_usb_driver(cintf->dev.driver);
 				if (drv->post_reset)
 					rebind = (drv->post_reset)(cintf);
 				else if (cintf->condition ==
 						USB_INTERFACE_BOUND)
 					rebind = 1;
 				if (rebind)
 					cintf->needs_binding = 1;
 			}
 		}
 		usb_unbind_and_rebind_marked_interfaces(udev);
 	}
 	usb_autosuspend_device(udev);
 	memalloc_noio_restore(noio_flag);
 	return ret;
 }
 EXPORT_SYMBOL_GPL(usb_reset_device);
 /**
  * usb_queue_reset_device - Reset a USB device from an atomic context
  * @iface: USB interface belonging to the device to reset
  *
  * This function can be used to reset a USB device from an atomic
  * context, where usb_reset_device() won't work (as it blocks).
  *
  * Doing a reset via this method is functionally equivalent to calling
  * usb_reset_device(), except for the fact that it is delayed to a
  * workqueue. This means that any drivers bound to other interfaces
  * might be unbound, as well as users from usbfs in user space.
  *
  * Corner cases:
  *
  * - Scheduling two resets at the same time from two different drivers
  *   attached to two different interfaces of the same device is
  *   possible; depending on how the driver attached to each interface
  *   handles ->pre_reset(), the second reset might happen or not.
  *
  * - If a driver is unbound and it had a pending reset, the reset will
  *   be cancelled.
  *
  * - This function can be called during .probe() or .disconnect()
  *   times. On return from .disconnect(), any pending resets will be
  *   cancelled.
  *
  * There is no no need to lock/unlock the @reset_ws as schedule_work()
  * does its own.
  *
  * NOTE: We don't do any reference count tracking because it is not
  *     needed. The lifecycle of the work_struct is tied to the
  *     usb_interface. Before destroying the interface we cancel the
  *     work_struct, so the fact that work_struct is queued and or
  *     running means the interface (and thus, the device) exist and
  *     are referenced.
  */
 void usb_queue_reset_device(struct usb_interface *iface)
 {
 	schedule_work(&iface->reset_ws);
 }
 EXPORT_SYMBOL_GPL(usb_queue_reset_device);
 /**
  * usb_hub_find_child - Get the pointer of child device
  * attached to the port which is specified by @port1.
  * @hdev: USB device belonging to the usb hub
  * @port1: port num to indicate which port the child device
  *	is attached to.
  *
  * USB drivers call this function to get hub's child device
  * pointer.
  *
  * Return: %NULL if input param is invalid and
  * child's usb_device pointer if non-NULL.
  */
 struct usb_device *usb_hub_find_child(struct usb_device *hdev,
 		int port1)
 {
 	struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
 	if (port1 < 1 || port1 > hdev->maxchild)
 		return NULL;
 	return hub->ports[port1 - 1]->child;
 }
 EXPORT_SYMBOL_GPL(usb_hub_find_child);
 /**
  * usb_set_hub_port_connect_type - set hub port connect type.
  * @hdev: USB device belonging to the usb hub
  * @port1: port num of the port
  * @type: connect type of the port
  */
 void usb_set_hub_port_connect_type(struct usb_device *hdev, int port1,
 	enum usb_port_connect_type type)
 {
 	struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
 	if (hub)
 		hub->ports[port1 - 1]->connect_type = type;
 }
 /**
  * usb_get_hub_port_connect_type - Get the port's connect type
  * @hdev: USB device belonging to the usb hub
  * @port1: port num of the port
  *
  * Return: The connect type of the port if successful. Or
  * USB_PORT_CONNECT_TYPE_UNKNOWN if input params are invalid.
  */
 enum usb_port_connect_type
 usb_get_hub_port_connect_type(struct usb_device *hdev, int port1)
 {
 	struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
 	if (!hub)
 		return USB_PORT_CONNECT_TYPE_UNKNOWN;
 	return hub->ports[port1 - 1]->connect_type;
 }
 void usb_hub_adjust_deviceremovable(struct usb_device *hdev,
 		struct usb_hub_descriptor *desc)
 {
 	enum usb_port_connect_type connect_type;
 	int i;
 	if (!hub_is_superspeed(hdev)) {
 		for (i = 1; i <= hdev->maxchild; i++) {
 			connect_type = usb_get_hub_port_connect_type(hdev, i);
 			if (connect_type == USB_PORT_CONNECT_TYPE_HARD_WIRED) {
 				u8 mask = 1 << (i%8);
 				if (!(desc->u.hs.DeviceRemovable[i/8] & mask)) {
 					dev_dbg(&hdev->dev, "usb port%d's DeviceRemovable is changed to 1 according to platform information.\n",
 						i);
 					desc->u.hs.DeviceRemovable[i/8]	|= mask;
 				}
 			}
 		}
 	} else {
 		u16 port_removable = le16_to_cpu(desc->u.ss.DeviceRemovable);
 		for (i = 1; i <= hdev->maxchild; i++) {
 			connect_type = usb_get_hub_port_connect_type(hdev, i);
 			if (connect_type == USB_PORT_CONNECT_TYPE_HARD_WIRED) {
 				u16 mask = 1 << i;
 				if (!(port_removable & mask)) {
 					dev_dbg(&hdev->dev, "usb port%d's DeviceRemovable is changed to 1 according to platform information.\n",
 						i);
 					port_removable |= mask;
 				}
 			}
 		}
 		desc->u.ss.DeviceRemovable = cpu_to_le16(port_removable);
 	}
 }
 #ifdef CONFIG_ACPI
 /**
  * usb_get_hub_port_acpi_handle - Get the usb port's acpi handle
  * @hdev: USB device belonging to the usb hub
  * @port1: port num of the port
  *
  * Return: Port's acpi handle if successful, %NULL if params are
  * invalid.
  */
 acpi_handle usb_get_hub_port_acpi_handle(struct usb_device *hdev,
 	int port1)
 {
 	struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
 	if (!hub)
 		return NULL;
 	return ACPI_HANDLE(&hub->ports[port1 - 1]->dev);
 }
 #endif

drivers/usb/host/pci-quirks.c

Diff comments View file @ 8ee7a33

 /*
  * This file contains code to reset and initialize USB host controllers.
  * Some of it includes work-arounds for PCI hardware and BIOS quirks.
  * It may need to run early during booting -- before USB would normally
  * initialize -- to ensure that Linux doesn't use any legacy modes.
  *
  *  Copyright (c) 1999 Martin Mares <mj@ucw.cz>
  *  (and others)
  */
 #include <linux/types.h>
 #include <linux/kconfig.h>
 #include <linux/kernel.h>
 #include <linux/pci.h>
 #include <linux/delay.h>
 #include <linux/export.h>
 #include <linux/acpi.h>
 #include <linux/dmi.h>
 #include "pci-quirks.h"
 #include "xhci-ext-caps.h"
 #define UHCI_USBLEGSUP		0xc0		/* legacy support */
 #define UHCI_USBCMD		0		/* command register */
 #define UHCI_USBINTR		4		/* interrupt register */
 #define UHCI_USBLEGSUP_RWC	0x8f00		/* the R/WC bits */
 #define UHCI_USBLEGSUP_RO	0x5040		/* R/O and reserved bits */
 #define UHCI_USBCMD_RUN		0x0001		/* RUN/STOP bit */
 #define UHCI_USBCMD_HCRESET	0x0002		/* Host Controller reset */
 #define UHCI_USBCMD_EGSM	0x0008		/* Global Suspend Mode */
 #define UHCI_USBCMD_CONFIGURE	0x0040		/* Config Flag */
 #define UHCI_USBINTR_RESUME	0x0002		/* Resume interrupt enable */
 #define OHCI_CONTROL		0x04
 #define OHCI_CMDSTATUS		0x08
 #define OHCI_INTRSTATUS		0x0c
 #define OHCI_INTRENABLE		0x10
 #define OHCI_INTRDISABLE	0x14
 #define OHCI_FMINTERVAL		0x34
 #define OHCI_HCFS		(3 << 6)	/* hc functional state */
 #define OHCI_HCR		(1 << 0)	/* host controller reset */
 #define OHCI_OCR		(1 << 3)	/* ownership change request */
 #define OHCI_CTRL_RWC		(1 << 9)	/* remote wakeup connected */
 #define OHCI_CTRL_IR		(1 << 8)	/* interrupt routing */
 #define OHCI_INTR_OC		(1 << 30)	/* ownership change */
 #define EHCI_HCC_PARAMS		0x08		/* extended capabilities */
 #define EHCI_USBCMD		0		/* command register */
 #define EHCI_USBCMD_RUN		(1 << 0)	/* RUN/STOP bit */
 #define EHCI_USBSTS		4		/* status register */
 #define EHCI_USBSTS_HALTED	(1 << 12)	/* HCHalted bit */
 #define EHCI_USBINTR		8		/* interrupt register */
 #define EHCI_CONFIGFLAG		0x40		/* configured flag register */
 #define EHCI_USBLEGSUP		0		/* legacy support register */
 #define EHCI_USBLEGSUP_BIOS	(1 << 16)	/* BIOS semaphore */
 #define EHCI_USBLEGSUP_OS	(1 << 24)	/* OS semaphore */
 #define EHCI_USBLEGCTLSTS	4		/* legacy control/status */
 #define EHCI_USBLEGCTLSTS_SOOE	(1 << 13)	/* SMI on ownership change */
 /* AMD quirk use */
 #define	AB_REG_BAR_LOW		0xe0
 #define	AB_REG_BAR_HIGH		0xe1
 #define	AB_REG_BAR_SB700	0xf0
 #define	AB_INDX(addr)		((addr) + 0x00)
 #define	AB_DATA(addr)		((addr) + 0x04)
 #define	AX_INDXC		0x30
 #define	AX_DATAC		0x34
 #define	NB_PCIE_INDX_ADDR	0xe0
 #define	NB_PCIE_INDX_DATA	0xe4
 #define	PCIE_P_CNTL		0x10040
 #define	BIF_NB			0x10002
 #define	NB_PIF0_PWRDOWN_0	0x01100012
 #define	NB_PIF0_PWRDOWN_1	0x01100013
 #define USB_INTEL_XUSB2PR      0xD0
 #define USB_INTEL_USB2PRM      0xD4
 #define USB_INTEL_USB3_PSSEN   0xD8
 #define USB_INTEL_USB3PRM      0xDC
 /*
  * amd_chipset_gen values represent AMD different chipset generations
  */
 enum amd_chipset_gen {
 	NOT_AMD_CHIPSET = 0,
 	AMD_CHIPSET_SB600,
 	AMD_CHIPSET_SB700,
 	AMD_CHIPSET_SB800,
 	AMD_CHIPSET_HUDSON2,
 	AMD_CHIPSET_BOLTON,
 	AMD_CHIPSET_YANGTZE,
 	AMD_CHIPSET_UNKNOWN,
 };
 struct amd_chipset_type {
 	enum amd_chipset_gen gen;
 	u8 rev;
 };
 static struct amd_chipset_info {
 	struct pci_dev	*nb_dev;
 	struct pci_dev	*smbus_dev;
 	int nb_type;
 	struct amd_chipset_type sb_type;
 	int isoc_reqs;
 	int probe_count;
 	int probe_result;
 } amd_chipset;
 static DEFINE_SPINLOCK(amd_lock);
 /*
  * amd_chipset_sb_type_init - initialize amd chipset southbridge type
  *
  * AMD FCH/SB generation and revision is identified by SMBus controller
  * vendor, device and revision IDs.
  *
  * Returns: 1 if it is an AMD chipset, 0 otherwise.
  */
 static int amd_chipset_sb_type_init(struct amd_chipset_info *pinfo)
 {
 	u8 rev = 0;
 	pinfo->sb_type.gen = AMD_CHIPSET_UNKNOWN;
 	pinfo->smbus_dev = pci_get_device(PCI_VENDOR_ID_ATI,
 			PCI_DEVICE_ID_ATI_SBX00_SMBUS, NULL);
 	if (pinfo->smbus_dev) {
 		rev = pinfo->smbus_dev->revision;
 		if (rev >= 0x10 && rev <= 0x1f)
 			pinfo->sb_type.gen = AMD_CHIPSET_SB600;
 		else if (rev >= 0x30 && rev <= 0x3f)
 			pinfo->sb_type.gen = AMD_CHIPSET_SB700;
 		else if (rev >= 0x40 && rev <= 0x4f)
 			pinfo->sb_type.gen = AMD_CHIPSET_SB800;
 	} else {
 		pinfo->smbus_dev = pci_get_device(PCI_VENDOR_ID_AMD,
 				PCI_DEVICE_ID_AMD_HUDSON2_SMBUS, NULL);
 		if (!pinfo->smbus_dev) {
 			pinfo->sb_type.gen = NOT_AMD_CHIPSET;
 			return 0;
 		}
 		rev = pinfo->smbus_dev->revision;
 		if (rev >= 0x11 && rev <= 0x14)
 			pinfo->sb_type.gen = AMD_CHIPSET_HUDSON2;
 		else if (rev >= 0x15 && rev <= 0x18)
 			pinfo->sb_type.gen = AMD_CHIPSET_BOLTON;
 		else if (rev >= 0x39 && rev <= 0x3a)
 			pinfo->sb_type.gen = AMD_CHIPSET_YANGTZE;
 	}
 	pinfo->sb_type.rev = rev;
 	return 1;
 }
 void sb800_prefetch(struct device *dev, int on)
 {
 	u16 misc;
 	struct pci_dev *pdev = to_pci_dev(dev);
 	pci_read_config_word(pdev, 0x50, &misc);
 	if (on == 0)
 		pci_write_config_word(pdev, 0x50, misc & 0xfcff);
 	else
 		pci_write_config_word(pdev, 0x50, misc | 0x0300);
 }
 EXPORT_SYMBOL_GPL(sb800_prefetch);
 int usb_amd_find_chipset_info(void)
 {
 	unsigned long flags;
 	struct amd_chipset_info info;
 	int ret;
 	spin_lock_irqsave(&amd_lock, flags);
 	/* probe only once */
 	if (amd_chipset.probe_count > 0) {
 		amd_chipset.probe_count++;
 		spin_unlock_irqrestore(&amd_lock, flags);
 		return amd_chipset.probe_result;
 	}
 	memset(&info, 0, sizeof(info));
 	spin_unlock_irqrestore(&amd_lock, flags);
 	if (!amd_chipset_sb_type_init(&info)) {
 		ret = 0;
 		goto commit;
 	}
 	/* Below chipset generations needn't enable AMD PLL quirk */
 	if (info.sb_type.gen == AMD_CHIPSET_UNKNOWN ||
 			info.sb_type.gen == AMD_CHIPSET_SB600 ||
 			info.sb_type.gen == AMD_CHIPSET_YANGTZE ||
 			(info.sb_type.gen == AMD_CHIPSET_SB700 &&
 			info.sb_type.rev > 0x3b)) {
 		if (info.smbus_dev) {
 			pci_dev_put(info.smbus_dev);
 			info.smbus_dev = NULL;
 		}
 		ret = 0;
 		goto commit;
 	}
 	info.nb_dev = pci_get_device(PCI_VENDOR_ID_AMD, 0x9601, NULL);
 	if (info.nb_dev) {
 		info.nb_type = 1;
 	} else {
 		info.nb_dev = pci_get_device(PCI_VENDOR_ID_AMD, 0x1510, NULL);
 		if (info.nb_dev) {
 			info.nb_type = 2;
 		} else {
 			info.nb_dev = pci_get_device(PCI_VENDOR_ID_AMD,
 						     0x9600, NULL);
 			if (info.nb_dev)
 				info.nb_type = 3;
 		}
 	}
 	ret = info.probe_result = 1;
 	printk(KERN_DEBUG "QUIRK: Enable AMD PLL fix\n");
 commit:
 	spin_lock_irqsave(&amd_lock, flags);
 	if (amd_chipset.probe_count > 0) {
 		/* race - someone else was faster - drop devices */
 		/* Mark that we where here */
 		amd_chipset.probe_count++;
 		ret = amd_chipset.probe_result;
 		spin_unlock_irqrestore(&amd_lock, flags);
 		if (info.nb_dev)
 			pci_dev_put(info.nb_dev);
 		if (info.smbus_dev)
 			pci_dev_put(info.smbus_dev);
 	} else {
 		/* no race - commit the result */
 		info.probe_count++;
 		amd_chipset = info;
 		spin_unlock_irqrestore(&amd_lock, flags);
 	}
 	return ret;
 }
 EXPORT_SYMBOL_GPL(usb_amd_find_chipset_info);
 int usb_hcd_amd_remote_wakeup_quirk(struct pci_dev *pdev)
 {
 	/* Make sure amd chipset type has already been initialized */
 	usb_amd_find_chipset_info();
 	if (amd_chipset.sb_type.gen != AMD_CHIPSET_YANGTZE)
 		return 0;
 	dev_dbg(&pdev->dev, "QUIRK: Enable AMD remote wakeup fix\n");
 	return 1;
 }
 EXPORT_SYMBOL_GPL(usb_hcd_amd_remote_wakeup_quirk);
 bool usb_amd_hang_symptom_quirk(void)
 {
 	u8 rev;
 	usb_amd_find_chipset_info();
 	rev = amd_chipset.sb_type.rev;
 	/* SB600 and old version of SB700 have hang symptom bug */
 	return amd_chipset.sb_type.gen == AMD_CHIPSET_SB600 ||
 			(amd_chipset.sb_type.gen == AMD_CHIPSET_SB700 &&
 			 rev >= 0x3a && rev <= 0x3b);
 }
 EXPORT_SYMBOL_GPL(usb_amd_hang_symptom_quirk);
 bool usb_amd_prefetch_quirk(void)
 {
 	usb_amd_find_chipset_info();
 	/* SB800 needs pre-fetch fix */
 	return amd_chipset.sb_type.gen == AMD_CHIPSET_SB800;
 }
 EXPORT_SYMBOL_GPL(usb_amd_prefetch_quirk);
 /*
  * The hardware normally enables the A-link power management feature, which
  * lets the system lower the power consumption in idle states.
  *
  * This USB quirk prevents the link going into that lower power state
  * during isochronous transfers.
  *
  * Without this quirk, isochronous stream on OHCI/EHCI/xHCI controllers of
  * some AMD platforms may stutter or have breaks occasionally.
  */
 static void usb_amd_quirk_pll(int disable)
 {
 	u32 addr, addr_low, addr_high, val;
 	u32 bit = disable ? 0 : 1;
 	unsigned long flags;
 	spin_lock_irqsave(&amd_lock, flags);
 	if (disable) {
 		amd_chipset.isoc_reqs++;
 		if (amd_chipset.isoc_reqs > 1) {
 			spin_unlock_irqrestore(&amd_lock, flags);
 			return;
 		}
 	} else {
 		amd_chipset.isoc_reqs--;
 		if (amd_chipset.isoc_reqs > 0) {
 			spin_unlock_irqrestore(&amd_lock, flags);
 			return;
 		}
 	}
 	if (amd_chipset.sb_type.gen == AMD_CHIPSET_SB800 ||
 			amd_chipset.sb_type.gen == AMD_CHIPSET_HUDSON2 ||
 			amd_chipset.sb_type.gen == AMD_CHIPSET_BOLTON) {
 		outb_p(AB_REG_BAR_LOW, 0xcd6);
 		addr_low = inb_p(0xcd7);
 		outb_p(AB_REG_BAR_HIGH, 0xcd6);
 		addr_high = inb_p(0xcd7);
 		addr = addr_high << 8 | addr_low;
 		outl_p(0x30, AB_INDX(addr));
 		outl_p(0x40, AB_DATA(addr));
 		outl_p(0x34, AB_INDX(addr));
 		val = inl_p(AB_DATA(addr));
 	} else if (amd_chipset.sb_type.gen == AMD_CHIPSET_SB700 &&
 			amd_chipset.sb_type.rev <= 0x3b) {
 		pci_read_config_dword(amd_chipset.smbus_dev,
 					AB_REG_BAR_SB700, &addr);
 		outl(AX_INDXC, AB_INDX(addr));
 		outl(0x40, AB_DATA(addr));
 		outl(AX_DATAC, AB_INDX(addr));
 		val = inl(AB_DATA(addr));
 	} else {
 		spin_unlock_irqrestore(&amd_lock, flags);
 		return;
 	}
 	if (disable) {
 		val &= ~0x08;
 		val |= (1 << 4) | (1 << 9);
 	} else {
 		val |= 0x08;
 		val &= ~((1 << 4) | (1 << 9));
 	}
 	outl_p(val, AB_DATA(addr));
 	if (!amd_chipset.nb_dev) {
 		spin_unlock_irqrestore(&amd_lock, flags);
 		return;
 	}
 	if (amd_chipset.nb_type == 1 || amd_chipset.nb_type == 3) {
 		addr = PCIE_P_CNTL;
 		pci_write_config_dword(amd_chipset.nb_dev,
 					NB_PCIE_INDX_ADDR, addr);
 		pci_read_config_dword(amd_chipset.nb_dev,
 					NB_PCIE_INDX_DATA, &val);
 		val &= ~(1 | (1 << 3) | (1 << 4) | (1 << 9) | (1 << 12));
 		val |= bit | (bit << 3) | (bit << 12);
 		val |= ((!bit) << 4) | ((!bit) << 9);
 		pci_write_config_dword(amd_chipset.nb_dev,
 					NB_PCIE_INDX_DATA, val);
 		addr = BIF_NB;
 		pci_write_config_dword(amd_chipset.nb_dev,
 					NB_PCIE_INDX_ADDR, addr);
 		pci_read_config_dword(amd_chipset.nb_dev,
 					NB_PCIE_INDX_DATA, &val);
 		val &= ~(1 << 8);
 		val |= bit << 8;
 		pci_write_config_dword(amd_chipset.nb_dev,
 					NB_PCIE_INDX_DATA, val);
 	} else if (amd_chipset.nb_type == 2) {
 		addr = NB_PIF0_PWRDOWN_0;
 		pci_write_config_dword(amd_chipset.nb_dev,
 					NB_PCIE_INDX_ADDR, addr);
 		pci_read_config_dword(amd_chipset.nb_dev,
 					NB_PCIE_INDX_DATA, &val);
 		if (disable)
 			val &= ~(0x3f << 7);
 		else
 			val |= 0x3f << 7;
 		pci_write_config_dword(amd_chipset.nb_dev,
 					NB_PCIE_INDX_DATA, val);
 		addr = NB_PIF0_PWRDOWN_1;
 		pci_write_config_dword(amd_chipset.nb_dev,
 					NB_PCIE_INDX_ADDR, addr);
 		pci_read_config_dword(amd_chipset.nb_dev,
 					NB_PCIE_INDX_DATA, &val);
 		if (disable)
 			val &= ~(0x3f << 7);
 		else
 			val |= 0x3f << 7;
 		pci_write_config_dword(amd_chipset.nb_dev,
 					NB_PCIE_INDX_DATA, val);
 	}
 	spin_unlock_irqrestore(&amd_lock, flags);
 	return;
 }
 void usb_amd_quirk_pll_disable(void)
 {
 	usb_amd_quirk_pll(1);
 }
 EXPORT_SYMBOL_GPL(usb_amd_quirk_pll_disable);
 void usb_amd_quirk_pll_enable(void)
 {
 	usb_amd_quirk_pll(0);
 }
 EXPORT_SYMBOL_GPL(usb_amd_quirk_pll_enable);
 void usb_amd_dev_put(void)
 {
 	struct pci_dev *nb, *smbus;
 	unsigned long flags;
 	spin_lock_irqsave(&amd_lock, flags);
 	amd_chipset.probe_count--;
 	if (amd_chipset.probe_count > 0) {
 		spin_unlock_irqrestore(&amd_lock, flags);
 		return;
 	}
 	/* save them to pci_dev_put outside of spinlock */
 	nb    = amd_chipset.nb_dev;
 	smbus = amd_chipset.smbus_dev;
 	amd_chipset.nb_dev = NULL;
 	amd_chipset.smbus_dev = NULL;
 	amd_chipset.nb_type = 0;
 	memset(&amd_chipset.sb_type, 0, sizeof(amd_chipset.sb_type));
 	amd_chipset.isoc_reqs = 0;
 	amd_chipset.probe_result = 0;
 	spin_unlock_irqrestore(&amd_lock, flags);
 	if (nb)
 		pci_dev_put(nb);
 	if (smbus)
 		pci_dev_put(smbus);
 }
 EXPORT_SYMBOL_GPL(usb_amd_dev_put);
 /*
  * Make sure the controller is completely inactive, unable to
  * generate interrupts or do DMA.
  */
 void uhci_reset_hc(struct pci_dev *pdev, unsigned long base)
 {
 	/* Turn off PIRQ enable and SMI enable.  (This also turns off the
 	 * BIOS's USB Legacy Support.)  Turn off all the R/WC bits too.
 	 */
 	pci_write_config_word(pdev, UHCI_USBLEGSUP, UHCI_USBLEGSUP_RWC);
 	/* Reset the HC - this will force us to get a
 	 * new notification of any already connected
 	 * ports due to the virtual disconnect that it
 	 * implies.
 	 */
 	outw(UHCI_USBCMD_HCRESET, base + UHCI_USBCMD);
 	mb();
 	udelay(5);
 	if (inw(base + UHCI_USBCMD) & UHCI_USBCMD_HCRESET)
 		dev_warn(&pdev->dev, "HCRESET not completed yet!\n");
 	/* Just to be safe, disable interrupt requests and
 	 * make sure the controller is stopped.
 	 */
 	outw(0, base + UHCI_USBINTR);
 	outw(0, base + UHCI_USBCMD);
 }
 EXPORT_SYMBOL_GPL(uhci_reset_hc);
 /*
  * Initialize a controller that was newly discovered or has just been
  * resumed.  In either case we can't be sure of its previous state.
  *
  * Returns: 1 if the controller was reset, 0 otherwise.
  */
 int uhci_check_and_reset_hc(struct pci_dev *pdev, unsigned long base)
 {
 	u16 legsup;
 	unsigned int cmd, intr;
 	/*
 	 * When restarting a suspended controller, we expect all the
 	 * settings to be the same as we left them:
 	 *
 	 *	PIRQ and SMI disabled, no R/W bits set in USBLEGSUP;
 	 *	Controller is stopped and configured with EGSM set;
 	 *	No interrupts enabled except possibly Resume Detect.
 	 *
 	 * If any of these conditions are violated we do a complete reset.
 	 */
 	pci_read_config_word(pdev, UHCI_USBLEGSUP, &legsup);
 	if (legsup & ~(UHCI_USBLEGSUP_RO | UHCI_USBLEGSUP_RWC)) {
 		dev_dbg(&pdev->dev, "%s: legsup = 0x%04x\n",
 				__func__, legsup);
 		goto reset_needed;
 	}
 	cmd = inw(base + UHCI_USBCMD);
 	if ((cmd & UHCI_USBCMD_RUN) || !(cmd & UHCI_USBCMD_CONFIGURE) ||
 			!(cmd & UHCI_USBCMD_EGSM)) {
 		dev_dbg(&pdev->dev, "%s: cmd = 0x%04x\n",
 				__func__, cmd);
 		goto reset_needed;
 	}
 	intr = inw(base + UHCI_USBINTR);
 	if (intr & (~UHCI_USBINTR_RESUME)) {
 		dev_dbg(&pdev->dev, "%s: intr = 0x%04x\n",
 				__func__, intr);
 		goto reset_needed;
 	}
 	return 0;
 reset_needed:
 	dev_dbg(&pdev->dev, "Performing full reset\n");
 	uhci_reset_hc(pdev, base);
 	return 1;
 }
 EXPORT_SYMBOL_GPL(uhci_check_and_reset_hc);
 static inline int io_type_enabled(struct pci_dev *pdev, unsigned int mask)
 {
 	u16 cmd;
 	return !pci_read_config_word(pdev, PCI_COMMAND, &cmd) && (cmd & mask);
 }
 #define pio_enabled(dev) io_type_enabled(dev, PCI_COMMAND_IO)
 #define mmio_enabled(dev) io_type_enabled(dev, PCI_COMMAND_MEMORY)
 static void quirk_usb_handoff_uhci(struct pci_dev *pdev)
 {
 	unsigned long base = 0;
 	int i;
 	if (!pio_enabled(pdev))
 		return;
 	for (i = 0; i < PCI_ROM_RESOURCE; i++)
 		if ((pci_resource_flags(pdev, i) & IORESOURCE_IO)) {
 			base = pci_resource_start(pdev, i);
 			break;
 		}
 	if (base)
 		uhci_check_and_reset_hc(pdev, base);
 }
 static int mmio_resource_enabled(struct pci_dev *pdev, int idx)
 {
 	return pci_resource_start(pdev, idx) && mmio_enabled(pdev);
 }
 static void quirk_usb_handoff_ohci(struct pci_dev *pdev)
 {
 	void __iomem *base;
 	u32 control;
 	u32 fminterval;
 	int cnt;
 	if (!mmio_resource_enabled(pdev, 0))
 		return;
 	base = pci_ioremap_bar(pdev, 0);
 	if (base == NULL)
 		return;
 	control = readl(base + OHCI_CONTROL);
 /* On PA-RISC, PDC can leave IR set incorrectly; ignore it there. */
 #ifdef __hppa__
 #define	OHCI_CTRL_MASK		(OHCI_CTRL_RWC | OHCI_CTRL_IR)
 #else
 #define	OHCI_CTRL_MASK		OHCI_CTRL_RWC
 	if (control & OHCI_CTRL_IR) {
 		int wait_time = 500; /* arbitrary; 5 seconds */
 		writel(OHCI_INTR_OC, base + OHCI_INTRENABLE);
 		writel(OHCI_OCR, base + OHCI_CMDSTATUS);
 		while (wait_time > 0 &&
 				readl(base + OHCI_CONTROL) & OHCI_CTRL_IR) {
 			wait_time -= 10;
 			msleep(10);
 		}
 		if (wait_time <= 0)
 			dev_warn(&pdev->dev, "OHCI: BIOS handoff failed"
 					" (BIOS bug?) %08x\n",
 					readl(base + OHCI_CONTROL));
 	}
 #endif
 	/* disable interrupts */
 	writel((u32) ~0, base + OHCI_INTRDISABLE);
 	/* Reset the USB bus, if the controller isn't already in RESET */
 	if (control & OHCI_HCFS) {
 		/* Go into RESET, preserving RWC (and possibly IR) */
 		writel(control & OHCI_CTRL_MASK, base + OHCI_CONTROL);
 		readl(base + OHCI_CONTROL);
 		/* drive bus reset for at least 50 ms (7.1.7.5) */
 		msleep(50);
 	}
 	/* software reset of the controller, preserving HcFmInterval */
 	fminterval = readl(base + OHCI_FMINTERVAL);
 	writel(OHCI_HCR, base + OHCI_CMDSTATUS);
 	/* reset requires max 10 us delay */
 	for (cnt = 30; cnt > 0; --cnt) {	/* ... allow extra time */
 		if ((readl(base + OHCI_CMDSTATUS) & OHCI_HCR) == 0)
 			break;
 		udelay(1);
 	}
 	writel(fminterval, base + OHCI_FMINTERVAL);
 	/* Now the controller is safely in SUSPEND and nothing can wake it up */
 	iounmap(base);
 }
 static const struct dmi_system_id ehci_dmi_nohandoff_table[] = {
 	{
 		/*  Pegatron Lucid (ExoPC) */
 		.matches = {
 			DMI_MATCH(DMI_BOARD_NAME, "EXOPG06411"),
 			DMI_MATCH(DMI_BIOS_VERSION, "Lucid-CE-133"),
 		},
 	},
 	{
 		/*  Pegatron Lucid (Ordissimo AIRIS) */
 		.matches = {
 			DMI_MATCH(DMI_BOARD_NAME, "M11JB"),
 			DMI_MATCH(DMI_BIOS_VERSION, "Lucid-"),
 		},
 	},
 	{
 		/*  Pegatron Lucid (Ordissimo) */
 		.matches = {
 			DMI_MATCH(DMI_BOARD_NAME, "Ordissimo"),
 			DMI_MATCH(DMI_BIOS_VERSION, "Lucid-"),
 		},
 	},
 	{ }
 };
 static void ehci_bios_handoff(struct pci_dev *pdev,
 					void __iomem *op_reg_base,
 					u32 cap, u8 offset)
 {
 	int try_handoff = 1, tried_handoff = 0;
 	/* The Pegatron Lucid tablet sporadically waits for 98 seconds trying
 	 * the handoff on its unused controller.  Skip it. */
 	if (pdev->vendor == 0x8086 && pdev->device == 0x283a) {
 		if (dmi_check_system(ehci_dmi_nohandoff_table))
 			try_handoff = 0;
 	}
 	if (try_handoff && (cap & EHCI_USBLEGSUP_BIOS)) {
 		dev_dbg(&pdev->dev, "EHCI: BIOS handoff\n");
 #if 0
 /* aleksey_gorelov@phoenix.com reports that some systems need SMI forced on,
  * but that seems dubious in general (the BIOS left it off intentionally)
  * and is known to prevent some systems from booting.  so we won't do this
  * unless maybe we can determine when we're on a system that needs SMI forced.
  */
 		/* BIOS workaround (?): be sure the pre-Linux code
 		 * receives the SMI
 		 */
 		pci_read_config_dword(pdev, offset + EHCI_USBLEGCTLSTS, &val);
 		pci_write_config_dword(pdev, offset + EHCI_USBLEGCTLSTS,
 				       val | EHCI_USBLEGCTLSTS_SOOE);
 #endif
 		/* some systems get upset if this semaphore is
 		 * set for any other reason than forcing a BIOS
 		 * handoff..
 		 */
 		pci_write_config_byte(pdev, offset + 3, 1);
 	}
 	/* if boot firmware now owns EHCI, spin till it hands it over. */
 	if (try_handoff) {
 		int msec = 1000;
 		while ((cap & EHCI_USBLEGSUP_BIOS) && (msec > 0)) {
 			tried_handoff = 1;
 			msleep(10);
 			msec -= 10;
 			pci_read_config_dword(pdev, offset, &cap);
 		}
 	}
 	if (cap & EHCI_USBLEGSUP_BIOS) {
 		/* well, possibly buggy BIOS... try to shut it down,
 		 * and hope nothing goes too wrong
 		 */
 		if (try_handoff)
 			dev_warn(&pdev->dev, "EHCI: BIOS handoff failed"
 				 " (BIOS bug?) %08x\n", cap);
 		pci_write_config_byte(pdev, offset + 2, 0);
 	}
 	/* just in case, always disable EHCI SMIs */
 	pci_write_config_dword(pdev, offset + EHCI_USBLEGCTLSTS, 0);
 	/* If the BIOS ever owned the controller then we can't expect
 	 * any power sessions to remain intact.
 	 */
 	if (tried_handoff)
 		writel(0, op_reg_base + EHCI_CONFIGFLAG);
 }
 static void quirk_usb_disable_ehci(struct pci_dev *pdev)
 {
 	void __iomem *base, *op_reg_base;
 	u32	hcc_params, cap, val;
 	u8	offset, cap_length;
 	int	wait_time, count = 256/4;
 	if (!mmio_resource_enabled(pdev, 0))
 		return;
 	base = pci_ioremap_bar(pdev, 0);
 	if (base == NULL)
 		return;
 	cap_length = readb(base);
 	op_reg_base = base + cap_length;
 	/* EHCI 0.96 and later may have "extended capabilities"
 	 * spec section 5.1 explains the bios handoff, e.g. for
 	 * booting from USB disk or using a usb keyboard
 	 */
 	hcc_params = readl(base + EHCI_HCC_PARAMS);
 	offset = (hcc_params >> 8) & 0xff;
 	while (offset && --count) {
 		pci_read_config_dword(pdev, offset, &cap);
 		switch (cap & 0xff) {
 		case 1:
 			ehci_bios_handoff(pdev, op_reg_base, cap, offset);
 			break;
 		case 0: /* Illegal reserved cap, set cap=0 so we exit */
 			cap = 0; /* then fallthrough... */
 		default:
 			dev_warn(&pdev->dev, "EHCI: unrecognized capability "
 				 "%02x\n", cap & 0xff);
 		}
 		offset = (cap >> 8) & 0xff;
 	}
 	if (!count)
 		dev_printk(KERN_DEBUG, &pdev->dev, "EHCI: capability loop?\n");
 	/*
 	 * halt EHCI & disable its interrupts in any case
 	 */
 	val = readl(op_reg_base + EHCI_USBSTS);
 	if ((val & EHCI_USBSTS_HALTED) == 0) {
 		val = readl(op_reg_base + EHCI_USBCMD);
 		val &= ~EHCI_USBCMD_RUN;
 		writel(val, op_reg_base + EHCI_USBCMD);
 		wait_time = 2000;
 		do {
 			writel(0x3f, op_reg_base + EHCI_USBSTS);
 			udelay(100);
 			wait_time -= 100;
 			val = readl(op_reg_base + EHCI_USBSTS);
 			if ((val == ~(u32)0) || (val & EHCI_USBSTS_HALTED)) {
 				break;
 			}
 		} while (wait_time > 0);
 	}
 	writel(0, op_reg_base + EHCI_USBINTR);
 	writel(0x3f, op_reg_base + EHCI_USBSTS);
 	iounmap(base);
 }
 /*
  * handshake - spin reading a register until handshake completes
  * @ptr: address of hc register to be read
  * @mask: bits to look at in result of read
  * @done: value of those bits when handshake succeeds
  * @wait_usec: timeout in microseconds
  * @delay_usec: delay in microseconds to wait between polling
  *
  * Polls a register every delay_usec microseconds.
  * Returns 0 when the mask bits have the value done.
  * Returns -ETIMEDOUT if this condition is not true after
  * wait_usec microseconds have passed.
  */
 static int handshake(void __iomem *ptr, u32 mask, u32 done,
 		int wait_usec, int delay_usec)
 {
 	u32	result;
 	do {
 		result = readl(ptr);
 		result &= mask;
 		if (result == done)
 			return 0;
 		udelay(delay_usec);
 		wait_usec -= delay_usec;
 	} while (wait_usec > 0);
 	return -ETIMEDOUT;
 }
 /*
  * Intel's Panther Point chipset has two host controllers (EHCI and xHCI) that
  * share some number of ports.  These ports can be switched between either
  * controller.  Not all of the ports under the EHCI host controller may be
  * switchable.
  *
  * The ports should be switched over to xHCI before PCI probes for any device
  * start.  This avoids active devices under EHCI being disconnected during the
  * port switchover, which could cause loss of data on USB storage devices, or
  * failed boot when the root file system is on a USB mass storage device and is
  * enumerated under EHCI first.
  *
  * We write into the xHC's PCI configuration space in some Intel-specific
  * registers to switch the ports over.  The USB 3.0 terminations and the USB
  * 2.0 data wires are switched separately.  We want to enable the SuperSpeed
  * terminations before switching the USB 2.0 wires over, so that USB 3.0
  * devices connect at SuperSpeed, rather than at USB 2.0 speeds.
  */
 void usb_enable_intel_xhci_ports(struct pci_dev *xhci_pdev)
 {
 	u32		ports_available;
 	bool		ehci_found = false;
 	struct pci_dev	*companion = NULL;
+	/* Sony VAIO t-series with subsystem device ID 90a8 is not capable of
+	 * switching ports from EHCI to xHCI
+	 */
+	if (xhci_pdev->subsystem_vendor == PCI_VENDOR_ID_SONY &&
+	    xhci_pdev->subsystem_device == 0x90a8)
+		return;
 	/* make sure an intel EHCI controller exists */
 	for_each_pci_dev(companion) {
 		if (companion->class == PCI_CLASS_SERIAL_USB_EHCI &&
 		    companion->vendor == PCI_VENDOR_ID_INTEL) {
 			ehci_found = true;
 			break;
 		}
 	}
 	if (!ehci_found)
 		return;
 	/* Don't switchover the ports if the user hasn't compiled the xHCI
 	 * driver.  Otherwise they will see "dead" USB ports that don't power
 	 * the devices.
 	 */
 	if (!IS_ENABLED(CONFIG_USB_XHCI_HCD)) {
 		dev_warn(&xhci_pdev->dev,
 				"CONFIG_USB_XHCI_HCD is turned off, "
 				"defaulting to EHCI.\n");
 		dev_warn(&xhci_pdev->dev,
 				"USB 3.0 devices will work at USB 2.0 speeds.\n");
 		usb_disable_xhci_ports(xhci_pdev);
 		return;
 	}
 	/* Read USB3PRM, the USB 3.0 Port Routing Mask Register
 	 * Indicate the ports that can be changed from OS.
 	 */
 	pci_read_config_dword(xhci_pdev, USB_INTEL_USB3PRM,
 			&ports_available);
 	dev_dbg(&xhci_pdev->dev, "Configurable ports to enable SuperSpeed: 0x%x\n",
 			ports_available);
 	/* Write USB3_PSSEN, the USB 3.0 Port SuperSpeed Enable
 	 * Register, to turn on SuperSpeed terminations for the
 	 * switchable ports.
 	 */
 	pci_write_config_dword(xhci_pdev, USB_INTEL_USB3_PSSEN,
 			ports_available);
 	pci_read_config_dword(xhci_pdev, USB_INTEL_USB3_PSSEN,
 			&ports_available);
 	dev_dbg(&xhci_pdev->dev, "USB 3.0 ports that are now enabled "
 			"under xHCI: 0x%x\n", ports_available);
 	/* Read XUSB2PRM, xHCI USB 2.0 Port Routing Mask Register
 	 * Indicate the USB 2.0 ports to be controlled by the xHCI host.
 	 */
 	pci_read_config_dword(xhci_pdev, USB_INTEL_USB2PRM,
 			&ports_available);
 	dev_dbg(&xhci_pdev->dev, "Configurable USB 2.0 ports to hand over to xCHI: 0x%x\n",
 			ports_available);
 	/* Write XUSB2PR, the xHC USB 2.0 Port Routing Register, to
 	 * switch the USB 2.0 power and data lines over to the xHCI
 	 * host.
 	 */
 	pci_write_config_dword(xhci_pdev, USB_INTEL_XUSB2PR,
 			ports_available);
 	pci_read_config_dword(xhci_pdev, USB_INTEL_XUSB2PR,
 			&ports_available);
 	dev_dbg(&xhci_pdev->dev, "USB 2.0 ports that are now switched over "
 			"to xHCI: 0x%x\n", ports_available);
 }
 EXPORT_SYMBOL_GPL(usb_enable_intel_xhci_ports);
 void usb_disable_xhci_ports(struct pci_dev *xhci_pdev)
 {
 	pci_write_config_dword(xhci_pdev, USB_INTEL_USB3_PSSEN, 0x0);
 	pci_write_config_dword(xhci_pdev, USB_INTEL_XUSB2PR, 0x0);
 }
 EXPORT_SYMBOL_GPL(usb_disable_xhci_ports);
 /**
  * PCI Quirks for xHCI.
  *
  * Takes care of the handoff between the Pre-OS (i.e. BIOS) and the OS.
  * It signals to the BIOS that the OS wants control of the host controller,
  * and then waits 5 seconds for the BIOS to hand over control.
  * If we timeout, assume the BIOS is broken and take control anyway.
  */
 static void quirk_usb_handoff_xhci(struct pci_dev *pdev)
 {
 	void __iomem *base;
 	int ext_cap_offset;
 	void __iomem *op_reg_base;
 	u32 val;
 	int timeout;
 	int len = pci_resource_len(pdev, 0);
 	if (!mmio_resource_enabled(pdev, 0))
 		return;
 	base = ioremap_nocache(pci_resource_start(pdev, 0), len);
 	if (base == NULL)
 		return;
 	/*
 	 * Find the Legacy Support Capability register -
 	 * this is optional for xHCI host controllers.
 	 */
 	ext_cap_offset = xhci_find_next_cap_offset(base, XHCI_HCC_PARAMS_OFFSET);
 	do {
 		if ((ext_cap_offset + sizeof(val)) > len) {
 			/* We're reading garbage from the controller */
 			dev_warn(&pdev->dev,
 				 "xHCI controller failing to respond");
 			return;
 		}
 		if (!ext_cap_offset)
 			/* We've reached the end of the extended capabilities */
 			goto hc_init;
 		val = readl(base + ext_cap_offset);
 		if (XHCI_EXT_CAPS_ID(val) == XHCI_EXT_CAPS_LEGACY)
 			break;
 		ext_cap_offset = xhci_find_next_cap_offset(base, ext_cap_offset);
 	} while (1);
 	/* If the BIOS owns the HC, signal that the OS wants it, and wait */
 	if (val & XHCI_HC_BIOS_OWNED) {
 		writel(val | XHCI_HC_OS_OWNED, base + ext_cap_offset);
 		/* Wait for 5 seconds with 10 microsecond polling interval */
 		timeout = handshake(base + ext_cap_offset, XHCI_HC_BIOS_OWNED,
 				0, 5000, 10);
 		/* Assume a buggy BIOS and take HC ownership anyway */
 		if (timeout) {
 			dev_warn(&pdev->dev, "xHCI BIOS handoff failed"
 					" (BIOS bug ?) %08x\n", val);
 			writel(val & ~XHCI_HC_BIOS_OWNED, base + ext_cap_offset);
 		}
 	}
 	val = readl(base + ext_cap_offset + XHCI_LEGACY_CONTROL_OFFSET);
 	/* Mask off (turn off) any enabled SMIs */
 	val &= XHCI_LEGACY_DISABLE_SMI;
 	/* Mask all SMI events bits, RW1C */
 	val |= XHCI_LEGACY_SMI_EVENTS;
 	/* Disable any BIOS SMIs and clear all SMI events*/
 	writel(val, base + ext_cap_offset + XHCI_LEGACY_CONTROL_OFFSET);
 hc_init:
 	if (pdev->vendor == PCI_VENDOR_ID_INTEL)
 		usb_enable_intel_xhci_ports(pdev);
 	op_reg_base = base + XHCI_HC_LENGTH(readl(base));
 	/* Wait for the host controller to be ready before writing any
 	 * operational or runtime registers.  Wait 5 seconds and no more.
 	 */
 	timeout = handshake(op_reg_base + XHCI_STS_OFFSET, XHCI_STS_CNR, 0,
 			5000, 10);
 	/* Assume a buggy HC and start HC initialization anyway */
 	if (timeout) {
 		val = readl(op_reg_base + XHCI_STS_OFFSET);
 		dev_warn(&pdev->dev,
 				"xHCI HW not ready after 5 sec (HC bug?) "
 				"status = 0x%x\n", val);
 	}
 	/* Send the halt and disable interrupts command */
 	val = readl(op_reg_base + XHCI_CMD_OFFSET);
 	val &= ~(XHCI_CMD_RUN | XHCI_IRQS);
 	writel(val, op_reg_base + XHCI_CMD_OFFSET);
 	/* Wait for the HC to halt - poll every 125 usec (one microframe). */
 	timeout = handshake(op_reg_base + XHCI_STS_OFFSET, XHCI_STS_HALT, 1,
 			XHCI_MAX_HALT_USEC, 125);
 	if (timeout) {
 		val = readl(op_reg_base + XHCI_STS_OFFSET);
 		dev_warn(&pdev->dev,
 				"xHCI HW did not halt within %d usec "
 				"status = 0x%x\n", XHCI_MAX_HALT_USEC, val);
 	}
 	iounmap(base);
 }
 static void quirk_usb_early_handoff(struct pci_dev *pdev)
 {
 	/* Skip Netlogic mips SoC's internal PCI USB controller.
 	 * This device does not need/support EHCI/OHCI handoff
 	 */
 	if (pdev->vendor == 0x184e)	/* vendor Netlogic */
 		return;
 	if (pdev->class != PCI_CLASS_SERIAL_USB_UHCI &&
 			pdev->class != PCI_CLASS_SERIAL_USB_OHCI &&
 			pdev->class != PCI_CLASS_SERIAL_USB_EHCI &&
 			pdev->class != PCI_CLASS_SERIAL_USB_XHCI)
 		return;
 	if (pci_enable_device(pdev) < 0) {
 		dev_warn(&pdev->dev, "Can't enable PCI device, "
 				"BIOS handoff failed.\n");
 		return;
 	}
 	if (pdev->class == PCI_CLASS_SERIAL_USB_UHCI)
 		quirk_usb_handoff_uhci(pdev);
 	else if (pdev->class == PCI_CLASS_SERIAL_USB_OHCI)
 		quirk_usb_handoff_ohci(pdev);
 	else if (pdev->class == PCI_CLASS_SERIAL_USB_EHCI)
 		quirk_usb_disable_ehci(pdev);
 	else if (pdev->class == PCI_CLASS_SERIAL_USB_XHCI)
 		quirk_usb_handoff_xhci(pdev);
 	pci_disable_device(pdev);
 }
 DECLARE_PCI_FIXUP_CLASS_FINAL(PCI_ANY_ID, PCI_ANY_ID,
 			PCI_CLASS_SERIAL_USB, 8, quirk_usb_early_handoff);

drivers/usb/host/xhci-mem.c

Diff comments View file @ 8ee7a33

 /*
  * xHCI host controller driver
  *
  * Copyright (C) 2008 Intel Corp.
  *
  * Author: Sarah Sharp
  * Some code borrowed from the Linux EHCI driver.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
  * 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.
  */
 #include <linux/usb.h>
 #include <linux/pci.h>
 #include <linux/slab.h>
 #include <linux/dmapool.h>
 #include <linux/dma-mapping.h>
 #include "xhci.h"
 #include "xhci-trace.h"
 /*
  * Allocates a generic ring segment from the ring pool, sets the dma address,
  * initializes the segment to zero, and sets the private next pointer to NULL.
  *
  * Section 4.11.1.1:
  * "All components of all Command and Transfer TRBs shall be initialized to '0'"
  */
 static struct xhci_segment *xhci_segment_alloc(struct xhci_hcd *xhci,
 					unsigned int cycle_state, gfp_t flags)
 {
 	struct xhci_segment *seg;
 	dma_addr_t	dma;
 	int		i;
 	seg = kzalloc(sizeof *seg, flags);
 	if (!seg)
 		return NULL;
 	seg->trbs = dma_pool_alloc(xhci->segment_pool, flags, &dma);
 	if (!seg->trbs) {
 		kfree(seg);
 		return NULL;
 	}
 	memset(seg->trbs, 0, TRB_SEGMENT_SIZE);
 	/* If the cycle state is 0, set the cycle bit to 1 for all the TRBs */
 	if (cycle_state == 0) {
 		for (i = 0; i < TRBS_PER_SEGMENT; i++)
 			seg->trbs[i].link.control |= cpu_to_le32(TRB_CYCLE);
 	}
 	seg->dma = dma;
 	seg->next = NULL;
 	return seg;
 }
 static void xhci_segment_free(struct xhci_hcd *xhci, struct xhci_segment *seg)
 {
 	if (seg->trbs) {
 		dma_pool_free(xhci->segment_pool, seg->trbs, seg->dma);
 		seg->trbs = NULL;
 	}
 	kfree(seg);
 }
 static void xhci_free_segments_for_ring(struct xhci_hcd *xhci,
 				struct xhci_segment *first)
 {
 	struct xhci_segment *seg;
 	seg = first->next;
 	while (seg != first) {
 		struct xhci_segment *next = seg->next;
 		xhci_segment_free(xhci, seg);
 		seg = next;
 	}
 	xhci_segment_free(xhci, first);
 }
 /*
  * Make the prev segment point to the next segment.
  *
  * Change the last TRB in the prev segment to be a Link TRB which points to the
  * DMA address of the next segment.  The caller needs to set any Link TRB
  * related flags, such as End TRB, Toggle Cycle, and no snoop.
  */
 static void xhci_link_segments(struct xhci_hcd *xhci, struct xhci_segment *prev,
 		struct xhci_segment *next, enum xhci_ring_type type)
 {
 	u32 val;
 	if (!prev || !next)
 		return;
 	prev->next = next;
 	if (type != TYPE_EVENT) {
 		prev->trbs[TRBS_PER_SEGMENT-1].link.segment_ptr =
 			cpu_to_le64(next->dma);
 		/* Set the last TRB in the segment to have a TRB type ID of Link TRB */
 		val = le32_to_cpu(prev->trbs[TRBS_PER_SEGMENT-1].link.control);
 		val &= ~TRB_TYPE_BITMASK;
 		val |= TRB_TYPE(TRB_LINK);
 		/* Always set the chain bit with 0.95 hardware */
 		/* Set chain bit for isoc rings on AMD 0.96 host */
 		if (xhci_link_trb_quirk(xhci) ||
 				(type == TYPE_ISOC &&
 				 (xhci->quirks & XHCI_AMD_0x96_HOST)))
 			val |= TRB_CHAIN;
 		prev->trbs[TRBS_PER_SEGMENT-1].link.control = cpu_to_le32(val);
 	}
 }
 /*
  * Link the ring to the new segments.
  * Set Toggle Cycle for the new ring if needed.
  */
 static void xhci_link_rings(struct xhci_hcd *xhci, struct xhci_ring *ring,
 		struct xhci_segment *first, struct xhci_segment *last,
 		unsigned int num_segs)
 {
 	struct xhci_segment *next;
 	if (!ring || !first || !last)
 		return;
 	next = ring->enq_seg->next;
 	xhci_link_segments(xhci, ring->enq_seg, first, ring->type);
 	xhci_link_segments(xhci, last, next, ring->type);
 	ring->num_segs += num_segs;
 	ring->num_trbs_free += (TRBS_PER_SEGMENT - 1) * num_segs;
 	if (ring->type != TYPE_EVENT && ring->enq_seg == ring->last_seg) {
 		ring->last_seg->trbs[TRBS_PER_SEGMENT-1].link.control
 			&= ~cpu_to_le32(LINK_TOGGLE);
 		last->trbs[TRBS_PER_SEGMENT-1].link.control
 			|= cpu_to_le32(LINK_TOGGLE);
 		ring->last_seg = last;
 	}
 }
 /*
  * We need a radix tree for mapping physical addresses of TRBs to which stream
  * ID they belong to.  We need to do this because the host controller won't tell
  * us which stream ring the TRB came from.  We could store the stream ID in an
  * event data TRB, but that doesn't help us for the cancellation case, since the
  * endpoint may stop before it reaches that event data TRB.
  *
  * The radix tree maps the upper portion of the TRB DMA address to a ring
  * segment that has the same upper portion of DMA addresses.  For example, say I
  * have segments of size 1KB, that are always 1KB aligned.  A segment may
  * start at 0x10c91000 and end at 0x10c913f0.  If I use the upper 10 bits, the
  * key to the stream ID is 0x43244.  I can use the DMA address of the TRB to
  * pass the radix tree a key to get the right stream ID:
  *
  *	0x10c90fff >> 10 = 0x43243
  *	0x10c912c0 >> 10 = 0x43244
  *	0x10c91400 >> 10 = 0x43245
  *
  * Obviously, only those TRBs with DMA addresses that are within the segment
  * will make the radix tree return the stream ID for that ring.
  *
  * Caveats for the radix tree:
  *
  * The radix tree uses an unsigned long as a key pair.  On 32-bit systems, an
  * unsigned long will be 32-bits; on a 64-bit system an unsigned long will be
  * 64-bits.  Since we only request 32-bit DMA addresses, we can use that as the
  * key on 32-bit or 64-bit systems (it would also be fine if we asked for 64-bit
  * PCI DMA addresses on a 64-bit system).  There might be a problem on 32-bit
  * extended systems (where the DMA address can be bigger than 32-bits),
  * if we allow the PCI dma mask to be bigger than 32-bits.  So don't do that.
  */
 static int xhci_insert_segment_mapping(struct radix_tree_root *trb_address_map,
 		struct xhci_ring *ring,
 		struct xhci_segment *seg,
 		gfp_t mem_flags)
 {
 	unsigned long key;
 	int ret;
 	key = (unsigned long)(seg->dma >> TRB_SEGMENT_SHIFT);
 	/* Skip any segments that were already added. */
 	if (radix_tree_lookup(trb_address_map, key))
 		return 0;
 	ret = radix_tree_maybe_preload(mem_flags);
 	if (ret)
 		return ret;
 	ret = radix_tree_insert(trb_address_map,
 			key, ring);
 	radix_tree_preload_end();
 	return ret;
 }
 static void xhci_remove_segment_mapping(struct radix_tree_root *trb_address_map,
 		struct xhci_segment *seg)
 {
 	unsigned long key;
 	key = (unsigned long)(seg->dma >> TRB_SEGMENT_SHIFT);
 	if (radix_tree_lookup(trb_address_map, key))
 		radix_tree_delete(trb_address_map, key);
 }
 static int xhci_update_stream_segment_mapping(
 		struct radix_tree_root *trb_address_map,
 		struct xhci_ring *ring,
 		struct xhci_segment *first_seg,
 		struct xhci_segment *last_seg,
 		gfp_t mem_flags)
 {
 	struct xhci_segment *seg;
 	struct xhci_segment *failed_seg;
 	int ret;
 	if (WARN_ON_ONCE(trb_address_map == NULL))
 		return 0;
 	seg = first_seg;
 	do {
 		ret = xhci_insert_segment_mapping(trb_address_map,
 				ring, seg, mem_flags);
 		if (ret)
 			goto remove_streams;
 		if (seg == last_seg)
 			return 0;
 		seg = seg->next;
 	} while (seg != first_seg);
 	return 0;
 remove_streams:
 	failed_seg = seg;
 	seg = first_seg;
 	do {
 		xhci_remove_segment_mapping(trb_address_map, seg);
 		if (seg == failed_seg)
 			return ret;
 		seg = seg->next;
 	} while (seg != first_seg);
 	return ret;
 }
 static void xhci_remove_stream_mapping(struct xhci_ring *ring)
 {
 	struct xhci_segment *seg;
 	if (WARN_ON_ONCE(ring->trb_address_map == NULL))
 		return;
 	seg = ring->first_seg;
 	do {
 		xhci_remove_segment_mapping(ring->trb_address_map, seg);
 		seg = seg->next;
 	} while (seg != ring->first_seg);
 }
 static int xhci_update_stream_mapping(struct xhci_ring *ring, gfp_t mem_flags)
 {
 	return xhci_update_stream_segment_mapping(ring->trb_address_map, ring,
 			ring->first_seg, ring->last_seg, mem_flags);
 }
 /* XXX: Do we need the hcd structure in all these functions? */
 void xhci_ring_free(struct xhci_hcd *xhci, struct xhci_ring *ring)
 {
 	if (!ring)
 		return;
 	if (ring->first_seg) {
 		if (ring->type == TYPE_STREAM)
 			xhci_remove_stream_mapping(ring);
 		xhci_free_segments_for_ring(xhci, ring->first_seg);
 	}
 	kfree(ring);
 }
 static void xhci_initialize_ring_info(struct xhci_ring *ring,
 					unsigned int cycle_state)
 {
 	/* The ring is empty, so the enqueue pointer == dequeue pointer */
 	ring->enqueue = ring->first_seg->trbs;
 	ring->enq_seg = ring->first_seg;
 	ring->dequeue = ring->enqueue;
 	ring->deq_seg = ring->first_seg;
 	/* The ring is initialized to 0. The producer must write 1 to the cycle
 	 * bit to handover ownership of the TRB, so PCS = 1.  The consumer must
 	 * compare CCS to the cycle bit to check ownership, so CCS = 1.
 	 *
 	 * New rings are initialized with cycle state equal to 1; if we are
 	 * handling ring expansion, set the cycle state equal to the old ring.
 	 */
 	ring->cycle_state = cycle_state;
 	/* Not necessary for new rings, but needed for re-initialized rings */
 	ring->enq_updates = 0;
 	ring->deq_updates = 0;
 	/*
 	 * Each segment has a link TRB, and leave an extra TRB for SW
 	 * accounting purpose
 	 */
 	ring->num_trbs_free = ring->num_segs * (TRBS_PER_SEGMENT - 1) - 1;
 }
 /* Allocate segments and link them for a ring */
 static int xhci_alloc_segments_for_ring(struct xhci_hcd *xhci,
 		struct xhci_segment **first, struct xhci_segment **last,
 		unsigned int num_segs, unsigned int cycle_state,
 		enum xhci_ring_type type, gfp_t flags)
 {
 	struct xhci_segment *prev;
 	prev = xhci_segment_alloc(xhci, cycle_state, flags);
 	if (!prev)
 		return -ENOMEM;
 	num_segs--;
 	*first = prev;
 	while (num_segs > 0) {
 		struct xhci_segment	*next;
 		next = xhci_segment_alloc(xhci, cycle_state, flags);
 		if (!next) {
 			prev = *first;
 			while (prev) {
 				next = prev->next;
 				xhci_segment_free(xhci, prev);
 				prev = next;
 			}
 			return -ENOMEM;
 		}
 		xhci_link_segments(xhci, prev, next, type);
 		prev = next;
 		num_segs--;
 	}
 	xhci_link_segments(xhci, prev, *first, type);
 	*last = prev;
 	return 0;
 }
 /**
  * Create a new ring with zero or more segments.
  *
  * Link each segment together into a ring.
  * Set the end flag and the cycle toggle bit on the last segment.
  * See section 4.9.1 and figures 15 and 16.
  */
 static struct xhci_ring *xhci_ring_alloc(struct xhci_hcd *xhci,
 		unsigned int num_segs, unsigned int cycle_state,
 		enum xhci_ring_type type, gfp_t flags)
 {
 	struct xhci_ring	*ring;
 	int ret;
 	ring = kzalloc(sizeof *(ring), flags);
 	if (!ring)
 		return NULL;
 	ring->num_segs = num_segs;
 	INIT_LIST_HEAD(&ring->td_list);
 	ring->type = type;
 	if (num_segs == 0)
 		return ring;
 	ret = xhci_alloc_segments_for_ring(xhci, &ring->first_seg,
 			&ring->last_seg, num_segs, cycle_state, type, flags);
 	if (ret)
 		goto fail;
 	/* Only event ring does not use link TRB */
 	if (type != TYPE_EVENT) {
 		/* See section 4.9.2.1 and 6.4.4.1 */
 		ring->last_seg->trbs[TRBS_PER_SEGMENT - 1].link.control |=
 			cpu_to_le32(LINK_TOGGLE);
 	}
 	xhci_initialize_ring_info(ring, cycle_state);
 	return ring;
 fail:
 	kfree(ring);
 	return NULL;
 }
 void xhci_free_or_cache_endpoint_ring(struct xhci_hcd *xhci,
 		struct xhci_virt_device *virt_dev,
 		unsigned int ep_index)
 {
 	int rings_cached;
 	rings_cached = virt_dev->num_rings_cached;
 	if (rings_cached < XHCI_MAX_RINGS_CACHED) {
 		virt_dev->ring_cache[rings_cached] =
 			virt_dev->eps[ep_index].ring;
 		virt_dev->num_rings_cached++;
 		xhci_dbg(xhci, "Cached old ring, "
 				"%d ring%s cached\n",
 				virt_dev->num_rings_cached,
 				(virt_dev->num_rings_cached > 1) ? "s" : "");
 	} else {
 		xhci_ring_free(xhci, virt_dev->eps[ep_index].ring);
 		xhci_dbg(xhci, "Ring cache full (%d rings), "
 				"freeing ring\n",
 				virt_dev->num_rings_cached);
 	}
 	virt_dev->eps[ep_index].ring = NULL;
 }
 /* Zero an endpoint ring (except for link TRBs) and move the enqueue and dequeue
  * pointers to the beginning of the ring.
  */
 static void xhci_reinit_cached_ring(struct xhci_hcd *xhci,
 			struct xhci_ring *ring, unsigned int cycle_state,
 			enum xhci_ring_type type)
 {
 	struct xhci_segment	*seg = ring->first_seg;
 	int i;
 	do {
 		memset(seg->trbs, 0,
 				sizeof(union xhci_trb)*TRBS_PER_SEGMENT);
 		if (cycle_state == 0) {
 			for (i = 0; i < TRBS_PER_SEGMENT; i++)
 				seg->trbs[i].link.control |=
 					cpu_to_le32(TRB_CYCLE);
 		}
 		/* All endpoint rings have link TRBs */
 		xhci_link_segments(xhci, seg, seg->next, type);
 		seg = seg->next;
 	} while (seg != ring->first_seg);
 	ring->type = type;
 	xhci_initialize_ring_info(ring, cycle_state);
 	/* td list should be empty since all URBs have been cancelled,
 	 * but just in case...
 	 */
 	INIT_LIST_HEAD(&ring->td_list);
 }
 /*
  * Expand an existing ring.
  * Look for a cached ring or allocate a new ring which has same segment numbers
  * and link the two rings.
  */
 int xhci_ring_expansion(struct xhci_hcd *xhci, struct xhci_ring *ring,
 				unsigned int num_trbs, gfp_t flags)
 {
 	struct xhci_segment	*first;
 	struct xhci_segment	*last;
 	unsigned int		num_segs;
 	unsigned int		num_segs_needed;
 	int			ret;
 	num_segs_needed = (num_trbs + (TRBS_PER_SEGMENT - 1) - 1) /
 				(TRBS_PER_SEGMENT - 1);
 	/* Allocate number of segments we needed, or double the ring size */
 	num_segs = ring->num_segs > num_segs_needed ?
 			ring->num_segs : num_segs_needed;
 	ret = xhci_alloc_segments_for_ring(xhci, &first, &last,
 			num_segs, ring->cycle_state, ring->type, flags);
 	if (ret)
 		return -ENOMEM;
 	if (ring->type == TYPE_STREAM)
 		ret = xhci_update_stream_segment_mapping(ring->trb_address_map,
 						ring, first, last, flags);
 	if (ret) {
 		struct xhci_segment *next;
 		do {
 			next = first->next;
 			xhci_segment_free(xhci, first);
 			if (first == last)
 				break;
 			first = next;
 		} while (true);
 		return ret;
 	}
 	xhci_link_rings(xhci, ring, first, last, num_segs);
 	xhci_dbg_trace(xhci, trace_xhci_dbg_ring_expansion,
 			"ring expansion succeed, now has %d segments",
 			ring->num_segs);
 	return 0;
 }
 #define CTX_SIZE(_hcc) (HCC_64BYTE_CONTEXT(_hcc) ? 64 : 32)
 static struct xhci_container_ctx *xhci_alloc_container_ctx(struct xhci_hcd *xhci,
 						    int type, gfp_t flags)
 {
 	struct xhci_container_ctx *ctx;
 	if ((type != XHCI_CTX_TYPE_DEVICE) && (type != XHCI_CTX_TYPE_INPUT))
 		return NULL;
 	ctx = kzalloc(sizeof(*ctx), flags);
 	if (!ctx)
 		return NULL;
 	ctx->type = type;
 	ctx->size = HCC_64BYTE_CONTEXT(xhci->hcc_params) ? 2048 : 1024;
 	if (type == XHCI_CTX_TYPE_INPUT)
 		ctx->size += CTX_SIZE(xhci->hcc_params);
 	ctx->bytes = dma_pool_alloc(xhci->device_pool, flags, &ctx->dma);
 	if (!ctx->bytes) {
 		kfree(ctx);
 		return NULL;
 	}
 	memset(ctx->bytes, 0, ctx->size);
 	return ctx;
 }
 static void xhci_free_container_ctx(struct xhci_hcd *xhci,
 			     struct xhci_container_ctx *ctx)
 {
 	if (!ctx)
 		return;
 	dma_pool_free(xhci->device_pool, ctx->bytes, ctx->dma);
 	kfree(ctx);
 }
 struct xhci_input_control_ctx *xhci_get_input_control_ctx(struct xhci_hcd *xhci,
 					      struct xhci_container_ctx *ctx)
 {
 	if (ctx->type != XHCI_CTX_TYPE_INPUT)
 		return NULL;
 	return (struct xhci_input_control_ctx *)ctx->bytes;
 }
 struct xhci_slot_ctx *xhci_get_slot_ctx(struct xhci_hcd *xhci,
 					struct xhci_container_ctx *ctx)
 {
 	if (ctx->type == XHCI_CTX_TYPE_DEVICE)
 		return (struct xhci_slot_ctx *)ctx->bytes;
 	return (struct xhci_slot_ctx *)
 		(ctx->bytes + CTX_SIZE(xhci->hcc_params));
 }
 struct xhci_ep_ctx *xhci_get_ep_ctx(struct xhci_hcd *xhci,
 				    struct xhci_container_ctx *ctx,
 				    unsigned int ep_index)
 {
 	/* increment ep index by offset of start of ep ctx array */
 	ep_index++;
 	if (ctx->type == XHCI_CTX_TYPE_INPUT)
 		ep_index++;
 	return (struct xhci_ep_ctx *)
 		(ctx->bytes + (ep_index * CTX_SIZE(xhci->hcc_params)));
 }
 /***************** Streams structures manipulation *************************/
 static void xhci_free_stream_ctx(struct xhci_hcd *xhci,
 		unsigned int num_stream_ctxs,
 		struct xhci_stream_ctx *stream_ctx, dma_addr_t dma)
 {
 	struct device *dev = xhci_to_hcd(xhci)->self.controller;
 	size_t size = sizeof(struct xhci_stream_ctx) * num_stream_ctxs;
 	if (size > MEDIUM_STREAM_ARRAY_SIZE)
 		dma_free_coherent(dev, size,
 				stream_ctx, dma);
 	else if (size <= SMALL_STREAM_ARRAY_SIZE)
 		return dma_pool_free(xhci->small_streams_pool,
 				stream_ctx, dma);
 	else
 		return dma_pool_free(xhci->medium_streams_pool,
 				stream_ctx, dma);
 }
 /*
  * The stream context array for each endpoint with bulk streams enabled can
  * vary in size, based on:
  *  - how many streams the endpoint supports,
  *  - the maximum primary stream array size the host controller supports,
  *  - and how many streams the device driver asks for.
  *
  * The stream context array must be a power of 2, and can be as small as
  * 64 bytes or as large as 1MB.
  */
 static struct xhci_stream_ctx *xhci_alloc_stream_ctx(struct xhci_hcd *xhci,
 		unsigned int num_stream_ctxs, dma_addr_t *dma,
 		gfp_t mem_flags)
 {
 	struct device *dev = xhci_to_hcd(xhci)->self.controller;
 	size_t size = sizeof(struct xhci_stream_ctx) * num_stream_ctxs;
 	if (size > MEDIUM_STREAM_ARRAY_SIZE)
 		return dma_alloc_coherent(dev, size,
 				dma, mem_flags);
 	else if (size <= SMALL_STREAM_ARRAY_SIZE)
 		return dma_pool_alloc(xhci->small_streams_pool,
 				mem_flags, dma);
 	else
 		return dma_pool_alloc(xhci->medium_streams_pool,
 				mem_flags, dma);
 }
 struct xhci_ring *xhci_dma_to_transfer_ring(
 		struct xhci_virt_ep *ep,
 		u64 address)
 {
 	if (ep->ep_state & EP_HAS_STREAMS)
 		return radix_tree_lookup(&ep->stream_info->trb_address_map,
 				address >> TRB_SEGMENT_SHIFT);
 	return ep->ring;
 }
 struct xhci_ring *xhci_stream_id_to_ring(
 		struct xhci_virt_device *dev,
 		unsigned int ep_index,
 		unsigned int stream_id)
 {
 	struct xhci_virt_ep *ep = &dev->eps[ep_index];
 	if (stream_id == 0)
 		return ep->ring;
 	if (!ep->stream_info)
 		return NULL;
 	if (stream_id > ep->stream_info->num_streams)
 		return NULL;
 	return ep->stream_info->stream_rings[stream_id];
 }
 /*
  * Change an endpoint's internal structure so it supports stream IDs.  The
  * number of requested streams includes stream 0, which cannot be used by device
  * drivers.
  *
  * The number of stream contexts in the stream context array may be bigger than
  * the number of streams the driver wants to use.  This is because the number of
  * stream context array entries must be a power of two.
  */
 struct xhci_stream_info *xhci_alloc_stream_info(struct xhci_hcd *xhci,
 		unsigned int num_stream_ctxs,
 		unsigned int num_streams, gfp_t mem_flags)
 {
 	struct xhci_stream_info *stream_info;
 	u32 cur_stream;
 	struct xhci_ring *cur_ring;
 	u64 addr;
 	int ret;
 	xhci_dbg(xhci, "Allocating %u streams and %u "
 			"stream context array entries.\n",
 			num_streams, num_stream_ctxs);
 	if (xhci->cmd_ring_reserved_trbs == MAX_RSVD_CMD_TRBS) {
 		xhci_dbg(xhci, "Command ring has no reserved TRBs available\n");
 		return NULL;
 	}
 	xhci->cmd_ring_reserved_trbs++;
 	stream_info = kzalloc(sizeof(struct xhci_stream_info), mem_flags);
 	if (!stream_info)
 		goto cleanup_trbs;
 	stream_info->num_streams = num_streams;
 	stream_info->num_stream_ctxs = num_stream_ctxs;
 	/* Initialize the array of virtual pointers to stream rings. */
 	stream_info->stream_rings = kzalloc(
 			sizeof(struct xhci_ring *)*num_streams,
 			mem_flags);
 	if (!stream_info->stream_rings)
 		goto cleanup_info;
 	/* Initialize the array of DMA addresses for stream rings for the HW. */
 	stream_info->stream_ctx_array = xhci_alloc_stream_ctx(xhci,
 			num_stream_ctxs, &stream_info->ctx_array_dma,
 			mem_flags);
 	if (!stream_info->stream_ctx_array)
 		goto cleanup_ctx;
 	memset(stream_info->stream_ctx_array, 0,
 			sizeof(struct xhci_stream_ctx)*num_stream_ctxs);
 	/* Allocate everything needed to free the stream rings later */
 	stream_info->free_streams_command =
 		xhci_alloc_command(xhci, true, true, mem_flags);
 	if (!stream_info->free_streams_command)
 		goto cleanup_ctx;
 	INIT_RADIX_TREE(&stream_info->trb_address_map, GFP_ATOMIC);
 	/* Allocate rings for all the streams that the driver will use,
 	 * and add their segment DMA addresses to the radix tree.
 	 * Stream 0 is reserved.
 	 */
 	for (cur_stream = 1; cur_stream < num_streams; cur_stream++) {
 		stream_info->stream_rings[cur_stream] =
 			xhci_ring_alloc(xhci, 2, 1, TYPE_STREAM, mem_flags);
 		cur_ring = stream_info->stream_rings[cur_stream];
 		if (!cur_ring)
 			goto cleanup_rings;
 		cur_ring->stream_id = cur_stream;
 		cur_ring->trb_address_map = &stream_info->trb_address_map;
 		/* Set deq ptr, cycle bit, and stream context type */
 		addr = cur_ring->first_seg->dma |
 			SCT_FOR_CTX(SCT_PRI_TR) |
 			cur_ring->cycle_state;
 		stream_info->stream_ctx_array[cur_stream].stream_ring =
 			cpu_to_le64(addr);
 		xhci_dbg(xhci, "Setting stream %d ring ptr to 0x%08llx\n",
 				cur_stream, (unsigned long long) addr);
 		ret = xhci_update_stream_mapping(cur_ring, mem_flags);
 		if (ret) {
 			xhci_ring_free(xhci, cur_ring);
 			stream_info->stream_rings[cur_stream] = NULL;
 			goto cleanup_rings;
 		}
 	}
 	/* Leave the other unused stream ring pointers in the stream context
 	 * array initialized to zero.  This will cause the xHC to give us an
 	 * error if the device asks for a stream ID we don't have setup (if it
 	 * was any other way, the host controller would assume the ring is
 	 * "empty" and wait forever for data to be queued to that stream ID).
 	 */
 	return stream_info;
 cleanup_rings:
 	for (cur_stream = 1; cur_stream < num_streams; cur_stream++) {
 		cur_ring = stream_info->stream_rings[cur_stream];
 		if (cur_ring) {
 			xhci_ring_free(xhci, cur_ring);
 			stream_info->stream_rings[cur_stream] = NULL;
 		}
 	}
 	xhci_free_command(xhci, stream_info->free_streams_command);
 cleanup_ctx:
 	kfree(stream_info->stream_rings);
 cleanup_info:
 	kfree(stream_info);
 cleanup_trbs:
 	xhci->cmd_ring_reserved_trbs--;
 	return NULL;
 }
 /*
  * Sets the MaxPStreams field and the Linear Stream Array field.
  * Sets the dequeue pointer to the stream context array.
  */
 void xhci_setup_streams_ep_input_ctx(struct xhci_hcd *xhci,
 		struct xhci_ep_ctx *ep_ctx,
 		struct xhci_stream_info *stream_info)
 {
 	u32 max_primary_streams;
 	/* MaxPStreams is the number of stream context array entries, not the
 	 * number we're actually using.  Must be in 2^(MaxPstreams + 1) format.
 	 * fls(0) = 0, fls(0x1) = 1, fls(0x10) = 2, fls(0x100) = 3, etc.
 	 */
 	max_primary_streams = fls(stream_info->num_stream_ctxs) - 2;
 	xhci_dbg_trace(xhci,  trace_xhci_dbg_context_change,
 			"Setting number of stream ctx array entries to %u",
 			1 << (max_primary_streams + 1));
 	ep_ctx->ep_info &= cpu_to_le32(~EP_MAXPSTREAMS_MASK);
 	ep_ctx->ep_info |= cpu_to_le32(EP_MAXPSTREAMS(max_primary_streams)
 				       | EP_HAS_LSA);
 	ep_ctx->deq  = cpu_to_le64(stream_info->ctx_array_dma);
 }
 /*
  * Sets the MaxPStreams field and the Linear Stream Array field to 0.
  * Reinstalls the "normal" endpoint ring (at its previous dequeue mark,
  * not at the beginning of the ring).
  */
 void xhci_setup_no_streams_ep_input_ctx(struct xhci_hcd *xhci,
 		struct xhci_ep_ctx *ep_ctx,
 		struct xhci_virt_ep *ep)
 {
 	dma_addr_t addr;
 	ep_ctx->ep_info &= cpu_to_le32(~(EP_MAXPSTREAMS_MASK | EP_HAS_LSA));
 	addr = xhci_trb_virt_to_dma(ep->ring->deq_seg, ep->ring->dequeue);
 	ep_ctx->deq  = cpu_to_le64(addr | ep->ring->cycle_state);
 }
 /* Frees all stream contexts associated with the endpoint,
  *
  * Caller should fix the endpoint context streams fields.
  */
 void xhci_free_stream_info(struct xhci_hcd *xhci,
 		struct xhci_stream_info *stream_info)
 {
 	int cur_stream;
 	struct xhci_ring *cur_ring;
 	if (!stream_info)
 		return;
 	for (cur_stream = 1; cur_stream < stream_info->num_streams;
 			cur_stream++) {
 		cur_ring = stream_info->stream_rings[cur_stream];
 		if (cur_ring) {
 			xhci_ring_free(xhci, cur_ring);
 			stream_info->stream_rings[cur_stream] = NULL;
 		}
 	}
 	xhci_free_command(xhci, stream_info->free_streams_command);
 	xhci->cmd_ring_reserved_trbs--;
 	if (stream_info->stream_ctx_array)
 		xhci_free_stream_ctx(xhci,
 				stream_info->num_stream_ctxs,
 				stream_info->stream_ctx_array,
 				stream_info->ctx_array_dma);
 	kfree(stream_info->stream_rings);
 	kfree(stream_info);
 }
 /***************** Device context manipulation *************************/
 static void xhci_init_endpoint_timer(struct xhci_hcd *xhci,
 		struct xhci_virt_ep *ep)
 {
 	init_timer(&ep->stop_cmd_timer);
 	ep->stop_cmd_timer.data = (unsigned long) ep;
 	ep->stop_cmd_timer.function = xhci_stop_endpoint_command_watchdog;
 	ep->xhci = xhci;
 }
 static void xhci_free_tt_info(struct xhci_hcd *xhci,
 		struct xhci_virt_device *virt_dev,
 		int slot_id)
 {
 	struct list_head *tt_list_head;
 	struct xhci_tt_bw_info *tt_info, *next;
 	bool slot_found = false;
 	/* If the device never made it past the Set Address stage,
 	 * it may not have the real_port set correctly.
 	 */
 	if (virt_dev->real_port == 0 ||
 			virt_dev->real_port > HCS_MAX_PORTS(xhci->hcs_params1)) {
 		xhci_dbg(xhci, "Bad real port.\n");
 		return;
 	}
 	tt_list_head = &(xhci->rh_bw[virt_dev->real_port - 1].tts);
 	list_for_each_entry_safe(tt_info, next, tt_list_head, tt_list) {
 		/* Multi-TT hubs will have more than one entry */
 		if (tt_info->slot_id == slot_id) {
 			slot_found = true;
 			list_del(&tt_info->tt_list);
 			kfree(tt_info);
 		} else if (slot_found) {
 			break;
 		}
 	}
 }
 int xhci_alloc_tt_info(struct xhci_hcd *xhci,
 		struct xhci_virt_device *virt_dev,
 		struct usb_device *hdev,
 		struct usb_tt *tt, gfp_t mem_flags)
 {
 	struct xhci_tt_bw_info		*tt_info;
 	unsigned int			num_ports;
 	int				i, j;
 	if (!tt->multi)
 		num_ports = 1;
 	else
 		num_ports = hdev->maxchild;
 	for (i = 0; i < num_ports; i++, tt_info++) {
 		struct xhci_interval_bw_table *bw_table;
 		tt_info = kzalloc(sizeof(*tt_info), mem_flags);
 		if (!tt_info)
 			goto free_tts;
 		INIT_LIST_HEAD(&tt_info->tt_list);
 		list_add(&tt_info->tt_list,
 				&xhci->rh_bw[virt_dev->real_port - 1].tts);
 		tt_info->slot_id = virt_dev->udev->slot_id;
 		if (tt->multi)
 			tt_info->ttport = i+1;
 		bw_table = &tt_info->bw_table;
 		for (j = 0; j < XHCI_MAX_INTERVAL; j++)
 			INIT_LIST_HEAD(&bw_table->interval_bw[j].endpoints);
 	}
 	return 0;
 free_tts:
 	xhci_free_tt_info(xhci, virt_dev, virt_dev->udev->slot_id);
 	return -ENOMEM;
 }
 /* All the xhci_tds in the ring's TD list should be freed at this point.
  * Should be called with xhci->lock held if there is any chance the TT lists
  * will be manipulated by the configure endpoint, allocate device, or update
  * hub functions while this function is removing the TT entries from the list.
  */
 void xhci_free_virt_device(struct xhci_hcd *xhci, int slot_id)
 {
 	struct xhci_virt_device *dev;
 	int i;
 	int old_active_eps = 0;
 	/* Slot ID 0 is reserved */
 	if (slot_id == 0 || !xhci->devs[slot_id])
 		return;
 	dev = xhci->devs[slot_id];
 	xhci->dcbaa->dev_context_ptrs[slot_id] = 0;
 	if (!dev)
 		return;
 	if (dev->tt_info)
 		old_active_eps = dev->tt_info->active_eps;
 	for (i = 0; i < 31; ++i) {
 		if (dev->eps[i].ring)
 			xhci_ring_free(xhci, dev->eps[i].ring);
 		if (dev->eps[i].stream_info)
 			xhci_free_stream_info(xhci,
 					dev->eps[i].stream_info);
 		/* Endpoints on the TT/root port lists should have been removed
 		 * when usb_disable_device() was called for the device.
 		 * We can't drop them anyway, because the udev might have gone
 		 * away by this point, and we can't tell what speed it was.
 		 */
 		if (!list_empty(&dev->eps[i].bw_endpoint_list))
 			xhci_warn(xhci, "Slot %u endpoint %u "
 					"not removed from BW list!\n",
 					slot_id, i);
 	}
 	/* If this is a hub, free the TT(s) from the TT list */
 	xhci_free_tt_info(xhci, dev, slot_id);
 	/* If necessary, update the number of active TTs on this root port */
 	xhci_update_tt_active_eps(xhci, dev, old_active_eps);
 	if (dev->ring_cache) {
 		for (i = 0; i < dev->num_rings_cached; i++)
 			xhci_ring_free(xhci, dev->ring_cache[i]);
 		kfree(dev->ring_cache);
 	}
 	if (dev->in_ctx)
 		xhci_free_container_ctx(xhci, dev->in_ctx);
 	if (dev->out_ctx)
 		xhci_free_container_ctx(xhci, dev->out_ctx);
 	kfree(xhci->devs[slot_id]);
 	xhci->devs[slot_id] = NULL;
 }
 int xhci_alloc_virt_device(struct xhci_hcd *xhci, int slot_id,
 		struct usb_device *udev, gfp_t flags)
 {
 	struct xhci_virt_device *dev;
 	int i;
 	/* Slot ID 0 is reserved */
 	if (slot_id == 0 || xhci->devs[slot_id]) {
 		xhci_warn(xhci, "Bad Slot ID %d\n", slot_id);
 		return 0;
 	}
 	xhci->devs[slot_id] = kzalloc(sizeof(*xhci->devs[slot_id]), flags);
 	if (!xhci->devs[slot_id])
 		return 0;
 	dev = xhci->devs[slot_id];
 	/* Allocate the (output) device context that will be used in the HC. */
 	dev->out_ctx = xhci_alloc_container_ctx(xhci, XHCI_CTX_TYPE_DEVICE, flags);
 	if (!dev->out_ctx)
 		goto fail;
 	xhci_dbg(xhci, "Slot %d output ctx = 0x%llx (dma)\n", slot_id,
 			(unsigned long long)dev->out_ctx->dma);
 	/* Allocate the (input) device context for address device command */
 	dev->in_ctx = xhci_alloc_container_ctx(xhci, XHCI_CTX_TYPE_INPUT, flags);
 	if (!dev->in_ctx)
 		goto fail;
 	xhci_dbg(xhci, "Slot %d input ctx = 0x%llx (dma)\n", slot_id,
 			(unsigned long long)dev->in_ctx->dma);
 	/* Initialize the cancellation list and watchdog timers for each ep */
 	for (i = 0; i < 31; i++) {
 		xhci_init_endpoint_timer(xhci, &dev->eps[i]);
 		INIT_LIST_HEAD(&dev->eps[i].cancelled_td_list);
 		INIT_LIST_HEAD(&dev->eps[i].bw_endpoint_list);
 	}
 	/* Allocate endpoint 0 ring */
 	dev->eps[0].ring = xhci_ring_alloc(xhci, 2, 1, TYPE_CTRL, flags);
 	if (!dev->eps[0].ring)
 		goto fail;
 	/* Allocate pointers to the ring cache */
 	dev->ring_cache = kzalloc(
 			sizeof(struct xhci_ring *)*XHCI_MAX_RINGS_CACHED,
 			flags);
 	if (!dev->ring_cache)
 		goto fail;
 	dev->num_rings_cached = 0;
 	init_completion(&dev->cmd_completion);
 	INIT_LIST_HEAD(&dev->cmd_list);
 	dev->udev = udev;
 	/* Point to output device context in dcbaa. */
 	xhci->dcbaa->dev_context_ptrs[slot_id] = cpu_to_le64(dev->out_ctx->dma);
 	xhci_dbg(xhci, "Set slot id %d dcbaa entry %p to 0x%llx\n",
 		 slot_id,
 		 &xhci->dcbaa->dev_context_ptrs[slot_id],
 		 le64_to_cpu(xhci->dcbaa->dev_context_ptrs[slot_id]));
 	return 1;
 fail:
 	xhci_free_virt_device(xhci, slot_id);
 	return 0;
 }
 void xhci_copy_ep0_dequeue_into_input_ctx(struct xhci_hcd *xhci,
 		struct usb_device *udev)
 {
 	struct xhci_virt_device *virt_dev;
 	struct xhci_ep_ctx	*ep0_ctx;
 	struct xhci_ring	*ep_ring;
 	virt_dev = xhci->devs[udev->slot_id];
 	ep0_ctx = xhci_get_ep_ctx(xhci, virt_dev->in_ctx, 0);
 	ep_ring = virt_dev->eps[0].ring;
 	/*
 	 * FIXME we don't keep track of the dequeue pointer very well after a
 	 * Set TR dequeue pointer, so we're setting the dequeue pointer of the
 	 * host to our enqueue pointer.  This should only be called after a
 	 * configured device has reset, so all control transfers should have
 	 * been completed or cancelled before the reset.
 	 */
 	ep0_ctx->deq = cpu_to_le64(xhci_trb_virt_to_dma(ep_ring->enq_seg,
 							ep_ring->enqueue)
 				   | ep_ring->cycle_state);
 }
 /*
  * The xHCI roothub may have ports of differing speeds in any order in the port
  * status registers.  xhci->port_array provides an array of the port speed for
  * each offset into the port status registers.
  *
  * The xHCI hardware wants to know the roothub port number that the USB device
  * is attached to (or the roothub port its ancestor hub is attached to).  All we
  * know is the index of that port under either the USB 2.0 or the USB 3.0
  * roothub, but that doesn't give us the real index into the HW port status
  * registers. Call xhci_find_raw_port_number() to get real index.
  */
 static u32 xhci_find_real_port_number(struct xhci_hcd *xhci,
 		struct usb_device *udev)
 {
 	struct usb_device *top_dev;
 	struct usb_hcd *hcd;
 	if (udev->speed == USB_SPEED_SUPER)
 		hcd = xhci->shared_hcd;
 	else
 		hcd = xhci->main_hcd;
 	for (top_dev = udev; top_dev->parent && top_dev->parent->parent;
 			top_dev = top_dev->parent)
 		/* Found device below root hub */;
 	return	xhci_find_raw_port_number(hcd, top_dev->portnum);
 }
 /* Setup an xHCI virtual device for a Set Address command */
 int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *udev)
 {
 	struct xhci_virt_device *dev;
 	struct xhci_ep_ctx	*ep0_ctx;
 	struct xhci_slot_ctx    *slot_ctx;
 	u32			port_num;
 	u32			max_packets;
 	struct usb_device *top_dev;
 	dev = xhci->devs[udev->slot_id];
 	/* Slot ID 0 is reserved */
 	if (udev->slot_id == 0 || !dev) {
 		xhci_warn(xhci, "Slot ID %d is not assigned to this device\n",
 				udev->slot_id);
 		return -EINVAL;
 	}
 	ep0_ctx = xhci_get_ep_ctx(xhci, dev->in_ctx, 0);
 	slot_ctx = xhci_get_slot_ctx(xhci, dev->in_ctx);
 	/* 3) Only the control endpoint is valid - one endpoint context */
 	slot_ctx->dev_info |= cpu_to_le32(LAST_CTX(1) | udev->route);
 	switch (udev->speed) {
 	case USB_SPEED_SUPER:
 		slot_ctx->dev_info |= cpu_to_le32(SLOT_SPEED_SS);
 		max_packets = MAX_PACKET(512);
 		break;
 	case USB_SPEED_HIGH:
 		slot_ctx->dev_info |= cpu_to_le32(SLOT_SPEED_HS);
 		max_packets = MAX_PACKET(64);
 		break;
 	/* USB core guesses at a 64-byte max packet first for FS devices */
 	case USB_SPEED_FULL:
 		slot_ctx->dev_info |= cpu_to_le32(SLOT_SPEED_FS);
 		max_packets = MAX_PACKET(64);
 		break;
 	case USB_SPEED_LOW:
 		slot_ctx->dev_info |= cpu_to_le32(SLOT_SPEED_LS);
 		max_packets = MAX_PACKET(8);
 		break;
 	case USB_SPEED_WIRELESS:
 		xhci_dbg(xhci, "FIXME xHCI doesn't support wireless speeds\n");
 		return -EINVAL;
 		break;
 	default:
 		/* Speed was set earlier, this shouldn't happen. */
 		return -EINVAL;
 	}
 	/* Find the root hub port this device is under */
 	port_num = xhci_find_real_port_number(xhci, udev);
 	if (!port_num)
 		return -EINVAL;
 	slot_ctx->dev_info2 |= cpu_to_le32(ROOT_HUB_PORT(port_num));
 	/* Set the port number in the virtual_device to the faked port number */
 	for (top_dev = udev; top_dev->parent && top_dev->parent->parent;
 			top_dev = top_dev->parent)
 		/* Found device below root hub */;
 	dev->fake_port = top_dev->portnum;
 	dev->real_port = port_num;
 	xhci_dbg(xhci, "Set root hub portnum to %d\n", port_num);
 	xhci_dbg(xhci, "Set fake root hub portnum to %d\n", dev->fake_port);
 	/* Find the right bandwidth table that this device will be a part of.
 	 * If this is a full speed device attached directly to a root port (or a
 	 * decendent of one), it counts as a primary bandwidth domain, not a
 	 * secondary bandwidth domain under a TT.  An xhci_tt_info structure
 	 * will never be created for the HS root hub.
 	 */
 	if (!udev->tt || !udev->tt->hub->parent) {
 		dev->bw_table = &xhci->rh_bw[port_num - 1].bw_table;
 	} else {
 		struct xhci_root_port_bw_info *rh_bw;
 		struct xhci_tt_bw_info *tt_bw;
 		rh_bw = &xhci->rh_bw[port_num - 1];
 		/* Find the right TT. */
 		list_for_each_entry(tt_bw, &rh_bw->tts, tt_list) {
 			if (tt_bw->slot_id != udev->tt->hub->slot_id)
 				continue;
 			if (!dev->udev->tt->multi ||
 					(udev->tt->multi &&
 					 tt_bw->ttport == dev->udev->ttport)) {
 				dev->bw_table = &tt_bw->bw_table;
 				dev->tt_info = tt_bw;
 				break;
 			}
 		}
 		if (!dev->tt_info)
 			xhci_warn(xhci, "WARN: Didn't find a matching TT\n");
 	}
 	/* Is this a LS/FS device under an external HS hub? */
 	if (udev->tt && udev->tt->hub->parent) {
 		slot_ctx->tt_info = cpu_to_le32(udev->tt->hub->slot_id |
 						(udev->ttport << 8));
 		if (udev->tt->multi)
 			slot_ctx->dev_info |= cpu_to_le32(DEV_MTT);
 	}
 	xhci_dbg(xhci, "udev->tt = %p\n", udev->tt);
 	xhci_dbg(xhci, "udev->ttport = 0x%x\n", udev->ttport);
 	/* Step 4 - ring already allocated */
 	/* Step 5 */
 	ep0_ctx->ep_info2 = cpu_to_le32(EP_TYPE(CTRL_EP));
 	/* EP 0 can handle "burst" sizes of 1, so Max Burst Size field is 0 */
 	ep0_ctx->ep_info2 |= cpu_to_le32(MAX_BURST(0) | ERROR_COUNT(3) |
 					 max_packets);
 	ep0_ctx->deq = cpu_to_le64(dev->eps[0].ring->first_seg->dma |
 				   dev->eps[0].ring->cycle_state);
 	/* Steps 7 and 8 were done in xhci_alloc_virt_device() */
 	return 0;
 }
 /*
  * Convert interval expressed as 2^(bInterval - 1) == interval into
  * straight exponent value 2^n == interval.
  *
  */
 static unsigned int xhci_parse_exponent_interval(struct usb_device *udev,
 		struct usb_host_endpoint *ep)
 {
 	unsigned int interval;
 	interval = clamp_val(ep->desc.bInterval, 1, 16) - 1;
 	if (interval != ep->desc.bInterval - 1)
 		dev_warn(&udev->dev,
 			 "ep %#x - rounding interval to %d %sframes\n",
 			 ep->desc.bEndpointAddress,
 			 1 << interval,
 			 udev->speed == USB_SPEED_FULL ? "" : "micro");
 	if (udev->speed == USB_SPEED_FULL) {
 		/*
 		 * Full speed isoc endpoints specify interval in frames,
 		 * not microframes. We are using microframes everywhere,
 		 * so adjust accordingly.
 		 */
 		interval += 3;	/* 1 frame = 2^3 uframes */
 	}
 	return interval;
 }
 /*
  * Convert bInterval expressed in microframes (in 1-255 range) to exponent of
  * microframes, rounded down to nearest power of 2.
  */
 static unsigned int xhci_microframes_to_exponent(struct usb_device *udev,
 		struct usb_host_endpoint *ep, unsigned int desc_interval,
 		unsigned int min_exponent, unsigned int max_exponent)
 {
 	unsigned int interval;
 	interval = fls(desc_interval) - 1;
 	interval = clamp_val(interval, min_exponent, max_exponent);
 	if ((1 << interval) != desc_interval)
 		dev_warn(&udev->dev,
 			 "ep %#x - rounding interval to %d microframes, ep desc says %d microframes\n",
 			 ep->desc.bEndpointAddress,
 			 1 << interval,
 			 desc_interval);
 	return interval;
 }
 static unsigned int xhci_parse_microframe_interval(struct usb_device *udev,
 		struct usb_host_endpoint *ep)
 {
 	if (ep->desc.bInterval == 0)
 		return 0;
 	return xhci_microframes_to_exponent(udev, ep,
 			ep->desc.bInterval, 0, 15);
 }
 static unsigned int xhci_parse_frame_interval(struct usb_device *udev,
 		struct usb_host_endpoint *ep)
 {
 	return xhci_microframes_to_exponent(udev, ep,
 			ep->desc.bInterval * 8, 3, 10);
 }
 /* Return the polling or NAK interval.
  *
  * The polling interval is expressed in "microframes".  If xHCI's Interval field
  * is set to N, it will service the endpoint every 2^(Interval)*125us.
  *
  * The NAK interval is one NAK per 1 to 255 microframes, or no NAKs if interval
  * is set to 0.
  */
 static unsigned int xhci_get_endpoint_interval(struct usb_device *udev,
 		struct usb_host_endpoint *ep)
 {
 	unsigned int interval = 0;
 	switch (udev->speed) {
 	case USB_SPEED_HIGH:
 		/* Max NAK rate */
 		if (usb_endpoint_xfer_control(&ep->desc) ||
 		    usb_endpoint_xfer_bulk(&ep->desc)) {
 			interval = xhci_parse_microframe_interval(udev, ep);
 			break;
 		}
 		/* Fall through - SS and HS isoc/int have same decoding */
 	case USB_SPEED_SUPER:
 		if (usb_endpoint_xfer_int(&ep->desc) ||
 		    usb_endpoint_xfer_isoc(&ep->desc)) {
 			interval = xhci_parse_exponent_interval(udev, ep);
 		}
 		break;
 	case USB_SPEED_FULL:
 		if (usb_endpoint_xfer_isoc(&ep->desc)) {
 			interval = xhci_parse_exponent_interval(udev, ep);
 			break;
 		}
 		/*
 		 * Fall through for interrupt endpoint interval decoding
 		 * since it uses the same rules as low speed interrupt
 		 * endpoints.
 		 */
 	case USB_SPEED_LOW:
 		if (usb_endpoint_xfer_int(&ep->desc) ||
 		    usb_endpoint_xfer_isoc(&ep->desc)) {
 			interval = xhci_parse_frame_interval(udev, ep);
 		}
 		break;
 	default:
 		BUG();
 	}
 	return EP_INTERVAL(interval);
 }
 /* The "Mult" field in the endpoint context is only set for SuperSpeed isoc eps.
  * High speed endpoint descriptors can define "the number of additional
  * transaction opportunities per microframe", but that goes in the Max Burst
  * endpoint context field.
  */
 static u32 xhci_get_endpoint_mult(struct usb_device *udev,
 		struct usb_host_endpoint *ep)
 {
 	if (udev->speed != USB_SPEED_SUPER ||
 			!usb_endpoint_xfer_isoc(&ep->desc))
 		return 0;
 	return ep->ss_ep_comp.bmAttributes;
 }
 static u32 xhci_get_endpoint_type(struct usb_device *udev,
 		struct usb_host_endpoint *ep)
 {
 	int in;
 	u32 type;
 	in = usb_endpoint_dir_in(&ep->desc);
 	if (usb_endpoint_xfer_control(&ep->desc)) {
 		type = EP_TYPE(CTRL_EP);
 	} else if (usb_endpoint_xfer_bulk(&ep->desc)) {
 		if (in)
 			type = EP_TYPE(BULK_IN_EP);
 		else
 			type = EP_TYPE(BULK_OUT_EP);
 	} else if (usb_endpoint_xfer_isoc(&ep->desc)) {
 		if (in)
 			type = EP_TYPE(ISOC_IN_EP);
 		else
 			type = EP_TYPE(ISOC_OUT_EP);
 	} else if (usb_endpoint_xfer_int(&ep->desc)) {
 		if (in)
 			type = EP_TYPE(INT_IN_EP);
 		else
 			type = EP_TYPE(INT_OUT_EP);
 	} else {
 		type = 0;
 	}
 	return type;
 }
 /* Return the maximum endpoint service interval time (ESIT) payload.
  * Basically, this is the maxpacket size, multiplied by the burst size
  * and mult size.
  */
 static u32 xhci_get_max_esit_payload(struct xhci_hcd *xhci,
 		struct usb_device *udev,
 		struct usb_host_endpoint *ep)
 {
 	int max_burst;
 	int max_packet;
 	/* Only applies for interrupt or isochronous endpoints */
 	if (usb_endpoint_xfer_control(&ep->desc) ||
 			usb_endpoint_xfer_bulk(&ep->desc))
 		return 0;
 	if (udev->speed == USB_SPEED_SUPER)
 		return le16_to_cpu(ep->ss_ep_comp.wBytesPerInterval);
 	max_packet = GET_MAX_PACKET(usb_endpoint_maxp(&ep->desc));
 	max_burst = (usb_endpoint_maxp(&ep->desc) & 0x1800) >> 11;
 	/* A 0 in max burst means 1 transfer per ESIT */
 	return max_packet * (max_burst + 1);
 }
 /* Set up an endpoint with one ring segment.  Do not allocate stream rings.
  * Drivers will have to call usb_alloc_streams() to do that.
  */
 int xhci_endpoint_init(struct xhci_hcd *xhci,
 		struct xhci_virt_device *virt_dev,
 		struct usb_device *udev,
 		struct usb_host_endpoint *ep,
 		gfp_t mem_flags)
 {
 	unsigned int ep_index;
 	struct xhci_ep_ctx *ep_ctx;
 	struct xhci_ring *ep_ring;
 	unsigned int max_packet;
 	unsigned int max_burst;
 	enum xhci_ring_type type;
 	u32 max_esit_payload;
 	u32 endpoint_type;
 	ep_index = xhci_get_endpoint_index(&ep->desc);
 	ep_ctx = xhci_get_ep_ctx(xhci, virt_dev->in_ctx, ep_index);
 	endpoint_type = xhci_get_endpoint_type(udev, ep);
 	if (!endpoint_type)
 		return -EINVAL;
 	ep_ctx->ep_info2 = cpu_to_le32(endpoint_type);
 	type = usb_endpoint_type(&ep->desc);
 	/* Set up the endpoint ring */
 	virt_dev->eps[ep_index].new_ring =
 		xhci_ring_alloc(xhci, 2, 1, type, mem_flags);
 	if (!virt_dev->eps[ep_index].new_ring) {
 		/* Attempt to use the ring cache */
 		if (virt_dev->num_rings_cached == 0)
 			return -ENOMEM;
 		virt_dev->eps[ep_index].new_ring =
 			virt_dev->ring_cache[virt_dev->num_rings_cached];
 		virt_dev->ring_cache[virt_dev->num_rings_cached] = NULL;
 		virt_dev->num_rings_cached--;
 		xhci_reinit_cached_ring(xhci, virt_dev->eps[ep_index].new_ring,
 					1, type);
 	}
 	virt_dev->eps[ep_index].skip = false;
 	ep_ring = virt_dev->eps[ep_index].new_ring;
 	ep_ctx->deq = cpu_to_le64(ep_ring->first_seg->dma | ep_ring->cycle_state);
 	ep_ctx->ep_info = cpu_to_le32(xhci_get_endpoint_interval(udev, ep)
 				      | EP_MULT(xhci_get_endpoint_mult(udev, ep)));
 	/* FIXME dig Mult and streams info out of ep companion desc */
 	/* Allow 3 retries for everything but isoc;
 	 * CErr shall be set to 0 for Isoch endpoints.
 	 */
 	if (!usb_endpoint_xfer_isoc(&ep->desc))
 		ep_ctx->ep_info2 |= cpu_to_le32(ERROR_COUNT(3));
 	else
 		ep_ctx->ep_info2 |= cpu_to_le32(ERROR_COUNT(0));
 	/* Set the max packet size and max burst */
 	max_packet = GET_MAX_PACKET(usb_endpoint_maxp(&ep->desc));
 	max_burst = 0;
 	switch (udev->speed) {
 	case USB_SPEED_SUPER:
 		/* dig out max burst from ep companion desc */
 		max_burst = ep->ss_ep_comp.bMaxBurst;
 		break;
 	case USB_SPEED_HIGH:
 		/* Some devices get this wrong */
 		if (usb_endpoint_xfer_bulk(&ep->desc))
 			max_packet = 512;
 		/* bits 11:12 specify the number of additional transaction
 		 * opportunities per microframe (USB 2.0, section 9.6.6)
 		 */
 		if (usb_endpoint_xfer_isoc(&ep->desc) ||
 				usb_endpoint_xfer_int(&ep->desc)) {
 			max_burst = (usb_endpoint_maxp(&ep->desc)
 				     & 0x1800) >> 11;
 		}
 		break;
 	case USB_SPEED_FULL:
 	case USB_SPEED_LOW:
 		break;
 	default:
 		BUG();
 	}
 	ep_ctx->ep_info2 |= cpu_to_le32(MAX_PACKET(max_packet) |
 			MAX_BURST(max_burst));
 	max_esit_payload = xhci_get_max_esit_payload(xhci, udev, ep);
 	ep_ctx->tx_info = cpu_to_le32(MAX_ESIT_PAYLOAD_FOR_EP(max_esit_payload));
 	/*
 	 * XXX no idea how to calculate the average TRB buffer length for bulk
 	 * endpoints, as the driver gives us no clue how big each scatter gather
 	 * list entry (or buffer) is going to be.
 	 *
 	 * For isochronous and interrupt endpoints, we set it to the max
 	 * available, until we have new API in the USB core to allow drivers to
 	 * declare how much bandwidth they actually need.
 	 *
 	 * Normally, it would be calculated by taking the total of the buffer
 	 * lengths in the TD and then dividing by the number of TRBs in a TD,
 	 * including link TRBs, No-op TRBs, and Event data TRBs.  Since we don't
 	 * use Event Data TRBs, and we don't chain in a link TRB on short
 	 * transfers, we're basically dividing by 1.
 	 *
 	 * xHCI 1.0 specification indicates that the Average TRB Length should
 	 * be set to 8 for control endpoints.
 	 */
 	if (usb_endpoint_xfer_control(&ep->desc) && xhci->hci_version == 0x100)
 		ep_ctx->tx_info |= cpu_to_le32(AVG_TRB_LENGTH_FOR_EP(8));
 	else
 		ep_ctx->tx_info |=
 			 cpu_to_le32(AVG_TRB_LENGTH_FOR_EP(max_esit_payload));
 	/* FIXME Debug endpoint context */
 	return 0;
 }
 void xhci_endpoint_zero(struct xhci_hcd *xhci,
 		struct xhci_virt_device *virt_dev,
 		struct usb_host_endpoint *ep)
 {
 	unsigned int ep_index;
 	struct xhci_ep_ctx *ep_ctx;
 	ep_index = xhci_get_endpoint_index(&ep->desc);
 	ep_ctx = xhci_get_ep_ctx(xhci, virt_dev->in_ctx, ep_index);
 	ep_ctx->ep_info = 0;
 	ep_ctx->ep_info2 = 0;
 	ep_ctx->deq = 0;
 	ep_ctx->tx_info = 0;
 	/* Don't free the endpoint ring until the set interface or configuration
 	 * request succeeds.
 	 */
 }
 void xhci_clear_endpoint_bw_info(struct xhci_bw_info *bw_info)
 {
 	bw_info->ep_interval = 0;
 	bw_info->mult = 0;
 	bw_info->num_packets = 0;
 	bw_info->max_packet_size = 0;
 	bw_info->type = 0;
 	bw_info->max_esit_payload = 0;
 }
 void xhci_update_bw_info(struct xhci_hcd *xhci,
 		struct xhci_container_ctx *in_ctx,
 		struct xhci_input_control_ctx *ctrl_ctx,
 		struct xhci_virt_device *virt_dev)
 {
 	struct xhci_bw_info *bw_info;
 	struct xhci_ep_ctx *ep_ctx;
 	unsigned int ep_type;
 	int i;
 	for (i = 1; i < 31; ++i) {
 		bw_info = &virt_dev->eps[i].bw_info;
 		/* We can't tell what endpoint type is being dropped, but
 		 * unconditionally clearing the bandwidth info for non-periodic
 		 * endpoints should be harmless because the info will never be
 		 * set in the first place.
 		 */
 		if (!EP_IS_ADDED(ctrl_ctx, i) && EP_IS_DROPPED(ctrl_ctx, i)) {
 			/* Dropped endpoint */
 			xhci_clear_endpoint_bw_info(bw_info);
 			continue;
 		}
 		if (EP_IS_ADDED(ctrl_ctx, i)) {
 			ep_ctx = xhci_get_ep_ctx(xhci, in_ctx, i);
 			ep_type = CTX_TO_EP_TYPE(le32_to_cpu(ep_ctx->ep_info2));
 			/* Ignore non-periodic endpoints */
 			if (ep_type != ISOC_OUT_EP && ep_type != INT_OUT_EP &&
 					ep_type != ISOC_IN_EP &&
 					ep_type != INT_IN_EP)
 				continue;
 			/* Added or changed endpoint */
 			bw_info->ep_interval = CTX_TO_EP_INTERVAL(
 					le32_to_cpu(ep_ctx->ep_info));
 			/* Number of packets and mult are zero-based in the
 			 * input context, but we want one-based for the
 			 * interval table.
 			 */
 			bw_info->mult = CTX_TO_EP_MULT(
 					le32_to_cpu(ep_ctx->ep_info)) + 1;
 			bw_info->num_packets = CTX_TO_MAX_BURST(
 					le32_to_cpu(ep_ctx->ep_info2)) + 1;
 			bw_info->max_packet_size = MAX_PACKET_DECODED(
 					le32_to_cpu(ep_ctx->ep_info2));
 			bw_info->type = ep_type;
 			bw_info->max_esit_payload = CTX_TO_MAX_ESIT_PAYLOAD(
 					le32_to_cpu(ep_ctx->tx_info));
 		}
 	}
 }
 /* Copy output xhci_ep_ctx to the input xhci_ep_ctx copy.
  * Useful when you want to change one particular aspect of the endpoint and then
  * issue a configure endpoint command.
  */
 void xhci_endpoint_copy(struct xhci_hcd *xhci,
 		struct xhci_container_ctx *in_ctx,
 		struct xhci_container_ctx *out_ctx,
 		unsigned int ep_index)
 {
 	struct xhci_ep_ctx *out_ep_ctx;
 	struct xhci_ep_ctx *in_ep_ctx;
 	out_ep_ctx = xhci_get_ep_ctx(xhci, out_ctx, ep_index);
 	in_ep_ctx = xhci_get_ep_ctx(xhci, in_ctx, ep_index);
 	in_ep_ctx->ep_info = out_ep_ctx->ep_info;
 	in_ep_ctx->ep_info2 = out_ep_ctx->ep_info2;
 	in_ep_ctx->deq = out_ep_ctx->deq;
 	in_ep_ctx->tx_info = out_ep_ctx->tx_info;
 }
 /* Copy output xhci_slot_ctx to the input xhci_slot_ctx.
  * Useful when you want to change one particular aspect of the endpoint and then
  * issue a configure endpoint command.  Only the context entries field matters,
  * but we'll copy the whole thing anyway.
  */
 void xhci_slot_copy(struct xhci_hcd *xhci,
 		struct xhci_container_ctx *in_ctx,
 		struct xhci_container_ctx *out_ctx)
 {
 	struct xhci_slot_ctx *in_slot_ctx;
 	struct xhci_slot_ctx *out_slot_ctx;
 	in_slot_ctx = xhci_get_slot_ctx(xhci, in_ctx);
 	out_slot_ctx = xhci_get_slot_ctx(xhci, out_ctx);
 	in_slot_ctx->dev_info = out_slot_ctx->dev_info;
 	in_slot_ctx->dev_info2 = out_slot_ctx->dev_info2;
 	in_slot_ctx->tt_info = out_slot_ctx->tt_info;
 	in_slot_ctx->dev_state = out_slot_ctx->dev_state;
 }
 /* Set up the scratchpad buffer array and scratchpad buffers, if needed. */
 static int scratchpad_alloc(struct xhci_hcd *xhci, gfp_t flags)
 {
 	int i;
 	struct device *dev = xhci_to_hcd(xhci)->self.controller;
 	int num_sp = HCS_MAX_SCRATCHPAD(xhci->hcs_params2);
 	xhci_dbg_trace(xhci, trace_xhci_dbg_init,
 			"Allocating %d scratchpad buffers", num_sp);
 	if (!num_sp)
 		return 0;
 	xhci->scratchpad = kzalloc(sizeof(*xhci->scratchpad), flags);
 	if (!xhci->scratchpad)
 		goto fail_sp;
 	xhci->scratchpad->sp_array = dma_alloc_coherent(dev,
 				     num_sp * sizeof(u64),
 				     &xhci->scratchpad->sp_dma, flags);
 	if (!xhci->scratchpad->sp_array)
 		goto fail_sp2;
 	xhci->scratchpad->sp_buffers = kzalloc(sizeof(void *) * num_sp, flags);
 	if (!xhci->scratchpad->sp_buffers)
 		goto fail_sp3;
 	xhci->scratchpad->sp_dma_buffers =
 		kzalloc(sizeof(dma_addr_t) * num_sp, flags);
 	if (!xhci->scratchpad->sp_dma_buffers)
 		goto fail_sp4;
 	xhci->dcbaa->dev_context_ptrs[0] = cpu_to_le64(xhci->scratchpad->sp_dma);
 	for (i = 0; i < num_sp; i++) {
 		dma_addr_t dma;
 		void *buf = dma_alloc_coherent(dev, xhci->page_size, &dma,
 				flags);
 		if (!buf)
 			goto fail_sp5;
 		xhci->scratchpad->sp_array[i] = dma;
 		xhci->scratchpad->sp_buffers[i] = buf;
 		xhci->scratchpad->sp_dma_buffers[i] = dma;
 	}
 	return 0;
  fail_sp5:
 	for (i = i - 1; i >= 0; i--) {
 		dma_free_coherent(dev, xhci->page_size,
 				    xhci->scratchpad->sp_buffers[i],
 				    xhci->scratchpad->sp_dma_buffers[i]);
 	}
 	kfree(xhci->scratchpad->sp_dma_buffers);
  fail_sp4:
 	kfree(xhci->scratchpad->sp_buffers);
  fail_sp3:
 	dma_free_coherent(dev, num_sp * sizeof(u64),
 			    xhci->scratchpad->sp_array,
 			    xhci->scratchpad->sp_dma);
  fail_sp2:
 	kfree(xhci->scratchpad);
 	xhci->scratchpad = NULL;
  fail_sp:
 	return -ENOMEM;
 }
 static void scratchpad_free(struct xhci_hcd *xhci)
 {
 	int num_sp;
 	int i;
 	struct device *dev = xhci_to_hcd(xhci)->self.controller;
 	if (!xhci->scratchpad)
 		return;
 	num_sp = HCS_MAX_SCRATCHPAD(xhci->hcs_params2);
 	for (i = 0; i < num_sp; i++) {
 		dma_free_coherent(dev, xhci->page_size,
 				    xhci->scratchpad->sp_buffers[i],
 				    xhci->scratchpad->sp_dma_buffers[i]);
 	}
 	kfree(xhci->scratchpad->sp_dma_buffers);
 	kfree(xhci->scratchpad->sp_buffers);
 	dma_free_coherent(dev, num_sp * sizeof(u64),
 			    xhci->scratchpad->sp_array,
 			    xhci->scratchpad->sp_dma);
 	kfree(xhci->scratchpad);
 	xhci->scratchpad = NULL;
 }
 struct xhci_command *xhci_alloc_command(struct xhci_hcd *xhci,
 		bool allocate_in_ctx, bool allocate_completion,
 		gfp_t mem_flags)
 {
 	struct xhci_command *command;
 	command = kzalloc(sizeof(*command), mem_flags);
 	if (!command)
 		return NULL;
 	if (allocate_in_ctx) {
 		command->in_ctx =
 			xhci_alloc_container_ctx(xhci, XHCI_CTX_TYPE_INPUT,
 					mem_flags);
 		if (!command->in_ctx) {
 			kfree(command);
 			return NULL;
 		}
 	}
 	if (allocate_completion) {
 		command->completion =
 			kzalloc(sizeof(struct completion), mem_flags);
 		if (!command->completion) {
 			xhci_free_container_ctx(xhci, command->in_ctx);
 			kfree(command);
 			return NULL;
 		}
 		init_completion(command->completion);
 	}
 	command->status = 0;
 	INIT_LIST_HEAD(&command->cmd_list);
 	return command;
 }
 void xhci_urb_free_priv(struct xhci_hcd *xhci, struct urb_priv *urb_priv)
 {
 	if (urb_priv) {
 		kfree(urb_priv->td[0]);
 		kfree(urb_priv);
 	}
 }
 void xhci_free_command(struct xhci_hcd *xhci,
 		struct xhci_command *command)
 {
 	xhci_free_container_ctx(xhci,
 			command->in_ctx);
 	kfree(command->completion);
 	kfree(command);
 }
 void xhci_mem_cleanup(struct xhci_hcd *xhci)
 {
 	struct device	*dev = xhci_to_hcd(xhci)->self.controller;
 	struct xhci_cd  *cur_cd, *next_cd;
 	int size;
 	int i, j, num_ports;
 	/* Free the Event Ring Segment Table and the actual Event Ring */
 	size = sizeof(struct xhci_erst_entry)*(xhci->erst.num_entries);
 	if (xhci->erst.entries)
 		dma_free_coherent(dev, size,
 				xhci->erst.entries, xhci->erst.erst_dma_addr);
 	xhci->erst.entries = NULL;
 	xhci_dbg_trace(xhci, trace_xhci_dbg_init, "Freed ERST");
 	if (xhci->event_ring)
 		xhci_ring_free(xhci, xhci->event_ring);
 	xhci->event_ring = NULL;
 	xhci_dbg_trace(xhci, trace_xhci_dbg_init, "Freed event ring");
 	if (xhci->lpm_command)
 		xhci_free_command(xhci, xhci->lpm_command);
 	if (xhci->cmd_ring)
 		xhci_ring_free(xhci, xhci->cmd_ring);
 	xhci->cmd_ring = NULL;
 	xhci_dbg_trace(xhci, trace_xhci_dbg_init, "Freed command ring");
 	list_for_each_entry_safe(cur_cd, next_cd,
 			&xhci->cancel_cmd_list, cancel_cmd_list) {
 		list_del(&cur_cd->cancel_cmd_list);
 		kfree(cur_cd);
 	}
+	num_ports = HCS_MAX_PORTS(xhci->hcs_params1);
+	for (i = 0; i < num_ports; i++) {
+		struct xhci_interval_bw_table *bwt = &xhci->rh_bw[i].bw_table;
+		for (j = 0; j < XHCI_MAX_INTERVAL; j++) {
+			struct list_head *ep = &bwt->interval_bw[j].endpoints;
+			while (!list_empty(ep))
+				list_del_init(ep->next);
+		}
+	}
 	for (i = 1; i < MAX_HC_SLOTS; ++i)
 		xhci_free_virt_device(xhci, i);
 	if (xhci->segment_pool)
 		dma_pool_destroy(xhci->segment_pool);
 	xhci->segment_pool = NULL;
 	xhci_dbg_trace(xhci, trace_xhci_dbg_init, "Freed segment pool");
 	if (xhci->device_pool)
 		dma_pool_destroy(xhci->device_pool);
 	xhci->device_pool = NULL;
 	xhci_dbg_trace(xhci, trace_xhci_dbg_init, "Freed device context pool");
 	if (xhci->small_streams_pool)
 		dma_pool_destroy(xhci->small_streams_pool);
 	xhci->small_streams_pool = NULL;
 	xhci_dbg_trace(xhci, trace_xhci_dbg_init,
 			"Freed small stream array pool");
 	if (xhci->medium_streams_pool)
 		dma_pool_destroy(xhci->medium_streams_pool);
 	xhci->medium_streams_pool = NULL;
 	xhci_dbg_trace(xhci, trace_xhci_dbg_init,
 			"Freed medium stream array pool");
 	if (xhci->dcbaa)
 		dma_free_coherent(dev, sizeof(*xhci->dcbaa),
 				xhci->dcbaa, xhci->dcbaa->dma);
 	xhci->dcbaa = NULL;
 	scratchpad_free(xhci);
 	if (!xhci->rh_bw)
 		goto no_bw;
-	num_ports = HCS_MAX_PORTS(xhci->hcs_params1);
-	for (i = 0; i < num_ports; i++) {
-		struct xhci_interval_bw_table *bwt = &xhci->rh_bw[i].bw_table;
-		for (j = 0; j < XHCI_MAX_INTERVAL; j++) {
-			struct list_head *ep = &bwt->interval_bw[j].endpoints;
-			while (!list_empty(ep))
-				list_del_init(ep->next);
-		}
-	}
 	for (i = 0; i < num_ports; i++) {
 		struct xhci_tt_bw_info *tt, *n;
 		list_for_each_entry_safe(tt, n, &xhci->rh_bw[i].tts, tt_list) {
 			list_del(&tt->tt_list);
 			kfree(tt);
 		}
 	}
 no_bw:
 	xhci->cmd_ring_reserved_trbs = 0;
 	xhci->num_usb2_ports = 0;
 	xhci->num_usb3_ports = 0;
 	xhci->num_active_eps = 0;
 	kfree(xhci->usb2_ports);
 	kfree(xhci->usb3_ports);
 	kfree(xhci->port_array);
 	kfree(xhci->rh_bw);
 	kfree(xhci->ext_caps);
 	xhci->page_size = 0;
 	xhci->page_shift = 0;
 	xhci->bus_state[0].bus_suspended = 0;
 	xhci->bus_state[1].bus_suspended = 0;
 }
 static int xhci_test_trb_in_td(struct xhci_hcd *xhci,
 		struct xhci_segment *input_seg,
 		union xhci_trb *start_trb,
 		union xhci_trb *end_trb,
 		dma_addr_t input_dma,
 		struct xhci_segment *result_seg,
 		char *test_name, int test_number)
 {
 	unsigned long long start_dma;
 	unsigned long long end_dma;
 	struct xhci_segment *seg;
 	start_dma = xhci_trb_virt_to_dma(input_seg, start_trb);
 	end_dma = xhci_trb_virt_to_dma(input_seg, end_trb);
 	seg = trb_in_td(input_seg, start_trb, end_trb, input_dma);
 	if (seg != result_seg) {
 		xhci_warn(xhci, "WARN: %s TRB math test %d failed!\n",
 				test_name, test_number);
 		xhci_warn(xhci, "Tested TRB math w/ seg %p and "
 				"input DMA 0x%llx\n",
 				input_seg,
 				(unsigned long long) input_dma);
 		xhci_warn(xhci, "starting TRB %p (0x%llx DMA), "
 				"ending TRB %p (0x%llx DMA)\n",
 				start_trb, start_dma,
 				end_trb, end_dma);
 		xhci_warn(xhci, "Expected seg %p, got seg %p\n",
 				result_seg, seg);
 		return -1;
 	}
 	return 0;
 }
 /* TRB math checks for xhci_trb_in_td(), using the command and event rings. */
 static int xhci_check_trb_in_td_math(struct xhci_hcd *xhci, gfp_t mem_flags)
 {
 	struct {
 		dma_addr_t		input_dma;
 		struct xhci_segment	*result_seg;
 	} simple_test_vector [] = {
 		/* A zeroed DMA field should fail */
 		{ 0, NULL },
 		/* One TRB before the ring start should fail */
 		{ xhci->event_ring->first_seg->dma - 16, NULL },
 		/* One byte before the ring start should fail */
 		{ xhci->event_ring->first_seg->dma - 1, NULL },
 		/* Starting TRB should succeed */
 		{ xhci->event_ring->first_seg->dma, xhci->event_ring->first_seg },
 		/* Ending TRB should succeed */
 		{ xhci->event_ring->first_seg->dma + (TRBS_PER_SEGMENT - 1)*16,
 			xhci->event_ring->first_seg },
 		/* One byte after the ring end should fail */
 		{ xhci->event_ring->first_seg->dma + (TRBS_PER_SEGMENT - 1)*16 + 1, NULL },
 		/* One TRB after the ring end should fail */
 		{ xhci->event_ring->first_seg->dma + (TRBS_PER_SEGMENT)*16, NULL },
 		/* An address of all ones should fail */
 		{ (dma_addr_t) (~0), NULL },
 	};
 	struct {
 		struct xhci_segment	*input_seg;
 		union xhci_trb		*start_trb;
 		union xhci_trb		*end_trb;
 		dma_addr_t		input_dma;
 		struct xhci_segment	*result_seg;
 	} complex_test_vector [] = {
 		/* Test feeding a valid DMA address from a different ring */
 		{	.input_seg = xhci->event_ring->first_seg,
 			.start_trb = xhci->event_ring->first_seg->trbs,
 			.end_trb = &xhci->event_ring->first_seg->trbs[TRBS_PER_SEGMENT - 1],
 			.input_dma = xhci->cmd_ring->first_seg->dma,
 			.result_seg = NULL,
 		},
 		/* Test feeding a valid end TRB from a different ring */
 		{	.input_seg = xhci->event_ring->first_seg,
 			.start_trb = xhci->event_ring->first_seg->trbs,
 			.end_trb = &xhci->cmd_ring->first_seg->trbs[TRBS_PER_SEGMENT - 1],
 			.input_dma = xhci->cmd_ring->first_seg->dma,
 			.result_seg = NULL,
 		},
 		/* Test feeding a valid start and end TRB from a different ring */
 		{	.input_seg = xhci->event_ring->first_seg,
 			.start_trb = xhci->cmd_ring->first_seg->trbs,
 			.end_trb = &xhci->cmd_ring->first_seg->trbs[TRBS_PER_SEGMENT - 1],
 			.input_dma = xhci->cmd_ring->first_seg->dma,
 			.result_seg = NULL,
 		},
 		/* TRB in this ring, but after this TD */
 		{	.input_seg = xhci->event_ring->first_seg,
 			.start_trb = &xhci->event_ring->first_seg->trbs[0],
 			.end_trb = &xhci->event_ring->first_seg->trbs[3],
 			.input_dma = xhci->event_ring->first_seg->dma + 4*16,
 			.result_seg = NULL,
 		},
 		/* TRB in this ring, but before this TD */
 		{	.input_seg = xhci->event_ring->first_seg,
 			.start_trb = &xhci->event_ring->first_seg->trbs[3],
 			.end_trb = &xhci->event_ring->first_seg->trbs[6],
 			.input_dma = xhci->event_ring->first_seg->dma + 2*16,
 			.result_seg = NULL,
 		},
 		/* TRB in this ring, but after this wrapped TD */
 		{	.input_seg = xhci->event_ring->first_seg,
 			.start_trb = &xhci->event_ring->first_seg->trbs[TRBS_PER_SEGMENT - 3],
 			.end_trb = &xhci->event_ring->first_seg->trbs[1],
 			.input_dma = xhci->event_ring->first_seg->dma + 2*16,
 			.result_seg = NULL,
 		},
 		/* TRB in this ring, but before this wrapped TD */
 		{	.input_seg = xhci->event_ring->first_seg,
 			.start_trb = &xhci->event_ring->first_seg->trbs[TRBS_PER_SEGMENT - 3],
 			.end_trb = &xhci->event_ring->first_seg->trbs[1],
 			.input_dma = xhci->event_ring->first_seg->dma + (TRBS_PER_SEGMENT - 4)*16,
 			.result_seg = NULL,
 		},
 		/* TRB not in this ring, and we have a wrapped TD */
 		{	.input_seg = xhci->event_ring->first_seg,
 			.start_trb = &xhci->event_ring->first_seg->trbs[TRBS_PER_SEGMENT - 3],
 			.end_trb = &xhci->event_ring->first_seg->trbs[1],
 			.input_dma = xhci->cmd_ring->first_seg->dma + 2*16,
 			.result_seg = NULL,
 		},
 	};
 	unsigned int num_tests;
 	int i, ret;
 	num_tests = ARRAY_SIZE(simple_test_vector);
 	for (i = 0; i < num_tests; i++) {
 		ret = xhci_test_trb_in_td(xhci,
 				xhci->event_ring->first_seg,
 				xhci->event_ring->first_seg->trbs,
 				&xhci->event_ring->first_seg->trbs[TRBS_PER_SEGMENT - 1],
 				simple_test_vector[i].input_dma,
 				simple_test_vector[i].result_seg,
 				"Simple", i);
 		if (ret < 0)
 			return ret;
 	}
 	num_tests = ARRAY_SIZE(complex_test_vector);
 	for (i = 0; i < num_tests; i++) {
 		ret = xhci_test_trb_in_td(xhci,
 				complex_test_vector[i].input_seg,
 				complex_test_vector[i].start_trb,
 				complex_test_vector[i].end_trb,
 				complex_test_vector[i].input_dma,
 				complex_test_vector[i].result_seg,
 				"Complex", i);
 		if (ret < 0)
 			return ret;
 	}
 	xhci_dbg(xhci, "TRB math tests passed.\n");
 	return 0;
 }
 static void xhci_set_hc_event_deq(struct xhci_hcd *xhci)
 {
 	u64 temp;
 	dma_addr_t deq;
 	deq = xhci_trb_virt_to_dma(xhci->event_ring->deq_seg,
 			xhci->event_ring->dequeue);
 	if (deq == 0 && !in_interrupt())
 		xhci_warn(xhci, "WARN something wrong with SW event ring "
 				"dequeue ptr.\n");
 	/* Update HC event ring dequeue pointer */
 	temp = xhci_read_64(xhci, &xhci->ir_set->erst_dequeue);
 	temp &= ERST_PTR_MASK;
 	/* Don't clear the EHB bit (which is RW1C) because
 	 * there might be more events to service.
 	 */
 	temp &= ~ERST_EHB;
 	xhci_dbg_trace(xhci, trace_xhci_dbg_init,
 			"// Write event ring dequeue pointer, "
 			"preserving EHB bit");
 	xhci_write_64(xhci, ((u64) deq & (u64) ~ERST_PTR_MASK) | temp,
 			&xhci->ir_set->erst_dequeue);
 }
 static void xhci_add_in_port(struct xhci_hcd *xhci, unsigned int num_ports,
 		__le32 __iomem *addr, u8 major_revision, int max_caps)
 {
 	u32 temp, port_offset, port_count;
 	int i;
 	if (major_revision > 0x03) {
 		xhci_warn(xhci, "Ignoring unknown port speed, "
 				"Ext Cap %p, revision = 0x%x\n",
 				addr, major_revision);
 		/* Ignoring port protocol we can't understand. FIXME */
 		return;
 	}
 	/* Port offset and count in the third dword, see section 7.2 */
 	temp = readl(addr + 2);
 	port_offset = XHCI_EXT_PORT_OFF(temp);
 	port_count = XHCI_EXT_PORT_COUNT(temp);
 	xhci_dbg_trace(xhci, trace_xhci_dbg_init,
 			"Ext Cap %p, port offset = %u, "
 			"count = %u, revision = 0x%x",
 			addr, port_offset, port_count, major_revision);
 	/* Port count includes the current port offset */
 	if (port_offset == 0 || (port_offset + port_count - 1) > num_ports)
 		/* WTF? "Valid values are ‘1’ to MaxPorts" */
 		return;
 	/* cache usb2 port capabilities */
 	if (major_revision < 0x03 && xhci->num_ext_caps < max_caps)
 		xhci->ext_caps[xhci->num_ext_caps++] = temp;
 	/* Check the host's USB2 LPM capability */
 	if ((xhci->hci_version == 0x96) && (major_revision != 0x03) &&
 			(temp & XHCI_L1C)) {
 		xhci_dbg_trace(xhci, trace_xhci_dbg_init,
 				"xHCI 0.96: support USB2 software lpm");
 		xhci->sw_lpm_support = 1;
 	}
 	if ((xhci->hci_version >= 0x100) && (major_revision != 0x03)) {
 		xhci_dbg_trace(xhci, trace_xhci_dbg_init,
 				"xHCI 1.0: support USB2 software lpm");
 		xhci->sw_lpm_support = 1;
 		if (temp & XHCI_HLC) {
 			xhci_dbg_trace(xhci, trace_xhci_dbg_init,
 					"xHCI 1.0: support USB2 hardware lpm");
 			xhci->hw_lpm_support = 1;
 		}
 	}
 	port_offset--;
 	for (i = port_offset; i < (port_offset + port_count); i++) {
 		/* Duplicate entry.  Ignore the port if the revisions differ. */
 		if (xhci->port_array[i] != 0) {
 			xhci_warn(xhci, "Duplicate port entry, Ext Cap %p,"
 					" port %u\n", addr, i);
 			xhci_warn(xhci, "Port was marked as USB %u, "
 					"duplicated as USB %u\n",
 					xhci->port_array[i], major_revision);
 			/* Only adjust the roothub port counts if we haven't
 			 * found a similar duplicate.
 			 */
 			if (xhci->port_array[i] != major_revision &&
 				xhci->port_array[i] != DUPLICATE_ENTRY) {
 				if (xhci->port_array[i] == 0x03)
 					xhci->num_usb3_ports--;
 				else
 					xhci->num_usb2_ports--;
 				xhci->port_array[i] = DUPLICATE_ENTRY;
 			}
 			/* FIXME: Should we disable the port? */
 			continue;
 		}
 		xhci->port_array[i] = major_revision;
 		if (major_revision == 0x03)
 			xhci->num_usb3_ports++;
 		else
 			xhci->num_usb2_ports++;
 	}
 	/* FIXME: Should we disable ports not in the Extended Capabilities? */
 }
 /*
  * Scan the Extended Capabilities for the "Supported Protocol Capabilities" that
  * specify what speeds each port is supposed to be.  We can't count on the port
  * speed bits in the PORTSC register being correct until a device is connected,
  * but we need to set up the two fake roothubs with the correct number of USB
  * 3.0 and USB 2.0 ports at host controller initialization time.
  */
 static int xhci_setup_port_arrays(struct xhci_hcd *xhci, gfp_t flags)
 {
 	__le32 __iomem *addr, *tmp_addr;
 	u32 offset, tmp_offset;
 	unsigned int num_ports;
 	int i, j, port_index;
 	int cap_count = 0;
 	addr = &xhci->cap_regs->hcc_params;
 	offset = XHCI_HCC_EXT_CAPS(readl(addr));
 	if (offset == 0) {
 		xhci_err(xhci, "No Extended Capability registers, "
 				"unable to set up roothub.\n");
 		return -ENODEV;
 	}
 	num_ports = HCS_MAX_PORTS(xhci->hcs_params1);
 	xhci->port_array = kzalloc(sizeof(*xhci->port_array)*num_ports, flags);
 	if (!xhci->port_array)
 		return -ENOMEM;
 	xhci->rh_bw = kzalloc(sizeof(*xhci->rh_bw)*num_ports, flags);
 	if (!xhci->rh_bw)
 		return -ENOMEM;
 	for (i = 0; i < num_ports; i++) {
 		struct xhci_interval_bw_table *bw_table;
 		INIT_LIST_HEAD(&xhci->rh_bw[i].tts);
 		bw_table = &xhci->rh_bw[i].bw_table;
 		for (j = 0; j < XHCI_MAX_INTERVAL; j++)
 			INIT_LIST_HEAD(&bw_table->interval_bw[j].endpoints);
 	}
 	/*
 	 * For whatever reason, the first capability offset is from the
 	 * capability register base, not from the HCCPARAMS register.
 	 * See section 5.3.6 for offset calculation.
 	 */
 	addr = &xhci->cap_regs->hc_capbase + offset;
 	tmp_addr = addr;
 	tmp_offset = offset;
 	/* count extended protocol capability entries for later caching */
 	do {
 		u32 cap_id;
 		cap_id = readl(tmp_addr);
 		if (XHCI_EXT_CAPS_ID(cap_id) == XHCI_EXT_CAPS_PROTOCOL)
 			cap_count++;
 		tmp_offset = XHCI_EXT_CAPS_NEXT(cap_id);
 		tmp_addr += tmp_offset;
 	} while (tmp_offset);
 	xhci->ext_caps = kzalloc(sizeof(*xhci->ext_caps) * cap_count, flags);
 	if (!xhci->ext_caps)
 		return -ENOMEM;
 	while (1) {
 		u32 cap_id;
 		cap_id = readl(addr);
 		if (XHCI_EXT_CAPS_ID(cap_id) == XHCI_EXT_CAPS_PROTOCOL)
 			xhci_add_in_port(xhci, num_ports, addr,
 					(u8) XHCI_EXT_PORT_MAJOR(cap_id),
 					cap_count);
 		offset = XHCI_EXT_CAPS_NEXT(cap_id);
 		if (!offset || (xhci->num_usb2_ports + xhci->num_usb3_ports)
 				== num_ports)
 			break;
 		/*
 		 * Once you're into the Extended Capabilities, the offset is
 		 * always relative to the register holding the offset.
 		 */
 		addr += offset;
 	}
 	if (xhci->num_usb2_ports == 0 && xhci->num_usb3_ports == 0) {
 		xhci_warn(xhci, "No ports on the roothubs?\n");
 		return -ENODEV;
 	}
 	xhci_dbg_trace(xhci, trace_xhci_dbg_init,
 			"Found %u USB 2.0 ports and %u USB 3.0 ports.",
 			xhci->num_usb2_ports, xhci->num_usb3_ports);
 	/* Place limits on the number of roothub ports so that the hub
 	 * descriptors aren't longer than the USB core will allocate.
 	 */
 	if (xhci->num_usb3_ports > 15) {
 		xhci_dbg_trace(xhci, trace_xhci_dbg_init,
 				"Limiting USB 3.0 roothub ports to 15.");
 		xhci->num_usb3_ports = 15;
 	}
 	if (xhci->num_usb2_ports > USB_MAXCHILDREN) {
 		xhci_dbg_trace(xhci, trace_xhci_dbg_init,
 				"Limiting USB 2.0 roothub ports to %u.",
 				USB_MAXCHILDREN);
 		xhci->num_usb2_ports = USB_MAXCHILDREN;
 	}
 	/*
 	 * Note we could have all USB 3.0 ports, or all USB 2.0 ports.
 	 * Not sure how the USB core will handle a hub with no ports...
 	 */
 	if (xhci->num_usb2_ports) {
 		xhci->usb2_ports = kmalloc(sizeof(*xhci->usb2_ports)*
 				xhci->num_usb2_ports, flags);
 		if (!xhci->usb2_ports)
 			return -ENOMEM;
 		port_index = 0;
 		for (i = 0; i < num_ports; i++) {
 			if (xhci->port_array[i] == 0x03 ||
 					xhci->port_array[i] == 0 ||
 					xhci->port_array[i] == DUPLICATE_ENTRY)
 				continue;
 			xhci->usb2_ports[port_index] =
 				&xhci->op_regs->port_status_base +
 				NUM_PORT_REGS*i;
 			xhci_dbg_trace(xhci, trace_xhci_dbg_init,
 					"USB 2.0 port at index %u, "
 					"addr = %p", i,
 					xhci->usb2_ports[port_index]);
 			port_index++;
 			if (port_index == xhci->num_usb2_ports)
 				break;
 		}
 	}
 	if (xhci->num_usb3_ports) {
 		xhci->usb3_ports = kmalloc(sizeof(*xhci->usb3_ports)*
 				xhci->num_usb3_ports, flags);
 		if (!xhci->usb3_ports)
 			return -ENOMEM;
 		port_index = 0;
 		for (i = 0; i < num_ports; i++)
 			if (xhci->port_array[i] == 0x03) {
 				xhci->usb3_ports[port_index] =
 					&xhci->op_regs->port_status_base +
 					NUM_PORT_REGS*i;
 				xhci_dbg_trace(xhci, trace_xhci_dbg_init,
 						"USB 3.0 port at index %u, "
 						"addr = %p", i,
 						xhci->usb3_ports[port_index]);
 				port_index++;
 				if (port_index == xhci->num_usb3_ports)
 					break;
 			}
 	}
 	return 0;
 }
 int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
 {
 	dma_addr_t	dma;
 	struct device	*dev = xhci_to_hcd(xhci)->self.controller;
 	unsigned int	val, val2;
 	u64		val_64;
 	struct xhci_segment	*seg;
 	u32 page_size, temp;
 	int i;
 	INIT_LIST_HEAD(&xhci->cancel_cmd_list);
 	page_size = readl(&xhci->op_regs->page_size);
 	xhci_dbg_trace(xhci, trace_xhci_dbg_init,
 			"Supported page size register = 0x%x", page_size);
 	for (i = 0; i < 16; i++) {
 		if ((0x1 & page_size) != 0)
 			break;
 		page_size = page_size >> 1;
 	}
 	if (i < 16)
 		xhci_dbg_trace(xhci, trace_xhci_dbg_init,
 			"Supported page size of %iK", (1 << (i+12)) / 1024);
 	else
 		xhci_warn(xhci, "WARN: no supported page size\n");
 	/* Use 4K pages, since that's common and the minimum the HC supports */
 	xhci->page_shift = 12;
 	xhci->page_size = 1 << xhci->page_shift;
 	xhci_dbg_trace(xhci, trace_xhci_dbg_init,
 			"HCD page size set to %iK", xhci->page_size / 1024);
 	/*
 	 * Program the Number of Device Slots Enabled field in the CONFIG
 	 * register with the max value of slots the HC can handle.
 	 */
 	val = HCS_MAX_SLOTS(readl(&xhci->cap_regs->hcs_params1));
 	xhci_dbg_trace(xhci, trace_xhci_dbg_init,
 			"// xHC can handle at most %d device slots.", val);
 	val2 = readl(&xhci->op_regs->config_reg);
 	val |= (val2 & ~HCS_SLOTS_MASK);
 	xhci_dbg_trace(xhci, trace_xhci_dbg_init,
 			"// Setting Max device slots reg = 0x%x.", val);
 	writel(val, &xhci->op_regs->config_reg);
 	/*
 	 * Section 5.4.8 - doorbell array must be
 	 * "physically contiguous and 64-byte (cache line) aligned".
 	 */
 	xhci->dcbaa = dma_alloc_coherent(dev, sizeof(*xhci->dcbaa), &dma,
 			GFP_KERNEL);
 	if (!xhci->dcbaa)
 		goto fail;
 	memset(xhci->dcbaa, 0, sizeof *(xhci->dcbaa));
 	xhci->dcbaa->dma = dma;
 	xhci_dbg_trace(xhci, trace_xhci_dbg_init,
 			"// Device context base array address = 0x%llx (DMA), %p (virt)",
 			(unsigned long long)xhci->dcbaa->dma, xhci->dcbaa);
 	xhci_write_64(xhci, dma, &xhci->op_regs->dcbaa_ptr);
 	/*
 	 * Initialize the ring segment pool.  The ring must be a contiguous
 	 * structure comprised of TRBs.  The TRBs must be 16 byte aligned,
 	 * however, the command ring segment needs 64-byte aligned segments
 	 * and our use of dma addresses in the trb_address_map radix tree needs
 	 * TRB_SEGMENT_SIZE alignment, so we pick the greater alignment need.
 	 */
 	xhci->segment_pool = dma_pool_create("xHCI ring segments", dev,
 			TRB_SEGMENT_SIZE, TRB_SEGMENT_SIZE, xhci->page_size);
 	/* See Table 46 and Note on Figure 55 */
 	xhci->device_pool = dma_pool_create("xHCI input/output contexts", dev,
 			2112, 64, xhci->page_size);
 	if (!xhci->segment_pool || !xhci->device_pool)
 		goto fail;
 	/* Linear stream context arrays don't have any boundary restrictions,
 	 * and only need to be 16-byte aligned.
 	 */
 	xhci->small_streams_pool =
 		dma_pool_create("xHCI 256 byte stream ctx arrays",
 			dev, SMALL_STREAM_ARRAY_SIZE, 16, 0);
 	xhci->medium_streams_pool =
 		dma_pool_create("xHCI 1KB stream ctx arrays",
 			dev, MEDIUM_STREAM_ARRAY_SIZE, 16, 0);
 	/* Any stream context array bigger than MEDIUM_STREAM_ARRAY_SIZE
 	 * will be allocated with dma_alloc_coherent()
 	 */
 	if (!xhci->small_streams_pool || !xhci->medium_streams_pool)
 		goto fail;
 	/* Set up the command ring to have one segments for now. */
 	xhci->cmd_ring = xhci_ring_alloc(xhci, 1, 1, TYPE_COMMAND, flags);
 	if (!xhci->cmd_ring)
 		goto fail;
 	xhci_dbg_trace(xhci, trace_xhci_dbg_init,
 			"Allocated command ring at %p", xhci->cmd_ring);
 	xhci_dbg_trace(xhci, trace_xhci_dbg_init, "First segment DMA is 0x%llx",
 			(unsigned long long)xhci->cmd_ring->first_seg->dma);
 	/* Set the address in the Command Ring Control register */
 	val_64 = xhci_read_64(xhci, &xhci->op_regs->cmd_ring);
 	val_64 = (val_64 & (u64) CMD_RING_RSVD_BITS) |
 		(xhci->cmd_ring->first_seg->dma & (u64) ~CMD_RING_RSVD_BITS) |
 		xhci->cmd_ring->cycle_state;
 	xhci_dbg_trace(xhci, trace_xhci_dbg_init,
 			"// Setting command ring address to 0x%x", val);
 	xhci_write_64(xhci, val_64, &xhci->op_regs->cmd_ring);
 	xhci_dbg_cmd_ptrs(xhci);
 	xhci->lpm_command = xhci_alloc_command(xhci, true, true, flags);
 	if (!xhci->lpm_command)
 		goto fail;
 	/* Reserve one command ring TRB for disabling LPM.
 	 * Since the USB core grabs the shared usb_bus bandwidth mutex before
 	 * disabling LPM, we only need to reserve one TRB for all devices.
 	 */
 	xhci->cmd_ring_reserved_trbs++;
 	val = readl(&xhci->cap_regs->db_off);
 	val &= DBOFF_MASK;
 	xhci_dbg_trace(xhci, trace_xhci_dbg_init,
 			"// Doorbell array is located at offset 0x%x"
 			" from cap regs base addr", val);
 	xhci->dba = (void __iomem *) xhci->cap_regs + val;
 	xhci_dbg_regs(xhci);
 	xhci_print_run_regs(xhci);
 	/* Set ir_set to interrupt register set 0 */
 	xhci->ir_set = &xhci->run_regs->ir_set[0];
 	/*
 	 * Event ring setup: Allocate a normal ring, but also setup
 	 * the event ring segment table (ERST).  Section 4.9.3.
 	 */
 	xhci_dbg_trace(xhci, trace_xhci_dbg_init, "// Allocating event ring");
 	xhci->event_ring = xhci_ring_alloc(xhci, ERST_NUM_SEGS, 1, TYPE_EVENT,
 						flags);
 	if (!xhci->event_ring)
 		goto fail;
 	if (xhci_check_trb_in_td_math(xhci, flags) < 0)
 		goto fail;
 	xhci->erst.entries = dma_alloc_coherent(dev,
 			sizeof(struct xhci_erst_entry) * ERST_NUM_SEGS, &dma,
 			GFP_KERNEL);
 	if (!xhci->erst.entries)
 		goto fail;
 	xhci_dbg_trace(xhci, trace_xhci_dbg_init,
 			"// Allocated event ring segment table at 0x%llx",
 			(unsigned long long)dma);
 	memset(xhci->erst.entries, 0, sizeof(struct xhci_erst_entry)*ERST_NUM_SEGS);
 	xhci->erst.num_entries = ERST_NUM_SEGS;
 	xhci->erst.erst_dma_addr = dma;
 	xhci_dbg_trace(xhci, trace_xhci_dbg_init,
 			"Set ERST to 0; private num segs = %i, virt addr = %p, dma addr = 0x%llx",
 			xhci->erst.num_entries,
 			xhci->erst.entries,
 			(unsigned long long)xhci->erst.erst_dma_addr);
 	/* set ring base address and size for each segment table entry */
 	for (val = 0, seg = xhci->event_ring->first_seg; val < ERST_NUM_SEGS; val++) {
 		struct xhci_erst_entry *entry = &xhci->erst.entries[val];
 		entry->seg_addr = cpu_to_le64(seg->dma);
 		entry->seg_size = cpu_to_le32(TRBS_PER_SEGMENT);
 		entry->rsvd = 0;
 		seg = seg->next;
 	}
 	/* set ERST count with the number of entries in the segment table */
 	val = readl(&xhci->ir_set->erst_size);
 	val &= ERST_SIZE_MASK;
 	val |= ERST_NUM_SEGS;
 	xhci_dbg_trace(xhci, trace_xhci_dbg_init,
 			"// Write ERST size = %i to ir_set 0 (some bits preserved)",
 			val);
 	writel(val, &xhci->ir_set->erst_size);
 	xhci_dbg_trace(xhci, trace_xhci_dbg_init,
 			"// Set ERST entries to point to event ring.");
 	/* set the segment table base address */
 	xhci_dbg_trace(xhci, trace_xhci_dbg_init,
 			"// Set ERST base address for ir_set 0 = 0x%llx",
 			(unsigned long long)xhci->erst.erst_dma_addr);
 	val_64 = xhci_read_64(xhci, &xhci->ir_set->erst_base);
 	val_64 &= ERST_PTR_MASK;
 	val_64 |= (xhci->erst.erst_dma_addr & (u64) ~ERST_PTR_MASK);
 	xhci_write_64(xhci, val_64, &xhci->ir_set->erst_base);
 	/* Set the event ring dequeue address */
 	xhci_set_hc_event_deq(xhci);
 	xhci_dbg_trace(xhci, trace_xhci_dbg_init,
 			"Wrote ERST address to ir_set 0.");
 	xhci_print_ir_set(xhci, 0);
 	/*
 	 * XXX: Might need to set the Interrupter Moderation Register to
 	 * something other than the default (~1ms minimum between interrupts).
 	 * See section 5.5.1.2.
 	 */
 	init_completion(&xhci->addr_dev);
 	for (i = 0; i < MAX_HC_SLOTS; ++i)
 		xhci->devs[i] = NULL;
 	for (i = 0; i < USB_MAXCHILDREN; ++i) {
 		xhci->bus_state[0].resume_done[i] = 0;
 		xhci->bus_state[1].resume_done[i] = 0;
 		/* Only the USB 2.0 completions will ever be used. */
 		init_completion(&xhci->bus_state[1].rexit_done[i]);
 	}
 	if (scratchpad_alloc(xhci, flags))
 		goto fail;
 	if (xhci_setup_port_arrays(xhci, flags))
 		goto fail;
 	/* Enable USB 3.0 device notifications for function remote wake, which
 	 * is necessary for allowing USB 3.0 devices to do remote wakeup from
 	 * U3 (device suspend).
 	 */
 	temp = readl(&xhci->op_regs->dev_notification);
 	temp &= ~DEV_NOTE_MASK;
 	temp |= DEV_NOTE_FWAKE;
 	writel(temp, &xhci->op_regs->dev_notification);

drivers/usb/serial/ftdi_sio.c

Diff comments View file @ 8ee7a33

 /*
  * USB FTDI SIO driver
  *
  *	Copyright (C) 2009 - 2013
  *	    Johan Hovold (jhovold@gmail.com)
  *	Copyright (C) 1999 - 2001
  *	    Greg Kroah-Hartman (greg@kroah.com)
  *          Bill Ryder (bryder@sgi.com)
  *	Copyright (C) 2002
  *	    Kuba Ober (kuba@mareimbrium.org)
  *
  *	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.
  *
  * See Documentation/usb/usb-serial.txt for more information on using this
  * driver
  *
  * See http://ftdi-usb-sio.sourceforge.net for up to date testing info
  *	and extra documentation
  *
  * Change entries from 2004 and earlier can be found in versions of this
  * file in kernel versions prior to the 2.6.24 release.
  *
  */
 /* Bill Ryder - bryder@sgi.com - wrote the FTDI_SIO implementation */
 /* Thanx to FTDI for so kindly providing details of the protocol required */
 /*   to talk to the device */
 /* Thanx to gkh and the rest of the usb dev group for all code I have
    assimilated :-) */
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/slab.h>
 #include <linux/tty.h>
 #include <linux/tty_driver.h>
 #include <linux/tty_flip.h>
 #include <linux/module.h>
 #include <linux/spinlock.h>
 #include <linux/mutex.h>
 #include <linux/uaccess.h>
 #include <linux/usb.h>
 #include <linux/serial.h>
 #include <linux/usb/serial.h>
 #include "ftdi_sio.h"
 #include "ftdi_sio_ids.h"
 #define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>, Bill Ryder <bryder@sgi.com>, Kuba Ober <kuba@mareimbrium.org>, Andreas Mohr, Johan Hovold <jhovold@gmail.com>"
 #define DRIVER_DESC "USB FTDI Serial Converters Driver"
 struct ftdi_private {
 	enum ftdi_chip_type chip_type;
 				/* type of device, either SIO or FT8U232AM */
 	int baud_base;		/* baud base clock for divisor setting */
 	int custom_divisor;	/* custom_divisor kludge, this is for
 				   baud_base (different from what goes to the
 				   chip!) */
 	__u16 last_set_data_urb_value ;
 				/* the last data state set - needed for doing
 				 * a break
 				 */
 	int flags;		/* some ASYNC_xxxx flags are supported */
 	unsigned long last_dtr_rts;	/* saved modem control outputs */
 	char prev_status;        /* Used for TIOCMIWAIT */
 	char transmit_empty;	/* If transmitter is empty or not */
 	__u16 interface;	/* FT2232C, FT2232H or FT4232H port interface
 				   (0 for FT232/245) */
 	speed_t force_baud;	/* if non-zero, force the baud rate to
 				   this value */
 	int force_rtscts;	/* if non-zero, force RTS-CTS to always
 				   be enabled */
 	unsigned int latency;		/* latency setting in use */
 	unsigned short max_packet_size;
 	struct mutex cfg_lock; /* Avoid mess by parallel calls of config ioctl() and change_speed() */
 };
 /* struct ftdi_sio_quirk is used by devices requiring special attention. */
 struct ftdi_sio_quirk {
 	int (*probe)(struct usb_serial *);
 	/* Special settings for probed ports. */
 	void (*port_probe)(struct ftdi_private *);
 };
 static int   ftdi_jtag_probe(struct usb_serial *serial);
 static int   ftdi_mtxorb_hack_setup(struct usb_serial *serial);
 static int   ftdi_NDI_device_setup(struct usb_serial *serial);
 static int   ftdi_stmclite_probe(struct usb_serial *serial);
 static int   ftdi_8u2232c_probe(struct usb_serial *serial);
 static void  ftdi_USB_UIRT_setup(struct ftdi_private *priv);
 static void  ftdi_HE_TIRA1_setup(struct ftdi_private *priv);
 static struct ftdi_sio_quirk ftdi_jtag_quirk = {
 	.probe	= ftdi_jtag_probe,
 };
 static struct ftdi_sio_quirk ftdi_mtxorb_hack_quirk = {
 	.probe  = ftdi_mtxorb_hack_setup,
 };
 static struct ftdi_sio_quirk ftdi_NDI_device_quirk = {
 	.probe	= ftdi_NDI_device_setup,
 };
 static struct ftdi_sio_quirk ftdi_USB_UIRT_quirk = {
 	.port_probe = ftdi_USB_UIRT_setup,
 };
 static struct ftdi_sio_quirk ftdi_HE_TIRA1_quirk = {
 	.port_probe = ftdi_HE_TIRA1_setup,
 };
 static struct ftdi_sio_quirk ftdi_stmclite_quirk = {
 	.probe	= ftdi_stmclite_probe,
 };
 static struct ftdi_sio_quirk ftdi_8u2232c_quirk = {
 	.probe	= ftdi_8u2232c_probe,
 };
 /*
  * The 8U232AM has the same API as the sio except for:
  * - it can support MUCH higher baudrates; up to:
  *   o 921600 for RS232 and 2000000 for RS422/485 at 48MHz
  *   o 230400 at 12MHz
  *   so .. 8U232AM's baudrate setting codes are different
  * - it has a two byte status code.
  * - it returns characters every 16ms (the FTDI does it every 40ms)
  *
  * the bcdDevice value is used to differentiate FT232BM and FT245BM from
  * the earlier FT8U232AM and FT8U232BM.  For now, include all known VID/PID
  * combinations in both tables.
  * FIXME: perhaps bcdDevice can also identify 12MHz FT8U232AM devices,
  * but I don't know if those ever went into mass production. [Ian Abbott]
  */
 /*
  * Device ID not listed? Test it using
  * /sys/bus/usb-serial/drivers/ftdi_sio/new_id and send a patch or report.
  */
 static const struct usb_device_id id_table_combined[] = {
 	{ USB_DEVICE(FTDI_VID, FTDI_ZEITCONTROL_TAGTRACE_MIFARE_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_CTI_MINI_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_CTI_NANO_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_AMC232_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_CANUSB_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_CANDAPTER_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_NXTCAM_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_EV3CON_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_0_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_1_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_2_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_3_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_4_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_5_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_6_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_7_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_USINT_CAT_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_USINT_WKEY_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_USINT_RS232_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ACTZWAVE_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_IRTRANS_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_IPLUS_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_IPLUS2_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_DMX4ALL) },
 	{ USB_DEVICE(FTDI_VID, FTDI_SIO_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_8U232AM_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_8U232AM_ALT_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_232RL_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_8U2232C_PID) ,
 		.driver_info = (kernel_ulong_t)&ftdi_8u2232c_quirk },
 	{ USB_DEVICE(FTDI_VID, FTDI_4232H_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_232H_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_FTX_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_MICRO_CHAMELEON_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_RELAIS_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_OPENDCC_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_OPENDCC_SNIFFER_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_OPENDCC_THROTTLE_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_OPENDCC_GATEWAY_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_OPENDCC_GBM_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_OPENDCC_GBM_BOOST_PID) },
 	{ USB_DEVICE(NEWPORT_VID, NEWPORT_AGILIS_PID) },
 	{ USB_DEVICE(NEWPORT_VID, NEWPORT_CONEX_CC_PID) },
 	{ USB_DEVICE(NEWPORT_VID, NEWPORT_CONEX_AGP_PID) },
 	{ USB_DEVICE(INTERBIOMETRICS_VID, INTERBIOMETRICS_IOBOARD_PID) },
 	{ USB_DEVICE(INTERBIOMETRICS_VID, INTERBIOMETRICS_MINI_IOBOARD_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_SPROG_II) },
 	{ USB_DEVICE(FTDI_VID, FTDI_TAGSYS_LP101_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_TAGSYS_P200X_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_LENZ_LIUSB_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_XF_632_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_XF_634_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_XF_547_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_XF_633_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_XF_631_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_XF_635_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_XF_640_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_XF_642_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_DSS20_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_URBAN_0_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_URBAN_1_PID) },
 	{ USB_DEVICE(FTDI_NF_RIC_VID, FTDI_NF_RIC_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_VNHCPCUSB_D_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_MTXORB_0_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_MTXORB_1_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_MTXORB_2_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_MTXORB_3_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_MTXORB_4_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_MTXORB_5_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_MTXORB_6_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_R2000KU_TRUE_RNG) },
 	{ USB_DEVICE(FTDI_VID, FTDI_VARDAAN_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0100_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0101_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0102_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0103_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0104_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0105_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0106_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0107_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0108_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0109_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_010A_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_010B_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_010C_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_010D_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_010E_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_010F_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0110_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0111_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0112_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0113_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0114_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0115_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0116_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0117_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0118_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0119_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_011A_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_011B_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_011C_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_011D_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_011E_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_011F_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0120_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0121_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0122_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0123_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0124_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0125_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0126_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0127_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0128_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0129_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_012A_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_012B_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_012C_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_012D_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_012E_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_012F_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0130_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0131_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0132_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0133_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0134_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0135_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0136_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0137_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0138_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0139_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_013A_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_013B_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_013C_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_013D_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_013E_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_013F_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0140_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0141_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0142_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0143_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0144_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0145_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0146_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0147_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0148_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0149_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_014A_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_014B_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_014C_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_014D_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_014E_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_014F_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0150_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0151_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0152_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0153_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0154_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0155_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0156_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0157_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0158_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0159_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_015A_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_015B_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_015C_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_015D_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_015E_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_015F_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0160_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0161_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0162_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0163_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0164_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0165_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0166_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0167_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0168_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0169_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_016A_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_016B_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_016C_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_016D_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_016E_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_016F_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0170_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0171_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0172_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0173_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0174_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0175_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0176_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0177_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0178_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0179_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_017A_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_017B_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_017C_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_017D_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_017E_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_017F_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0180_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0181_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0182_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0183_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0184_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0185_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0186_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0187_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0188_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0189_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_018A_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_018B_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_018C_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_018D_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_018E_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_018F_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0190_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0191_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0192_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0193_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0194_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0195_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0196_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0197_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0198_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0199_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_019A_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_019B_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_019C_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_019D_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_019E_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_019F_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A0_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A1_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A2_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A3_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A4_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A5_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A6_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A7_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A8_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A9_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01AA_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01AB_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01AC_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01AD_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01AE_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01AF_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B0_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B1_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B2_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B3_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B4_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B5_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B6_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B7_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B8_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B9_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01BA_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01BB_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01BC_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01BD_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01BE_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01BF_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C0_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C1_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C2_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C3_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C4_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C5_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C6_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C7_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C8_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C9_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01CA_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01CB_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01CC_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01CD_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01CE_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01CF_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D0_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D1_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D2_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D3_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D4_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D5_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D6_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D7_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D8_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D9_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01DA_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01DB_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01DC_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01DD_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01DE_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01DF_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E0_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E1_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E2_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E3_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E4_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E5_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E6_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E7_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E8_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E9_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01EA_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01EB_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01EC_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01ED_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01EE_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01EF_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F0_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F1_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F2_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F3_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F4_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F5_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F6_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F7_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F8_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F9_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01FA_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01FB_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01FC_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01FD_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01FE_PID) },
 	{ USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01FF_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_PERLE_ULTRAPORT_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_PIEGROUP_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_TNC_X_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_USBX_707_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2101_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2102_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2103_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2104_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2106_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2201_1_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2201_2_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2202_1_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2202_2_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2203_1_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2203_2_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_1_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_2_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_3_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_4_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_1_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_2_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_3_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_4_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_1_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_2_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_3_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_4_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_1_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_2_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_3_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_4_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_5_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_6_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_7_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_8_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_1_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_2_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_3_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_4_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_5_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_6_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_7_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_8_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_1_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_2_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_3_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_4_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_5_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_6_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_7_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_8_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803R_1_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803R_2_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803R_3_PID) },
 	{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803R_4_PID) },
 	{ USB_DEVICE(IDTECH_VID, IDTECH_IDT1221U_PID) },
 	{ USB_DEVICE(OCT_VID, OCT_US101_PID) },
 	{ USB_DEVICE(OCT_VID, OCT_DK201_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_HE_TIRA1_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_HE_TIRA1_quirk },
 	{ USB_DEVICE(FTDI_VID, FTDI_USB_UIRT_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_USB_UIRT_quirk },
 	{ USB_DEVICE(FTDI_VID, PROTEGO_SPECIAL_1) },
 	{ USB_DEVICE(FTDI_VID, PROTEGO_R2X0) },
 	{ USB_DEVICE(FTDI_VID, PROTEGO_SPECIAL_3) },
 	{ USB_DEVICE(FTDI_VID, PROTEGO_SPECIAL_4) },
 	{ USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E808_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E809_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80A_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80B_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80C_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80D_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80E_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80F_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E888_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E889_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88A_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88B_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88C_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88D_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88E_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88F_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_UO100_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_UM100_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_UR100_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_ALC8500_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_PYRAMID_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_FHZ1000PC_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_IBS_US485_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_IBS_PICPRO_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_IBS_PCMCIA_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_IBS_PK1_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_IBS_RS232MON_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_IBS_APP70_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_IBS_PEDO_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_IBS_PROD_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_TAVIR_STK500_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_TIAO_UMPA_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
+	{ USB_DEVICE(FTDI_VID, FTDI_NT_ORIONLXM_PID),
+		.driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
 	/*
 	 * ELV devices:
 	 */
 	{ USB_DEVICE(FTDI_ELV_VID, FTDI_ELV_WS300_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_USR_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_MSM1_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_KL100_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_WS550_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_EC3000_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_WS888_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_TWS550_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_FEM_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_CLI7000_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_PPS7330_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_TFM100_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_UDF77_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_UIO88_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_UAD8_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_UDA7_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_USI2_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_T1100_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_PCD200_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_ULA200_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_CSI8_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_EM1000DL_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_PCK100_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_RFP500_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_FS20SIG_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_UTP8_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_WS300PC_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_WS444PC_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_FHZ1300PC_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_EM1010PC_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_WS500_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_HS485_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_UMS100_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_TFD128_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_FM3RX_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELV_WS777_PID) },
 	{ USB_DEVICE(FTDI_VID, LINX_SDMUSBQSS_PID) },
 	{ USB_DEVICE(FTDI_VID, LINX_MASTERDEVEL2_PID) },
 	{ USB_DEVICE(FTDI_VID, LINX_FUTURE_0_PID) },
 	{ USB_DEVICE(FTDI_VID, LINX_FUTURE_1_PID) },
 	{ USB_DEVICE(FTDI_VID, LINX_FUTURE_2_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_CCSICDU20_0_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_CCSICDU40_1_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_CCSMACHX_2_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_CCSLOAD_N_GO_3_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_CCSICDU64_4_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_CCSPRIME8_5_PID) },
 	{ USB_DEVICE(FTDI_VID, INSIDE_ACCESSO) },
 	{ USB_DEVICE(INTREPID_VID, INTREPID_VALUECAN_PID) },
 	{ USB_DEVICE(INTREPID_VID, INTREPID_NEOVI_PID) },
 	{ USB_DEVICE(FALCOM_VID, FALCOM_TWIST_PID) },
 	{ USB_DEVICE(FALCOM_VID, FALCOM_SAMBA_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_SUUNTO_SPORTS_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_OCEANIC_PID) },
 	{ USB_DEVICE(TTI_VID, TTI_QL355P_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_RM_CANVIEW_PID) },
 	{ USB_DEVICE(ACTON_VID, ACTON_SPECTRAPRO_PID) },
 	{ USB_DEVICE(CONTEC_VID, CONTEC_COM1USBH_PID) },
 	{ USB_DEVICE(MITSUBISHI_VID, MITSUBISHI_FXUSB_PID) },
 	{ USB_DEVICE(BANDB_VID, BANDB_USOTL4_PID) },
 	{ USB_DEVICE(BANDB_VID, BANDB_USTL4_PID) },
 	{ USB_DEVICE(BANDB_VID, BANDB_USO9ML2_PID) },
 	{ USB_DEVICE(BANDB_VID, BANDB_USOPTL4_PID) },
 	{ USB_DEVICE(BANDB_VID, BANDB_USPTL4_PID) },
 	{ USB_DEVICE(BANDB_VID, BANDB_USO9ML2DR_2_PID) },
 	{ USB_DEVICE(BANDB_VID, BANDB_USO9ML2DR_PID) },
 	{ USB_DEVICE(BANDB_VID, BANDB_USOPTL4DR2_PID) },
 	{ USB_DEVICE(BANDB_VID, BANDB_USOPTL4DR_PID) },
 	{ USB_DEVICE(BANDB_VID, BANDB_485USB9F_2W_PID) },
 	{ USB_DEVICE(BANDB_VID, BANDB_485USB9F_4W_PID) },
 	{ USB_DEVICE(BANDB_VID, BANDB_232USB9M_PID) },
 	{ USB_DEVICE(BANDB_VID, BANDB_485USBTB_2W_PID) },
 	{ USB_DEVICE(BANDB_VID, BANDB_485USBTB_4W_PID) },
 	{ USB_DEVICE(BANDB_VID, BANDB_TTL5USB9M_PID) },
 	{ USB_DEVICE(BANDB_VID, BANDB_TTL3USB9M_PID) },
 	{ USB_DEVICE(BANDB_VID, BANDB_ZZ_PROG1_USB_PID) },
 	{ USB_DEVICE(FTDI_VID, EVER_ECO_PRO_CDS) },
 	{ USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_1_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_2_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_3_PID) },
 	{ USB_DEVICE(FTDI_VID, XSENS_CONVERTER_0_PID) },
 	{ USB_DEVICE(FTDI_VID, XSENS_CONVERTER_1_PID) },
 	{ USB_DEVICE(FTDI_VID, XSENS_CONVERTER_2_PID) },
 	{ USB_DEVICE(FTDI_VID, XSENS_CONVERTER_3_PID) },
 	{ USB_DEVICE(FTDI_VID, XSENS_CONVERTER_4_PID) },
 	{ USB_DEVICE(FTDI_VID, XSENS_CONVERTER_5_PID) },
 	{ USB_DEVICE(FTDI_VID, XSENS_CONVERTER_6_PID) },
 	{ USB_DEVICE(FTDI_VID, XSENS_CONVERTER_7_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_OMNI1509) },
 	{ USB_DEVICE(MOBILITY_VID, MOBILITY_USB_SERIAL_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ACTIVE_ROBOTS_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_MHAM_KW_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_MHAM_YS_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_MHAM_Y6_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_MHAM_Y8_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_MHAM_IC_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_MHAM_DB9_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_MHAM_RS232_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_MHAM_Y9_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_TERATRONIK_VCP_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_TERATRONIK_D2XX_PID) },
 	{ USB_DEVICE(EVOLUTION_VID, EVOLUTION_ER1_PID) },
 	{ USB_DEVICE(EVOLUTION_VID, EVO_HYBRID_PID) },
 	{ USB_DEVICE(EVOLUTION_VID, EVO_RCM4_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ARTEMIS_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16C_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16HR_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16HRC_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16IC_PID) },
 	{ USB_DEVICE(KOBIL_VID, KOBIL_CONV_B1_PID) },
 	{ USB_DEVICE(KOBIL_VID, KOBIL_CONV_KAAN_PID) },
 	{ USB_DEVICE(POSIFLEX_VID, POSIFLEX_PP7000_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_TTUSB_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ECLO_COM_1WIRE_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_WESTREX_MODEL_777_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_WESTREX_MODEL_8900F_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_PCDJ_DAC2_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_RRCIRKITS_LOCOBUFFER_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ASK_RDR400_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_NZR_SEM_USB_PID) },
 	{ USB_DEVICE(ICOM_VID, ICOM_ID_1_PID) },
 	{ USB_DEVICE(ICOM_VID, ICOM_OPC_U_UC_PID) },
 	{ USB_DEVICE(ICOM_VID, ICOM_ID_RP2C1_PID) },
 	{ USB_DEVICE(ICOM_VID, ICOM_ID_RP2C2_PID) },
 	{ USB_DEVICE(ICOM_VID, ICOM_ID_RP2D_PID) },
 	{ USB_DEVICE(ICOM_VID, ICOM_ID_RP2VT_PID) },
 	{ USB_DEVICE(ICOM_VID, ICOM_ID_RP2VR_PID) },
 	{ USB_DEVICE(ICOM_VID, ICOM_ID_RP4KVT_PID) },
 	{ USB_DEVICE(ICOM_VID, ICOM_ID_RP4KVR_PID) },
 	{ USB_DEVICE(ICOM_VID, ICOM_ID_RP2KVT_PID) },
 	{ USB_DEVICE(ICOM_VID, ICOM_ID_RP2KVR_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ACG_HFDUAL_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_YEI_SERVOCENTER31_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_THORLABS_PID) },
 	{ USB_DEVICE(TESTO_VID, TESTO_USB_INTERFACE_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_GAMMA_SCOUT_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_TACTRIX_OPENPORT_13M_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_TACTRIX_OPENPORT_13S_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_TACTRIX_OPENPORT_13U_PID) },
 	{ USB_DEVICE(ELEKTOR_VID, ELEKTOR_FT323R_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_NDI_HUC_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_NDI_device_quirk },
 	{ USB_DEVICE(FTDI_VID, FTDI_NDI_SPECTRA_SCU_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_NDI_device_quirk },
 	{ USB_DEVICE(FTDI_VID, FTDI_NDI_FUTURE_2_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_NDI_device_quirk },
 	{ USB_DEVICE(FTDI_VID, FTDI_NDI_FUTURE_3_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_NDI_device_quirk },
 	{ USB_DEVICE(FTDI_VID, FTDI_NDI_AURORA_SCU_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_NDI_device_quirk },
 	{ USB_DEVICE(TELLDUS_VID, TELLDUS_TELLSTICK_PID) },
 	{ USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_S03_PID) },
 	{ USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_59_PID) },
 	{ USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_57A_PID) },
 	{ USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_57B_PID) },
 	{ USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_29A_PID) },
 	{ USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_29B_PID) },
 	{ USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_29F_PID) },
 	{ USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_62B_PID) },
 	{ USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_S01_PID) },
 	{ USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_63_PID) },
 	{ USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_29C_PID) },
 	{ USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_81B_PID) },
 	{ USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_82B_PID) },
 	{ USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_K5D_PID) },
 	{ USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_K4Y_PID) },
 	{ USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_K5G_PID) },
 	{ USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_S05_PID) },
 	{ USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_60_PID) },
 	{ USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_61_PID) },
 	{ USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_62_PID) },
 	{ USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_63B_PID) },
 	{ USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_64_PID) },
 	{ USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_65_PID) },
 	{ USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_92_PID) },
 	{ USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_92D_PID) },
 	{ USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_W5R_PID) },
 	{ USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_A5R_PID) },
 	{ USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_PW1_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_MAXSTREAM_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_PHI_FISCO_PID) },
 	{ USB_DEVICE(TML_VID, TML_USB_SERIAL_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_ELSTER_UNICOM_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_PROPOX_JTAGCABLEII_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_PROPOX_ISPCABLEIII_PID) },
 	{ USB_DEVICE(OLIMEX_VID, OLIMEX_ARM_USB_OCD_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
 	{ USB_DEVICE(OLIMEX_VID, OLIMEX_ARM_USB_OCD_H_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
 	{ USB_DEVICE(FIC_VID, FIC_NEO1973_DEBUG_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
 	{ USB_DEVICE(FTDI_VID, FTDI_OOCDLINK_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
 	{ USB_DEVICE(FTDI_VID, LMI_LM3S_DEVEL_BOARD_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
 	{ USB_DEVICE(FTDI_VID, LMI_LM3S_EVAL_BOARD_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
 	{ USB_DEVICE(FTDI_VID, LMI_LM3S_ICDI_BOARD_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
 	{ USB_DEVICE(FTDI_VID, FTDI_TURTELIZER_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
 	{ USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID_USB60F) },
 	{ USB_DEVICE(FTDI_VID, FTDI_REU_TINY_PID) },
 	/* Papouch devices based on FTDI chip */
 	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB485_PID) },
 	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_AP485_PID) },
 	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB422_PID) },
 	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB485_2_PID) },
 	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_AP485_2_PID) },
 	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB422_2_PID) },
 	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB485S_PID) },
 	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB485C_PID) },
 	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_LEC_PID) },
 	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB232_PID) },
 	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_TMU_PID) },
 	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_IRAMP_PID) },
 	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_DRAK5_PID) },
 	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO8x8_PID) },
 	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO4x4_PID) },
 	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO2x2_PID) },
 	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO10x1_PID) },
 	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO30x3_PID) },
 	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO60x3_PID) },
 	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO2x16_PID) },
 	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO3x32_PID) },
 	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_DRAK6_PID) },
 	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_UPSUSB_PID) },
 	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_MU_PID) },
 	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_SIMUKEY_PID) },
 	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_AD4USB_PID) },
 	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_GMUX_PID) },
 	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_GMSR_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_DOMINTELL_DGQG_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_DOMINTELL_DUSB_PID) },
 	{ USB_DEVICE(ALTI2_VID, ALTI2_N3_PID) },
 	{ USB_DEVICE(FTDI_VID, DIEBOLD_BCS_SE923_PID) },
 	{ USB_DEVICE(ATMEL_VID, STK541_PID) },
 	{ USB_DEVICE(DE_VID, STB_PID) },
 	{ USB_DEVICE(DE_VID, WHT_PID) },
 	{ USB_DEVICE(ADI_VID, ADI_GNICE_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
 	{ USB_DEVICE(ADI_VID, ADI_GNICEPLUS_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
 	{ USB_DEVICE_AND_INTERFACE_INFO(MICROCHIP_VID, MICROCHIP_USB_BOARD_PID,
 					USB_CLASS_VENDOR_SPEC,
 					USB_SUBCLASS_VENDOR_SPEC, 0x00) },
 	{ USB_DEVICE(JETI_VID, JETI_SPC1201_PID) },
 	{ USB_DEVICE(MARVELL_VID, MARVELL_SHEEVAPLUG_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
 	{ USB_DEVICE(LARSENBRUSGAARD_VID, LB_ALTITRACK_PID) },
 	{ USB_DEVICE(GN_OTOMETRICS_VID, AURICAL_USB_PID) },
 	{ USB_DEVICE(FTDI_VID, PI_C865_PID) },
 	{ USB_DEVICE(FTDI_VID, PI_C857_PID) },
 	{ USB_DEVICE(PI_VID, PI_C866_PID) },
 	{ USB_DEVICE(PI_VID, PI_C663_PID) },
 	{ USB_DEVICE(PI_VID, PI_C725_PID) },
 	{ USB_DEVICE(PI_VID, PI_E517_PID) },
 	{ USB_DEVICE(PI_VID, PI_C863_PID) },
 	{ USB_DEVICE(PI_VID, PI_E861_PID) },
 	{ USB_DEVICE(PI_VID, PI_C867_PID) },
 	{ USB_DEVICE(PI_VID, PI_E609_PID) },
 	{ USB_DEVICE(PI_VID, PI_E709_PID) },
 	{ USB_DEVICE(PI_VID, PI_100F_PID) },
 	{ USB_DEVICE(PI_VID, PI_1011_PID) },
 	{ USB_DEVICE(PI_VID, PI_1012_PID) },
 	{ USB_DEVICE(PI_VID, PI_1013_PID) },
 	{ USB_DEVICE(PI_VID, PI_1014_PID) },
 	{ USB_DEVICE(PI_VID, PI_1015_PID) },
 	{ USB_DEVICE(PI_VID, PI_1016_PID) },
 	{ USB_DEVICE(KONDO_VID, KONDO_USB_SERIAL_PID) },
 	{ USB_DEVICE(BAYER_VID, BAYER_CONTOUR_CABLE_PID) },
 	{ USB_DEVICE(FTDI_VID, MARVELL_OPENRD_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
 	{ USB_DEVICE(FTDI_VID, TI_XDS100V2_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
 	{ USB_DEVICE(FTDI_VID, HAMEG_HO820_PID) },
 	{ USB_DEVICE(FTDI_VID, HAMEG_HO720_PID) },
 	{ USB_DEVICE(FTDI_VID, HAMEG_HO730_PID) },
 	{ USB_DEVICE(FTDI_VID, HAMEG_HO870_PID) },
 	{ USB_DEVICE(FTDI_VID, MJSG_GENERIC_PID) },
 	{ USB_DEVICE(FTDI_VID, MJSG_SR_RADIO_PID) },
 	{ USB_DEVICE(FTDI_VID, MJSG_HD_RADIO_PID) },
 	{ USB_DEVICE(FTDI_VID, MJSG_XM_RADIO_PID) },
 	{ USB_DEVICE(FTDI_VID, XVERVE_SIGNALYZER_ST_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
 	{ USB_DEVICE(FTDI_VID, XVERVE_SIGNALYZER_SLITE_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
 	{ USB_DEVICE(FTDI_VID, XVERVE_SIGNALYZER_SH2_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
 	{ USB_DEVICE(FTDI_VID, XVERVE_SIGNALYZER_SH4_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
 	{ USB_DEVICE(FTDI_VID, SEGWAY_RMP200_PID) },
 	{ USB_DEVICE(FTDI_VID, ACCESIO_COM4SM_PID) },
 	{ USB_DEVICE(IONICS_VID, IONICS_PLUGCOMPUTER_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
 	{ USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_24_MASTER_WING_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_PC_WING_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_USB_DMX_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_MIDI_TIMECODE_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_MINI_WING_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_MAXI_WING_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_MEDIA_WING_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_WING_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_SCIENCESCOPE_LOGBOOKML_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_SCIENCESCOPE_LS_LOGBOOK_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_SCIENCESCOPE_HS_LOGBOOK_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_CINTERION_MC55I_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_DOTEC_PID) },
 	{ USB_DEVICE(QIHARDWARE_VID, MILKYMISTONE_JTAGSERIAL_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
 	{ USB_DEVICE(ST_VID, ST_STMCLT_2232_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
 	{ USB_DEVICE(ST_VID, ST_STMCLT_4232_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_stmclite_quirk },
 	{ USB_DEVICE(FTDI_VID, FTDI_RF_R106) },
 	{ USB_DEVICE(FTDI_VID, FTDI_DISTORTEC_JTAG_LOCK_PICK_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
 	{ USB_DEVICE(FTDI_VID, FTDI_LUMEL_PD12_PID) },
 	/* Crucible Devices */
 	{ USB_DEVICE(FTDI_VID, FTDI_CT_COMET_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_Z3X_PID) },
 	/* Cressi Devices */
 	{ USB_DEVICE(FTDI_VID, FTDI_CRESSI_PID) },
 	/* Brainboxes Devices */
 	{ USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_VX_001_PID) },
 	{ USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_VX_012_PID) },
 	{ USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_VX_023_PID) },
 	{ USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_VX_034_PID) },
 	{ USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_101_PID) },
 	{ USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_160_1_PID) },
 	{ USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_160_2_PID) },
 	{ USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_160_3_PID) },
 	{ USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_160_4_PID) },
 	{ USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_160_5_PID) },
 	{ USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_160_6_PID) },
 	{ USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_160_7_PID) },
 	{ USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_160_8_PID) },
 	{ USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_257_PID) },
 	{ USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_279_1_PID) },
 	{ USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_279_2_PID) },
 	{ USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_279_3_PID) },
 	{ USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_279_4_PID) },
 	{ USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_313_PID) },
 	{ USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_324_PID) },
 	{ USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_346_1_PID) },
 	{ USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_346_2_PID) },
 	{ USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_357_PID) },
 	{ USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_606_1_PID) },
 	{ USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_606_2_PID) },
 	{ USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_606_3_PID) },
 	{ USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_701_1_PID) },
 	{ USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_701_2_PID) },
 	{ USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_842_1_PID) },
 	{ USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_842_2_PID) },
 	{ USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_842_3_PID) },
 	{ USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_842_4_PID) },
 	{ }					/* Terminating entry */
 };
 MODULE_DEVICE_TABLE(usb, id_table_combined);
 static const char *ftdi_chip_name[] = {
 	[SIO] = "SIO",	/* the serial part of FT8U100AX */
 	[FT8U232AM] = "FT8U232AM",
 	[FT232BM] = "FT232BM",
 	[FT2232C] = "FT2232C",
 	[FT232RL] = "FT232RL",
 	[FT2232H] = "FT2232H",
 	[FT4232H] = "FT4232H",
 	[FT232H]  = "FT232H",
 	[FTX]     = "FT-X"
 };
 /* Used for TIOCMIWAIT */
 #define FTDI_STATUS_B0_MASK	(FTDI_RS0_CTS | FTDI_RS0_DSR | FTDI_RS0_RI | FTDI_RS0_RLSD)
 #define FTDI_STATUS_B1_MASK	(FTDI_RS_BI)
 /* End TIOCMIWAIT */
 /* function prototypes for a FTDI serial converter */
 static int  ftdi_sio_probe(struct usb_serial *serial,
 					const struct usb_device_id *id);
 static int  ftdi_sio_port_probe(struct usb_serial_port *port);
 static int  ftdi_sio_port_remove(struct usb_serial_port *port);
 static int  ftdi_open(struct tty_struct *tty, struct usb_serial_port *port);
 static void ftdi_dtr_rts(struct usb_serial_port *port, int on);
 static void ftdi_process_read_urb(struct urb *urb);
 static int ftdi_prepare_write_buffer(struct usb_serial_port *port,
 						void *dest, size_t size);
 static void ftdi_set_termios(struct tty_struct *tty,
 			struct usb_serial_port *port, struct ktermios *old);
 static int  ftdi_tiocmget(struct tty_struct *tty);
 static int  ftdi_tiocmset(struct tty_struct *tty,
 			unsigned int set, unsigned int clear);
 static int  ftdi_ioctl(struct tty_struct *tty,
 			unsigned int cmd, unsigned long arg);
 static void ftdi_break_ctl(struct tty_struct *tty, int break_state);
 static bool ftdi_tx_empty(struct usb_serial_port *port);
 static int ftdi_get_modem_status(struct usb_serial_port *port,
 						unsigned char status[2]);
 static unsigned short int ftdi_232am_baud_base_to_divisor(int baud, int base);
 static unsigned short int ftdi_232am_baud_to_divisor(int baud);
 static __u32 ftdi_232bm_baud_base_to_divisor(int baud, int base);
 static __u32 ftdi_232bm_baud_to_divisor(int baud);
 static __u32 ftdi_2232h_baud_base_to_divisor(int baud, int base);
 static __u32 ftdi_2232h_baud_to_divisor(int baud);
 static struct usb_serial_driver ftdi_sio_device = {
 	.driver = {
 		.owner =	THIS_MODULE,
 		.name =		"ftdi_sio",
 	},
 	.description =		"FTDI USB Serial Device",
 	.id_table =		id_table_combined,
 	.num_ports =		1,
 	.bulk_in_size =		512,
 	.bulk_out_size =	256,
 	.probe =		ftdi_sio_probe,
 	.port_probe =		ftdi_sio_port_probe,
 	.port_remove =		ftdi_sio_port_remove,
 	.open =			ftdi_open,
 	.dtr_rts =		ftdi_dtr_rts,
 	.throttle =		usb_serial_generic_throttle,
 	.unthrottle =		usb_serial_generic_unthrottle,
 	.process_read_urb =	ftdi_process_read_urb,
 	.prepare_write_buffer =	ftdi_prepare_write_buffer,
 	.tiocmget =		ftdi_tiocmget,
 	.tiocmset =		ftdi_tiocmset,
 	.tiocmiwait =		usb_serial_generic_tiocmiwait,
 	.get_icount =           usb_serial_generic_get_icount,
 	.ioctl =		ftdi_ioctl,
 	.set_termios =		ftdi_set_termios,
 	.break_ctl =		ftdi_break_ctl,
 	.tx_empty =		ftdi_tx_empty,
 };
 static struct usb_serial_driver * const serial_drivers[] = {
 	&ftdi_sio_device, NULL
 };
 #define WDR_TIMEOUT 5000 /* default urb timeout */
 #define WDR_SHORT_TIMEOUT 1000	/* shorter urb timeout */
 /*
  * ***************************************************************************
  * Utility functions
  * ***************************************************************************
  */
 static unsigned short int ftdi_232am_baud_base_to_divisor(int baud, int base)
 {
 	unsigned short int divisor;
 	/* divisor shifted 3 bits to the left */
 	int divisor3 = base / 2 / baud;
 	if ((divisor3 & 0x7) == 7)
 		divisor3++; /* round x.7/8 up to x+1 */
 	divisor = divisor3 >> 3;
 	divisor3 &= 0x7;
 	if (divisor3 == 1)
 		divisor |= 0xc000;
 	else if (divisor3 >= 4)
 		divisor |= 0x4000;
 	else if (divisor3 != 0)
 		divisor |= 0x8000;
 	else if (divisor == 1)
 		divisor = 0;	/* special case for maximum baud rate */
 	return divisor;
 }
 static unsigned short int ftdi_232am_baud_to_divisor(int baud)
 {
 	 return ftdi_232am_baud_base_to_divisor(baud, 48000000);
 }
 static __u32 ftdi_232bm_baud_base_to_divisor(int baud, int base)
 {
 	static const unsigned char divfrac[8] = { 0, 3, 2, 4, 1, 5, 6, 7 };
 	__u32 divisor;
 	/* divisor shifted 3 bits to the left */
 	int divisor3 = base / 2 / baud;
 	divisor = divisor3 >> 3;
 	divisor |= (__u32)divfrac[divisor3 & 0x7] << 14;
 	/* Deal with special cases for highest baud rates. */
 	if (divisor == 1)
 		divisor = 0;
 	else if (divisor == 0x4001)
 		divisor = 1;
 	return divisor;
 }
 static __u32 ftdi_232bm_baud_to_divisor(int baud)
 {
 	 return ftdi_232bm_baud_base_to_divisor(baud, 48000000);
 }
 static __u32 ftdi_2232h_baud_base_to_divisor(int baud, int base)
 {
 	static const unsigned char divfrac[8] = { 0, 3, 2, 4, 1, 5, 6, 7 };
 	__u32 divisor;
 	int divisor3;
 	/* hi-speed baud rate is 10-bit sampling instead of 16-bit */
 	divisor3 = base * 8 / (baud * 10);
 	divisor = divisor3 >> 3;
 	divisor |= (__u32)divfrac[divisor3 & 0x7] << 14;
 	/* Deal with special cases for highest baud rates. */
 	if (divisor == 1)
 		divisor = 0;
 	else if (divisor == 0x4001)
 		divisor = 1;
 	/*
 	 * Set this bit to turn off a divide by 2.5 on baud rate generator
 	 * This enables baud rates up to 12Mbaud but cannot reach below 1200
 	 * baud with this bit set
 	 */
 	divisor |= 0x00020000;
 	return divisor;
 }
 static __u32 ftdi_2232h_baud_to_divisor(int baud)
 {
 	 return ftdi_2232h_baud_base_to_divisor(baud, 120000000);
 }
 #define set_mctrl(port, set)		update_mctrl((port), (set), 0)
 #define clear_mctrl(port, clear)	update_mctrl((port), 0, (clear))
 static int update_mctrl(struct usb_serial_port *port, unsigned int set,
 							unsigned int clear)
 {
 	struct ftdi_private *priv = usb_get_serial_port_data(port);
 	struct device *dev = &port->dev;
 	unsigned urb_value;
 	int rv;
 	if (((set | clear) & (TIOCM_DTR | TIOCM_RTS)) == 0) {
 		dev_dbg(dev, "%s - DTR|RTS not being set|cleared\n", __func__);
 		return 0;	/* no change */
 	}
 	clear &= ~set;	/* 'set' takes precedence over 'clear' */
 	urb_value = 0;
 	if (clear & TIOCM_DTR)
 		urb_value |= FTDI_SIO_SET_DTR_LOW;
 	if (clear & TIOCM_RTS)
 		urb_value |= FTDI_SIO_SET_RTS_LOW;
 	if (set & TIOCM_DTR)
 		urb_value |= FTDI_SIO_SET_DTR_HIGH;
 	if (set & TIOCM_RTS)
 		urb_value |= FTDI_SIO_SET_RTS_HIGH;
 	rv = usb_control_msg(port->serial->dev,
 			       usb_sndctrlpipe(port->serial->dev, 0),
 			       FTDI_SIO_SET_MODEM_CTRL_REQUEST,
 			       FTDI_SIO_SET_MODEM_CTRL_REQUEST_TYPE,
 			       urb_value, priv->interface,
 			       NULL, 0, WDR_TIMEOUT);
 	if (rv < 0) {
 		dev_dbg(dev, "%s Error from MODEM_CTRL urb: DTR %s, RTS %s\n",
 			__func__,
 			(set & TIOCM_DTR) ? "HIGH" : (clear & TIOCM_DTR) ? "LOW" : "unchanged",
 			(set & TIOCM_RTS) ? "HIGH" : (clear & TIOCM_RTS) ? "LOW" : "unchanged");
 		rv = usb_translate_errors(rv);
 	} else {
 		dev_dbg(dev, "%s - DTR %s, RTS %s\n", __func__,
 			(set & TIOCM_DTR) ? "HIGH" : (clear & TIOCM_DTR) ? "LOW" : "unchanged",
 			(set & TIOCM_RTS) ? "HIGH" : (clear & TIOCM_RTS) ? "LOW" : "unchanged");
 		/* FIXME: locking on last_dtr_rts */
 		priv->last_dtr_rts = (priv->last_dtr_rts & ~clear) | set;
 	}
 	return rv;
 }
 static __u32 get_ftdi_divisor(struct tty_struct *tty,
 						struct usb_serial_port *port)
 {
 	struct ftdi_private *priv = usb_get_serial_port_data(port);
 	struct device *dev = &port->dev;
 	__u32 div_value = 0;
 	int div_okay = 1;
 	int baud;
 	/*
 	 * The logic involved in setting the baudrate can be cleanly split into
 	 * 3 steps.
 	 * 1. Standard baud rates are set in tty->termios->c_cflag
 	 * 2. If these are not enough, you can set any speed using alt_speed as
 	 * follows:
 	 *    - set tty->termios->c_cflag speed to B38400
 	 *    - set your real speed in tty->alt_speed; it gets ignored when
 	 *      alt_speed==0, (or)
 	 *    - call TIOCSSERIAL ioctl with (struct serial_struct) set as
 	 *	follows:
 	 *      flags & ASYNC_SPD_MASK == ASYNC_SPD_[HI, VHI, SHI, WARP],
 	 *	this just sets alt_speed to (HI: 57600, VHI: 115200,
 	 *	SHI: 230400, WARP: 460800)
 	 * ** Steps 1, 2 are done courtesy of tty_get_baud_rate
 	 * 3. You can also set baud rate by setting custom divisor as follows
 	 *    - set tty->termios->c_cflag speed to B38400
 	 *    - call TIOCSSERIAL ioctl with (struct serial_struct) set as
 	 *	follows:
 	 *      o flags & ASYNC_SPD_MASK == ASYNC_SPD_CUST
 	 *      o custom_divisor set to baud_base / your_new_baudrate
 	 * ** Step 3 is done courtesy of code borrowed from serial.c
 	 *    I should really spend some time and separate + move this common
 	 *    code to serial.c, it is replicated in nearly every serial driver
 	 *    you see.
 	 */
 	/* 1. Get the baud rate from the tty settings, this observes
 	      alt_speed hack */
 	baud = tty_get_baud_rate(tty);
 	dev_dbg(dev, "%s - tty_get_baud_rate reports speed %d\n", __func__, baud);
 	/* 2. Observe async-compatible custom_divisor hack, update baudrate
 	   if needed */
 	if (baud == 38400 &&
 	    ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST) &&
 	     (priv->custom_divisor)) {
 		baud = priv->baud_base / priv->custom_divisor;
 		dev_dbg(dev, "%s - custom divisor %d sets baud rate to %d\n",
 			__func__, priv->custom_divisor, baud);
 	}
 	/* 3. Convert baudrate to device-specific divisor */
 	if (!baud)
 		baud = 9600;
 	switch (priv->chip_type) {
 	case SIO: /* SIO chip */
 		switch (baud) {
 		case 300: div_value = ftdi_sio_b300; break;
 		case 600: div_value = ftdi_sio_b600; break;
 		case 1200: div_value = ftdi_sio_b1200; break;
 		case 2400: div_value = ftdi_sio_b2400; break;
 		case 4800: div_value = ftdi_sio_b4800; break;
 		case 9600: div_value = ftdi_sio_b9600; break;
 		case 19200: div_value = ftdi_sio_b19200; break;
 		case 38400: div_value = ftdi_sio_b38400; break;
 		case 57600: div_value = ftdi_sio_b57600;  break;
 		case 115200: div_value = ftdi_sio_b115200; break;
 		} /* baud */
 		if (div_value == 0) {
 			dev_dbg(dev, "%s - Baudrate (%d) requested is not supported\n",
 				__func__,  baud);
 			div_value = ftdi_sio_b9600;
 			baud = 9600;
 			div_okay = 0;
 		}
 		break;
 	case FT8U232AM: /* 8U232AM chip */
 		if (baud <= 3000000) {
 			div_value = ftdi_232am_baud_to_divisor(baud);
 		} else {
 			dev_dbg(dev, "%s - Baud rate too high!\n", __func__);
 			baud = 9600;
 			div_value = ftdi_232am_baud_to_divisor(9600);
 			div_okay = 0;
 		}
 		break;
 	case FT232BM: /* FT232BM chip */
 	case FT2232C: /* FT2232C chip */
 	case FT232RL: /* FT232RL chip */
 	case FTX:     /* FT-X series */
 		if (baud <= 3000000) {
 			__u16 product_id = le16_to_cpu(
 				port->serial->dev->descriptor.idProduct);
 			if (((FTDI_NDI_HUC_PID == product_id) ||
 			     (FTDI_NDI_SPECTRA_SCU_PID == product_id) ||
 			     (FTDI_NDI_FUTURE_2_PID == product_id) ||
 			     (FTDI_NDI_FUTURE_3_PID == product_id) ||
 			     (FTDI_NDI_AURORA_SCU_PID == product_id)) &&
 			    (baud == 19200)) {
 				baud = 1200000;
 			}
 			div_value = ftdi_232bm_baud_to_divisor(baud);
 		} else {
 			dev_dbg(dev, "%s - Baud rate too high!\n", __func__);
 			div_value = ftdi_232bm_baud_to_divisor(9600);
 			div_okay = 0;
 			baud = 9600;
 		}
 		break;
 	case FT2232H: /* FT2232H chip */
 	case FT4232H: /* FT4232H chip */
 	case FT232H:  /* FT232H chip */
 		if ((baud <= 12000000) && (baud >= 1200)) {
 			div_value = ftdi_2232h_baud_to_divisor(baud);
 		} else if (baud < 1200) {
 			div_value = ftdi_232bm_baud_to_divisor(baud);
 		} else {
 			dev_dbg(dev, "%s - Baud rate too high!\n", __func__);
 			div_value = ftdi_232bm_baud_to_divisor(9600);
 			div_okay = 0;
 			baud = 9600;
 		}
 		break;
 	} /* priv->chip_type */
 	if (div_okay) {
 		dev_dbg(dev, "%s - Baud rate set to %d (divisor 0x%lX) on chip %s\n",
 			__func__, baud, (unsigned long)div_value,
 			ftdi_chip_name[priv->chip_type]);
 	}
 	tty_encode_baud_rate(tty, baud, baud);
 	return div_value;
 }
 static int change_speed(struct tty_struct *tty, struct usb_serial_port *port)
 {
 	struct ftdi_private *priv = usb_get_serial_port_data(port);
 	__u16 urb_value;
 	__u16 urb_index;
 	__u32 urb_index_value;
 	int rv;
 	urb_index_value = get_ftdi_divisor(tty, port);
 	urb_value = (__u16)urb_index_value;
 	urb_index = (__u16)(urb_index_value >> 16);
 	if ((priv->chip_type == FT2232C) || (priv->chip_type == FT2232H) ||
 		(priv->chip_type == FT4232H) || (priv->chip_type == FT232H)) {
 		/* Probably the BM type needs the MSB of the encoded fractional
 		 * divider also moved like for the chips above. Any infos? */
 		urb_index = (__u16)((urb_index << 8) | priv->interface);
 	}
 	rv = usb_control_msg(port->serial->dev,
 			    usb_sndctrlpipe(port->serial->dev, 0),
 			    FTDI_SIO_SET_BAUDRATE_REQUEST,
 			    FTDI_SIO_SET_BAUDRATE_REQUEST_TYPE,
 			    urb_value, urb_index,
 			    NULL, 0, WDR_SHORT_TIMEOUT);
 	return rv;
 }
 static int write_latency_timer(struct usb_serial_port *port)
 {
 	struct ftdi_private *priv = usb_get_serial_port_data(port);
 	struct usb_device *udev = port->serial->dev;
 	int rv;
 	int l = priv->latency;
 	if (priv->flags & ASYNC_LOW_LATENCY)
 		l = 1;
 	dev_dbg(&port->dev, "%s: setting latency timer = %i\n", __func__, l);
 	rv = usb_control_msg(udev,
 			     usb_sndctrlpipe(udev, 0),
 			     FTDI_SIO_SET_LATENCY_TIMER_REQUEST,
 			     FTDI_SIO_SET_LATENCY_TIMER_REQUEST_TYPE,
 			     l, priv->interface,
 			     NULL, 0, WDR_TIMEOUT);
 	if (rv < 0)
 		dev_err(&port->dev, "Unable to write latency timer: %i\n", rv);
 	return rv;
 }
 static int read_latency_timer(struct usb_serial_port *port)
 {
 	struct ftdi_private *priv = usb_get_serial_port_data(port);
 	struct usb_device *udev = port->serial->dev;
 	unsigned char *buf;
 	int rv;
 	buf = kmalloc(1, GFP_KERNEL);
 	if (!buf)
 		return -ENOMEM;
 	rv = usb_control_msg(udev,
 			     usb_rcvctrlpipe(udev, 0),
 			     FTDI_SIO_GET_LATENCY_TIMER_REQUEST,
 			     FTDI_SIO_GET_LATENCY_TIMER_REQUEST_TYPE,
 			     0, priv->interface,
 			     buf, 1, WDR_TIMEOUT);
 	if (rv < 0)
 		dev_err(&port->dev, "Unable to read latency timer: %i\n", rv);
 	else
 		priv->latency = buf[0];
 	kfree(buf);
 	return rv;
 }
 static int get_serial_info(struct usb_serial_port *port,
 				struct serial_struct __user *retinfo)
 {
 	struct ftdi_private *priv = usb_get_serial_port_data(port);
 	struct serial_struct tmp;
 	if (!retinfo)
 		return -EFAULT;
 	memset(&tmp, 0, sizeof(tmp));
 	tmp.flags = priv->flags;
 	tmp.baud_base = priv->baud_base;
 	tmp.custom_divisor = priv->custom_divisor;
 	if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
 		return -EFAULT;
 	return 0;
 }
 static int set_serial_info(struct tty_struct *tty,
 	struct usb_serial_port *port, struct serial_struct __user *newinfo)
 {
 	struct ftdi_private *priv = usb_get_serial_port_data(port);
 	struct serial_struct new_serial;
 	struct ftdi_private old_priv;
 	if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
 		return -EFAULT;
 	mutex_lock(&priv->cfg_lock);
 	old_priv = *priv;
 	/* Do error checking and permission checking */
 	if (!capable(CAP_SYS_ADMIN)) {
 		if (((new_serial.flags & ~ASYNC_USR_MASK) !=
 		     (priv->flags & ~ASYNC_USR_MASK))) {
 			mutex_unlock(&priv->cfg_lock);
 			return -EPERM;
 		}
 		priv->flags = ((priv->flags & ~ASYNC_USR_MASK) |
 			       (new_serial.flags & ASYNC_USR_MASK));
 		priv->custom_divisor = new_serial.custom_divisor;
 		goto check_and_exit;
 	}
 	if (new_serial.baud_base != priv->baud_base) {
 		mutex_unlock(&priv->cfg_lock);
 		return -EINVAL;
 	}
 	/* Make the changes - these are privileged changes! */
 	priv->flags = ((priv->flags & ~ASYNC_FLAGS) |
 					(new_serial.flags & ASYNC_FLAGS));
 	priv->custom_divisor = new_serial.custom_divisor;
 	write_latency_timer(port);
 check_and_exit:
 	if ((old_priv.flags & ASYNC_SPD_MASK) !=
 	     (priv->flags & ASYNC_SPD_MASK)) {
 		if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
 			tty->alt_speed = 57600;
 		else if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
 			tty->alt_speed = 115200;
 		else if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
 			tty->alt_speed = 230400;
 		else if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
 			tty->alt_speed = 460800;
 		else
 			tty->alt_speed = 0;
 	}
 	if (((old_priv.flags & ASYNC_SPD_MASK) !=
 	     (priv->flags & ASYNC_SPD_MASK)) ||
 	    (((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST) &&
 	     (old_priv.custom_divisor != priv->custom_divisor))) {
 		change_speed(tty, port);
 		mutex_unlock(&priv->cfg_lock);
 	}
 	else
 		mutex_unlock(&priv->cfg_lock);
 	return 0;
 }
 static int get_lsr_info(struct usb_serial_port *port,
 			struct serial_struct __user *retinfo)
 {
 	struct ftdi_private *priv = usb_get_serial_port_data(port);
 	unsigned int result = 0;
 	if (!retinfo)
 		return -EFAULT;
 	if (priv->transmit_empty)
 		result = TIOCSER_TEMT;
 	if (copy_to_user(retinfo, &result, sizeof(unsigned int)))
 		return -EFAULT;
 	return 0;
 }
 /* Determine type of FTDI chip based on USB config and descriptor. */
 static void ftdi_determine_type(struct usb_serial_port *port)
 {
 	struct ftdi_private *priv = usb_get_serial_port_data(port);
 	struct usb_serial *serial = port->serial;
 	struct usb_device *udev = serial->dev;
 	unsigned version;
 	unsigned interfaces;
 	/* Assume it is not the original SIO device for now. */
 	priv->baud_base = 48000000 / 2;
 	version = le16_to_cpu(udev->descriptor.bcdDevice);
 	interfaces = udev->actconfig->desc.bNumInterfaces;
 	dev_dbg(&port->dev, "%s: bcdDevice = 0x%x, bNumInterfaces = %u\n", __func__,
 		version, interfaces);
 	if (interfaces > 1) {
 		int inter;
 		/* Multiple interfaces.*/
 		if (version == 0x0800) {
 			priv->chip_type = FT4232H;
 			/* Hi-speed - baud clock runs at 120MHz */
 			priv->baud_base = 120000000 / 2;
 		} else if (version == 0x0700) {
 			priv->chip_type = FT2232H;
 			/* Hi-speed - baud clock runs at 120MHz */
 			priv->baud_base = 120000000 / 2;
 		} else
 			priv->chip_type = FT2232C;
 		/* Determine interface code. */
 		inter = serial->interface->altsetting->desc.bInterfaceNumber;
 		if (inter == 0) {
 			priv->interface = INTERFACE_A;
 		} else  if (inter == 1) {
 			priv->interface = INTERFACE_B;
 		} else  if (inter == 2) {
 			priv->interface = INTERFACE_C;
 		} else  if (inter == 3) {
 			priv->interface = INTERFACE_D;
 		}
 		/* BM-type devices have a bug where bcdDevice gets set
 		 * to 0x200 when iSerialNumber is 0.  */
 		if (version < 0x500) {
 			dev_dbg(&port->dev,
 				"%s: something fishy - bcdDevice too low for multi-interface device\n",
 				__func__);
 		}
 	} else if (version < 0x200) {
 		/* Old device.  Assume it's the original SIO. */
 		priv->chip_type = SIO;
 		priv->baud_base = 12000000 / 16;
 	} else if (version < 0x400) {
 		/* Assume it's an FT8U232AM (or FT8U245AM) */
 		/* (It might be a BM because of the iSerialNumber bug,
 		 * but it will still work as an AM device.) */
 		priv->chip_type = FT8U232AM;
 	} else if (version < 0x600) {
 		/* Assume it's an FT232BM (or FT245BM) */
 		priv->chip_type = FT232BM;
 	} else if (version < 0x900) {
 		/* Assume it's an FT232RL */
 		priv->chip_type = FT232RL;
 	} else if (version < 0x1000) {
 		/* Assume it's an FT232H */
 		priv->chip_type = FT232H;
 	} else {
 		/* Assume it's an FT-X series device */
 		priv->chip_type = FTX;
 	}
 	dev_info(&udev->dev, "Detected %s\n", ftdi_chip_name[priv->chip_type]);
 }
 /* Determine the maximum packet size for the device.  This depends on the chip
  * type and the USB host capabilities.  The value should be obtained from the
  * device descriptor as the chip will use the appropriate values for the host.*/
 static void ftdi_set_max_packet_size(struct usb_serial_port *port)
 {
 	struct ftdi_private *priv = usb_get_serial_port_data(port);
 	struct usb_serial *serial = port->serial;
 	struct usb_device *udev = serial->dev;
 	struct usb_interface *interface = serial->interface;
 	struct usb_endpoint_descriptor *ep_desc = &interface->cur_altsetting->endpoint[1].desc;
 	unsigned num_endpoints;
 	int i;
 	num_endpoints = interface->cur_altsetting->desc.bNumEndpoints;
 	dev_info(&udev->dev, "Number of endpoints %d\n", num_endpoints);
 	/* NOTE: some customers have programmed FT232R/FT245R devices
 	 * with an endpoint size of 0 - not good.  In this case, we
 	 * want to override the endpoint descriptor setting and use a
 	 * value of 64 for wMaxPacketSize */
 	for (i = 0; i < num_endpoints; i++) {
 		dev_info(&udev->dev, "Endpoint %d MaxPacketSize %d\n", i+1,
 			interface->cur_altsetting->endpoint[i].desc.wMaxPacketSize);
 		ep_desc = &interface->cur_altsetting->endpoint[i].desc;
 		if (ep_desc->wMaxPacketSize == 0) {
 			ep_desc->wMaxPacketSize = cpu_to_le16(0x40);
 			dev_info(&udev->dev, "Overriding wMaxPacketSize on endpoint %d\n", i);
 		}
 	}
 	/* set max packet size based on descriptor */
 	priv->max_packet_size = usb_endpoint_maxp(ep_desc);
 	dev_info(&udev->dev, "Setting MaxPacketSize %d\n", priv->max_packet_size);
 }
 /*
  * ***************************************************************************
  * Sysfs Attribute
  * ***************************************************************************
  */
 static ssize_t latency_timer_show(struct device *dev,
 				  struct device_attribute *attr, char *buf)
 {
 	struct usb_serial_port *port = to_usb_serial_port(dev);
 	struct ftdi_private *priv = usb_get_serial_port_data(port);
 	if (priv->flags & ASYNC_LOW_LATENCY)
 		return sprintf(buf, "1\n");
 	else
 		return sprintf(buf, "%i\n", priv->latency);
 }
 /* Write a new value of the latency timer, in units of milliseconds. */
 static ssize_t latency_timer_store(struct device *dev,
 				   struct device_attribute *attr,
 				   const char *valbuf, size_t count)
 {
 	struct usb_serial_port *port = to_usb_serial_port(dev);
 	struct ftdi_private *priv = usb_get_serial_port_data(port);
 	int v = simple_strtoul(valbuf, NULL, 10);
 	int rv;
 	priv->latency = v;
 	rv = write_latency_timer(port);
 	if (rv < 0)
 		return -EIO;
 	return count;
 }
 static DEVICE_ATTR_RW(latency_timer);
 /* Write an event character directly to the FTDI register.  The ASCII
    value is in the low 8 bits, with the enable bit in the 9th bit. */
 static ssize_t store_event_char(struct device *dev,
 	struct device_attribute *attr, const char *valbuf, size_t count)
 {
 	struct usb_serial_port *port = to_usb_serial_port(dev);
 	struct ftdi_private *priv = usb_get_serial_port_data(port);
 	struct usb_device *udev = port->serial->dev;
 	int v = simple_strtoul(valbuf, NULL, 10);
 	int rv;
 	dev_dbg(&port->dev, "%s: setting event char = %i\n", __func__, v);
 	rv = usb_control_msg(udev,
 			     usb_sndctrlpipe(udev, 0),
 			     FTDI_SIO_SET_EVENT_CHAR_REQUEST,
 			     FTDI_SIO_SET_EVENT_CHAR_REQUEST_TYPE,
 			     v, priv->interface,
 			     NULL, 0, WDR_TIMEOUT);
 	if (rv < 0) {
 		dev_dbg(&port->dev, "Unable to write event character: %i\n", rv);
 		return -EIO;
 	}
 	return count;
 }
 static DEVICE_ATTR(event_char, S_IWUSR, NULL, store_event_char);
 static int create_sysfs_attrs(struct usb_serial_port *port)
 {
 	struct ftdi_private *priv = usb_get_serial_port_data(port);
 	int retval = 0;
 	/* XXX I've no idea if the original SIO supports the event_char
 	 * sysfs parameter, so I'm playing it safe.  */
 	if (priv->chip_type != SIO) {
 		dev_dbg(&port->dev, "sysfs attributes for %s\n", ftdi_chip_name[priv->chip_type]);
 		retval = device_create_file(&port->dev, &dev_attr_event_char);
 		if ((!retval) &&
 		    (priv->chip_type == FT232BM ||
 		     priv->chip_type == FT2232C ||
 		     priv->chip_type == FT232RL ||
 		     priv->chip_type == FT2232H ||
 		     priv->chip_type == FT4232H ||
 		     priv->chip_type == FT232H ||
 		     priv->chip_type == FTX)) {
 			retval = device_create_file(&port->dev,
 						    &dev_attr_latency_timer);
 		}
 	}
 	return retval;
 }
 static void remove_sysfs_attrs(struct usb_serial_port *port)
 {
 	struct ftdi_private *priv = usb_get_serial_port_data(port);
 	/* XXX see create_sysfs_attrs */
 	if (priv->chip_type != SIO) {
 		device_remove_file(&port->dev, &dev_attr_event_char);
 		if (priv->chip_type == FT232BM ||
 		    priv->chip_type == FT2232C ||
 		    priv->chip_type == FT232RL ||
 		    priv->chip_type == FT2232H ||
 		    priv->chip_type == FT4232H ||
 		    priv->chip_type == FT232H ||
 		    priv->chip_type == FTX) {
 			device_remove_file(&port->dev, &dev_attr_latency_timer);
 		}
 	}
 }
 /*
  * ***************************************************************************
  * FTDI driver specific functions
  * ***************************************************************************
  */
 /* Probe function to check for special devices */
 static int ftdi_sio_probe(struct usb_serial *serial,
 					const struct usb_device_id *id)
 {
 	struct ftdi_sio_quirk *quirk =
 				(struct ftdi_sio_quirk *)id->driver_info;
 	if (quirk && quirk->probe) {
 		int ret = quirk->probe(serial);
 		if (ret != 0)
 			return ret;
 	}
 	usb_set_serial_data(serial, (void *)id->driver_info);
 	return 0;
 }
 static int ftdi_sio_port_probe(struct usb_serial_port *port)
 {
 	struct ftdi_private *priv;
 	struct ftdi_sio_quirk *quirk = usb_get_serial_data(port->serial);
 	priv = kzalloc(sizeof(struct ftdi_private), GFP_KERNEL);
 	if (!priv)
 		return -ENOMEM;
 	mutex_init(&priv->cfg_lock);
 	priv->flags = ASYNC_LOW_LATENCY;
 	if (quirk && quirk->port_probe)
 		quirk->port_probe(priv);
 	usb_set_serial_port_data(port, priv);
 	ftdi_determine_type(port);
 	ftdi_set_max_packet_size(port);
 	if (read_latency_timer(port) < 0)
 		priv->latency = 16;
 	write_latency_timer(port);
 	create_sysfs_attrs(port);
 	return 0;
 }
 /* Setup for the USB-UIRT device, which requires hardwired
  * baudrate (38400 gets mapped to 312500) */
 /* Called from usbserial:serial_probe */
 static void ftdi_USB_UIRT_setup(struct ftdi_private *priv)
 {
 	priv->flags |= ASYNC_SPD_CUST;
 	priv->custom_divisor = 77;
 	priv->force_baud = 38400;
 }
 /* Setup for the HE-TIRA1 device, which requires hardwired
  * baudrate (38400 gets mapped to 100000) and RTS-CTS enabled.  */
 static void ftdi_HE_TIRA1_setup(struct ftdi_private *priv)
 {
 	priv->flags |= ASYNC_SPD_CUST;
 	priv->custom_divisor = 240;
 	priv->force_baud = 38400;
 	priv->force_rtscts = 1;
 }
 /*
  * Module parameter to control latency timer for NDI FTDI-based USB devices.
  * If this value is not set in /etc/modprobe.d/ its value will be set
  * to 1ms.
  */
 static int ndi_latency_timer = 1;
 /* Setup for the NDI FTDI-based USB devices, which requires hardwired
  * baudrate (19200 gets mapped to 1200000).
  *
  * Called from usbserial:serial_probe.
  */
 static int ftdi_NDI_device_setup(struct usb_serial *serial)
 {
 	struct usb_device *udev = serial->dev;
 	int latency = ndi_latency_timer;
 	if (latency == 0)
 		latency = 1;
 	if (latency > 99)
 		latency = 99;
 	dev_dbg(&udev->dev, "%s setting NDI device latency to %d\n", __func__, latency);
 	dev_info(&udev->dev, "NDI device with a latency value of %d\n", latency);
 	/* FIXME: errors are not returned */
 	usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
 				FTDI_SIO_SET_LATENCY_TIMER_REQUEST,
 				FTDI_SIO_SET_LATENCY_TIMER_REQUEST_TYPE,
 				latency, 0, NULL, 0, WDR_TIMEOUT);
 	return 0;
 }
 /*
  * First port on JTAG adaptors such as Olimex arm-usb-ocd or the FIC/OpenMoko
  * Neo1973 Debug Board is reserved for JTAG interface and can be accessed from
  * userspace using openocd.
  */
 static int ftdi_jtag_probe(struct usb_serial *serial)
 {
 	struct usb_device *udev = serial->dev;
 	struct usb_interface *interface = serial->interface;
 	if (interface == udev->actconfig->interface[0]) {
 		dev_info(&udev->dev,
 			 "Ignoring serial port reserved for JTAG\n");
 		return -ENODEV;
 	}
 	return 0;
 }
 static int ftdi_8u2232c_probe(struct usb_serial *serial)
 {
 	struct usb_device *udev = serial->dev;
 	if ((udev->manufacturer && !strcmp(udev->manufacturer, "CALAO Systems")) ||
 	    (udev->product && !strcmp(udev->product, "BeagleBone/XDS100V2")))
 		return ftdi_jtag_probe(serial);
 	return 0;
 }
 /*
  * First two ports on JTAG adaptors using an FT4232 such as STMicroelectronics's
  * ST Micro Connect Lite are reserved for JTAG or other non-UART interfaces and
  * can be accessed from userspace.
  * The next two ports are enabled as UARTs by default, where port 2 is
  * a conventional RS-232 UART.
  */
 static int ftdi_stmclite_probe(struct usb_serial *serial)
 {
 	struct usb_device *udev = serial->dev;
 	struct usb_interface *interface = serial->interface;
 	if (interface == udev->actconfig->interface[0] ||
 	    interface == udev->actconfig->interface[1]) {
 		dev_info(&udev->dev, "Ignoring serial port reserved for JTAG\n");
 		return -ENODEV;
 	}
 	return 0;
 }
 /*
  * The Matrix Orbital VK204-25-USB has an invalid IN endpoint.
  * We have to correct it if we want to read from it.
  */
 static int ftdi_mtxorb_hack_setup(struct usb_serial *serial)
 {
 	struct usb_host_endpoint *ep = serial->dev->ep_in[1];
 	struct usb_endpoint_descriptor *ep_desc = &ep->desc;
 	if (ep->enabled && ep_desc->wMaxPacketSize == 0) {
 		ep_desc->wMaxPacketSize = cpu_to_le16(0x40);
 		dev_info(&serial->dev->dev,
 			 "Fixing invalid wMaxPacketSize on read pipe\n");
 	}
 	return 0;
 }
 static int ftdi_sio_port_remove(struct usb_serial_port *port)
 {
 	struct ftdi_private *priv = usb_get_serial_port_data(port);
 	remove_sysfs_attrs(port);
 	kfree(priv);
 	return 0;
 }
 static int ftdi_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
 	struct usb_device *dev = port->serial->dev;
 	struct ftdi_private *priv = usb_get_serial_port_data(port);
 	/* No error checking for this (will get errors later anyway) */
 	/* See ftdi_sio.h for description of what is reset */
 	usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 			FTDI_SIO_RESET_REQUEST, FTDI_SIO_RESET_REQUEST_TYPE,
 			FTDI_SIO_RESET_SIO,
 			priv->interface, NULL, 0, WDR_TIMEOUT);
 	/* Termios defaults are set by usb_serial_init. We don't change
 	   port->tty->termios - this would lose speed settings, etc.
 	   This is same behaviour as serial.c/rs_open() - Kuba */
 	/* ftdi_set_termios  will send usb control messages */
 	if (tty)
 		ftdi_set_termios(tty, port, NULL);
 	return usb_serial_generic_open(tty, port);
 }
 static void ftdi_dtr_rts(struct usb_serial_port *port, int on)
 {
 	struct ftdi_private *priv = usb_get_serial_port_data(port);
 	/* Disable flow control */
 	if (!on) {
 		if (usb_control_msg(port->serial->dev,
 			    usb_sndctrlpipe(port->serial->dev, 0),
 			    FTDI_SIO_SET_FLOW_CTRL_REQUEST,
 			    FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
 			    0, priv->interface, NULL, 0,
 			    WDR_TIMEOUT) < 0) {
 			dev_err(&port->dev, "error from flowcontrol urb\n");
 		}
 	}
 	/* drop RTS and DTR */
 	if (on)
 		set_mctrl(port, TIOCM_DTR | TIOCM_RTS);
 	else
 		clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
 }
 /* The SIO requires the first byte to have:
  *  B0 1
  *  B1 0
  *  B2..7 length of message excluding byte 0
  *
  * The new devices do not require this byte
  */
 static int ftdi_prepare_write_buffer(struct usb_serial_port *port,
 						void *dest, size_t size)
 {
 	struct ftdi_private *priv;
 	int count;
 	unsigned long flags;
 	priv = usb_get_serial_port_data(port);
 	if (priv->chip_type == SIO) {
 		unsigned char *buffer = dest;
 		int i, len, c;
 		count = 0;
 		spin_lock_irqsave(&port->lock, flags);
 		for (i = 0; i < size - 1; i += priv->max_packet_size) {
 			len = min_t(int, size - i, priv->max_packet_size) - 1;
 			c = kfifo_out(&port->write_fifo, &buffer[i + 1], len);
 			if (!c)
 				break;
 			port->icount.tx += c;
 			buffer[i] = (c << 2) + 1;
 			count += c + 1;
 		}
 		spin_unlock_irqrestore(&port->lock, flags);
 	} else {
 		count = kfifo_out_locked(&port->write_fifo, dest, size,
 								&port->lock);
 		port->icount.tx += count;
 	}
 	return count;
 }
 #define FTDI_RS_ERR_MASK (FTDI_RS_BI | FTDI_RS_PE | FTDI_RS_FE | FTDI_RS_OE)
 static int ftdi_process_packet(struct usb_serial_port *port,
 		struct ftdi_private *priv, char *packet, int len)
 {
 	int i;
 	char status;
 	char flag;
 	char *ch;
 	if (len < 2) {
 		dev_dbg(&port->dev, "malformed packet\n");
 		return 0;
 	}
 	/* Compare new line status to the old one, signal if different/
 	   N.B. packet may be processed more than once, but differences
 	   are only processed once.  */
 	status = packet[0] & FTDI_STATUS_B0_MASK;
 	if (status != priv->prev_status) {
 		char diff_status = status ^ priv->prev_status;
 		if (diff_status & FTDI_RS0_CTS)
 			port->icount.cts++;
 		if (diff_status & FTDI_RS0_DSR)
 			port->icount.dsr++;
 		if (diff_status & FTDI_RS0_RI)
 			port->icount.rng++;
 		if (diff_status & FTDI_RS0_RLSD) {
 			struct tty_struct *tty;
 			port->icount.dcd++;
 			tty = tty_port_tty_get(&port->port);
 			if (tty)
 				usb_serial_handle_dcd_change(port, tty,
 						status & FTDI_RS0_RLSD);
 			tty_kref_put(tty);
 		}
 		wake_up_interruptible(&port->port.delta_msr_wait);
 		priv->prev_status = status;
 	}
 	flag = TTY_NORMAL;
 	if (packet[1] & FTDI_RS_ERR_MASK) {
 		/* Break takes precedence over parity, which takes precedence
 		 * over framing errors */
 		if (packet[1] & FTDI_RS_BI) {
 			flag = TTY_BREAK;
 			port->icount.brk++;
 			usb_serial_handle_break(port);
 		} else if (packet[1] & FTDI_RS_PE) {
 			flag = TTY_PARITY;
 			port->icount.parity++;
 		} else if (packet[1] & FTDI_RS_FE) {
 			flag = TTY_FRAME;
 			port->icount.frame++;
 		}
 		/* Overrun is special, not associated with a char */
 		if (packet[1] & FTDI_RS_OE) {
 			port->icount.overrun++;
 			tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
 		}
 	}
 	/* save if the transmitter is empty or not */
 	if (packet[1] & FTDI_RS_TEMT)
 		priv->transmit_empty = 1;
 	else
 		priv->transmit_empty = 0;
 	len -= 2;
 	if (!len)
 		return 0;	/* status only */
 	port->icount.rx += len;
 	ch = packet + 2;
 	if (port->port.console && port->sysrq) {
 		for (i = 0; i < len; i++, ch++) {
 			if (!usb_serial_handle_sysrq_char(port, *ch))
 				tty_insert_flip_char(&port->port, *ch, flag);
 		}
 	} else {
 		tty_insert_flip_string_fixed_flag(&port->port, ch, flag, len);
 	}
 	return len;
 }
 static void ftdi_process_read_urb(struct urb *urb)
 {
 	struct usb_serial_port *port = urb->context;
 	struct ftdi_private *priv = usb_get_serial_port_data(port);
 	char *data = (char *)urb->transfer_buffer;
 	int i;
 	int len;
 	int count = 0;
 	for (i = 0; i < urb->actual_length; i += priv->max_packet_size) {
 		len = min_t(int, urb->actual_length - i, priv->max_packet_size);
 		count += ftdi_process_packet(port, priv, &data[i], len);
 	}
 	if (count)
 		tty_flip_buffer_push(&port->port);
 }
 static void ftdi_break_ctl(struct tty_struct *tty, int break_state)
 {
 	struct usb_serial_port *port = tty->driver_data;
 	struct ftdi_private *priv = usb_get_serial_port_data(port);
 	__u16 urb_value;
 	/* break_state = -1 to turn on break, and 0 to turn off break */
 	/* see drivers/char/tty_io.c to see it used */
 	/* last_set_data_urb_value NEVER has the break bit set in it */
 	if (break_state)
 		urb_value = priv->last_set_data_urb_value | FTDI_SIO_SET_BREAK;
 	else
 		urb_value = priv->last_set_data_urb_value;
 	if (usb_control_msg(port->serial->dev,
 			usb_sndctrlpipe(port->serial->dev, 0),
 			FTDI_SIO_SET_DATA_REQUEST,
 			FTDI_SIO_SET_DATA_REQUEST_TYPE,
 			urb_value , priv->interface,
 			NULL, 0, WDR_TIMEOUT) < 0) {
 		dev_err(&port->dev, "%s FAILED to enable/disable break state (state was %d)\n",
 			__func__, break_state);
 	}
 	dev_dbg(&port->dev, "%s break state is %d - urb is %d\n", __func__,
 		break_state, urb_value);
 }
 static bool ftdi_tx_empty(struct usb_serial_port *port)
 {
 	unsigned char buf[2];
 	int ret;
 	ret = ftdi_get_modem_status(port, buf);
 	if (ret == 2) {
 		if (!(buf[1] & FTDI_RS_TEMT))
 			return false;
 	}
 	return true;
 }
 /* old_termios contains the original termios settings and tty->termios contains
  * the new setting to be used
  * WARNING: set_termios calls this with old_termios in kernel space
  */
 static void ftdi_set_termios(struct tty_struct *tty,
 		struct usb_serial_port *port, struct ktermios *old_termios)
 {
 	struct usb_device *dev = port->serial->dev;
 	struct device *ddev = &port->dev;
 	struct ftdi_private *priv = usb_get_serial_port_data(port);
 	struct ktermios *termios = &tty->termios;
 	unsigned int cflag = termios->c_cflag;
 	__u16 urb_value; /* will hold the new flags */
 	/* Added for xon/xoff support */
 	unsigned int iflag = termios->c_iflag;
 	unsigned char vstop;
 	unsigned char vstart;
 	/* Force baud rate if this device requires it, unless it is set to
 	   B0. */
 	if (priv->force_baud && ((termios->c_cflag & CBAUD) != B0)) {
 		dev_dbg(ddev, "%s: forcing baud rate for this device\n", __func__);
 		tty_encode_baud_rate(tty, priv->force_baud,
 					priv->force_baud);
 	}
 	/* Force RTS-CTS if this device requires it. */
 	if (priv->force_rtscts) {
 		dev_dbg(ddev, "%s: forcing rtscts for this device\n", __func__);
 		termios->c_cflag |= CRTSCTS;
 	}
 	/*
 	 * All FTDI UART chips are limited to CS7/8. We shouldn't pretend to
 	 * support CS5/6 and revert the CSIZE setting instead.
 	 *
 	 * CS5 however is used to control some smartcard readers which abuse
 	 * this limitation to switch modes. Original FTDI chips fall back to
 	 * eight data bits.
 	 *
 	 * TODO: Implement a quirk to only allow this with mentioned
 	 *       readers. One I know of (Argolis Smartreader V1)
 	 *       returns "USB smartcard server" as iInterface string.
 	 *       The vendor didn't bother with a custom VID/PID of
 	 *       course.
 	 */
 	if (C_CSIZE(tty) == CS6) {
 		dev_warn(ddev, "requested CSIZE setting not supported\n");
 		termios->c_cflag &= ~CSIZE;
 		if (old_termios)
 			termios->c_cflag |= old_termios->c_cflag & CSIZE;
 		else
 			termios->c_cflag |= CS8;
 	}
 	cflag = termios->c_cflag;
 	if (!old_termios)
 		goto no_skip;
 	if (old_termios->c_cflag == termios->c_cflag
 	    && old_termios->c_ispeed == termios->c_ispeed
 	    && old_termios->c_ospeed == termios->c_ospeed)
 		goto no_c_cflag_changes;
 	/* NOTE These routines can get interrupted by
 	   ftdi_sio_read_bulk_callback  - need to examine what this means -
 	   don't see any problems yet */
 	if ((old_termios->c_cflag & (CSIZE|PARODD|PARENB|CMSPAR|CSTOPB)) ==
 	    (termios->c_cflag & (CSIZE|PARODD|PARENB|CMSPAR|CSTOPB)))
 		goto no_data_parity_stop_changes;
 no_skip:
 	/* Set number of data bits, parity, stop bits */
 	urb_value = 0;
 	urb_value |= (cflag & CSTOPB ? FTDI_SIO_SET_DATA_STOP_BITS_2 :
 		      FTDI_SIO_SET_DATA_STOP_BITS_1);
 	if (cflag & PARENB) {
 		if (cflag & CMSPAR)
 			urb_value |= cflag & PARODD ?
 				     FTDI_SIO_SET_DATA_PARITY_MARK :
 				     FTDI_SIO_SET_DATA_PARITY_SPACE;
 		else
 			urb_value |= cflag & PARODD ?
 				     FTDI_SIO_SET_DATA_PARITY_ODD :
 				     FTDI_SIO_SET_DATA_PARITY_EVEN;
 	} else {
 		urb_value |= FTDI_SIO_SET_DATA_PARITY_NONE;
 	}
 	switch (cflag & CSIZE) {
 	case CS5:
 		dev_dbg(ddev, "Setting CS5 quirk\n");
 		break;
 	case CS7:
 		urb_value |= 7;
 		dev_dbg(ddev, "Setting CS7\n");
 		break;
 	default:
 	case CS8:
 		urb_value |= 8;
 		dev_dbg(ddev, "Setting CS8\n");
 		break;
 	}
 	/* This is needed by the break command since it uses the same command
 	   - but is or'ed with this value  */
 	priv->last_set_data_urb_value = urb_value;
 	if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 			    FTDI_SIO_SET_DATA_REQUEST,
 			    FTDI_SIO_SET_DATA_REQUEST_TYPE,
 			    urb_value , priv->interface,
 			    NULL, 0, WDR_SHORT_TIMEOUT) < 0) {
 		dev_err(ddev, "%s FAILED to set databits/stopbits/parity\n",
 			__func__);
 	}
 	/* Now do the baudrate */
 no_data_parity_stop_changes:
 	if ((cflag & CBAUD) == B0) {
 		/* Disable flow control */
 		if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 				    FTDI_SIO_SET_FLOW_CTRL_REQUEST,
 				    FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
 				    0, priv->interface,
 				    NULL, 0, WDR_TIMEOUT) < 0) {
 			dev_err(ddev, "%s error from disable flowcontrol urb\n",
 				__func__);
 		}
 		/* Drop RTS and DTR */
 		clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
 	} else {
 		/* set the baudrate determined before */
 		mutex_lock(&priv->cfg_lock);
 		if (change_speed(tty, port))
 			dev_err(ddev, "%s urb failed to set baudrate\n", __func__);
 		mutex_unlock(&priv->cfg_lock);
 		/* Ensure RTS and DTR are raised when baudrate changed from 0 */
 		if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
 			set_mctrl(port, TIOCM_DTR | TIOCM_RTS);
 	}
 	/* Set flow control */
 	/* Note device also supports DTR/CD (ugh) and Xon/Xoff in hardware */
 no_c_cflag_changes:
 	if (cflag & CRTSCTS) {
 		dev_dbg(ddev, "%s Setting to CRTSCTS flow control\n", __func__);
 		if (usb_control_msg(dev,
 				    usb_sndctrlpipe(dev, 0),
 				    FTDI_SIO_SET_FLOW_CTRL_REQUEST,
 				    FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
 				    0 , (FTDI_SIO_RTS_CTS_HS | priv->interface),
 				    NULL, 0, WDR_TIMEOUT) < 0) {
 			dev_err(ddev, "urb failed to set to rts/cts flow control\n");
 		}
 	} else {
 		/*
 		 * Xon/Xoff code
 		 *
 		 * Check the IXOFF status in the iflag component of the
 		 * termios structure. If IXOFF is not set, the pre-xon/xoff
 		 * code is executed.
 		 */
 		if (iflag & IXOFF) {
 			dev_dbg(ddev, "%s  request to enable xonxoff iflag=%04x\n",
 				__func__, iflag);
 			/* Try to enable the XON/XOFF on the ftdi_sio
 			 * Set the vstart and vstop -- could have been done up
 			 * above where a lot of other dereferencing is done but
 			 * that would be very inefficient as vstart and vstop
 			 * are not always needed.
 			 */
 			vstart = termios->c_cc[VSTART];
 			vstop = termios->c_cc[VSTOP];
 			urb_value = (vstop << 8) | (vstart);
 			if (usb_control_msg(dev,
 					    usb_sndctrlpipe(dev, 0),
 					    FTDI_SIO_SET_FLOW_CTRL_REQUEST,
 					    FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
 					    urb_value , (FTDI_SIO_XON_XOFF_HS
 							 | priv->interface),
 					    NULL, 0, WDR_TIMEOUT) < 0) {
 				dev_err(&port->dev, "urb failed to set to "
 					"xon/xoff flow control\n");
 			}
 		} else {
 			/* else clause to only run if cflag ! CRTSCTS and iflag
 			 * ! XOFF. CHECKME Assuming XON/XOFF handled by tty
 			 * stack - not by device */
 			dev_dbg(ddev, "%s Turning off hardware flow control\n", __func__);
 			if (usb_control_msg(dev,
 					    usb_sndctrlpipe(dev, 0),
 					    FTDI_SIO_SET_FLOW_CTRL_REQUEST,
 					    FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
 					    0, priv->interface,
 					    NULL, 0, WDR_TIMEOUT) < 0) {
 				dev_err(ddev, "urb failed to clear flow control\n");
 			}
 		}
 	}
 }
 /*
  * Get modem-control status.
  *
  * Returns the number of status bytes retrieved (device dependant), or
  * negative error code.
  */
 static int ftdi_get_modem_status(struct usb_serial_port *port,
 						unsigned char status[2])
 {
 	struct ftdi_private *priv = usb_get_serial_port_data(port);
 	unsigned char *buf;
 	int len;
 	int ret;
 	buf = kmalloc(2, GFP_KERNEL);
 	if (!buf)
 		return -ENOMEM;
 	/*
 	 * The 8U232AM returns a two byte value (the SIO a 1 byte value) in
 	 * the same format as the data returned from the in point.
 	 */
 	switch (priv->chip_type) {
 	case SIO:
 		len = 1;
 		break;
 	case FT8U232AM:
 	case FT232BM:
 	case FT2232C:
 	case FT232RL:
 	case FT2232H:
 	case FT4232H:
 	case FT232H:
 	case FTX:
 		len = 2;
 		break;
 	default:
 		ret = -EFAULT;
 		goto out;
 	}
 	ret = usb_control_msg(port->serial->dev,
 			usb_rcvctrlpipe(port->serial->dev, 0),
 			FTDI_SIO_GET_MODEM_STATUS_REQUEST,
 			FTDI_SIO_GET_MODEM_STATUS_REQUEST_TYPE,
 			0, priv->interface,
 			buf, len, WDR_TIMEOUT);
 	if (ret < 0) {
 		dev_err(&port->dev, "failed to get modem status: %d\n", ret);
 		ret = usb_translate_errors(ret);
 		goto out;
 	}
 	status[0] = buf[0];
 	if (ret > 1)
 		status[1] = buf[1];
 	else
 		status[1] = 0;
 	dev_dbg(&port->dev, "%s - 0x%02x%02x\n", __func__, status[0],
 								status[1]);
 out:
 	kfree(buf);
 	return ret;
 }
 static int ftdi_tiocmget(struct tty_struct *tty)
 {
 	struct usb_serial_port *port = tty->driver_data;
 	struct ftdi_private *priv = usb_get_serial_port_data(port);
 	unsigned char buf[2];
 	int ret;
 	ret = ftdi_get_modem_status(port, buf);
 	if (ret < 0)
 		return ret;
 	ret =	(buf[0] & FTDI_SIO_DSR_MASK  ? TIOCM_DSR : 0) |
 		(buf[0] & FTDI_SIO_CTS_MASK  ? TIOCM_CTS : 0) |
 		(buf[0] & FTDI_SIO_RI_MASK   ? TIOCM_RI  : 0) |
 		(buf[0] & FTDI_SIO_RLSD_MASK ? TIOCM_CD  : 0) |
 		priv->last_dtr_rts;
 	return ret;
 }
 static int ftdi_tiocmset(struct tty_struct *tty,
 			unsigned int set, unsigned int clear)
 {
 	struct usb_serial_port *port = tty->driver_data;
 	return update_mctrl(port, set, clear);
 }
 static int ftdi_ioctl(struct tty_struct *tty,
 					unsigned int cmd, unsigned long arg)
 {
 	struct usb_serial_port *port = tty->driver_data;
 	/* Based on code from acm.c and others */
 	switch (cmd) {
 	case TIOCGSERIAL: /* gets serial port data */
 		return get_serial_info(port,
 					(struct serial_struct __user *) arg);
 	case TIOCSSERIAL: /* sets serial port data */
 		return set_serial_info(tty, port,
 					(struct serial_struct __user *) arg);
 	case TIOCSERGETLSR:
 		return get_lsr_info(port, (struct serial_struct __user *)arg);
 		break;
 	default:
 		break;
 	}
 	return -ENOIOCTLCMD;
 }
 module_usb_serial_driver(serial_drivers, id_table_combined);
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
 module_param(ndi_latency_timer, int, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(ndi_latency_timer, "NDI device latency timer override");

drivers/usb/serial/ftdi_sio_ids.h

Diff comments View file @ 8ee7a33

 /*
  * vendor/product IDs (VID/PID) of devices using FTDI USB serial converters.
  * Please keep numerically sorted within individual areas, thanks!
  *
  * Philipp Gühring - pg@futureware.at - added the Device ID of the USB relais
  * from Rudolf Gugler
  *
  */
 /**********************************/
 /***** devices using FTDI VID *****/
 /**********************************/
 #define FTDI_VID	0x0403	/* Vendor Id */
 /*** "original" FTDI device PIDs ***/
 #define FTDI_8U232AM_PID 0x6001 /* Similar device to SIO above */
 #define FTDI_8U232AM_ALT_PID 0x6006 /* FTDI's alternate PID for above */
 #define FTDI_8U2232C_PID 0x6010 /* Dual channel device */
 #define FTDI_4232H_PID 0x6011 /* Quad channel hi-speed device */
 #define FTDI_232H_PID  0x6014 /* Single channel hi-speed device */
 #define FTDI_FTX_PID   0x6015 /* FT-X series (FT201X, FT230X, FT231X, etc) */
 #define FTDI_SIO_PID	0x8372	/* Product Id SIO application of 8U100AX */
 #define FTDI_232RL_PID  0xFBFA  /* Product ID for FT232RL */
 /*** third-party PIDs (using FTDI_VID) ***/
 #define FTDI_LUMEL_PD12_PID	0x6002
 /*
  * Marvell OpenRD Base, Client
  * http://www.open-rd.org
  * OpenRD Base, Client use VID 0x0403
  */
 #define MARVELL_OPENRD_PID	0x9e90
 /* www.candapter.com Ewert Energy Systems CANdapter device */
 #define FTDI_CANDAPTER_PID 0x9F80 /* Product Id */
 /*
  * Texas Instruments XDS100v2 JTAG / BeagleBone A3
  * http://processors.wiki.ti.com/index.php/XDS100
  * http://beagleboard.org/bone
  */
 #define TI_XDS100V2_PID		0xa6d0
 #define FTDI_NXTCAM_PID		0xABB8 /* NXTCam for Mindstorms NXT */
 #define FTDI_EV3CON_PID		0xABB9 /* Mindstorms EV3 Console Adapter */
 /* US Interface Navigator (http://www.usinterface.com/) */
 #define FTDI_USINT_CAT_PID	0xb810	/* Navigator CAT and 2nd PTT lines */
 #define FTDI_USINT_WKEY_PID	0xb811	/* Navigator WKEY and FSK lines */
 #define FTDI_USINT_RS232_PID	0xb812	/* Navigator RS232 and CONFIG lines */
 /* OOCDlink by Joern Kaipf <joernk@web.de>
  * (http://www.joernonline.de/) */
 #define FTDI_OOCDLINK_PID	0xbaf8	/* Amontec JTAGkey */
 /* Luminary Micro Stellaris Boards, VID = FTDI_VID */
 /* FTDI 2332C Dual channel device, side A=245 FIFO (JTAG), Side B=RS232 UART */
 #define LMI_LM3S_DEVEL_BOARD_PID	0xbcd8
 #define LMI_LM3S_EVAL_BOARD_PID		0xbcd9
 #define LMI_LM3S_ICDI_BOARD_PID		0xbcda
 #define FTDI_TURTELIZER_PID	0xBDC8 /* JTAG/RS-232 adapter by egnite GmbH */
 /* OpenDCC (www.opendcc.de) product id */
 #define FTDI_OPENDCC_PID	0xBFD8
 #define FTDI_OPENDCC_SNIFFER_PID	0xBFD9
 #define FTDI_OPENDCC_THROTTLE_PID	0xBFDA
 #define FTDI_OPENDCC_GATEWAY_PID	0xBFDB
 #define FTDI_OPENDCC_GBM_PID	0xBFDC
 #define FTDI_OPENDCC_GBM_BOOST_PID	0xBFDD
 /* NZR SEM 16+ USB (http://www.nzr.de) */
 #define FTDI_NZR_SEM_USB_PID	0xC1E0	/* NZR SEM-LOG16+ */
 /*
  * RR-CirKits LocoBuffer USB (http://www.rr-cirkits.com)
  */
 #define FTDI_RRCIRKITS_LOCOBUFFER_PID	0xc7d0	/* LocoBuffer USB */
 /* DMX4ALL DMX Interfaces */
 #define FTDI_DMX4ALL 0xC850
 /*
  * ASK.fr devices
  */
 #define FTDI_ASK_RDR400_PID	0xC991	/* ASK RDR 400 series card reader */
 /* www.starting-point-systems.com µChameleon device */
 #define FTDI_MICRO_CHAMELEON_PID	0xCAA0	/* Product Id */
 /*
  * Tactrix OpenPort (ECU) devices.
  * OpenPort 1.3M submitted by Donour Sizemore.
  * OpenPort 1.3S and 1.3U submitted by Ian Abbott.
  */
 #define FTDI_TACTRIX_OPENPORT_13M_PID	0xCC48	/* OpenPort 1.3 Mitsubishi */
 #define FTDI_TACTRIX_OPENPORT_13S_PID	0xCC49	/* OpenPort 1.3 Subaru */
 #define FTDI_TACTRIX_OPENPORT_13U_PID	0xCC4A	/* OpenPort 1.3 Universal */
 #define FTDI_DISTORTEC_JTAG_LOCK_PICK_PID	0xCFF8
 /* SCS HF Radio Modems PID's (http://www.scs-ptc.com) */
 /* the VID is the standard ftdi vid (FTDI_VID) */
 #define FTDI_SCS_DEVICE_0_PID 0xD010    /* SCS PTC-IIusb */
 #define FTDI_SCS_DEVICE_1_PID 0xD011    /* SCS Tracker / DSP TNC */
 #define FTDI_SCS_DEVICE_2_PID 0xD012
 #define FTDI_SCS_DEVICE_3_PID 0xD013
 #define FTDI_SCS_DEVICE_4_PID 0xD014
 #define FTDI_SCS_DEVICE_5_PID 0xD015
 #define FTDI_SCS_DEVICE_6_PID 0xD016
 #define FTDI_SCS_DEVICE_7_PID 0xD017
 /* iPlus device */
 #define FTDI_IPLUS_PID 0xD070 /* Product Id */
 #define FTDI_IPLUS2_PID 0xD071 /* Product Id */
 /*
  * Gamma Scout (http://gamma-scout.com/). Submitted by rsc@runtux.com.
  */
 #define FTDI_GAMMA_SCOUT_PID		0xD678	/* Gamma Scout online */
 /* Propox devices */
 #define FTDI_PROPOX_JTAGCABLEII_PID	0xD738
 #define FTDI_PROPOX_ISPCABLEIII_PID	0xD739
 /* Lenz LI-USB Computer Interface. */
 #define FTDI_LENZ_LIUSB_PID	0xD780
 /* Vardaan Enterprises Serial Interface VEUSB422R3 */
 #define FTDI_VARDAAN_PID	0xF070
 /*
  * Xsens Technologies BV products (http://www.xsens.com).
  */
 #define XSENS_CONVERTER_0_PID	0xD388
 #define XSENS_CONVERTER_1_PID	0xD389
 #define XSENS_CONVERTER_2_PID	0xD38A
 #define XSENS_CONVERTER_3_PID	0xD38B
 #define XSENS_CONVERTER_4_PID	0xD38C
 #define XSENS_CONVERTER_5_PID	0xD38D
 #define XSENS_CONVERTER_6_PID	0xD38E
 #define XSENS_CONVERTER_7_PID	0xD38F
 /**
  * Zolix (www.zolix.com.cb) product ids
  */
 #define FTDI_OMNI1509			0xD491	/* Omni1509 embedded USB-serial */
 /*
  * NDI (www.ndigital.com) product ids
  */
 #define FTDI_NDI_HUC_PID		0xDA70	/* NDI Host USB Converter */
 #define FTDI_NDI_SPECTRA_SCU_PID	0xDA71	/* NDI Spectra SCU */
 #define FTDI_NDI_FUTURE_2_PID		0xDA72	/* NDI future device #2 */
 #define FTDI_NDI_FUTURE_3_PID		0xDA73	/* NDI future device #3 */
 #define FTDI_NDI_AURORA_SCU_PID		0xDA74	/* NDI Aurora SCU */
 /*
  * ChamSys Limited (www.chamsys.co.uk) USB wing/interface product IDs
  */
 #define FTDI_CHAMSYS_24_MASTER_WING_PID        0xDAF8
 #define FTDI_CHAMSYS_PC_WING_PID       0xDAF9
 #define FTDI_CHAMSYS_USB_DMX_PID       0xDAFA
 #define FTDI_CHAMSYS_MIDI_TIMECODE_PID 0xDAFB
 #define FTDI_CHAMSYS_MINI_WING_PID     0xDAFC
 #define FTDI_CHAMSYS_MAXI_WING_PID     0xDAFD
 #define FTDI_CHAMSYS_MEDIA_WING_PID    0xDAFE
 #define FTDI_CHAMSYS_WING_PID  0xDAFF
 /*
  * Westrex International devices submitted by Cory Lee
  */
 #define FTDI_WESTREX_MODEL_777_PID	0xDC00	/* Model 777 */
 #define FTDI_WESTREX_MODEL_8900F_PID	0xDC01	/* Model 8900F */
 /*
  * ACG Identification Technologies GmbH products (http://www.acg.de/).
  * Submitted by anton -at- goto10 -dot- org.
  */
 #define FTDI_ACG_HFDUAL_PID		0xDD20	/* HF Dual ISO Reader (RFID) */
 /*
  * Definitions for Artemis astronomical USB based cameras
  * Check it at http://www.artemisccd.co.uk/
  */
 #define FTDI_ARTEMIS_PID	0xDF28	/* All Artemis Cameras */
 /*
  * Definitions for ATIK Instruments astronomical USB based cameras
  * Check it at http://www.atik-instruments.com/
  */
 #define FTDI_ATIK_ATK16_PID	0xDF30	/* ATIK ATK-16 Grayscale Camera */
 #define FTDI_ATIK_ATK16C_PID	0xDF32	/* ATIK ATK-16C Colour Camera */
 #define FTDI_ATIK_ATK16HR_PID	0xDF31	/* ATIK ATK-16HR Grayscale Camera */
 #define FTDI_ATIK_ATK16HRC_PID	0xDF33	/* ATIK ATK-16HRC Colour Camera */
 #define FTDI_ATIK_ATK16IC_PID   0xDF35  /* ATIK ATK-16IC Grayscale Camera */
 /*
  * Yost Engineering, Inc. products (www.yostengineering.com).
  * PID 0xE050 submitted by Aaron Prose.
  */
 #define FTDI_YEI_SERVOCENTER31_PID	0xE050	/* YEI ServoCenter3.1 USB */
 /*
  * ELV USB devices submitted by Christian Abt of ELV (www.elv.de).
  * Almost all of these devices use FTDI's vendor ID (0x0403).
  * Further IDs taken from ELV Windows .inf file.
  *
  * The previously included PID for the UO 100 module was incorrect.
  * In fact, that PID was for ELV's UR 100 USB-RS232 converter (0xFB58).
  *
  * Armin Laeuger originally sent the PID for the UM 100 module.
  */
 #define FTDI_ELV_VID	0x1B1F	/* ELV AG */
 #define FTDI_ELV_WS300_PID	0xC006	/* eQ3 WS 300 PC II */
 #define FTDI_ELV_USR_PID	0xE000	/* ELV Universal-Sound-Recorder */
 #define FTDI_ELV_MSM1_PID	0xE001	/* ELV Mini-Sound-Modul */
 #define FTDI_ELV_KL100_PID	0xE002	/* ELV Kfz-Leistungsmesser KL 100 */
 #define FTDI_ELV_WS550_PID	0xE004	/* WS 550 */
 #define FTDI_ELV_EC3000_PID	0xE006	/* ENERGY CONTROL 3000 USB */
 #define FTDI_ELV_WS888_PID	0xE008	/* WS 888 */
 #define FTDI_ELV_TWS550_PID	0xE009	/* Technoline WS 550 */
 #define FTDI_ELV_FEM_PID	0xE00A	/* Funk Energie Monitor */
 #define FTDI_ELV_FHZ1300PC_PID	0xE0E8	/* FHZ 1300 PC */
 #define FTDI_ELV_WS500_PID	0xE0E9	/* PC-Wetterstation (WS 500) */
 #define FTDI_ELV_HS485_PID	0xE0EA	/* USB to RS-485 adapter */
 #define FTDI_ELV_UMS100_PID	0xE0EB	/* ELV USB Master-Slave Schaltsteckdose UMS 100 */
 #define FTDI_ELV_TFD128_PID	0xE0EC	/* ELV Temperatur-Feuchte-Datenlogger TFD 128 */
 #define FTDI_ELV_FM3RX_PID	0xE0ED	/* ELV Messwertuebertragung FM3 RX */
 #define FTDI_ELV_WS777_PID	0xE0EE	/* Conrad WS 777 */
 #define FTDI_ELV_EM1010PC_PID	0xE0EF	/* Energy monitor EM 1010 PC */
 #define FTDI_ELV_CSI8_PID	0xE0F0	/* Computer-Schalt-Interface (CSI 8) */
 #define FTDI_ELV_EM1000DL_PID	0xE0F1	/* PC-Datenlogger fuer Energiemonitor (EM 1000 DL) */
 #define FTDI_ELV_PCK100_PID	0xE0F2	/* PC-Kabeltester (PCK 100) */
 #define FTDI_ELV_RFP500_PID	0xE0F3	/* HF-Leistungsmesser (RFP 500) */
 #define FTDI_ELV_FS20SIG_PID	0xE0F4	/* Signalgeber (FS 20 SIG) */
 #define FTDI_ELV_UTP8_PID	0xE0F5	/* ELV UTP 8 */
 #define FTDI_ELV_WS300PC_PID	0xE0F6	/* PC-Wetterstation (WS 300 PC) */
 #define FTDI_ELV_WS444PC_PID	0xE0F7	/* Conrad WS 444 PC */
 #define FTDI_PHI_FISCO_PID      0xE40B  /* PHI Fisco USB to Serial cable */
 #define FTDI_ELV_UAD8_PID	0xF068	/* USB-AD-Wandler (UAD 8) */
 #define FTDI_ELV_UDA7_PID	0xF069	/* USB-DA-Wandler (UDA 7) */
 #define FTDI_ELV_USI2_PID	0xF06A	/* USB-Schrittmotoren-Interface (USI 2) */
 #define FTDI_ELV_T1100_PID	0xF06B	/* Thermometer (T 1100) */
 #define FTDI_ELV_PCD200_PID	0xF06C	/* PC-Datenlogger (PCD 200) */
 #define FTDI_ELV_ULA200_PID	0xF06D	/* USB-LCD-Ansteuerung (ULA 200) */
 #define FTDI_ELV_ALC8500_PID	0xF06E	/* ALC 8500 Expert */
 #define FTDI_ELV_FHZ1000PC_PID	0xF06F	/* FHZ 1000 PC */
 #define FTDI_ELV_UR100_PID	0xFB58	/* USB-RS232-Umsetzer (UR 100) */
 #define FTDI_ELV_UM100_PID	0xFB5A	/* USB-Modul UM 100 */
 #define FTDI_ELV_UO100_PID	0xFB5B	/* USB-Modul UO 100 */
 /* Additional ELV PIDs that default to using the FTDI D2XX drivers on
  * MS Windows, rather than the FTDI Virtual Com Port drivers.
  * Maybe these will be easier to use with the libftdi/libusb user-space
  * drivers, or possibly the Comedi drivers in some cases. */
 #define FTDI_ELV_CLI7000_PID	0xFB59	/* Computer-Light-Interface (CLI 7000) */
 #define FTDI_ELV_PPS7330_PID	0xFB5C	/* Processor-Power-Supply (PPS 7330) */
 #define FTDI_ELV_TFM100_PID	0xFB5D	/* Temperatur-Feuchte-Messgeraet (TFM 100) */
 #define FTDI_ELV_UDF77_PID	0xFB5E	/* USB DCF Funkuhr (UDF 77) */
 #define FTDI_ELV_UIO88_PID	0xFB5F	/* USB-I/O Interface (UIO 88) */
 /*
  * EVER Eco Pro UPS (http://www.ever.com.pl/)
  */
 #define	EVER_ECO_PRO_CDS	0xe520	/* RS-232 converter */
 /*
  * Active Robots product ids.
  */
 #define FTDI_ACTIVE_ROBOTS_PID	0xE548	/* USB comms board */
 /* Pyramid Computer GmbH */
 #define FTDI_PYRAMID_PID	0xE6C8	/* Pyramid Appliance Display */
 /* www.elsterelectricity.com Elster Unicom III Optical Probe */
 #define FTDI_ELSTER_UNICOM_PID		0xE700 /* Product Id */
 /*
  * Gude Analog- und Digitalsysteme GmbH
  */
 #define FTDI_GUDEADS_E808_PID    0xE808
 #define FTDI_GUDEADS_E809_PID    0xE809
 #define FTDI_GUDEADS_E80A_PID    0xE80A
 #define FTDI_GUDEADS_E80B_PID    0xE80B
 #define FTDI_GUDEADS_E80C_PID    0xE80C
 #define FTDI_GUDEADS_E80D_PID    0xE80D
 #define FTDI_GUDEADS_E80E_PID    0xE80E
 #define FTDI_GUDEADS_E80F_PID    0xE80F
 #define FTDI_GUDEADS_E888_PID    0xE888  /* Expert ISDN Control USB */
 #define FTDI_GUDEADS_E889_PID    0xE889  /* USB RS-232 OptoBridge */
 #define FTDI_GUDEADS_E88A_PID    0xE88A
 #define FTDI_GUDEADS_E88B_PID    0xE88B
 #define FTDI_GUDEADS_E88C_PID    0xE88C
 #define FTDI_GUDEADS_E88D_PID    0xE88D
 #define FTDI_GUDEADS_E88E_PID    0xE88E
 #define FTDI_GUDEADS_E88F_PID    0xE88F
 /*
  * Eclo (http://www.eclo.pt/) product IDs.
  * PID 0xEA90 submitted by Martin Grill.
  */
 #define FTDI_ECLO_COM_1WIRE_PID	0xEA90	/* COM to 1-Wire USB adaptor */
 /* TNC-X USB-to-packet-radio adapter, versions prior to 3.0 (DLP module) */
 #define FTDI_TNC_X_PID		0xEBE0
 /*
  * Teratronik product ids.
  * Submitted by O. Wölfelschneider.
  */
 #define FTDI_TERATRONIK_VCP_PID	 0xEC88	/* Teratronik device (preferring VCP driver on windows) */
 #define FTDI_TERATRONIK_D2XX_PID 0xEC89	/* Teratronik device (preferring D2XX driver on windows) */
 /* Rig Expert Ukraine devices */
 #define FTDI_REU_TINY_PID		0xED22	/* RigExpert Tiny */
 /*
  * Hameg HO820 and HO870 interface (using VID 0x0403)
  */
 #define HAMEG_HO820_PID			0xed74
 #define HAMEG_HO730_PID			0xed73
 #define HAMEG_HO720_PID			0xed72
 #define HAMEG_HO870_PID			0xed71
 /*
  *  MaxStream devices	www.maxstream.net
  */
 #define FTDI_MAXSTREAM_PID	0xEE18	/* Xbee PKG-U Module */
 /*
  * microHAM product IDs (http://www.microham.com).
  * Submitted by Justin Burket (KL1RL) <zorton@jtan.com>
  * and Mike Studer (K6EEP) <k6eep@hamsoftware.org>.
  * Ian Abbott <abbotti@mev.co.uk> added a few more from the driver INF file.
  */
 #define FTDI_MHAM_KW_PID	0xEEE8	/* USB-KW interface */
 #define FTDI_MHAM_YS_PID	0xEEE9	/* USB-YS interface */
 #define FTDI_MHAM_Y6_PID	0xEEEA	/* USB-Y6 interface */
 #define FTDI_MHAM_Y8_PID	0xEEEB	/* USB-Y8 interface */
 #define FTDI_MHAM_IC_PID	0xEEEC	/* USB-IC interface */
 #define FTDI_MHAM_DB9_PID	0xEEED	/* USB-DB9 interface */
 #define FTDI_MHAM_RS232_PID	0xEEEE	/* USB-RS232 interface */
 #define FTDI_MHAM_Y9_PID	0xEEEF	/* USB-Y9 interface */
 /* Domintell products  http://www.domintell.com */
 #define FTDI_DOMINTELL_DGQG_PID	0xEF50	/* Master */
 #define FTDI_DOMINTELL_DUSB_PID	0xEF51	/* DUSB01 module */
 /*
  * The following are the values for the Perle Systems
  * UltraPort USB serial converters
  */
 #define FTDI_PERLE_ULTRAPORT_PID 0xF0C0	/* Perle UltraPort Product Id */
 /* Sprog II (Andrew Crosland's SprogII DCC interface) */
 #define FTDI_SPROG_II		0xF0C8
 /*
  * Two of the Tagsys RFID Readers
  */
 #define FTDI_TAGSYS_LP101_PID	0xF0E9	/* Tagsys L-P101 RFID*/
 #define FTDI_TAGSYS_P200X_PID	0xF0EE	/* Tagsys Medio P200x RFID*/
 /* an infrared receiver for user access control with IR tags */
 #define FTDI_PIEGROUP_PID	0xF208	/* Product Id */
 /* ACT Solutions HomePro ZWave interface
    (http://www.act-solutions.com/HomePro-Product-Matrix.html) */
 #define FTDI_ACTZWAVE_PID	0xF2D0
 /*
  * 4N-GALAXY.DE PIDs for CAN-USB, USB-RS232, USB-RS422, USB-RS485,
  * USB-TTY aktiv, USB-TTY passiv.  Some PIDs are used by several devices
  * and I'm not entirely sure which are used by which.
  */
 #define FTDI_4N_GALAXY_DE_1_PID	0xF3C0
 #define FTDI_4N_GALAXY_DE_2_PID	0xF3C1
 #define FTDI_4N_GALAXY_DE_3_PID	0xF3C2
 /*
  * Linx Technologies product ids
  */
 #define LINX_SDMUSBQSS_PID	0xF448	/* Linx SDM-USB-QS-S */
 #define LINX_MASTERDEVEL2_PID   0xF449	/* Linx Master Development 2.0 */
 #define LINX_FUTURE_0_PID   0xF44A	/* Linx future device */
 #define LINX_FUTURE_1_PID   0xF44B	/* Linx future device */
 #define LINX_FUTURE_2_PID   0xF44C	/* Linx future device */
 /*
  * Oceanic product ids
  */
 #define FTDI_OCEANIC_PID	0xF460  /* Oceanic dive instrument */
 /*
  * SUUNTO product ids
  */
 #define FTDI_SUUNTO_SPORTS_PID	0xF680	/* Suunto Sports instrument */
 /* USB-UIRT - An infrared receiver and transmitter using the 8U232AM chip */
 /* http://www.usbuirt.com/ */
 #define FTDI_USB_UIRT_PID	0xF850	/* Product Id */
 /* CCS Inc. ICDU/ICDU40 product ID -
  * the FT232BM is used in an in-circuit-debugger unit for PIC16's/PIC18's */
 #define FTDI_CCSICDU20_0_PID    0xF9D0
 #define FTDI_CCSICDU40_1_PID    0xF9D1
 #define FTDI_CCSMACHX_2_PID     0xF9D2
 #define FTDI_CCSLOAD_N_GO_3_PID 0xF9D3
 #define FTDI_CCSICDU64_4_PID    0xF9D4
 #define FTDI_CCSPRIME8_5_PID    0xF9D5
 /*
  * The following are the values for the Matrix Orbital LCD displays,
  * which are the FT232BM ( similar to the 8U232AM )
  */
 #define FTDI_MTXORB_0_PID      0xFA00  /* Matrix Orbital Product Id */
 #define FTDI_MTXORB_1_PID      0xFA01  /* Matrix Orbital Product Id */
 #define FTDI_MTXORB_2_PID      0xFA02  /* Matrix Orbital Product Id */
 #define FTDI_MTXORB_3_PID      0xFA03  /* Matrix Orbital Product Id */
 #define FTDI_MTXORB_4_PID      0xFA04  /* Matrix Orbital Product Id */
 #define FTDI_MTXORB_5_PID      0xFA05  /* Matrix Orbital Product Id */
 #define FTDI_MTXORB_6_PID      0xFA06  /* Matrix Orbital Product Id */
 /*
  * Home Electronics (www.home-electro.com) USB gadgets
  */
 #define FTDI_HE_TIRA1_PID	0xFA78	/* Tira-1 IR transceiver */
 /* Inside Accesso contactless reader (http://www.insidecontactless.com/) */
 #define INSIDE_ACCESSO		0xFAD0
 /*
  * ThorLabs USB motor drivers
  */
 #define FTDI_THORLABS_PID		0xfaf0 /* ThorLabs USB motor drivers */
 /*
  * Protego product ids
  */
 #define PROTEGO_SPECIAL_1	0xFC70	/* special/unknown device */
 #define PROTEGO_R2X0		0xFC71	/* R200-USB TRNG unit (R210, R220, and R230) */
 #define PROTEGO_SPECIAL_3	0xFC72	/* special/unknown device */
 #define PROTEGO_SPECIAL_4	0xFC73	/* special/unknown device */
 /*
  * Sony Ericsson product ids
  */
 #define FTDI_DSS20_PID		0xFC82	/* DSS-20 Sync Station for Sony Ericsson P800 */
 #define FTDI_URBAN_0_PID	0xFC8A	/* Sony Ericsson Urban, uart #0 */
 #define FTDI_URBAN_1_PID	0xFC8B	/* Sony Ericsson Urban, uart #1 */
 /* www.irtrans.de device */
 #define FTDI_IRTRANS_PID 0xFC60 /* Product Id */
 /*
  * RM Michaelides CANview USB (http://www.rmcan.com) (FTDI_VID)
  * CAN fieldbus interface adapter, added by port GmbH www.port.de)
  * Ian Abbott changed the macro names for consistency.
  */
 #define FTDI_RM_CANVIEW_PID	0xfd60	/* Product Id */
 /* www.thoughttechnology.com/ TT-USB provide with procomp use ftdi_sio */
 #define FTDI_TTUSB_PID 0xFF20 /* Product Id */
 #define FTDI_USBX_707_PID 0xF857	/* ADSTech IR Blaster USBX-707 (FTDI_VID) */
 #define FTDI_RELAIS_PID	0xFA10  /* Relais device from Rudolf Gugler */
 /*
  * PCDJ use ftdi based dj-controllers. The following PID is
  * for their DAC-2 device http://www.pcdjhardware.com/DAC2.asp
  * (the VID is the standard ftdi vid (FTDI_VID), PID sent by Wouter Paesen)
  */
 #define FTDI_PCDJ_DAC2_PID 0xFA88
 #define FTDI_R2000KU_TRUE_RNG	0xFB80  /* R2000KU TRUE RNG (FTDI_VID) */
 /*
  * DIEBOLD BCS SE923 (FTDI_VID)
  */
 #define DIEBOLD_BCS_SE923_PID	0xfb99
 /* www.crystalfontz.com devices
  * - thanx for providing free devices for evaluation !
  * they use the ftdi chipset for the USB interface
  * and the vendor id is the same
  */
 #define FTDI_XF_632_PID 0xFC08	/* 632: 16x2 Character Display */
 #define FTDI_XF_634_PID 0xFC09	/* 634: 20x4 Character Display */
 #define FTDI_XF_547_PID 0xFC0A	/* 547: Two line Display */
 #define FTDI_XF_633_PID 0xFC0B	/* 633: 16x2 Character Display with Keys */
 #define FTDI_XF_631_PID 0xFC0C	/* 631: 20x2 Character Display */
 #define FTDI_XF_635_PID 0xFC0D	/* 635: 20x4 Character Display */
 #define FTDI_XF_640_PID 0xFC0E	/* 640: Two line Display */
 #define FTDI_XF_642_PID 0xFC0F	/* 642: Two line Display */
 /*
  * Video Networks Limited / Homechoice in the UK use an ftdi-based device
  * for their 1Mb broadband internet service.  The following PID is exhibited
  * by the usb device supplied (the VID is the standard ftdi vid (FTDI_VID)
  */
 #define FTDI_VNHCPCUSB_D_PID 0xfe38 /* Product Id */
 /* AlphaMicro Components AMC-232USB01 device (FTDI_VID) */
 #define FTDI_AMC232_PID 0xFF00 /* Product Id */
 /*
  * IBS elektronik product ids (FTDI_VID)
  * Submitted by Thomas Schleusener
  */
 #define FTDI_IBS_US485_PID	0xff38  /* IBS US485 (USB<-->RS422/485 interface) */
 #define FTDI_IBS_PICPRO_PID	0xff39  /* IBS PIC-Programmer */
 #define FTDI_IBS_PCMCIA_PID	0xff3a  /* IBS Card reader for PCMCIA SRAM-cards */
 #define FTDI_IBS_PK1_PID	0xff3b  /* IBS PK1 - Particel counter */
 #define FTDI_IBS_RS232MON_PID	0xff3c  /* IBS RS232 - Monitor */
 #define FTDI_IBS_APP70_PID	0xff3d  /* APP 70 (dust monitoring system) */
 #define FTDI_IBS_PEDO_PID	0xff3e  /* IBS PEDO-Modem (RF modem 868.35 MHz) */
 #define FTDI_IBS_PROD_PID	0xff3f  /* future device */
 /* www.canusb.com Lawicel CANUSB device (FTDI_VID) */
 #define FTDI_CANUSB_PID 0xFFA8 /* Product Id */
 /*
  * TavIR AVR product ids (FTDI_VID)
  */
 #define FTDI_TAVIR_STK500_PID	0xFA33	/* STK500 AVR programmer */
 /*
  * TIAO product ids (FTDI_VID)
  * http://www.tiaowiki.com/w/Main_Page
  */
 #define FTDI_TIAO_UMPA_PID	0x8a98	/* TIAO/DIYGADGET USB Multi-Protocol Adapter */
+/*
+ * NovaTech product ids (FTDI_VID)
+ */
+#define FTDI_NT_ORIONLXM_PID	0x7c90	/* OrionLXm Substation Automation Platform */
 /********************************/
 /** third-party VID/PID combos **/
 /********************************/
 /*
  * Atmel STK541
  */
 #define ATMEL_VID		0x03eb /* Vendor ID */
 #define STK541_PID		0x2109 /* Zigbee Controller */
 /*
  * Blackfin gnICE JTAG
  * http://docs.blackfin.uclinux.org/doku.php?id=hw:jtag:gnice
  */
 #define ADI_VID			0x0456
 #define ADI_GNICE_PID		0xF000
 #define ADI_GNICEPLUS_PID	0xF001
 /*
  * Microchip Technology, Inc.
  *
  * MICROCHIP_VID (0x04D8) and MICROCHIP_USB_BOARD_PID (0x000A) are
  * used by single function CDC ACM class based firmware demo
  * applications.  The VID/PID has also been used in firmware
  * emulating FTDI serial chips by:
  * Hornby Elite - Digital Command Control Console
  * http://www.hornby.com/hornby-dcc/controllers/
  */
 #define MICROCHIP_VID		0x04D8
 #define MICROCHIP_USB_BOARD_PID	0x000A /* CDC RS-232 Emulation Demo */
 /*
  * RATOC REX-USB60F
  */
 #define RATOC_VENDOR_ID		0x0584
 #define RATOC_PRODUCT_ID_USB60F	0xb020
 /*
  * Acton Research Corp.
  */
 #define ACTON_VID		0x0647	/* Vendor ID */
 #define ACTON_SPECTRAPRO_PID	0x0100
 /*
  * Contec products (http://www.contec.com)
  * Submitted by Daniel Sangorrin
  */
 #define CONTEC_VID		0x06CE	/* Vendor ID */
 #define CONTEC_COM1USBH_PID	0x8311	/* COM-1(USB)H */
 /*
  * Mitsubishi Electric Corp. (http://www.meau.com)
  * Submitted by Konstantin Holoborodko
  */
 #define MITSUBISHI_VID		0x06D3
 #define MITSUBISHI_FXUSB_PID	0x0284 /* USB/RS422 converters: FX-USB-AW/-BD */
 /*
  * Definitions for B&B Electronics products.
  */
 #define BANDB_VID		0x0856	/* B&B Electronics Vendor ID */
 #define BANDB_USOTL4_PID	0xAC01	/* USOTL4 Isolated RS-485 Converter */
 #define BANDB_USTL4_PID		0xAC02	/* USTL4 RS-485 Converter */
 #define BANDB_USO9ML2_PID	0xAC03	/* USO9ML2 Isolated RS-232 Converter */
 #define BANDB_USOPTL4_PID	0xAC11
 #define BANDB_USPTL4_PID	0xAC12
 #define BANDB_USO9ML2DR_2_PID	0xAC16
 #define BANDB_USO9ML2DR_PID	0xAC17
 #define BANDB_USOPTL4DR2_PID	0xAC18	/* USOPTL4R-2 2-port Isolated RS-232 Converter */
 #define BANDB_USOPTL4DR_PID	0xAC19
 #define BANDB_485USB9F_2W_PID	0xAC25
 #define BANDB_485USB9F_4W_PID	0xAC26
 #define BANDB_232USB9M_PID	0xAC27
 #define BANDB_485USBTB_2W_PID	0xAC33
 #define BANDB_485USBTB_4W_PID	0xAC34
 #define BANDB_TTL5USB9M_PID	0xAC49
 #define BANDB_TTL3USB9M_PID	0xAC50
 #define BANDB_ZZ_PROG1_USB_PID	0xBA02
 /*
  * Intrepid Control Systems (http://www.intrepidcs.com/) ValueCAN and NeoVI
  */
 #define INTREPID_VID		0x093C
 #define INTREPID_VALUECAN_PID	0x0601
 #define INTREPID_NEOVI_PID	0x0701
 /*
  * Definitions for ID TECH (www.idt-net.com) devices
  */
 #define IDTECH_VID		0x0ACD	/* ID TECH Vendor ID */
 #define IDTECH_IDT1221U_PID	0x0300	/* IDT1221U USB to RS-232 adapter */
 /*
  * Definitions for Omnidirectional Control Technology, Inc. devices
  */
 #define OCT_VID			0x0B39	/* OCT vendor ID */
 /* Note: OCT US101 is also rebadged as Dick Smith Electronics (NZ) XH6381 */
 /* Also rebadged as Dick Smith Electronics (Aus) XH6451 */
 /* Also rebadged as SIIG Inc. model US2308 hardware version 1 */
 #define OCT_DK201_PID		0x0103	/* OCT DK201 USB docking station */
 #define OCT_US101_PID		0x0421	/* OCT US101 USB to RS-232 */
 /*
  * Definitions for Icom Inc. devices
  */
 #define ICOM_VID		0x0C26 /* Icom vendor ID */
 /* Note: ID-1 is a communications tranceiver for HAM-radio operators */
 #define ICOM_ID_1_PID		0x0004 /* ID-1 USB to RS-232 */
 /* Note: OPC is an Optional cable to connect an Icom Tranceiver */
 #define ICOM_OPC_U_UC_PID	0x0018 /* OPC-478UC, OPC-1122U cloning cable */
 /* Note: ID-RP* devices are Icom Repeater Devices for HAM-radio */
 #define ICOM_ID_RP2C1_PID	0x0009 /* ID-RP2C Asset 1 to RS-232 */
 #define ICOM_ID_RP2C2_PID	0x000A /* ID-RP2C Asset 2 to RS-232 */
 #define ICOM_ID_RP2D_PID	0x000B /* ID-RP2D configuration port*/
 #define ICOM_ID_RP2VT_PID	0x000C /* ID-RP2V Transmit config port */
 #define ICOM_ID_RP2VR_PID	0x000D /* ID-RP2V Receive config port */
 #define ICOM_ID_RP4KVT_PID	0x0010 /* ID-RP4000V Transmit config port */
 #define ICOM_ID_RP4KVR_PID	0x0011 /* ID-RP4000V Receive config port */
 #define ICOM_ID_RP2KVT_PID	0x0012 /* ID-RP2000V Transmit config port */
 #define ICOM_ID_RP2KVR_PID	0x0013 /* ID-RP2000V Receive config port */
 /*
  * GN Otometrics (http://www.otometrics.com)
  * Submitted by Ville Sundberg.
  */
 #define GN_OTOMETRICS_VID	0x0c33	/* Vendor ID */
 #define AURICAL_USB_PID		0x0010	/* Aurical USB Audiometer */
 /*
  * The following are the values for the Sealevel SeaLINK+ adapters.
  * (Original list sent by Tuan Hoang.  Ian Abbott renamed the macros and
  * removed some PIDs that don't seem to match any existing products.)
  */
 #define SEALEVEL_VID		0x0c52	/* Sealevel Vendor ID */
 #define SEALEVEL_2101_PID	0x2101	/* SeaLINK+232 (2101/2105) */
 #define SEALEVEL_2102_PID	0x2102	/* SeaLINK+485 (2102) */
 #define SEALEVEL_2103_PID	0x2103	/* SeaLINK+232I (2103) */
 #define SEALEVEL_2104_PID	0x2104	/* SeaLINK+485I (2104) */
 #define SEALEVEL_2106_PID	0x9020	/* SeaLINK+422 (2106) */
 #define SEALEVEL_2201_1_PID	0x2211	/* SeaPORT+2/232 (2201) Port 1 */
 #define SEALEVEL_2201_2_PID	0x2221	/* SeaPORT+2/232 (2201) Port 2 */
 #define SEALEVEL_2202_1_PID	0x2212	/* SeaPORT+2/485 (2202) Port 1 */
 #define SEALEVEL_2202_2_PID	0x2222	/* SeaPORT+2/485 (2202) Port 2 */
 #define SEALEVEL_2203_1_PID	0x2213	/* SeaPORT+2 (2203) Port 1 */
 #define SEALEVEL_2203_2_PID	0x2223	/* SeaPORT+2 (2203) Port 2 */
 #define SEALEVEL_2401_1_PID	0x2411	/* SeaPORT+4/232 (2401) Port 1 */
 #define SEALEVEL_2401_2_PID	0x2421	/* SeaPORT+4/232 (2401) Port 2 */
 #define SEALEVEL_2401_3_PID	0x2431	/* SeaPORT+4/232 (2401) Port 3 */
 #define SEALEVEL_2401_4_PID	0x2441	/* SeaPORT+4/232 (2401) Port 4 */
 #define SEALEVEL_2402_1_PID	0x2412	/* SeaPORT+4/485 (2402) Port 1 */
 #define SEALEVEL_2402_2_PID	0x2422	/* SeaPORT+4/485 (2402) Port 2 */
 #define SEALEVEL_2402_3_PID	0x2432	/* SeaPORT+4/485 (2402) Port 3 */
 #define SEALEVEL_2402_4_PID	0x2442	/* SeaPORT+4/485 (2402) Port 4 */
 #define SEALEVEL_2403_1_PID	0x2413	/* SeaPORT+4 (2403) Port 1 */
 #define SEALEVEL_2403_2_PID	0x2423	/* SeaPORT+4 (2403) Port 2 */
 #define SEALEVEL_2403_3_PID	0x2433	/* SeaPORT+4 (2403) Port 3 */
 #define SEALEVEL_2403_4_PID	0x2443	/* SeaPORT+4 (2403) Port 4 */
 #define SEALEVEL_2801_1_PID	0X2811	/* SeaLINK+8/232 (2801) Port 1 */
 #define SEALEVEL_2801_2_PID	0X2821	/* SeaLINK+8/232 (2801) Port 2 */
 #define SEALEVEL_2801_3_PID	0X2831	/* SeaLINK+8/232 (2801) Port 3 */
 #define SEALEVEL_2801_4_PID	0X2841	/* SeaLINK+8/232 (2801) Port 4 */
 #define SEALEVEL_2801_5_PID	0X2851	/* SeaLINK+8/232 (2801) Port 5 */
 #define SEALEVEL_2801_6_PID	0X2861	/* SeaLINK+8/232 (2801) Port 6 */
 #define SEALEVEL_2801_7_PID	0X2871	/* SeaLINK+8/232 (2801) Port 7 */
 #define SEALEVEL_2801_8_PID	0X2881	/* SeaLINK+8/232 (2801) Port 8 */
 #define SEALEVEL_2802_1_PID	0X2812	/* SeaLINK+8/485 (2802) Port 1 */
 #define SEALEVEL_2802_2_PID	0X2822	/* SeaLINK+8/485 (2802) Port 2 */
 #define SEALEVEL_2802_3_PID	0X2832	/* SeaLINK+8/485 (2802) Port 3 */
 #define SEALEVEL_2802_4_PID	0X2842	/* SeaLINK+8/485 (2802) Port 4 */
 #define SEALEVEL_2802_5_PID	0X2852	/* SeaLINK+8/485 (2802) Port 5 */
 #define SEALEVEL_2802_6_PID	0X2862	/* SeaLINK+8/485 (2802) Port 6 */
 #define SEALEVEL_2802_7_PID	0X2872	/* SeaLINK+8/485 (2802) Port 7 */
 #define SEALEVEL_2802_8_PID	0X2882	/* SeaLINK+8/485 (2802) Port 8 */
 #define SEALEVEL_2803_1_PID	0X2813	/* SeaLINK+8 (2803) Port 1 */
 #define SEALEVEL_2803_2_PID	0X2823	/* SeaLINK+8 (2803) Port 2 */
 #define SEALEVEL_2803_3_PID	0X2833	/* SeaLINK+8 (2803) Port 3 */
 #define SEALEVEL_2803_4_PID	0X2843	/* SeaLINK+8 (2803) Port 4 */
 #define SEALEVEL_2803_5_PID	0X2853	/* SeaLINK+8 (2803) Port 5 */
 #define SEALEVEL_2803_6_PID	0X2863	/* SeaLINK+8 (2803) Port 6 */
 #define SEALEVEL_2803_7_PID	0X2873	/* SeaLINK+8 (2803) Port 7 */
 #define SEALEVEL_2803_8_PID	0X2883	/* SeaLINK+8 (2803) Port 8 */
 #define SEALEVEL_2803R_1_PID	0Xa02a	/* SeaLINK+8 (2803-ROHS) Port 1+2 */
 #define SEALEVEL_2803R_2_PID	0Xa02b	/* SeaLINK+8 (2803-ROHS) Port 3+4 */
 #define SEALEVEL_2803R_3_PID	0Xa02c	/* SeaLINK+8 (2803-ROHS) Port 5+6 */
 #define SEALEVEL_2803R_4_PID	0Xa02d	/* SeaLINK+8 (2803-ROHS) Port 7+8 */
 /*
  * JETI SPECTROMETER SPECBOS 1201
  * http://www.jeti.com/cms/index.php/instruments/other-instruments/specbos-2101
  */
 #define JETI_VID		0x0c6c
 #define JETI_SPC1201_PID	0x04b2
 /*
  * FTDI USB UART chips used in construction projects from the
  * Elektor Electronics magazine (http://www.elektor.com/)
  */
 #define ELEKTOR_VID		0x0C7D
 #define ELEKTOR_FT323R_PID	0x0005	/* RFID-Reader, issue 09-2006 */
 /*
  * Posiflex inc retail equipment (http://www.posiflex.com.tw)
  */
 #define POSIFLEX_VID		0x0d3a  /* Vendor ID */
 #define POSIFLEX_PP7000_PID	0x0300  /* PP-7000II thermal printer */
 /*
  * The following are the values for two KOBIL chipcard terminals.
  */
 #define KOBIL_VID		0x0d46	/* KOBIL Vendor ID */
 #define KOBIL_CONV_B1_PID	0x2020	/* KOBIL Konverter for B1 */
 #define KOBIL_CONV_KAAN_PID	0x2021	/* KOBIL_Konverter for KAAN */
 #define FTDI_NF_RIC_VID	0x0DCD	/* Vendor Id */
 #define FTDI_NF_RIC_PID	0x0001	/* Product Id */
 /*
  * Falcom Wireless Communications GmbH
  */
 #define FALCOM_VID		0x0F94	/* Vendor Id */
 #define FALCOM_TWIST_PID	0x0001	/* Falcom Twist USB GPRS modem */
 #define FALCOM_SAMBA_PID	0x0005	/* Falcom Samba USB GPRS modem */
 /* Larsen and Brusgaard AltiTrack/USBtrack */
 #define LARSENBRUSGAARD_VID		0x0FD8
 #define LB_ALTITRACK_PID		0x0001
 /*
  * TTi (Thurlby Thandar Instruments)
  */
 #define TTI_VID			0x103E	/* Vendor Id */
 #define TTI_QL355P_PID		0x03E8	/* TTi QL355P power supply */
 /*
  * Newport Cooperation (www.newport.com)
  */
 #define NEWPORT_VID			0x104D
 #define NEWPORT_AGILIS_PID		0x3000
 #define NEWPORT_CONEX_CC_PID		0x3002
 #define NEWPORT_CONEX_AGP_PID		0x3006
 /* Interbiometrics USB I/O Board */
 /* Developed for Interbiometrics by Rudolf Gugler */
 #define INTERBIOMETRICS_VID              0x1209
 #define INTERBIOMETRICS_IOBOARD_PID      0x1002
 #define INTERBIOMETRICS_MINI_IOBOARD_PID 0x1006
 /*
  * Testo products (http://www.testo.com/)
  * Submitted by Colin Leroy
  */
 #define TESTO_VID			0x128D
 #define TESTO_USB_INTERFACE_PID		0x0001
 /*
  * Mobility Electronics products.
  */
 #define MOBILITY_VID			0x1342
 #define MOBILITY_USB_SERIAL_PID		0x0202	/* EasiDock USB 200 serial */
 /*
  * FIC / OpenMoko, Inc. http://wiki.openmoko.org/wiki/Neo1973_Debug_Board_v3
  * Submitted by Harald Welte <laforge@openmoko.org>
  */
 #define	FIC_VID			0x1457
 #define	FIC_NEO1973_DEBUG_PID	0x5118
 /* Olimex */
 #define OLIMEX_VID			0x15BA
 #define OLIMEX_ARM_USB_OCD_PID		0x0003
 #define OLIMEX_ARM_USB_OCD_H_PID	0x002b
 /*
  * Telldus Technologies
  */
 #define TELLDUS_VID			0x1781	/* Vendor ID */
 #define TELLDUS_TELLSTICK_PID		0x0C30	/* RF control dongle 433 MHz using FT232RL */
 /*
  * RT Systems programming cables for various ham radios
  */
 #define RTSYSTEMS_VID		0x2100	/* Vendor ID */
 #define RTSYSTEMS_USB_S03_PID	0x9001	/* RTS-03 USB to Serial Adapter */
 #define RTSYSTEMS_USB_59_PID	0x9e50	/* USB-59 USB to 8 pin plug */
 #define RTSYSTEMS_USB_57A_PID	0x9e51	/* USB-57A USB to 4pin 3.5mm plug */
 #define RTSYSTEMS_USB_57B_PID	0x9e52	/* USB-57B USB to extended 4pin 3.5mm plug */
 #define RTSYSTEMS_USB_29A_PID	0x9e53	/* USB-29A USB to 3.5mm stereo plug */
 #define RTSYSTEMS_USB_29B_PID	0x9e54	/* USB-29B USB to 6 pin mini din */
 #define RTSYSTEMS_USB_29F_PID	0x9e55	/* USB-29F USB to 6 pin modular plug */
 #define RTSYSTEMS_USB_62B_PID	0x9e56	/* USB-62B USB to 8 pin mini din plug*/
 #define RTSYSTEMS_USB_S01_PID	0x9e57	/* USB-RTS01 USB to 3.5 mm stereo plug*/
 #define RTSYSTEMS_USB_63_PID	0x9e58	/* USB-63 USB to 9 pin female*/
 #define RTSYSTEMS_USB_29C_PID	0x9e59	/* USB-29C USB to 4 pin modular plug*/
 #define RTSYSTEMS_USB_81B_PID	0x9e5A	/* USB-81 USB to 8 pin mini din plug*/
 #define RTSYSTEMS_USB_82B_PID	0x9e5B	/* USB-82 USB to 2.5 mm stereo plug*/
 #define RTSYSTEMS_USB_K5D_PID	0x9e5C	/* USB-K5D USB to 8 pin modular plug*/
 #define RTSYSTEMS_USB_K4Y_PID	0x9e5D	/* USB-K4Y USB to 2.5/3.5 mm plugs*/
 #define RTSYSTEMS_USB_K5G_PID	0x9e5E	/* USB-K5G USB to 8 pin modular plug*/
 #define RTSYSTEMS_USB_S05_PID	0x9e5F	/* USB-RTS05 USB to 2.5 mm stereo plug*/
 #define RTSYSTEMS_USB_60_PID	0x9e60	/* USB-60 USB to 6 pin din*/
 #define RTSYSTEMS_USB_61_PID	0x9e61	/* USB-61 USB to 6 pin mini din*/
 #define RTSYSTEMS_USB_62_PID	0x9e62	/* USB-62 USB to 8 pin mini din*/
 #define RTSYSTEMS_USB_63B_PID	0x9e63	/* USB-63 USB to 9 pin female*/
 #define RTSYSTEMS_USB_64_PID	0x9e64	/* USB-64 USB to 9 pin male*/
 #define RTSYSTEMS_USB_65_PID	0x9e65	/* USB-65 USB to 9 pin female null modem*/
 #define RTSYSTEMS_USB_92_PID	0x9e66	/* USB-92 USB to 12 pin plug*/
 #define RTSYSTEMS_USB_92D_PID	0x9e67	/* USB-92D USB to 12 pin plug data*/
 #define RTSYSTEMS_USB_W5R_PID	0x9e68	/* USB-W5R USB to 8 pin modular plug*/
 #define RTSYSTEMS_USB_A5R_PID	0x9e69	/* USB-A5R USB to 8 pin modular plug*/
 #define RTSYSTEMS_USB_PW1_PID	0x9e6A	/* USB-PW1 USB to 8 pin modular plug*/
 /*
  * Physik Instrumente
  * http://www.physikinstrumente.com/en/products/
  */
 /* These two devices use the VID of FTDI */
 #define PI_C865_PID	0xe0a0  /* PI C-865 Piezomotor Controller */
 #define PI_C857_PID	0xe0a1  /* PI Encoder Trigger Box */
 #define PI_VID              0x1a72  /* Vendor ID */
 #define PI_C866_PID	0x1000  /* PI C-866 Piezomotor Controller */
 #define PI_C663_PID	0x1001  /* PI C-663 Mercury-Step */
 #define PI_C725_PID	0x1002  /* PI C-725 Piezomotor Controller */
 #define PI_E517_PID	0x1005  /* PI E-517 Digital Piezo Controller Operation Module */
 #define PI_C863_PID	0x1007  /* PI C-863 */
 #define PI_E861_PID	0x1008  /* PI E-861 Piezomotor Controller */
 #define PI_C867_PID	0x1009  /* PI C-867 Piezomotor Controller */
 #define PI_E609_PID	0x100D  /* PI E-609 Digital Piezo Controller */
 #define PI_E709_PID	0x100E  /* PI E-709 Digital Piezo Controller */
 #define PI_100F_PID	0x100F  /* PI Digital Piezo Controller */
 #define PI_1011_PID	0x1011  /* PI Digital Piezo Controller */
 #define PI_1012_PID	0x1012  /* PI Motion Controller */
 #define PI_1013_PID	0x1013  /* PI Motion Controller */
 #define PI_1014_PID	0x1014  /* PI Device */
 #define PI_1015_PID	0x1015  /* PI Device */
 #define PI_1016_PID	0x1016  /* PI Digital Servo Module */
 /*
  * Kondo Kagaku Co.Ltd.
  * http://www.kondo-robot.com/EN
  */
 #define KONDO_VID 		0x165c
 #define KONDO_USB_SERIAL_PID	0x0002
 /*
  * Bayer Ascensia Contour blood glucose meter USB-converter cable.
  * http://winglucofacts.com/cables/
  */
 #define BAYER_VID                      0x1A79
 #define BAYER_CONTOUR_CABLE_PID        0x6001
 /*
  * The following are the values for the Matrix Orbital FTDI Range
  * Anything in this range will use an FT232RL.
  */
 #define MTXORB_VID			0x1B3D
 #define MTXORB_FTDI_RANGE_0100_PID	0x0100
 #define MTXORB_FTDI_RANGE_0101_PID	0x0101
 #define MTXORB_FTDI_RANGE_0102_PID	0x0102
 #define MTXORB_FTDI_RANGE_0103_PID	0x0103
 #define MTXORB_FTDI_RANGE_0104_PID	0x0104
 #define MTXORB_FTDI_RANGE_0105_PID	0x0105
 #define MTXORB_FTDI_RANGE_0106_PID	0x0106
 #define MTXORB_FTDI_RANGE_0107_PID	0x0107
 #define MTXORB_FTDI_RANGE_0108_PID	0x0108
 #define MTXORB_FTDI_RANGE_0109_PID	0x0109
 #define MTXORB_FTDI_RANGE_010A_PID	0x010A
 #define MTXORB_FTDI_RANGE_010B_PID	0x010B
 #define MTXORB_FTDI_RANGE_010C_PID	0x010C
 #define MTXORB_FTDI_RANGE_010D_PID	0x010D
 #define MTXORB_FTDI_RANGE_010E_PID	0x010E
 #define MTXORB_FTDI_RANGE_010F_PID	0x010F
 #define MTXORB_FTDI_RANGE_0110_PID	0x0110
 #define MTXORB_FTDI_RANGE_0111_PID	0x0111
 #define MTXORB_FTDI_RANGE_0112_PID	0x0112
 #define MTXORB_FTDI_RANGE_0113_PID	0x0113
 #define MTXORB_FTDI_RANGE_0114_PID	0x0114
 #define MTXORB_FTDI_RANGE_0115_PID	0x0115
 #define MTXORB_FTDI_RANGE_0116_PID	0x0116
 #define MTXORB_FTDI_RANGE_0117_PID	0x0117
 #define MTXORB_FTDI_RANGE_0118_PID	0x0118
 #define MTXORB_FTDI_RANGE_0119_PID	0x0119
 #define MTXORB_FTDI_RANGE_011A_PID	0x011A
 #define MTXORB_FTDI_RANGE_011B_PID	0x011B
 #define MTXORB_FTDI_RANGE_011C_PID	0x011C
 #define MTXORB_FTDI_RANGE_011D_PID	0x011D
 #define MTXORB_FTDI_RANGE_011E_PID	0x011E
 #define MTXORB_FTDI_RANGE_011F_PID	0x011F
 #define MTXORB_FTDI_RANGE_0120_PID	0x0120
 #define MTXORB_FTDI_RANGE_0121_PID	0x0121
 #define MTXORB_FTDI_RANGE_0122_PID	0x0122
 #define MTXORB_FTDI_RANGE_0123_PID	0x0123
 #define MTXORB_FTDI_RANGE_0124_PID	0x0124
 #define MTXORB_FTDI_RANGE_0125_PID	0x0125
 #define MTXORB_FTDI_RANGE_0126_PID	0x0126
 #define MTXORB_FTDI_RANGE_0127_PID	0x0127
 #define MTXORB_FTDI_RANGE_0128_PID	0x0128
 #define MTXORB_FTDI_RANGE_0129_PID	0x0129
 #define MTXORB_FTDI_RANGE_012A_PID	0x012A
 #define MTXORB_FTDI_RANGE_012B_PID	0x012B
 #define MTXORB_FTDI_RANGE_012C_PID	0x012C
 #define MTXORB_FTDI_RANGE_012D_PID	0x012D
 #define MTXORB_FTDI_RANGE_012E_PID	0x012E
 #define MTXORB_FTDI_RANGE_012F_PID	0x012F
 #define MTXORB_FTDI_RANGE_0130_PID	0x0130
 #define MTXORB_FTDI_RANGE_0131_PID	0x0131
 #define MTXORB_FTDI_RANGE_0132_PID	0x0132
 #define MTXORB_FTDI_RANGE_0133_PID	0x0133
 #define MTXORB_FTDI_RANGE_0134_PID	0x0134
 #define MTXORB_FTDI_RANGE_0135_PID	0x0135
 #define MTXORB_FTDI_RANGE_0136_PID	0x0136
 #define MTXORB_FTDI_RANGE_0137_PID	0x0137
 #define MTXORB_FTDI_RANGE_0138_PID	0x0138
 #define MTXORB_FTDI_RANGE_0139_PID	0x0139
 #define MTXORB_FTDI_RANGE_013A_PID	0x013A
 #define MTXORB_FTDI_RANGE_013B_PID	0x013B
 #define MTXORB_FTDI_RANGE_013C_PID	0x013C
 #define MTXORB_FTDI_RANGE_013D_PID	0x013D
 #define MTXORB_FTDI_RANGE_013E_PID	0x013E
 #define MTXORB_FTDI_RANGE_013F_PID	0x013F
 #define MTXORB_FTDI_RANGE_0140_PID	0x0140
 #define MTXORB_FTDI_RANGE_0141_PID	0x0141
 #define MTXORB_FTDI_RANGE_0142_PID	0x0142
 #define MTXORB_FTDI_RANGE_0143_PID	0x0143
 #define MTXORB_FTDI_RANGE_0144_PID	0x0144
 #define MTXORB_FTDI_RANGE_0145_PID	0x0145
 #define MTXORB_FTDI_RANGE_0146_PID	0x0146
 #define MTXORB_FTDI_RANGE_0147_PID	0x0147
 #define MTXORB_FTDI_RANGE_0148_PID	0x0148
 #define MTXORB_FTDI_RANGE_0149_PID	0x0149
 #define MTXORB_FTDI_RANGE_014A_PID	0x014A
 #define MTXORB_FTDI_RANGE_014B_PID	0x014B
 #define MTXORB_FTDI_RANGE_014C_PID	0x014C
 #define MTXORB_FTDI_RANGE_014D_PID	0x014D
 #define MTXORB_FTDI_RANGE_014E_PID	0x014E
 #define MTXORB_FTDI_RANGE_014F_PID	0x014F
 #define MTXORB_FTDI_RANGE_0150_PID	0x0150
 #define MTXORB_FTDI_RANGE_0151_PID	0x0151
 #define MTXORB_FTDI_RANGE_0152_PID	0x0152
 #define MTXORB_FTDI_RANGE_0153_PID	0x0153
 #define MTXORB_FTDI_RANGE_0154_PID	0x0154
 #define MTXORB_FTDI_RANGE_0155_PID	0x0155
 #define MTXORB_FTDI_RANGE_0156_PID	0x0156
 #define MTXORB_FTDI_RANGE_0157_PID	0x0157
 #define MTXORB_FTDI_RANGE_0158_PID	0x0158
 #define MTXORB_FTDI_RANGE_0159_PID	0x0159
 #define MTXORB_FTDI_RANGE_015A_PID	0x015A
 #define MTXORB_FTDI_RANGE_015B_PID	0x015B
 #define MTXORB_FTDI_RANGE_015C_PID	0x015C
 #define MTXORB_FTDI_RANGE_015D_PID	0x015D
 #define MTXORB_FTDI_RANGE_015E_PID	0x015E
 #define MTXORB_FTDI_RANGE_015F_PID	0x015F
 #define MTXORB_FTDI_RANGE_0160_PID	0x0160
 #define MTXORB_FTDI_RANGE_0161_PID	0x0161
 #define MTXORB_FTDI_RANGE_0162_PID	0x0162
 #define MTXORB_FTDI_RANGE_0163_PID	0x0163
 #define MTXORB_FTDI_RANGE_0164_PID	0x0164
 #define MTXORB_FTDI_RANGE_0165_PID	0x0165
 #define MTXORB_FTDI_RANGE_0166_PID	0x0166
 #define MTXORB_FTDI_RANGE_0167_PID	0x0167
 #define MTXORB_FTDI_RANGE_0168_PID	0x0168
 #define MTXORB_FTDI_RANGE_0169_PID	0x0169
 #define MTXORB_FTDI_RANGE_016A_PID	0x016A
 #define MTXORB_FTDI_RANGE_016B_PID	0x016B
 #define MTXORB_FTDI_RANGE_016C_PID	0x016C
 #define MTXORB_FTDI_RANGE_016D_PID	0x016D
 #define MTXORB_FTDI_RANGE_016E_PID	0x016E
 #define MTXORB_FTDI_RANGE_016F_PID	0x016F
 #define MTXORB_FTDI_RANGE_0170_PID	0x0170
 #define MTXORB_FTDI_RANGE_0171_PID	0x0171
 #define MTXORB_FTDI_RANGE_0172_PID	0x0172
 #define MTXORB_FTDI_RANGE_0173_PID	0x0173
 #define MTXORB_FTDI_RANGE_0174_PID	0x0174
 #define MTXORB_FTDI_RANGE_0175_PID	0x0175
 #define MTXORB_FTDI_RANGE_0176_PID	0x0176
 #define MTXORB_FTDI_RANGE_0177_PID	0x0177
 #define MTXORB_FTDI_RANGE_0178_PID	0x0178
 #define MTXORB_FTDI_RANGE_0179_PID	0x0179
 #define MTXORB_FTDI_RANGE_017A_PID	0x017A
 #define MTXORB_FTDI_RANGE_017B_PID	0x017B
 #define MTXORB_FTDI_RANGE_017C_PID	0x017C
 #define MTXORB_FTDI_RANGE_017D_PID	0x017D
 #define MTXORB_FTDI_RANGE_017E_PID	0x017E
 #define MTXORB_FTDI_RANGE_017F_PID	0x017F
 #define MTXORB_FTDI_RANGE_0180_PID	0x0180
 #define MTXORB_FTDI_RANGE_0181_PID	0x0181
 #define MTXORB_FTDI_RANGE_0182_PID	0x0182
 #define MTXORB_FTDI_RANGE_0183_PID	0x0183
 #define MTXORB_FTDI_RANGE_0184_PID	0x0184
 #define MTXORB_FTDI_RANGE_0185_PID	0x0185
 #define MTXORB_FTDI_RANGE_0186_PID	0x0186
 #define MTXORB_FTDI_RANGE_0187_PID	0x0187
 #define MTXORB_FTDI_RANGE_0188_PID	0x0188
 #define MTXORB_FTDI_RANGE_0189_PID	0x0189
 #define MTXORB_FTDI_RANGE_018A_PID	0x018A
 #define MTXORB_FTDI_RANGE_018B_PID	0x018B
 #define MTXORB_FTDI_RANGE_018C_PID	0x018C
 #define MTXORB_FTDI_RANGE_018D_PID	0x018D
 #define MTXORB_FTDI_RANGE_018E_PID	0x018E
 #define MTXORB_FTDI_RANGE_018F_PID	0x018F
 #define MTXORB_FTDI_RANGE_0190_PID	0x0190
 #define MTXORB_FTDI_RANGE_0191_PID	0x0191
 #define MTXORB_FTDI_RANGE_0192_PID	0x0192
 #define MTXORB_FTDI_RANGE_0193_PID	0x0193
 #define MTXORB_FTDI_RANGE_0194_PID	0x0194
 #define MTXORB_FTDI_RANGE_0195_PID	0x0195
 #define MTXORB_FTDI_RANGE_0196_PID	0x0196
 #define MTXORB_FTDI_RANGE_0197_PID	0x0197
 #define MTXORB_FTDI_RANGE_0198_PID	0x0198
 #define MTXORB_FTDI_RANGE_0199_PID	0x0199
 #define MTXORB_FTDI_RANGE_019A_PID	0x019A
 #define MTXORB_FTDI_RANGE_019B_PID	0x019B
 #define MTXORB_FTDI_RANGE_019C_PID	0x019C
 #define MTXORB_FTDI_RANGE_019D_PID	0x019D
 #define MTXORB_FTDI_RANGE_019E_PID	0x019E
 #define MTXORB_FTDI_RANGE_019F_PID	0x019F
 #define MTXORB_FTDI_RANGE_01A0_PID	0x01A0
 #define MTXORB_FTDI_RANGE_01A1_PID	0x01A1
 #define MTXORB_FTDI_RANGE_01A2_PID	0x01A2
 #define MTXORB_FTDI_RANGE_01A3_PID	0x01A3
 #define MTXORB_FTDI_RANGE_01A4_PID	0x01A4
 #define MTXORB_FTDI_RANGE_01A5_PID	0x01A5
 #define MTXORB_FTDI_RANGE_01A6_PID	0x01A6
 #define MTXORB_FTDI_RANGE_01A7_PID	0x01A7
 #define MTXORB_FTDI_RANGE_01A8_PID	0x01A8
 #define MTXORB_FTDI_RANGE_01A9_PID	0x01A9
 #define MTXORB_FTDI_RANGE_01AA_PID	0x01AA
 #define MTXORB_FTDI_RANGE_01AB_PID	0x01AB
 #define MTXORB_FTDI_RANGE_01AC_PID	0x01AC
 #define MTXORB_FTDI_RANGE_01AD_PID	0x01AD
 #define MTXORB_FTDI_RANGE_01AE_PID	0x01AE
 #define MTXORB_FTDI_RANGE_01AF_PID	0x01AF
 #define MTXORB_FTDI_RANGE_01B0_PID	0x01B0
 #define MTXORB_FTDI_RANGE_01B1_PID	0x01B1
 #define MTXORB_FTDI_RANGE_01B2_PID	0x01B2
 #define MTXORB_FTDI_RANGE_01B3_PID	0x01B3
 #define MTXORB_FTDI_RANGE_01B4_PID	0x01B4
 #define MTXORB_FTDI_RANGE_01B5_PID	0x01B5
 #define MTXORB_FTDI_RANGE_01B6_PID	0x01B6
 #define MTXORB_FTDI_RANGE_01B7_PID	0x01B7
 #define MTXORB_FTDI_RANGE_01B8_PID	0x01B8
 #define MTXORB_FTDI_RANGE_01B9_PID	0x01B9
 #define MTXORB_FTDI_RANGE_01BA_PID	0x01BA
 #define MTXORB_FTDI_RANGE_01BB_PID	0x01BB
 #define MTXORB_FTDI_RANGE_01BC_PID	0x01BC
 #define MTXORB_FTDI_RANGE_01BD_PID	0x01BD
 #define MTXORB_FTDI_RANGE_01BE_PID	0x01BE
 #define MTXORB_FTDI_RANGE_01BF_PID	0x01BF
 #define MTXORB_FTDI_RANGE_01C0_PID	0x01C0
 #define MTXORB_FTDI_RANGE_01C1_PID	0x01C1
 #define MTXORB_FTDI_RANGE_01C2_PID	0x01C2
 #define MTXORB_FTDI_RANGE_01C3_PID	0x01C3
 #define MTXORB_FTDI_RANGE_01C4_PID	0x01C4
 #define MTXORB_FTDI_RANGE_01C5_PID	0x01C5
 #define MTXORB_FTDI_RANGE_01C6_PID	0x01C6
 #define MTXORB_FTDI_RANGE_01C7_PID	0x01C7
 #define MTXORB_FTDI_RANGE_01C8_PID	0x01C8
 #define MTXORB_FTDI_RANGE_01C9_PID	0x01C9
 #define MTXORB_FTDI_RANGE_01CA_PID	0x01CA
 #define MTXORB_FTDI_RANGE_01CB_PID	0x01CB
 #define MTXORB_FTDI_RANGE_01CC_PID	0x01CC
 #define MTXORB_FTDI_RANGE_01CD_PID	0x01CD
 #define MTXORB_FTDI_RANGE_01CE_PID	0x01CE
 #define MTXORB_FTDI_RANGE_01CF_PID	0x01CF
 #define MTXORB_FTDI_RANGE_01D0_PID	0x01D0
 #define MTXORB_FTDI_RANGE_01D1_PID	0x01D1
 #define MTXORB_FTDI_RANGE_01D2_PID	0x01D2
 #define MTXORB_FTDI_RANGE_01D3_PID	0x01D3
 #define MTXORB_FTDI_RANGE_01D4_PID	0x01D4
 #define MTXORB_FTDI_RANGE_01D5_PID	0x01D5
 #define MTXORB_FTDI_RANGE_01D6_PID	0x01D6
 #define MTXORB_FTDI_RANGE_01D7_PID	0x01D7
 #define MTXORB_FTDI_RANGE_01D8_PID	0x01D8
 #define MTXORB_FTDI_RANGE_01D9_PID	0x01D9
 #define MTXORB_FTDI_RANGE_01DA_PID	0x01DA
 #define MTXORB_FTDI_RANGE_01DB_PID	0x01DB
 #define MTXORB_FTDI_RANGE_01DC_PID	0x01DC
 #define MTXORB_FTDI_RANGE_01DD_PID	0x01DD
 #define MTXORB_FTDI_RANGE_01DE_PID	0x01DE
 #define MTXORB_FTDI_RANGE_01DF_PID	0x01DF
 #define MTXORB_FTDI_RANGE_01E0_PID	0x01E0
 #define MTXORB_FTDI_RANGE_01E1_PID	0x01E1
 #define MTXORB_FTDI_RANGE_01E2_PID	0x01E2
 #define MTXORB_FTDI_RANGE_01E3_PID	0x01E3
 #define MTXORB_FTDI_RANGE_01E4_PID	0x01E4
 #define MTXORB_FTDI_RANGE_01E5_PID	0x01E5
 #define MTXORB_FTDI_RANGE_01E6_PID	0x01E6
 #define MTXORB_FTDI_RANGE_01E7_PID	0x01E7
 #define MTXORB_FTDI_RANGE_01E8_PID	0x01E8
 #define MTXORB_FTDI_RANGE_01E9_PID	0x01E9
 #define MTXORB_FTDI_RANGE_01EA_PID	0x01EA
 #define MTXORB_FTDI_RANGE_01EB_PID	0x01EB
 #define MTXORB_FTDI_RANGE_01EC_PID	0x01EC
 #define MTXORB_FTDI_RANGE_01ED_PID	0x01ED
 #define MTXORB_FTDI_RANGE_01EE_PID	0x01EE
 #define MTXORB_FTDI_RANGE_01EF_PID	0x01EF
 #define MTXORB_FTDI_RANGE_01F0_PID	0x01F0
 #define MTXORB_FTDI_RANGE_01F1_PID	0x01F1
 #define MTXORB_FTDI_RANGE_01F2_PID	0x01F2
 #define MTXORB_FTDI_RANGE_01F3_PID	0x01F3
 #define MTXORB_FTDI_RANGE_01F4_PID	0x01F4
 #define MTXORB_FTDI_RANGE_01F5_PID	0x01F5
 #define MTXORB_FTDI_RANGE_01F6_PID	0x01F6
 #define MTXORB_FTDI_RANGE_01F7_PID	0x01F7
 #define MTXORB_FTDI_RANGE_01F8_PID	0x01F8
 #define MTXORB_FTDI_RANGE_01F9_PID	0x01F9
 #define MTXORB_FTDI_RANGE_01FA_PID	0x01FA
 #define MTXORB_FTDI_RANGE_01FB_PID	0x01FB
 #define MTXORB_FTDI_RANGE_01FC_PID	0x01FC
 #define MTXORB_FTDI_RANGE_01FD_PID	0x01FD
 #define MTXORB_FTDI_RANGE_01FE_PID	0x01FE
 #define MTXORB_FTDI_RANGE_01FF_PID	0x01FF
 /*
  * The Mobility Lab (TML)
  * Submitted by Pierre Castella
  */
 #define TML_VID			0x1B91	/* Vendor ID */
 #define TML_USB_SERIAL_PID	0x0064	/* USB - Serial Converter */
 /* Alti-2 products  http://www.alti-2.com */
 #define ALTI2_VID	0x1BC9
 #define ALTI2_N3_PID	0x6001	/* Neptune 3 */
 /*
  * Ionics PlugComputer
  */
 #define IONICS_VID			0x1c0c
 #define IONICS_PLUGCOMPUTER_PID		0x0102
 /*
  * Dresden Elektronik Sensor Terminal Board
  */
 #define DE_VID			0x1cf1 /* Vendor ID */
 #define STB_PID			0x0001 /* Sensor Terminal Board */
 #define WHT_PID			0x0004 /* Wireless Handheld Terminal */
 /*
  * STMicroelectonics
  */
 #define ST_VID			0x0483
 #define ST_STMCLT_2232_PID	0x3746
 #define ST_STMCLT_4232_PID	0x3747
 /*
  * Papouch products (http://www.papouch.com/)
  * Submitted by Folkert van Heusden
  */
 #define PAPOUCH_VID			0x5050	/* Vendor ID */
 #define PAPOUCH_SB485_PID		0x0100	/* Papouch SB485 USB-485/422 Converter */
 #define PAPOUCH_AP485_PID		0x0101	/* AP485 USB-RS485 Converter */
 #define PAPOUCH_SB422_PID		0x0102	/* Papouch SB422 USB-RS422 Converter  */
 #define PAPOUCH_SB485_2_PID		0x0103	/* Papouch SB485 USB-485/422 Converter */
 #define PAPOUCH_AP485_2_PID		0x0104	/* AP485 USB-RS485 Converter */
 #define PAPOUCH_SB422_2_PID		0x0105	/* Papouch SB422 USB-RS422 Converter  */
 #define PAPOUCH_SB485S_PID		0x0106	/* Papouch SB485S USB-485/422 Converter */
 #define PAPOUCH_SB485C_PID		0x0107	/* Papouch SB485C USB-485/422 Converter */
 #define PAPOUCH_LEC_PID			0x0300	/* LEC USB Converter */
 #define PAPOUCH_SB232_PID		0x0301	/* Papouch SB232 USB-RS232 Converter */
 #define PAPOUCH_TMU_PID			0x0400	/* TMU USB Thermometer */
 #define PAPOUCH_IRAMP_PID		0x0500	/* Papouch IRAmp Duplex */
 #define PAPOUCH_DRAK5_PID		0x0700	/* Papouch DRAK5 */
 #define PAPOUCH_QUIDO8x8_PID		0x0800	/* Papouch Quido 8/8 Module */
 #define PAPOUCH_QUIDO4x4_PID		0x0900	/* Papouch Quido 4/4 Module */
 #define PAPOUCH_QUIDO2x2_PID		0x0a00	/* Papouch Quido 2/2 Module */
 #define PAPOUCH_QUIDO10x1_PID		0x0b00	/* Papouch Quido 10/1 Module */
 #define PAPOUCH_QUIDO30x3_PID		0x0c00	/* Papouch Quido 30/3 Module */
 #define PAPOUCH_QUIDO60x3_PID		0x0d00	/* Papouch Quido 60(100)/3 Module */
 #define PAPOUCH_QUIDO2x16_PID		0x0e00	/* Papouch Quido 2/16 Module */
 #define PAPOUCH_QUIDO3x32_PID		0x0f00	/* Papouch Quido 3/32 Module */
 #define PAPOUCH_DRAK6_PID		0x1000	/* Papouch DRAK6 */
 #define PAPOUCH_UPSUSB_PID		0x8000	/* Papouch UPS-USB adapter */
 #define PAPOUCH_MU_PID			0x8001	/* MU controller */
 #define PAPOUCH_SIMUKEY_PID		0x8002	/* Papouch SimuKey */
 #define PAPOUCH_AD4USB_PID		0x8003	/* AD4USB Measurement Module */
 #define PAPOUCH_GMUX_PID		0x8004	/* Papouch GOLIATH MUX */
 #define PAPOUCH_GMSR_PID		0x8005	/* Papouch GOLIATH MSR */
 /*
  * Marvell SheevaPlug
  */
 #define MARVELL_VID		0x9e88
 #define MARVELL_SHEEVAPLUG_PID	0x9e8f
 /*
  * Evolution Robotics products (http://www.evolution.com/).
  * Submitted by Shawn M. Lavelle.
  */
 #define EVOLUTION_VID		0xDEEE	/* Vendor ID */
 #define EVOLUTION_ER1_PID	0x0300	/* ER1 Control Module */
 #define EVO_8U232AM_PID		0x02FF	/* Evolution robotics RCM2 (FT232AM)*/
 #define EVO_HYBRID_PID		0x0302	/* Evolution robotics RCM4 PID (FT232BM)*/
 #define EVO_RCM4_PID		0x0303	/* Evolution robotics RCM4 PID */
 /*
  * MJS Gadgets HD Radio / XM Radio / Sirius Radio interfaces (using VID 0x0403)
  */
 #define MJSG_GENERIC_PID	0x9378
 #define MJSG_SR_RADIO_PID	0x9379
 #define MJSG_XM_RADIO_PID	0x937A
 #define MJSG_HD_RADIO_PID	0x937C
 /*
  * D.O.Tec products (http://www.directout.eu)
  */
 #define FTDI_DOTEC_PID 0x9868
 /*
  * Xverve Signalyzer tools (http://www.signalyzer.com/)
  */
 #define XVERVE_SIGNALYZER_ST_PID	0xBCA0
 #define XVERVE_SIGNALYZER_SLITE_PID	0xBCA1
 #define XVERVE_SIGNALYZER_SH2_PID	0xBCA2
 #define XVERVE_SIGNALYZER_SH4_PID	0xBCA4
 /*
  * Segway Robotic Mobility Platform USB interface (using VID 0x0403)
  * Submitted by John G. Rogers
  */
 #define SEGWAY_RMP200_PID	0xe729
 /*
  * Accesio USB Data Acquisition products (http://www.accesio.com/)
  */
 #define ACCESIO_COM4SM_PID 	0xD578
 /* www.sciencescope.co.uk educational dataloggers */
 #define FTDI_SCIENCESCOPE_LOGBOOKML_PID		0xFF18
 #define FTDI_SCIENCESCOPE_LS_LOGBOOK_PID	0xFF1C
 #define FTDI_SCIENCESCOPE_HS_LOGBOOK_PID	0xFF1D
 /*
  * Milkymist One JTAG/Serial
  */
 #define QIHARDWARE_VID			0x20B7
 #define MILKYMISTONE_JTAGSERIAL_PID	0x0713
 /*
  * CTI GmbH RS485 Converter http://www.cti-lean.com/
  */
 /* USB-485-Mini*/
 #define FTDI_CTI_MINI_PID	0xF608
 /* USB-Nano-485*/
 #define FTDI_CTI_NANO_PID	0xF60B
 /*
  * ZeitControl cardsystems GmbH rfid-readers http://zeitconrol.de
  */
 /* TagTracer MIFARE*/
 #define FTDI_ZEITCONTROL_TAGTRACE_MIFARE_PID	0xF7C0
 /*
  * Rainforest Automation
  */
 /* ZigBee controller */
 #define FTDI_RF_R106		0x8A28
 /*
  * Product: HCP HIT GPRS modem
  * Manufacturer: HCP d.o.o.
  * ATI command output: Cinterion MC55i
  */
 #define FTDI_CINTERION_MC55I_PID	0xA951
 /*
  * Product: Comet Caller ID decoder
  * Manufacturer: Crucible Technologies
  */
 #define FTDI_CT_COMET_PID	0x8e08
 /*
  * Product: Z3X Box
  * Manufacturer: Smart GSM Team
  */
 #define FTDI_Z3X_PID		0x0011
 /*
  * Product: Cressi PC Interface
  * Manufacturer: Cressi
  */
 #define FTDI_CRESSI_PID		0x87d0
 /*
  * Brainboxes devices
  */
 #define BRAINBOXES_VID			0x05d1
 #define BRAINBOXES_VX_001_PID		0x1001 /* VX-001 ExpressCard 1 Port RS232 */
 #define BRAINBOXES_VX_012_PID		0x1002 /* VX-012 ExpressCard 2 Port RS232 */
 #define BRAINBOXES_VX_023_PID		0x1003 /* VX-023 ExpressCard 1 Port RS422/485 */
 #define BRAINBOXES_VX_034_PID		0x1004 /* VX-034 ExpressCard 2 Port RS422/485 */
 #define BRAINBOXES_US_101_PID		0x1011 /* US-101 1xRS232 */
 #define BRAINBOXES_US_324_PID		0x1013 /* US-324 1xRS422/485 1Mbaud */
 #define BRAINBOXES_US_606_1_PID		0x2001 /* US-606 6 Port RS232 Serial Port 1 and 2 */
 #define BRAINBOXES_US_606_2_PID		0x2002 /* US-606 6 Port RS232 Serial Port 3 and 4 */
 #define BRAINBOXES_US_606_3_PID		0x2003 /* US-606 6 Port RS232 Serial Port 4 and 6 */
 #define BRAINBOXES_US_701_1_PID		0x2011 /* US-701 4xRS232 1Mbaud Port 1 and 2 */
 #define BRAINBOXES_US_701_2_PID		0x2012 /* US-701 4xRS422 1Mbaud Port 3 and 4 */
 #define BRAINBOXES_US_279_1_PID		0x2021 /* US-279 8xRS422 1Mbaud Port 1 and 2 */
 #define BRAINBOXES_US_279_2_PID		0x2022 /* US-279 8xRS422 1Mbaud Port 3 and 4 */
 #define BRAINBOXES_US_279_3_PID		0x2023 /* US-279 8xRS422 1Mbaud Port 5 and 6 */
 #define BRAINBOXES_US_279_4_PID		0x2024 /* US-279 8xRS422 1Mbaud Port 7 and 8 */
 #define BRAINBOXES_US_346_1_PID		0x3011 /* US-346 4xRS422/485 1Mbaud Port 1 and 2 */
 #define BRAINBOXES_US_346_2_PID		0x3012 /* US-346 4xRS422/485 1Mbaud Port 3 and 4 */
 #define BRAINBOXES_US_257_PID		0x5001 /* US-257 2xRS232 1Mbaud */
 #define BRAINBOXES_US_313_PID		0x6001 /* US-313 2xRS422/485 1Mbaud */
 #define BRAINBOXES_US_357_PID		0x7001 /* US_357 1xRS232/422/485 */
 #define BRAINBOXES_US_842_1_PID		0x8001 /* US-842 8xRS422/485 1Mbaud Port 1 and 2 */
 #define BRAINBOXES_US_842_2_PID		0x8002 /* US-842 8xRS422/485 1Mbaud Port 3 and 4 */
 #define BRAINBOXES_US_842_3_PID		0x8003 /* US-842 8xRS422/485 1Mbaud Port 5 and 6 */
 #define BRAINBOXES_US_842_4_PID		0x8004 /* US-842 8xRS422/485 1Mbaud Port 7 and 8 */
 #define BRAINBOXES_US_160_1_PID		0x9001 /* US-160 16xRS232 1Mbaud Port 1 and 2 */
 #define BRAINBOXES_US_160_2_PID		0x9002 /* US-160 16xRS232 1Mbaud Port 3 and 4 */
 #define BRAINBOXES_US_160_3_PID		0x9003 /* US-160 16xRS232 1Mbaud Port 5 and 6 */
 #define BRAINBOXES_US_160_4_PID		0x9004 /* US-160 16xRS232 1Mbaud Port 7 and 8 */
 #define BRAINBOXES_US_160_5_PID		0x9005 /* US-160 16xRS232 1Mbaud Port 9 and 10 */
 #define BRAINBOXES_US_160_6_PID		0x9006 /* US-160 16xRS232 1Mbaud Port 11 and 12 */
 #define BRAINBOXES_US_160_7_PID		0x9007 /* US-160 16xRS232 1Mbaud Port 13 and 14 */
 #define BRAINBOXES_US_160_8_PID		0x9008 /* US-160 16xRS232 1Mbaud Port 15 and 16 */

drivers/usb/serial/io_ti.c

Diff comments View file @ 8ee7a33

1	/*	1	/*
2	* Edgeport USB Serial Converter driver	2	* Edgeport USB Serial Converter driver
3	*	3	*
4	* Copyright (C) 2000-2002 Inside Out Networks, All rights reserved.	4	* Copyright (C) 2000-2002 Inside Out Networks, All rights reserved.
5	* Copyright (C) 2001-2002 Greg Kroah-Hartman <greg@kroah.com>	5	* Copyright (C) 2001-2002 Greg Kroah-Hartman <greg@kroah.com>
6	*	6	*
7	* This program is free software; you can redistribute it and/or modify	7	* This program is free software; you can redistribute it and/or modify
8	* it under the terms of the GNU General Public License as published by	8	* it under the terms of the GNU General Public License as published by
9	* the Free Software Foundation; either version 2 of the License, or	9	* the Free Software Foundation; either version 2 of the License, or
10	* (at your option) any later version.	10	* (at your option) any later version.
11	*	11	*
12	* Supports the following devices:	12	* Supports the following devices:
13	* EP/1 EP/2 EP/4 EP/21 EP/22 EP/221 EP/42 EP/421 WATCHPORT	13	* EP/1 EP/2 EP/4 EP/21 EP/22 EP/221 EP/42 EP/421 WATCHPORT
14	*	14	*
15	* For questions or problems with this driver, contact Inside Out	15	* For questions or problems with this driver, contact Inside Out
16	* Networks technical support, or Peter Berger <pberger@brimson.com>,	16	* Networks technical support, or Peter Berger <pberger@brimson.com>,
17	* or Al Borchers <alborchers@steinerpoint.com>.	17	* or Al Borchers <alborchers@steinerpoint.com>.
18	*/	18	*/
19		19
20	#include <linux/kernel.h>	20	#include <linux/kernel.h>
21	#include <linux/jiffies.h>	21	#include <linux/jiffies.h>
22	#include <linux/errno.h>	22	#include <linux/errno.h>
23	#include <linux/slab.h>	23	#include <linux/slab.h>
24	#include <linux/tty.h>	24	#include <linux/tty.h>
25	#include <linux/tty_driver.h>	25	#include <linux/tty_driver.h>
26	#include <linux/tty_flip.h>	26	#include <linux/tty_flip.h>
27	#include <linux/module.h>	27	#include <linux/module.h>
28	#include <linux/spinlock.h>	28	#include <linux/spinlock.h>
29	#include <linux/mutex.h>	29	#include <linux/mutex.h>
30	#include <linux/serial.h>	30	#include <linux/serial.h>
31	#include <linux/swab.h>	31	#include <linux/swab.h>
32	#include <linux/kfifo.h>	32	#include <linux/kfifo.h>
33	#include <linux/ioctl.h>	33	#include <linux/ioctl.h>
34	#include <linux/firmware.h>	34	#include <linux/firmware.h>
35	#include <linux/uaccess.h>	35	#include <linux/uaccess.h>
36	#include <linux/usb.h>	36	#include <linux/usb.h>
37	#include <linux/usb/serial.h>	37	#include <linux/usb/serial.h>
38		38
39	#include "io_16654.h"	39	#include "io_16654.h"
40	#include "io_usbvend.h"	40	#include "io_usbvend.h"
41	#include "io_ti.h"	41	#include "io_ti.h"
42		42
43	#define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com> and David Iacovelli"	43	#define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com> and David Iacovelli"
44	#define DRIVER_DESC "Edgeport USB Serial Driver"	44	#define DRIVER_DESC "Edgeport USB Serial Driver"
45		45
46	#define EPROM_PAGE_SIZE 64	46	#define EPROM_PAGE_SIZE 64
47		47
48		48
49	/* different hardware types */	49	/* different hardware types */
50	#define HARDWARE_TYPE_930 0	50	#define HARDWARE_TYPE_930 0
51	#define HARDWARE_TYPE_TIUMP 1	51	#define HARDWARE_TYPE_TIUMP 1
52		52
53	/* IOCTL_PRIVATE_TI_GET_MODE Definitions */	53	/* IOCTL_PRIVATE_TI_GET_MODE Definitions */
54	#define TI_MODE_CONFIGURING 0 /* Device has not entered start device */	54	#define TI_MODE_CONFIGURING 0 /* Device has not entered start device */
55	#define TI_MODE_BOOT 1 /* Staying in boot mode */	55	#define TI_MODE_BOOT 1 /* Staying in boot mode */
56	#define TI_MODE_DOWNLOAD 2 /* Made it to download mode */	56	#define TI_MODE_DOWNLOAD 2 /* Made it to download mode */
57	#define TI_MODE_TRANSITIONING 3 /* Currently in boot mode but	57	#define TI_MODE_TRANSITIONING 3 /* Currently in boot mode but
58	transitioning to download mode */	58	transitioning to download mode */
59		59
60	/* read urb state */	60	/* read urb state */
61	#define EDGE_READ_URB_RUNNING 0	61	#define EDGE_READ_URB_RUNNING 0
62	#define EDGE_READ_URB_STOPPING 1	62	#define EDGE_READ_URB_STOPPING 1
63	#define EDGE_READ_URB_STOPPED 2	63	#define EDGE_READ_URB_STOPPED 2
64		64
65	#define EDGE_CLOSING_WAIT 4000 /* in .01 sec */	65	#define EDGE_CLOSING_WAIT 4000 /* in .01 sec */
66		66
67		67
68	/* Product information read from the Edgeport */	68	/* Product information read from the Edgeport */
69	struct product_info {	69	struct product_info {
70	int TiMode; /* Current TI Mode */	70	int TiMode; /* Current TI Mode */
71	__u8 hardware_type; /* Type of hardware */	71	__u8 hardware_type; /* Type of hardware */
72	} __attribute__((packed));	72	} __attribute__((packed));
73		73
74	struct edgeport_port {	74	struct edgeport_port {
75	__u16 uart_base;	75	__u16 uart_base;
76	__u16 dma_address;	76	__u16 dma_address;
77	__u8 shadow_msr;	77	__u8 shadow_msr;
78	__u8 shadow_mcr;	78	__u8 shadow_mcr;
79	__u8 shadow_lsr;	79	__u8 shadow_lsr;
80	__u8 lsr_mask;	80	__u8 lsr_mask;
81	__u32 ump_read_timeout; /* Number of milliseconds the UMP will	81	__u32 ump_read_timeout; /* Number of milliseconds the UMP will
82	wait without data before completing	82	wait without data before completing
83	a read short */	83	a read short */
84	int baud_rate;	84	int baud_rate;
85	int close_pending;	85	int close_pending;
86	int lsr_event;	86	int lsr_event;
87		87
88	struct edgeport_serial *edge_serial;	88	struct edgeport_serial *edge_serial;
89	struct usb_serial_port *port;	89	struct usb_serial_port *port;
90	__u8 bUartMode; /* Port type, 0: RS232, etc. */	90	__u8 bUartMode; /* Port type, 0: RS232, etc. */
91	spinlock_t ep_lock;	91	spinlock_t ep_lock;
92	int ep_read_urb_state;	92	int ep_read_urb_state;
93	int ep_write_urb_in_use;	93	int ep_write_urb_in_use;
94	};	94	};
95		95
96	struct edgeport_serial {	96	struct edgeport_serial {
97	struct product_info product_info;	97	struct product_info product_info;
98	u8 TI_I2C_Type; /* Type of I2C in UMP */	98	u8 TI_I2C_Type; /* Type of I2C in UMP */
99	u8 TiReadI2C; /* Set to TRUE if we have read the	99	u8 TiReadI2C; /* Set to TRUE if we have read the
100	I2c in Boot Mode */	100	I2c in Boot Mode */
101	struct mutex es_lock;	101	struct mutex es_lock;
102	int num_ports_open;	102	int num_ports_open;
103	struct usb_serial *serial;	103	struct usb_serial *serial;
104	};	104	};
105		105
106		106
107	/* Devices that this driver supports */	107	/* Devices that this driver supports */
108	static const struct usb_device_id edgeport_1port_id_table[] = {	108	static const struct usb_device_id edgeport_1port_id_table[] = {
109	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_1) },	109	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_1) },
110	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_TI3410_EDGEPORT_1) },	110	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_TI3410_EDGEPORT_1) },
111	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_TI3410_EDGEPORT_1I) },	111	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_TI3410_EDGEPORT_1I) },
112	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_PROXIMITY) },	112	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_PROXIMITY) },
113	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_MOTION) },	113	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_MOTION) },
114	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_MOISTURE) },	114	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_MOISTURE) },
115	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_TEMPERATURE) },	115	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_TEMPERATURE) },
116	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_HUMIDITY) },	116	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_HUMIDITY) },
117	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_POWER) },	117	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_POWER) },
118	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_LIGHT) },	118	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_LIGHT) },
119	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_RADIATION) },	119	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_RADIATION) },
120	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_DISTANCE) },	120	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_DISTANCE) },
121	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_ACCELERATION) },	121	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_ACCELERATION) },
122	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_PROX_DIST) },	122	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_PROX_DIST) },
123	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_PLUS_PWR_HP4CD) },	123	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_PLUS_PWR_HP4CD) },
124	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_PLUS_PWR_PCI) },	124	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_PLUS_PWR_PCI) },
125	{ }	125	{ }
126	};	126	};
127		127
128	static const struct usb_device_id edgeport_2port_id_table[] = {	128	static const struct usb_device_id edgeport_2port_id_table[] = {
129	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_2) },	129	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_2) },
130	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_2C) },	130	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_2C) },
131	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_2I) },	131	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_2I) },
132	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_421) },	132	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_421) },
133	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_21) },	133	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_21) },
134	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_42) },	134	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_42) },
135	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_4) },	135	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_4) },
136	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_4I) },	136	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_4I) },
137	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_22I) },	137	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_22I) },
138	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_221C) },	138	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_221C) },
139	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_22C) },	139	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_22C) },
140	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_21C) },	140	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_21C) },
141	/* The 4, 8 and 16 port devices show up as multiple 2 port devices */	141	/* The 4, 8 and 16 port devices show up as multiple 2 port devices */
142	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_4S) },	142	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_4S) },
143	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_8) },	143	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_8) },
144	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_8S) },	144	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_8S) },
145	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_416) },	145	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_416) },
146	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_416B) },	146	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_416B) },
147	{ }	147	{ }
148	};	148	};
149		149
150	/* Devices that this driver supports */	150	/* Devices that this driver supports */
151	static const struct usb_device_id id_table_combined[] = {	151	static const struct usb_device_id id_table_combined[] = {
152	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_1) },	152	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_1) },
153	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_TI3410_EDGEPORT_1) },	153	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_TI3410_EDGEPORT_1) },
154	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_TI3410_EDGEPORT_1I) },	154	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_TI3410_EDGEPORT_1I) },
155	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_PROXIMITY) },	155	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_PROXIMITY) },
156	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_MOTION) },	156	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_MOTION) },
157	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_MOISTURE) },	157	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_MOISTURE) },
158	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_TEMPERATURE) },	158	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_TEMPERATURE) },
159	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_HUMIDITY) },	159	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_HUMIDITY) },
160	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_POWER) },	160	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_POWER) },
161	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_LIGHT) },	161	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_LIGHT) },
162	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_RADIATION) },	162	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_RADIATION) },
163	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_DISTANCE) },	163	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_DISTANCE) },
164	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_ACCELERATION) },	164	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_ACCELERATION) },
165	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_PROX_DIST) },	165	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_PROX_DIST) },
166	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_PLUS_PWR_HP4CD) },	166	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_PLUS_PWR_HP4CD) },
167	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_PLUS_PWR_PCI) },	167	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_PLUS_PWR_PCI) },
168	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_2) },	168	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_2) },
169	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_2C) },	169	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_2C) },
170	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_2I) },	170	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_2I) },
171	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_421) },	171	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_421) },
172	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_21) },	172	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_21) },
173	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_42) },	173	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_42) },
174	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_4) },	174	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_4) },
175	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_4I) },	175	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_4I) },
176	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_22I) },	176	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_22I) },
177	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_221C) },	177	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_221C) },
178	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_22C) },	178	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_22C) },
179	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_21C) },	179	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_21C) },
180	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_4S) },	180	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_4S) },
181	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_8) },	181	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_8) },
182	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_8S) },	182	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_8S) },
183	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_416) },	183	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_416) },
184	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_416B) },	184	{ USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_416B) },
185	{ }	185	{ }
186	};	186	};
187		187
188	MODULE_DEVICE_TABLE(usb, id_table_combined);	188	MODULE_DEVICE_TABLE(usb, id_table_combined);
189		189
190	static unsigned char OperationalMajorVersion;	190	static unsigned char OperationalMajorVersion;
191	static unsigned char OperationalMinorVersion;	191	static unsigned char OperationalMinorVersion;
192	static unsigned short OperationalBuildNumber;	192	static unsigned short OperationalBuildNumber;
193		193
194	static int closing_wait = EDGE_CLOSING_WAIT;	194	static int closing_wait = EDGE_CLOSING_WAIT;
195	static bool ignore_cpu_rev;	195	static bool ignore_cpu_rev;
196	static int default_uart_mode; /* RS232 */	196	static int default_uart_mode; /* RS232 */
197		197
198	static void edge_tty_recv(struct usb_serial_port port, unsigned char data,	198	static void edge_tty_recv(struct usb_serial_port port, unsigned char data,
199	int length);	199	int length);
200		200
201	static void stop_read(struct edgeport_port *edge_port);	201	static void stop_read(struct edgeport_port *edge_port);
202	static int restart_read(struct edgeport_port *edge_port);	202	static int restart_read(struct edgeport_port *edge_port);
203		203
204	static void edge_set_termios(struct tty_struct *tty,	204	static void edge_set_termios(struct tty_struct *tty,
205	struct usb_serial_port port, struct ktermios old_termios);	205	struct usb_serial_port port, struct ktermios old_termios);
206	static void edge_send(struct usb_serial_port port, struct tty_struct tty);	206	static void edge_send(struct usb_serial_port port, struct tty_struct tty);
207		207
208	/* sysfs attributes */	208	/* sysfs attributes */
209	static int edge_create_sysfs_attrs(struct usb_serial_port *port);	209	static int edge_create_sysfs_attrs(struct usb_serial_port *port);
210	static int edge_remove_sysfs_attrs(struct usb_serial_port *port);	210	static int edge_remove_sysfs_attrs(struct usb_serial_port *port);
211		211
212		212
213	static int ti_vread_sync(struct usb_device *dev, __u8 request,	213	static int ti_vread_sync(struct usb_device *dev, __u8 request,
214	__u16 value, __u16 index, u8 *data, int size)	214	__u16 value, __u16 index, u8 *data, int size)
215	{	215	{
216	int status;	216	int status;
217		217
218	status = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), request,	218	status = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), request,
219	(USB_TYPE_VENDOR \| USB_RECIP_DEVICE \| USB_DIR_IN),	219	(USB_TYPE_VENDOR \| USB_RECIP_DEVICE \| USB_DIR_IN),
220	value, index, data, size, 1000);	220	value, index, data, size, 1000);
221	if (status < 0)	221	if (status < 0)
222	return status;	222	return status;
223	if (status != size) {	223	if (status != size) {
224	dev_dbg(&dev->dev, "%s - wanted to write %d, but only wrote %d\n",	224	dev_dbg(&dev->dev, "%s - wanted to write %d, but only wrote %d\n",
225	__func__, size, status);	225	__func__, size, status);
226	return -ECOMM;	226	return -ECOMM;
227	}	227	}
228	return 0;	228	return 0;
229	}	229	}
230		230
231	static int ti_vsend_sync(struct usb_device *dev, __u8 request,	231	static int ti_vsend_sync(struct usb_device *dev, __u8 request,
232	__u16 value, __u16 index, u8 *data, int size)	232	__u16 value, __u16 index, u8 *data, int size)
233	{	233	{
234	int status;	234	int status;
235		235
236	status = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), request,	236	status = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), request,
237	(USB_TYPE_VENDOR \| USB_RECIP_DEVICE \| USB_DIR_OUT),	237	(USB_TYPE_VENDOR \| USB_RECIP_DEVICE \| USB_DIR_OUT),
238	value, index, data, size, 1000);	238	value, index, data, size, 1000);
239	if (status < 0)	239	if (status < 0)
240	return status;	240	return status;
241	if (status != size) {	241	if (status != size) {
242	dev_dbg(&dev->dev, "%s - wanted to write %d, but only wrote %d\n",	242	dev_dbg(&dev->dev, "%s - wanted to write %d, but only wrote %d\n",
243	__func__, size, status);	243	__func__, size, status);
244	return -ECOMM;	244	return -ECOMM;
245	}	245	}
246	return 0;	246	return 0;
247	}	247	}
248		248
249	static int send_cmd(struct usb_device *dev, __u8 command,	249	static int send_cmd(struct usb_device *dev, __u8 command,
250	__u8 moduleid, __u16 value, u8 *data,	250	__u8 moduleid, __u16 value, u8 *data,
251	int size)	251	int size)
252	{	252	{
253	return ti_vsend_sync(dev, command, value, moduleid, data, size);	253	return ti_vsend_sync(dev, command, value, moduleid, data, size);
254	}	254	}
255		255
256	/* clear tx/rx buffers and fifo in TI UMP */	256	/* clear tx/rx buffers and fifo in TI UMP */
257	static int purge_port(struct usb_serial_port *port, __u16 mask)	257	static int purge_port(struct usb_serial_port *port, __u16 mask)
258	{	258	{
259	int port_number = port->port_number;	259	int port_number = port->port_number;
260		260
261	dev_dbg(&port->dev, "%s - port %d, mask %x\n", __func__, port_number, mask);	261	dev_dbg(&port->dev, "%s - port %d, mask %x\n", __func__, port_number, mask);
262		262
263	return send_cmd(port->serial->dev,	263	return send_cmd(port->serial->dev,
264	UMPC_PURGE_PORT,	264	UMPC_PURGE_PORT,
265	(__u8)(UMPM_UART1_PORT + port_number),	265	(__u8)(UMPM_UART1_PORT + port_number),
266	mask,	266	mask,
267	NULL,	267	NULL,
268	0);	268	0);
269	}	269	}
270		270
271	/**	271	/**
272	* read_download_mem - Read edgeport memory from TI chip	272	* read_download_mem - Read edgeport memory from TI chip
273	* @dev: usb device pointer	273	* @dev: usb device pointer
274	* @start_address: Device CPU address at which to read	274	* @start_address: Device CPU address at which to read
275	* @length: Length of above data	275	* @length: Length of above data
276	* @address_type: Can read both XDATA and I2C	276	* @address_type: Can read both XDATA and I2C
277	* @buffer: pointer to input data buffer	277	* @buffer: pointer to input data buffer
278	*/	278	*/
279	static int read_download_mem(struct usb_device *dev, int start_address,	279	static int read_download_mem(struct usb_device *dev, int start_address,
280	int length, __u8 address_type, __u8 *buffer)	280	int length, __u8 address_type, __u8 *buffer)
281	{	281	{
282	int status = 0;	282	int status = 0;
283	__u8 read_length;	283	__u8 read_length;
284	u16 be_start_address;	284	u16 be_start_address;
285		285
286	dev_dbg(&dev->dev, "%s - @ %x for %d\n", __func__, start_address, length);	286	dev_dbg(&dev->dev, "%s - @ %x for %d\n", __func__, start_address, length);
287		287
288	/* Read in blocks of 64 bytes	288	/* Read in blocks of 64 bytes
289	* (TI firmware can't handle more than 64 byte reads)	289	* (TI firmware can't handle more than 64 byte reads)
290	*/	290	*/
291	while (length) {	291	while (length) {
292	if (length > 64)	292	if (length > 64)
293	read_length = 64;	293	read_length = 64;
294	else	294	else
295	read_length = (__u8)length;	295	read_length = (__u8)length;
296		296
297	if (read_length > 1) {	297	if (read_length > 1) {
298	dev_dbg(&dev->dev, "%s - @ %x for %d\n", __func__, start_address, read_length);	298	dev_dbg(&dev->dev, "%s - @ %x for %d\n", __func__, start_address, read_length);
299	}	299	}
300	/*	300	/*
301	* NOTE: Must use swab as wIndex is sent in little-endian	301	* NOTE: Must use swab as wIndex is sent in little-endian
302	* byte order regardless of host byte order.	302	* byte order regardless of host byte order.
303	*/	303	*/
304	be_start_address = swab16((u16)start_address);	304	be_start_address = swab16((u16)start_address);
305	status = ti_vread_sync(dev, UMPC_MEMORY_READ,	305	status = ti_vread_sync(dev, UMPC_MEMORY_READ,
306	(__u16)address_type,	306	(__u16)address_type,
307	be_start_address,	307	be_start_address,
308	buffer, read_length);	308	buffer, read_length);
309		309
310	if (status) {	310	if (status) {
311	dev_dbg(&dev->dev, "%s - ERROR %x\n", __func__, status);	311	dev_dbg(&dev->dev, "%s - ERROR %x\n", __func__, status);
312	return status;	312	return status;
313	}	313	}
314		314
315	if (read_length > 1)	315	if (read_length > 1)
316	usb_serial_debug_data(&dev->dev, __func__, read_length, buffer);	316	usb_serial_debug_data(&dev->dev, __func__, read_length, buffer);
317		317
318	/* Update pointers/length */	318	/* Update pointers/length */
319	start_address += read_length;	319	start_address += read_length;
320	buffer += read_length;	320	buffer += read_length;
321	length -= read_length;	321	length -= read_length;
322	}	322	}
323		323
324	return status;	324	return status;
325	}	325	}
326		326
327	static int read_ram(struct usb_device *dev, int start_address,	327	static int read_ram(struct usb_device *dev, int start_address,
328	int length, __u8 *buffer)	328	int length, __u8 *buffer)
329	{	329	{
330	return read_download_mem(dev, start_address, length,	330	return read_download_mem(dev, start_address, length,
331	DTK_ADDR_SPACE_XDATA, buffer);	331	DTK_ADDR_SPACE_XDATA, buffer);
332	}	332	}
333		333
334	/* Read edgeport memory to a given block */	334	/* Read edgeport memory to a given block */
335	static int read_boot_mem(struct edgeport_serial *serial,	335	static int read_boot_mem(struct edgeport_serial *serial,
336	int start_address, int length, __u8 *buffer)	336	int start_address, int length, __u8 *buffer)
337	{	337	{
338	int status = 0;	338	int status = 0;
339	int i;	339	int i;
340		340
341	for (i = 0; i < length; i++) {	341	for (i = 0; i < length; i++) {
342	status = ti_vread_sync(serial->serial->dev,	342	status = ti_vread_sync(serial->serial->dev,
343	UMPC_MEMORY_READ, serial->TI_I2C_Type,	343	UMPC_MEMORY_READ, serial->TI_I2C_Type,
344	(__u16)(start_address+i), &buffer[i], 0x01);	344	(__u16)(start_address+i), &buffer[i], 0x01);
345	if (status) {	345	if (status) {
346	dev_dbg(&serial->serial->dev->dev, "%s - ERROR %x\n", __func__, status);	346	dev_dbg(&serial->serial->dev->dev, "%s - ERROR %x\n", __func__, status);
347	return status;	347	return status;
348	}	348	}
349	}	349	}
350		350
351	dev_dbg(&serial->serial->dev->dev, "%s - start_address = %x, length = %d\n",	351	dev_dbg(&serial->serial->dev->dev, "%s - start_address = %x, length = %d\n",
352	__func__, start_address, length);	352	__func__, start_address, length);
353	usb_serial_debug_data(&serial->serial->dev->dev, __func__, length, buffer);	353	usb_serial_debug_data(&serial->serial->dev->dev, __func__, length, buffer);
354		354
355	serial->TiReadI2C = 1;	355	serial->TiReadI2C = 1;
356		356
357	return status;	357	return status;
358	}	358	}
359		359
360	/* Write given block to TI EPROM memory */	360	/* Write given block to TI EPROM memory */
361	static int write_boot_mem(struct edgeport_serial *serial,	361	static int write_boot_mem(struct edgeport_serial *serial,
362	int start_address, int length, __u8 *buffer)	362	int start_address, int length, __u8 *buffer)
363	{	363	{
364	int status = 0;	364	int status = 0;
365	int i;	365	int i;
366	u8 *temp;	366	u8 *temp;
367		367
368	/* Must do a read before write */	368	/* Must do a read before write */
369	if (!serial->TiReadI2C) {	369	if (!serial->TiReadI2C) {
370	temp = kmalloc(1, GFP_KERNEL);	370	temp = kmalloc(1, GFP_KERNEL);
371	if (!temp)	371	if (!temp)
372	return -ENOMEM;	372	return -ENOMEM;
373		373
374	status = read_boot_mem(serial, 0, 1, temp);	374	status = read_boot_mem(serial, 0, 1, temp);
375	kfree(temp);	375	kfree(temp);
376	if (status)	376	if (status)
377	return status;	377	return status;
378	}	378	}
379		379
380	for (i = 0; i < length; ++i) {	380	for (i = 0; i < length; ++i) {
381	status = ti_vsend_sync(serial->serial->dev,	381	status = ti_vsend_sync(serial->serial->dev,
382	UMPC_MEMORY_WRITE, buffer[i],	382	UMPC_MEMORY_WRITE, buffer[i],
383	(__u16)(i + start_address), NULL, 0);	383	(__u16)(i + start_address), NULL, 0);
384	if (status)	384	if (status)
385	return status;	385	return status;
386	}	386	}
387		387
388	dev_dbg(&serial->serial->dev->dev, "%s - start_sddr = %x, length = %d\n", __func__, start_address, length);	388	dev_dbg(&serial->serial->dev->dev, "%s - start_sddr = %x, length = %d\n", __func__, start_address, length);
389	usb_serial_debug_data(&serial->serial->dev->dev, __func__, length, buffer);	389	usb_serial_debug_data(&serial->serial->dev->dev, __func__, length, buffer);
390		390
391	return status;	391	return status;
392	}	392	}
393		393
394		394
395	/* Write edgeport I2C memory to TI chip */	395	/* Write edgeport I2C memory to TI chip */
396	static int write_i2c_mem(struct edgeport_serial *serial,	396	static int write_i2c_mem(struct edgeport_serial *serial,
397	int start_address, int length, __u8 address_type, __u8 *buffer)	397	int start_address, int length, __u8 address_type, __u8 *buffer)
398	{	398	{
399	struct device *dev = &serial->serial->dev->dev;	399	struct device *dev = &serial->serial->dev->dev;
400	int status = 0;	400	int status = 0;
401	int write_length;	401	int write_length;
402	u16 be_start_address;	402	u16 be_start_address;
403		403
404	/* We can only send a maximum of 1 aligned byte page at a time */	404	/* We can only send a maximum of 1 aligned byte page at a time */
405		405
406	/* calculate the number of bytes left in the first page */	406	/* calculate the number of bytes left in the first page */
407	write_length = EPROM_PAGE_SIZE -	407	write_length = EPROM_PAGE_SIZE -
408	(start_address & (EPROM_PAGE_SIZE - 1));	408	(start_address & (EPROM_PAGE_SIZE - 1));
409		409
410	if (write_length > length)	410	if (write_length > length)
411	write_length = length;	411	write_length = length;
412		412
413	dev_dbg(dev, "%s - BytesInFirstPage Addr = %x, length = %d\n",	413	dev_dbg(dev, "%s - BytesInFirstPage Addr = %x, length = %d\n",
414	__func__, start_address, write_length);	414	__func__, start_address, write_length);
415	usb_serial_debug_data(dev, __func__, write_length, buffer);	415	usb_serial_debug_data(dev, __func__, write_length, buffer);
416		416
417	/*	417	/*
418	* Write first page.	418	* Write first page.
419	*	419	*
420	* NOTE: Must use swab as wIndex is sent in little-endian byte order	420	* NOTE: Must use swab as wIndex is sent in little-endian byte order
421	* regardless of host byte order.	421	* regardless of host byte order.
422	*/	422	*/
423	be_start_address = swab16((u16)start_address);	423	be_start_address = swab16((u16)start_address);
424	status = ti_vsend_sync(serial->serial->dev,	424	status = ti_vsend_sync(serial->serial->dev,
425	UMPC_MEMORY_WRITE, (__u16)address_type,	425	UMPC_MEMORY_WRITE, (__u16)address_type,
426	be_start_address,	426	be_start_address,
427	buffer, write_length);	427	buffer, write_length);
428	if (status) {	428	if (status) {
429	dev_dbg(dev, "%s - ERROR %d\n", __func__, status);	429	dev_dbg(dev, "%s - ERROR %d\n", __func__, status);
430	return status;	430	return status;
431	}	431	}
432		432
433	length -= write_length;	433	length -= write_length;
434	start_address += write_length;	434	start_address += write_length;
435	buffer += write_length;	435	buffer += write_length;
436		436
437	/* We should be aligned now -- can write	437	/* We should be aligned now -- can write
438	max page size bytes at a time */	438	max page size bytes at a time */
439	while (length) {	439	while (length) {
440	if (length > EPROM_PAGE_SIZE)	440	if (length > EPROM_PAGE_SIZE)
441	write_length = EPROM_PAGE_SIZE;	441	write_length = EPROM_PAGE_SIZE;
442	else	442	else
443	write_length = length;	443	write_length = length;
444		444
445	dev_dbg(dev, "%s - Page Write Addr = %x, length = %d\n",	445	dev_dbg(dev, "%s - Page Write Addr = %x, length = %d\n",
446	__func__, start_address, write_length);	446	__func__, start_address, write_length);
447	usb_serial_debug_data(dev, __func__, write_length, buffer);	447	usb_serial_debug_data(dev, __func__, write_length, buffer);
448		448
449	/*	449	/*
450	* Write next page.	450	* Write next page.
451	*	451	*
452	* NOTE: Must use swab as wIndex is sent in little-endian byte	452	* NOTE: Must use swab as wIndex is sent in little-endian byte
453	* order regardless of host byte order.	453	* order regardless of host byte order.
454	*/	454	*/
455	be_start_address = swab16((u16)start_address);	455	be_start_address = swab16((u16)start_address);
456	status = ti_vsend_sync(serial->serial->dev, UMPC_MEMORY_WRITE,	456	status = ti_vsend_sync(serial->serial->dev, UMPC_MEMORY_WRITE,
457	(__u16)address_type,	457	(__u16)address_type,
458	be_start_address,	458	be_start_address,
459	buffer, write_length);	459	buffer, write_length);
460	if (status) {	460	if (status) {
461	dev_err(dev, "%s - ERROR %d\n", __func__, status);	461	dev_err(dev, "%s - ERROR %d\n", __func__, status);
462	return status;	462	return status;
463	}	463	}
464		464
465	length -= write_length;	465	length -= write_length;
466	start_address += write_length;	466	start_address += write_length;
467	buffer += write_length;	467	buffer += write_length;
468	}	468	}
469	return status;	469	return status;
470	}	470	}
471		471
472	/* Examine the UMP DMA registers and LSR	472	/* Examine the UMP DMA registers and LSR
473	*	473	*
474	* Check the MSBit of the X and Y DMA byte count registers.	474	* Check the MSBit of the X and Y DMA byte count registers.
475	* A zero in this bit indicates that the TX DMA buffers are empty	475	* A zero in this bit indicates that the TX DMA buffers are empty
476	* then check the TX Empty bit in the UART.	476	* then check the TX Empty bit in the UART.
477	*/	477	*/
478	static int tx_active(struct edgeport_port *port)	478	static int tx_active(struct edgeport_port *port)
479	{	479	{
480	int status;	480	int status;
481	struct out_endpoint_desc_block *oedb;	481	struct out_endpoint_desc_block *oedb;
482	__u8 *lsr;	482	__u8 *lsr;
483	int bytes_left = 0;	483	int bytes_left = 0;
484		484
485	oedb = kmalloc(sizeof(*oedb), GFP_KERNEL);	485	oedb = kmalloc(sizeof(*oedb), GFP_KERNEL);
486	if (!oedb)	486	if (!oedb)
487	return -ENOMEM;	487	return -ENOMEM;
488		488
489	lsr = kmalloc(1, GFP_KERNEL); /* Sigh, that's right, just one byte,	489	lsr = kmalloc(1, GFP_KERNEL); /* Sigh, that's right, just one byte,
490	as not all platforms can do DMA	490	as not all platforms can do DMA
491	from stack */	491	from stack */
492	if (!lsr) {	492	if (!lsr) {
493	kfree(oedb);	493	kfree(oedb);
494	return -ENOMEM;	494	return -ENOMEM;
495	}	495	}
496	/* Read the DMA Count Registers */	496	/* Read the DMA Count Registers */
497	status = read_ram(port->port->serial->dev, port->dma_address,	497	status = read_ram(port->port->serial->dev, port->dma_address,
498	sizeof(oedb), (void )oedb);	498	sizeof(oedb), (void )oedb);
499	if (status)	499	if (status)
500	goto exit_is_tx_active;	500	goto exit_is_tx_active;
501		501
502	dev_dbg(&port->port->dev, "%s - XByteCount 0x%X\n", __func__, oedb->XByteCount);	502	dev_dbg(&port->port->dev, "%s - XByteCount 0x%X\n", __func__, oedb->XByteCount);
503		503
504	/* and the LSR */	504	/* and the LSR */
505	status = read_ram(port->port->serial->dev,	505	status = read_ram(port->port->serial->dev,
506	port->uart_base + UMPMEM_OFFS_UART_LSR, 1, lsr);	506	port->uart_base + UMPMEM_OFFS_UART_LSR, 1, lsr);
507		507
508	if (status)	508	if (status)
509	goto exit_is_tx_active;	509	goto exit_is_tx_active;
510	dev_dbg(&port->port->dev, "%s - LSR = 0x%X\n", __func__, *lsr);	510	dev_dbg(&port->port->dev, "%s - LSR = 0x%X\n", __func__, *lsr);
511		511
512	/* If either buffer has data or we are transmitting then return TRUE */	512	/* If either buffer has data or we are transmitting then return TRUE */
513	if ((oedb->XByteCount & 0x80) != 0)	513	if ((oedb->XByteCount & 0x80) != 0)
514	bytes_left += 64;	514	bytes_left += 64;
515		515
516	if ((*lsr & UMP_UART_LSR_TX_MASK) == 0)	516	if ((*lsr & UMP_UART_LSR_TX_MASK) == 0)
517	bytes_left += 1;	517	bytes_left += 1;
518		518
519	/* We return Not Active if we get any kind of error */	519	/* We return Not Active if we get any kind of error */
520	exit_is_tx_active:	520	exit_is_tx_active:
521	dev_dbg(&port->port->dev, "%s - return %d\n", __func__, bytes_left);	521	dev_dbg(&port->port->dev, "%s - return %d\n", __func__, bytes_left);
522		522
523	kfree(lsr);	523	kfree(lsr);
524	kfree(oedb);	524	kfree(oedb);
525	return bytes_left;	525	return bytes_left;
526	}	526	}
527		527
528	static int choose_config(struct usb_device *dev)	528	static int choose_config(struct usb_device *dev)
529	{	529	{
530	/*	530	/*
531	* There may be multiple configurations on this device, in which case	531	* There may be multiple configurations on this device, in which case
532	* we would need to read and parse all of them to find out which one	532	* we would need to read and parse all of them to find out which one
533	* we want. However, we just support one config at this point,	533	* we want. However, we just support one config at this point,
534	* configuration # 1, which is Config Descriptor 0.	534	* configuration # 1, which is Config Descriptor 0.
535	*/	535	*/
536		536
537	dev_dbg(&dev->dev, "%s - Number of Interfaces = %d\n",	537	dev_dbg(&dev->dev, "%s - Number of Interfaces = %d\n",
538	__func__, dev->config->desc.bNumInterfaces);	538	__func__, dev->config->desc.bNumInterfaces);
539	dev_dbg(&dev->dev, "%s - MAX Power = %d\n",	539	dev_dbg(&dev->dev, "%s - MAX Power = %d\n",
540	__func__, dev->config->desc.bMaxPower * 2);	540	__func__, dev->config->desc.bMaxPower * 2);
541		541
542	if (dev->config->desc.bNumInterfaces != 1) {	542	if (dev->config->desc.bNumInterfaces != 1) {
543	dev_err(&dev->dev, "%s - bNumInterfaces is not 1, ERROR!\n", __func__);	543	dev_err(&dev->dev, "%s - bNumInterfaces is not 1, ERROR!\n", __func__);
544	return -ENODEV;	544	return -ENODEV;
545	}	545	}
546		546
547	return 0;	547	return 0;
548	}	548	}
549		549
550	static int read_rom(struct edgeport_serial *serial,	550	static int read_rom(struct edgeport_serial *serial,
551	int start_address, int length, __u8 *buffer)	551	int start_address, int length, __u8 *buffer)
552	{	552	{
553	int status;	553	int status;
554		554
555	if (serial->product_info.TiMode == TI_MODE_DOWNLOAD) {	555	if (serial->product_info.TiMode == TI_MODE_DOWNLOAD) {
556	status = read_download_mem(serial->serial->dev,	556	status = read_download_mem(serial->serial->dev,
557	start_address,	557	start_address,
558	length,	558	length,
559	serial->TI_I2C_Type,	559	serial->TI_I2C_Type,
560	buffer);	560	buffer);
561	} else {	561	} else {
562	status = read_boot_mem(serial, start_address, length,	562	status = read_boot_mem(serial, start_address, length,
563	buffer);	563	buffer);
564	}	564	}
565	return status;	565	return status;
566	}	566	}
567		567
568	static int write_rom(struct edgeport_serial *serial, int start_address,	568	static int write_rom(struct edgeport_serial *serial, int start_address,
569	int length, __u8 *buffer)	569	int length, __u8 *buffer)
570	{	570	{
571	if (serial->product_info.TiMode == TI_MODE_BOOT)	571	if (serial->product_info.TiMode == TI_MODE_BOOT)
572	return write_boot_mem(serial, start_address, length,	572	return write_boot_mem(serial, start_address, length,
573	buffer);	573	buffer);
574		574
575	if (serial->product_info.TiMode == TI_MODE_DOWNLOAD)	575	if (serial->product_info.TiMode == TI_MODE_DOWNLOAD)
576	return write_i2c_mem(serial, start_address, length,	576	return write_i2c_mem(serial, start_address, length,
577	serial->TI_I2C_Type, buffer);	577	serial->TI_I2C_Type, buffer);
578	return -EINVAL;	578	return -EINVAL;
579	}	579	}
580		580
581		581
582		582
583	/* Read a descriptor header from I2C based on type */	583	/* Read a descriptor header from I2C based on type */
584	static int get_descriptor_addr(struct edgeport_serial *serial,	584	static int get_descriptor_addr(struct edgeport_serial *serial,
585	int desc_type, struct ti_i2c_desc *rom_desc)	585	int desc_type, struct ti_i2c_desc *rom_desc)
586	{	586	{
587	int start_address;	587	int start_address;
588	int status;	588	int status;
589		589
590	/* Search for requested descriptor in I2C */	590	/* Search for requested descriptor in I2C */
591	start_address = 2;	591	start_address = 2;
592	do {	592	do {
593	status = read_rom(serial,	593	status = read_rom(serial,
594	start_address,	594	start_address,
595	sizeof(struct ti_i2c_desc),	595	sizeof(struct ti_i2c_desc),
596	(__u8 *)rom_desc);	596	(__u8 *)rom_desc);
597	if (status)	597	if (status)
598	return 0;	598	return 0;
599		599
600	if (rom_desc->Type == desc_type)	600	if (rom_desc->Type == desc_type)
601	return start_address;	601	return start_address;
602		602
603	start_address = start_address + sizeof(struct ti_i2c_desc) +	603	start_address = start_address + sizeof(struct ti_i2c_desc) +
604	le16_to_cpu(rom_desc->Size);	604	le16_to_cpu(rom_desc->Size);
605		605
606	} while ((start_address < TI_MAX_I2C_SIZE) && rom_desc->Type);	606	} while ((start_address < TI_MAX_I2C_SIZE) && rom_desc->Type);
607		607
608	return 0;	608	return 0;
609	}	609	}
610		610
611	/* Validate descriptor checksum */	611	/* Validate descriptor checksum */
612	static int valid_csum(struct ti_i2c_desc rom_desc, __u8 buffer)	612	static int valid_csum(struct ti_i2c_desc rom_desc, __u8 buffer)
613	{	613	{
614	__u16 i;	614	__u16 i;
615	__u8 cs = 0;	615	__u8 cs = 0;
616		616
617	for (i = 0; i < le16_to_cpu(rom_desc->Size); i++)	617	for (i = 0; i < le16_to_cpu(rom_desc->Size); i++)
618	cs = (__u8)(cs + buffer[i]);	618	cs = (__u8)(cs + buffer[i]);
619		619
620	if (cs != rom_desc->CheckSum) {	620	if (cs != rom_desc->CheckSum) {
621	pr_debug("%s - Mismatch %x - %x", __func__, rom_desc->CheckSum, cs);	621	pr_debug("%s - Mismatch %x - %x", __func__, rom_desc->CheckSum, cs);
622	return -EINVAL;	622	return -EINVAL;
623	}	623	}
624	return 0;	624	return 0;
625	}	625	}
626		626
627	/* Make sure that the I2C image is good */	627	/* Make sure that the I2C image is good */
628	static int check_i2c_image(struct edgeport_serial *serial)	628	static int check_i2c_image(struct edgeport_serial *serial)
629	{	629	{
630	struct device *dev = &serial->serial->dev->dev;	630	struct device *dev = &serial->serial->dev->dev;
631	int status = 0;	631	int status = 0;
632	struct ti_i2c_desc *rom_desc;	632	struct ti_i2c_desc *rom_desc;
633	int start_address = 2;	633	int start_address = 2;
634	__u8 *buffer;	634	__u8 *buffer;
635	__u16 ttype;	635	__u16 ttype;
636		636
637	rom_desc = kmalloc(sizeof(*rom_desc), GFP_KERNEL);	637	rom_desc = kmalloc(sizeof(*rom_desc), GFP_KERNEL);
638	if (!rom_desc)	638	if (!rom_desc)
639	return -ENOMEM;	639	return -ENOMEM;
640		640
641	buffer = kmalloc(TI_MAX_I2C_SIZE, GFP_KERNEL);	641	buffer = kmalloc(TI_MAX_I2C_SIZE, GFP_KERNEL);
642	if (!buffer) {	642	if (!buffer) {
643	kfree(rom_desc);	643	kfree(rom_desc);
644	return -ENOMEM;	644	return -ENOMEM;
645	}	645	}
646		646
647	/* Read the first byte (Signature0) must be 0x52 or 0x10 */	647	/* Read the first byte (Signature0) must be 0x52 or 0x10 */
648	status = read_rom(serial, 0, 1, buffer);	648	status = read_rom(serial, 0, 1, buffer);
649	if (status)	649	if (status)
650	goto out;	650	goto out;
651		651
652	if (buffer != UMP5152 && buffer != UMP3410) {	652	if (buffer != UMP5152 && buffer != UMP3410) {
653	dev_err(dev, "%s - invalid buffer signature\n", __func__);	653	dev_err(dev, "%s - invalid buffer signature\n", __func__);
654	status = -ENODEV;	654	status = -ENODEV;
655	goto out;	655	goto out;
656	}	656	}
657		657
658	do {	658	do {
659	/* Validate the I2C */	659	/* Validate the I2C */
660	status = read_rom(serial,	660	status = read_rom(serial,
661	start_address,	661	start_address,
662	sizeof(struct ti_i2c_desc),	662	sizeof(struct ti_i2c_desc),
663	(__u8 *)rom_desc);	663	(__u8 *)rom_desc);
664	if (status)	664	if (status)
665	break;	665	break;
666		666
667	if ((start_address + sizeof(struct ti_i2c_desc) +	667	if ((start_address + sizeof(struct ti_i2c_desc) +
668	le16_to_cpu(rom_desc->Size)) > TI_MAX_I2C_SIZE) {	668	le16_to_cpu(rom_desc->Size)) > TI_MAX_I2C_SIZE) {
669	status = -ENODEV;	669	status = -ENODEV;
670	dev_dbg(dev, "%s - structure too big, erroring out.\n", __func__);	670	dev_dbg(dev, "%s - structure too big, erroring out.\n", __func__);
671	break;	671	break;
672	}	672	}
673		673
674	dev_dbg(dev, "%s Type = 0x%x\n", __func__, rom_desc->Type);	674	dev_dbg(dev, "%s Type = 0x%x\n", __func__, rom_desc->Type);
675		675
676	/* Skip type 2 record */	676	/* Skip type 2 record */
677	ttype = rom_desc->Type & 0x0f;	677	ttype = rom_desc->Type & 0x0f;
678	if (ttype != I2C_DESC_TYPE_FIRMWARE_BASIC	678	if (ttype != I2C_DESC_TYPE_FIRMWARE_BASIC
679	&& ttype != I2C_DESC_TYPE_FIRMWARE_AUTO) {	679	&& ttype != I2C_DESC_TYPE_FIRMWARE_AUTO) {
680	/* Read the descriptor data */	680	/* Read the descriptor data */
681	status = read_rom(serial, start_address +	681	status = read_rom(serial, start_address +
682	sizeof(struct ti_i2c_desc),	682	sizeof(struct ti_i2c_desc),
683	le16_to_cpu(rom_desc->Size),	683	le16_to_cpu(rom_desc->Size),
684	buffer);	684	buffer);
685	if (status)	685	if (status)
686	break;	686	break;
687		687
688	status = valid_csum(rom_desc, buffer);	688	status = valid_csum(rom_desc, buffer);
689	if (status)	689	if (status)
690	break;	690	break;
691	}	691	}
692	start_address = start_address + sizeof(struct ti_i2c_desc) +	692	start_address = start_address + sizeof(struct ti_i2c_desc) +
693	le16_to_cpu(rom_desc->Size);	693	le16_to_cpu(rom_desc->Size);
694		694
695	} while ((rom_desc->Type != I2C_DESC_TYPE_ION) &&	695	} while ((rom_desc->Type != I2C_DESC_TYPE_ION) &&
696	(start_address < TI_MAX_I2C_SIZE));	696	(start_address < TI_MAX_I2C_SIZE));
697		697
698	if ((rom_desc->Type != I2C_DESC_TYPE_ION) \|\|	698	if ((rom_desc->Type != I2C_DESC_TYPE_ION) \|\|
699	(start_address > TI_MAX_I2C_SIZE))	699	(start_address > TI_MAX_I2C_SIZE))
700	status = -ENODEV;	700	status = -ENODEV;
701		701
702	out:	702	out:
703	kfree(buffer);	703	kfree(buffer);
704	kfree(rom_desc);	704	kfree(rom_desc);
705	return status;	705	return status;
706	}	706	}
707		707
708	static int get_manuf_info(struct edgeport_serial serial, __u8 buffer)	708	static int get_manuf_info(struct edgeport_serial serial, __u8 buffer)
709	{	709	{
710	int status;	710	int status;
711	int start_address;	711	int start_address;
712	struct ti_i2c_desc *rom_desc;	712	struct ti_i2c_desc *rom_desc;
713	struct edge_ti_manuf_descriptor *desc;	713	struct edge_ti_manuf_descriptor *desc;
714	struct device *dev = &serial->serial->dev->dev;	714	struct device *dev = &serial->serial->dev->dev;
715		715
716	rom_desc = kmalloc(sizeof(*rom_desc), GFP_KERNEL);	716	rom_desc = kmalloc(sizeof(*rom_desc), GFP_KERNEL);
717	if (!rom_desc)	717	if (!rom_desc)
718	return -ENOMEM;	718	return -ENOMEM;
719		719
720	start_address = get_descriptor_addr(serial, I2C_DESC_TYPE_ION,	720	start_address = get_descriptor_addr(serial, I2C_DESC_TYPE_ION,
721	rom_desc);	721	rom_desc);
722		722
723	if (!start_address) {	723	if (!start_address) {
724	dev_dbg(dev, "%s - Edge Descriptor not found in I2C\n", __func__);	724	dev_dbg(dev, "%s - Edge Descriptor not found in I2C\n", __func__);
725	status = -ENODEV;	725	status = -ENODEV;
726	goto exit;	726	goto exit;
727	}	727	}
728		728
729	/* Read the descriptor data */	729	/* Read the descriptor data */
730	status = read_rom(serial, start_address+sizeof(struct ti_i2c_desc),	730	status = read_rom(serial, start_address+sizeof(struct ti_i2c_desc),
731	le16_to_cpu(rom_desc->Size), buffer);	731	le16_to_cpu(rom_desc->Size), buffer);
732	if (status)	732	if (status)
733	goto exit;	733	goto exit;
734		734
735	status = valid_csum(rom_desc, buffer);	735	status = valid_csum(rom_desc, buffer);
736		736
737	desc = (struct edge_ti_manuf_descriptor *)buffer;	737	desc = (struct edge_ti_manuf_descriptor *)buffer;
738	dev_dbg(dev, "%s - IonConfig 0x%x\n", __func__, desc->IonConfig);	738	dev_dbg(dev, "%s - IonConfig 0x%x\n", __func__, desc->IonConfig);
739	dev_dbg(dev, "%s - Version %d\n", __func__, desc->Version);	739	dev_dbg(dev, "%s - Version %d\n", __func__, desc->Version);
740	dev_dbg(dev, "%s - Cpu/Board 0x%x\n", __func__, desc->CpuRev_BoardRev);	740	dev_dbg(dev, "%s - Cpu/Board 0x%x\n", __func__, desc->CpuRev_BoardRev);
741	dev_dbg(dev, "%s - NumPorts %d\n", __func__, desc->NumPorts);	741	dev_dbg(dev, "%s - NumPorts %d\n", __func__, desc->NumPorts);
742	dev_dbg(dev, "%s - NumVirtualPorts %d\n", __func__, desc->NumVirtualPorts);	742	dev_dbg(dev, "%s - NumVirtualPorts %d\n", __func__, desc->NumVirtualPorts);
743	dev_dbg(dev, "%s - TotalPorts %d\n", __func__, desc->TotalPorts);	743	dev_dbg(dev, "%s - TotalPorts %d\n", __func__, desc->TotalPorts);
744		744
745	exit:	745	exit:
746	kfree(rom_desc);	746	kfree(rom_desc);
747	return status;	747	return status;
748	}	748	}
749		749
750	/* Build firmware header used for firmware update */	750	/* Build firmware header used for firmware update */
751	static int build_i2c_fw_hdr(__u8 header, struct device dev)	751	static int build_i2c_fw_hdr(__u8 header, struct device dev)
752	{	752	{
753	__u8 *buffer;	753	__u8 *buffer;
754	int buffer_size;	754	int buffer_size;
755	int i;	755	int i;
756	int err;	756	int err;
757	__u8 cs = 0;	757	__u8 cs = 0;
758	struct ti_i2c_desc *i2c_header;	758	struct ti_i2c_desc *i2c_header;
759	struct ti_i2c_image_header *img_header;	759	struct ti_i2c_image_header *img_header;
760	struct ti_i2c_firmware_rec *firmware_rec;	760	struct ti_i2c_firmware_rec *firmware_rec;
761	const struct firmware *fw;	761	const struct firmware *fw;
762	const char *fw_name = "edgeport/down3.bin";	762	const char *fw_name = "edgeport/down3.bin";
763		763
764	/* In order to update the I2C firmware we must change the type 2 record	764	/* In order to update the I2C firmware we must change the type 2 record
765	* to type 0xF2. This will force the UMP to come up in Boot Mode.	765	* to type 0xF2. This will force the UMP to come up in Boot Mode.
766	* Then while in boot mode, the driver will download the latest	766	* Then while in boot mode, the driver will download the latest
767	* firmware (padded to 15.5k) into the UMP ram. And finally when the	767	* firmware (padded to 15.5k) into the UMP ram. And finally when the
768	* device comes back up in download mode the driver will cause the new	768	* device comes back up in download mode the driver will cause the new
769	* firmware to be copied from the UMP Ram to I2C and the firmware will	769	* firmware to be copied from the UMP Ram to I2C and the firmware will
770	* update the record type from 0xf2 to 0x02.	770	* update the record type from 0xf2 to 0x02.
771	*/	771	*/
772		772
773	/* Allocate a 15.5k buffer + 2 bytes for version number	773	/* Allocate a 15.5k buffer + 2 bytes for version number
774	* (Firmware Record) */	774	* (Firmware Record) */
775	buffer_size = (((1024 * 16) - 512 ) +	775	buffer_size = (((1024 * 16) - 512 ) +
776	sizeof(struct ti_i2c_firmware_rec));	776	sizeof(struct ti_i2c_firmware_rec));
777		777
778	buffer = kmalloc(buffer_size, GFP_KERNEL);	778	buffer = kmalloc(buffer_size, GFP_KERNEL);
779	if (!buffer)	779	if (!buffer)
780	return -ENOMEM;	780	return -ENOMEM;
781		781
782	// Set entire image of 0xffs	782	// Set entire image of 0xffs
783	memset(buffer, 0xff, buffer_size);	783	memset(buffer, 0xff, buffer_size);
784		784
785	err = request_firmware(&fw, fw_name, dev);	785	err = request_firmware(&fw, fw_name, dev);
786	if (err) {	786	if (err) {
787	dev_err(dev, "Failed to load image \"%s\" err %d\n",	787	dev_err(dev, "Failed to load image \"%s\" err %d\n",
788	fw_name, err);	788	fw_name, err);
789	kfree(buffer);	789	kfree(buffer);
790	return err;	790	return err;
791	}	791	}
792		792
793	/* Save Download Version Number */	793	/* Save Download Version Number */
794	OperationalMajorVersion = fw->data[0];	794	OperationalMajorVersion = fw->data[0];
795	OperationalMinorVersion = fw->data[1];	795	OperationalMinorVersion = fw->data[1];
796	OperationalBuildNumber = fw->data[2] \| (fw->data[3] << 8);	796	OperationalBuildNumber = fw->data[2] \| (fw->data[3] << 8);
797		797
798	/* Copy version number into firmware record */	798	/* Copy version number into firmware record */
799	firmware_rec = (struct ti_i2c_firmware_rec *)buffer;	799	firmware_rec = (struct ti_i2c_firmware_rec *)buffer;
800		800
801	firmware_rec->Ver_Major = OperationalMajorVersion;	801	firmware_rec->Ver_Major = OperationalMajorVersion;
802	firmware_rec->Ver_Minor = OperationalMinorVersion;	802	firmware_rec->Ver_Minor = OperationalMinorVersion;
803		803
804	/* Pointer to fw_down memory image */	804	/* Pointer to fw_down memory image */
805	img_header = (struct ti_i2c_image_header *)&fw->data[4];	805	img_header = (struct ti_i2c_image_header *)&fw->data[4];
806		806
807	memcpy(buffer + sizeof(struct ti_i2c_firmware_rec),	807	memcpy(buffer + sizeof(struct ti_i2c_firmware_rec),
808	&fw->data[4 + sizeof(struct ti_i2c_image_header)],	808	&fw->data[4 + sizeof(struct ti_i2c_image_header)],
809	le16_to_cpu(img_header->Length));	809	le16_to_cpu(img_header->Length));
810		810
811	release_firmware(fw);	811	release_firmware(fw);
812		812
813	for (i=0; i < buffer_size; i++) {	813	for (i=0; i < buffer_size; i++) {
814	cs = (__u8)(cs + buffer[i]);	814	cs = (__u8)(cs + buffer[i]);
815	}	815	}
816		816
817	kfree(buffer);	817	kfree(buffer);
818		818
819	/* Build new header */	819	/* Build new header */
820	i2c_header = (struct ti_i2c_desc *)header;	820	i2c_header = (struct ti_i2c_desc *)header;
821	firmware_rec = (struct ti_i2c_firmware_rec*)i2c_header->Data;	821	firmware_rec = (struct ti_i2c_firmware_rec*)i2c_header->Data;
822		822
823	i2c_header->Type = I2C_DESC_TYPE_FIRMWARE_BLANK;	823	i2c_header->Type = I2C_DESC_TYPE_FIRMWARE_BLANK;
824	i2c_header->Size = (__u16)buffer_size;	824	i2c_header->Size = cpu_to_le16(buffer_size);
825	i2c_header->CheckSum = cs;	825	i2c_header->CheckSum = cs;
826	firmware_rec->Ver_Major = OperationalMajorVersion;	826	firmware_rec->Ver_Major = OperationalMajorVersion;
827	firmware_rec->Ver_Minor = OperationalMinorVersion;	827	firmware_rec->Ver_Minor = OperationalMinorVersion;
828		828
829	return 0;	829	return 0;
830	}	830	}
831		831
832	/* Try to figure out what type of I2c we have */	832	/* Try to figure out what type of I2c we have */
833	static int i2c_type_bootmode(struct edgeport_serial *serial)	833	static int i2c_type_bootmode(struct edgeport_serial *serial)
834	{	834	{
835	struct device *dev = &serial->serial->dev->dev;	835	struct device *dev = &serial->serial->dev->dev;
836	int status;	836	int status;
837	u8 *data;	837	u8 *data;
838		838
839	data = kmalloc(1, GFP_KERNEL);	839	data = kmalloc(1, GFP_KERNEL);
840	if (!data)	840	if (!data)
841	return -ENOMEM;	841	return -ENOMEM;
842		842
843	/* Try to read type 2 */	843	/* Try to read type 2 */
844	status = ti_vread_sync(serial->serial->dev, UMPC_MEMORY_READ,	844	status = ti_vread_sync(serial->serial->dev, UMPC_MEMORY_READ,
845	DTK_ADDR_SPACE_I2C_TYPE_II, 0, data, 0x01);	845	DTK_ADDR_SPACE_I2C_TYPE_II, 0, data, 0x01);
846	if (status)	846	if (status)
847	dev_dbg(dev, "%s - read 2 status error = %d\n", __func__, status);	847	dev_dbg(dev, "%s - read 2 status error = %d\n", __func__, status);
848	else	848	else
849	dev_dbg(dev, "%s - read 2 data = 0x%x\n", __func__, *data);	849	dev_dbg(dev, "%s - read 2 data = 0x%x\n", __func__, *data);
850	if ((!status) && (data == UMP5152 \|\| data == UMP3410)) {	850	if ((!status) && (data == UMP5152 \|\| data == UMP3410)) {
851	dev_dbg(dev, "%s - ROM_TYPE_II\n", __func__);	851	dev_dbg(dev, "%s - ROM_TYPE_II\n", __func__);
852	serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_II;	852	serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_II;
853	goto out;	853	goto out;
854	}	854	}
855		855
856	/* Try to read type 3 */	856	/* Try to read type 3 */
857	status = ti_vread_sync(serial->serial->dev, UMPC_MEMORY_READ,	857	status = ti_vread_sync(serial->serial->dev, UMPC_MEMORY_READ,
858	DTK_ADDR_SPACE_I2C_TYPE_III, 0, data, 0x01);	858	DTK_ADDR_SPACE_I2C_TYPE_III, 0, data, 0x01);
859	if (status)	859	if (status)
860	dev_dbg(dev, "%s - read 3 status error = %d\n", __func__, status);	860	dev_dbg(dev, "%s - read 3 status error = %d\n", __func__, status);
861	else	861	else
862	dev_dbg(dev, "%s - read 2 data = 0x%x\n", __func__, *data);	862	dev_dbg(dev, "%s - read 2 data = 0x%x\n", __func__, *data);
863	if ((!status) && (data == UMP5152 \|\| data == UMP3410)) {	863	if ((!status) && (data == UMP5152 \|\| data == UMP3410)) {
864	dev_dbg(dev, "%s - ROM_TYPE_III\n", __func__);	864	dev_dbg(dev, "%s - ROM_TYPE_III\n", __func__);
865	serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_III;	865	serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_III;
866	goto out;	866	goto out;
867	}	867	}
868		868
869	dev_dbg(dev, "%s - Unknown\n", __func__);	869	dev_dbg(dev, "%s - Unknown\n", __func__);
870	serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_II;	870	serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_II;
871	status = -ENODEV;	871	status = -ENODEV;
872	out:	872	out:
873	kfree(data);	873	kfree(data);
874	return status;	874	return status;
875	}	875	}
876		876
877	static int bulk_xfer(struct usb_serial serial, void buffer,	877	static int bulk_xfer(struct usb_serial serial, void buffer,
878	int length, int *num_sent)	878	int length, int *num_sent)
879	{	879	{
880	int status;	880	int status;
881		881
882	status = usb_bulk_msg(serial->dev,	882	status = usb_bulk_msg(serial->dev,
883	usb_sndbulkpipe(serial->dev,	883	usb_sndbulkpipe(serial->dev,
884	serial->port[0]->bulk_out_endpointAddress),	884	serial->port[0]->bulk_out_endpointAddress),
885	buffer, length, num_sent, 1000);	885	buffer, length, num_sent, 1000);
886	return status;	886	return status;
887	}	887	}
888		888
889	/* Download given firmware image to the device (IN BOOT MODE) */	889	/* Download given firmware image to the device (IN BOOT MODE) */
890	static int download_code(struct edgeport_serial serial, __u8 image,	890	static int download_code(struct edgeport_serial serial, __u8 image,
891	int image_length)	891	int image_length)
892	{	892	{
893	int status = 0;	893	int status = 0;
894	int pos;	894	int pos;
895	int transfer;	895	int transfer;
896	int done;	896	int done;
897		897
898	/* Transfer firmware image */	898	/* Transfer firmware image */
899	for (pos = 0; pos < image_length; ) {	899	for (pos = 0; pos < image_length; ) {
900	/* Read the next buffer from file */	900	/* Read the next buffer from file */
901	transfer = image_length - pos;	901	transfer = image_length - pos;
902	if (transfer > EDGE_FW_BULK_MAX_PACKET_SIZE)	902	if (transfer > EDGE_FW_BULK_MAX_PACKET_SIZE)
903	transfer = EDGE_FW_BULK_MAX_PACKET_SIZE;	903	transfer = EDGE_FW_BULK_MAX_PACKET_SIZE;
904		904
905	/* Transfer data */	905	/* Transfer data */
906	status = bulk_xfer(serial->serial, &image[pos],	906	status = bulk_xfer(serial->serial, &image[pos],
907	transfer, &done);	907	transfer, &done);
908	if (status)	908	if (status)
909	break;	909	break;
910	/* Advance buffer pointer */	910	/* Advance buffer pointer */
911	pos += done;	911	pos += done;
912	}	912	}
913		913
914	return status;	914	return status;
915	}	915	}
916		916
917	/* FIXME!!! */	917	/* FIXME!!! */
918	static int config_boot_dev(struct usb_device *dev)	918	static int config_boot_dev(struct usb_device *dev)
919	{	919	{
920	return 0;	920	return 0;
921	}	921	}
922		922
923	static int ti_cpu_rev(struct edge_ti_manuf_descriptor *desc)	923	static int ti_cpu_rev(struct edge_ti_manuf_descriptor *desc)
924	{	924	{
925	return TI_GET_CPU_REVISION(desc->CpuRev_BoardRev);	925	return TI_GET_CPU_REVISION(desc->CpuRev_BoardRev);
926	}	926	}
927		927
928	/**	928	/**
929	* DownloadTIFirmware - Download run-time operating firmware to the TI5052	929	* DownloadTIFirmware - Download run-time operating firmware to the TI5052
930	*	930	*
931	* This routine downloads the main operating code into the TI5052, using the	931	* This routine downloads the main operating code into the TI5052, using the
932	* boot code already burned into E2PROM or ROM.	932	* boot code already burned into E2PROM or ROM.
933	*/	933	*/
934	static int download_fw(struct edgeport_serial *serial)	934	static int download_fw(struct edgeport_serial *serial)
935	{	935	{
936	struct device *dev = &serial->serial->dev->dev;	936	struct device *dev = &serial->serial->dev->dev;
937	int status = 0;	937	int status = 0;
938	int start_address;	938	int start_address;
939	struct edge_ti_manuf_descriptor *ti_manuf_desc;	939	struct edge_ti_manuf_descriptor *ti_manuf_desc;
940	struct usb_interface_descriptor *interface;	940	struct usb_interface_descriptor *interface;
941	int download_cur_ver;	941	int download_cur_ver;
942	int download_new_ver;	942	int download_new_ver;
943		943
944	/* This routine is entered by both the BOOT mode and the Download mode	944	/* This routine is entered by both the BOOT mode and the Download mode
945	* We can determine which code is running by the reading the config	945	* We can determine which code is running by the reading the config
946	* descriptor and if we have only one bulk pipe it is in boot mode	946	* descriptor and if we have only one bulk pipe it is in boot mode
947	*/	947	*/
948	serial->product_info.hardware_type = HARDWARE_TYPE_TIUMP;	948	serial->product_info.hardware_type = HARDWARE_TYPE_TIUMP;
949		949
950	/* Default to type 2 i2c */	950	/* Default to type 2 i2c */
951	serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_II;	951	serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_II;
952		952
953	status = choose_config(serial->serial->dev);	953	status = choose_config(serial->serial->dev);
954	if (status)	954	if (status)
955	return status;	955	return status;
956		956
957	interface = &serial->serial->interface->cur_altsetting->desc;	957	interface = &serial->serial->interface->cur_altsetting->desc;
958	if (!interface) {	958	if (!interface) {
959	dev_err(dev, "%s - no interface set, error!\n", __func__);	959	dev_err(dev, "%s - no interface set, error!\n", __func__);
960	return -ENODEV;	960	return -ENODEV;
961	}	961	}
962		962
963	/*	963	/*
964	* Setup initial mode -- the default mode 0 is TI_MODE_CONFIGURING	964	* Setup initial mode -- the default mode 0 is TI_MODE_CONFIGURING
965	* if we have more than one endpoint we are definitely in download	965	* if we have more than one endpoint we are definitely in download
966	* mode	966	* mode
967	*/	967	*/
968	if (interface->bNumEndpoints > 1)	968	if (interface->bNumEndpoints > 1)
969	serial->product_info.TiMode = TI_MODE_DOWNLOAD;	969	serial->product_info.TiMode = TI_MODE_DOWNLOAD;
970	else	970	else
971	/* Otherwise we will remain in configuring mode */	971	/* Otherwise we will remain in configuring mode */
972	serial->product_info.TiMode = TI_MODE_CONFIGURING;	972	serial->product_info.TiMode = TI_MODE_CONFIGURING;
973		973
974	/********************************************************************/	974	/********************************************************************/
975	/* Download Mode */	975	/* Download Mode */
976	/********************************************************************/	976	/********************************************************************/
977	if (serial->product_info.TiMode == TI_MODE_DOWNLOAD) {	977	if (serial->product_info.TiMode == TI_MODE_DOWNLOAD) {
978	struct ti_i2c_desc *rom_desc;	978	struct ti_i2c_desc *rom_desc;
979		979
980	dev_dbg(dev, "%s - RUNNING IN DOWNLOAD MODE\n", __func__);	980	dev_dbg(dev, "%s - RUNNING IN DOWNLOAD MODE\n", __func__);
981		981
982	status = check_i2c_image(serial);	982	status = check_i2c_image(serial);
983	if (status) {	983	if (status) {
984	dev_dbg(dev, "%s - DOWNLOAD MODE -- BAD I2C\n", __func__);	984	dev_dbg(dev, "%s - DOWNLOAD MODE -- BAD I2C\n", __func__);
985	return status;	985	return status;
986	}	986	}
987		987
988	/* Validate Hardware version number	988	/* Validate Hardware version number
989	* Read Manufacturing Descriptor from TI Based Edgeport	989	* Read Manufacturing Descriptor from TI Based Edgeport
990	*/	990	*/
991	ti_manuf_desc = kmalloc(sizeof(*ti_manuf_desc), GFP_KERNEL);	991	ti_manuf_desc = kmalloc(sizeof(*ti_manuf_desc), GFP_KERNEL);
992	if (!ti_manuf_desc)	992	if (!ti_manuf_desc)
993	return -ENOMEM;	993	return -ENOMEM;
994		994
995	status = get_manuf_info(serial, (__u8 *)ti_manuf_desc);	995	status = get_manuf_info(serial, (__u8 *)ti_manuf_desc);
996	if (status) {	996	if (status) {
997	kfree(ti_manuf_desc);	997	kfree(ti_manuf_desc);
998	return status;	998	return status;
999	}	999	}
1000		1000
1001	/* Check version number of ION descriptor */	1001	/* Check version number of ION descriptor */
1002	if (!ignore_cpu_rev && ti_cpu_rev(ti_manuf_desc) < 2) {	1002	if (!ignore_cpu_rev && ti_cpu_rev(ti_manuf_desc) < 2) {
1003	dev_dbg(dev, "%s - Wrong CPU Rev %d (Must be 2)\n",	1003	dev_dbg(dev, "%s - Wrong CPU Rev %d (Must be 2)\n",
1004	__func__, ti_cpu_rev(ti_manuf_desc));	1004	__func__, ti_cpu_rev(ti_manuf_desc));
1005	kfree(ti_manuf_desc);	1005	kfree(ti_manuf_desc);
1006	return -EINVAL;	1006	return -EINVAL;
1007	}	1007	}
1008		1008
1009	rom_desc = kmalloc(sizeof(*rom_desc), GFP_KERNEL);	1009	rom_desc = kmalloc(sizeof(*rom_desc), GFP_KERNEL);
1010	if (!rom_desc) {	1010	if (!rom_desc) {
1011	kfree(ti_manuf_desc);	1011	kfree(ti_manuf_desc);
1012	return -ENOMEM;	1012	return -ENOMEM;
1013	}	1013	}
1014		1014
1015	/* Search for type 2 record (firmware record) */	1015	/* Search for type 2 record (firmware record) */
1016	start_address = get_descriptor_addr(serial,	1016	start_address = get_descriptor_addr(serial,
1017	I2C_DESC_TYPE_FIRMWARE_BASIC, rom_desc);	1017	I2C_DESC_TYPE_FIRMWARE_BASIC, rom_desc);
1018	if (start_address != 0) {	1018	if (start_address != 0) {
1019	struct ti_i2c_firmware_rec *firmware_version;	1019	struct ti_i2c_firmware_rec *firmware_version;
1020	u8 *record;	1020	u8 *record;
1021		1021
1022	dev_dbg(dev, "%s - Found Type FIRMWARE (Type 2) record\n", __func__);	1022	dev_dbg(dev, "%s - Found Type FIRMWARE (Type 2) record\n", __func__);
1023		1023
1024	firmware_version = kmalloc(sizeof(*firmware_version),	1024	firmware_version = kmalloc(sizeof(*firmware_version),
1025	GFP_KERNEL);	1025	GFP_KERNEL);
1026	if (!firmware_version) {	1026	if (!firmware_version) {
1027	kfree(rom_desc);	1027	kfree(rom_desc);
1028	kfree(ti_manuf_desc);	1028	kfree(ti_manuf_desc);
1029	return -ENOMEM;	1029	return -ENOMEM;
1030	}	1030	}
1031		1031
1032	/* Validate version number	1032	/* Validate version number
1033	* Read the descriptor data	1033	* Read the descriptor data
1034	*/	1034	*/
1035	status = read_rom(serial, start_address +	1035	status = read_rom(serial, start_address +
1036	sizeof(struct ti_i2c_desc),	1036	sizeof(struct ti_i2c_desc),
1037	sizeof(struct ti_i2c_firmware_rec),	1037	sizeof(struct ti_i2c_firmware_rec),
1038	(__u8 *)firmware_version);	1038	(__u8 *)firmware_version);
1039	if (status) {	1039	if (status) {
1040	kfree(firmware_version);	1040	kfree(firmware_version);
1041	kfree(rom_desc);	1041	kfree(rom_desc);
1042	kfree(ti_manuf_desc);	1042	kfree(ti_manuf_desc);
1043	return status;	1043	return status;
1044	}	1044	}
1045		1045
1046	/* Check version number of download with current	1046	/* Check version number of download with current
1047	version in I2c */	1047	version in I2c */
1048	download_cur_ver = (firmware_version->Ver_Major << 8) +	1048	download_cur_ver = (firmware_version->Ver_Major << 8) +
1049	(firmware_version->Ver_Minor);	1049	(firmware_version->Ver_Minor);
1050	download_new_ver = (OperationalMajorVersion << 8) +	1050	download_new_ver = (OperationalMajorVersion << 8) +
1051	(OperationalMinorVersion);	1051	(OperationalMinorVersion);
1052		1052
1053	dev_dbg(dev, "%s - >> FW Versions Device %d.%d Driver %d.%d\n",	1053	dev_dbg(dev, "%s - >> FW Versions Device %d.%d Driver %d.%d\n",
1054	__func__, firmware_version->Ver_Major,	1054	__func__, firmware_version->Ver_Major,
1055	firmware_version->Ver_Minor,	1055	firmware_version->Ver_Minor,
1056	OperationalMajorVersion,	1056	OperationalMajorVersion,
1057	OperationalMinorVersion);	1057	OperationalMinorVersion);
1058		1058
1059	/* Check if we have an old version in the I2C and	1059	/* Check if we have an old version in the I2C and
1060	update if necessary */	1060	update if necessary */
1061	if (download_cur_ver < download_new_ver) {	1061	if (download_cur_ver < download_new_ver) {
1062	dev_dbg(dev, "%s - Update I2C dld from %d.%d to %d.%d\n",	1062	dev_dbg(dev, "%s - Update I2C dld from %d.%d to %d.%d\n",
1063	__func__,	1063	__func__,
1064	firmware_version->Ver_Major,	1064	firmware_version->Ver_Major,
1065	firmware_version->Ver_Minor,	1065	firmware_version->Ver_Minor,
1066	OperationalMajorVersion,	1066	OperationalMajorVersion,
1067	OperationalMinorVersion);	1067	OperationalMinorVersion);
1068		1068
1069	record = kmalloc(1, GFP_KERNEL);	1069	record = kmalloc(1, GFP_KERNEL);
1070	if (!record) {	1070	if (!record) {
1071	kfree(firmware_version);	1071	kfree(firmware_version);
1072	kfree(rom_desc);	1072	kfree(rom_desc);
1073	kfree(ti_manuf_desc);	1073	kfree(ti_manuf_desc);
1074	return -ENOMEM;	1074	return -ENOMEM;
1075	}	1075	}
1076	/* In order to update the I2C firmware we must	1076	/* In order to update the I2C firmware we must
1077	* change the type 2 record to type 0xF2. This	1077	* change the type 2 record to type 0xF2. This
1078	* will force the UMP to come up in Boot Mode.	1078	* will force the UMP to come up in Boot Mode.
1079	* Then while in boot mode, the driver will	1079	* Then while in boot mode, the driver will
1080	* download the latest firmware (padded to	1080	* download the latest firmware (padded to
1081	* 15.5k) into the UMP ram. Finally when the	1081	* 15.5k) into the UMP ram. Finally when the
1082	* device comes back up in download mode the	1082	* device comes back up in download mode the
1083	* driver will cause the new firmware to be	1083	* driver will cause the new firmware to be
1084	* copied from the UMP Ram to I2C and the	1084	* copied from the UMP Ram to I2C and the
1085	* firmware will update the record type from	1085	* firmware will update the record type from
1086	* 0xf2 to 0x02.	1086	* 0xf2 to 0x02.
1087	*/	1087	*/
1088	*record = I2C_DESC_TYPE_FIRMWARE_BLANK;	1088	*record = I2C_DESC_TYPE_FIRMWARE_BLANK;
1089		1089
1090	/* Change the I2C Firmware record type to	1090	/* Change the I2C Firmware record type to
1091	0xf2 to trigger an update */	1091	0xf2 to trigger an update */
1092	status = write_rom(serial, start_address,	1092	status = write_rom(serial, start_address,
1093	sizeof(*record), record);	1093	sizeof(*record), record);
1094	if (status) {	1094	if (status) {
1095	kfree(record);	1095	kfree(record);
1096	kfree(firmware_version);	1096	kfree(firmware_version);
1097	kfree(rom_desc);	1097	kfree(rom_desc);
1098	kfree(ti_manuf_desc);	1098	kfree(ti_manuf_desc);
1099	return status;	1099	return status;
1100	}	1100	}
1101		1101
1102	/* verify the write -- must do this in order	1102	/* verify the write -- must do this in order
1103	* for write to complete before we do the	1103	* for write to complete before we do the
1104	* hardware reset	1104	* hardware reset
1105	*/	1105	*/
1106	status = read_rom(serial,	1106	status = read_rom(serial,
1107	start_address,	1107	start_address,
1108	sizeof(*record),	1108	sizeof(*record),
1109	record);	1109	record);
1110	if (status) {	1110	if (status) {
1111	kfree(record);	1111	kfree(record);
1112	kfree(firmware_version);	1112	kfree(firmware_version);
1113	kfree(rom_desc);	1113	kfree(rom_desc);
1114	kfree(ti_manuf_desc);	1114	kfree(ti_manuf_desc);
1115	return status;	1115	return status;
1116	}	1116	}
1117		1117
1118	if (*record != I2C_DESC_TYPE_FIRMWARE_BLANK) {	1118	if (*record != I2C_DESC_TYPE_FIRMWARE_BLANK) {
1119	dev_err(dev, "%s - error resetting device\n", __func__);	1119	dev_err(dev, "%s - error resetting device\n", __func__);
1120	kfree(record);	1120	kfree(record);
1121	kfree(firmware_version);	1121	kfree(firmware_version);
1122	kfree(rom_desc);	1122	kfree(rom_desc);
1123	kfree(ti_manuf_desc);	1123	kfree(ti_manuf_desc);
1124	return -ENODEV;	1124	return -ENODEV;
1125	}	1125	}
1126		1126
1127	dev_dbg(dev, "%s - HARDWARE RESET\n", __func__);	1127	dev_dbg(dev, "%s - HARDWARE RESET\n", __func__);
1128		1128
1129	/* Reset UMP -- Back to BOOT MODE */	1129	/* Reset UMP -- Back to BOOT MODE */
1130	status = ti_vsend_sync(serial->serial->dev,	1130	status = ti_vsend_sync(serial->serial->dev,
1131	UMPC_HARDWARE_RESET,	1131	UMPC_HARDWARE_RESET,
1132	0, 0, NULL, 0);	1132	0, 0, NULL, 0);
1133		1133
1134	dev_dbg(dev, "%s - HARDWARE RESET return %d\n", __func__, status);	1134	dev_dbg(dev, "%s - HARDWARE RESET return %d\n", __func__, status);
1135		1135
1136	/* return an error on purpose. */	1136	/* return an error on purpose. */
1137	kfree(record);	1137	kfree(record);
1138	kfree(firmware_version);	1138	kfree(firmware_version);
1139	kfree(rom_desc);	1139	kfree(rom_desc);
1140	kfree(ti_manuf_desc);	1140	kfree(ti_manuf_desc);
1141	return -ENODEV;	1141	return -ENODEV;
1142	}	1142	}
1143	kfree(firmware_version);	1143	kfree(firmware_version);
1144	}	1144	}
1145	/* Search for type 0xF2 record (firmware blank record) */	1145	/* Search for type 0xF2 record (firmware blank record) */
1146	else if ((start_address = get_descriptor_addr(serial, I2C_DESC_TYPE_FIRMWARE_BLANK, rom_desc)) != 0) {	1146	else if ((start_address = get_descriptor_addr(serial, I2C_DESC_TYPE_FIRMWARE_BLANK, rom_desc)) != 0) {
1147	#define HEADER_SIZE (sizeof(struct ti_i2c_desc) + \	1147	#define HEADER_SIZE (sizeof(struct ti_i2c_desc) + \
1148	sizeof(struct ti_i2c_firmware_rec))	1148	sizeof(struct ti_i2c_firmware_rec))
1149	__u8 *header;	1149	__u8 *header;
1150	__u8 *vheader;	1150	__u8 *vheader;
1151		1151
1152	header = kmalloc(HEADER_SIZE, GFP_KERNEL);	1152	header = kmalloc(HEADER_SIZE, GFP_KERNEL);
1153	if (!header) {	1153	if (!header) {
1154	kfree(rom_desc);	1154	kfree(rom_desc);
1155	kfree(ti_manuf_desc);	1155	kfree(ti_manuf_desc);
1156	return -ENOMEM;	1156	return -ENOMEM;
1157	}	1157	}
1158		1158
1159	vheader = kmalloc(HEADER_SIZE, GFP_KERNEL);	1159	vheader = kmalloc(HEADER_SIZE, GFP_KERNEL);
1160	if (!vheader) {	1160	if (!vheader) {
1161	kfree(header);	1161	kfree(header);
1162	kfree(rom_desc);	1162	kfree(rom_desc);
1163	kfree(ti_manuf_desc);	1163	kfree(ti_manuf_desc);
1164	return -ENOMEM;	1164	return -ENOMEM;
1165	}	1165	}
1166		1166
1167	dev_dbg(dev, "%s - Found Type BLANK FIRMWARE (Type F2) record\n", __func__);	1167	dev_dbg(dev, "%s - Found Type BLANK FIRMWARE (Type F2) record\n", __func__);
1168		1168
1169	/*	1169	/*
1170	* In order to update the I2C firmware we must change	1170	* In order to update the I2C firmware we must change
1171	* the type 2 record to type 0xF2. This will force the	1171	* the type 2 record to type 0xF2. This will force the
1172	* UMP to come up in Boot Mode. Then while in boot	1172	* UMP to come up in Boot Mode. Then while in boot
1173	* mode, the driver will download the latest firmware	1173	* mode, the driver will download the latest firmware
1174	* (padded to 15.5k) into the UMP ram. Finally when the	1174	* (padded to 15.5k) into the UMP ram. Finally when the
1175	* device comes back up in download mode the driver	1175	* device comes back up in download mode the driver
1176	* will cause the new firmware to be copied from the	1176	* will cause the new firmware to be copied from the
1177	* UMP Ram to I2C and the firmware will update the	1177	* UMP Ram to I2C and the firmware will update the
1178	* record type from 0xf2 to 0x02.	1178	* record type from 0xf2 to 0x02.
1179	*/	1179	*/
1180	status = build_i2c_fw_hdr(header, dev);	1180	status = build_i2c_fw_hdr(header, dev);
1181	if (status) {	1181	if (status) {
1182	kfree(vheader);	1182	kfree(vheader);
1183	kfree(header);	1183	kfree(header);
1184	kfree(rom_desc);	1184	kfree(rom_desc);
1185	kfree(ti_manuf_desc);	1185	kfree(ti_manuf_desc);
1186	return -EINVAL;	1186	return -EINVAL;
1187	}	1187	}
1188		1188
1189	/* Update I2C with type 0xf2 record with correct	1189	/* Update I2C with type 0xf2 record with correct
1190	size and checksum */	1190	size and checksum */
1191	status = write_rom(serial,	1191	status = write_rom(serial,
1192	start_address,	1192	start_address,
1193	HEADER_SIZE,	1193	HEADER_SIZE,
1194	header);	1194	header);
1195	if (status) {	1195	if (status) {
1196	kfree(vheader);	1196	kfree(vheader);
1197	kfree(header);	1197	kfree(header);
1198	kfree(rom_desc);	1198	kfree(rom_desc);
1199	kfree(ti_manuf_desc);	1199	kfree(ti_manuf_desc);
1200	return -EINVAL;	1200	return -EINVAL;
1201	}	1201	}
1202		1202
1203	/* verify the write -- must do this in order for	1203	/* verify the write -- must do this in order for
1204	write to complete before we do the hardware reset */	1204	write to complete before we do the hardware reset */
1205	status = read_rom(serial, start_address,	1205	status = read_rom(serial, start_address,
1206	HEADER_SIZE, vheader);	1206	HEADER_SIZE, vheader);
1207		1207
1208	if (status) {	1208	if (status) {
1209	dev_dbg(dev, "%s - can't read header back\n", __func__);	1209	dev_dbg(dev, "%s - can't read header back\n", __func__);
1210	kfree(vheader);	1210	kfree(vheader);
1211	kfree(header);	1211	kfree(header);
1212	kfree(rom_desc);	1212	kfree(rom_desc);
1213	kfree(ti_manuf_desc);	1213	kfree(ti_manuf_desc);
1214	return status;	1214	return status;
1215	}	1215	}
1216	if (memcmp(vheader, header, HEADER_SIZE)) {	1216	if (memcmp(vheader, header, HEADER_SIZE)) {
1217	dev_dbg(dev, "%s - write download record failed\n", __func__);	1217	dev_dbg(dev, "%s - write download record failed\n", __func__);
1218	kfree(vheader);	1218	kfree(vheader);
1219	kfree(header);	1219	kfree(header);
1220	kfree(rom_desc);	1220	kfree(rom_desc);
1221	kfree(ti_manuf_desc);	1221	kfree(ti_manuf_desc);
1222	return -EINVAL;	1222	return -EINVAL;
1223	}	1223	}
1224		1224
1225	kfree(vheader);	1225	kfree(vheader);
1226	kfree(header);	1226	kfree(header);
1227		1227
1228	dev_dbg(dev, "%s - Start firmware update\n", __func__);	1228	dev_dbg(dev, "%s - Start firmware update\n", __func__);
1229		1229
1230	/* Tell firmware to copy download image into I2C */	1230	/* Tell firmware to copy download image into I2C */
1231	status = ti_vsend_sync(serial->serial->dev,	1231	status = ti_vsend_sync(serial->serial->dev,
1232	UMPC_COPY_DNLD_TO_I2C, 0, 0, NULL, 0);	1232	UMPC_COPY_DNLD_TO_I2C, 0, 0, NULL, 0);
1233		1233
1234	dev_dbg(dev, "%s - Update complete 0x%x\n", __func__, status);	1234	dev_dbg(dev, "%s - Update complete 0x%x\n", __func__, status);
1235	if (status) {	1235	if (status) {
1236	dev_err(dev,	1236	dev_err(dev,
1237	"%s - UMPC_COPY_DNLD_TO_I2C failed\n",	1237	"%s - UMPC_COPY_DNLD_TO_I2C failed\n",
1238	__func__);	1238	__func__);
1239	kfree(rom_desc);	1239	kfree(rom_desc);
1240	kfree(ti_manuf_desc);	1240	kfree(ti_manuf_desc);
1241	return status;	1241	return status;
1242	}	1242	}
1243	}	1243	}
1244		1244
1245	// The device is running the download code	1245	// The device is running the download code
1246	kfree(rom_desc);	1246	kfree(rom_desc);
1247	kfree(ti_manuf_desc);	1247	kfree(ti_manuf_desc);
1248	return 0;	1248	return 0;
1249	}	1249	}
1250		1250
1251	/********************************************************************/	1251	/********************************************************************/
1252	/* Boot Mode */	1252	/* Boot Mode */
1253	/********************************************************************/	1253	/********************************************************************/
1254	dev_dbg(dev, "%s - RUNNING IN BOOT MODE\n", __func__);	1254	dev_dbg(dev, "%s - RUNNING IN BOOT MODE\n", __func__);
1255		1255
1256	/* Configure the TI device so we can use the BULK pipes for download */	1256	/* Configure the TI device so we can use the BULK pipes for download */
1257	status = config_boot_dev(serial->serial->dev);	1257	status = config_boot_dev(serial->serial->dev);
1258	if (status)	1258	if (status)
1259	return status;	1259	return status;
1260		1260
1261	if (le16_to_cpu(serial->serial->dev->descriptor.idVendor)	1261	if (le16_to_cpu(serial->serial->dev->descriptor.idVendor)
1262	!= USB_VENDOR_ID_ION) {	1262	!= USB_VENDOR_ID_ION) {
1263	dev_dbg(dev, "%s - VID = 0x%x\n", __func__,	1263	dev_dbg(dev, "%s - VID = 0x%x\n", __func__,
1264	le16_to_cpu(serial->serial->dev->descriptor.idVendor));	1264	le16_to_cpu(serial->serial->dev->descriptor.idVendor));
1265	serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_II;	1265	serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_II;
1266	goto stayinbootmode;	1266	goto stayinbootmode;
1267	}	1267	}
1268		1268
1269	/* We have an ION device (I2c Must be programmed)	1269	/* We have an ION device (I2c Must be programmed)
1270	Determine I2C image type */	1270	Determine I2C image type */
1271	if (i2c_type_bootmode(serial))	1271	if (i2c_type_bootmode(serial))
1272	goto stayinbootmode;	1272	goto stayinbootmode;
1273		1273
1274	/* Check for ION Vendor ID and that the I2C is valid */	1274	/* Check for ION Vendor ID and that the I2C is valid */
1275	if (!check_i2c_image(serial)) {	1275	if (!check_i2c_image(serial)) {
1276	struct ti_i2c_image_header *header;	1276	struct ti_i2c_image_header *header;
1277	int i;	1277	int i;
1278	__u8 cs = 0;	1278	__u8 cs = 0;
1279	__u8 *buffer;	1279	__u8 *buffer;
1280	int buffer_size;	1280	int buffer_size;
1281	int err;	1281	int err;
1282	const struct firmware *fw;	1282	const struct firmware *fw;
1283	const char *fw_name = "edgeport/down3.bin";	1283	const char *fw_name = "edgeport/down3.bin";
1284		1284
1285	/* Validate Hardware version number	1285	/* Validate Hardware version number
1286	* Read Manufacturing Descriptor from TI Based Edgeport	1286	* Read Manufacturing Descriptor from TI Based Edgeport
1287	*/	1287	*/
1288	ti_manuf_desc = kmalloc(sizeof(*ti_manuf_desc), GFP_KERNEL);	1288	ti_manuf_desc = kmalloc(sizeof(*ti_manuf_desc), GFP_KERNEL);
1289	if (!ti_manuf_desc)	1289	if (!ti_manuf_desc)
1290	return -ENOMEM;	1290	return -ENOMEM;
1291		1291
1292	status = get_manuf_info(serial, (__u8 *)ti_manuf_desc);	1292	status = get_manuf_info(serial, (__u8 *)ti_manuf_desc);
1293	if (status) {	1293	if (status) {
1294	kfree(ti_manuf_desc);	1294	kfree(ti_manuf_desc);
1295	goto stayinbootmode;	1295	goto stayinbootmode;
1296	}	1296	}
1297		1297
1298	/* Check for version 2 */	1298	/* Check for version 2 */
1299	if (!ignore_cpu_rev && ti_cpu_rev(ti_manuf_desc) < 2) {	1299	if (!ignore_cpu_rev && ti_cpu_rev(ti_manuf_desc) < 2) {
1300	dev_dbg(dev, "%s - Wrong CPU Rev %d (Must be 2)\n",	1300	dev_dbg(dev, "%s - Wrong CPU Rev %d (Must be 2)\n",
1301	__func__, ti_cpu_rev(ti_manuf_desc));	1301	__func__, ti_cpu_rev(ti_manuf_desc));
1302	kfree(ti_manuf_desc);	1302	kfree(ti_manuf_desc);
1303	goto stayinbootmode;	1303	goto stayinbootmode;
1304	}	1304	}
1305		1305
1306	kfree(ti_manuf_desc);	1306	kfree(ti_manuf_desc);
1307		1307
1308	/*	1308	/*
1309	* In order to update the I2C firmware we must change the type	1309	* In order to update the I2C firmware we must change the type
1310	* 2 record to type 0xF2. This will force the UMP to come up	1310	* 2 record to type 0xF2. This will force the UMP to come up
1311	* in Boot Mode. Then while in boot mode, the driver will	1311	* in Boot Mode. Then while in boot mode, the driver will
1312	* download the latest firmware (padded to 15.5k) into the	1312	* download the latest firmware (padded to 15.5k) into the
1313	* UMP ram. Finally when the device comes back up in download	1313	* UMP ram. Finally when the device comes back up in download
1314	* mode the driver will cause the new firmware to be copied	1314	* mode the driver will cause the new firmware to be copied
1315	* from the UMP Ram to I2C and the firmware will update the	1315	* from the UMP Ram to I2C and the firmware will update the
1316	* record type from 0xf2 to 0x02.	1316	* record type from 0xf2 to 0x02.
1317	*	1317	*
1318	* Do we really have to copy the whole firmware image,	1318	* Do we really have to copy the whole firmware image,
1319	* or could we do this in place!	1319	* or could we do this in place!
1320	*/	1320	*/
1321		1321
1322	/* Allocate a 15.5k buffer + 3 byte header */	1322	/* Allocate a 15.5k buffer + 3 byte header */
1323	buffer_size = (((1024 * 16) - 512) +	1323	buffer_size = (((1024 * 16) - 512) +
1324	sizeof(struct ti_i2c_image_header));	1324	sizeof(struct ti_i2c_image_header));
1325	buffer = kmalloc(buffer_size, GFP_KERNEL);	1325	buffer = kmalloc(buffer_size, GFP_KERNEL);
1326	if (!buffer)	1326	if (!buffer)
1327	return -ENOMEM;	1327	return -ENOMEM;
1328		1328
1329	/* Initialize the buffer to 0xff (pad the buffer) */	1329	/* Initialize the buffer to 0xff (pad the buffer) */
1330	memset(buffer, 0xff, buffer_size);	1330	memset(buffer, 0xff, buffer_size);
1331		1331
1332	err = request_firmware(&fw, fw_name, dev);	1332	err = request_firmware(&fw, fw_name, dev);
1333	if (err) {	1333	if (err) {
1334	dev_err(dev, "Failed to load image \"%s\" err %d\n",	1334	dev_err(dev, "Failed to load image \"%s\" err %d\n",
1335	fw_name, err);	1335	fw_name, err);
1336	kfree(buffer);	1336	kfree(buffer);
1337	return err;	1337	return err;
1338	}	1338	}
1339	memcpy(buffer, &fw->data[4], fw->size - 4);	1339	memcpy(buffer, &fw->data[4], fw->size - 4);
1340	release_firmware(fw);	1340	release_firmware(fw);
1341		1341
1342	for (i = sizeof(struct ti_i2c_image_header);	1342	for (i = sizeof(struct ti_i2c_image_header);
1343	i < buffer_size; i++) {	1343	i < buffer_size; i++) {
1344	cs = (__u8)(cs + buffer[i]);	1344	cs = (__u8)(cs + buffer[i]);
1345	}	1345	}
1346		1346
1347	header = (struct ti_i2c_image_header *)buffer;	1347	header = (struct ti_i2c_image_header *)buffer;
1348		1348
1349	/* update length and checksum after padding */	1349	/* update length and checksum after padding */
1350	header->Length = cpu_to_le16((__u16)(buffer_size -	1350	header->Length = cpu_to_le16((__u16)(buffer_size -
1351	sizeof(struct ti_i2c_image_header)));	1351	sizeof(struct ti_i2c_image_header)));
1352	header->CheckSum = cs;	1352	header->CheckSum = cs;
1353		1353
1354	/* Download the operational code */	1354	/* Download the operational code */
1355	dev_dbg(dev, "%s - Downloading operational code image (TI UMP)\n", __func__);	1355	dev_dbg(dev, "%s - Downloading operational code image (TI UMP)\n", __func__);
1356	status = download_code(serial, buffer, buffer_size);	1356	status = download_code(serial, buffer, buffer_size);
1357		1357
1358	kfree(buffer);	1358	kfree(buffer);
1359		1359
1360	if (status) {	1360	if (status) {
1361	dev_dbg(dev, "%s - Error downloading operational code image\n", __func__);	1361	dev_dbg(dev, "%s - Error downloading operational code image\n", __func__);
1362	return status;	1362	return status;
1363	}	1363	}
1364		1364
1365	/* Device will reboot */	1365	/* Device will reboot */
1366	serial->product_info.TiMode = TI_MODE_TRANSITIONING;	1366	serial->product_info.TiMode = TI_MODE_TRANSITIONING;
1367		1367
1368	dev_dbg(dev, "%s - Download successful -- Device rebooting...\n", __func__);	1368	dev_dbg(dev, "%s - Download successful -- Device rebooting...\n", __func__);
1369		1369
1370	/* return an error on purpose */	1370	/* return an error on purpose */
1371	return -ENODEV;	1371	return -ENODEV;
1372	}	1372	}
1373		1373
1374	stayinbootmode:	1374	stayinbootmode:
1375	/* Eprom is invalid or blank stay in boot mode */	1375	/* Eprom is invalid or blank stay in boot mode */
1376	dev_dbg(dev, "%s - STAYING IN BOOT MODE\n", __func__);	1376	dev_dbg(dev, "%s - STAYING IN BOOT MODE\n", __func__);
1377	serial->product_info.TiMode = TI_MODE_BOOT;	1377	serial->product_info.TiMode = TI_MODE_BOOT;
1378		1378
1379	return 0;	1379	return 0;
1380	}	1380	}
1381		1381
1382		1382
1383	static int ti_do_config(struct edgeport_port *port, int feature, int on)	1383	static int ti_do_config(struct edgeport_port *port, int feature, int on)
1384	{	1384	{
1385	int port_number = port->port->port_number;	1385	int port_number = port->port->port_number;
1386		1386
1387	on = !!on; /* 1 or 0 not bitmask */	1387	on = !!on; /* 1 or 0 not bitmask */
1388	return send_cmd(port->port->serial->dev,	1388	return send_cmd(port->port->serial->dev,
1389	feature, (__u8)(UMPM_UART1_PORT + port_number),	1389	feature, (__u8)(UMPM_UART1_PORT + port_number),
1390	on, NULL, 0);	1390	on, NULL, 0);
1391	}	1391	}
1392		1392
1393		1393
1394	static int restore_mcr(struct edgeport_port *port, __u8 mcr)	1394	static int restore_mcr(struct edgeport_port *port, __u8 mcr)
1395	{	1395	{
1396	int status = 0;	1396	int status = 0;
1397		1397
1398	dev_dbg(&port->port->dev, "%s - %x\n", __func__, mcr);	1398	dev_dbg(&port->port->dev, "%s - %x\n", __func__, mcr);
1399		1399
1400	status = ti_do_config(port, UMPC_SET_CLR_DTR, mcr & MCR_DTR);	1400	status = ti_do_config(port, UMPC_SET_CLR_DTR, mcr & MCR_DTR);
1401	if (status)	1401	if (status)
1402	return status;	1402	return status;
1403	status = ti_do_config(port, UMPC_SET_CLR_RTS, mcr & MCR_RTS);	1403	status = ti_do_config(port, UMPC_SET_CLR_RTS, mcr & MCR_RTS);
1404	if (status)	1404	if (status)
1405	return status;	1405	return status;
1406	return ti_do_config(port, UMPC_SET_CLR_LOOPBACK, mcr & MCR_LOOPBACK);	1406	return ti_do_config(port, UMPC_SET_CLR_LOOPBACK, mcr & MCR_LOOPBACK);
1407	}	1407	}
1408		1408
1409	/* Convert TI LSR to standard UART flags */	1409	/* Convert TI LSR to standard UART flags */
1410	static __u8 map_line_status(__u8 ti_lsr)	1410	static __u8 map_line_status(__u8 ti_lsr)
1411	{	1411	{
1412	__u8 lsr = 0;	1412	__u8 lsr = 0;
1413		1413
1414	#define MAP_FLAG(flagUmp, flagUart) \	1414	#define MAP_FLAG(flagUmp, flagUart) \
1415	if (ti_lsr & flagUmp) \	1415	if (ti_lsr & flagUmp) \
1416	lsr \|= flagUart;	1416	lsr \|= flagUart;
1417		1417
1418	MAP_FLAG(UMP_UART_LSR_OV_MASK, LSR_OVER_ERR) /* overrun */	1418	MAP_FLAG(UMP_UART_LSR_OV_MASK, LSR_OVER_ERR) /* overrun */
1419	MAP_FLAG(UMP_UART_LSR_PE_MASK, LSR_PAR_ERR) /* parity error */	1419	MAP_FLAG(UMP_UART_LSR_PE_MASK, LSR_PAR_ERR) /* parity error */
1420	MAP_FLAG(UMP_UART_LSR_FE_MASK, LSR_FRM_ERR) /* framing error */	1420	MAP_FLAG(UMP_UART_LSR_FE_MASK, LSR_FRM_ERR) /* framing error */
1421	MAP_FLAG(UMP_UART_LSR_BR_MASK, LSR_BREAK) /* break detected */	1421	MAP_FLAG(UMP_UART_LSR_BR_MASK, LSR_BREAK) /* break detected */
1422	MAP_FLAG(UMP_UART_LSR_RX_MASK, LSR_RX_AVAIL) /* rx data available */	1422	MAP_FLAG(UMP_UART_LSR_RX_MASK, LSR_RX_AVAIL) /* rx data available */
1423	MAP_FLAG(UMP_UART_LSR_TX_MASK, LSR_TX_EMPTY) /* tx hold reg empty */	1423	MAP_FLAG(UMP_UART_LSR_TX_MASK, LSR_TX_EMPTY) /* tx hold reg empty */
1424		1424
1425	#undef MAP_FLAG	1425	#undef MAP_FLAG
1426		1426
1427	return lsr;	1427	return lsr;
1428	}	1428	}
1429		1429
1430	static void handle_new_msr(struct edgeport_port *edge_port, __u8 msr)	1430	static void handle_new_msr(struct edgeport_port *edge_port, __u8 msr)
1431	{	1431	{
1432	struct async_icount *icount;	1432	struct async_icount *icount;
1433	struct tty_struct *tty;	1433	struct tty_struct *tty;
1434		1434
1435	dev_dbg(&edge_port->port->dev, "%s - %02x\n", __func__, msr);	1435	dev_dbg(&edge_port->port->dev, "%s - %02x\n", __func__, msr);
1436		1436
1437	if (msr & (EDGEPORT_MSR_DELTA_CTS \| EDGEPORT_MSR_DELTA_DSR \|	1437	if (msr & (EDGEPORT_MSR_DELTA_CTS \| EDGEPORT_MSR_DELTA_DSR \|
1438	EDGEPORT_MSR_DELTA_RI \| EDGEPORT_MSR_DELTA_CD)) {	1438	EDGEPORT_MSR_DELTA_RI \| EDGEPORT_MSR_DELTA_CD)) {
1439	icount = &edge_port->port->icount;	1439	icount = &edge_port->port->icount;
1440		1440
1441	/* update input line counters */	1441	/* update input line counters */
1442	if (msr & EDGEPORT_MSR_DELTA_CTS)	1442	if (msr & EDGEPORT_MSR_DELTA_CTS)
1443	icount->cts++;	1443	icount->cts++;
1444	if (msr & EDGEPORT_MSR_DELTA_DSR)	1444	if (msr & EDGEPORT_MSR_DELTA_DSR)
1445	icount->dsr++;	1445	icount->dsr++;
1446	if (msr & EDGEPORT_MSR_DELTA_CD)	1446	if (msr & EDGEPORT_MSR_DELTA_CD)
1447	icount->dcd++;	1447	icount->dcd++;
1448	if (msr & EDGEPORT_MSR_DELTA_RI)	1448	if (msr & EDGEPORT_MSR_DELTA_RI)
1449	icount->rng++;	1449	icount->rng++;
1450	wake_up_interruptible(&edge_port->port->port.delta_msr_wait);	1450	wake_up_interruptible(&edge_port->port->port.delta_msr_wait);
1451	}	1451	}
1452		1452
1453	/* Save the new modem status */	1453	/* Save the new modem status */
1454	edge_port->shadow_msr = msr & 0xf0;	1454	edge_port->shadow_msr = msr & 0xf0;
1455		1455
1456	tty = tty_port_tty_get(&edge_port->port->port);	1456	tty = tty_port_tty_get(&edge_port->port->port);
1457	/* handle CTS flow control */	1457	/* handle CTS flow control */
1458	if (tty && C_CRTSCTS(tty)) {	1458	if (tty && C_CRTSCTS(tty)) {
1459	if (msr & EDGEPORT_MSR_CTS) {	1459	if (msr & EDGEPORT_MSR_CTS) {
1460	tty->hw_stopped = 0;	1460	tty->hw_stopped = 0;
1461	tty_wakeup(tty);	1461	tty_wakeup(tty);
1462	} else {	1462	} else {
1463	tty->hw_stopped = 1;	1463	tty->hw_stopped = 1;
1464	}	1464	}
1465	}	1465	}
1466	tty_kref_put(tty);	1466	tty_kref_put(tty);
1467	}	1467	}
1468		1468
1469	static void handle_new_lsr(struct edgeport_port *edge_port, int lsr_data,	1469	static void handle_new_lsr(struct edgeport_port *edge_port, int lsr_data,
1470	__u8 lsr, __u8 data)	1470	__u8 lsr, __u8 data)
1471	{	1471	{
1472	struct async_icount *icount;	1472	struct async_icount *icount;
1473	__u8 new_lsr = (__u8)(lsr & (__u8)(LSR_OVER_ERR \| LSR_PAR_ERR \|	1473	__u8 new_lsr = (__u8)(lsr & (__u8)(LSR_OVER_ERR \| LSR_PAR_ERR \|
1474	LSR_FRM_ERR \| LSR_BREAK));	1474	LSR_FRM_ERR \| LSR_BREAK));
1475		1475
1476	dev_dbg(&edge_port->port->dev, "%s - %02x\n", __func__, new_lsr);	1476	dev_dbg(&edge_port->port->dev, "%s - %02x\n", __func__, new_lsr);
1477		1477
1478	edge_port->shadow_lsr = lsr;	1478	edge_port->shadow_lsr = lsr;
1479		1479
1480	if (new_lsr & LSR_BREAK)	1480	if (new_lsr & LSR_BREAK)
1481	/*	1481	/*
1482	* Parity and Framing errors only count if they	1482	* Parity and Framing errors only count if they
1483	* occur exclusive of a break being received.	1483	* occur exclusive of a break being received.
1484	*/	1484	*/
1485	new_lsr &= (__u8)(LSR_OVER_ERR \| LSR_BREAK);	1485	new_lsr &= (__u8)(LSR_OVER_ERR \| LSR_BREAK);
1486		1486
1487	/* Place LSR data byte into Rx buffer */	1487	/* Place LSR data byte into Rx buffer */
1488	if (lsr_data)	1488	if (lsr_data)
1489	edge_tty_recv(edge_port->port, &data, 1);	1489	edge_tty_recv(edge_port->port, &data, 1);
1490		1490
1491	/* update input line counters */	1491	/* update input line counters */
1492	icount = &edge_port->port->icount;	1492	icount = &edge_port->port->icount;
1493	if (new_lsr & LSR_BREAK)	1493	if (new_lsr & LSR_BREAK)
1494	icount->brk++;	1494	icount->brk++;
1495	if (new_lsr & LSR_OVER_ERR)	1495	if (new_lsr & LSR_OVER_ERR)
1496	icount->overrun++;	1496	icount->overrun++;
1497	if (new_lsr & LSR_PAR_ERR)	1497	if (new_lsr & LSR_PAR_ERR)
1498	icount->parity++;	1498	icount->parity++;
1499	if (new_lsr & LSR_FRM_ERR)	1499	if (new_lsr & LSR_FRM_ERR)
1500	icount->frame++;	1500	icount->frame++;
1501	}	1501	}
1502		1502
1503		1503
1504	static void edge_interrupt_callback(struct urb *urb)	1504	static void edge_interrupt_callback(struct urb *urb)
1505	{	1505	{
1506	struct edgeport_serial *edge_serial = urb->context;	1506	struct edgeport_serial *edge_serial = urb->context;
1507	struct usb_serial_port *port;	1507	struct usb_serial_port *port;
1508	struct edgeport_port *edge_port;	1508	struct edgeport_port *edge_port;
1509	struct device *dev;	1509	struct device *dev;
1510	unsigned char *data = urb->transfer_buffer;	1510	unsigned char *data = urb->transfer_buffer;
1511	int length = urb->actual_length;	1511	int length = urb->actual_length;
1512	int port_number;	1512	int port_number;
1513	int function;	1513	int function;
1514	int retval;	1514	int retval;
1515	__u8 lsr;	1515	__u8 lsr;
1516	__u8 msr;	1516	__u8 msr;
1517	int status = urb->status;	1517	int status = urb->status;
1518		1518
1519	switch (status) {	1519	switch (status) {
1520	case 0:	1520	case 0:
1521	/* success */	1521	/* success */
1522	break;	1522	break;
1523	case -ECONNRESET:	1523	case -ECONNRESET:
1524	case -ENOENT:	1524	case -ENOENT:
1525	case -ESHUTDOWN:	1525	case -ESHUTDOWN:
1526	/* this urb is terminated, clean up */	1526	/* this urb is terminated, clean up */
1527	dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n",	1527	dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n",
1528	__func__, status);	1528	__func__, status);
1529	return;	1529	return;
1530	default:	1530	default:
1531	dev_err(&urb->dev->dev, "%s - nonzero urb status received: "	1531	dev_err(&urb->dev->dev, "%s - nonzero urb status received: "
1532	"%d\n", __func__, status);	1532	"%d\n", __func__, status);
1533	goto exit;	1533	goto exit;
1534	}	1534	}
1535		1535
1536	if (!length) {	1536	if (!length) {
1537	dev_dbg(&urb->dev->dev, "%s - no data in urb\n", __func__);	1537	dev_dbg(&urb->dev->dev, "%s - no data in urb\n", __func__);
1538	goto exit;	1538	goto exit;
1539	}	1539	}
1540		1540
1541	dev = &edge_serial->serial->dev->dev;	1541	dev = &edge_serial->serial->dev->dev;
1542	usb_serial_debug_data(dev, __func__, length, data);	1542	usb_serial_debug_data(dev, __func__, length, data);
1543		1543
1544	if (length != 2) {	1544	if (length != 2) {
1545	dev_dbg(dev, "%s - expecting packet of size 2, got %d\n", __func__, length);	1545	dev_dbg(dev, "%s - expecting packet of size 2, got %d\n", __func__, length);
1546	goto exit;	1546	goto exit;
1547	}	1547	}
1548		1548
1549	port_number = TIUMP_GET_PORT_FROM_CODE(data[0]);	1549	port_number = TIUMP_GET_PORT_FROM_CODE(data[0]);
1550	function = TIUMP_GET_FUNC_FROM_CODE(data[0]);	1550	function = TIUMP_GET_FUNC_FROM_CODE(data[0]);
1551	dev_dbg(dev, "%s - port_number %d, function %d, info 0x%x\n", __func__,	1551	dev_dbg(dev, "%s - port_number %d, function %d, info 0x%x\n", __func__,
1552	port_number, function, data[1]);	1552	port_number, function, data[1]);
1553	port = edge_serial->serial->port[port_number];	1553	port = edge_serial->serial->port[port_number];
1554	edge_port = usb_get_serial_port_data(port);	1554	edge_port = usb_get_serial_port_data(port);
1555	if (!edge_port) {	1555	if (!edge_port) {
1556	dev_dbg(dev, "%s - edge_port not found\n", __func__);	1556	dev_dbg(dev, "%s - edge_port not found\n", __func__);
1557	return;	1557	return;
1558	}	1558	}
1559	switch (function) {	1559	switch (function) {
1560	case TIUMP_INTERRUPT_CODE_LSR:	1560	case TIUMP_INTERRUPT_CODE_LSR:
1561	lsr = map_line_status(data[1]);	1561	lsr = map_line_status(data[1]);
1562	if (lsr & UMP_UART_LSR_DATA_MASK) {	1562	if (lsr & UMP_UART_LSR_DATA_MASK) {
1563	/* Save the LSR event for bulk read	1563	/* Save the LSR event for bulk read
1564	completion routine */	1564	completion routine */
1565	dev_dbg(dev, "%s - LSR Event Port %u LSR Status = %02x\n",	1565	dev_dbg(dev, "%s - LSR Event Port %u LSR Status = %02x\n",
1566	__func__, port_number, lsr);	1566	__func__, port_number, lsr);
1567	edge_port->lsr_event = 1;	1567	edge_port->lsr_event = 1;
1568	edge_port->lsr_mask = lsr;	1568	edge_port->lsr_mask = lsr;
1569	} else {	1569	} else {
1570	dev_dbg(dev, "%s - ===== Port %d LSR Status = %02x ======\n",	1570	dev_dbg(dev, "%s - ===== Port %d LSR Status = %02x ======\n",
1571	__func__, port_number, lsr);	1571	__func__, port_number, lsr);
1572	handle_new_lsr(edge_port, 0, lsr, 0);	1572	handle_new_lsr(edge_port, 0, lsr, 0);
1573	}	1573	}
1574	break;	1574	break;
1575		1575
1576	case TIUMP_INTERRUPT_CODE_MSR: /* MSR */	1576	case TIUMP_INTERRUPT_CODE_MSR: /* MSR */
1577	/* Copy MSR from UMP */	1577	/* Copy MSR from UMP */
1578	msr = data[1];	1578	msr = data[1];
1579	dev_dbg(dev, "%s - ===== Port %u MSR Status = %02x ======\n",	1579	dev_dbg(dev, "%s - ===== Port %u MSR Status = %02x ======\n",
1580	__func__, port_number, msr);	1580	__func__, port_number, msr);
1581	handle_new_msr(edge_port, msr);	1581	handle_new_msr(edge_port, msr);
1582	break;	1582	break;
1583		1583
1584	default:	1584	default:
1585	dev_err(&urb->dev->dev,	1585	dev_err(&urb->dev->dev,
1586	"%s - Unknown Interrupt code from UMP %x\n",	1586	"%s - Unknown Interrupt code from UMP %x\n",
1587	__func__, data[1]);	1587	__func__, data[1]);
1588	break;	1588	break;
1589		1589
1590	}	1590	}
1591		1591
1592	exit:	1592	exit:
1593	retval = usb_submit_urb(urb, GFP_ATOMIC);	1593	retval = usb_submit_urb(urb, GFP_ATOMIC);
1594	if (retval)	1594	if (retval)
1595	dev_err(&urb->dev->dev,	1595	dev_err(&urb->dev->dev,
1596	"%s - usb_submit_urb failed with result %d\n",	1596	"%s - usb_submit_urb failed with result %d\n",
1597	__func__, retval);	1597	__func__, retval);
1598	}	1598	}
1599		1599
1600	static void edge_bulk_in_callback(struct urb *urb)	1600	static void edge_bulk_in_callback(struct urb *urb)
1601	{	1601	{
1602	struct edgeport_port *edge_port = urb->context;	1602	struct edgeport_port *edge_port = urb->context;
1603	struct device *dev = &edge_port->port->dev;	1603	struct device *dev = &edge_port->port->dev;
1604	unsigned char *data = urb->transfer_buffer;	1604	unsigned char *data = urb->transfer_buffer;
1605	int retval = 0;	1605	int retval = 0;
1606	int port_number;	1606	int port_number;
1607	int status = urb->status;	1607	int status = urb->status;
1608		1608
1609	switch (status) {	1609	switch (status) {
1610	case 0:	1610	case 0:
1611	/* success */	1611	/* success */
1612	break;	1612	break;
1613	case -ECONNRESET:	1613	case -ECONNRESET:
1614	case -ENOENT:	1614	case -ENOENT:
1615	case -ESHUTDOWN:	1615	case -ESHUTDOWN:
1616	/* this urb is terminated, clean up */	1616	/* this urb is terminated, clean up */
1617	dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n", __func__, status);	1617	dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n", __func__, status);
1618	return;	1618	return;
1619	default:	1619	default:
1620	dev_err(&urb->dev->dev, "%s - nonzero read bulk status received: %d\n", __func__, status);	1620	dev_err(&urb->dev->dev, "%s - nonzero read bulk status received: %d\n", __func__, status);
1621	}	1621	}
1622		1622
1623	if (status == -EPIPE)	1623	if (status == -EPIPE)
1624	goto exit;	1624	goto exit;
1625		1625
1626	if (status) {	1626	if (status) {
1627	dev_err(&urb->dev->dev, "%s - stopping read!\n", __func__);	1627	dev_err(&urb->dev->dev, "%s - stopping read!\n", __func__);
1628	return;	1628	return;
1629	}	1629	}
1630		1630
1631	port_number = edge_port->port->port_number;	1631	port_number = edge_port->port->port_number;
1632		1632
1633	if (edge_port->lsr_event) {	1633	if (edge_port->lsr_event) {
1634	edge_port->lsr_event = 0;	1634	edge_port->lsr_event = 0;
1635	dev_dbg(dev, "%s ===== Port %u LSR Status = %02x, Data = %02x ======\n",	1635	dev_dbg(dev, "%s ===== Port %u LSR Status = %02x, Data = %02x ======\n",
1636	__func__, port_number, edge_port->lsr_mask, *data);	1636	__func__, port_number, edge_port->lsr_mask, *data);
1637	handle_new_lsr(edge_port, 1, edge_port->lsr_mask, *data);	1637	handle_new_lsr(edge_port, 1, edge_port->lsr_mask, *data);
1638	/* Adjust buffer length/pointer */	1638	/* Adjust buffer length/pointer */
1639	--urb->actual_length;	1639	--urb->actual_length;
1640	++data;	1640	++data;
1641	}	1641	}
1642		1642
1643	if (urb->actual_length) {	1643	if (urb->actual_length) {
1644	usb_serial_debug_data(dev, __func__, urb->actual_length, data);	1644	usb_serial_debug_data(dev, __func__, urb->actual_length, data);
1645	if (edge_port->close_pending)	1645	if (edge_port->close_pending)
1646	dev_dbg(dev, "%s - close pending, dropping data on the floor\n",	1646	dev_dbg(dev, "%s - close pending, dropping data on the floor\n",
1647	__func__);	1647	__func__);
1648	else	1648	else
1649	edge_tty_recv(edge_port->port, data,	1649	edge_tty_recv(edge_port->port, data,
1650	urb->actual_length);	1650	urb->actual_length);
1651	edge_port->port->icount.rx += urb->actual_length;	1651	edge_port->port->icount.rx += urb->actual_length;
1652	}	1652	}
1653		1653
1654	exit:	1654	exit:
1655	/* continue read unless stopped */	1655	/* continue read unless stopped */
1656	spin_lock(&edge_port->ep_lock);	1656	spin_lock(&edge_port->ep_lock);
1657	if (edge_port->ep_read_urb_state == EDGE_READ_URB_RUNNING)	1657	if (edge_port->ep_read_urb_state == EDGE_READ_URB_RUNNING)
1658	retval = usb_submit_urb(urb, GFP_ATOMIC);	1658	retval = usb_submit_urb(urb, GFP_ATOMIC);
1659	else if (edge_port->ep_read_urb_state == EDGE_READ_URB_STOPPING)	1659	else if (edge_port->ep_read_urb_state == EDGE_READ_URB_STOPPING)
1660	edge_port->ep_read_urb_state = EDGE_READ_URB_STOPPED;	1660	edge_port->ep_read_urb_state = EDGE_READ_URB_STOPPED;
1661		1661
1662	spin_unlock(&edge_port->ep_lock);	1662	spin_unlock(&edge_port->ep_lock);
1663	if (retval)	1663	if (retval)
1664	dev_err(dev, "%s - usb_submit_urb failed with result %d\n", __func__, retval);	1664	dev_err(dev, "%s - usb_submit_urb failed with result %d\n", __func__, retval);
1665	}	1665	}
1666		1666
1667	static void edge_tty_recv(struct usb_serial_port port, unsigned char data,	1667	static void edge_tty_recv(struct usb_serial_port port, unsigned char data,
1668	int length)	1668	int length)
1669	{	1669	{
1670	int queued;	1670	int queued;
1671		1671
1672	queued = tty_insert_flip_string(&port->port, data, length);	1672	queued = tty_insert_flip_string(&port->port, data, length);
1673	if (queued < length)	1673	if (queued < length)
1674	dev_err(&port->dev, "%s - dropping data, %d bytes lost\n",	1674	dev_err(&port->dev, "%s - dropping data, %d bytes lost\n",
1675	__func__, length - queued);	1675	__func__, length - queued);
1676	tty_flip_buffer_push(&port->port);	1676	tty_flip_buffer_push(&port->port);
1677	}	1677	}
1678		1678
1679	static void edge_bulk_out_callback(struct urb *urb)	1679	static void edge_bulk_out_callback(struct urb *urb)
1680	{	1680	{
1681	struct usb_serial_port *port = urb->context;	1681	struct usb_serial_port *port = urb->context;
1682	struct edgeport_port *edge_port = usb_get_serial_port_data(port);	1682	struct edgeport_port *edge_port = usb_get_serial_port_data(port);
1683	int status = urb->status;	1683	int status = urb->status;
1684	struct tty_struct *tty;	1684	struct tty_struct *tty;
1685		1685
1686	edge_port->ep_write_urb_in_use = 0;	1686	edge_port->ep_write_urb_in_use = 0;
1687		1687
1688	switch (status) {	1688	switch (status) {
1689	case 0:	1689	case 0:
1690	/* success */	1690	/* success */
1691	break;	1691	break;
1692	case -ECONNRESET:	1692	case -ECONNRESET:
1693	case -ENOENT:	1693	case -ENOENT:
1694	case -ESHUTDOWN:	1694	case -ESHUTDOWN:
1695	/* this urb is terminated, clean up */	1695	/* this urb is terminated, clean up */
1696	dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n",	1696	dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n",
1697	__func__, status);	1697	__func__, status);
1698	return;	1698	return;
1699	default:	1699	default:
1700	dev_err_console(port, "%s - nonzero write bulk status "	1700	dev_err_console(port, "%s - nonzero write bulk status "
1701	"received: %d\n", __func__, status);	1701	"received: %d\n", __func__, status);
1702	}	1702	}
1703		1703
1704	/* send any buffered data */	1704	/* send any buffered data */
1705	tty = tty_port_tty_get(&port->port);	1705	tty = tty_port_tty_get(&port->port);
1706	edge_send(port, tty);	1706	edge_send(port, tty);
1707	tty_kref_put(tty);	1707	tty_kref_put(tty);
1708	}	1708	}
1709		1709
1710	static int edge_open(struct tty_struct tty, struct usb_serial_port port)	1710	static int edge_open(struct tty_struct tty, struct usb_serial_port port)
1711	{	1711	{
1712	struct edgeport_port *edge_port = usb_get_serial_port_data(port);	1712	struct edgeport_port *edge_port = usb_get_serial_port_data(port);
1713	struct edgeport_serial *edge_serial;	1713	struct edgeport_serial *edge_serial;
1714	struct usb_device *dev;	1714	struct usb_device *dev;
1715	struct urb *urb;	1715	struct urb *urb;
1716	int port_number;	1716	int port_number;
1717	int status;	1717	int status;
1718	u16 open_settings;	1718	u16 open_settings;
1719	u8 transaction_timeout;	1719	u8 transaction_timeout;
1720		1720
1721	if (edge_port == NULL)	1721	if (edge_port == NULL)
1722	return -ENODEV;	1722	return -ENODEV;
1723		1723
1724	port_number = port->port_number;	1724	port_number = port->port_number;
1725		1725
1726	dev = port->serial->dev;	1726	dev = port->serial->dev;
1727		1727
1728	/* turn off loopback */	1728	/* turn off loopback */
1729	status = ti_do_config(edge_port, UMPC_SET_CLR_LOOPBACK, 0);	1729	status = ti_do_config(edge_port, UMPC_SET_CLR_LOOPBACK, 0);
1730	if (status) {	1730	if (status) {
1731	dev_err(&port->dev,	1731	dev_err(&port->dev,
1732	"%s - cannot send clear loopback command, %d\n",	1732	"%s - cannot send clear loopback command, %d\n",
1733	__func__, status);	1733	__func__, status);
1734	return status;	1734	return status;
1735	}	1735	}
1736		1736
1737	/* set up the port settings */	1737	/* set up the port settings */
1738	if (tty)	1738	if (tty)
1739	edge_set_termios(tty, port, &tty->termios);	1739	edge_set_termios(tty, port, &tty->termios);
1740		1740
1741	/* open up the port */	1741	/* open up the port */
1742		1742
1743	/* milliseconds to timeout for DMA transfer */	1743	/* milliseconds to timeout for DMA transfer */
1744	transaction_timeout = 2;	1744	transaction_timeout = 2;
1745		1745
1746	edge_port->ump_read_timeout =	1746	edge_port->ump_read_timeout =
1747	max(20, ((transaction_timeout * 3) / 2));	1747	max(20, ((transaction_timeout * 3) / 2));
1748		1748
1749	/* milliseconds to timeout for DMA transfer */	1749	/* milliseconds to timeout for DMA transfer */
1750	open_settings = (u8)(UMP_DMA_MODE_CONTINOUS \|	1750	open_settings = (u8)(UMP_DMA_MODE_CONTINOUS \|
1751	UMP_PIPE_TRANS_TIMEOUT_ENA \|	1751	UMP_PIPE_TRANS_TIMEOUT_ENA \|
1752	(transaction_timeout << 2));	1752	(transaction_timeout << 2));
1753		1753
1754	dev_dbg(&port->dev, "%s - Sending UMPC_OPEN_PORT\n", __func__);	1754	dev_dbg(&port->dev, "%s - Sending UMPC_OPEN_PORT\n", __func__);
1755		1755
1756	/* Tell TI to open and start the port */	1756	/* Tell TI to open and start the port */
1757	status = send_cmd(dev, UMPC_OPEN_PORT,	1757	status = send_cmd(dev, UMPC_OPEN_PORT,
1758	(u8)(UMPM_UART1_PORT + port_number), open_settings, NULL, 0);	1758	(u8)(UMPM_UART1_PORT + port_number), open_settings, NULL, 0);
1759	if (status) {	1759	if (status) {
1760	dev_err(&port->dev, "%s - cannot send open command, %d\n",	1760	dev_err(&port->dev, "%s - cannot send open command, %d\n",
1761	__func__, status);	1761	__func__, status);
1762	return status;	1762	return status;
1763	}	1763	}
1764		1764
1765	/* Start the DMA? */	1765	/* Start the DMA? */
1766	status = send_cmd(dev, UMPC_START_PORT,	1766	status = send_cmd(dev, UMPC_START_PORT,
1767	(u8)(UMPM_UART1_PORT + port_number), 0, NULL, 0);	1767	(u8)(UMPM_UART1_PORT + port_number), 0, NULL, 0);
1768	if (status) {	1768	if (status) {
1769	dev_err(&port->dev, "%s - cannot send start DMA command, %d\n",	1769	dev_err(&port->dev, "%s - cannot send start DMA command, %d\n",
1770	__func__, status);	1770	__func__, status);
1771	return status;	1771	return status;
1772	}	1772	}
1773		1773
1774	/* Clear TX and RX buffers in UMP */	1774	/* Clear TX and RX buffers in UMP */
1775	status = purge_port(port, UMP_PORT_DIR_OUT \| UMP_PORT_DIR_IN);	1775	status = purge_port(port, UMP_PORT_DIR_OUT \| UMP_PORT_DIR_IN);
1776	if (status) {	1776	if (status) {
1777	dev_err(&port->dev,	1777	dev_err(&port->dev,
1778	"%s - cannot send clear buffers command, %d\n",	1778	"%s - cannot send clear buffers command, %d\n",
1779	__func__, status);	1779	__func__, status);
1780	return status;	1780	return status;
1781	}	1781	}
1782		1782
1783	/* Read Initial MSR */	1783	/* Read Initial MSR */
1784	status = ti_vread_sync(dev, UMPC_READ_MSR, 0,	1784	status = ti_vread_sync(dev, UMPC_READ_MSR, 0,
1785	(__u16)(UMPM_UART1_PORT + port_number),	1785	(__u16)(UMPM_UART1_PORT + port_number),
1786	&edge_port->shadow_msr, 1);	1786	&edge_port->shadow_msr, 1);
1787	if (status) {	1787	if (status) {
1788	dev_err(&port->dev, "%s - cannot send read MSR command, %d\n",	1788	dev_err(&port->dev, "%s - cannot send read MSR command, %d\n",
1789	__func__, status);	1789	__func__, status);
1790	return status;	1790	return status;
1791	}	1791	}
1792		1792
1793	dev_dbg(&port->dev, "ShadowMSR 0x%X\n", edge_port->shadow_msr);	1793	dev_dbg(&port->dev, "ShadowMSR 0x%X\n", edge_port->shadow_msr);
1794		1794
1795	/* Set Initial MCR */	1795	/* Set Initial MCR */
1796	edge_port->shadow_mcr = MCR_RTS \| MCR_DTR;	1796	edge_port->shadow_mcr = MCR_RTS \| MCR_DTR;
1797	dev_dbg(&port->dev, "ShadowMCR 0x%X\n", edge_port->shadow_mcr);	1797	dev_dbg(&port->dev, "ShadowMCR 0x%X\n", edge_port->shadow_mcr);
1798		1798
1799	edge_serial = edge_port->edge_serial;	1799	edge_serial = edge_port->edge_serial;
1800	if (mutex_lock_interruptible(&edge_serial->es_lock))	1800	if (mutex_lock_interruptible(&edge_serial->es_lock))
1801	return -ERESTARTSYS;	1801	return -ERESTARTSYS;
1802	if (edge_serial->num_ports_open == 0) {	1802	if (edge_serial->num_ports_open == 0) {
1803	/* we are the first port to open, post the interrupt urb */	1803	/* we are the first port to open, post the interrupt urb */
1804	urb = edge_serial->serial->port[0]->interrupt_in_urb;	1804	urb = edge_serial->serial->port[0]->interrupt_in_urb;
1805	if (!urb) {	1805	if (!urb) {
1806	dev_err(&port->dev,	1806	dev_err(&port->dev,
1807	"%s - no interrupt urb present, exiting\n",	1807	"%s - no interrupt urb present, exiting\n",
1808	__func__);	1808	__func__);
1809	status = -EINVAL;	1809	status = -EINVAL;
1810	goto release_es_lock;	1810	goto release_es_lock;
1811	}	1811	}
1812	urb->context = edge_serial;	1812	urb->context = edge_serial;
1813	status = usb_submit_urb(urb, GFP_KERNEL);	1813	status = usb_submit_urb(urb, GFP_KERNEL);
1814	if (status) {	1814	if (status) {
1815	dev_err(&port->dev,	1815	dev_err(&port->dev,
1816	"%s - usb_submit_urb failed with value %d\n",	1816	"%s - usb_submit_urb failed with value %d\n",
1817	__func__, status);	1817	__func__, status);
1818	goto release_es_lock;	1818	goto release_es_lock;
1819	}	1819	}
1820	}	1820	}
1821		1821
1822	/*	1822	/*
1823	* reset the data toggle on the bulk endpoints to work around bug in	1823	* reset the data toggle on the bulk endpoints to work around bug in
1824	* host controllers where things get out of sync some times	1824	* host controllers where things get out of sync some times
1825	*/	1825	*/
1826	usb_clear_halt(dev, port->write_urb->pipe);	1826	usb_clear_halt(dev, port->write_urb->pipe);
1827	usb_clear_halt(dev, port->read_urb->pipe);	1827	usb_clear_halt(dev, port->read_urb->pipe);
1828		1828
1829	/* start up our bulk read urb */	1829	/* start up our bulk read urb */
1830	urb = port->read_urb;	1830	urb = port->read_urb;
1831	if (!urb) {	1831	if (!urb) {
1832	dev_err(&port->dev, "%s - no read urb present, exiting\n",	1832	dev_err(&port->dev, "%s - no read urb present, exiting\n",
1833	__func__);	1833	__func__);
1834	status = -EINVAL;	1834	status = -EINVAL;
1835	goto unlink_int_urb;	1835	goto unlink_int_urb;
1836	}	1836	}
1837	edge_port->ep_read_urb_state = EDGE_READ_URB_RUNNING;	1837	edge_port->ep_read_urb_state = EDGE_READ_URB_RUNNING;
1838	urb->context = edge_port;	1838	urb->context = edge_port;
1839	status = usb_submit_urb(urb, GFP_KERNEL);	1839	status = usb_submit_urb(urb, GFP_KERNEL);
1840	if (status) {	1840	if (status) {
1841	dev_err(&port->dev,	1841	dev_err(&port->dev,
1842	"%s - read bulk usb_submit_urb failed with value %d\n",	1842	"%s - read bulk usb_submit_urb failed with value %d\n",
1843	__func__, status);	1843	__func__, status);
1844	goto unlink_int_urb;	1844	goto unlink_int_urb;
1845	}	1845	}
1846		1846
1847	++edge_serial->num_ports_open;	1847	++edge_serial->num_ports_open;
1848		1848
1849	goto release_es_lock;	1849	goto release_es_lock;
1850		1850
1851	unlink_int_urb:	1851	unlink_int_urb:
1852	if (edge_port->edge_serial->num_ports_open == 0)	1852	if (edge_port->edge_serial->num_ports_open == 0)
1853	usb_kill_urb(port->serial->port[0]->interrupt_in_urb);	1853	usb_kill_urb(port->serial->port[0]->interrupt_in_urb);
1854	release_es_lock:	1854	release_es_lock:
1855	mutex_unlock(&edge_serial->es_lock);	1855	mutex_unlock(&edge_serial->es_lock);
1856	return status;	1856	return status;
1857	}	1857	}
1858		1858
1859	static void edge_close(struct usb_serial_port *port)	1859	static void edge_close(struct usb_serial_port *port)
1860	{	1860	{
1861	struct edgeport_serial *edge_serial;	1861	struct edgeport_serial *edge_serial;
1862	struct edgeport_port *edge_port;	1862	struct edgeport_port *edge_port;
1863	struct usb_serial *serial = port->serial;	1863	struct usb_serial *serial = port->serial;
1864	unsigned long flags;	1864	unsigned long flags;
1865	int port_number;	1865	int port_number;
1866		1866
1867	edge_serial = usb_get_serial_data(port->serial);	1867	edge_serial = usb_get_serial_data(port->serial);
1868	edge_port = usb_get_serial_port_data(port);	1868	edge_port = usb_get_serial_port_data(port);
1869	if (edge_serial == NULL \|\| edge_port == NULL)	1869	if (edge_serial == NULL \|\| edge_port == NULL)
1870	return;	1870	return;
1871		1871
1872	/* The bulkreadcompletion routine will check	1872	/* The bulkreadcompletion routine will check
1873	* this flag and dump add read data */	1873	* this flag and dump add read data */
1874	edge_port->close_pending = 1;	1874	edge_port->close_pending = 1;
1875		1875
1876	usb_kill_urb(port->read_urb);	1876	usb_kill_urb(port->read_urb);
1877	usb_kill_urb(port->write_urb);	1877	usb_kill_urb(port->write_urb);
1878	edge_port->ep_write_urb_in_use = 0;	1878	edge_port->ep_write_urb_in_use = 0;
1879	spin_lock_irqsave(&edge_port->ep_lock, flags);	1879	spin_lock_irqsave(&edge_port->ep_lock, flags);
1880	kfifo_reset_out(&port->write_fifo);	1880	kfifo_reset_out(&port->write_fifo);
1881	spin_unlock_irqrestore(&edge_port->ep_lock, flags);	1881	spin_unlock_irqrestore(&edge_port->ep_lock, flags);
1882		1882
1883	dev_dbg(&port->dev, "%s - send umpc_close_port\n", __func__);	1883	dev_dbg(&port->dev, "%s - send umpc_close_port\n", __func__);
1884	port_number = port->port_number;	1884	port_number = port->port_number;
1885	send_cmd(serial->dev, UMPC_CLOSE_PORT,	1885	send_cmd(serial->dev, UMPC_CLOSE_PORT,
1886	(__u8)(UMPM_UART1_PORT + port_number), 0, NULL, 0);	1886	(__u8)(UMPM_UART1_PORT + port_number), 0, NULL, 0);
1887		1887
1888	mutex_lock(&edge_serial->es_lock);	1888	mutex_lock(&edge_serial->es_lock);
1889	--edge_port->edge_serial->num_ports_open;	1889	--edge_port->edge_serial->num_ports_open;
1890	if (edge_port->edge_serial->num_ports_open <= 0) {	1890	if (edge_port->edge_serial->num_ports_open <= 0) {
1891	/* last port is now closed, let's shut down our interrupt urb */	1891	/* last port is now closed, let's shut down our interrupt urb */
1892	usb_kill_urb(port->serial->port[0]->interrupt_in_urb);	1892	usb_kill_urb(port->serial->port[0]->interrupt_in_urb);
1893	edge_port->edge_serial->num_ports_open = 0;	1893	edge_port->edge_serial->num_ports_open = 0;
1894	}	1894	}
1895	mutex_unlock(&edge_serial->es_lock);	1895	mutex_unlock(&edge_serial->es_lock);
1896	edge_port->close_pending = 0;	1896	edge_port->close_pending = 0;
1897	}	1897	}
1898		1898
1899	static int edge_write(struct tty_struct tty, struct usb_serial_port port,	1899	static int edge_write(struct tty_struct tty, struct usb_serial_port port,
1900	const unsigned char *data, int count)	1900	const unsigned char *data, int count)
1901	{	1901	{
1902	struct edgeport_port *edge_port = usb_get_serial_port_data(port);	1902	struct edgeport_port *edge_port = usb_get_serial_port_data(port);
1903		1903
1904	if (count == 0) {	1904	if (count == 0) {
1905	dev_dbg(&port->dev, "%s - write request of 0 bytes\n", __func__);	1905	dev_dbg(&port->dev, "%s - write request of 0 bytes\n", __func__);
1906	return 0;	1906	return 0;
1907	}	1907	}
1908		1908
1909	if (edge_port == NULL)	1909	if (edge_port == NULL)
1910	return -ENODEV;	1910	return -ENODEV;
1911	if (edge_port->close_pending == 1)	1911	if (edge_port->close_pending == 1)
1912	return -ENODEV;	1912	return -ENODEV;
1913		1913
1914	count = kfifo_in_locked(&port->write_fifo, data, count,	1914	count = kfifo_in_locked(&port->write_fifo, data, count,
1915	&edge_port->ep_lock);	1915	&edge_port->ep_lock);
1916	edge_send(port, tty);	1916	edge_send(port, tty);
1917		1917
1918	return count;	1918	return count;
1919	}	1919	}
1920		1920
1921	static void edge_send(struct usb_serial_port port, struct tty_struct tty)	1921	static void edge_send(struct usb_serial_port port, struct tty_struct tty)
1922	{	1922	{
1923	int count, result;	1923	int count, result;
1924	struct edgeport_port *edge_port = usb_get_serial_port_data(port);	1924	struct edgeport_port *edge_port = usb_get_serial_port_data(port);
1925	unsigned long flags;	1925	unsigned long flags;
1926		1926
1927	spin_lock_irqsave(&edge_port->ep_lock, flags);	1927	spin_lock_irqsave(&edge_port->ep_lock, flags);
1928		1928
1929	if (edge_port->ep_write_urb_in_use) {	1929	if (edge_port->ep_write_urb_in_use) {
1930	spin_unlock_irqrestore(&edge_port->ep_lock, flags);	1930	spin_unlock_irqrestore(&edge_port->ep_lock, flags);
1931	return;	1931	return;
1932	}	1932	}
1933		1933
1934	count = kfifo_out(&port->write_fifo,	1934	count = kfifo_out(&port->write_fifo,
1935	port->write_urb->transfer_buffer,	1935	port->write_urb->transfer_buffer,
1936	port->bulk_out_size);	1936	port->bulk_out_size);
1937		1937
1938	if (count == 0) {	1938	if (count == 0) {
1939	spin_unlock_irqrestore(&edge_port->ep_lock, flags);	1939	spin_unlock_irqrestore(&edge_port->ep_lock, flags);
1940	return;	1940	return;
1941	}	1941	}
1942		1942
1943	edge_port->ep_write_urb_in_use = 1;	1943	edge_port->ep_write_urb_in_use = 1;
1944		1944
1945	spin_unlock_irqrestore(&edge_port->ep_lock, flags);	1945	spin_unlock_irqrestore(&edge_port->ep_lock, flags);
1946		1946
1947	usb_serial_debug_data(&port->dev, __func__, count, port->write_urb->transfer_buffer);	1947	usb_serial_debug_data(&port->dev, __func__, count, port->write_urb->transfer_buffer);
1948		1948
1949	/* set up our urb */	1949	/* set up our urb */
1950	port->write_urb->transfer_buffer_length = count;	1950	port->write_urb->transfer_buffer_length = count;
1951		1951
1952	/* send the data out the bulk port */	1952	/* send the data out the bulk port */
1953	result = usb_submit_urb(port->write_urb, GFP_ATOMIC);	1953	result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
1954	if (result) {	1954	if (result) {
1955	dev_err_console(port,	1955	dev_err_console(port,
1956	"%s - failed submitting write urb, error %d\n",	1956	"%s - failed submitting write urb, error %d\n",
1957	__func__, result);	1957	__func__, result);
1958	edge_port->ep_write_urb_in_use = 0;	1958	edge_port->ep_write_urb_in_use = 0;
1959	/* TODO: reschedule edge_send */	1959	/* TODO: reschedule edge_send */
1960	} else	1960	} else
1961	edge_port->port->icount.tx += count;	1961	edge_port->port->icount.tx += count;
1962		1962
1963	/* wakeup any process waiting for writes to complete */	1963	/* wakeup any process waiting for writes to complete */
1964	/* there is now more room in the buffer for new writes */	1964	/* there is now more room in the buffer for new writes */
1965	if (tty)	1965	if (tty)
1966	tty_wakeup(tty);	1966	tty_wakeup(tty);
1967	}	1967	}
1968		1968
1969	static int edge_write_room(struct tty_struct *tty)	1969	static int edge_write_room(struct tty_struct *tty)
1970	{	1970	{
1971	struct usb_serial_port *port = tty->driver_data;	1971	struct usb_serial_port *port = tty->driver_data;
1972	struct edgeport_port *edge_port = usb_get_serial_port_data(port);	1972	struct edgeport_port *edge_port = usb_get_serial_port_data(port);
1973	int room = 0;	1973	int room = 0;
1974	unsigned long flags;	1974	unsigned long flags;
1975		1975
1976	if (edge_port == NULL)	1976	if (edge_port == NULL)
1977	return 0;	1977	return 0;
1978	if (edge_port->close_pending == 1)	1978	if (edge_port->close_pending == 1)
1979	return 0;	1979	return 0;
1980		1980
1981	spin_lock_irqsave(&edge_port->ep_lock, flags);	1981	spin_lock_irqsave(&edge_port->ep_lock, flags);
1982	room = kfifo_avail(&port->write_fifo);	1982	room = kfifo_avail(&port->write_fifo);
1983	spin_unlock_irqrestore(&edge_port->ep_lock, flags);	1983	spin_unlock_irqrestore(&edge_port->ep_lock, flags);
1984		1984
1985	dev_dbg(&port->dev, "%s - returns %d\n", __func__, room);	1985	dev_dbg(&port->dev, "%s - returns %d\n", __func__, room);
1986	return room;	1986	return room;
1987	}	1987	}
1988		1988
1989	static int edge_chars_in_buffer(struct tty_struct *tty)	1989	static int edge_chars_in_buffer(struct tty_struct *tty)
1990	{	1990	{
1991	struct usb_serial_port *port = tty->driver_data;	1991	struct usb_serial_port *port = tty->driver_data;
1992	struct edgeport_port *edge_port = usb_get_serial_port_data(port);	1992	struct edgeport_port *edge_port = usb_get_serial_port_data(port);
1993	int chars = 0;	1993	int chars = 0;
1994	unsigned long flags;	1994	unsigned long flags;
1995	if (edge_port == NULL)	1995	if (edge_port == NULL)
1996	return 0;	1996	return 0;
1997		1997
1998	spin_lock_irqsave(&edge_port->ep_lock, flags);	1998	spin_lock_irqsave(&edge_port->ep_lock, flags);
1999	chars = kfifo_len(&port->write_fifo);	1999	chars = kfifo_len(&port->write_fifo);
2000	spin_unlock_irqrestore(&edge_port->ep_lock, flags);	2000	spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2001		2001
2002	dev_dbg(&port->dev, "%s - returns %d\n", __func__, chars);	2002	dev_dbg(&port->dev, "%s - returns %d\n", __func__, chars);
2003	return chars;	2003	return chars;
2004	}	2004	}
2005		2005
2006	static bool edge_tx_empty(struct usb_serial_port *port)	2006	static bool edge_tx_empty(struct usb_serial_port *port)
2007	{	2007	{
2008	struct edgeport_port *edge_port = usb_get_serial_port_data(port);	2008	struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2009	int ret;	2009	int ret;
2010		2010
2011	ret = tx_active(edge_port);	2011	ret = tx_active(edge_port);
2012	if (ret > 0)	2012	if (ret > 0)
2013	return false;	2013	return false;
2014		2014
2015	return true;	2015	return true;
2016	}	2016	}
2017		2017
2018	static void edge_throttle(struct tty_struct *tty)	2018	static void edge_throttle(struct tty_struct *tty)
2019	{	2019	{
2020	struct usb_serial_port *port = tty->driver_data;	2020	struct usb_serial_port *port = tty->driver_data;
2021	struct edgeport_port *edge_port = usb_get_serial_port_data(port);	2021	struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2022	int status;	2022	int status;
2023		2023
2024	if (edge_port == NULL)	2024	if (edge_port == NULL)
2025	return;	2025	return;
2026		2026
2027	/* if we are implementing XON/XOFF, send the stop character */	2027	/* if we are implementing XON/XOFF, send the stop character */
2028	if (I_IXOFF(tty)) {	2028	if (I_IXOFF(tty)) {
2029	unsigned char stop_char = STOP_CHAR(tty);	2029	unsigned char stop_char = STOP_CHAR(tty);
2030	status = edge_write(tty, port, &stop_char, 1);	2030	status = edge_write(tty, port, &stop_char, 1);
2031	if (status <= 0) {	2031	if (status <= 0) {
2032	dev_err(&port->dev, "%s - failed to write stop character, %d\n", __func__, status);	2032	dev_err(&port->dev, "%s - failed to write stop character, %d\n", __func__, status);
2033	}	2033	}
2034	}	2034	}
2035		2035
2036	/* if we are implementing RTS/CTS, stop reads */	2036	/* if we are implementing RTS/CTS, stop reads */
2037	/* and the Edgeport will clear the RTS line */	2037	/* and the Edgeport will clear the RTS line */
2038	if (C_CRTSCTS(tty))	2038	if (C_CRTSCTS(tty))
2039	stop_read(edge_port);	2039	stop_read(edge_port);
2040		2040
2041	}	2041	}
2042		2042
2043	static void edge_unthrottle(struct tty_struct *tty)	2043	static void edge_unthrottle(struct tty_struct *tty)
2044	{	2044	{
2045	struct usb_serial_port *port = tty->driver_data;	2045	struct usb_serial_port *port = tty->driver_data;
2046	struct edgeport_port *edge_port = usb_get_serial_port_data(port);	2046	struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2047	int status;	2047	int status;
2048		2048
2049	if (edge_port == NULL)	2049	if (edge_port == NULL)
2050	return;	2050	return;
2051		2051
2052	/* if we are implementing XON/XOFF, send the start character */	2052	/* if we are implementing XON/XOFF, send the start character */
2053	if (I_IXOFF(tty)) {	2053	if (I_IXOFF(tty)) {
2054	unsigned char start_char = START_CHAR(tty);	2054	unsigned char start_char = START_CHAR(tty);
2055	status = edge_write(tty, port, &start_char, 1);	2055	status = edge_write(tty, port, &start_char, 1);
2056	if (status <= 0) {	2056	if (status <= 0) {
2057	dev_err(&port->dev, "%s - failed to write start character, %d\n", __func__, status);	2057	dev_err(&port->dev, "%s - failed to write start character, %d\n", __func__, status);
2058	}	2058	}
2059	}	2059	}
2060	/* if we are implementing RTS/CTS, restart reads */	2060	/* if we are implementing RTS/CTS, restart reads */
2061	/* are the Edgeport will assert the RTS line */	2061	/* are the Edgeport will assert the RTS line */
2062	if (C_CRTSCTS(tty)) {	2062	if (C_CRTSCTS(tty)) {
2063	status = restart_read(edge_port);	2063	status = restart_read(edge_port);
2064	if (status)	2064	if (status)
2065	dev_err(&port->dev,	2065	dev_err(&port->dev,
2066	"%s - read bulk usb_submit_urb failed: %d\n",	2066	"%s - read bulk usb_submit_urb failed: %d\n",
2067	__func__, status);	2067	__func__, status);
2068	}	2068	}
2069		2069
2070	}	2070	}
2071		2071
2072	static void stop_read(struct edgeport_port *edge_port)	2072	static void stop_read(struct edgeport_port *edge_port)
2073	{	2073	{
2074	unsigned long flags;	2074	unsigned long flags;
2075		2075
2076	spin_lock_irqsave(&edge_port->ep_lock, flags);	2076	spin_lock_irqsave(&edge_port->ep_lock, flags);
2077		2077
2078	if (edge_port->ep_read_urb_state == EDGE_READ_URB_RUNNING)	2078	if (edge_port->ep_read_urb_state == EDGE_READ_URB_RUNNING)
2079	edge_port->ep_read_urb_state = EDGE_READ_URB_STOPPING;	2079	edge_port->ep_read_urb_state = EDGE_READ_URB_STOPPING;
2080	edge_port->shadow_mcr &= ~MCR_RTS;	2080	edge_port->shadow_mcr &= ~MCR_RTS;
2081		2081
2082	spin_unlock_irqrestore(&edge_port->ep_lock, flags);	2082	spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2083	}	2083	}
2084		2084
2085	static int restart_read(struct edgeport_port *edge_port)	2085	static int restart_read(struct edgeport_port *edge_port)
2086	{	2086	{
2087	struct urb *urb;	2087	struct urb *urb;
2088	int status = 0;	2088	int status = 0;
2089	unsigned long flags;	2089	unsigned long flags;
2090		2090
2091	spin_lock_irqsave(&edge_port->ep_lock, flags);	2091	spin_lock_irqsave(&edge_port->ep_lock, flags);
2092		2092
2093	if (edge_port->ep_read_urb_state == EDGE_READ_URB_STOPPED) {	2093	if (edge_port->ep_read_urb_state == EDGE_READ_URB_STOPPED) {
2094	urb = edge_port->port->read_urb;	2094	urb = edge_port->port->read_urb;
2095	status = usb_submit_urb(urb, GFP_ATOMIC);	2095	status = usb_submit_urb(urb, GFP_ATOMIC);
2096	}	2096	}
2097	edge_port->ep_read_urb_state = EDGE_READ_URB_RUNNING;	2097	edge_port->ep_read_urb_state = EDGE_READ_URB_RUNNING;
2098	edge_port->shadow_mcr \|= MCR_RTS;	2098	edge_port->shadow_mcr \|= MCR_RTS;
2099		2099
2100	spin_unlock_irqrestore(&edge_port->ep_lock, flags);	2100	spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2101		2101
2102	return status;	2102	return status;
2103	}	2103	}
2104		2104
2105	static void change_port_settings(struct tty_struct *tty,	2105	static void change_port_settings(struct tty_struct *tty,
2106	struct edgeport_port edge_port, struct ktermios old_termios)	2106	struct edgeport_port edge_port, struct ktermios old_termios)
2107	{	2107	{
2108	struct device *dev = &edge_port->port->dev;	2108	struct device *dev = &edge_port->port->dev;
2109	struct ump_uart_config *config;	2109	struct ump_uart_config *config;
2110	int baud;	2110	int baud;
2111	unsigned cflag;	2111	unsigned cflag;
2112	int status;	2112	int status;
2113	int port_number = edge_port->port->port_number;	2113	int port_number = edge_port->port->port_number;
2114		2114
2115	config = kmalloc (sizeof (*config), GFP_KERNEL);	2115	config = kmalloc (sizeof (*config), GFP_KERNEL);
2116	if (!config) {	2116	if (!config) {
2117	tty->termios = *old_termios;	2117	tty->termios = *old_termios;
2118	return;	2118	return;
2119	}	2119	}
2120		2120
2121	cflag = tty->termios.c_cflag;	2121	cflag = tty->termios.c_cflag;
2122		2122
2123	config->wFlags = 0;	2123	config->wFlags = 0;
2124		2124
2125	/* These flags must be set */	2125	/* These flags must be set */
2126	config->wFlags \|= UMP_MASK_UART_FLAGS_RECEIVE_MS_INT;	2126	config->wFlags \|= UMP_MASK_UART_FLAGS_RECEIVE_MS_INT;
2127	config->wFlags \|= UMP_MASK_UART_FLAGS_AUTO_START_ON_ERR;	2127	config->wFlags \|= UMP_MASK_UART_FLAGS_AUTO_START_ON_ERR;
2128	config->bUartMode = (__u8)(edge_port->bUartMode);	2128	config->bUartMode = (__u8)(edge_port->bUartMode);
2129		2129
2130	switch (cflag & CSIZE) {	2130	switch (cflag & CSIZE) {
2131	case CS5:	2131	case CS5:
2132	config->bDataBits = UMP_UART_CHAR5BITS;	2132	config->bDataBits = UMP_UART_CHAR5BITS;
2133	dev_dbg(dev, "%s - data bits = 5\n", __func__);	2133	dev_dbg(dev, "%s - data bits = 5\n", __func__);
2134	break;	2134	break;
2135	case CS6:	2135	case CS6:
2136	config->bDataBits = UMP_UART_CHAR6BITS;	2136	config->bDataBits = UMP_UART_CHAR6BITS;
2137	dev_dbg(dev, "%s - data bits = 6\n", __func__);	2137	dev_dbg(dev, "%s - data bits = 6\n", __func__);
2138	break;	2138	break;
2139	case CS7:	2139	case CS7:
2140	config->bDataBits = UMP_UART_CHAR7BITS;	2140	config->bDataBits = UMP_UART_CHAR7BITS;
2141	dev_dbg(dev, "%s - data bits = 7\n", __func__);	2141	dev_dbg(dev, "%s - data bits = 7\n", __func__);
2142	break;	2142	break;
2143	default:	2143	default:
2144	case CS8:	2144	case CS8:
2145	config->bDataBits = UMP_UART_CHAR8BITS;	2145	config->bDataBits = UMP_UART_CHAR8BITS;
2146	dev_dbg(dev, "%s - data bits = 8\n", __func__);	2146	dev_dbg(dev, "%s - data bits = 8\n", __func__);
2147	break;	2147	break;
2148	}	2148	}
2149		2149
2150	if (cflag & PARENB) {	2150	if (cflag & PARENB) {
2151	if (cflag & PARODD) {	2151	if (cflag & PARODD) {
2152	config->wFlags \|= UMP_MASK_UART_FLAGS_PARITY;	2152	config->wFlags \|= UMP_MASK_UART_FLAGS_PARITY;
2153	config->bParity = UMP_UART_ODDPARITY;	2153	config->bParity = UMP_UART_ODDPARITY;
2154	dev_dbg(dev, "%s - parity = odd\n", __func__);	2154	dev_dbg(dev, "%s - parity = odd\n", __func__);
2155	} else {	2155	} else {
2156	config->wFlags \|= UMP_MASK_UART_FLAGS_PARITY;	2156	config->wFlags \|= UMP_MASK_UART_FLAGS_PARITY;
2157	config->bParity = UMP_UART_EVENPARITY;	2157	config->bParity = UMP_UART_EVENPARITY;
2158	dev_dbg(dev, "%s - parity = even\n", __func__);	2158	dev_dbg(dev, "%s - parity = even\n", __func__);
2159	}	2159	}
2160	} else {	2160	} else {
2161	config->bParity = UMP_UART_NOPARITY;	2161	config->bParity = UMP_UART_NOPARITY;
2162	dev_dbg(dev, "%s - parity = none\n", __func__);	2162	dev_dbg(dev, "%s - parity = none\n", __func__);
2163	}	2163	}
2164		2164
2165	if (cflag & CSTOPB) {	2165	if (cflag & CSTOPB) {
2166	config->bStopBits = UMP_UART_STOPBIT2;	2166	config->bStopBits = UMP_UART_STOPBIT2;
2167	dev_dbg(dev, "%s - stop bits = 2\n", __func__);	2167	dev_dbg(dev, "%s - stop bits = 2\n", __func__);
2168	} else {	2168	} else {
2169	config->bStopBits = UMP_UART_STOPBIT1;	2169	config->bStopBits = UMP_UART_STOPBIT1;
2170	dev_dbg(dev, "%s - stop bits = 1\n", __func__);	2170	dev_dbg(dev, "%s - stop bits = 1\n", __func__);
2171	}	2171	}
2172		2172
2173	/* figure out the flow control settings */	2173	/* figure out the flow control settings */
2174	if (cflag & CRTSCTS) {	2174	if (cflag & CRTSCTS) {
2175	config->wFlags \|= UMP_MASK_UART_FLAGS_OUT_X_CTS_FLOW;	2175	config->wFlags \|= UMP_MASK_UART_FLAGS_OUT_X_CTS_FLOW;
2176	config->wFlags \|= UMP_MASK_UART_FLAGS_RTS_FLOW;	2176	config->wFlags \|= UMP_MASK_UART_FLAGS_RTS_FLOW;
2177	dev_dbg(dev, "%s - RTS/CTS is enabled\n", __func__);	2177	dev_dbg(dev, "%s - RTS/CTS is enabled\n", __func__);
2178	} else {	2178	} else {
2179	dev_dbg(dev, "%s - RTS/CTS is disabled\n", __func__);	2179	dev_dbg(dev, "%s - RTS/CTS is disabled\n", __func__);
2180	tty->hw_stopped = 0;	2180	tty->hw_stopped = 0;
2181	restart_read(edge_port);	2181	restart_read(edge_port);
2182	}	2182	}
2183		2183
2184	/* if we are implementing XON/XOFF, set the start and stop	2184	/* if we are implementing XON/XOFF, set the start and stop
2185	character in the device */	2185	character in the device */
2186	config->cXon = START_CHAR(tty);	2186	config->cXon = START_CHAR(tty);
2187	config->cXoff = STOP_CHAR(tty);	2187	config->cXoff = STOP_CHAR(tty);
2188		2188
2189	/* if we are implementing INBOUND XON/XOFF */	2189	/* if we are implementing INBOUND XON/XOFF */
2190	if (I_IXOFF(tty)) {	2190	if (I_IXOFF(tty)) {
2191	config->wFlags \|= UMP_MASK_UART_FLAGS_IN_X;	2191	config->wFlags \|= UMP_MASK_UART_FLAGS_IN_X;
2192	dev_dbg(dev, "%s - INBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x\n",	2192	dev_dbg(dev, "%s - INBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x\n",
2193	__func__, config->cXon, config->cXoff);	2193	__func__, config->cXon, config->cXoff);
2194	} else	2194	} else
2195	dev_dbg(dev, "%s - INBOUND XON/XOFF is disabled\n", __func__);	2195	dev_dbg(dev, "%s - INBOUND XON/XOFF is disabled\n", __func__);
2196		2196
2197	/* if we are implementing OUTBOUND XON/XOFF */	2197	/* if we are implementing OUTBOUND XON/XOFF */
2198	if (I_IXON(tty)) {	2198	if (I_IXON(tty)) {
2199	config->wFlags \|= UMP_MASK_UART_FLAGS_OUT_X;	2199	config->wFlags \|= UMP_MASK_UART_FLAGS_OUT_X;
2200	dev_dbg(dev, "%s - OUTBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x\n",	2200	dev_dbg(dev, "%s - OUTBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x\n",
2201	__func__, config->cXon, config->cXoff);	2201	__func__, config->cXon, config->cXoff);
2202	} else	2202	} else
2203	dev_dbg(dev, "%s - OUTBOUND XON/XOFF is disabled\n", __func__);	2203	dev_dbg(dev, "%s - OUTBOUND XON/XOFF is disabled\n", __func__);
2204		2204
2205	tty->termios.c_cflag &= ~CMSPAR;	2205	tty->termios.c_cflag &= ~CMSPAR;
2206		2206
2207	/* Round the baud rate */	2207	/* Round the baud rate */
2208	baud = tty_get_baud_rate(tty);	2208	baud = tty_get_baud_rate(tty);
2209	if (!baud) {	2209	if (!baud) {
2210	/* pick a default, any default... */	2210	/* pick a default, any default... */
2211	baud = 9600;	2211	baud = 9600;
2212	} else	2212	} else
2213	tty_encode_baud_rate(tty, baud, baud);	2213	tty_encode_baud_rate(tty, baud, baud);
2214		2214
2215	edge_port->baud_rate = baud;	2215	edge_port->baud_rate = baud;
2216	config->wBaudRate = (__u16)((461550L + baud/2) / baud);	2216	config->wBaudRate = (__u16)((461550L + baud/2) / baud);
2217		2217
2218	/* FIXME: Recompute actual baud from divisor here */	2218	/* FIXME: Recompute actual baud from divisor here */
2219		2219
2220	dev_dbg(dev, "%s - baud rate = %d, wBaudRate = %d\n", __func__, baud, config->wBaudRate);	2220	dev_dbg(dev, "%s - baud rate = %d, wBaudRate = %d\n", __func__, baud, config->wBaudRate);
2221		2221
2222	dev_dbg(dev, "wBaudRate: %d\n", (int)(461550L / config->wBaudRate));	2222	dev_dbg(dev, "wBaudRate: %d\n", (int)(461550L / config->wBaudRate));
2223	dev_dbg(dev, "wFlags: 0x%x\n", config->wFlags);	2223	dev_dbg(dev, "wFlags: 0x%x\n", config->wFlags);
2224	dev_dbg(dev, "bDataBits: %d\n", config->bDataBits);	2224	dev_dbg(dev, "bDataBits: %d\n", config->bDataBits);
2225	dev_dbg(dev, "bParity: %d\n", config->bParity);	2225	dev_dbg(dev, "bParity: %d\n", config->bParity);
2226	dev_dbg(dev, "bStopBits: %d\n", config->bStopBits);	2226	dev_dbg(dev, "bStopBits: %d\n", config->bStopBits);
2227	dev_dbg(dev, "cXon: %d\n", config->cXon);	2227	dev_dbg(dev, "cXon: %d\n", config->cXon);
2228	dev_dbg(dev, "cXoff: %d\n", config->cXoff);	2228	dev_dbg(dev, "cXoff: %d\n", config->cXoff);
2229	dev_dbg(dev, "bUartMode: %d\n", config->bUartMode);	2229	dev_dbg(dev, "bUartMode: %d\n", config->bUartMode);
2230		2230
2231	/* move the word values into big endian mode */	2231	/* move the word values into big endian mode */
2232	cpu_to_be16s(&config->wFlags);	2232	cpu_to_be16s(&config->wFlags);
2233	cpu_to_be16s(&config->wBaudRate);	2233	cpu_to_be16s(&config->wBaudRate);
2234		2234
2235	status = send_cmd(edge_port->port->serial->dev, UMPC_SET_CONFIG,	2235	status = send_cmd(edge_port->port->serial->dev, UMPC_SET_CONFIG,
2236	(__u8)(UMPM_UART1_PORT + port_number),	2236	(__u8)(UMPM_UART1_PORT + port_number),
2237	0, (__u8 )config, sizeof(config));	2237	0, (__u8 )config, sizeof(config));
2238	if (status)	2238	if (status)
2239	dev_dbg(dev, "%s - error %d when trying to write config to device\n",	2239	dev_dbg(dev, "%s - error %d when trying to write config to device\n",
2240	__func__, status);	2240	__func__, status);
2241	kfree(config);	2241	kfree(config);
2242	}	2242	}
2243		2243
2244	static void edge_set_termios(struct tty_struct *tty,	2244	static void edge_set_termios(struct tty_struct *tty,
2245	struct usb_serial_port port, struct ktermios old_termios)	2245	struct usb_serial_port port, struct ktermios old_termios)
2246	{	2246	{
2247	struct edgeport_port *edge_port = usb_get_serial_port_data(port);	2247	struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2248	unsigned int cflag;	2248	unsigned int cflag;
2249		2249
2250	cflag = tty->termios.c_cflag;	2250	cflag = tty->termios.c_cflag;
2251		2251
2252	dev_dbg(&port->dev, "%s - clfag %08x iflag %08x\n", __func__,	2252	dev_dbg(&port->dev, "%s - clfag %08x iflag %08x\n", __func__,
2253	tty->termios.c_cflag, tty->termios.c_iflag);	2253	tty->termios.c_cflag, tty->termios.c_iflag);
2254	dev_dbg(&port->dev, "%s - old clfag %08x old iflag %08x\n", __func__,	2254	dev_dbg(&port->dev, "%s - old clfag %08x old iflag %08x\n", __func__,
2255	old_termios->c_cflag, old_termios->c_iflag);	2255	old_termios->c_cflag, old_termios->c_iflag);
2256		2256
2257	if (edge_port == NULL)	2257	if (edge_port == NULL)
2258	return;	2258	return;
2259	/* change the port settings to the new ones specified */	2259	/* change the port settings to the new ones specified */
2260	change_port_settings(tty, edge_port, old_termios);	2260	change_port_settings(tty, edge_port, old_termios);
2261	}	2261	}
2262		2262
2263	static int edge_tiocmset(struct tty_struct *tty,	2263	static int edge_tiocmset(struct tty_struct *tty,
2264	unsigned int set, unsigned int clear)	2264	unsigned int set, unsigned int clear)
2265	{	2265	{
2266	struct usb_serial_port *port = tty->driver_data;	2266	struct usb_serial_port *port = tty->driver_data;
2267	struct edgeport_port *edge_port = usb_get_serial_port_data(port);	2267	struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2268	unsigned int mcr;	2268	unsigned int mcr;
2269	unsigned long flags;	2269	unsigned long flags;
2270		2270
2271	spin_lock_irqsave(&edge_port->ep_lock, flags);	2271	spin_lock_irqsave(&edge_port->ep_lock, flags);
2272	mcr = edge_port->shadow_mcr;	2272	mcr = edge_port->shadow_mcr;
2273	if (set & TIOCM_RTS)	2273	if (set & TIOCM_RTS)
2274	mcr \|= MCR_RTS;	2274	mcr \|= MCR_RTS;
2275	if (set & TIOCM_DTR)	2275	if (set & TIOCM_DTR)
2276	mcr \|= MCR_DTR;	2276	mcr \|= MCR_DTR;
2277	if (set & TIOCM_LOOP)	2277	if (set & TIOCM_LOOP)
2278	mcr \|= MCR_LOOPBACK;	2278	mcr \|= MCR_LOOPBACK;
2279		2279
2280	if (clear & TIOCM_RTS)	2280	if (clear & TIOCM_RTS)
2281	mcr &= ~MCR_RTS;	2281	mcr &= ~MCR_RTS;
2282	if (clear & TIOCM_DTR)	2282	if (clear & TIOCM_DTR)
2283	mcr &= ~MCR_DTR;	2283	mcr &= ~MCR_DTR;
2284	if (clear & TIOCM_LOOP)	2284	if (clear & TIOCM_LOOP)
2285	mcr &= ~MCR_LOOPBACK;	2285	mcr &= ~MCR_LOOPBACK;
2286		2286
2287	edge_port->shadow_mcr = mcr;	2287	edge_port->shadow_mcr = mcr;
2288	spin_unlock_irqrestore(&edge_port->ep_lock, flags);	2288	spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2289		2289
2290	restore_mcr(edge_port, mcr);	2290	restore_mcr(edge_port, mcr);
2291	return 0;	2291	return 0;
2292	}	2292	}
2293		2293
2294	static int edge_tiocmget(struct tty_struct *tty)	2294	static int edge_tiocmget(struct tty_struct *tty)
2295	{	2295	{
2296	struct usb_serial_port *port = tty->driver_data;	2296	struct usb_serial_port *port = tty->driver_data;
2297	struct edgeport_port *edge_port = usb_get_serial_port_data(port);	2297	struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2298	unsigned int result = 0;	2298	unsigned int result = 0;
2299	unsigned int msr;	2299	unsigned int msr;
2300	unsigned int mcr;	2300	unsigned int mcr;
2301	unsigned long flags;	2301	unsigned long flags;
2302		2302
2303	spin_lock_irqsave(&edge_port->ep_lock, flags);	2303	spin_lock_irqsave(&edge_port->ep_lock, flags);
2304		2304
2305	msr = edge_port->shadow_msr;	2305	msr = edge_port->shadow_msr;
2306	mcr = edge_port->shadow_mcr;	2306	mcr = edge_port->shadow_mcr;
2307	result = ((mcr & MCR_DTR) ? TIOCM_DTR: 0) /* 0x002 */	2307	result = ((mcr & MCR_DTR) ? TIOCM_DTR: 0) /* 0x002 */
2308	\| ((mcr & MCR_RTS) ? TIOCM_RTS: 0) /* 0x004 */	2308	\| ((mcr & MCR_RTS) ? TIOCM_RTS: 0) /* 0x004 */
2309	\| ((msr & EDGEPORT_MSR_CTS) ? TIOCM_CTS: 0) /* 0x020 */	2309	\| ((msr & EDGEPORT_MSR_CTS) ? TIOCM_CTS: 0) /* 0x020 */
2310	\| ((msr & EDGEPORT_MSR_CD) ? TIOCM_CAR: 0) /* 0x040 */	2310	\| ((msr & EDGEPORT_MSR_CD) ? TIOCM_CAR: 0) /* 0x040 */
2311	\| ((msr & EDGEPORT_MSR_RI) ? TIOCM_RI: 0) /* 0x080 */	2311	\| ((msr & EDGEPORT_MSR_RI) ? TIOCM_RI: 0) /* 0x080 */
2312	\| ((msr & EDGEPORT_MSR_DSR) ? TIOCM_DSR: 0); /* 0x100 */	2312	\| ((msr & EDGEPORT_MSR_DSR) ? TIOCM_DSR: 0); /* 0x100 */
2313		2313
2314		2314
2315	dev_dbg(&port->dev, "%s -- %x\n", __func__, result);	2315	dev_dbg(&port->dev, "%s -- %x\n", __func__, result);
2316	spin_unlock_irqrestore(&edge_port->ep_lock, flags);	2316	spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2317		2317
2318	return result;	2318	return result;
2319	}	2319	}
2320		2320
2321	static int get_serial_info(struct edgeport_port *edge_port,	2321	static int get_serial_info(struct edgeport_port *edge_port,
2322	struct serial_struct __user *retinfo)	2322	struct serial_struct __user *retinfo)
2323	{	2323	{
2324	struct serial_struct tmp;	2324	struct serial_struct tmp;
2325	unsigned cwait;	2325	unsigned cwait;
2326		2326
2327	if (!retinfo)	2327	if (!retinfo)
2328	return -EFAULT;	2328	return -EFAULT;
2329		2329
2330	cwait = edge_port->port->port.closing_wait;	2330	cwait = edge_port->port->port.closing_wait;
2331	if (cwait != ASYNC_CLOSING_WAIT_NONE)	2331	if (cwait != ASYNC_CLOSING_WAIT_NONE)
2332	cwait = jiffies_to_msecs(cwait) / 10;	2332	cwait = jiffies_to_msecs(cwait) / 10;
2333		2333
2334	memset(&tmp, 0, sizeof(tmp));	2334	memset(&tmp, 0, sizeof(tmp));
2335		2335
2336	tmp.type = PORT_16550A;	2336	tmp.type = PORT_16550A;
2337	tmp.line = edge_port->port->minor;	2337	tmp.line = edge_port->port->minor;
2338	tmp.port = edge_port->port->port_number;	2338	tmp.port = edge_port->port->port_number;
2339	tmp.irq = 0;	2339	tmp.irq = 0;
2340	tmp.flags = ASYNC_SKIP_TEST \| ASYNC_AUTO_IRQ;	2340	tmp.flags = ASYNC_SKIP_TEST \| ASYNC_AUTO_IRQ;
2341	tmp.xmit_fifo_size = edge_port->port->bulk_out_size;	2341	tmp.xmit_fifo_size = edge_port->port->bulk_out_size;
2342	tmp.baud_base = 9600;	2342	tmp.baud_base = 9600;
2343	tmp.close_delay = 5*HZ;	2343	tmp.close_delay = 5*HZ;
2344	tmp.closing_wait = cwait;	2344	tmp.closing_wait = cwait;
2345		2345
2346	if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))	2346	if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
2347	return -EFAULT;	2347	return -EFAULT;
2348	return 0;	2348	return 0;
2349	}	2349	}
2350		2350
2351	static int edge_ioctl(struct tty_struct *tty,	2351	static int edge_ioctl(struct tty_struct *tty,
2352	unsigned int cmd, unsigned long arg)	2352	unsigned int cmd, unsigned long arg)
2353	{	2353	{
2354	struct usb_serial_port *port = tty->driver_data;	2354	struct usb_serial_port *port = tty->driver_data;
2355	struct edgeport_port *edge_port = usb_get_serial_port_data(port);	2355	struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2356		2356
2357	switch (cmd) {	2357	switch (cmd) {
2358	case TIOCGSERIAL:	2358	case TIOCGSERIAL:
2359	dev_dbg(&port->dev, "%s - TIOCGSERIAL\n", __func__);	2359	dev_dbg(&port->dev, "%s - TIOCGSERIAL\n", __func__);
2360	return get_serial_info(edge_port,	2360	return get_serial_info(edge_port,
2361	(struct serial_struct __user *) arg);	2361	(struct serial_struct __user *) arg);
2362	}	2362	}
2363	return -ENOIOCTLCMD;	2363	return -ENOIOCTLCMD;
2364	}	2364	}
2365		2365
2366	static void edge_break(struct tty_struct *tty, int break_state)	2366	static void edge_break(struct tty_struct *tty, int break_state)
2367	{	2367	{
2368	struct usb_serial_port *port = tty->driver_data;	2368	struct usb_serial_port *port = tty->driver_data;
2369	struct edgeport_port *edge_port = usb_get_serial_port_data(port);	2369	struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2370	int status;	2370	int status;
2371	int bv = 0; /* Off */	2371	int bv = 0; /* Off */
2372		2372
2373	if (break_state == -1)	2373	if (break_state == -1)
2374	bv = 1; /* On */	2374	bv = 1; /* On */
2375	status = ti_do_config(edge_port, UMPC_SET_CLR_BREAK, bv);	2375	status = ti_do_config(edge_port, UMPC_SET_CLR_BREAK, bv);
2376	if (status)	2376	if (status)
2377	dev_dbg(&port->dev, "%s - error %d sending break set/clear command.\n",	2377	dev_dbg(&port->dev, "%s - error %d sending break set/clear command.\n",
2378	__func__, status);	2378	__func__, status);
2379	}	2379	}
2380		2380
2381	static int edge_startup(struct usb_serial *serial)	2381	static int edge_startup(struct usb_serial *serial)
2382	{	2382	{
2383	struct edgeport_serial *edge_serial;	2383	struct edgeport_serial *edge_serial;
2384	int status;	2384	int status;
2385		2385
2386	/* create our private serial structure */	2386	/* create our private serial structure */
2387	edge_serial = kzalloc(sizeof(struct edgeport_serial), GFP_KERNEL);	2387	edge_serial = kzalloc(sizeof(struct edgeport_serial), GFP_KERNEL);
2388	if (!edge_serial)	2388	if (!edge_serial)
2389	return -ENOMEM;	2389	return -ENOMEM;
2390		2390
2391	mutex_init(&edge_serial->es_lock);	2391	mutex_init(&edge_serial->es_lock);
2392	edge_serial->serial = serial;	2392	edge_serial->serial = serial;
2393	usb_set_serial_data(serial, edge_serial);	2393	usb_set_serial_data(serial, edge_serial);
2394		2394
2395	status = download_fw(edge_serial);	2395	status = download_fw(edge_serial);
2396	if (status) {	2396	if (status) {
2397	kfree(edge_serial);	2397	kfree(edge_serial);
2398	return status;	2398	return status;
2399	}	2399	}
2400		2400
2401	return 0;	2401	return 0;
2402	}	2402	}
2403		2403
2404	static void edge_disconnect(struct usb_serial *serial)	2404	static void edge_disconnect(struct usb_serial *serial)
2405	{	2405	{
2406	}	2406	}
2407		2407
2408	static void edge_release(struct usb_serial *serial)	2408	static void edge_release(struct usb_serial *serial)
2409	{	2409	{
2410	kfree(usb_get_serial_data(serial));	2410	kfree(usb_get_serial_data(serial));
2411	}	2411	}
2412		2412
2413	static int edge_port_probe(struct usb_serial_port *port)	2413	static int edge_port_probe(struct usb_serial_port *port)
2414	{	2414	{
2415	struct edgeport_port *edge_port;	2415	struct edgeport_port *edge_port;
2416	int ret;	2416	int ret;
2417		2417
2418	edge_port = kzalloc(sizeof(*edge_port), GFP_KERNEL);	2418	edge_port = kzalloc(sizeof(*edge_port), GFP_KERNEL);
2419	if (!edge_port)	2419	if (!edge_port)
2420	return -ENOMEM;	2420	return -ENOMEM;
2421		2421
2422	spin_lock_init(&edge_port->ep_lock);	2422	spin_lock_init(&edge_port->ep_lock);
2423	edge_port->port = port;	2423	edge_port->port = port;
2424	edge_port->edge_serial = usb_get_serial_data(port->serial);	2424	edge_port->edge_serial = usb_get_serial_data(port->serial);
2425	edge_port->bUartMode = default_uart_mode;	2425	edge_port->bUartMode = default_uart_mode;
2426		2426
2427	switch (port->port_number) {	2427	switch (port->port_number) {
2428	case 0:	2428	case 0:
2429	edge_port->uart_base = UMPMEM_BASE_UART1;	2429	edge_port->uart_base = UMPMEM_BASE_UART1;
2430	edge_port->dma_address = UMPD_OEDB1_ADDRESS;	2430	edge_port->dma_address = UMPD_OEDB1_ADDRESS;
2431	break;	2431	break;
2432	case 1:	2432	case 1:
2433	edge_port->uart_base = UMPMEM_BASE_UART2;	2433	edge_port->uart_base = UMPMEM_BASE_UART2;
2434	edge_port->dma_address = UMPD_OEDB2_ADDRESS;	2434	edge_port->dma_address = UMPD_OEDB2_ADDRESS;
2435	break;	2435	break;
2436	default:	2436	default:
2437	dev_err(&port->dev, "unknown port number\n");	2437	dev_err(&port->dev, "unknown port number\n");
2438	ret = -ENODEV;	2438	ret = -ENODEV;
2439	goto err;	2439	goto err;
2440	}	2440	}
2441		2441
2442	dev_dbg(&port->dev,	2442	dev_dbg(&port->dev,
2443	"%s - port_number = %d, uart_base = %04x, dma_address = %04x\n",	2443	"%s - port_number = %d, uart_base = %04x, dma_address = %04x\n",
2444	__func__, port->port_number, edge_port->uart_base,	2444	__func__, port->port_number, edge_port->uart_base,
2445	edge_port->dma_address);	2445	edge_port->dma_address);
2446		2446
2447	usb_set_serial_port_data(port, edge_port);	2447	usb_set_serial_port_data(port, edge_port);
2448		2448
2449	ret = edge_create_sysfs_attrs(port);	2449	ret = edge_create_sysfs_attrs(port);
2450	if (ret)	2450	if (ret)
2451	goto err;	2451	goto err;
2452		2452
2453	port->port.closing_wait = msecs_to_jiffies(closing_wait * 10);	2453	port->port.closing_wait = msecs_to_jiffies(closing_wait * 10);
2454	port->port.drain_delay = 1;	2454	port->port.drain_delay = 1;
2455		2455
2456	return 0;	2456	return 0;
2457	err:	2457	err:
2458	kfree(edge_port);	2458	kfree(edge_port);
2459		2459
2460	return ret;	2460	return ret;
2461	}	2461	}
2462		2462
2463	static int edge_port_remove(struct usb_serial_port *port)	2463	static int edge_port_remove(struct usb_serial_port *port)
2464	{	2464	{
2465	struct edgeport_port *edge_port;	2465	struct edgeport_port *edge_port;
2466		2466
2467	edge_port = usb_get_serial_port_data(port);	2467	edge_port = usb_get_serial_port_data(port);
2468	edge_remove_sysfs_attrs(port);	2468	edge_remove_sysfs_attrs(port);
2469	kfree(edge_port);	2469	kfree(edge_port);
2470		2470
2471	return 0;	2471	return 0;
2472	}	2472	}
2473		2473
2474	/* Sysfs Attributes */	2474	/* Sysfs Attributes */
2475		2475
2476	static ssize_t uart_mode_show(struct device *dev,	2476	static ssize_t uart_mode_show(struct device *dev,
2477	struct device_attribute attr, char buf)	2477	struct device_attribute attr, char buf)
2478	{	2478	{
2479	struct usb_serial_port *port = to_usb_serial_port(dev);	2479	struct usb_serial_port *port = to_usb_serial_port(dev);
2480	struct edgeport_port *edge_port = usb_get_serial_port_data(port);	2480	struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2481		2481
2482	return sprintf(buf, "%d\n", edge_port->bUartMode);	2482	return sprintf(buf, "%d\n", edge_port->bUartMode);
2483	}	2483	}
2484		2484
2485	static ssize_t uart_mode_store(struct device *dev,	2485	static ssize_t uart_mode_store(struct device *dev,
2486	struct device_attribute attr, const char valbuf, size_t count)	2486	struct device_attribute attr, const char valbuf, size_t count)
2487	{	2487	{
2488	struct usb_serial_port *port = to_usb_serial_port(dev);	2488	struct usb_serial_port *port = to_usb_serial_port(dev);
2489	struct edgeport_port *edge_port = usb_get_serial_port_data(port);	2489	struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2490	unsigned int v = simple_strtoul(valbuf, NULL, 0);	2490	unsigned int v = simple_strtoul(valbuf, NULL, 0);
2491		2491
2492	dev_dbg(dev, "%s: setting uart_mode = %d\n", __func__, v);	2492	dev_dbg(dev, "%s: setting uart_mode = %d\n", __func__, v);
2493		2493
2494	if (v < 256)	2494	if (v < 256)
2495	edge_port->bUartMode = v;	2495	edge_port->bUartMode = v;
2496	else	2496	else
2497	dev_err(dev, "%s - uart_mode %d is invalid\n", __func__, v);	2497	dev_err(dev, "%s - uart_mode %d is invalid\n", __func__, v);
2498		2498
2499	return count;	2499	return count;
2500	}	2500	}
2501	static DEVICE_ATTR_RW(uart_mode);	2501	static DEVICE_ATTR_RW(uart_mode);
2502		2502
2503	static int edge_create_sysfs_attrs(struct usb_serial_port *port)	2503	static int edge_create_sysfs_attrs(struct usb_serial_port *port)
2504	{	2504	{
2505	return device_create_file(&port->dev, &dev_attr_uart_mode);	2505	return device_create_file(&port->dev, &dev_attr_uart_mode);
2506	}	2506	}
2507		2507
2508	static int edge_remove_sysfs_attrs(struct usb_serial_port *port)	2508	static int edge_remove_sysfs_attrs(struct usb_serial_port *port)
2509	{	2509	{
2510	device_remove_file(&port->dev, &dev_attr_uart_mode);	2510	device_remove_file(&port->dev, &dev_attr_uart_mode);
2511	return 0;	2511	return 0;
2512	}	2512	}
2513		2513
2514		2514
2515	static struct usb_serial_driver edgeport_1port_device = {	2515	static struct usb_serial_driver edgeport_1port_device = {
2516	.driver = {	2516	.driver = {
2517	.owner = THIS_MODULE,	2517	.owner = THIS_MODULE,
2518	.name = "edgeport_ti_1",	2518	.name = "edgeport_ti_1",
2519	},	2519	},
2520	.description = "Edgeport TI 1 port adapter",	2520	.description = "Edgeport TI 1 port adapter",
2521	.id_table = edgeport_1port_id_table,	2521	.id_table = edgeport_1port_id_table,
2522	.num_ports = 1,	2522	.num_ports = 1,
2523	.open = edge_open,	2523	.open = edge_open,
2524	.close = edge_close,	2524	.close = edge_close,
2525	.throttle = edge_throttle,	2525	.throttle = edge_throttle,
2526	.unthrottle = edge_unthrottle,	2526	.unthrottle = edge_unthrottle,
2527	.attach = edge_startup,	2527	.attach = edge_startup,
2528	.disconnect = edge_disconnect,	2528	.disconnect = edge_disconnect,
2529	.release = edge_release,	2529	.release = edge_release,
2530	.port_probe = edge_port_probe,	2530	.port_probe = edge_port_probe,
2531	.port_remove = edge_port_remove,	2531	.port_remove = edge_port_remove,
2532	.ioctl = edge_ioctl,	2532	.ioctl = edge_ioctl,
2533	.set_termios = edge_set_termios,	2533	.set_termios = edge_set_termios,
2534	.tiocmget = edge_tiocmget,	2534	.tiocmget = edge_tiocmget,
2535	.tiocmset = edge_tiocmset,	2535	.tiocmset = edge_tiocmset,
2536	.tiocmiwait = usb_serial_generic_tiocmiwait,	2536	.tiocmiwait = usb_serial_generic_tiocmiwait,
2537	.get_icount = usb_serial_generic_get_icount,	2537	.get_icount = usb_serial_generic_get_icount,
2538	.write = edge_write,	2538	.write = edge_write,
2539	.write_room = edge_write_room,	2539	.write_room = edge_write_room,
2540	.chars_in_buffer = edge_chars_in_buffer,	2540	.chars_in_buffer = edge_chars_in_buffer,
2541	.tx_empty = edge_tx_empty,	2541	.tx_empty = edge_tx_empty,
2542	.break_ctl = edge_break,	2542	.break_ctl = edge_break,
2543	.read_int_callback = edge_interrupt_callback,	2543	.read_int_callback = edge_interrupt_callback,
2544	.read_bulk_callback = edge_bulk_in_callback,	2544	.read_bulk_callback = edge_bulk_in_callback,
2545	.write_bulk_callback = edge_bulk_out_callback,	2545	.write_bulk_callback = edge_bulk_out_callback,
2546	};	2546	};
2547		2547
2548	static struct usb_serial_driver edgeport_2port_device = {	2548	static struct usb_serial_driver edgeport_2port_device = {
2549	.driver = {	2549	.driver = {
2550	.owner = THIS_MODULE,	2550	.owner = THIS_MODULE,
2551	.name = "edgeport_ti_2",	2551	.name = "edgeport_ti_2",
2552	},	2552	},
2553	.description = "Edgeport TI 2 port adapter",	2553	.description = "Edgeport TI 2 port adapter",
2554	.id_table = edgeport_2port_id_table,	2554	.id_table = edgeport_2port_id_table,
2555	.num_ports = 2,	2555	.num_ports = 2,
2556	.open = edge_open,	2556	.open = edge_open,
2557	.close = edge_close,	2557	.close = edge_close,
2558	.throttle = edge_throttle,	2558	.throttle = edge_throttle,
2559	.unthrottle = edge_unthrottle,	2559	.unthrottle = edge_unthrottle,
2560	.attach = edge_startup,	2560	.attach = edge_startup,
2561	.disconnect = edge_disconnect,	2561	.disconnect = edge_disconnect,
2562	.release = edge_release,	2562	.release = edge_release,
2563	.port_probe = edge_port_probe,	2563	.port_probe = edge_port_probe,
2564	.port_remove = edge_port_remove,	2564	.port_remove = edge_port_remove,
2565	.ioctl = edge_ioctl,	2565	.ioctl = edge_ioctl,
2566	.set_termios = edge_set_termios,	2566	.set_termios = edge_set_termios,
2567	.tiocmget = edge_tiocmget,	2567	.tiocmget = edge_tiocmget,
2568	.tiocmset = edge_tiocmset,	2568	.tiocmset = edge_tiocmset,
2569	.tiocmiwait = usb_serial_generic_tiocmiwait,	2569	.tiocmiwait = usb_serial_generic_tiocmiwait,
2570	.get_icount = usb_serial_generic_get_icount,	2570	.get_icount = usb_serial_generic_get_icount,
2571	.write = edge_write,	2571	.write = edge_write,
2572	.write_room = edge_write_room,	2572	.write_room = edge_write_room,
2573	.chars_in_buffer = edge_chars_in_buffer,	2573	.chars_in_buffer = edge_chars_in_buffer,
2574	.tx_empty = edge_tx_empty,	2574	.tx_empty = edge_tx_empty,
2575	.break_ctl = edge_break,	2575	.break_ctl = edge_break,
2576	.read_int_callback = edge_interrupt_callback,	2576	.read_int_callback = edge_interrupt_callback,
2577	.read_bulk_callback = edge_bulk_in_callback,	2577	.read_bulk_callback = edge_bulk_in_callback,
2578	.write_bulk_callback = edge_bulk_out_callback,	2578	.write_bulk_callback = edge_bulk_out_callback,
2579	};	2579	};
2580		2580
2581	static struct usb_serial_driver * const serial_drivers[] = {	2581	static struct usb_serial_driver * const serial_drivers[] = {
2582	&edgeport_1port_device, &edgeport_2port_device, NULL	2582	&edgeport_1port_device, &edgeport_2port_device, NULL
2583	};	2583	};
2584		2584
2585	module_usb_serial_driver(serial_drivers, id_table_combined);	2585	module_usb_serial_driver(serial_drivers, id_table_combined);
2586		2586
2587	MODULE_AUTHOR(DRIVER_AUTHOR);	2587	MODULE_AUTHOR(DRIVER_AUTHOR);
2588	MODULE_DESCRIPTION(DRIVER_DESC);	2588	MODULE_DESCRIPTION(DRIVER_DESC);
2589	MODULE_LICENSE("GPL");	2589	MODULE_LICENSE("GPL");
2590	MODULE_FIRMWARE("edgeport/down3.bin");	2590	MODULE_FIRMWARE("edgeport/down3.bin");
2591		2591
2592	module_param(closing_wait, int, S_IRUGO \| S_IWUSR);	2592	module_param(closing_wait, int, S_IRUGO \| S_IWUSR);
2593	MODULE_PARM_DESC(closing_wait, "Maximum wait for data to drain, in .01 secs");	2593	MODULE_PARM_DESC(closing_wait, "Maximum wait for data to drain, in .01 secs");
2594		2594
2595	module_param(ignore_cpu_rev, bool, S_IRUGO \| S_IWUSR);	2595	module_param(ignore_cpu_rev, bool, S_IRUGO \| S_IWUSR);
2596	MODULE_PARM_DESC(ignore_cpu_rev,	2596	MODULE_PARM_DESC(ignore_cpu_rev,
2597	"Ignore the cpu revision when connecting to a device");	2597	"Ignore the cpu revision when connecting to a device");
2598		2598
2599	module_param(default_uart_mode, int, S_IRUGO \| S_IWUSR);	2599	module_param(default_uart_mode, int, S_IRUGO \| S_IWUSR);
2600	MODULE_PARM_DESC(default_uart_mode, "Default uart_mode, 0=RS232, ...");	2600	MODULE_PARM_DESC(default_uart_mode, "Default uart_mode, 0=RS232, ...");
2601		2601

drivers/usb/serial/io_usbvend.h

Diff comments View file @ 8ee7a33

drivers/usb/serial/option.c

Diff comments View file @ 8ee7a33

 /*
   USB Driver for GSM modems
   Copyright (C) 2005  Matthias Urlichs <smurf@smurf.noris.de>
   This driver is free software; you can redistribute it and/or modify
   it under the terms of Version 2 of the GNU General Public License as
   published by the Free Software Foundation.
   Portions copied from the Keyspan driver by Hugh Blemings <hugh@blemings.org>
   History: see the git log.
   Work sponsored by: Sigos GmbH, Germany <info@sigos.de>
   This driver exists because the "normal" serial driver doesn't work too well
   with GSM modems. Issues:
   - data loss -- one single Receive URB is not nearly enough
   - nonstandard flow (Option devices) control
   - controlling the baud rate doesn't make sense
   This driver is named "option" because the most common device it's
   used for is a PC-Card (with an internal OHCI-USB interface, behind
   which the GSM interface sits), made by Option Inc.
   Some of the "one port" devices actually exhibit multiple USB instances
   on the USB bus. This is not a bug, these ports are used for different
   device features.
 */
 #define DRIVER_AUTHOR "Matthias Urlichs <smurf@smurf.noris.de>"
 #define DRIVER_DESC "USB Driver for GSM modems"
 #include <linux/kernel.h>
 #include <linux/jiffies.h>
 #include <linux/errno.h>
 #include <linux/tty.h>
 #include <linux/tty_flip.h>
 #include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/bitops.h>
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
 #include "usb-wwan.h"
 /* Function prototypes */
 static int  option_probe(struct usb_serial *serial,
 			const struct usb_device_id *id);
 static int option_attach(struct usb_serial *serial);
 static void option_release(struct usb_serial *serial);
 static int option_send_setup(struct usb_serial_port *port);
 static void option_instat_callback(struct urb *urb);
 /* Vendor and product IDs */
 #define OPTION_VENDOR_ID			0x0AF0
 #define OPTION_PRODUCT_COLT			0x5000
 #define OPTION_PRODUCT_RICOLA			0x6000
 #define OPTION_PRODUCT_RICOLA_LIGHT		0x6100
 #define OPTION_PRODUCT_RICOLA_QUAD		0x6200
 #define OPTION_PRODUCT_RICOLA_QUAD_LIGHT	0x6300
 #define OPTION_PRODUCT_RICOLA_NDIS		0x6050
 #define OPTION_PRODUCT_RICOLA_NDIS_LIGHT	0x6150
 #define OPTION_PRODUCT_RICOLA_NDIS_QUAD		0x6250
 #define OPTION_PRODUCT_RICOLA_NDIS_QUAD_LIGHT	0x6350
 #define OPTION_PRODUCT_COBRA			0x6500
 #define OPTION_PRODUCT_COBRA_BUS		0x6501
 #define OPTION_PRODUCT_VIPER			0x6600
 #define OPTION_PRODUCT_VIPER_BUS		0x6601
 #define OPTION_PRODUCT_GT_MAX_READY		0x6701
 #define OPTION_PRODUCT_FUJI_MODEM_LIGHT		0x6721
 #define OPTION_PRODUCT_FUJI_MODEM_GT		0x6741
 #define OPTION_PRODUCT_FUJI_MODEM_EX		0x6761
 #define OPTION_PRODUCT_KOI_MODEM		0x6800
 #define OPTION_PRODUCT_SCORPION_MODEM		0x6901
 #define OPTION_PRODUCT_ETNA_MODEM		0x7001
 #define OPTION_PRODUCT_ETNA_MODEM_LITE		0x7021
 #define OPTION_PRODUCT_ETNA_MODEM_GT		0x7041
 #define OPTION_PRODUCT_ETNA_MODEM_EX		0x7061
 #define OPTION_PRODUCT_ETNA_KOI_MODEM		0x7100
 #define OPTION_PRODUCT_GTM380_MODEM		0x7201
 #define HUAWEI_VENDOR_ID			0x12D1
 #define HUAWEI_PRODUCT_E173			0x140C
 #define HUAWEI_PRODUCT_E1750			0x1406
 #define HUAWEI_PRODUCT_K4505			0x1464
 #define HUAWEI_PRODUCT_K3765			0x1465
 #define HUAWEI_PRODUCT_K4605			0x14C6
 #define HUAWEI_PRODUCT_E173S6			0x1C07
 #define QUANTA_VENDOR_ID			0x0408
 #define QUANTA_PRODUCT_Q101			0xEA02
 #define QUANTA_PRODUCT_Q111			0xEA03
 #define QUANTA_PRODUCT_GLX			0xEA04
 #define QUANTA_PRODUCT_GKE			0xEA05
 #define QUANTA_PRODUCT_GLE			0xEA06
 #define NOVATELWIRELESS_VENDOR_ID		0x1410
 /* YISO PRODUCTS */
 #define YISO_VENDOR_ID				0x0EAB
 #define YISO_PRODUCT_U893			0xC893
 /*
  * NOVATEL WIRELESS PRODUCTS
  *
  * Note from Novatel Wireless:
  * If your Novatel modem does not work on linux, don't
  * change the option module, but check our website. If
  * that does not help, contact ddeschepper@nvtl.com
 */
 /* MERLIN EVDO PRODUCTS */
 #define NOVATELWIRELESS_PRODUCT_V640		0x1100
 #define NOVATELWIRELESS_PRODUCT_V620		0x1110
 #define NOVATELWIRELESS_PRODUCT_V740		0x1120
 #define NOVATELWIRELESS_PRODUCT_V720		0x1130
 /* MERLIN HSDPA/HSPA PRODUCTS */
 #define NOVATELWIRELESS_PRODUCT_U730		0x1400
 #define NOVATELWIRELESS_PRODUCT_U740		0x1410
 #define NOVATELWIRELESS_PRODUCT_U870		0x1420
 #define NOVATELWIRELESS_PRODUCT_XU870		0x1430
 #define NOVATELWIRELESS_PRODUCT_X950D		0x1450
 /* EXPEDITE PRODUCTS */
 #define NOVATELWIRELESS_PRODUCT_EV620		0x2100
 #define NOVATELWIRELESS_PRODUCT_ES720		0x2110
 #define NOVATELWIRELESS_PRODUCT_E725		0x2120
 #define NOVATELWIRELESS_PRODUCT_ES620		0x2130
 #define NOVATELWIRELESS_PRODUCT_EU730		0x2400
 #define NOVATELWIRELESS_PRODUCT_EU740		0x2410
 #define NOVATELWIRELESS_PRODUCT_EU870D		0x2420
 /* OVATION PRODUCTS */
 #define NOVATELWIRELESS_PRODUCT_MC727		0x4100
 #define NOVATELWIRELESS_PRODUCT_MC950D		0x4400
 /*
  * Note from Novatel Wireless:
  * All PID in the 5xxx range are currently reserved for
  * auto-install CDROMs, and should not be added to this
  * module.
  *
  * #define NOVATELWIRELESS_PRODUCT_U727		0x5010
  * #define NOVATELWIRELESS_PRODUCT_MC727_NEW	0x5100
 */
 #define NOVATELWIRELESS_PRODUCT_OVMC760		0x6002
 #define NOVATELWIRELESS_PRODUCT_MC780		0x6010
 #define NOVATELWIRELESS_PRODUCT_EVDO_FULLSPEED	0x6000
 #define NOVATELWIRELESS_PRODUCT_EVDO_HIGHSPEED	0x6001
 #define NOVATELWIRELESS_PRODUCT_HSPA_FULLSPEED	0x7000
 #define NOVATELWIRELESS_PRODUCT_HSPA_HIGHSPEED	0x7001
 #define NOVATELWIRELESS_PRODUCT_HSPA_HIGHSPEED3	0x7003
 #define NOVATELWIRELESS_PRODUCT_HSPA_HIGHSPEED4	0x7004
 #define NOVATELWIRELESS_PRODUCT_HSPA_HIGHSPEED5	0x7005
 #define NOVATELWIRELESS_PRODUCT_HSPA_HIGHSPEED6	0x7006
 #define NOVATELWIRELESS_PRODUCT_HSPA_HIGHSPEED7	0x7007
 #define NOVATELWIRELESS_PRODUCT_MC996D		0x7030
 #define NOVATELWIRELESS_PRODUCT_MF3470		0x7041
 #define NOVATELWIRELESS_PRODUCT_MC547		0x7042
 #define NOVATELWIRELESS_PRODUCT_EVDO_EMBEDDED_FULLSPEED	0x8000
 #define NOVATELWIRELESS_PRODUCT_EVDO_EMBEDDED_HIGHSPEED	0x8001
 #define NOVATELWIRELESS_PRODUCT_HSPA_EMBEDDED_FULLSPEED	0x9000
 #define NOVATELWIRELESS_PRODUCT_HSPA_EMBEDDED_HIGHSPEED	0x9001
 #define NOVATELWIRELESS_PRODUCT_E362		0x9010
+#define NOVATELWIRELESS_PRODUCT_E371		0x9011
 #define NOVATELWIRELESS_PRODUCT_G2		0xA010
 #define NOVATELWIRELESS_PRODUCT_MC551		0xB001
 /* AMOI PRODUCTS */
 #define AMOI_VENDOR_ID				0x1614
 #define AMOI_PRODUCT_H01			0x0800
 #define AMOI_PRODUCT_H01A			0x7002
 #define AMOI_PRODUCT_H02			0x0802
 #define AMOI_PRODUCT_SKYPEPHONE_S2		0x0407
 #define DELL_VENDOR_ID				0x413C
 /* Dell modems */
 #define DELL_PRODUCT_5700_MINICARD		0x8114
 #define DELL_PRODUCT_5500_MINICARD		0x8115
 #define DELL_PRODUCT_5505_MINICARD		0x8116
 #define DELL_PRODUCT_5700_EXPRESSCARD		0x8117
 #define DELL_PRODUCT_5510_EXPRESSCARD		0x8118
 #define DELL_PRODUCT_5700_MINICARD_SPRINT	0x8128
 #define DELL_PRODUCT_5700_MINICARD_TELUS	0x8129
 #define DELL_PRODUCT_5720_MINICARD_VZW		0x8133
 #define DELL_PRODUCT_5720_MINICARD_SPRINT	0x8134
 #define DELL_PRODUCT_5720_MINICARD_TELUS	0x8135
 #define DELL_PRODUCT_5520_MINICARD_CINGULAR	0x8136
 #define DELL_PRODUCT_5520_MINICARD_GENERIC_L	0x8137
 #define DELL_PRODUCT_5520_MINICARD_GENERIC_I	0x8138
 #define DELL_PRODUCT_5730_MINICARD_SPRINT	0x8180
 #define DELL_PRODUCT_5730_MINICARD_TELUS	0x8181
 #define DELL_PRODUCT_5730_MINICARD_VZW		0x8182
 #define DELL_PRODUCT_5800_MINICARD_VZW		0x8195  /* Novatel E362 */
 #define DELL_PRODUCT_5800_V2_MINICARD_VZW	0x8196  /* Novatel E362 */
 #define DELL_PRODUCT_5804_MINICARD_ATT		0x819b  /* Novatel E371 */
 #define KYOCERA_VENDOR_ID			0x0c88
 #define KYOCERA_PRODUCT_KPC650			0x17da
 #define KYOCERA_PRODUCT_KPC680			0x180a
 #define ANYDATA_VENDOR_ID			0x16d5
 #define ANYDATA_PRODUCT_ADU_620UW		0x6202
 #define ANYDATA_PRODUCT_ADU_E100A		0x6501
 #define ANYDATA_PRODUCT_ADU_500A		0x6502
 #define AXESSTEL_VENDOR_ID			0x1726
 #define AXESSTEL_PRODUCT_MV110H			0x1000
 #define BANDRICH_VENDOR_ID			0x1A8D
 #define BANDRICH_PRODUCT_C100_1			0x1002
 #define BANDRICH_PRODUCT_C100_2			0x1003
 #define BANDRICH_PRODUCT_1004			0x1004
 #define BANDRICH_PRODUCT_1005			0x1005
 #define BANDRICH_PRODUCT_1006			0x1006
 #define BANDRICH_PRODUCT_1007			0x1007
 #define BANDRICH_PRODUCT_1008			0x1008
 #define BANDRICH_PRODUCT_1009			0x1009
 #define BANDRICH_PRODUCT_100A			0x100a
 #define BANDRICH_PRODUCT_100B			0x100b
 #define BANDRICH_PRODUCT_100C			0x100c
 #define BANDRICH_PRODUCT_100D			0x100d
 #define BANDRICH_PRODUCT_100E			0x100e
 #define BANDRICH_PRODUCT_100F			0x100f
 #define BANDRICH_PRODUCT_1010			0x1010
 #define BANDRICH_PRODUCT_1011			0x1011
 #define BANDRICH_PRODUCT_1012			0x1012
 #define QUALCOMM_VENDOR_ID			0x05C6
 #define CMOTECH_VENDOR_ID			0x16d8
 #define CMOTECH_PRODUCT_6001			0x6001
 #define CMOTECH_PRODUCT_CMU_300			0x6002
 #define CMOTECH_PRODUCT_6003			0x6003
 #define CMOTECH_PRODUCT_6004			0x6004
 #define CMOTECH_PRODUCT_6005			0x6005
 #define CMOTECH_PRODUCT_CGU_628A		0x6006
 #define CMOTECH_PRODUCT_CHE_628S		0x6007
 #define CMOTECH_PRODUCT_CMU_301			0x6008
 #define CMOTECH_PRODUCT_CHU_628			0x6280
 #define CMOTECH_PRODUCT_CHU_628S		0x6281
 #define CMOTECH_PRODUCT_CDU_680			0x6803
 #define CMOTECH_PRODUCT_CDU_685A		0x6804
 #define CMOTECH_PRODUCT_CHU_720S		0x7001
 #define CMOTECH_PRODUCT_7002			0x7002
 #define CMOTECH_PRODUCT_CHU_629K		0x7003
 #define CMOTECH_PRODUCT_7004			0x7004
 #define CMOTECH_PRODUCT_7005			0x7005
 #define CMOTECH_PRODUCT_CGU_629			0x7006
 #define CMOTECH_PRODUCT_CHU_629S		0x700a
 #define CMOTECH_PRODUCT_CHU_720I		0x7211
 #define CMOTECH_PRODUCT_7212			0x7212
 #define CMOTECH_PRODUCT_7213			0x7213
 #define CMOTECH_PRODUCT_7251			0x7251
 #define CMOTECH_PRODUCT_7252			0x7252
 #define CMOTECH_PRODUCT_7253			0x7253
 #define TELIT_VENDOR_ID				0x1bc7
 #define TELIT_PRODUCT_UC864E			0x1003
 #define TELIT_PRODUCT_UC864G			0x1004
 #define TELIT_PRODUCT_CC864_DUAL		0x1005
 #define TELIT_PRODUCT_CC864_SINGLE		0x1006
 #define TELIT_PRODUCT_DE910_DUAL		0x1010
 #define TELIT_PRODUCT_UE910_V2			0x1012
 #define TELIT_PRODUCT_LE920			0x1200
 /* ZTE PRODUCTS */
 #define ZTE_VENDOR_ID				0x19d2
 #define ZTE_PRODUCT_MF622			0x0001
 #define ZTE_PRODUCT_MF628			0x0015
 #define ZTE_PRODUCT_MF626			0x0031
 #define ZTE_PRODUCT_MC2718			0xffe8
 #define ZTE_PRODUCT_AC2726			0xfff1
 #define BENQ_VENDOR_ID				0x04a5
 #define BENQ_PRODUCT_H10			0x4068
 #define DLINK_VENDOR_ID				0x1186
 #define DLINK_PRODUCT_DWM_652			0x3e04
 #define DLINK_PRODUCT_DWM_652_U5		0xce16
 #define DLINK_PRODUCT_DWM_652_U5A		0xce1e
 #define QISDA_VENDOR_ID				0x1da5
 #define QISDA_PRODUCT_H21_4512			0x4512
 #define QISDA_PRODUCT_H21_4523			0x4523
 #define QISDA_PRODUCT_H20_4515			0x4515
 #define QISDA_PRODUCT_H20_4518			0x4518
 #define QISDA_PRODUCT_H20_4519			0x4519
 /* TLAYTECH PRODUCTS */
 #define TLAYTECH_VENDOR_ID			0x20B9
 #define TLAYTECH_PRODUCT_TEU800			0x1682
 /* TOSHIBA PRODUCTS */
 #define TOSHIBA_VENDOR_ID			0x0930
 #define TOSHIBA_PRODUCT_HSDPA_MINICARD		0x1302
 #define TOSHIBA_PRODUCT_G450			0x0d45
 #define ALINK_VENDOR_ID				0x1e0e
 #define ALINK_PRODUCT_PH300			0x9100
 #define ALINK_PRODUCT_3GU			0x9200
 /* ALCATEL PRODUCTS */
 #define ALCATEL_VENDOR_ID			0x1bbb
 #define ALCATEL_PRODUCT_X060S_X200		0x0000
 #define ALCATEL_PRODUCT_X220_X500D		0x0017
 #define ALCATEL_PRODUCT_L100V			0x011e
 #define ALCATEL_PRODUCT_L800MA			0x0203
 #define PIRELLI_VENDOR_ID			0x1266
 #define PIRELLI_PRODUCT_C100_1			0x1002
 #define PIRELLI_PRODUCT_C100_2			0x1003
 #define PIRELLI_PRODUCT_1004			0x1004
 #define PIRELLI_PRODUCT_1005			0x1005
 #define PIRELLI_PRODUCT_1006			0x1006
 #define PIRELLI_PRODUCT_1007			0x1007
 #define PIRELLI_PRODUCT_1008			0x1008
 #define PIRELLI_PRODUCT_1009			0x1009
 #define PIRELLI_PRODUCT_100A			0x100a
 #define PIRELLI_PRODUCT_100B			0x100b
 #define PIRELLI_PRODUCT_100C			0x100c
 #define PIRELLI_PRODUCT_100D			0x100d
 #define PIRELLI_PRODUCT_100E			0x100e
 #define PIRELLI_PRODUCT_100F			0x100f
 #define PIRELLI_PRODUCT_1011			0x1011
 #define PIRELLI_PRODUCT_1012			0x1012
 /* Airplus products */
 #define AIRPLUS_VENDOR_ID			0x1011
 #define AIRPLUS_PRODUCT_MCD650			0x3198
 /* Longcheer/Longsung vendor ID; makes whitelabel devices that
  * many other vendors like 4G Systems, Alcatel, ChinaBird,
  * Mobidata, etc sell under their own brand names.
  */
 #define LONGCHEER_VENDOR_ID			0x1c9e
 /* 4G Systems products */
 /* This is the 4G XS Stick W14 a.k.a. Mobilcom Debitel Surf-Stick *
  * It seems to contain a Qualcomm QSC6240/6290 chipset            */
 #define FOUR_G_SYSTEMS_PRODUCT_W14		0x9603
 /* iBall 3.5G connect wireless modem */
 #define IBALL_3_5G_CONNECT			0x9605
 /* Zoom */
 #define ZOOM_PRODUCT_4597			0x9607
 /* Haier products */
 #define HAIER_VENDOR_ID				0x201e
 #define HAIER_PRODUCT_CE100			0x2009
 /* Cinterion (formerly Siemens) products */
 #define SIEMENS_VENDOR_ID				0x0681
 #define CINTERION_VENDOR_ID				0x1e2d
 #define CINTERION_PRODUCT_HC25_MDM		0x0047
 #define CINTERION_PRODUCT_HC25_MDMNET	0x0040
 #define CINTERION_PRODUCT_HC28_MDM		0x004C
 #define CINTERION_PRODUCT_HC28_MDMNET	0x004A /* same for HC28J */
 #define CINTERION_PRODUCT_EU3_E			0x0051
 #define CINTERION_PRODUCT_EU3_P			0x0052
 #define CINTERION_PRODUCT_PH8			0x0053
 #define CINTERION_PRODUCT_AHXX			0x0055
 #define CINTERION_PRODUCT_PLXX			0x0060
 /* Olivetti products */
 #define OLIVETTI_VENDOR_ID			0x0b3c
 #define OLIVETTI_PRODUCT_OLICARD100		0xc000
 #define OLIVETTI_PRODUCT_OLICARD145		0xc003
 #define OLIVETTI_PRODUCT_OLICARD200		0xc005
 #define OLIVETTI_PRODUCT_OLICARD500		0xc00b
 /* Celot products */
 #define CELOT_VENDOR_ID				0x211f
 #define CELOT_PRODUCT_CT680M			0x6801
 /* Samsung products */
 #define SAMSUNG_VENDOR_ID                       0x04e8
 #define SAMSUNG_PRODUCT_GT_B3730                0x6889
 /* YUGA products  www.yuga-info.com gavin.kx@qq.com */
 #define YUGA_VENDOR_ID				0x257A
 #define YUGA_PRODUCT_CEM600			0x1601
 #define YUGA_PRODUCT_CEM610			0x1602
 #define YUGA_PRODUCT_CEM500			0x1603
 #define YUGA_PRODUCT_CEM510			0x1604
 #define YUGA_PRODUCT_CEM800			0x1605
 #define YUGA_PRODUCT_CEM900			0x1606
 #define YUGA_PRODUCT_CEU818			0x1607
 #define YUGA_PRODUCT_CEU816			0x1608
 #define YUGA_PRODUCT_CEU828			0x1609
 #define YUGA_PRODUCT_CEU826			0x160A
 #define YUGA_PRODUCT_CEU518			0x160B
 #define YUGA_PRODUCT_CEU516			0x160C
 #define YUGA_PRODUCT_CEU528			0x160D
 #define YUGA_PRODUCT_CEU526			0x160F
 #define YUGA_PRODUCT_CEU881			0x161F
 #define YUGA_PRODUCT_CEU882			0x162F
 #define YUGA_PRODUCT_CWM600			0x2601
 #define YUGA_PRODUCT_CWM610			0x2602
 #define YUGA_PRODUCT_CWM500			0x2603
 #define YUGA_PRODUCT_CWM510			0x2604
 #define YUGA_PRODUCT_CWM800			0x2605
 #define YUGA_PRODUCT_CWM900			0x2606
 #define YUGA_PRODUCT_CWU718			0x2607
 #define YUGA_PRODUCT_CWU716			0x2608
 #define YUGA_PRODUCT_CWU728			0x2609
 #define YUGA_PRODUCT_CWU726			0x260A
 #define YUGA_PRODUCT_CWU518			0x260B
 #define YUGA_PRODUCT_CWU516			0x260C
 #define YUGA_PRODUCT_CWU528			0x260D
 #define YUGA_PRODUCT_CWU581			0x260E
 #define YUGA_PRODUCT_CWU526			0x260F
 #define YUGA_PRODUCT_CWU582			0x261F
 #define YUGA_PRODUCT_CWU583			0x262F
 #define YUGA_PRODUCT_CLM600			0x3601
 #define YUGA_PRODUCT_CLM610			0x3602
 #define YUGA_PRODUCT_CLM500			0x3603
 #define YUGA_PRODUCT_CLM510			0x3604
 #define YUGA_PRODUCT_CLM800			0x3605
 #define YUGA_PRODUCT_CLM900			0x3606
 #define YUGA_PRODUCT_CLU718			0x3607
 #define YUGA_PRODUCT_CLU716			0x3608
 #define YUGA_PRODUCT_CLU728			0x3609
 #define YUGA_PRODUCT_CLU726			0x360A
 #define YUGA_PRODUCT_CLU518			0x360B
 #define YUGA_PRODUCT_CLU516			0x360C
 #define YUGA_PRODUCT_CLU528			0x360D
 #define YUGA_PRODUCT_CLU526			0x360F
 /* Viettel products */
 #define VIETTEL_VENDOR_ID			0x2262
 #define VIETTEL_PRODUCT_VT1000			0x0002
 /* ZD Incorporated */
 #define ZD_VENDOR_ID				0x0685
 #define ZD_PRODUCT_7000				0x7000
 /* LG products */
 #define LG_VENDOR_ID				0x1004
 #define LG_PRODUCT_L02C				0x618f
 /* MediaTek products */
 #define MEDIATEK_VENDOR_ID			0x0e8d
 #define MEDIATEK_PRODUCT_DC_1COM		0x00a0
 #define MEDIATEK_PRODUCT_DC_4COM		0x00a5
 #define MEDIATEK_PRODUCT_DC_4COM2		0x00a7
 #define MEDIATEK_PRODUCT_DC_5COM		0x00a4
 #define MEDIATEK_PRODUCT_7208_1COM		0x7101
 #define MEDIATEK_PRODUCT_7208_2COM		0x7102
 #define MEDIATEK_PRODUCT_7103_2COM		0x7103
 #define MEDIATEK_PRODUCT_7106_2COM		0x7106
 #define MEDIATEK_PRODUCT_FP_1COM		0x0003
 #define MEDIATEK_PRODUCT_FP_2COM		0x0023
 #define MEDIATEK_PRODUCT_FPDC_1COM		0x0043
 #define MEDIATEK_PRODUCT_FPDC_2COM		0x0033
 /* Cellient products */
 #define CELLIENT_VENDOR_ID			0x2692
 #define CELLIENT_PRODUCT_MEN200			0x9005
 /* Hyundai Petatel Inc. products */
 #define PETATEL_VENDOR_ID			0x1ff4
 #define PETATEL_PRODUCT_NP10T_600A		0x600a
 #define PETATEL_PRODUCT_NP10T_600E		0x600e
 /* TP-LINK Incorporated products */
 #define TPLINK_VENDOR_ID			0x2357
 #define TPLINK_PRODUCT_MA180			0x0201
 /* Changhong products */
 #define CHANGHONG_VENDOR_ID			0x2077
 #define CHANGHONG_PRODUCT_CH690			0x7001
 /* Inovia */
 #define INOVIA_VENDOR_ID			0x20a6
 #define INOVIA_SEW858				0x1105
 /* some devices interfaces need special handling due to a number of reasons */
 enum option_blacklist_reason {
 		OPTION_BLACKLIST_NONE = 0,
 		OPTION_BLACKLIST_SENDSETUP = 1,
 		OPTION_BLACKLIST_RESERVED_IF = 2
 };
 #define MAX_BL_NUM  8
 struct option_blacklist_info {
 	/* bitfield of interface numbers for OPTION_BLACKLIST_SENDSETUP */
 	const unsigned long sendsetup;
 	/* bitfield of interface numbers for OPTION_BLACKLIST_RESERVED_IF */
 	const unsigned long reserved;
 };
 static const struct option_blacklist_info four_g_w14_blacklist = {
 	.sendsetup = BIT(0) | BIT(1),
 };
 static const struct option_blacklist_info alcatel_x200_blacklist = {
 	.sendsetup = BIT(0) | BIT(1),
 	.reserved = BIT(4),
 };
 static const struct option_blacklist_info zte_0037_blacklist = {
 	.sendsetup = BIT(0) | BIT(1),
 };
 static const struct option_blacklist_info zte_k3765_z_blacklist = {
 	.sendsetup = BIT(0) | BIT(1) | BIT(2),
 	.reserved = BIT(4),
 };
 static const struct option_blacklist_info zte_mc2718_z_blacklist = {
 	.sendsetup = BIT(1) | BIT(2) | BIT(3) | BIT(4),
 };
 static const struct option_blacklist_info huawei_cdc12_blacklist = {
 	.reserved = BIT(1) | BIT(2),
 };
 static const struct option_blacklist_info net_intf0_blacklist = {
 	.reserved = BIT(0),
 };
 static const struct option_blacklist_info net_intf1_blacklist = {
 	.reserved = BIT(1),
 };
 static const struct option_blacklist_info net_intf2_blacklist = {
 	.reserved = BIT(2),
 };
 static const struct option_blacklist_info net_intf3_blacklist = {
 	.reserved = BIT(3),
 };
 static const struct option_blacklist_info net_intf4_blacklist = {
 	.reserved = BIT(4),
 };
 static const struct option_blacklist_info net_intf5_blacklist = {
 	.reserved = BIT(5),
 };
 static const struct option_blacklist_info net_intf6_blacklist = {
 	.reserved = BIT(6),
 };
 static const struct option_blacklist_info zte_mf626_blacklist = {
 	.sendsetup = BIT(0) | BIT(1),
 	.reserved = BIT(4),
 };
 static const struct option_blacklist_info zte_1255_blacklist = {
 	.reserved = BIT(3) | BIT(4),
 };
 static const struct option_blacklist_info telit_le920_blacklist = {
 	.sendsetup = BIT(0),
 	.reserved = BIT(1) | BIT(5),
 };
 static const struct usb_device_id option_ids[] = {
 	{ USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COLT) },
 	{ USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA) },
 	{ USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_LIGHT) },
 	{ USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_QUAD) },
 	{ USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_QUAD_LIGHT) },
 	{ USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_NDIS) },
 	{ USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_NDIS_LIGHT) },
 	{ USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_NDIS_QUAD) },
 	{ USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_NDIS_QUAD_LIGHT) },
 	{ USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA) },
 	{ USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA_BUS) },
 	{ USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_VIPER) },
 	{ USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_VIPER_BUS) },
 	{ USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_GT_MAX_READY) },
 	{ USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUJI_MODEM_LIGHT) },
 	{ USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUJI_MODEM_GT) },
 	{ USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUJI_MODEM_EX) },
 	{ USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_KOI_MODEM) },
 	{ USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_SCORPION_MODEM) },
 	{ USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_MODEM) },
 	{ USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_MODEM_LITE) },
 	{ USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_MODEM_GT) },
 	{ USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_MODEM_EX) },
 	{ USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_KOI_MODEM) },
 	{ USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_GTM380_MODEM) },
 	{ USB_DEVICE(QUANTA_VENDOR_ID, QUANTA_PRODUCT_Q101) },
 	{ USB_DEVICE(QUANTA_VENDOR_ID, QUANTA_PRODUCT_Q111) },
 	{ USB_DEVICE(QUANTA_VENDOR_ID, QUANTA_PRODUCT_GLX) },
 	{ USB_DEVICE(QUANTA_VENDOR_ID, QUANTA_PRODUCT_GKE) },
 	{ USB_DEVICE(QUANTA_VENDOR_ID, QUANTA_PRODUCT_GLE) },
 	{ USB_DEVICE(QUANTA_VENDOR_ID, 0xea42),
 		.driver_info = (kernel_ulong_t)&net_intf4_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0x1c05, USB_CLASS_COMM, 0x02, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0x1c1f, USB_CLASS_COMM, 0x02, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0x1c23, USB_CLASS_COMM, 0x02, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E173, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t) &net_intf1_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E173S6, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t) &net_intf1_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1750, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t) &net_intf2_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0x1441, USB_CLASS_COMM, 0x02, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0x1442, USB_CLASS_COMM, 0x02, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K4505, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t) &huawei_cdc12_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K3765, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t) &huawei_cdc12_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0x14ac, 0xff, 0xff, 0xff),	/* Huawei E1820 */
 		.driver_info = (kernel_ulong_t) &net_intf1_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K4605, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t) &huawei_cdc12_blacklist },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0xff, 0xff) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x01) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x02) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x03) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x04) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x05) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x06) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x0A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x0B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x0D) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x0E) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x0F) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x10) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x12) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x13) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x14) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x15) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x17) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x18) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x19) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x1A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x1B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x1C) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x31) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x32) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x33) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x34) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x35) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x36) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x3A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x3B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x3D) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x3E) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x3F) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x48) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x49) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x4A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x4B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x4C) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x61) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x62) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x63) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x64) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x65) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x66) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x6A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x6B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x6D) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x6E) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x6F) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x72) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x73) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x74) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x75) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x78) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x79) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x7A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x7B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x01, 0x7C) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x01) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x02) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x03) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x04) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x05) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x06) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x0A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x0B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x0D) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x0E) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x0F) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x10) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x12) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x13) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x14) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x15) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x17) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x18) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x19) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x1A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x1B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x1C) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x31) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x32) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x33) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x34) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x35) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x36) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x3A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x3B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x3D) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x3E) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x3F) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x48) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x49) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x4A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x4B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x4C) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x61) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x62) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x63) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x64) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x65) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x66) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x6A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x6B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x6D) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x6E) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x6F) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x72) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x73) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x74) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x75) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x78) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x79) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x7A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x7B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x7C) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x01) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x02) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x03) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x04) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x05) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x06) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x0A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x0B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x0D) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x0E) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x0F) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x10) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x12) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x13) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x14) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x15) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x17) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x18) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x19) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x1A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x1B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x1C) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x31) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x32) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x33) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x34) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x35) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x36) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x3A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x3B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x3D) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x3E) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x3F) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x48) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x49) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x4A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x4B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x4C) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x61) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x62) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x63) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x64) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x65) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x66) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x6A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x6B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x6D) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x6E) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x6F) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x72) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x73) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x74) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x75) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x78) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x79) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x7A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x7B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x7C) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x01) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x02) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x03) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x04) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x05) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x06) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x0A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x0B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x0D) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x0E) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x0F) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x10) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x12) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x13) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x14) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x15) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x17) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x18) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x19) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x1A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x1B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x1C) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x31) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x32) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x33) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x34) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x35) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x36) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x3A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x3B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x3D) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x3E) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x3F) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x48) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x49) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x4A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x4B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x4C) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x61) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x62) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x63) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x64) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x65) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x66) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x6A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x6B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x6D) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x6E) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x6F) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x72) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x73) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x74) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x75) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x78) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x79) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x7A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x7B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x7C) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x01) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x02) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x03) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x04) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x05) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x06) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x0A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x0B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x0D) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x0E) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x0F) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x10) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x12) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x13) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x14) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x15) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x17) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x18) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x19) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x1A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x1B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x1C) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x31) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x32) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x33) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x34) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x35) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x36) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x3A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x3B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x3D) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x3E) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x3F) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x48) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x49) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x4A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x4B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x4C) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x61) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x62) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x63) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x64) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x65) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x66) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x6A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x6B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x6D) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x6E) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x6F) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x72) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x73) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x74) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x75) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x78) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x79) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x7A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x7B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x7C) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x01) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x02) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x03) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x04) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x05) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x06) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x0A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x0B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x0D) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x0E) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x0F) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x10) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x12) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x13) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x14) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x15) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x17) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x18) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x19) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x1A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x1B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x1C) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x31) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x32) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x33) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x34) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x35) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x36) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x3A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x3B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x3D) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x3E) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x3F) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x48) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x49) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x4A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x4B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x4C) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x61) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x62) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x63) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x64) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x65) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x66) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x6A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x6B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x6D) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x6E) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x6F) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x72) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x73) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x74) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x75) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x78) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x79) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x7A) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x7B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x7C) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_V640) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_V620) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_V740) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_V720) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_U730) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_U740) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_U870) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_XU870) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_X950D) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_EV620) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_ES720) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_E725) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_ES620) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_EU730) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_EU740) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_EU870D) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_MC950D) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_MC727) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_OVMC760) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_MC780) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_EVDO_FULLSPEED) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_HSPA_FULLSPEED) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_EVDO_EMBEDDED_FULLSPEED) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_HSPA_EMBEDDED_FULLSPEED) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_EVDO_HIGHSPEED) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_HSPA_HIGHSPEED) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_HSPA_HIGHSPEED3) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_HSPA_HIGHSPEED4) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_HSPA_HIGHSPEED5) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_HSPA_HIGHSPEED6) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_HSPA_HIGHSPEED7) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_MC996D) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_MF3470) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_MC547) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_EVDO_EMBEDDED_HIGHSPEED) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_HSPA_EMBEDDED_HIGHSPEED) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_G2) },
 	/* Novatel Ovation MC551 a.k.a. Verizon USB551L */
 	{ USB_DEVICE_AND_INTERFACE_INFO(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_MC551, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_E362, 0xff, 0xff, 0xff) },
+	{ USB_DEVICE_AND_INTERFACE_INFO(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_E371, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE(AMOI_VENDOR_ID, AMOI_PRODUCT_H01) },
 	{ USB_DEVICE(AMOI_VENDOR_ID, AMOI_PRODUCT_H01A) },
 	{ USB_DEVICE(AMOI_VENDOR_ID, AMOI_PRODUCT_H02) },
 	{ USB_DEVICE(AMOI_VENDOR_ID, AMOI_PRODUCT_SKYPEPHONE_S2) },
 	{ USB_DEVICE(DELL_VENDOR_ID, DELL_PRODUCT_5700_MINICARD) },		/* Dell Wireless 5700 Mobile Broadband CDMA/EVDO Mini-Card == Novatel Expedite EV620 CDMA/EV-DO */
 	{ USB_DEVICE(DELL_VENDOR_ID, DELL_PRODUCT_5500_MINICARD) },		/* Dell Wireless 5500 Mobile Broadband HSDPA Mini-Card == Novatel Expedite EU740 HSDPA/3G */
 	{ USB_DEVICE(DELL_VENDOR_ID, DELL_PRODUCT_5505_MINICARD) },		/* Dell Wireless 5505 Mobile Broadband HSDPA Mini-Card == Novatel Expedite EU740 HSDPA/3G */
 	{ USB_DEVICE(DELL_VENDOR_ID, DELL_PRODUCT_5700_EXPRESSCARD) },		/* Dell Wireless 5700 Mobile Broadband CDMA/EVDO ExpressCard == Novatel Merlin XV620 CDMA/EV-DO */
 	{ USB_DEVICE(DELL_VENDOR_ID, DELL_PRODUCT_5510_EXPRESSCARD) },		/* Dell Wireless 5510 Mobile Broadband HSDPA ExpressCard == Novatel Merlin XU870 HSDPA/3G */
 	{ USB_DEVICE(DELL_VENDOR_ID, DELL_PRODUCT_5700_MINICARD_SPRINT) },	/* Dell Wireless 5700 Mobile Broadband CDMA/EVDO Mini-Card == Novatel Expedite E720 CDMA/EV-DO */
 	{ USB_DEVICE(DELL_VENDOR_ID, DELL_PRODUCT_5700_MINICARD_TELUS) },	/* Dell Wireless 5700 Mobile Broadband CDMA/EVDO Mini-Card == Novatel Expedite ET620 CDMA/EV-DO */
 	{ USB_DEVICE(DELL_VENDOR_ID, DELL_PRODUCT_5720_MINICARD_VZW) }, 	/* Dell Wireless 5720 == Novatel EV620 CDMA/EV-DO */
 	{ USB_DEVICE(DELL_VENDOR_ID, DELL_PRODUCT_5720_MINICARD_SPRINT) }, 	/* Dell Wireless 5720 == Novatel EV620 CDMA/EV-DO */
 	{ USB_DEVICE(DELL_VENDOR_ID, DELL_PRODUCT_5720_MINICARD_TELUS) }, 	/* Dell Wireless 5720 == Novatel EV620 CDMA/EV-DO */
 	{ USB_DEVICE(DELL_VENDOR_ID, DELL_PRODUCT_5520_MINICARD_CINGULAR) },	/* Dell Wireless HSDPA 5520 == Novatel Expedite EU860D */
 	{ USB_DEVICE(DELL_VENDOR_ID, DELL_PRODUCT_5520_MINICARD_GENERIC_L) },	/* Dell Wireless HSDPA 5520 */
 	{ USB_DEVICE(DELL_VENDOR_ID, DELL_PRODUCT_5520_MINICARD_GENERIC_I) },	/* Dell Wireless 5520 Voda I Mobile Broadband (3G HSDPA) Minicard */
 	{ USB_DEVICE(DELL_VENDOR_ID, DELL_PRODUCT_5730_MINICARD_SPRINT) },	/* Dell Wireless 5730 Mobile Broadband EVDO/HSPA Mini-Card */
 	{ USB_DEVICE(DELL_VENDOR_ID, DELL_PRODUCT_5730_MINICARD_TELUS) },	/* Dell Wireless 5730 Mobile Broadband EVDO/HSPA Mini-Card */
 	{ USB_DEVICE(DELL_VENDOR_ID, DELL_PRODUCT_5730_MINICARD_VZW) }, 	/* Dell Wireless 5730 Mobile Broadband EVDO/HSPA Mini-Card */
 	{ USB_DEVICE_AND_INTERFACE_INFO(DELL_VENDOR_ID, DELL_PRODUCT_5800_MINICARD_VZW, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(DELL_VENDOR_ID, DELL_PRODUCT_5800_V2_MINICARD_VZW, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(DELL_VENDOR_ID, DELL_PRODUCT_5804_MINICARD_ATT, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ADU_E100A) },	/* ADU-E100, ADU-310 */
 	{ USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ADU_500A) },
 	{ USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ADU_620UW) },
 	{ USB_DEVICE(AXESSTEL_VENDOR_ID, AXESSTEL_PRODUCT_MV110H) },
 	{ USB_DEVICE(YISO_VENDOR_ID, YISO_PRODUCT_U893) },
 	{ USB_DEVICE_INTERFACE_CLASS(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_C100_1, 0xff) },
 	{ USB_DEVICE_INTERFACE_CLASS(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_C100_2, 0xff) },
 	{ USB_DEVICE_INTERFACE_CLASS(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_1004, 0xff) },
 	{ USB_DEVICE_INTERFACE_CLASS(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_1005, 0xff) },
 	{ USB_DEVICE_INTERFACE_CLASS(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_1006, 0xff) },
 	{ USB_DEVICE_INTERFACE_CLASS(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_1007, 0xff) },
 	{ USB_DEVICE_INTERFACE_CLASS(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_1008, 0xff) },
 	{ USB_DEVICE_INTERFACE_CLASS(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_1009, 0xff) },
 	{ USB_DEVICE_INTERFACE_CLASS(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_100A, 0xff) },
 	{ USB_DEVICE_INTERFACE_CLASS(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_100B, 0xff) },
 	{ USB_DEVICE_INTERFACE_CLASS(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_100C, 0xff) },
 	{ USB_DEVICE_INTERFACE_CLASS(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_100D, 0xff) },
 	{ USB_DEVICE_INTERFACE_CLASS(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_100E, 0xff) },
 	{ USB_DEVICE_INTERFACE_CLASS(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_100F, 0xff) },
 	{ USB_DEVICE_INTERFACE_CLASS(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_1010, 0xff) },
 	{ USB_DEVICE_INTERFACE_CLASS(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_1011, 0xff) },
 	{ USB_DEVICE_INTERFACE_CLASS(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_1012, 0xff) },
 	{ USB_DEVICE(KYOCERA_VENDOR_ID, KYOCERA_PRODUCT_KPC650) },
 	{ USB_DEVICE(KYOCERA_VENDOR_ID, KYOCERA_PRODUCT_KPC680) },
 	{ USB_DEVICE(QUALCOMM_VENDOR_ID, 0x6613)}, /* Onda H600/ZTE MF330 */
 	{ USB_DEVICE(QUALCOMM_VENDOR_ID, 0x0023)}, /* ONYX 3G device */
 	{ USB_DEVICE(QUALCOMM_VENDOR_ID, 0x9000)}, /* SIMCom SIM5218 */
 	{ USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_6001) },
 	{ USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_CMU_300) },
 	{ USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_6003),
 	  .driver_info = (kernel_ulong_t)&net_intf0_blacklist },
 	{ USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_6004) },
 	{ USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_6005) },
 	{ USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_CGU_628A) },
 	{ USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_CHE_628S),
 	  .driver_info = (kernel_ulong_t)&net_intf0_blacklist },
 	{ USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_CMU_301),
 	  .driver_info = (kernel_ulong_t)&net_intf0_blacklist },
 	{ USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_CHU_628),
 	  .driver_info = (kernel_ulong_t)&net_intf0_blacklist },
 	{ USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_CHU_628S) },
 	{ USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_CDU_680) },
 	{ USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_CDU_685A) },
 	{ USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_CHU_720S),
 	  .driver_info = (kernel_ulong_t)&net_intf0_blacklist },
 	{ USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_7002),
 	  .driver_info = (kernel_ulong_t)&net_intf0_blacklist },
 	{ USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_CHU_629K),
 	  .driver_info = (kernel_ulong_t)&net_intf4_blacklist },
 	{ USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_7004),
 	  .driver_info = (kernel_ulong_t)&net_intf3_blacklist },
 	{ USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_7005) },
 	{ USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_CGU_629),
 	  .driver_info = (kernel_ulong_t)&net_intf5_blacklist },
 	{ USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_CHU_629S),
 	  .driver_info = (kernel_ulong_t)&net_intf4_blacklist },
 	{ USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_CHU_720I),
 	  .driver_info = (kernel_ulong_t)&net_intf0_blacklist },
 	{ USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_7212),
 	  .driver_info = (kernel_ulong_t)&net_intf0_blacklist },
 	{ USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_7213),
 	  .driver_info = (kernel_ulong_t)&net_intf0_blacklist },
 	{ USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_7251),
 	  .driver_info = (kernel_ulong_t)&net_intf1_blacklist },
 	{ USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_7252),
 	  .driver_info = (kernel_ulong_t)&net_intf1_blacklist },
 	{ USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_7253),
 	  .driver_info = (kernel_ulong_t)&net_intf1_blacklist },
 	{ USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_UC864E) },
 	{ USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_UC864G) },
 	{ USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_CC864_DUAL) },
 	{ USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_CC864_SINGLE) },
 	{ USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_DE910_DUAL) },
 	{ USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_UE910_V2) },
 	{ USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_LE920),
 		.driver_info = (kernel_ulong_t)&telit_le920_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_MF622, 0xff, 0xff, 0xff) }, /* ZTE WCDMA products */
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0002, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t)&net_intf1_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0003, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0004, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0005, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0006, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0008, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0009, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x000a, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x000b, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x000c, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x000d, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x000e, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x000f, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0010, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0011, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0012, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t)&net_intf1_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0013, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_MF628, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0016, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0017, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t)&net_intf3_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0018, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0019, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t)&net_intf3_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0020, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0021, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t)&net_intf4_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0022, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0023, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0024, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0025, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t)&net_intf1_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0028, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0029, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0030, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_MF626, 0xff,
 	  0xff, 0xff), .driver_info = (kernel_ulong_t)&zte_mf626_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0032, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0033, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0034, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0037, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t)&zte_0037_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0038, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0039, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0040, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0042, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t)&net_intf4_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0043, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0044, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0048, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0049, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t)&net_intf5_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0050, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0051, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0052, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t)&net_intf4_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0054, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0055, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t)&net_intf1_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0056, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0057, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0058, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t)&net_intf4_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0061, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0062, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0063, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t)&net_intf4_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0064, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0065, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0066, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0067, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0069, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0076, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0077, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0078, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0079, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0082, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0083, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0086, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0087, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0088, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0089, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0090, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0091, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0092, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0093, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0094, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0095, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0096, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0097, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0104, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t)&net_intf4_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0105, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0106, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0108, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0113, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t)&net_intf5_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0117, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0118, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t)&net_intf5_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0121, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t)&net_intf5_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0122, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0123, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t)&net_intf4_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0124, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t)&net_intf5_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0125, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t)&net_intf6_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0126, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t)&net_intf5_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0128, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0135, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0136, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0137, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0139, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0142, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0143, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0144, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0145, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0148, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0151, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0153, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0155, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0156, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0157, 0xff, 0xff, 0xff),
 	  .driver_info = (kernel_ulong_t)&net_intf5_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0158, 0xff, 0xff, 0xff),
 	  .driver_info = (kernel_ulong_t)&net_intf3_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0159, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0161, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0162, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0164, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0165, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0167, 0xff, 0xff, 0xff),
 	  .driver_info = (kernel_ulong_t)&net_intf4_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0189, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0191, 0xff, 0xff, 0xff), /* ZTE EuFi890 */
 	  .driver_info = (kernel_ulong_t)&net_intf4_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0196, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0197, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0199, 0xff, 0xff, 0xff), /* ZTE MF820S */
 	  .driver_info = (kernel_ulong_t)&net_intf1_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0200, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0201, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0254, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0257, 0xff, 0xff, 0xff), /* ZTE MF821 */
 	  .driver_info = (kernel_ulong_t)&net_intf3_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0265, 0xff, 0xff, 0xff), /* ONDA MT8205 */
 	  .driver_info = (kernel_ulong_t)&net_intf4_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0284, 0xff, 0xff, 0xff), /* ZTE MF880 */
 	  .driver_info = (kernel_ulong_t)&net_intf4_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0317, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0326, 0xff, 0xff, 0xff),
 	  .driver_info = (kernel_ulong_t)&net_intf4_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0330, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0395, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0412, 0xff, 0xff, 0xff), /* Telewell TW-LTE 4G */
 	  .driver_info = (kernel_ulong_t)&net_intf4_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0414, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0417, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1008, 0xff, 0xff, 0xff),
 	  .driver_info = (kernel_ulong_t)&net_intf4_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1010, 0xff, 0xff, 0xff),
 	  .driver_info = (kernel_ulong_t)&net_intf4_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1012, 0xff, 0xff, 0xff),
 	  .driver_info = (kernel_ulong_t)&net_intf4_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1018, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1021, 0xff, 0xff, 0xff),
 	  .driver_info = (kernel_ulong_t)&net_intf2_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1057, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1058, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1059, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1060, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1061, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1062, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1063, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1064, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1065, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1066, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1067, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1068, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1069, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1070, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1071, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1072, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1073, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1074, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1075, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1076, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1077, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1078, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1079, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1080, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1081, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1082, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1083, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1084, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1085, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1086, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1087, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1088, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1089, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1090, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1091, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1092, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1093, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1094, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1095, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1096, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1097, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1098, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1099, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1100, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1101, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1102, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1103, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1104, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1105, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1106, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1107, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1108, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1109, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1110, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1111, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1112, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1113, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1114, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1115, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1116, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1117, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1118, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1119, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1120, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1121, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1122, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1123, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1124, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1125, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1126, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1127, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1128, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1129, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1130, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1131, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1132, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1133, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1134, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1135, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1136, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1137, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1138, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1139, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1140, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1141, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1142, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1143, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1144, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1145, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1146, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1147, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1148, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1149, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1150, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1151, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1152, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1153, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1154, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1155, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1156, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1157, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1158, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1159, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1160, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1161, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1162, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1163, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1164, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1165, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1166, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1167, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1168, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1169, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1170, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1244, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1245, 0xff, 0xff, 0xff),
 	  .driver_info = (kernel_ulong_t)&net_intf4_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1246, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1247, 0xff, 0xff, 0xff),
 	  .driver_info = (kernel_ulong_t)&net_intf4_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1248, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1249, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1250, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1251, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1252, 0xff, 0xff, 0xff),
 	  .driver_info = (kernel_ulong_t)&net_intf4_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1253, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1254, 0xff, 0xff, 0xff),
 	  .driver_info = (kernel_ulong_t)&net_intf4_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1255, 0xff, 0xff, 0xff),
 	  .driver_info = (kernel_ulong_t)&zte_1255_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1256, 0xff, 0xff, 0xff),
 	  .driver_info = (kernel_ulong_t)&net_intf4_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1257, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1258, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1259, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1260, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1261, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1262, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1263, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1264, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1265, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1266, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1267, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1268, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1269, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1270, 0xff, 0xff, 0xff),
 	  .driver_info = (kernel_ulong_t)&net_intf5_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1271, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1272, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1273, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1274, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1275, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1276, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1277, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1278, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1279, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1280, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1281, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1282, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1283, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1284, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1285, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1286, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1287, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1288, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1289, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1290, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1291, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1292, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1293, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1294, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1295, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1296, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1297, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1298, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1299, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1300, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1301, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1302, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1303, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1333, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1401, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t)&net_intf2_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1402, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t)&net_intf2_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1424, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t)&net_intf2_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1425, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t)&net_intf2_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1426, 0xff, 0xff, 0xff),  /* ZTE MF91 */
 		.driver_info = (kernel_ulong_t)&net_intf2_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1533, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1534, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1535, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1545, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1546, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1547, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1565, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1566, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1567, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1589, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1590, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1591, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1592, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1594, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1596, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1598, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1600, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x2002, 0xff,
 	  0xff, 0xff), .driver_info = (kernel_ulong_t)&zte_k3765_z_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x2003, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0014, 0xff, 0xff, 0xff) }, /* ZTE CDMA products */
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0027, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0059, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0060, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0070, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0073, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0094, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0130, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t)&net_intf1_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0133, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t)&net_intf3_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0141, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t)&net_intf5_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0147, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0152, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0168, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t)&net_intf4_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0170, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0176, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t)&net_intf3_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0178, 0xff, 0xff, 0xff),
 		.driver_info = (kernel_ulong_t)&net_intf3_blacklist },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffe9, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff8b, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff8c, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff8d, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff8e, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff8f, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff90, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff91, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff92, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff93, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff94, 0xff, 0xff, 0xff) },
 	/* NOTE: most ZTE CDMA devices should be driven by zte_ev, not option */
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_MC2718, 0xff, 0xff, 0xff),
 	 .driver_info = (kernel_ulong_t)&zte_mc2718_z_blacklist },
 	{ USB_VENDOR_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff, 0x02, 0x01) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff, 0x02, 0x05) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff, 0x86, 0x10) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_AC2726, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_H10) },
 	{ USB_DEVICE(DLINK_VENDOR_ID, DLINK_PRODUCT_DWM_652) },
 	{ USB_DEVICE(ALINK_VENDOR_ID, DLINK_PRODUCT_DWM_652_U5) }, /* Yes, ALINK_VENDOR_ID */
 	{ USB_DEVICE(ALINK_VENDOR_ID, DLINK_PRODUCT_DWM_652_U5A) },
 	{ USB_DEVICE(QISDA_VENDOR_ID, QISDA_PRODUCT_H21_4512) },
 	{ USB_DEVICE(QISDA_VENDOR_ID, QISDA_PRODUCT_H21_4523) },
 	{ USB_DEVICE(QISDA_VENDOR_ID, QISDA_PRODUCT_H20_4515) },
 	{ USB_DEVICE(QISDA_VENDOR_ID, QISDA_PRODUCT_H20_4518) },
 	{ USB_DEVICE(QISDA_VENDOR_ID, QISDA_PRODUCT_H20_4519) },
 	{ USB_DEVICE(TOSHIBA_VENDOR_ID, TOSHIBA_PRODUCT_G450) },
 	{ USB_DEVICE(TOSHIBA_VENDOR_ID, TOSHIBA_PRODUCT_HSDPA_MINICARD ) }, /* Toshiba 3G HSDPA == Novatel Expedite EU870D MiniCard */
 	{ USB_DEVICE(ALINK_VENDOR_ID, 0x9000) },
 	{ USB_DEVICE(ALINK_VENDOR_ID, ALINK_PRODUCT_PH300) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ALINK_VENDOR_ID, ALINK_PRODUCT_3GU, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_X060S_X200),
 	  .driver_info = (kernel_ulong_t)&alcatel_x200_blacklist
 	},
 	{ USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_X220_X500D),
 	  .driver_info = (kernel_ulong_t)&net_intf6_blacklist },
 	{ USB_DEVICE(ALCATEL_VENDOR_ID, 0x0052),
 	  .driver_info = (kernel_ulong_t)&net_intf6_blacklist },
 	{ USB_DEVICE(ALCATEL_VENDOR_ID, 0x00b6),
 	  .driver_info = (kernel_ulong_t)&net_intf3_blacklist },
 	{ USB_DEVICE(ALCATEL_VENDOR_ID, 0x00b7),
 	  .driver_info = (kernel_ulong_t)&net_intf5_blacklist },
 	{ USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_L100V),
 	  .driver_info = (kernel_ulong_t)&net_intf4_blacklist },
 	{ USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_L800MA),
 	  .driver_info = (kernel_ulong_t)&net_intf2_blacklist },
 	{ USB_DEVICE(AIRPLUS_VENDOR_ID, AIRPLUS_PRODUCT_MCD650) },
 	{ USB_DEVICE(TLAYTECH_VENDOR_ID, TLAYTECH_PRODUCT_TEU800) },
 	{ USB_DEVICE(LONGCHEER_VENDOR_ID, FOUR_G_SYSTEMS_PRODUCT_W14),
   	  .driver_info = (kernel_ulong_t)&four_g_w14_blacklist
   	},
 	{ USB_DEVICE(LONGCHEER_VENDOR_ID, ZOOM_PRODUCT_4597) },
 	{ USB_DEVICE(LONGCHEER_VENDOR_ID, IBALL_3_5G_CONNECT) },
 	{ USB_DEVICE(HAIER_VENDOR_ID, HAIER_PRODUCT_CE100) },
 	/* Pirelli  */
 	{ USB_DEVICE_INTERFACE_CLASS(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_C100_1, 0xff) },
 	{ USB_DEVICE_INTERFACE_CLASS(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_C100_2, 0xff) },
 	{ USB_DEVICE_INTERFACE_CLASS(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_1004, 0xff) },
 	{ USB_DEVICE_INTERFACE_CLASS(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_1005, 0xff) },
 	{ USB_DEVICE_INTERFACE_CLASS(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_1006, 0xff) },
 	{ USB_DEVICE_INTERFACE_CLASS(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_1007, 0xff) },
 	{ USB_DEVICE_INTERFACE_CLASS(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_1008, 0xff) },
 	{ USB_DEVICE_INTERFACE_CLASS(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_1009, 0xff) },
 	{ USB_DEVICE_INTERFACE_CLASS(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_100A, 0xff) },
 	{ USB_DEVICE_INTERFACE_CLASS(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_100B, 0xff) },
 	{ USB_DEVICE_INTERFACE_CLASS(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_100C, 0xff) },
 	{ USB_DEVICE_INTERFACE_CLASS(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_100D, 0xff) },
 	{ USB_DEVICE_INTERFACE_CLASS(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_100E, 0xff) },
 	{ USB_DEVICE_INTERFACE_CLASS(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_100F, 0xff) },
 	{ USB_DEVICE_INTERFACE_CLASS(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_1011, 0xff) },
 	{ USB_DEVICE_INTERFACE_CLASS(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_1012, 0xff) },
 	/* Cinterion */
 	{ USB_DEVICE(CINTERION_VENDOR_ID, CINTERION_PRODUCT_EU3_E) },
 	{ USB_DEVICE(CINTERION_VENDOR_ID, CINTERION_PRODUCT_EU3_P) },
 	{ USB_DEVICE(CINTERION_VENDOR_ID, CINTERION_PRODUCT_PH8),
 		.driver_info = (kernel_ulong_t)&net_intf4_blacklist },
 	{ USB_DEVICE(CINTERION_VENDOR_ID, CINTERION_PRODUCT_AHXX) },
 	{ USB_DEVICE(CINTERION_VENDOR_ID, CINTERION_PRODUCT_PLXX),
 		.driver_info = (kernel_ulong_t)&net_intf4_blacklist },
 	{ USB_DEVICE(CINTERION_VENDOR_ID, CINTERION_PRODUCT_HC28_MDM) },
 	{ USB_DEVICE(CINTERION_VENDOR_ID, CINTERION_PRODUCT_HC28_MDMNET) },
 	{ USB_DEVICE(SIEMENS_VENDOR_ID, CINTERION_PRODUCT_HC25_MDM) },
 	{ USB_DEVICE(SIEMENS_VENDOR_ID, CINTERION_PRODUCT_HC25_MDMNET) },
 	{ USB_DEVICE(SIEMENS_VENDOR_ID, CINTERION_PRODUCT_HC28_MDM) }, /* HC28 enumerates with Siemens or Cinterion VID depending on FW revision */
 	{ USB_DEVICE(SIEMENS_VENDOR_ID, CINTERION_PRODUCT_HC28_MDMNET) },
 	{ USB_DEVICE(OLIVETTI_VENDOR_ID, OLIVETTI_PRODUCT_OLICARD100) },
 	{ USB_DEVICE(OLIVETTI_VENDOR_ID, OLIVETTI_PRODUCT_OLICARD145) },
 	{ USB_DEVICE(OLIVETTI_VENDOR_ID, OLIVETTI_PRODUCT_OLICARD200),
 		.driver_info = (kernel_ulong_t)&net_intf6_blacklist
 	},
 	{ USB_DEVICE(OLIVETTI_VENDOR_ID, OLIVETTI_PRODUCT_OLICARD500),
 		.driver_info = (kernel_ulong_t)&net_intf4_blacklist
 	},
 	{ USB_DEVICE(CELOT_VENDOR_ID, CELOT_PRODUCT_CT680M) }, /* CT-650 CDMA 450 1xEVDO modem */
 	{ USB_DEVICE_AND_INTERFACE_INFO(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_GT_B3730, USB_CLASS_CDC_DATA, 0x00, 0x00) }, /* Samsung GT-B3730 LTE USB modem.*/
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEM600) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEM610) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEM500) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEM510) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEM800) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEM900) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEU818) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEU816) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEU828) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEU826) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEU518) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEU516) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEU528) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEU526) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWM600) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWM610) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWM500) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWM510) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWM800) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWM900) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWU718) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWU716) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWU728) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWU726) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWU518) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWU516) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWU528) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWU526) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLM600) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLM610) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLM500) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLM510) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLM800) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLM900) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLU718) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLU716) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLU728) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLU726) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLU518) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLU516) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLU528) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLU526) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEU881) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEU882) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWU581) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWU582) },
 	{ USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWU583) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(VIETTEL_VENDOR_ID, VIETTEL_PRODUCT_VT1000, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZD_VENDOR_ID, ZD_PRODUCT_7000, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE(LG_VENDOR_ID, LG_PRODUCT_L02C) }, /* docomo L-02C modem */
 	{ USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, 0x00a1, 0xff, 0x00, 0x00) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, 0x00a1, 0xff, 0x02, 0x01) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, 0x00a2, 0xff, 0x00, 0x00) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, 0x00a2, 0xff, 0x02, 0x01) },        /* MediaTek MT6276M modem & app port */
 	{ USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_DC_1COM, 0x0a, 0x00, 0x00) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_DC_5COM, 0xff, 0x02, 0x01) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_DC_5COM, 0xff, 0x00, 0x00) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_DC_4COM, 0xff, 0x02, 0x01) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_DC_4COM, 0xff, 0x00, 0x00) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_7208_1COM, 0x02, 0x00, 0x00) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_7208_2COM, 0x02, 0x02, 0x01) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_FP_1COM, 0x0a, 0x00, 0x00) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_FP_2COM, 0x0a, 0x00, 0x00) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_FPDC_1COM, 0x0a, 0x00, 0x00) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_FPDC_2COM, 0x0a, 0x00, 0x00) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_7103_2COM, 0xff, 0x00, 0x00) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_7106_2COM, 0x02, 0x02, 0x01) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_DC_4COM2, 0xff, 0x02, 0x01) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_DC_4COM2, 0xff, 0x00, 0x00) },
 	{ USB_DEVICE(CELLIENT_VENDOR_ID, CELLIENT_PRODUCT_MEN200) },
 	{ USB_DEVICE(PETATEL_VENDOR_ID, PETATEL_PRODUCT_NP10T_600A) },
 	{ USB_DEVICE(PETATEL_VENDOR_ID, PETATEL_PRODUCT_NP10T_600E) },
 	{ USB_DEVICE(TPLINK_VENDOR_ID, TPLINK_PRODUCT_MA180),
 	  .driver_info = (kernel_ulong_t)&net_intf4_blacklist },
 	{ USB_DEVICE(TPLINK_VENDOR_ID, 0x9000),					/* TP-Link MA260 */
 	  .driver_info = (kernel_ulong_t)&net_intf4_blacklist },
 	{ USB_DEVICE(CHANGHONG_VENDOR_ID, CHANGHONG_PRODUCT_CH690) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(0x2001, 0x7d01, 0xff, 0x02, 0x01) },	/* D-Link DWM-156 (variant) */
 	{ USB_DEVICE_AND_INTERFACE_INFO(0x2001, 0x7d01, 0xff, 0x00, 0x00) },	/* D-Link DWM-156 (variant) */
 	{ USB_DEVICE_AND_INTERFACE_INFO(0x2001, 0x7d02, 0xff, 0x02, 0x01) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(0x2001, 0x7d02, 0xff, 0x00, 0x00) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(0x2001, 0x7d03, 0xff, 0x02, 0x01) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(0x2001, 0x7d03, 0xff, 0x00, 0x00) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(0x07d1, 0x3e01, 0xff, 0xff, 0xff) }, /* D-Link DWM-152/C1 */
 	{ USB_DEVICE_AND_INTERFACE_INFO(0x07d1, 0x3e02, 0xff, 0xff, 0xff) }, /* D-Link DWM-156/C1 */
 	{ USB_DEVICE(INOVIA_VENDOR_ID, INOVIA_SEW858) },
 	{ } /* Terminating entry */
 };
 MODULE_DEVICE_TABLE(usb, option_ids);
 /* The card has three separate interfaces, which the serial driver
  * recognizes separately, thus num_port=1.
  */
 static struct usb_serial_driver option_1port_device = {
 	.driver = {
 		.owner =	THIS_MODULE,
 		.name =		"option1",
 	},
 	.description       = "GSM modem (1-port)",
 	.id_table          = option_ids,
 	.num_ports         = 1,
 	.probe             = option_probe,
 	.open              = usb_wwan_open,
 	.close             = usb_wwan_close,
 	.dtr_rts	   = usb_wwan_dtr_rts,
 	.write             = usb_wwan_write,
 	.write_room        = usb_wwan_write_room,
 	.chars_in_buffer   = usb_wwan_chars_in_buffer,
 	.set_termios       = usb_wwan_set_termios,
 	.tiocmget          = usb_wwan_tiocmget,
 	.tiocmset          = usb_wwan_tiocmset,
 	.ioctl             = usb_wwan_ioctl,
 	.attach            = option_attach,
 	.release           = option_release,
 	.port_probe        = usb_wwan_port_probe,
 	.port_remove	   = usb_wwan_port_remove,
 	.read_int_callback = option_instat_callback,
 #ifdef CONFIG_PM
 	.suspend           = usb_wwan_suspend,
 	.resume            = usb_wwan_resume,
 #endif
 };
 static struct usb_serial_driver * const serial_drivers[] = {
 	&option_1port_device, NULL
 };
 struct option_private {
 	u8 bInterfaceNumber;
 };
 module_usb_serial_driver(serial_drivers, option_ids);
 static bool is_blacklisted(const u8 ifnum, enum option_blacklist_reason reason,
 			   const struct option_blacklist_info *blacklist)
 {
 	unsigned long num;
 	const unsigned long *intf_list;
 	if (blacklist) {
 		if (reason == OPTION_BLACKLIST_SENDSETUP)
 			intf_list = &blacklist->sendsetup;
 		else if (reason == OPTION_BLACKLIST_RESERVED_IF)
 			intf_list = &blacklist->reserved;
 		else {
 			BUG_ON(reason);
 			return false;
 		}
 		for_each_set_bit(num, intf_list, MAX_BL_NUM + 1) {
 			if (num == ifnum)
 				return true;
 		}
 	}
 	return false;
 }
 static int option_probe(struct usb_serial *serial,
 			const struct usb_device_id *id)
 {
 	struct usb_interface_descriptor *iface_desc =
 				&serial->interface->cur_altsetting->desc;
 	struct usb_device_descriptor *dev_desc = &serial->dev->descriptor;
 	/* Never bind to the CD-Rom emulation interface	*/
 	if (iface_desc->bInterfaceClass == 0x08)
 		return -ENODEV;
 	/*
 	 * Don't bind reserved interfaces (like network ones) which often have
 	 * the same class/subclass/protocol as the serial interfaces.  Look at
 	 * the Windows driver .INF files for reserved interface numbers.
 	 */
 	if (is_blacklisted(
 		iface_desc->bInterfaceNumber,
 		OPTION_BLACKLIST_RESERVED_IF,
 		(const struct option_blacklist_info *) id->driver_info))
 		return -ENODEV;
 	/*
 	 * Don't bind network interface on Samsung GT-B3730, it is handled by
 	 * a separate module.
 	 */
 	if (dev_desc->idVendor == cpu_to_le16(SAMSUNG_VENDOR_ID) &&
 	    dev_desc->idProduct == cpu_to_le16(SAMSUNG_PRODUCT_GT_B3730) &&
 	    iface_desc->bInterfaceClass != USB_CLASS_CDC_DATA)
 		return -ENODEV;
 	/* Store device id so we can use it during attach. */
 	usb_set_serial_data(serial, (void *)id);
 	return 0;
 }
 static int option_attach(struct usb_serial *serial)
 {
 	struct usb_interface_descriptor *iface_desc;
 	const struct usb_device_id *id;
 	struct usb_wwan_intf_private *data;
 	struct option_private *priv;
 	data = kzalloc(sizeof(struct usb_wwan_intf_private), GFP_KERNEL);
 	if (!data)
 		return -ENOMEM;
 	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
 	if (!priv) {
 		kfree(data);
 		return -ENOMEM;
 	}
 	/* Retrieve device id stored at probe. */
 	id = usb_get_serial_data(serial);
 	iface_desc = &serial->interface->cur_altsetting->desc;
 	priv->bInterfaceNumber = iface_desc->bInterfaceNumber;
 	data->private = priv;
 	if (!is_blacklisted(iface_desc->bInterfaceNumber,
 			OPTION_BLACKLIST_SENDSETUP,
 			(struct option_blacklist_info *)id->driver_info)) {
 		data->send_setup = option_send_setup;
 	}
 	spin_lock_init(&data->susp_lock);
 	usb_set_serial_data(serial, data);
 	return 0;
 }
 static void option_release(struct usb_serial *serial)
 {
 	struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial);
 	struct option_private *priv = intfdata->private;
 	kfree(priv);
 	kfree(intfdata);
 }
 static void option_instat_callback(struct urb *urb)
 {
 	int err;
 	int status = urb->status;
 	struct usb_serial_port *port = urb->context;
 	struct device *dev = &port->dev;
 	struct usb_wwan_port_private *portdata =
 					usb_get_serial_port_data(port);
 	dev_dbg(dev, "%s: urb %p port %p has data %p\n", __func__, urb, port, portdata);
 	if (status == 0) {
 		struct usb_ctrlrequest *req_pkt =
 				(struct usb_ctrlrequest *)urb->transfer_buffer;
 		if (!req_pkt) {
 			dev_dbg(dev, "%s: NULL req_pkt\n", __func__);
 			return;
 		}
 		if ((req_pkt->bRequestType == 0xA1) &&
 				(req_pkt->bRequest == 0x20)) {
 			int old_dcd_state;
 			unsigned char signals = *((unsigned char *)
 					urb->transfer_buffer +
 					sizeof(struct usb_ctrlrequest));
 			dev_dbg(dev, "%s: signal x%x\n", __func__, signals);
 			old_dcd_state = portdata->dcd_state;
 			portdata->cts_state = 1;
 			portdata->dcd_state = ((signals & 0x01) ? 1 : 0);
 			portdata->dsr_state = ((signals & 0x02) ? 1 : 0);
 			portdata->ri_state = ((signals & 0x08) ? 1 : 0);
 			if (old_dcd_state && !portdata->dcd_state)
 				tty_port_tty_hangup(&port->port, true);
 		} else {
 			dev_dbg(dev, "%s: type %x req %x\n", __func__,
 				req_pkt->bRequestType, req_pkt->bRequest);
 		}
 	} else
 		dev_err(dev, "%s: error %d\n", __func__, status);
 	/* Resubmit urb so we continue receiving IRQ data */
 	if (status != -ESHUTDOWN && status != -ENOENT) {
 		err = usb_submit_urb(urb, GFP_ATOMIC);
 		if (err)
 			dev_dbg(dev, "%s: resubmit intr urb failed. (%d)\n",
 				__func__, err);
 	}
 }
 /** send RTS/DTR state to the port.
  *
  * This is exactly the same as SET_CONTROL_LINE_STATE from the PSTN
  * CDC.
 */
 static int option_send_setup(struct usb_serial_port *port)
 {
 	struct usb_serial *serial = port->serial;
 	struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial);
 	struct option_private *priv = intfdata->private;
 	struct usb_wwan_port_private *portdata;
 	int val = 0;
 	portdata = usb_get_serial_port_data(port);
 	if (portdata->dtr_state)
 		val |= 0x01;
 	if (portdata->rts_state)
 		val |= 0x02;
 	return usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 				0x22, 0x21, val, priv->bInterfaceNumber, NULL,
 				0, USB_CTRL_SET_TIMEOUT);
 }
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");

include/uapi/linux/usb/Kbuild

Diff comments View file @ 8ee7a33

 # UAPI Header export list
 header-y += audio.h
 header-y += cdc.h
+header-y += cdc-wdm.h
 header-y += ch11.h
 header-y += ch9.h
 header-y += functionfs.h
 header-y += g_printer.h
 header-y += gadgetfs.h
 header-y += midi.h
 header-y += tmc.h
 header-y += video.h

include/uapi/linux/usb/cdc-wdm.h

Diff comments View file @ 8ee7a33

 /*
  * USB CDC Device Management userspace API definitions
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * version 2 as published by the Free Software Foundation.
  */
 #ifndef _UAPI__LINUX_USB_CDC_WDM_H
 #define _UAPI__LINUX_USB_CDC_WDM_H
+#include <linux/types.h>
 /*
  * This IOCTL is used to retrieve the wMaxCommand for the device,
  * defining the message limit for both reading and writing.
  *
  * For CDC WDM functions this will be the wMaxCommand field of the
  * Device Management Functional Descriptor.
  */
 #define IOCTL_WDM_MAX_COMMAND _IOR('H', 0xA0, __u16)
 #endif /* _UAPI__LINUX_USB_CDC_WDM_H */