Merge tag 'for-usb-next-2012-02-14' of... (03a41f3d) · Commits · 戴 / test

drivers/usb/core/hub.c

+115 −47

Original line number	Diff line number	Diff line
		@@ -62,6 +62,8 @@ struct usb_hub {
		resumed */
		unsigned long removed_bits[1]; /* ports with a "removed"
		device present */
		unsigned long wakeup_bits[1]; /* ports that have signaled
		remote wakeup */
		#if USB_MAXCHILDREN > 31 /* 8sizeof(unsigned long) - 1 /
		#error event_bits[] is too short!
		#endif
		@@ -411,6 +413,29 @@ void usb_kick_khubd(struct usb_device *hdev)
		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 = hdev_to_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)
		@@ -807,12 +832,6 @@ static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
		clear_port_feature(hub->hdev, port1,
		USB_PORT_FEAT_C_ENABLE);
		}
		if (portchange & USB_PORT_STAT_C_LINK_STATE) {
		need_debounce_delay = true;
		clear_port_feature(hub->hdev, port1,
		USB_PORT_FEAT_C_PORT_LINK_STATE);
		}

		if ((portchange & USB_PORT_STAT_C_BH_RESET) &&
		hub_is_superspeed(hub->hdev)) {
		need_debounce_delay = true;
		@@ -834,12 +853,19 @@ static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
		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.
		* 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)
		if (portchange \|\| (hub_is_superspeed(hub->hdev) &&
		port_resumed))
		set_bit(port1, hub->change_bits);

		} else if (udev->persist_enabled) {
		@@ -1289,13 +1315,7 @@ static int hub_probe(struct usb_interface intf, const struct usb_device_id id)
		desc = intf->cur_altsetting;
		hdev = interface_to_usbdev(intf);

		/* Hubs have proper suspend/resume support. USB 3.0 device suspend is
		* different from USB 2.0/1.1 device suspend, and unfortunately we
		* don't support it yet. So leave autosuspend disabled for USB 3.0
		* external hubs for now. Enable autosuspend for USB 3.0 roothubs,
		* since that isn't a "real" hub.
		*/
		if (!hub_is_superspeed(hdev) \|\| !hdev->parent)
		/* Hubs have proper suspend/resume support. */
		usb_enable_autosuspend(hdev);

		if (hdev->level == MAX_TOPO_LEVEL) {
		@@ -2421,11 +2441,27 @@ int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
		* we don't explicitly enable it here.
		*/
		if (udev->do_remote_wakeup) {
		if (!hub_is_superspeed(hub->hdev)) {
		status = 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 {
		/* Assume there's only one function on the USB 3.0
		* device and enable remote wake for the first
		* interface. FIXME if the interface association
		* descriptor shows there's more than one function.
		*/
		status = 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);
		}
		if (status) {
		dev_dbg(&udev->dev, "won't remote wakeup, status %d\n",
		status);
		@@ -2715,6 +2751,7 @@ 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 */
		for (port1 = 1; port1 <= hdev->maxchild; port1++) {
		@@ -2727,6 +2764,17 @@ static int hub_suspend(struct usb_interface *intf, pm_message_t msg)
		return -EBUSY;
		}
		}
		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__);

		@@ -3460,6 +3508,46 @@ done:
		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 = hdev->children[port-1];
		if (!hub_is_superspeed(hdev)) {
		if (!(portchange & USB_PORT_STAT_C_SUSPEND))
		return 0;
		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;
		@@ -3472,7 +3560,7 @@ static void hub_events(void)
		u16 portstatus;
		u16 portchange;
		int i, ret;
		int connect_change;
		int connect_change, wakeup_change;

		/*
		* We restart the list every time to avoid a deadlock with
		@@ -3551,8 +3639,9 @@ static void hub_events(void)
		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)
		!connect_change && !wakeup_change)
		continue;

		ret = hub_port_status(hub, i,
		@@ -3593,30 +3682,9 @@ static void hub_events(void)
		}
		}

		if (portchange & USB_PORT_STAT_C_SUSPEND) {
		struct usb_device *udev;

		clear_port_feature(hdev, i,
		USB_PORT_FEAT_C_SUSPEND);
		udev = hdev->children[i-1];
		if (udev) {
		/* TRSMRCY = 10 msec */
		msleep(10);

		usb_lock_device(udev);
		ret = usb_remote_wakeup(hdev->
		children[i-1]);
		usb_unlock_device(udev);
		if (ret < 0)
		if (hub_handle_remote_wakeup(hub, i,
		portstatus, portchange))
		connect_change = 1;
		} else {
		ret = -ENODEV;
		hub_port_disable(hub, i, 1);
		}
		dev_dbg (hub_dev,
		"resume on port %d, status %d\n",
		i, ret);
		}

		if (portchange & USB_PORT_STAT_C_OVERCURRENT) {
		u16 status = 0;

drivers/usb/host/xhci-hub.c

+41 −0

Original line number	Diff line number	Diff line
		@@ -422,6 +422,32 @@ void xhci_set_link_state(struct xhci_hcd xhci, __le32 __iomem *port_array,
		xhci_writel(xhci, temp, port_array[port_id]);
		}

		void xhci_set_remote_wake_mask(struct xhci_hcd *xhci,
		__le32 __iomem **port_array, int port_id, u16 wake_mask)
		{
		u32 temp;

		temp = xhci_readl(xhci, port_array[port_id]);
		temp = xhci_port_state_to_neutral(temp);

		if (wake_mask & USB_PORT_FEAT_REMOTE_WAKE_CONNECT)
		temp \|= PORT_WKCONN_E;
		else
		temp &= ~PORT_WKCONN_E;

		if (wake_mask & USB_PORT_FEAT_REMOTE_WAKE_DISCONNECT)
		temp \|= PORT_WKDISC_E;
		else
		temp &= ~PORT_WKDISC_E;

		if (wake_mask & USB_PORT_FEAT_REMOTE_WAKE_OVER_CURRENT)
		temp \|= PORT_WKOC_E;
		else
		temp &= ~PORT_WKOC_E;

		xhci_writel(xhci, temp, port_array[port_id]);
		}

		/* Test and clear port RWC bit */
		void xhci_test_and_clear_bit(struct xhci_hcd xhci, __le32 __iomem *port_array,
		int port_id, u32 port_bit)
		@@ -448,6 +474,7 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
		int slot_id;
		struct xhci_bus_state *bus_state;
		u16 link_state = 0;
		u16 wake_mask = 0;

		max_ports = xhci_get_ports(hcd, &port_array);
		bus_state = &xhci->bus_state[hcd_index(hcd)];
		@@ -593,6 +620,8 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
		case SetPortFeature:
		if (wValue == USB_PORT_FEAT_LINK_STATE)
		link_state = (wIndex & 0xff00) >> 3;
		if (wValue == USB_PORT_FEAT_REMOTE_WAKE_MASK)
		wake_mask = wIndex & 0xff00;
		wIndex &= 0xff;
		if (!wIndex \|\| wIndex > max_ports)
		goto error;
		@@ -703,6 +732,14 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
		temp = xhci_readl(xhci, port_array[wIndex]);
		xhci_dbg(xhci, "set port reset, actual port %d status = 0x%x\n", wIndex, temp);
		break;
		case USB_PORT_FEAT_REMOTE_WAKE_MASK:
		xhci_set_remote_wake_mask(xhci, port_array,
		wIndex, wake_mask);
		temp = xhci_readl(xhci, port_array[wIndex]);
		xhci_dbg(xhci, "set port remote wake mask, "
		"actual port %d status = 0x%x\n",
		wIndex, temp);
		break;
		case USB_PORT_FEAT_BH_PORT_RESET:
		temp \|= PORT_WR;
		xhci_writel(xhci, temp, port_array[wIndex]);
		@@ -883,6 +920,10 @@ int xhci_bus_suspend(struct usb_hcd *hcd)
		t2 \|= PORT_LINK_STROBE \| XDEV_U3;
		set_bit(port_index, &bus_state->bus_suspended);
		}
		/* USB core sets remote wake mask for USB 3.0 hubs,
		* including the USB 3.0 roothub, but only if CONFIG_USB_SUSPEND
		* is enabled, so also enable remote wake here.
		*/
		if (hcd->self.root_hub->do_remote_wakeup) {
		if (t1 & PORT_CONNECT) {
		t2 \|= PORT_WKOC_E \| PORT_WKDISC_E;

drivers/usb/host/xhci-mem.c

+10 −1

Original line number	Diff line number	Diff line
		@@ -2141,7 +2141,7 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
		unsigned int val, val2;
		u64 val_64;
		struct xhci_segment *seg;
		u32 page_size;
		u32 page_size, temp;
		int i;

		page_size = xhci_readl(xhci, &xhci->op_regs->page_size);
		@@ -2324,6 +2324,15 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)

		INIT_LIST_HEAD(&xhci->lpm_failed_devs);

		/* 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 = xhci_readl(xhci, &xhci->op_regs->dev_notification);
		temp &= ~DEV_NOTE_MASK;
		temp \|= DEV_NOTE_FWAKE;
		xhci_writel(xhci, temp, &xhci->op_regs->dev_notification);

		return 0;

		fail:

drivers/usb/host/xhci-ring.c

+62 −12

Original line number	Diff line number	Diff line
		@@ -1237,6 +1237,26 @@ static unsigned int find_faked_portnum_from_hw_portnum(struct usb_hcd *hcd,
		return num_similar_speed_ports;
		}

		static void handle_device_notification(struct xhci_hcd *xhci,
		union xhci_trb *event)
		{
		u32 slot_id;
		struct usb_device *udev;

		slot_id = TRB_TO_SLOT_ID(event->generic.field[3]);
		if (!xhci->devs[slot_id]) {
		xhci_warn(xhci, "Device Notification event for "
		"unused slot %u\n", slot_id);
		return;
		}

		xhci_dbg(xhci, "Device Wake Notification event for slot ID %u\n",
		slot_id);
		udev = xhci->devs[slot_id]->udev;
		if (udev && udev->parent)
		usb_wakeup_notification(udev->parent, udev->portnum);
		}

		static void handle_port_status(struct xhci_hcd *xhci,
		union xhci_trb *event)
		{
		@@ -1321,20 +1341,21 @@ static void handle_port_status(struct xhci_hcd *xhci,
		}

		if (DEV_SUPERSPEED(temp)) {
		xhci_dbg(xhci, "resume SS port %d\n", port_id);
		xhci_dbg(xhci, "remote wake SS port %d\n", port_id);
		/* Set a flag to say the port signaled remote wakeup,
		* so we can tell the difference between the end of
		* device and host initiated resume.
		*/
		bus_state->port_remote_wakeup \|= 1 << faked_port_index;
		xhci_test_and_clear_bit(xhci, port_array,
		faked_port_index, PORT_PLC);
		xhci_set_link_state(xhci, port_array, faked_port_index,
		XDEV_U0);
		slot_id = xhci_find_slot_id_by_port(hcd, xhci,
		faked_port_index + 1);
		if (!slot_id) {
		xhci_dbg(xhci, "slot_id is zero\n");
		/* Need to wait until the next link state change
		* indicates the device is actually in U0.
		*/
		bogus_port_status = true;
		goto cleanup;
		}
		xhci_ring_device(xhci, slot_id);
		xhci_dbg(xhci, "resume SS port %d finished\n", port_id);
		/* Clear PORT_PLC */
		xhci_test_and_clear_bit(xhci, port_array,
		faked_port_index, PORT_PLC);
		} else {
		xhci_dbg(xhci, "resume HS port %d\n", port_id);
		bus_state->resume_done[faked_port_index] = jiffies +
		@@ -1345,6 +1366,32 @@ static void handle_port_status(struct xhci_hcd *xhci,
		}
		}

		if ((temp & PORT_PLC) && (temp & PORT_PLS_MASK) == XDEV_U0 &&
		DEV_SUPERSPEED(temp)) {
		xhci_dbg(xhci, "resume SS port %d finished\n", port_id);
		/* We've just brought the device into U0 through either the
		* Resume state after a device remote wakeup, or through the
		* U3Exit state after a host-initiated resume. If it's a device
		* initiated remote wake, don't pass up the link state change,
		* so the roothub behavior is consistent with external
		* USB 3.0 hub behavior.
		*/
		slot_id = xhci_find_slot_id_by_port(hcd, xhci,
		faked_port_index + 1);
		if (slot_id && xhci->devs[slot_id])
		xhci_ring_device(xhci, slot_id);
		if (bus_state->port_remote_wakeup && (1 << faked_port_index)) {
		bus_state->port_remote_wakeup &=
		~(1 << faked_port_index);
		xhci_test_and_clear_bit(xhci, port_array,
		faked_port_index, PORT_PLC);
		usb_wakeup_notification(hcd->self.root_hub,
		faked_port_index + 1);
		bogus_port_status = true;
		goto cleanup;
		}
		}

		if (hcd->speed != HCD_USB3)
		xhci_test_and_clear_bit(xhci, port_array, faked_port_index,
		PORT_PLC);
		@@ -2277,6 +2324,9 @@ static int xhci_handle_event(struct xhci_hcd *xhci)
		else
		update_ptrs = 0;
		break;
		case TRB_TYPE(TRB_DEV_NOTE):
		handle_device_notification(xhci, event);
		break;
		default:
		if ((le32_to_cpu(event->event_cmd.flags) & TRB_TYPE_BITMASK) >=
		TRB_TYPE(48))

drivers/usb/host/xhci.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -1344,6 +1344,7 @@ struct xhci_bus_state {
		/* ports suspend status arrays - max 31 ports for USB2, 15 for USB3 */
		u32 port_c_suspend;
		u32 suspended_ports;
		u32 port_remote_wakeup;
		unsigned long resume_done[USB_MAXCHILDREN];
		};

Admin message