Merge tag 'for-usb-next-2014-03-06' of... (c9050b64) · Commits · 戴 / test

MAINTAINERS

+1 −2

Original line number	Original line	Diff line number	Diff line
	@@ -9063,8 +9063,7 @@ S: Maintained
	F: drivers/net/wireless/ath/ar5523/		F: drivers/net/wireless/ath/ar5523/

	USB ATTACHED SCSI		USB ATTACHED SCSI
	M: Matthew Wilcox <willy@linux.intel.com>		M: Hans de Goede <hdegoede@redhat.com>
	M: Sarah Sharp <sarah.a.sharp@linux.intel.com>
	M: Gerd Hoffmann <kraxel@redhat.com>		M: Gerd Hoffmann <kraxel@redhat.com>
	L: linux-usb@vger.kernel.org		L: linux-usb@vger.kernel.org
	L: linux-scsi@vger.kernel.org		L: linux-scsi@vger.kernel.org

drivers/usb/core/config.c

+0 −1

Original line number	Original line	Diff line number	Diff line
	@@ -10,7 +10,6 @@


	#define USB_MAXALTSETTING 128 /* Hard limit */		#define USB_MAXALTSETTING 128 /* Hard limit */
	#define USB_MAXENDPOINTS 30 /* Hard limit */

	#define USB_MAXCONFIG 8 /* Arbitrary limit */		#define USB_MAXCONFIG 8 /* Arbitrary limit */

drivers/usb/core/devio.c

+143 −15

Original line number	Original line	Diff line number	Diff line
	@@ -769,6 +769,88 @@ static int check_ctrlrecip(struct dev_state *ps, unsigned int requesttype,
	return ret;		return ret;
	}		}

			static struct usb_host_endpoint ep_to_host_endpoint(struct usb_device dev,
			unsigned char ep)
			{
			if (ep & USB_ENDPOINT_DIR_MASK)
			return dev->ep_in[ep & USB_ENDPOINT_NUMBER_MASK];
			else
			return dev->ep_out[ep & USB_ENDPOINT_NUMBER_MASK];
			}

			static int parse_usbdevfs_streams(struct dev_state *ps,
			struct usbdevfs_streams __user *streams,
			unsigned int *num_streams_ret,
			unsigned int *num_eps_ret,
			struct usb_host_endpoint ***eps_ret,
			struct usb_interface **intf_ret)
			{
			unsigned int i, num_streams, num_eps;
			struct usb_host_endpoint **eps;
			struct usb_interface *intf = NULL;
			unsigned char ep;
			int ifnum, ret;

			if (get_user(num_streams, &streams->num_streams) \|\|
			get_user(num_eps, &streams->num_eps))
			return -EFAULT;

			if (num_eps < 1 \|\| num_eps > USB_MAXENDPOINTS)
			return -EINVAL;

			/* The XHCI controller allows max 2 ^ 16 streams */
			if (num_streams_ret && (num_streams < 2 \|\| num_streams > 65536))
			return -EINVAL;

			eps = kmalloc(num_eps * sizeof(*eps), GFP_KERNEL);
			if (!eps)
			return -ENOMEM;

			for (i = 0; i < num_eps; i++) {
			if (get_user(ep, &streams->eps[i])) {
			ret = -EFAULT;
			goto error;
			}
			eps[i] = ep_to_host_endpoint(ps->dev, ep);
			if (!eps[i]) {
			ret = -EINVAL;
			goto error;
			}

			/* usb_alloc/free_streams operate on an usb_interface */
			ifnum = findintfep(ps->dev, ep);
			if (ifnum < 0) {
			ret = ifnum;
			goto error;
			}

			if (i == 0) {
			ret = checkintf(ps, ifnum);
			if (ret < 0)
			goto error;
			intf = usb_ifnum_to_if(ps->dev, ifnum);
			} else {
			/* Verify all eps belong to the same interface */
			if (ifnum != intf->altsetting->desc.bInterfaceNumber) {
			ret = -EINVAL;
			goto error;
			}
			}
			}

			if (num_streams_ret)
			*num_streams_ret = num_streams;
			*num_eps_ret = num_eps;
			*eps_ret = eps;
			*intf_ret = intf;

			return 0;

			error:
			kfree(eps);
			return ret;
			}

	static int match_devt(struct device dev, void data)		static int match_devt(struct device dev, void data)
	{		{
	return dev->devt == (dev_t) (unsigned long) data;		return dev->devt == (dev_t) (unsigned long) data;
	@@ -1143,6 +1225,9 @@ static int proc_setintf(struct dev_state ps, void __user arg)
	return -EFAULT;		return -EFAULT;
	if ((ret = checkintf(ps, setintf.interface)))		if ((ret = checkintf(ps, setintf.interface)))
	return ret;		return ret;

			destroy_async_on_interface(ps, setintf.interface);

	return usb_set_interface(ps->dev, setintf.interface,		return usb_set_interface(ps->dev, setintf.interface,
	setintf.altsetting);		setintf.altsetting);
	}		}
	@@ -1205,6 +1290,8 @@ static int proc_do_submiturb(struct dev_state ps, struct usbdevfs_urb uurb,
	struct usb_ctrlrequest *dr = NULL;		struct usb_ctrlrequest *dr = NULL;
	unsigned int u, totlen, isofrmlen;		unsigned int u, totlen, isofrmlen;
	int i, ret, is_in, num_sgs = 0, ifnum = -1;		int i, ret, is_in, num_sgs = 0, ifnum = -1;
			int number_of_packets = 0;
			unsigned int stream_id = 0;
	void *buf;		void *buf;

	if (uurb->flags & ~(USBDEVFS_URB_ISO_ASAP \|		if (uurb->flags & ~(USBDEVFS_URB_ISO_ASAP \|
	@@ -1225,15 +1312,10 @@ static int proc_do_submiturb(struct dev_state ps, struct usbdevfs_urb uurb,
	if (ret)		if (ret)
	return ret;		return ret;
	}		}
	if ((uurb->endpoint & USB_ENDPOINT_DIR_MASK) != 0) {		ep = ep_to_host_endpoint(ps->dev, uurb->endpoint);
	is_in = 1;
	ep = ps->dev->ep_in[uurb->endpoint & USB_ENDPOINT_NUMBER_MASK];
	} else {
	is_in = 0;
	ep = ps->dev->ep_out[uurb->endpoint & USB_ENDPOINT_NUMBER_MASK];
	}
	if (!ep)		if (!ep)
	return -ENOENT;		return -ENOENT;
			is_in = (uurb->endpoint & USB_ENDPOINT_DIR_MASK) != 0;

	u = 0;		u = 0;
	switch(uurb->type) {		switch(uurb->type) {
	@@ -1258,7 +1340,6 @@ static int proc_do_submiturb(struct dev_state ps, struct usbdevfs_urb uurb,
	le16_to_cpup(&dr->wIndex));		le16_to_cpup(&dr->wIndex));
	if (ret)		if (ret)
	goto error;		goto error;
	uurb->number_of_packets = 0;
	uurb->buffer_length = le16_to_cpup(&dr->wLength);		uurb->buffer_length = le16_to_cpup(&dr->wLength);
	uurb->buffer += 8;		uurb->buffer += 8;
	if ((dr->bRequestType & USB_DIR_IN) && uurb->buffer_length) {		if ((dr->bRequestType & USB_DIR_IN) && uurb->buffer_length) {
	@@ -1288,17 +1369,17 @@ static int proc_do_submiturb(struct dev_state ps, struct usbdevfs_urb uurb,
	uurb->type = USBDEVFS_URB_TYPE_INTERRUPT;		uurb->type = USBDEVFS_URB_TYPE_INTERRUPT;
	goto interrupt_urb;		goto interrupt_urb;
	}		}
	uurb->number_of_packets = 0;
	num_sgs = DIV_ROUND_UP(uurb->buffer_length, USB_SG_SIZE);		num_sgs = DIV_ROUND_UP(uurb->buffer_length, USB_SG_SIZE);
	if (num_sgs == 1 \|\| num_sgs > ps->dev->bus->sg_tablesize)		if (num_sgs == 1 \|\| num_sgs > ps->dev->bus->sg_tablesize)
	num_sgs = 0;		num_sgs = 0;
			if (ep->streams)
			stream_id = uurb->stream_id;
	break;		break;

	case USBDEVFS_URB_TYPE_INTERRUPT:		case USBDEVFS_URB_TYPE_INTERRUPT:
	if (!usb_endpoint_xfer_int(&ep->desc))		if (!usb_endpoint_xfer_int(&ep->desc))
	return -EINVAL;		return -EINVAL;
	interrupt_urb:		interrupt_urb:
	uurb->number_of_packets = 0;
	break;		break;

	case USBDEVFS_URB_TYPE_ISO:		case USBDEVFS_URB_TYPE_ISO:
	@@ -1308,15 +1389,16 @@ static int proc_do_submiturb(struct dev_state ps, struct usbdevfs_urb uurb,
	return -EINVAL;		return -EINVAL;
	if (!usb_endpoint_xfer_isoc(&ep->desc))		if (!usb_endpoint_xfer_isoc(&ep->desc))
	return -EINVAL;		return -EINVAL;
			number_of_packets = uurb->number_of_packets;
	isofrmlen = sizeof(struct usbdevfs_iso_packet_desc) *		isofrmlen = sizeof(struct usbdevfs_iso_packet_desc) *
	uurb->number_of_packets;		number_of_packets;
	if (!(isopkt = kmalloc(isofrmlen, GFP_KERNEL)))		if (!(isopkt = kmalloc(isofrmlen, GFP_KERNEL)))
	return -ENOMEM;		return -ENOMEM;
	if (copy_from_user(isopkt, iso_frame_desc, isofrmlen)) {		if (copy_from_user(isopkt, iso_frame_desc, isofrmlen)) {
	ret = -EFAULT;		ret = -EFAULT;
	goto error;		goto error;
	}		}
	for (totlen = u = 0; u < uurb->number_of_packets; u++) {		for (totlen = u = 0; u < number_of_packets; u++) {
	/*		/*
	* arbitrary limit need for USB 3.0		* arbitrary limit need for USB 3.0
	* bMaxBurst (0~15 allowed, 1~16 packets)		* bMaxBurst (0~15 allowed, 1~16 packets)
	@@ -1347,7 +1429,7 @@ static int proc_do_submiturb(struct dev_state ps, struct usbdevfs_urb uurb,
	ret = -EFAULT;		ret = -EFAULT;
	goto error;		goto error;
	}		}
	as = alloc_async(uurb->number_of_packets);		as = alloc_async(number_of_packets);
	if (!as) {		if (!as) {
	ret = -ENOMEM;		ret = -ENOMEM;
	goto error;		goto error;
	@@ -1441,7 +1523,8 @@ static int proc_do_submiturb(struct dev_state ps, struct usbdevfs_urb uurb,
	as->urb->setup_packet = (unsigned char *)dr;		as->urb->setup_packet = (unsigned char *)dr;
	dr = NULL;		dr = NULL;
	as->urb->start_frame = uurb->start_frame;		as->urb->start_frame = uurb->start_frame;
	as->urb->number_of_packets = uurb->number_of_packets;		as->urb->number_of_packets = number_of_packets;
			as->urb->stream_id = stream_id;
	if (uurb->type == USBDEVFS_URB_TYPE_ISO \|\|		if (uurb->type == USBDEVFS_URB_TYPE_ISO \|\|
	ps->dev->speed == USB_SPEED_HIGH)		ps->dev->speed == USB_SPEED_HIGH)
	as->urb->interval = 1 << min(15, ep->desc.bInterval - 1);		as->urb->interval = 1 << min(15, ep->desc.bInterval - 1);
	@@ -1449,7 +1532,7 @@ static int proc_do_submiturb(struct dev_state ps, struct usbdevfs_urb uurb,
	as->urb->interval = ep->desc.bInterval;		as->urb->interval = ep->desc.bInterval;
	as->urb->context = as;		as->urb->context = as;
	as->urb->complete = async_completed;		as->urb->complete = async_completed;
	for (totlen = u = 0; u < uurb->number_of_packets; u++) {		for (totlen = u = 0; u < number_of_packets; u++) {
	as->urb->iso_frame_desc[u].offset = totlen;		as->urb->iso_frame_desc[u].offset = totlen;
	as->urb->iso_frame_desc[u].length = isopkt[u].length;		as->urb->iso_frame_desc[u].length = isopkt[u].length;
	totlen += isopkt[u].length;		totlen += isopkt[u].length;
	@@ -1999,6 +2082,45 @@ static int proc_disconnect_claim(struct dev_state ps, void __user arg)
	return claimintf(ps, dc.interface);		return claimintf(ps, dc.interface);
	}		}

			static int proc_alloc_streams(struct dev_state ps, void __user arg)
			{
			unsigned num_streams, num_eps;
			struct usb_host_endpoint **eps;
			struct usb_interface *intf;
			int r;

			r = parse_usbdevfs_streams(ps, arg, &num_streams, &num_eps,
			&eps, &intf);
			if (r)
			return r;

			destroy_async_on_interface(ps,
			intf->altsetting[0].desc.bInterfaceNumber);

			r = usb_alloc_streams(intf, eps, num_eps, num_streams, GFP_KERNEL);
			kfree(eps);
			return r;
			}

			static int proc_free_streams(struct dev_state ps, void __user arg)
			{
			unsigned num_eps;
			struct usb_host_endpoint **eps;
			struct usb_interface *intf;
			int r;

			r = parse_usbdevfs_streams(ps, arg, NULL, &num_eps, &eps, &intf);
			if (r)
			return r;

			destroy_async_on_interface(ps,
			intf->altsetting[0].desc.bInterfaceNumber);

			r = usb_free_streams(intf, eps, num_eps, GFP_KERNEL);
			kfree(eps);
			return r;
			}

	/*		/*
	* NOTE: All requests here that have interface numbers as parameters		* NOTE: All requests here that have interface numbers as parameters
	* are assuming that somehow the configuration has been prevented from		* are assuming that somehow the configuration has been prevented from
	@@ -2175,6 +2297,12 @@ static long usbdev_do_ioctl(struct file *file, unsigned int cmd,
	case USBDEVFS_DISCONNECT_CLAIM:		case USBDEVFS_DISCONNECT_CLAIM:
	ret = proc_disconnect_claim(ps, p);		ret = proc_disconnect_claim(ps, p);
	break;		break;
			case USBDEVFS_ALLOC_STREAMS:
			ret = proc_alloc_streams(ps, p);
			break;
			case USBDEVFS_FREE_STREAMS:
			ret = proc_free_streams(ps, p);
			break;
	}		}
	usb_unlock_device(dev);		usb_unlock_device(dev);
	if (ret >= 0)		if (ret >= 0)

drivers/usb/core/driver.c

+22 −1

Original line number	Original line	Diff line number	Diff line
	@@ -400,8 +400,9 @@ static int usb_unbind_interface(struct device *dev)
	{		{
	struct usb_driver *driver = to_usb_driver(dev->driver);		struct usb_driver *driver = to_usb_driver(dev->driver);
	struct usb_interface *intf = to_usb_interface(dev);		struct usb_interface *intf = to_usb_interface(dev);
			struct usb_host_endpoint ep, *eps = NULL;
	struct usb_device *udev;		struct usb_device *udev;
	int error, r, lpm_disable_error;		int i, j, error, r, lpm_disable_error;

	intf->condition = USB_INTERFACE_UNBINDING;		intf->condition = USB_INTERFACE_UNBINDING;

	@@ -425,6 +426,26 @@ static int usb_unbind_interface(struct device *dev)
	driver->disconnect(intf);		driver->disconnect(intf);
	usb_cancel_queued_reset(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.		/* Reset other interface state.
	* We cannot do a Set-Interface if the device is suspended or		* We cannot do a Set-Interface if the device is suspended or
	* if it is prepared for a system sleep (since installing a new		* if it is prepared for a system sleep (since installing a new

drivers/usb/core/hcd.c

+27 −10

Original line number	Original line	Diff line number	Diff line
	@@ -2049,7 +2049,7 @@ int usb_alloc_streams(struct usb_interface *interface,
	{		{
	struct usb_hcd *hcd;		struct usb_hcd *hcd;
	struct usb_device *dev;		struct usb_device *dev;
	int i;		int i, ret;

	dev = interface_to_usbdev(interface);		dev = interface_to_usbdev(interface);
	hcd = bus_to_hcd(dev->bus);		hcd = bus_to_hcd(dev->bus);
	@@ -2058,13 +2058,24 @@ int usb_alloc_streams(struct usb_interface *interface,
	if (dev->speed != USB_SPEED_SUPER)		if (dev->speed != USB_SPEED_SUPER)
	return -EINVAL;		return -EINVAL;

			for (i = 0; i < num_eps; i++) {
	/* Streams only apply to bulk endpoints. */		/* Streams only apply to bulk endpoints. */
	for (i = 0; i < num_eps; i++)
	if (!usb_endpoint_xfer_bulk(&eps[i]->desc))		if (!usb_endpoint_xfer_bulk(&eps[i]->desc))
	return -EINVAL;		return -EINVAL;
			/* Re-alloc is not allowed */
			if (eps[i]->streams)
			return -EINVAL;
			}

	return hcd->driver->alloc_streams(hcd, dev, eps, num_eps,		ret = hcd->driver->alloc_streams(hcd, dev, eps, num_eps,
	num_streams, mem_flags);		num_streams, mem_flags);
			if (ret < 0)
			return ret;

			for (i = 0; i < num_eps; i++)
			eps[i]->streams = ret;

			return ret;
	}		}
	EXPORT_SYMBOL_GPL(usb_alloc_streams);		EXPORT_SYMBOL_GPL(usb_alloc_streams);

	@@ -2078,8 +2089,7 @@ EXPORT_SYMBOL_GPL(usb_alloc_streams);
	* Reverts a group of bulk endpoints back to not using stream IDs.		* Reverts a group of bulk endpoints back to not using stream IDs.
	* Can fail if we are given bad arguments, or HCD is broken.		* Can fail if we are given bad arguments, or HCD is broken.
	*		*
	* Return: On success, the number of allocated streams. On failure, a negative		* Return: 0 on success. On failure, a negative error code.
	* error code.
	*/		*/
	int usb_free_streams(struct usb_interface *interface,		int usb_free_streams(struct usb_interface *interface,
	struct usb_host_endpoint **eps, unsigned int num_eps,		struct usb_host_endpoint **eps, unsigned int num_eps,
	@@ -2087,19 +2097,26 @@ int usb_free_streams(struct usb_interface *interface,
	{		{
	struct usb_hcd *hcd;		struct usb_hcd *hcd;
	struct usb_device *dev;		struct usb_device *dev;
	int i;		int i, ret;

	dev = interface_to_usbdev(interface);		dev = interface_to_usbdev(interface);
	hcd = bus_to_hcd(dev->bus);		hcd = bus_to_hcd(dev->bus);
	if (dev->speed != USB_SPEED_SUPER)		if (dev->speed != USB_SPEED_SUPER)
	return -EINVAL;		return -EINVAL;

	/* Streams only apply to bulk endpoints. */		/* Double-free is not allowed */
	for (i = 0; i < num_eps; i++)		for (i = 0; i < num_eps; i++)
	if (!eps[i] \|\| !usb_endpoint_xfer_bulk(&eps[i]->desc))		if (!eps[i] \|\| !eps[i]->streams)
	return -EINVAL;		return -EINVAL;

	return hcd->driver->free_streams(hcd, dev, eps, num_eps, mem_flags);		ret = hcd->driver->free_streams(hcd, dev, eps, num_eps, mem_flags);
			if (ret < 0)
			return ret;

			for (i = 0; i < num_eps; i++)
			eps[i]->streams = 0;

			return ret;
	}		}
	EXPORT_SYMBOL_GPL(usb_free_streams);		EXPORT_SYMBOL_GPL(usb_free_streams);

Admin message