diff options
author | Daniel Vetter <daniel.vetter@ffwll.ch> | 2012-05-07 05:30:46 -0400 |
---|---|---|
committer | Daniel Vetter <daniel.vetter@ffwll.ch> | 2012-05-07 08:02:14 -0400 |
commit | dc257cf154be708ecc47b8b89c12ad8cd2cc35e4 (patch) | |
tree | 625d57ef6c42030cc1ce1842d4efc105e284bc3d /drivers/usb | |
parent | 5bc69bf9aeb73547cad8e1ce683a103fe9728282 (diff) | |
parent | d48b97b403d23f6df0b990cee652bdf9a52337a3 (diff) |
Merge tag 'v3.4-rc6' into drm-intel-next
Conflicts:
drivers/gpu/drm/i915/intel_display.c
Ok, this is a fun story of git totally messing things up. There
/shouldn't/ be any conflict in here, because the fixes in -rc6 do only
touch functions that have not been changed in -next.
The offending commits in drm-next are 14415745b2..1fa611065 which
simply move a few functions from intel_display.c to intel_pm.c. The
problem seems to be that git diff gets completely confused:
$ git diff 14415745b2..1fa611065
is a nice mess in intel_display.c, and the diff leaks into totally
unrelated functions, whereas
$git diff --minimal 14415745b2..1fa611065
is exactly what we want.
Unfortunately there seems to be no way to teach similar smarts to the
merge diff and conflict generation code, because with the minimal diff
there really shouldn't be any conflicts. For added hilarity, every
time something in that area changes the + and - lines in the diff move
around like crazy, again resulting in new conflicts. So I fear this
mess will stay with us for a little longer (and might result in
another backmerge down the road).
Signed-Off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Diffstat (limited to 'drivers/usb')
35 files changed, 422 insertions, 277 deletions
diff --git a/drivers/usb/class/cdc-wdm.c b/drivers/usb/class/cdc-wdm.c index c6f6560d436c..0bb2b3248dad 100644 --- a/drivers/usb/class/cdc-wdm.c +++ b/drivers/usb/class/cdc-wdm.c | |||
@@ -157,8 +157,9 @@ static void wdm_out_callback(struct urb *urb) | |||
157 | spin_lock(&desc->iuspin); | 157 | spin_lock(&desc->iuspin); |
158 | desc->werr = urb->status; | 158 | desc->werr = urb->status; |
159 | spin_unlock(&desc->iuspin); | 159 | spin_unlock(&desc->iuspin); |
160 | clear_bit(WDM_IN_USE, &desc->flags); | ||
161 | kfree(desc->outbuf); | 160 | kfree(desc->outbuf); |
161 | desc->outbuf = NULL; | ||
162 | clear_bit(WDM_IN_USE, &desc->flags); | ||
162 | wake_up(&desc->wait); | 163 | wake_up(&desc->wait); |
163 | } | 164 | } |
164 | 165 | ||
@@ -338,7 +339,7 @@ static ssize_t wdm_write | |||
338 | if (we < 0) | 339 | if (we < 0) |
339 | return -EIO; | 340 | return -EIO; |
340 | 341 | ||
341 | desc->outbuf = buf = kmalloc(count, GFP_KERNEL); | 342 | buf = kmalloc(count, GFP_KERNEL); |
342 | if (!buf) { | 343 | if (!buf) { |
343 | rv = -ENOMEM; | 344 | rv = -ENOMEM; |
344 | goto outnl; | 345 | goto outnl; |
@@ -406,10 +407,12 @@ static ssize_t wdm_write | |||
406 | req->wIndex = desc->inum; | 407 | req->wIndex = desc->inum; |
407 | req->wLength = cpu_to_le16(count); | 408 | req->wLength = cpu_to_le16(count); |
408 | set_bit(WDM_IN_USE, &desc->flags); | 409 | set_bit(WDM_IN_USE, &desc->flags); |
410 | desc->outbuf = buf; | ||
409 | 411 | ||
410 | rv = usb_submit_urb(desc->command, GFP_KERNEL); | 412 | rv = usb_submit_urb(desc->command, GFP_KERNEL); |
411 | if (rv < 0) { | 413 | if (rv < 0) { |
412 | kfree(buf); | 414 | kfree(buf); |
415 | desc->outbuf = NULL; | ||
413 | clear_bit(WDM_IN_USE, &desc->flags); | 416 | clear_bit(WDM_IN_USE, &desc->flags); |
414 | dev_err(&desc->intf->dev, "Tx URB error: %d\n", rv); | 417 | dev_err(&desc->intf->dev, "Tx URB error: %d\n", rv); |
415 | } else { | 418 | } else { |
diff --git a/drivers/usb/core/hcd-pci.c b/drivers/usb/core/hcd-pci.c index 622b4a48e732..57ed9e400c06 100644 --- a/drivers/usb/core/hcd-pci.c +++ b/drivers/usb/core/hcd-pci.c | |||
@@ -493,6 +493,15 @@ static int hcd_pci_suspend_noirq(struct device *dev) | |||
493 | 493 | ||
494 | pci_save_state(pci_dev); | 494 | pci_save_state(pci_dev); |
495 | 495 | ||
496 | /* | ||
497 | * Some systems crash if an EHCI controller is in D3 during | ||
498 | * a sleep transition. We have to leave such controllers in D0. | ||
499 | */ | ||
500 | if (hcd->broken_pci_sleep) { | ||
501 | dev_dbg(dev, "Staying in PCI D0\n"); | ||
502 | return retval; | ||
503 | } | ||
504 | |||
496 | /* If the root hub is dead rather than suspended, disallow remote | 505 | /* If the root hub is dead rather than suspended, disallow remote |
497 | * wakeup. usb_hc_died() should ensure that both hosts are marked as | 506 | * wakeup. usb_hc_died() should ensure that both hosts are marked as |
498 | * dying, so we only need to check the primary roothub. | 507 | * dying, so we only need to check the primary roothub. |
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c index a2aa9d652c67..ec6c97dadbe4 100644 --- a/drivers/usb/core/hub.c +++ b/drivers/usb/core/hub.c | |||
@@ -1667,7 +1667,6 @@ void usb_disconnect(struct usb_device **pdev) | |||
1667 | { | 1667 | { |
1668 | struct usb_device *udev = *pdev; | 1668 | struct usb_device *udev = *pdev; |
1669 | int i; | 1669 | int i; |
1670 | struct usb_hcd *hcd = bus_to_hcd(udev->bus); | ||
1671 | 1670 | ||
1672 | /* mark the device as inactive, so any further urb submissions for | 1671 | /* mark the device as inactive, so any further urb submissions for |
1673 | * this device (and any of its children) will fail immediately. | 1672 | * this device (and any of its children) will fail immediately. |
@@ -1690,9 +1689,7 @@ void usb_disconnect(struct usb_device **pdev) | |||
1690 | * so that the hardware is now fully quiesced. | 1689 | * so that the hardware is now fully quiesced. |
1691 | */ | 1690 | */ |
1692 | dev_dbg (&udev->dev, "unregistering device\n"); | 1691 | dev_dbg (&udev->dev, "unregistering device\n"); |
1693 | mutex_lock(hcd->bandwidth_mutex); | ||
1694 | usb_disable_device(udev, 0); | 1692 | usb_disable_device(udev, 0); |
1695 | mutex_unlock(hcd->bandwidth_mutex); | ||
1696 | usb_hcd_synchronize_unlinks(udev); | 1693 | usb_hcd_synchronize_unlinks(udev); |
1697 | 1694 | ||
1698 | usb_remove_ep_devs(&udev->ep0); | 1695 | usb_remove_ep_devs(&udev->ep0); |
diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c index aed3e07942d4..ca717da3be95 100644 --- a/drivers/usb/core/message.c +++ b/drivers/usb/core/message.c | |||
@@ -1136,8 +1136,6 @@ void usb_disable_interface(struct usb_device *dev, struct usb_interface *intf, | |||
1136 | * Deallocates hcd/hardware state for the endpoints (nuking all or most | 1136 | * Deallocates hcd/hardware state for the endpoints (nuking all or most |
1137 | * pending urbs) and usbcore state for the interfaces, so that usbcore | 1137 | * pending urbs) and usbcore state for the interfaces, so that usbcore |
1138 | * must usb_set_configuration() before any interfaces could be used. | 1138 | * must usb_set_configuration() before any interfaces could be used. |
1139 | * | ||
1140 | * Must be called with hcd->bandwidth_mutex held. | ||
1141 | */ | 1139 | */ |
1142 | void usb_disable_device(struct usb_device *dev, int skip_ep0) | 1140 | void usb_disable_device(struct usb_device *dev, int skip_ep0) |
1143 | { | 1141 | { |
@@ -1190,7 +1188,9 @@ void usb_disable_device(struct usb_device *dev, int skip_ep0) | |||
1190 | usb_disable_endpoint(dev, i + USB_DIR_IN, false); | 1188 | usb_disable_endpoint(dev, i + USB_DIR_IN, false); |
1191 | } | 1189 | } |
1192 | /* Remove endpoints from the host controller internal state */ | 1190 | /* Remove endpoints from the host controller internal state */ |
1191 | mutex_lock(hcd->bandwidth_mutex); | ||
1193 | usb_hcd_alloc_bandwidth(dev, NULL, NULL, NULL); | 1192 | usb_hcd_alloc_bandwidth(dev, NULL, NULL, NULL); |
1193 | mutex_unlock(hcd->bandwidth_mutex); | ||
1194 | /* Second pass: remove endpoint pointers */ | 1194 | /* Second pass: remove endpoint pointers */ |
1195 | } | 1195 | } |
1196 | for (i = skip_ep0; i < 16; ++i) { | 1196 | for (i = skip_ep0; i < 16; ++i) { |
@@ -1750,7 +1750,6 @@ free_interfaces: | |||
1750 | /* if it's already configured, clear out old state first. | 1750 | /* if it's already configured, clear out old state first. |
1751 | * getting rid of old interfaces means unbinding their drivers. | 1751 | * getting rid of old interfaces means unbinding their drivers. |
1752 | */ | 1752 | */ |
1753 | mutex_lock(hcd->bandwidth_mutex); | ||
1754 | if (dev->state != USB_STATE_ADDRESS) | 1753 | if (dev->state != USB_STATE_ADDRESS) |
1755 | usb_disable_device(dev, 1); /* Skip ep0 */ | 1754 | usb_disable_device(dev, 1); /* Skip ep0 */ |
1756 | 1755 | ||
@@ -1763,6 +1762,7 @@ free_interfaces: | |||
1763 | * host controller will not allow submissions to dropped endpoints. If | 1762 | * host controller will not allow submissions to dropped endpoints. If |
1764 | * this call fails, the device state is unchanged. | 1763 | * this call fails, the device state is unchanged. |
1765 | */ | 1764 | */ |
1765 | mutex_lock(hcd->bandwidth_mutex); | ||
1766 | ret = usb_hcd_alloc_bandwidth(dev, cp, NULL, NULL); | 1766 | ret = usb_hcd_alloc_bandwidth(dev, cp, NULL, NULL); |
1767 | if (ret < 0) { | 1767 | if (ret < 0) { |
1768 | mutex_unlock(hcd->bandwidth_mutex); | 1768 | mutex_unlock(hcd->bandwidth_mutex); |
diff --git a/drivers/usb/dwc3/core.c b/drivers/usb/dwc3/core.c index 7bd815a507e8..99b58d84553a 100644 --- a/drivers/usb/dwc3/core.c +++ b/drivers/usb/dwc3/core.c | |||
@@ -206,11 +206,11 @@ static void dwc3_free_event_buffers(struct dwc3 *dwc) | |||
206 | 206 | ||
207 | for (i = 0; i < dwc->num_event_buffers; i++) { | 207 | for (i = 0; i < dwc->num_event_buffers; i++) { |
208 | evt = dwc->ev_buffs[i]; | 208 | evt = dwc->ev_buffs[i]; |
209 | if (evt) { | 209 | if (evt) |
210 | dwc3_free_one_event_buffer(dwc, evt); | 210 | dwc3_free_one_event_buffer(dwc, evt); |
211 | dwc->ev_buffs[i] = NULL; | ||
212 | } | ||
213 | } | 211 | } |
212 | |||
213 | kfree(dwc->ev_buffs); | ||
214 | } | 214 | } |
215 | 215 | ||
216 | /** | 216 | /** |
diff --git a/drivers/usb/dwc3/ep0.c b/drivers/usb/dwc3/ep0.c index 25910e251c04..3584a169886f 100644 --- a/drivers/usb/dwc3/ep0.c +++ b/drivers/usb/dwc3/ep0.c | |||
@@ -353,6 +353,9 @@ static int dwc3_ep0_handle_feature(struct dwc3 *dwc, | |||
353 | 353 | ||
354 | dwc->test_mode_nr = wIndex >> 8; | 354 | dwc->test_mode_nr = wIndex >> 8; |
355 | dwc->test_mode = true; | 355 | dwc->test_mode = true; |
356 | break; | ||
357 | default: | ||
358 | return -EINVAL; | ||
356 | } | 359 | } |
357 | break; | 360 | break; |
358 | 361 | ||
@@ -559,15 +562,20 @@ static void dwc3_ep0_complete_data(struct dwc3 *dwc, | |||
559 | length = trb->size & DWC3_TRB_SIZE_MASK; | 562 | length = trb->size & DWC3_TRB_SIZE_MASK; |
560 | 563 | ||
561 | if (dwc->ep0_bounced) { | 564 | if (dwc->ep0_bounced) { |
565 | unsigned transfer_size = ur->length; | ||
566 | unsigned maxp = ep0->endpoint.maxpacket; | ||
567 | |||
568 | transfer_size += (maxp - (transfer_size % maxp)); | ||
562 | transferred = min_t(u32, ur->length, | 569 | transferred = min_t(u32, ur->length, |
563 | ep0->endpoint.maxpacket - length); | 570 | transfer_size - length); |
564 | memcpy(ur->buf, dwc->ep0_bounce, transferred); | 571 | memcpy(ur->buf, dwc->ep0_bounce, transferred); |
565 | dwc->ep0_bounced = false; | 572 | dwc->ep0_bounced = false; |
566 | } else { | 573 | } else { |
567 | transferred = ur->length - length; | 574 | transferred = ur->length - length; |
568 | ur->actual += transferred; | ||
569 | } | 575 | } |
570 | 576 | ||
577 | ur->actual += transferred; | ||
578 | |||
571 | if ((epnum & 1) && ur->actual < ur->length) { | 579 | if ((epnum & 1) && ur->actual < ur->length) { |
572 | /* for some reason we did not get everything out */ | 580 | /* for some reason we did not get everything out */ |
573 | 581 | ||
diff --git a/drivers/usb/gadget/at91_udc.c b/drivers/usb/gadget/at91_udc.c index 0c935d7c65bd..9d7bcd910074 100644 --- a/drivers/usb/gadget/at91_udc.c +++ b/drivers/usb/gadget/at91_udc.c | |||
@@ -1863,8 +1863,8 @@ static int __devinit at91udc_probe(struct platform_device *pdev) | |||
1863 | mod_timer(&udc->vbus_timer, | 1863 | mod_timer(&udc->vbus_timer, |
1864 | jiffies + VBUS_POLL_TIMEOUT); | 1864 | jiffies + VBUS_POLL_TIMEOUT); |
1865 | } else { | 1865 | } else { |
1866 | if (request_irq(udc->board.vbus_pin, at91_vbus_irq, | 1866 | if (request_irq(gpio_to_irq(udc->board.vbus_pin), |
1867 | 0, driver_name, udc)) { | 1867 | at91_vbus_irq, 0, driver_name, udc)) { |
1868 | DBG("request vbus irq %d failed\n", | 1868 | DBG("request vbus irq %d failed\n", |
1869 | udc->board.vbus_pin); | 1869 | udc->board.vbus_pin); |
1870 | retval = -EBUSY; | 1870 | retval = -EBUSY; |
@@ -1886,7 +1886,7 @@ static int __devinit at91udc_probe(struct platform_device *pdev) | |||
1886 | return 0; | 1886 | return 0; |
1887 | fail4: | 1887 | fail4: |
1888 | if (gpio_is_valid(udc->board.vbus_pin) && !udc->board.vbus_polled) | 1888 | if (gpio_is_valid(udc->board.vbus_pin) && !udc->board.vbus_polled) |
1889 | free_irq(udc->board.vbus_pin, udc); | 1889 | free_irq(gpio_to_irq(udc->board.vbus_pin), udc); |
1890 | fail3: | 1890 | fail3: |
1891 | if (gpio_is_valid(udc->board.vbus_pin)) | 1891 | if (gpio_is_valid(udc->board.vbus_pin)) |
1892 | gpio_free(udc->board.vbus_pin); | 1892 | gpio_free(udc->board.vbus_pin); |
@@ -1924,7 +1924,7 @@ static int __exit at91udc_remove(struct platform_device *pdev) | |||
1924 | device_init_wakeup(&pdev->dev, 0); | 1924 | device_init_wakeup(&pdev->dev, 0); |
1925 | remove_debug_file(udc); | 1925 | remove_debug_file(udc); |
1926 | if (gpio_is_valid(udc->board.vbus_pin)) { | 1926 | if (gpio_is_valid(udc->board.vbus_pin)) { |
1927 | free_irq(udc->board.vbus_pin, udc); | 1927 | free_irq(gpio_to_irq(udc->board.vbus_pin), udc); |
1928 | gpio_free(udc->board.vbus_pin); | 1928 | gpio_free(udc->board.vbus_pin); |
1929 | } | 1929 | } |
1930 | free_irq(udc->udp_irq, udc); | 1930 | free_irq(udc->udp_irq, udc); |
diff --git a/drivers/usb/gadget/dummy_hcd.c b/drivers/usb/gadget/dummy_hcd.c index a6dfd2164166..170cbe89d9f8 100644 --- a/drivers/usb/gadget/dummy_hcd.c +++ b/drivers/usb/gadget/dummy_hcd.c | |||
@@ -927,7 +927,6 @@ static int dummy_udc_stop(struct usb_gadget *g, | |||
927 | 927 | ||
928 | dum->driver = NULL; | 928 | dum->driver = NULL; |
929 | 929 | ||
930 | dummy_pullup(&dum->gadget, 0); | ||
931 | return 0; | 930 | return 0; |
932 | } | 931 | } |
933 | 932 | ||
diff --git a/drivers/usb/gadget/f_fs.c b/drivers/usb/gadget/f_fs.c index 1cbba70836bc..f52cb1ae45d9 100644 --- a/drivers/usb/gadget/f_fs.c +++ b/drivers/usb/gadget/f_fs.c | |||
@@ -712,7 +712,7 @@ static long ffs_ep0_ioctl(struct file *file, unsigned code, unsigned long value) | |||
712 | if (code == FUNCTIONFS_INTERFACE_REVMAP) { | 712 | if (code == FUNCTIONFS_INTERFACE_REVMAP) { |
713 | struct ffs_function *func = ffs->func; | 713 | struct ffs_function *func = ffs->func; |
714 | ret = func ? ffs_func_revmap_intf(func, value) : -ENODEV; | 714 | ret = func ? ffs_func_revmap_intf(func, value) : -ENODEV; |
715 | } else if (gadget->ops->ioctl) { | 715 | } else if (gadget && gadget->ops->ioctl) { |
716 | ret = gadget->ops->ioctl(gadget, code, value); | 716 | ret = gadget->ops->ioctl(gadget, code, value); |
717 | } else { | 717 | } else { |
718 | ret = -ENOTTY; | 718 | ret = -ENOTTY; |
@@ -1382,6 +1382,7 @@ static void functionfs_unbind(struct ffs_data *ffs) | |||
1382 | ffs->ep0req = NULL; | 1382 | ffs->ep0req = NULL; |
1383 | ffs->gadget = NULL; | 1383 | ffs->gadget = NULL; |
1384 | ffs_data_put(ffs); | 1384 | ffs_data_put(ffs); |
1385 | clear_bit(FFS_FL_BOUND, &ffs->flags); | ||
1385 | } | 1386 | } |
1386 | } | 1387 | } |
1387 | 1388 | ||
diff --git a/drivers/usb/gadget/f_mass_storage.c b/drivers/usb/gadget/f_mass_storage.c index a371e966425f..cb8c162cae5a 100644 --- a/drivers/usb/gadget/f_mass_storage.c +++ b/drivers/usb/gadget/f_mass_storage.c | |||
@@ -2189,7 +2189,7 @@ unknown_cmnd: | |||
2189 | common->data_size_from_cmnd = 0; | 2189 | common->data_size_from_cmnd = 0; |
2190 | sprintf(unknown, "Unknown x%02x", common->cmnd[0]); | 2190 | sprintf(unknown, "Unknown x%02x", common->cmnd[0]); |
2191 | reply = check_command(common, common->cmnd_size, | 2191 | reply = check_command(common, common->cmnd_size, |
2192 | DATA_DIR_UNKNOWN, 0xff, 0, unknown); | 2192 | DATA_DIR_UNKNOWN, ~0, 0, unknown); |
2193 | if (reply == 0) { | 2193 | if (reply == 0) { |
2194 | common->curlun->sense_data = SS_INVALID_COMMAND; | 2194 | common->curlun->sense_data = SS_INVALID_COMMAND; |
2195 | reply = -EINVAL; | 2195 | reply = -EINVAL; |
diff --git a/drivers/usb/gadget/f_rndis.c b/drivers/usb/gadget/f_rndis.c index 7b1cf18df5e3..52343654f5df 100644 --- a/drivers/usb/gadget/f_rndis.c +++ b/drivers/usb/gadget/f_rndis.c | |||
@@ -500,6 +500,7 @@ rndis_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl) | |||
500 | if (buf) { | 500 | if (buf) { |
501 | memcpy(req->buf, buf, n); | 501 | memcpy(req->buf, buf, n); |
502 | req->complete = rndis_response_complete; | 502 | req->complete = rndis_response_complete; |
503 | req->context = rndis; | ||
503 | rndis_free_response(rndis->config, buf); | 504 | rndis_free_response(rndis->config, buf); |
504 | value = n; | 505 | value = n; |
505 | } | 506 | } |
diff --git a/drivers/usb/gadget/file_storage.c b/drivers/usb/gadget/file_storage.c index 4fac56927741..a896d73f7a93 100644 --- a/drivers/usb/gadget/file_storage.c +++ b/drivers/usb/gadget/file_storage.c | |||
@@ -2579,7 +2579,7 @@ static int do_scsi_command(struct fsg_dev *fsg) | |||
2579 | fsg->data_size_from_cmnd = 0; | 2579 | fsg->data_size_from_cmnd = 0; |
2580 | sprintf(unknown, "Unknown x%02x", fsg->cmnd[0]); | 2580 | sprintf(unknown, "Unknown x%02x", fsg->cmnd[0]); |
2581 | if ((reply = check_command(fsg, fsg->cmnd_size, | 2581 | if ((reply = check_command(fsg, fsg->cmnd_size, |
2582 | DATA_DIR_UNKNOWN, 0xff, 0, unknown)) == 0) { | 2582 | DATA_DIR_UNKNOWN, ~0, 0, unknown)) == 0) { |
2583 | fsg->curlun->sense_data = SS_INVALID_COMMAND; | 2583 | fsg->curlun->sense_data = SS_INVALID_COMMAND; |
2584 | reply = -EINVAL; | 2584 | reply = -EINVAL; |
2585 | } | 2585 | } |
diff --git a/drivers/usb/gadget/fsl_udc_core.c b/drivers/usb/gadget/fsl_udc_core.c index 5f94e79cd6b9..55abfb6bd612 100644 --- a/drivers/usb/gadget/fsl_udc_core.c +++ b/drivers/usb/gadget/fsl_udc_core.c | |||
@@ -730,7 +730,7 @@ static void fsl_queue_td(struct fsl_ep *ep, struct fsl_req *req) | |||
730 | : (1 << (ep_index(ep))); | 730 | : (1 << (ep_index(ep))); |
731 | 731 | ||
732 | /* check if the pipe is empty */ | 732 | /* check if the pipe is empty */ |
733 | if (!(list_empty(&ep->queue))) { | 733 | if (!(list_empty(&ep->queue)) && !(ep_index(ep) == 0)) { |
734 | /* Add td to the end */ | 734 | /* Add td to the end */ |
735 | struct fsl_req *lastreq; | 735 | struct fsl_req *lastreq; |
736 | lastreq = list_entry(ep->queue.prev, struct fsl_req, queue); | 736 | lastreq = list_entry(ep->queue.prev, struct fsl_req, queue); |
@@ -918,10 +918,6 @@ fsl_ep_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags) | |||
918 | return -ENOMEM; | 918 | return -ENOMEM; |
919 | } | 919 | } |
920 | 920 | ||
921 | /* Update ep0 state */ | ||
922 | if ((ep_index(ep) == 0)) | ||
923 | udc->ep0_state = DATA_STATE_XMIT; | ||
924 | |||
925 | /* irq handler advances the queue */ | 921 | /* irq handler advances the queue */ |
926 | if (req != NULL) | 922 | if (req != NULL) |
927 | list_add_tail(&req->queue, &ep->queue); | 923 | list_add_tail(&req->queue, &ep->queue); |
@@ -1279,7 +1275,8 @@ static int ep0_prime_status(struct fsl_udc *udc, int direction) | |||
1279 | udc->ep0_dir = USB_DIR_OUT; | 1275 | udc->ep0_dir = USB_DIR_OUT; |
1280 | 1276 | ||
1281 | ep = &udc->eps[0]; | 1277 | ep = &udc->eps[0]; |
1282 | udc->ep0_state = WAIT_FOR_OUT_STATUS; | 1278 | if (udc->ep0_state != DATA_STATE_XMIT) |
1279 | udc->ep0_state = WAIT_FOR_OUT_STATUS; | ||
1283 | 1280 | ||
1284 | req->ep = ep; | 1281 | req->ep = ep; |
1285 | req->req.length = 0; | 1282 | req->req.length = 0; |
@@ -1384,6 +1381,9 @@ static void ch9getstatus(struct fsl_udc *udc, u8 request_type, u16 value, | |||
1384 | 1381 | ||
1385 | list_add_tail(&req->queue, &ep->queue); | 1382 | list_add_tail(&req->queue, &ep->queue); |
1386 | udc->ep0_state = DATA_STATE_XMIT; | 1383 | udc->ep0_state = DATA_STATE_XMIT; |
1384 | if (ep0_prime_status(udc, EP_DIR_OUT)) | ||
1385 | ep0stall(udc); | ||
1386 | |||
1387 | return; | 1387 | return; |
1388 | stall: | 1388 | stall: |
1389 | ep0stall(udc); | 1389 | ep0stall(udc); |
@@ -1492,6 +1492,14 @@ static void setup_received_irq(struct fsl_udc *udc, | |||
1492 | spin_lock(&udc->lock); | 1492 | spin_lock(&udc->lock); |
1493 | udc->ep0_state = (setup->bRequestType & USB_DIR_IN) | 1493 | udc->ep0_state = (setup->bRequestType & USB_DIR_IN) |
1494 | ? DATA_STATE_XMIT : DATA_STATE_RECV; | 1494 | ? DATA_STATE_XMIT : DATA_STATE_RECV; |
1495 | /* | ||
1496 | * If the data stage is IN, send status prime immediately. | ||
1497 | * See 2.0 Spec chapter 8.5.3.3 for detail. | ||
1498 | */ | ||
1499 | if (udc->ep0_state == DATA_STATE_XMIT) | ||
1500 | if (ep0_prime_status(udc, EP_DIR_OUT)) | ||
1501 | ep0stall(udc); | ||
1502 | |||
1495 | } else { | 1503 | } else { |
1496 | /* No data phase, IN status from gadget */ | 1504 | /* No data phase, IN status from gadget */ |
1497 | udc->ep0_dir = USB_DIR_IN; | 1505 | udc->ep0_dir = USB_DIR_IN; |
@@ -1520,9 +1528,8 @@ static void ep0_req_complete(struct fsl_udc *udc, struct fsl_ep *ep0, | |||
1520 | 1528 | ||
1521 | switch (udc->ep0_state) { | 1529 | switch (udc->ep0_state) { |
1522 | case DATA_STATE_XMIT: | 1530 | case DATA_STATE_XMIT: |
1523 | /* receive status phase */ | 1531 | /* already primed at setup_received_irq */ |
1524 | if (ep0_prime_status(udc, EP_DIR_OUT)) | 1532 | udc->ep0_state = WAIT_FOR_OUT_STATUS; |
1525 | ep0stall(udc); | ||
1526 | break; | 1533 | break; |
1527 | case DATA_STATE_RECV: | 1534 | case DATA_STATE_RECV: |
1528 | /* send status phase */ | 1535 | /* send status phase */ |
diff --git a/drivers/usb/gadget/g_ffs.c b/drivers/usb/gadget/g_ffs.c index 331cd6729d3c..a85eaf40b948 100644 --- a/drivers/usb/gadget/g_ffs.c +++ b/drivers/usb/gadget/g_ffs.c | |||
@@ -161,7 +161,7 @@ static struct usb_composite_driver gfs_driver = { | |||
161 | static struct ffs_data *gfs_ffs_data; | 161 | static struct ffs_data *gfs_ffs_data; |
162 | static unsigned long gfs_registered; | 162 | static unsigned long gfs_registered; |
163 | 163 | ||
164 | static int gfs_init(void) | 164 | static int __init gfs_init(void) |
165 | { | 165 | { |
166 | ENTER(); | 166 | ENTER(); |
167 | 167 | ||
@@ -169,7 +169,7 @@ static int gfs_init(void) | |||
169 | } | 169 | } |
170 | module_init(gfs_init); | 170 | module_init(gfs_init); |
171 | 171 | ||
172 | static void gfs_exit(void) | 172 | static void __exit gfs_exit(void) |
173 | { | 173 | { |
174 | ENTER(); | 174 | ENTER(); |
175 | 175 | ||
diff --git a/drivers/usb/gadget/s3c-hsotg.c b/drivers/usb/gadget/s3c-hsotg.c index 69295ba9d99a..105b206cd844 100644 --- a/drivers/usb/gadget/s3c-hsotg.c +++ b/drivers/usb/gadget/s3c-hsotg.c | |||
@@ -340,7 +340,7 @@ static void s3c_hsotg_init_fifo(struct s3c_hsotg *hsotg) | |||
340 | /* currently we allocate TX FIFOs for all possible endpoints, | 340 | /* currently we allocate TX FIFOs for all possible endpoints, |
341 | * and assume that they are all the same size. */ | 341 | * and assume that they are all the same size. */ |
342 | 342 | ||
343 | for (ep = 0; ep <= 15; ep++) { | 343 | for (ep = 1; ep <= 15; ep++) { |
344 | val = addr; | 344 | val = addr; |
345 | val |= size << S3C_DPTXFSIZn_DPTxFSize_SHIFT; | 345 | val |= size << S3C_DPTXFSIZn_DPTxFSize_SHIFT; |
346 | addr += size; | 346 | addr += size; |
@@ -741,7 +741,7 @@ static void s3c_hsotg_start_req(struct s3c_hsotg *hsotg, | |||
741 | /* write size / packets */ | 741 | /* write size / packets */ |
742 | writel(epsize, hsotg->regs + epsize_reg); | 742 | writel(epsize, hsotg->regs + epsize_reg); |
743 | 743 | ||
744 | if (using_dma(hsotg)) { | 744 | if (using_dma(hsotg) && !continuing) { |
745 | unsigned int dma_reg; | 745 | unsigned int dma_reg; |
746 | 746 | ||
747 | /* write DMA address to control register, buffer already | 747 | /* write DMA address to control register, buffer already |
@@ -1696,10 +1696,12 @@ static void s3c_hsotg_set_ep_maxpacket(struct s3c_hsotg *hsotg, | |||
1696 | reg |= mpsval; | 1696 | reg |= mpsval; |
1697 | writel(reg, regs + S3C_DIEPCTL(ep)); | 1697 | writel(reg, regs + S3C_DIEPCTL(ep)); |
1698 | 1698 | ||
1699 | reg = readl(regs + S3C_DOEPCTL(ep)); | 1699 | if (ep) { |
1700 | reg &= ~S3C_DxEPCTL_MPS_MASK; | 1700 | reg = readl(regs + S3C_DOEPCTL(ep)); |
1701 | reg |= mpsval; | 1701 | reg &= ~S3C_DxEPCTL_MPS_MASK; |
1702 | writel(reg, regs + S3C_DOEPCTL(ep)); | 1702 | reg |= mpsval; |
1703 | writel(reg, regs + S3C_DOEPCTL(ep)); | ||
1704 | } | ||
1703 | 1705 | ||
1704 | return; | 1706 | return; |
1705 | 1707 | ||
@@ -1919,7 +1921,8 @@ static void s3c_hsotg_epint(struct s3c_hsotg *hsotg, unsigned int idx, | |||
1919 | ints & S3C_DIEPMSK_TxFIFOEmpty) { | 1921 | ints & S3C_DIEPMSK_TxFIFOEmpty) { |
1920 | dev_dbg(hsotg->dev, "%s: ep%d: TxFIFOEmpty\n", | 1922 | dev_dbg(hsotg->dev, "%s: ep%d: TxFIFOEmpty\n", |
1921 | __func__, idx); | 1923 | __func__, idx); |
1922 | s3c_hsotg_trytx(hsotg, hs_ep); | 1924 | if (!using_dma(hsotg)) |
1925 | s3c_hsotg_trytx(hsotg, hs_ep); | ||
1923 | } | 1926 | } |
1924 | } | 1927 | } |
1925 | } | 1928 | } |
diff --git a/drivers/usb/gadget/udc-core.c b/drivers/usb/gadget/udc-core.c index 56da49f31d6c..e5e44f8cde9a 100644 --- a/drivers/usb/gadget/udc-core.c +++ b/drivers/usb/gadget/udc-core.c | |||
@@ -263,9 +263,9 @@ static void usb_gadget_remove_driver(struct usb_udc *udc) | |||
263 | 263 | ||
264 | if (udc_is_newstyle(udc)) { | 264 | if (udc_is_newstyle(udc)) { |
265 | udc->driver->disconnect(udc->gadget); | 265 | udc->driver->disconnect(udc->gadget); |
266 | usb_gadget_disconnect(udc->gadget); | ||
266 | udc->driver->unbind(udc->gadget); | 267 | udc->driver->unbind(udc->gadget); |
267 | usb_gadget_udc_stop(udc->gadget, udc->driver); | 268 | usb_gadget_udc_stop(udc->gadget, udc->driver); |
268 | usb_gadget_disconnect(udc->gadget); | ||
269 | } else { | 269 | } else { |
270 | usb_gadget_stop(udc->gadget, udc->driver); | 270 | usb_gadget_stop(udc->gadget, udc->driver); |
271 | } | 271 | } |
@@ -411,9 +411,13 @@ static ssize_t usb_udc_softconn_store(struct device *dev, | |||
411 | struct usb_udc *udc = container_of(dev, struct usb_udc, dev); | 411 | struct usb_udc *udc = container_of(dev, struct usb_udc, dev); |
412 | 412 | ||
413 | if (sysfs_streq(buf, "connect")) { | 413 | if (sysfs_streq(buf, "connect")) { |
414 | if (udc_is_newstyle(udc)) | ||
415 | usb_gadget_udc_start(udc->gadget, udc->driver); | ||
414 | usb_gadget_connect(udc->gadget); | 416 | usb_gadget_connect(udc->gadget); |
415 | } else if (sysfs_streq(buf, "disconnect")) { | 417 | } else if (sysfs_streq(buf, "disconnect")) { |
416 | usb_gadget_disconnect(udc->gadget); | 418 | usb_gadget_disconnect(udc->gadget); |
419 | if (udc_is_newstyle(udc)) | ||
420 | usb_gadget_udc_stop(udc->gadget, udc->driver); | ||
417 | } else { | 421 | } else { |
418 | dev_err(dev, "unsupported command '%s'\n", buf); | 422 | dev_err(dev, "unsupported command '%s'\n", buf); |
419 | return -EINVAL; | 423 | return -EINVAL; |
diff --git a/drivers/usb/gadget/uvc.h b/drivers/usb/gadget/uvc.h index bc78c606c12b..ca4e03a1c73a 100644 --- a/drivers/usb/gadget/uvc.h +++ b/drivers/usb/gadget/uvc.h | |||
@@ -28,7 +28,7 @@ | |||
28 | 28 | ||
29 | struct uvc_request_data | 29 | struct uvc_request_data |
30 | { | 30 | { |
31 | unsigned int length; | 31 | __s32 length; |
32 | __u8 data[60]; | 32 | __u8 data[60]; |
33 | }; | 33 | }; |
34 | 34 | ||
diff --git a/drivers/usb/gadget/uvc_queue.c b/drivers/usb/gadget/uvc_queue.c index d776adb2da67..0cdf89d32a15 100644 --- a/drivers/usb/gadget/uvc_queue.c +++ b/drivers/usb/gadget/uvc_queue.c | |||
@@ -543,11 +543,11 @@ done: | |||
543 | return ret; | 543 | return ret; |
544 | } | 544 | } |
545 | 545 | ||
546 | /* called with queue->irqlock held.. */ | ||
546 | static struct uvc_buffer * | 547 | static struct uvc_buffer * |
547 | uvc_queue_next_buffer(struct uvc_video_queue *queue, struct uvc_buffer *buf) | 548 | uvc_queue_next_buffer(struct uvc_video_queue *queue, struct uvc_buffer *buf) |
548 | { | 549 | { |
549 | struct uvc_buffer *nextbuf; | 550 | struct uvc_buffer *nextbuf; |
550 | unsigned long flags; | ||
551 | 551 | ||
552 | if ((queue->flags & UVC_QUEUE_DROP_INCOMPLETE) && | 552 | if ((queue->flags & UVC_QUEUE_DROP_INCOMPLETE) && |
553 | buf->buf.length != buf->buf.bytesused) { | 553 | buf->buf.length != buf->buf.bytesused) { |
@@ -556,14 +556,12 @@ uvc_queue_next_buffer(struct uvc_video_queue *queue, struct uvc_buffer *buf) | |||
556 | return buf; | 556 | return buf; |
557 | } | 557 | } |
558 | 558 | ||
559 | spin_lock_irqsave(&queue->irqlock, flags); | ||
560 | list_del(&buf->queue); | 559 | list_del(&buf->queue); |
561 | if (!list_empty(&queue->irqqueue)) | 560 | if (!list_empty(&queue->irqqueue)) |
562 | nextbuf = list_first_entry(&queue->irqqueue, struct uvc_buffer, | 561 | nextbuf = list_first_entry(&queue->irqqueue, struct uvc_buffer, |
563 | queue); | 562 | queue); |
564 | else | 563 | else |
565 | nextbuf = NULL; | 564 | nextbuf = NULL; |
566 | spin_unlock_irqrestore(&queue->irqlock, flags); | ||
567 | 565 | ||
568 | buf->buf.sequence = queue->sequence++; | 566 | buf->buf.sequence = queue->sequence++; |
569 | do_gettimeofday(&buf->buf.timestamp); | 567 | do_gettimeofday(&buf->buf.timestamp); |
diff --git a/drivers/usb/gadget/uvc_v4l2.c b/drivers/usb/gadget/uvc_v4l2.c index f6e083b50191..54d7ca559cb2 100644 --- a/drivers/usb/gadget/uvc_v4l2.c +++ b/drivers/usb/gadget/uvc_v4l2.c | |||
@@ -39,7 +39,7 @@ uvc_send_response(struct uvc_device *uvc, struct uvc_request_data *data) | |||
39 | if (data->length < 0) | 39 | if (data->length < 0) |
40 | return usb_ep_set_halt(cdev->gadget->ep0); | 40 | return usb_ep_set_halt(cdev->gadget->ep0); |
41 | 41 | ||
42 | req->length = min(uvc->event_length, data->length); | 42 | req->length = min_t(unsigned int, uvc->event_length, data->length); |
43 | req->zero = data->length < uvc->event_length; | 43 | req->zero = data->length < uvc->event_length; |
44 | req->dma = DMA_ADDR_INVALID; | 44 | req->dma = DMA_ADDR_INVALID; |
45 | 45 | ||
diff --git a/drivers/usb/host/ehci-fsl.c b/drivers/usb/host/ehci-fsl.c index 3e7345172e03..d0a84bd3f3eb 100644 --- a/drivers/usb/host/ehci-fsl.c +++ b/drivers/usb/host/ehci-fsl.c | |||
@@ -218,6 +218,9 @@ static void ehci_fsl_setup_phy(struct ehci_hcd *ehci, | |||
218 | u32 portsc; | 218 | u32 portsc; |
219 | struct usb_hcd *hcd = ehci_to_hcd(ehci); | 219 | struct usb_hcd *hcd = ehci_to_hcd(ehci); |
220 | void __iomem *non_ehci = hcd->regs; | 220 | void __iomem *non_ehci = hcd->regs; |
221 | struct fsl_usb2_platform_data *pdata; | ||
222 | |||
223 | pdata = hcd->self.controller->platform_data; | ||
221 | 224 | ||
222 | portsc = ehci_readl(ehci, &ehci->regs->port_status[port_offset]); | 225 | portsc = ehci_readl(ehci, &ehci->regs->port_status[port_offset]); |
223 | portsc &= ~(PORT_PTS_MSK | PORT_PTS_PTW); | 226 | portsc &= ~(PORT_PTS_MSK | PORT_PTS_PTW); |
@@ -234,7 +237,9 @@ static void ehci_fsl_setup_phy(struct ehci_hcd *ehci, | |||
234 | /* fall through */ | 237 | /* fall through */ |
235 | case FSL_USB2_PHY_UTMI: | 238 | case FSL_USB2_PHY_UTMI: |
236 | /* enable UTMI PHY */ | 239 | /* enable UTMI PHY */ |
237 | setbits32(non_ehci + FSL_SOC_USB_CTRL, CTRL_UTMI_PHY_EN); | 240 | if (pdata->have_sysif_regs) |
241 | setbits32(non_ehci + FSL_SOC_USB_CTRL, | ||
242 | CTRL_UTMI_PHY_EN); | ||
238 | portsc |= PORT_PTS_UTMI; | 243 | portsc |= PORT_PTS_UTMI; |
239 | break; | 244 | break; |
240 | case FSL_USB2_PHY_NONE: | 245 | case FSL_USB2_PHY_NONE: |
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c index 806cc95317aa..4a3bc5b7a06f 100644 --- a/drivers/usb/host/ehci-hcd.c +++ b/drivers/usb/host/ehci-hcd.c | |||
@@ -858,8 +858,13 @@ static irqreturn_t ehci_irq (struct usb_hcd *hcd) | |||
858 | goto dead; | 858 | goto dead; |
859 | } | 859 | } |
860 | 860 | ||
861 | /* | ||
862 | * We don't use STS_FLR, but some controllers don't like it to | ||
863 | * remain on, so mask it out along with the other status bits. | ||
864 | */ | ||
865 | masked_status = status & (INTR_MASK | STS_FLR); | ||
866 | |||
861 | /* Shared IRQ? */ | 867 | /* Shared IRQ? */ |
862 | masked_status = status & INTR_MASK; | ||
863 | if (!masked_status || unlikely(ehci->rh_state == EHCI_RH_HALTED)) { | 868 | if (!masked_status || unlikely(ehci->rh_state == EHCI_RH_HALTED)) { |
864 | spin_unlock(&ehci->lock); | 869 | spin_unlock(&ehci->lock); |
865 | return IRQ_NONE; | 870 | return IRQ_NONE; |
@@ -910,7 +915,7 @@ static irqreturn_t ehci_irq (struct usb_hcd *hcd) | |||
910 | pcd_status = status; | 915 | pcd_status = status; |
911 | 916 | ||
912 | /* resume root hub? */ | 917 | /* resume root hub? */ |
913 | if (!(cmd & CMD_RUN)) | 918 | if (ehci->rh_state == EHCI_RH_SUSPENDED) |
914 | usb_hcd_resume_root_hub(hcd); | 919 | usb_hcd_resume_root_hub(hcd); |
915 | 920 | ||
916 | /* get per-port change detect bits */ | 921 | /* get per-port change detect bits */ |
diff --git a/drivers/usb/host/ehci-omap.c b/drivers/usb/host/ehci-omap.c index bba9850f32f0..5c78f9e71466 100644 --- a/drivers/usb/host/ehci-omap.c +++ b/drivers/usb/host/ehci-omap.c | |||
@@ -42,6 +42,7 @@ | |||
42 | #include <plat/usb.h> | 42 | #include <plat/usb.h> |
43 | #include <linux/regulator/consumer.h> | 43 | #include <linux/regulator/consumer.h> |
44 | #include <linux/pm_runtime.h> | 44 | #include <linux/pm_runtime.h> |
45 | #include <linux/gpio.h> | ||
45 | 46 | ||
46 | /* EHCI Register Set */ | 47 | /* EHCI Register Set */ |
47 | #define EHCI_INSNREG04 (0xA0) | 48 | #define EHCI_INSNREG04 (0xA0) |
@@ -191,6 +192,19 @@ static int ehci_hcd_omap_probe(struct platform_device *pdev) | |||
191 | } | 192 | } |
192 | } | 193 | } |
193 | 194 | ||
195 | if (pdata->phy_reset) { | ||
196 | if (gpio_is_valid(pdata->reset_gpio_port[0])) | ||
197 | gpio_request_one(pdata->reset_gpio_port[0], | ||
198 | GPIOF_OUT_INIT_LOW, "USB1 PHY reset"); | ||
199 | |||
200 | if (gpio_is_valid(pdata->reset_gpio_port[1])) | ||
201 | gpio_request_one(pdata->reset_gpio_port[1], | ||
202 | GPIOF_OUT_INIT_LOW, "USB2 PHY reset"); | ||
203 | |||
204 | /* Hold the PHY in RESET for enough time till DIR is high */ | ||
205 | udelay(10); | ||
206 | } | ||
207 | |||
194 | pm_runtime_enable(dev); | 208 | pm_runtime_enable(dev); |
195 | pm_runtime_get_sync(dev); | 209 | pm_runtime_get_sync(dev); |
196 | 210 | ||
@@ -237,6 +251,19 @@ static int ehci_hcd_omap_probe(struct platform_device *pdev) | |||
237 | /* root ports should always stay powered */ | 251 | /* root ports should always stay powered */ |
238 | ehci_port_power(omap_ehci, 1); | 252 | ehci_port_power(omap_ehci, 1); |
239 | 253 | ||
254 | if (pdata->phy_reset) { | ||
255 | /* Hold the PHY in RESET for enough time till | ||
256 | * PHY is settled and ready | ||
257 | */ | ||
258 | udelay(10); | ||
259 | |||
260 | if (gpio_is_valid(pdata->reset_gpio_port[0])) | ||
261 | gpio_set_value(pdata->reset_gpio_port[0], 1); | ||
262 | |||
263 | if (gpio_is_valid(pdata->reset_gpio_port[1])) | ||
264 | gpio_set_value(pdata->reset_gpio_port[1], 1); | ||
265 | } | ||
266 | |||
240 | return 0; | 267 | return 0; |
241 | 268 | ||
242 | err_add_hcd: | 269 | err_add_hcd: |
@@ -259,8 +286,9 @@ err_io: | |||
259 | */ | 286 | */ |
260 | static int ehci_hcd_omap_remove(struct platform_device *pdev) | 287 | static int ehci_hcd_omap_remove(struct platform_device *pdev) |
261 | { | 288 | { |
262 | struct device *dev = &pdev->dev; | 289 | struct device *dev = &pdev->dev; |
263 | struct usb_hcd *hcd = dev_get_drvdata(dev); | 290 | struct usb_hcd *hcd = dev_get_drvdata(dev); |
291 | struct ehci_hcd_omap_platform_data *pdata = dev->platform_data; | ||
264 | 292 | ||
265 | usb_remove_hcd(hcd); | 293 | usb_remove_hcd(hcd); |
266 | disable_put_regulator(dev->platform_data); | 294 | disable_put_regulator(dev->platform_data); |
@@ -269,6 +297,13 @@ static int ehci_hcd_omap_remove(struct platform_device *pdev) | |||
269 | pm_runtime_put_sync(dev); | 297 | pm_runtime_put_sync(dev); |
270 | pm_runtime_disable(dev); | 298 | pm_runtime_disable(dev); |
271 | 299 | ||
300 | if (pdata->phy_reset) { | ||
301 | if (gpio_is_valid(pdata->reset_gpio_port[0])) | ||
302 | gpio_free(pdata->reset_gpio_port[0]); | ||
303 | |||
304 | if (gpio_is_valid(pdata->reset_gpio_port[1])) | ||
305 | gpio_free(pdata->reset_gpio_port[1]); | ||
306 | } | ||
272 | return 0; | 307 | return 0; |
273 | } | 308 | } |
274 | 309 | ||
diff --git a/drivers/usb/host/ehci-pci.c b/drivers/usb/host/ehci-pci.c index 01bb7241d6ef..fe8dc069164e 100644 --- a/drivers/usb/host/ehci-pci.c +++ b/drivers/usb/host/ehci-pci.c | |||
@@ -144,6 +144,14 @@ static int ehci_pci_setup(struct usb_hcd *hcd) | |||
144 | hcd->has_tt = 1; | 144 | hcd->has_tt = 1; |
145 | tdi_reset(ehci); | 145 | tdi_reset(ehci); |
146 | } | 146 | } |
147 | if (pdev->subsystem_vendor == PCI_VENDOR_ID_ASUSTEK) { | ||
148 | /* EHCI #1 or #2 on 6 Series/C200 Series chipset */ | ||
149 | if (pdev->device == 0x1c26 || pdev->device == 0x1c2d) { | ||
150 | ehci_info(ehci, "broken D3 during system sleep on ASUS\n"); | ||
151 | hcd->broken_pci_sleep = 1; | ||
152 | device_set_wakeup_capable(&pdev->dev, false); | ||
153 | } | ||
154 | } | ||
147 | break; | 155 | break; |
148 | case PCI_VENDOR_ID_TDI: | 156 | case PCI_VENDOR_ID_TDI: |
149 | if (pdev->device == PCI_DEVICE_ID_TDI_EHCI) { | 157 | if (pdev->device == PCI_DEVICE_ID_TDI_EHCI) { |
diff --git a/drivers/usb/host/ehci-tegra.c b/drivers/usb/host/ehci-tegra.c index 73544bd440bd..f214a80cdee2 100644 --- a/drivers/usb/host/ehci-tegra.c +++ b/drivers/usb/host/ehci-tegra.c | |||
@@ -24,6 +24,7 @@ | |||
24 | #include <linux/gpio.h> | 24 | #include <linux/gpio.h> |
25 | #include <linux/of.h> | 25 | #include <linux/of.h> |
26 | #include <linux/of_gpio.h> | 26 | #include <linux/of_gpio.h> |
27 | #include <linux/pm_runtime.h> | ||
27 | 28 | ||
28 | #include <mach/usb_phy.h> | 29 | #include <mach/usb_phy.h> |
29 | #include <mach/iomap.h> | 30 | #include <mach/iomap.h> |
@@ -37,9 +38,7 @@ struct tegra_ehci_hcd { | |||
37 | struct clk *emc_clk; | 38 | struct clk *emc_clk; |
38 | struct usb_phy *transceiver; | 39 | struct usb_phy *transceiver; |
39 | int host_resumed; | 40 | int host_resumed; |
40 | int bus_suspended; | ||
41 | int port_resuming; | 41 | int port_resuming; |
42 | int power_down_on_bus_suspend; | ||
43 | enum tegra_usb_phy_port_speed port_speed; | 42 | enum tegra_usb_phy_port_speed port_speed; |
44 | }; | 43 | }; |
45 | 44 | ||
@@ -273,120 +272,6 @@ static void tegra_ehci_restart(struct usb_hcd *hcd) | |||
273 | up_write(&ehci_cf_port_reset_rwsem); | 272 | up_write(&ehci_cf_port_reset_rwsem); |
274 | } | 273 | } |
275 | 274 | ||
276 | static int tegra_usb_suspend(struct usb_hcd *hcd) | ||
277 | { | ||
278 | struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller); | ||
279 | struct ehci_regs __iomem *hw = tegra->ehci->regs; | ||
280 | unsigned long flags; | ||
281 | |||
282 | spin_lock_irqsave(&tegra->ehci->lock, flags); | ||
283 | |||
284 | tegra->port_speed = (readl(&hw->port_status[0]) >> 26) & 0x3; | ||
285 | ehci_halt(tegra->ehci); | ||
286 | clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags); | ||
287 | |||
288 | spin_unlock_irqrestore(&tegra->ehci->lock, flags); | ||
289 | |||
290 | tegra_ehci_power_down(hcd); | ||
291 | return 0; | ||
292 | } | ||
293 | |||
294 | static int tegra_usb_resume(struct usb_hcd *hcd) | ||
295 | { | ||
296 | struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller); | ||
297 | struct ehci_hcd *ehci = hcd_to_ehci(hcd); | ||
298 | struct ehci_regs __iomem *hw = ehci->regs; | ||
299 | unsigned long val; | ||
300 | |||
301 | set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags); | ||
302 | tegra_ehci_power_up(hcd); | ||
303 | |||
304 | if (tegra->port_speed > TEGRA_USB_PHY_PORT_SPEED_HIGH) { | ||
305 | /* Wait for the phy to detect new devices | ||
306 | * before we restart the controller */ | ||
307 | msleep(10); | ||
308 | goto restart; | ||
309 | } | ||
310 | |||
311 | /* Force the phy to keep data lines in suspend state */ | ||
312 | tegra_ehci_phy_restore_start(tegra->phy, tegra->port_speed); | ||
313 | |||
314 | /* Enable host mode */ | ||
315 | tdi_reset(ehci); | ||
316 | |||
317 | /* Enable Port Power */ | ||
318 | val = readl(&hw->port_status[0]); | ||
319 | val |= PORT_POWER; | ||
320 | writel(val, &hw->port_status[0]); | ||
321 | udelay(10); | ||
322 | |||
323 | /* Check if the phy resume from LP0. When the phy resume from LP0 | ||
324 | * USB register will be reset. */ | ||
325 | if (!readl(&hw->async_next)) { | ||
326 | /* Program the field PTC based on the saved speed mode */ | ||
327 | val = readl(&hw->port_status[0]); | ||
328 | val &= ~PORT_TEST(~0); | ||
329 | if (tegra->port_speed == TEGRA_USB_PHY_PORT_SPEED_HIGH) | ||
330 | val |= PORT_TEST_FORCE; | ||
331 | else if (tegra->port_speed == TEGRA_USB_PHY_PORT_SPEED_FULL) | ||
332 | val |= PORT_TEST(6); | ||
333 | else if (tegra->port_speed == TEGRA_USB_PHY_PORT_SPEED_LOW) | ||
334 | val |= PORT_TEST(7); | ||
335 | writel(val, &hw->port_status[0]); | ||
336 | udelay(10); | ||
337 | |||
338 | /* Disable test mode by setting PTC field to NORMAL_OP */ | ||
339 | val = readl(&hw->port_status[0]); | ||
340 | val &= ~PORT_TEST(~0); | ||
341 | writel(val, &hw->port_status[0]); | ||
342 | udelay(10); | ||
343 | } | ||
344 | |||
345 | /* Poll until CCS is enabled */ | ||
346 | if (handshake(ehci, &hw->port_status[0], PORT_CONNECT, | ||
347 | PORT_CONNECT, 2000)) { | ||
348 | pr_err("%s: timeout waiting for PORT_CONNECT\n", __func__); | ||
349 | goto restart; | ||
350 | } | ||
351 | |||
352 | /* Poll until PE is enabled */ | ||
353 | if (handshake(ehci, &hw->port_status[0], PORT_PE, | ||
354 | PORT_PE, 2000)) { | ||
355 | pr_err("%s: timeout waiting for USB_PORTSC1_PE\n", __func__); | ||
356 | goto restart; | ||
357 | } | ||
358 | |||
359 | /* Clear the PCI status, to avoid an interrupt taken upon resume */ | ||
360 | val = readl(&hw->status); | ||
361 | val |= STS_PCD; | ||
362 | writel(val, &hw->status); | ||
363 | |||
364 | /* Put controller in suspend mode by writing 1 to SUSP bit of PORTSC */ | ||
365 | val = readl(&hw->port_status[0]); | ||
366 | if ((val & PORT_POWER) && (val & PORT_PE)) { | ||
367 | val |= PORT_SUSPEND; | ||
368 | writel(val, &hw->port_status[0]); | ||
369 | |||
370 | /* Wait until port suspend completes */ | ||
371 | if (handshake(ehci, &hw->port_status[0], PORT_SUSPEND, | ||
372 | PORT_SUSPEND, 1000)) { | ||
373 | pr_err("%s: timeout waiting for PORT_SUSPEND\n", | ||
374 | __func__); | ||
375 | goto restart; | ||
376 | } | ||
377 | } | ||
378 | |||
379 | tegra_ehci_phy_restore_end(tegra->phy); | ||
380 | return 0; | ||
381 | |||
382 | restart: | ||
383 | if (tegra->port_speed <= TEGRA_USB_PHY_PORT_SPEED_HIGH) | ||
384 | tegra_ehci_phy_restore_end(tegra->phy); | ||
385 | |||
386 | tegra_ehci_restart(hcd); | ||
387 | return 0; | ||
388 | } | ||
389 | |||
390 | static void tegra_ehci_shutdown(struct usb_hcd *hcd) | 275 | static void tegra_ehci_shutdown(struct usb_hcd *hcd) |
391 | { | 276 | { |
392 | struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller); | 277 | struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller); |
@@ -434,36 +319,6 @@ static int tegra_ehci_setup(struct usb_hcd *hcd) | |||
434 | return retval; | 319 | return retval; |
435 | } | 320 | } |
436 | 321 | ||
437 | #ifdef CONFIG_PM | ||
438 | static int tegra_ehci_bus_suspend(struct usb_hcd *hcd) | ||
439 | { | ||
440 | struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller); | ||
441 | int error_status = 0; | ||
442 | |||
443 | error_status = ehci_bus_suspend(hcd); | ||
444 | if (!error_status && tegra->power_down_on_bus_suspend) { | ||
445 | tegra_usb_suspend(hcd); | ||
446 | tegra->bus_suspended = 1; | ||
447 | } | ||
448 | |||
449 | return error_status; | ||
450 | } | ||
451 | |||
452 | static int tegra_ehci_bus_resume(struct usb_hcd *hcd) | ||
453 | { | ||
454 | struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller); | ||
455 | |||
456 | if (tegra->bus_suspended && tegra->power_down_on_bus_suspend) { | ||
457 | tegra_usb_resume(hcd); | ||
458 | tegra->bus_suspended = 0; | ||
459 | } | ||
460 | |||
461 | tegra_usb_phy_preresume(tegra->phy); | ||
462 | tegra->port_resuming = 1; | ||
463 | return ehci_bus_resume(hcd); | ||
464 | } | ||
465 | #endif | ||
466 | |||
467 | struct temp_buffer { | 322 | struct temp_buffer { |
468 | void *kmalloc_ptr; | 323 | void *kmalloc_ptr; |
469 | void *old_xfer_buffer; | 324 | void *old_xfer_buffer; |
@@ -574,8 +429,8 @@ static const struct hc_driver tegra_ehci_hc_driver = { | |||
574 | .hub_control = tegra_ehci_hub_control, | 429 | .hub_control = tegra_ehci_hub_control, |
575 | .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete, | 430 | .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete, |
576 | #ifdef CONFIG_PM | 431 | #ifdef CONFIG_PM |
577 | .bus_suspend = tegra_ehci_bus_suspend, | 432 | .bus_suspend = ehci_bus_suspend, |
578 | .bus_resume = tegra_ehci_bus_resume, | 433 | .bus_resume = ehci_bus_resume, |
579 | #endif | 434 | #endif |
580 | .relinquish_port = ehci_relinquish_port, | 435 | .relinquish_port = ehci_relinquish_port, |
581 | .port_handed_over = ehci_port_handed_over, | 436 | .port_handed_over = ehci_port_handed_over, |
@@ -603,11 +458,187 @@ static int setup_vbus_gpio(struct platform_device *pdev) | |||
603 | dev_err(&pdev->dev, "can't enable vbus\n"); | 458 | dev_err(&pdev->dev, "can't enable vbus\n"); |
604 | return err; | 459 | return err; |
605 | } | 460 | } |
606 | gpio_set_value(gpio, 1); | ||
607 | 461 | ||
608 | return err; | 462 | return err; |
609 | } | 463 | } |
610 | 464 | ||
465 | #ifdef CONFIG_PM | ||
466 | |||
467 | static int controller_suspend(struct device *dev) | ||
468 | { | ||
469 | struct tegra_ehci_hcd *tegra = | ||
470 | platform_get_drvdata(to_platform_device(dev)); | ||
471 | struct ehci_hcd *ehci = tegra->ehci; | ||
472 | struct usb_hcd *hcd = ehci_to_hcd(ehci); | ||
473 | struct ehci_regs __iomem *hw = ehci->regs; | ||
474 | unsigned long flags; | ||
475 | |||
476 | if (time_before(jiffies, ehci->next_statechange)) | ||
477 | msleep(10); | ||
478 | |||
479 | spin_lock_irqsave(&ehci->lock, flags); | ||
480 | |||
481 | tegra->port_speed = (readl(&hw->port_status[0]) >> 26) & 0x3; | ||
482 | ehci_halt(ehci); | ||
483 | clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags); | ||
484 | |||
485 | spin_unlock_irqrestore(&ehci->lock, flags); | ||
486 | |||
487 | tegra_ehci_power_down(hcd); | ||
488 | return 0; | ||
489 | } | ||
490 | |||
491 | static int controller_resume(struct device *dev) | ||
492 | { | ||
493 | struct tegra_ehci_hcd *tegra = | ||
494 | platform_get_drvdata(to_platform_device(dev)); | ||
495 | struct ehci_hcd *ehci = tegra->ehci; | ||
496 | struct usb_hcd *hcd = ehci_to_hcd(ehci); | ||
497 | struct ehci_regs __iomem *hw = ehci->regs; | ||
498 | unsigned long val; | ||
499 | |||
500 | set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags); | ||
501 | tegra_ehci_power_up(hcd); | ||
502 | |||
503 | if (tegra->port_speed > TEGRA_USB_PHY_PORT_SPEED_HIGH) { | ||
504 | /* Wait for the phy to detect new devices | ||
505 | * before we restart the controller */ | ||
506 | msleep(10); | ||
507 | goto restart; | ||
508 | } | ||
509 | |||
510 | /* Force the phy to keep data lines in suspend state */ | ||
511 | tegra_ehci_phy_restore_start(tegra->phy, tegra->port_speed); | ||
512 | |||
513 | /* Enable host mode */ | ||
514 | tdi_reset(ehci); | ||
515 | |||
516 | /* Enable Port Power */ | ||
517 | val = readl(&hw->port_status[0]); | ||
518 | val |= PORT_POWER; | ||
519 | writel(val, &hw->port_status[0]); | ||
520 | udelay(10); | ||
521 | |||
522 | /* Check if the phy resume from LP0. When the phy resume from LP0 | ||
523 | * USB register will be reset. */ | ||
524 | if (!readl(&hw->async_next)) { | ||
525 | /* Program the field PTC based on the saved speed mode */ | ||
526 | val = readl(&hw->port_status[0]); | ||
527 | val &= ~PORT_TEST(~0); | ||
528 | if (tegra->port_speed == TEGRA_USB_PHY_PORT_SPEED_HIGH) | ||
529 | val |= PORT_TEST_FORCE; | ||
530 | else if (tegra->port_speed == TEGRA_USB_PHY_PORT_SPEED_FULL) | ||
531 | val |= PORT_TEST(6); | ||
532 | else if (tegra->port_speed == TEGRA_USB_PHY_PORT_SPEED_LOW) | ||
533 | val |= PORT_TEST(7); | ||
534 | writel(val, &hw->port_status[0]); | ||
535 | udelay(10); | ||
536 | |||
537 | /* Disable test mode by setting PTC field to NORMAL_OP */ | ||
538 | val = readl(&hw->port_status[0]); | ||
539 | val &= ~PORT_TEST(~0); | ||
540 | writel(val, &hw->port_status[0]); | ||
541 | udelay(10); | ||
542 | } | ||
543 | |||
544 | /* Poll until CCS is enabled */ | ||
545 | if (handshake(ehci, &hw->port_status[0], PORT_CONNECT, | ||
546 | PORT_CONNECT, 2000)) { | ||
547 | pr_err("%s: timeout waiting for PORT_CONNECT\n", __func__); | ||
548 | goto restart; | ||
549 | } | ||
550 | |||
551 | /* Poll until PE is enabled */ | ||
552 | if (handshake(ehci, &hw->port_status[0], PORT_PE, | ||
553 | PORT_PE, 2000)) { | ||
554 | pr_err("%s: timeout waiting for USB_PORTSC1_PE\n", __func__); | ||
555 | goto restart; | ||
556 | } | ||
557 | |||
558 | /* Clear the PCI status, to avoid an interrupt taken upon resume */ | ||
559 | val = readl(&hw->status); | ||
560 | val |= STS_PCD; | ||
561 | writel(val, &hw->status); | ||
562 | |||
563 | /* Put controller in suspend mode by writing 1 to SUSP bit of PORTSC */ | ||
564 | val = readl(&hw->port_status[0]); | ||
565 | if ((val & PORT_POWER) && (val & PORT_PE)) { | ||
566 | val |= PORT_SUSPEND; | ||
567 | writel(val, &hw->port_status[0]); | ||
568 | |||
569 | /* Wait until port suspend completes */ | ||
570 | if (handshake(ehci, &hw->port_status[0], PORT_SUSPEND, | ||
571 | PORT_SUSPEND, 1000)) { | ||
572 | pr_err("%s: timeout waiting for PORT_SUSPEND\n", | ||
573 | __func__); | ||
574 | goto restart; | ||
575 | } | ||
576 | } | ||
577 | |||
578 | tegra_ehci_phy_restore_end(tegra->phy); | ||
579 | goto done; | ||
580 | |||
581 | restart: | ||
582 | if (tegra->port_speed <= TEGRA_USB_PHY_PORT_SPEED_HIGH) | ||
583 | tegra_ehci_phy_restore_end(tegra->phy); | ||
584 | |||
585 | tegra_ehci_restart(hcd); | ||
586 | |||
587 | done: | ||
588 | tegra_usb_phy_preresume(tegra->phy); | ||
589 | tegra->port_resuming = 1; | ||
590 | return 0; | ||
591 | } | ||
592 | |||
593 | static int tegra_ehci_suspend(struct device *dev) | ||
594 | { | ||
595 | struct tegra_ehci_hcd *tegra = | ||
596 | platform_get_drvdata(to_platform_device(dev)); | ||
597 | struct usb_hcd *hcd = ehci_to_hcd(tegra->ehci); | ||
598 | int rc = 0; | ||
599 | |||
600 | /* | ||
601 | * When system sleep is supported and USB controller wakeup is | ||
602 | * implemented: If the controller is runtime-suspended and the | ||
603 | * wakeup setting needs to be changed, call pm_runtime_resume(). | ||
604 | */ | ||
605 | if (HCD_HW_ACCESSIBLE(hcd)) | ||
606 | rc = controller_suspend(dev); | ||
607 | return rc; | ||
608 | } | ||
609 | |||
610 | static int tegra_ehci_resume(struct device *dev) | ||
611 | { | ||
612 | int rc; | ||
613 | |||
614 | rc = controller_resume(dev); | ||
615 | if (rc == 0) { | ||
616 | pm_runtime_disable(dev); | ||
617 | pm_runtime_set_active(dev); | ||
618 | pm_runtime_enable(dev); | ||
619 | } | ||
620 | return rc; | ||
621 | } | ||
622 | |||
623 | static int tegra_ehci_runtime_suspend(struct device *dev) | ||
624 | { | ||
625 | return controller_suspend(dev); | ||
626 | } | ||
627 | |||
628 | static int tegra_ehci_runtime_resume(struct device *dev) | ||
629 | { | ||
630 | return controller_resume(dev); | ||
631 | } | ||
632 | |||
633 | static const struct dev_pm_ops tegra_ehci_pm_ops = { | ||
634 | .suspend = tegra_ehci_suspend, | ||
635 | .resume = tegra_ehci_resume, | ||
636 | .runtime_suspend = tegra_ehci_runtime_suspend, | ||
637 | .runtime_resume = tegra_ehci_runtime_resume, | ||
638 | }; | ||
639 | |||
640 | #endif | ||
641 | |||
611 | static u64 tegra_ehci_dma_mask = DMA_BIT_MASK(32); | 642 | static u64 tegra_ehci_dma_mask = DMA_BIT_MASK(32); |
612 | 643 | ||
613 | static int tegra_ehci_probe(struct platform_device *pdev) | 644 | static int tegra_ehci_probe(struct platform_device *pdev) |
@@ -722,7 +753,6 @@ static int tegra_ehci_probe(struct platform_device *pdev) | |||
722 | } | 753 | } |
723 | 754 | ||
724 | tegra->host_resumed = 1; | 755 | tegra->host_resumed = 1; |
725 | tegra->power_down_on_bus_suspend = pdata->power_down_on_bus_suspend; | ||
726 | tegra->ehci = hcd_to_ehci(hcd); | 756 | tegra->ehci = hcd_to_ehci(hcd); |
727 | 757 | ||
728 | irq = platform_get_irq(pdev, 0); | 758 | irq = platform_get_irq(pdev, 0); |
@@ -731,7 +761,6 @@ static int tegra_ehci_probe(struct platform_device *pdev) | |||
731 | err = -ENODEV; | 761 | err = -ENODEV; |
732 | goto fail; | 762 | goto fail; |
733 | } | 763 | } |
734 | set_irq_flags(irq, IRQF_VALID); | ||
735 | 764 | ||
736 | #ifdef CONFIG_USB_OTG_UTILS | 765 | #ifdef CONFIG_USB_OTG_UTILS |
737 | if (pdata->operating_mode == TEGRA_USB_OTG) { | 766 | if (pdata->operating_mode == TEGRA_USB_OTG) { |
@@ -747,6 +776,14 @@ static int tegra_ehci_probe(struct platform_device *pdev) | |||
747 | goto fail; | 776 | goto fail; |
748 | } | 777 | } |
749 | 778 | ||
779 | pm_runtime_set_active(&pdev->dev); | ||
780 | pm_runtime_get_noresume(&pdev->dev); | ||
781 | |||
782 | /* Don't skip the pm_runtime_forbid call if wakeup isn't working */ | ||
783 | /* if (!pdata->power_down_on_bus_suspend) */ | ||
784 | pm_runtime_forbid(&pdev->dev); | ||
785 | pm_runtime_enable(&pdev->dev); | ||
786 | pm_runtime_put_sync(&pdev->dev); | ||
750 | return err; | 787 | return err; |
751 | 788 | ||
752 | fail: | 789 | fail: |
@@ -773,33 +810,6 @@ fail_hcd: | |||
773 | return err; | 810 | return err; |
774 | } | 811 | } |
775 | 812 | ||
776 | #ifdef CONFIG_PM | ||
777 | static int tegra_ehci_resume(struct platform_device *pdev) | ||
778 | { | ||
779 | struct tegra_ehci_hcd *tegra = platform_get_drvdata(pdev); | ||
780 | struct usb_hcd *hcd = ehci_to_hcd(tegra->ehci); | ||
781 | |||
782 | if (tegra->bus_suspended) | ||
783 | return 0; | ||
784 | |||
785 | return tegra_usb_resume(hcd); | ||
786 | } | ||
787 | |||
788 | static int tegra_ehci_suspend(struct platform_device *pdev, pm_message_t state) | ||
789 | { | ||
790 | struct tegra_ehci_hcd *tegra = platform_get_drvdata(pdev); | ||
791 | struct usb_hcd *hcd = ehci_to_hcd(tegra->ehci); | ||
792 | |||
793 | if (tegra->bus_suspended) | ||
794 | return 0; | ||
795 | |||
796 | if (time_before(jiffies, tegra->ehci->next_statechange)) | ||
797 | msleep(10); | ||
798 | |||
799 | return tegra_usb_suspend(hcd); | ||
800 | } | ||
801 | #endif | ||
802 | |||
803 | static int tegra_ehci_remove(struct platform_device *pdev) | 813 | static int tegra_ehci_remove(struct platform_device *pdev) |
804 | { | 814 | { |
805 | struct tegra_ehci_hcd *tegra = platform_get_drvdata(pdev); | 815 | struct tegra_ehci_hcd *tegra = platform_get_drvdata(pdev); |
@@ -808,6 +818,10 @@ static int tegra_ehci_remove(struct platform_device *pdev) | |||
808 | if (tegra == NULL || hcd == NULL) | 818 | if (tegra == NULL || hcd == NULL) |
809 | return -EINVAL; | 819 | return -EINVAL; |
810 | 820 | ||
821 | pm_runtime_get_sync(&pdev->dev); | ||
822 | pm_runtime_disable(&pdev->dev); | ||
823 | pm_runtime_put_noidle(&pdev->dev); | ||
824 | |||
811 | #ifdef CONFIG_USB_OTG_UTILS | 825 | #ifdef CONFIG_USB_OTG_UTILS |
812 | if (tegra->transceiver) { | 826 | if (tegra->transceiver) { |
813 | otg_set_host(tegra->transceiver->otg, NULL); | 827 | otg_set_host(tegra->transceiver->otg, NULL); |
@@ -848,13 +862,12 @@ static struct of_device_id tegra_ehci_of_match[] __devinitdata = { | |||
848 | static struct platform_driver tegra_ehci_driver = { | 862 | static struct platform_driver tegra_ehci_driver = { |
849 | .probe = tegra_ehci_probe, | 863 | .probe = tegra_ehci_probe, |
850 | .remove = tegra_ehci_remove, | 864 | .remove = tegra_ehci_remove, |
851 | #ifdef CONFIG_PM | ||
852 | .suspend = tegra_ehci_suspend, | ||
853 | .resume = tegra_ehci_resume, | ||
854 | #endif | ||
855 | .shutdown = tegra_ehci_hcd_shutdown, | 865 | .shutdown = tegra_ehci_hcd_shutdown, |
856 | .driver = { | 866 | .driver = { |
857 | .name = "tegra-ehci", | 867 | .name = "tegra-ehci", |
858 | .of_match_table = tegra_ehci_of_match, | 868 | .of_match_table = tegra_ehci_of_match, |
869 | #ifdef CONFIG_PM | ||
870 | .pm = &tegra_ehci_pm_ops, | ||
871 | #endif | ||
859 | } | 872 | } |
860 | }; | 873 | }; |
diff --git a/drivers/usb/host/ohci-at91.c b/drivers/usb/host/ohci-at91.c index 09f597ad6e00..13ebeca8e73e 100644 --- a/drivers/usb/host/ohci-at91.c +++ b/drivers/usb/host/ohci-at91.c | |||
@@ -94,7 +94,7 @@ static void at91_stop_hc(struct platform_device *pdev) | |||
94 | 94 | ||
95 | /*-------------------------------------------------------------------------*/ | 95 | /*-------------------------------------------------------------------------*/ |
96 | 96 | ||
97 | static void usb_hcd_at91_remove (struct usb_hcd *, struct platform_device *); | 97 | static void __devexit usb_hcd_at91_remove (struct usb_hcd *, struct platform_device *); |
98 | 98 | ||
99 | /* configure so an HC device and id are always provided */ | 99 | /* configure so an HC device and id are always provided */ |
100 | /* always called with process context; sleeping is OK */ | 100 | /* always called with process context; sleeping is OK */ |
@@ -108,7 +108,7 @@ static void usb_hcd_at91_remove (struct usb_hcd *, struct platform_device *); | |||
108 | * then invokes the start() method for the HCD associated with it | 108 | * then invokes the start() method for the HCD associated with it |
109 | * through the hotplug entry's driver_data. | 109 | * through the hotplug entry's driver_data. |
110 | */ | 110 | */ |
111 | static int usb_hcd_at91_probe(const struct hc_driver *driver, | 111 | static int __devinit usb_hcd_at91_probe(const struct hc_driver *driver, |
112 | struct platform_device *pdev) | 112 | struct platform_device *pdev) |
113 | { | 113 | { |
114 | int retval; | 114 | int retval; |
@@ -203,7 +203,7 @@ static int usb_hcd_at91_probe(const struct hc_driver *driver, | |||
203 | * context, "rmmod" or something similar. | 203 | * context, "rmmod" or something similar. |
204 | * | 204 | * |
205 | */ | 205 | */ |
206 | static void usb_hcd_at91_remove(struct usb_hcd *hcd, | 206 | static void __devexit usb_hcd_at91_remove(struct usb_hcd *hcd, |
207 | struct platform_device *pdev) | 207 | struct platform_device *pdev) |
208 | { | 208 | { |
209 | usb_remove_hcd(hcd); | 209 | usb_remove_hcd(hcd); |
@@ -545,7 +545,7 @@ static int __devinit ohci_at91_of_init(struct platform_device *pdev) | |||
545 | 545 | ||
546 | /*-------------------------------------------------------------------------*/ | 546 | /*-------------------------------------------------------------------------*/ |
547 | 547 | ||
548 | static int ohci_hcd_at91_drv_probe(struct platform_device *pdev) | 548 | static int __devinit ohci_hcd_at91_drv_probe(struct platform_device *pdev) |
549 | { | 549 | { |
550 | struct at91_usbh_data *pdata; | 550 | struct at91_usbh_data *pdata; |
551 | int i; | 551 | int i; |
@@ -620,7 +620,7 @@ static int ohci_hcd_at91_drv_probe(struct platform_device *pdev) | |||
620 | return usb_hcd_at91_probe(&ohci_at91_hc_driver, pdev); | 620 | return usb_hcd_at91_probe(&ohci_at91_hc_driver, pdev); |
621 | } | 621 | } |
622 | 622 | ||
623 | static int ohci_hcd_at91_drv_remove(struct platform_device *pdev) | 623 | static int __devexit ohci_hcd_at91_drv_remove(struct platform_device *pdev) |
624 | { | 624 | { |
625 | struct at91_usbh_data *pdata = pdev->dev.platform_data; | 625 | struct at91_usbh_data *pdata = pdev->dev.platform_data; |
626 | int i; | 626 | int i; |
@@ -696,7 +696,7 @@ MODULE_ALIAS("platform:at91_ohci"); | |||
696 | 696 | ||
697 | static struct platform_driver ohci_hcd_at91_driver = { | 697 | static struct platform_driver ohci_hcd_at91_driver = { |
698 | .probe = ohci_hcd_at91_drv_probe, | 698 | .probe = ohci_hcd_at91_drv_probe, |
699 | .remove = ohci_hcd_at91_drv_remove, | 699 | .remove = __devexit_p(ohci_hcd_at91_drv_remove), |
700 | .shutdown = usb_hcd_platform_shutdown, | 700 | .shutdown = usb_hcd_platform_shutdown, |
701 | .suspend = ohci_hcd_at91_drv_suspend, | 701 | .suspend = ohci_hcd_at91_drv_suspend, |
702 | .resume = ohci_hcd_at91_drv_resume, | 702 | .resume = ohci_hcd_at91_drv_resume, |
diff --git a/drivers/usb/misc/usbtest.c b/drivers/usb/misc/usbtest.c index 959145baf3cf..9dcb68f04f03 100644 --- a/drivers/usb/misc/usbtest.c +++ b/drivers/usb/misc/usbtest.c | |||
@@ -423,7 +423,7 @@ alloc_sglist(int nents, int max, int vary) | |||
423 | unsigned i; | 423 | unsigned i; |
424 | unsigned size = max; | 424 | unsigned size = max; |
425 | 425 | ||
426 | sg = kmalloc(nents * sizeof *sg, GFP_KERNEL); | 426 | sg = kmalloc_array(nents, sizeof *sg, GFP_KERNEL); |
427 | if (!sg) | 427 | if (!sg) |
428 | return NULL; | 428 | return NULL; |
429 | sg_init_table(sg, nents); | 429 | sg_init_table(sg, nents); |
@@ -904,6 +904,9 @@ test_ctrl_queue(struct usbtest_dev *dev, struct usbtest_param *param) | |||
904 | struct ctrl_ctx context; | 904 | struct ctrl_ctx context; |
905 | int i; | 905 | int i; |
906 | 906 | ||
907 | if (param->sglen == 0 || param->iterations > UINT_MAX / param->sglen) | ||
908 | return -EOPNOTSUPP; | ||
909 | |||
907 | spin_lock_init(&context.lock); | 910 | spin_lock_init(&context.lock); |
908 | context.dev = dev; | 911 | context.dev = dev; |
909 | init_completion(&context.complete); | 912 | init_completion(&context.complete); |
@@ -1981,8 +1984,6 @@ usbtest_ioctl(struct usb_interface *intf, unsigned int code, void *buf) | |||
1981 | 1984 | ||
1982 | /* queued control messaging */ | 1985 | /* queued control messaging */ |
1983 | case 10: | 1986 | case 10: |
1984 | if (param->sglen == 0) | ||
1985 | break; | ||
1986 | retval = 0; | 1987 | retval = 0; |
1987 | dev_info(&intf->dev, | 1988 | dev_info(&intf->dev, |
1988 | "TEST 10: queue %d control calls, %d times\n", | 1989 | "TEST 10: queue %d control calls, %d times\n", |
@@ -2276,6 +2277,8 @@ usbtest_probe(struct usb_interface *intf, const struct usb_device_id *id) | |||
2276 | if (status < 0) { | 2277 | if (status < 0) { |
2277 | WARNING(dev, "couldn't get endpoints, %d\n", | 2278 | WARNING(dev, "couldn't get endpoints, %d\n", |
2278 | status); | 2279 | status); |
2280 | kfree(dev->buf); | ||
2281 | kfree(dev); | ||
2279 | return status; | 2282 | return status; |
2280 | } | 2283 | } |
2281 | /* may find bulk or ISO pipes */ | 2284 | /* may find bulk or ISO pipes */ |
diff --git a/drivers/usb/misc/yurex.c b/drivers/usb/misc/yurex.c index 897edda42270..70201462e19c 100644 --- a/drivers/usb/misc/yurex.c +++ b/drivers/usb/misc/yurex.c | |||
@@ -99,9 +99,7 @@ static void yurex_delete(struct kref *kref) | |||
99 | usb_put_dev(dev->udev); | 99 | usb_put_dev(dev->udev); |
100 | if (dev->cntl_urb) { | 100 | if (dev->cntl_urb) { |
101 | usb_kill_urb(dev->cntl_urb); | 101 | usb_kill_urb(dev->cntl_urb); |
102 | if (dev->cntl_req) | 102 | kfree(dev->cntl_req); |
103 | usb_free_coherent(dev->udev, YUREX_BUF_SIZE, | ||
104 | dev->cntl_req, dev->cntl_urb->setup_dma); | ||
105 | if (dev->cntl_buffer) | 103 | if (dev->cntl_buffer) |
106 | usb_free_coherent(dev->udev, YUREX_BUF_SIZE, | 104 | usb_free_coherent(dev->udev, YUREX_BUF_SIZE, |
107 | dev->cntl_buffer, dev->cntl_urb->transfer_dma); | 105 | dev->cntl_buffer, dev->cntl_urb->transfer_dma); |
@@ -234,9 +232,7 @@ static int yurex_probe(struct usb_interface *interface, const struct usb_device_ | |||
234 | } | 232 | } |
235 | 233 | ||
236 | /* allocate buffer for control req */ | 234 | /* allocate buffer for control req */ |
237 | dev->cntl_req = usb_alloc_coherent(dev->udev, YUREX_BUF_SIZE, | 235 | dev->cntl_req = kmalloc(YUREX_BUF_SIZE, GFP_KERNEL); |
238 | GFP_KERNEL, | ||
239 | &dev->cntl_urb->setup_dma); | ||
240 | if (!dev->cntl_req) { | 236 | if (!dev->cntl_req) { |
241 | err("Could not allocate cntl_req"); | 237 | err("Could not allocate cntl_req"); |
242 | goto error; | 238 | goto error; |
@@ -286,7 +282,7 @@ static int yurex_probe(struct usb_interface *interface, const struct usb_device_ | |||
286 | usb_rcvintpipe(dev->udev, dev->int_in_endpointAddr), | 282 | usb_rcvintpipe(dev->udev, dev->int_in_endpointAddr), |
287 | dev->int_buffer, YUREX_BUF_SIZE, yurex_interrupt, | 283 | dev->int_buffer, YUREX_BUF_SIZE, yurex_interrupt, |
288 | dev, 1); | 284 | dev, 1); |
289 | dev->cntl_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; | 285 | dev->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; |
290 | if (usb_submit_urb(dev->urb, GFP_KERNEL)) { | 286 | if (usb_submit_urb(dev->urb, GFP_KERNEL)) { |
291 | retval = -EIO; | 287 | retval = -EIO; |
292 | err("Could not submitting URB"); | 288 | err("Could not submitting URB"); |
diff --git a/drivers/usb/musb/davinci.c b/drivers/usb/musb/davinci.c index 97ab975fa442..768b4b55c816 100644 --- a/drivers/usb/musb/davinci.c +++ b/drivers/usb/musb/davinci.c | |||
@@ -386,7 +386,7 @@ static int davinci_musb_init(struct musb *musb) | |||
386 | usb_nop_xceiv_register(); | 386 | usb_nop_xceiv_register(); |
387 | musb->xceiv = usb_get_transceiver(); | 387 | musb->xceiv = usb_get_transceiver(); |
388 | if (!musb->xceiv) | 388 | if (!musb->xceiv) |
389 | return -ENODEV; | 389 | goto unregister; |
390 | 390 | ||
391 | musb->mregs += DAVINCI_BASE_OFFSET; | 391 | musb->mregs += DAVINCI_BASE_OFFSET; |
392 | 392 | ||
@@ -444,6 +444,7 @@ static int davinci_musb_init(struct musb *musb) | |||
444 | 444 | ||
445 | fail: | 445 | fail: |
446 | usb_put_transceiver(musb->xceiv); | 446 | usb_put_transceiver(musb->xceiv); |
447 | unregister: | ||
447 | usb_nop_xceiv_unregister(); | 448 | usb_nop_xceiv_unregister(); |
448 | return -ENODEV; | 449 | return -ENODEV; |
449 | } | 450 | } |
diff --git a/drivers/usb/musb/musb_core.c b/drivers/usb/musb/musb_core.c index 0f8b82918a40..66aaccf04490 100644 --- a/drivers/usb/musb/musb_core.c +++ b/drivers/usb/musb/musb_core.c | |||
@@ -137,6 +137,9 @@ static int musb_ulpi_read(struct usb_phy *phy, u32 offset) | |||
137 | int i = 0; | 137 | int i = 0; |
138 | u8 r; | 138 | u8 r; |
139 | u8 power; | 139 | u8 power; |
140 | int ret; | ||
141 | |||
142 | pm_runtime_get_sync(phy->io_dev); | ||
140 | 143 | ||
141 | /* Make sure the transceiver is not in low power mode */ | 144 | /* Make sure the transceiver is not in low power mode */ |
142 | power = musb_readb(addr, MUSB_POWER); | 145 | power = musb_readb(addr, MUSB_POWER); |
@@ -154,15 +157,22 @@ static int musb_ulpi_read(struct usb_phy *phy, u32 offset) | |||
154 | while (!(musb_readb(addr, MUSB_ULPI_REG_CONTROL) | 157 | while (!(musb_readb(addr, MUSB_ULPI_REG_CONTROL) |
155 | & MUSB_ULPI_REG_CMPLT)) { | 158 | & MUSB_ULPI_REG_CMPLT)) { |
156 | i++; | 159 | i++; |
157 | if (i == 10000) | 160 | if (i == 10000) { |
158 | return -ETIMEDOUT; | 161 | ret = -ETIMEDOUT; |
162 | goto out; | ||
163 | } | ||
159 | 164 | ||
160 | } | 165 | } |
161 | r = musb_readb(addr, MUSB_ULPI_REG_CONTROL); | 166 | r = musb_readb(addr, MUSB_ULPI_REG_CONTROL); |
162 | r &= ~MUSB_ULPI_REG_CMPLT; | 167 | r &= ~MUSB_ULPI_REG_CMPLT; |
163 | musb_writeb(addr, MUSB_ULPI_REG_CONTROL, r); | 168 | musb_writeb(addr, MUSB_ULPI_REG_CONTROL, r); |
164 | 169 | ||
165 | return musb_readb(addr, MUSB_ULPI_REG_DATA); | 170 | ret = musb_readb(addr, MUSB_ULPI_REG_DATA); |
171 | |||
172 | out: | ||
173 | pm_runtime_put(phy->io_dev); | ||
174 | |||
175 | return ret; | ||
166 | } | 176 | } |
167 | 177 | ||
168 | static int musb_ulpi_write(struct usb_phy *phy, u32 offset, u32 data) | 178 | static int musb_ulpi_write(struct usb_phy *phy, u32 offset, u32 data) |
@@ -171,6 +181,9 @@ static int musb_ulpi_write(struct usb_phy *phy, u32 offset, u32 data) | |||
171 | int i = 0; | 181 | int i = 0; |
172 | u8 r = 0; | 182 | u8 r = 0; |
173 | u8 power; | 183 | u8 power; |
184 | int ret = 0; | ||
185 | |||
186 | pm_runtime_get_sync(phy->io_dev); | ||
174 | 187 | ||
175 | /* Make sure the transceiver is not in low power mode */ | 188 | /* Make sure the transceiver is not in low power mode */ |
176 | power = musb_readb(addr, MUSB_POWER); | 189 | power = musb_readb(addr, MUSB_POWER); |
@@ -184,15 +197,20 @@ static int musb_ulpi_write(struct usb_phy *phy, u32 offset, u32 data) | |||
184 | while (!(musb_readb(addr, MUSB_ULPI_REG_CONTROL) | 197 | while (!(musb_readb(addr, MUSB_ULPI_REG_CONTROL) |
185 | & MUSB_ULPI_REG_CMPLT)) { | 198 | & MUSB_ULPI_REG_CMPLT)) { |
186 | i++; | 199 | i++; |
187 | if (i == 10000) | 200 | if (i == 10000) { |
188 | return -ETIMEDOUT; | 201 | ret = -ETIMEDOUT; |
202 | goto out; | ||
203 | } | ||
189 | } | 204 | } |
190 | 205 | ||
191 | r = musb_readb(addr, MUSB_ULPI_REG_CONTROL); | 206 | r = musb_readb(addr, MUSB_ULPI_REG_CONTROL); |
192 | r &= ~MUSB_ULPI_REG_CMPLT; | 207 | r &= ~MUSB_ULPI_REG_CMPLT; |
193 | musb_writeb(addr, MUSB_ULPI_REG_CONTROL, r); | 208 | musb_writeb(addr, MUSB_ULPI_REG_CONTROL, r); |
194 | 209 | ||
195 | return 0; | 210 | out: |
211 | pm_runtime_put(phy->io_dev); | ||
212 | |||
213 | return ret; | ||
196 | } | 214 | } |
197 | #else | 215 | #else |
198 | #define musb_ulpi_read NULL | 216 | #define musb_ulpi_read NULL |
@@ -1904,14 +1922,17 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl) | |||
1904 | 1922 | ||
1905 | if (!musb->isr) { | 1923 | if (!musb->isr) { |
1906 | status = -ENODEV; | 1924 | status = -ENODEV; |
1907 | goto fail3; | 1925 | goto fail2; |
1908 | } | 1926 | } |
1909 | 1927 | ||
1910 | if (!musb->xceiv->io_ops) { | 1928 | if (!musb->xceiv->io_ops) { |
1929 | musb->xceiv->io_dev = musb->controller; | ||
1911 | musb->xceiv->io_priv = musb->mregs; | 1930 | musb->xceiv->io_priv = musb->mregs; |
1912 | musb->xceiv->io_ops = &musb_ulpi_access; | 1931 | musb->xceiv->io_ops = &musb_ulpi_access; |
1913 | } | 1932 | } |
1914 | 1933 | ||
1934 | pm_runtime_get_sync(musb->controller); | ||
1935 | |||
1915 | #ifndef CONFIG_MUSB_PIO_ONLY | 1936 | #ifndef CONFIG_MUSB_PIO_ONLY |
1916 | if (use_dma && dev->dma_mask) { | 1937 | if (use_dma && dev->dma_mask) { |
1917 | struct dma_controller *c; | 1938 | struct dma_controller *c; |
@@ -2023,6 +2044,8 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl) | |||
2023 | goto fail5; | 2044 | goto fail5; |
2024 | #endif | 2045 | #endif |
2025 | 2046 | ||
2047 | pm_runtime_put(musb->controller); | ||
2048 | |||
2026 | dev_info(dev, "USB %s mode controller at %p using %s, IRQ %d\n", | 2049 | dev_info(dev, "USB %s mode controller at %p using %s, IRQ %d\n", |
2027 | ({char *s; | 2050 | ({char *s; |
2028 | switch (musb->board_mode) { | 2051 | switch (musb->board_mode) { |
@@ -2047,6 +2070,9 @@ fail4: | |||
2047 | musb_gadget_cleanup(musb); | 2070 | musb_gadget_cleanup(musb); |
2048 | 2071 | ||
2049 | fail3: | 2072 | fail3: |
2073 | pm_runtime_put_sync(musb->controller); | ||
2074 | |||
2075 | fail2: | ||
2050 | if (musb->irq_wake) | 2076 | if (musb->irq_wake) |
2051 | device_init_wakeup(dev, 0); | 2077 | device_init_wakeup(dev, 0); |
2052 | musb_platform_exit(musb); | 2078 | musb_platform_exit(musb); |
diff --git a/drivers/usb/musb/musb_core.h b/drivers/usb/musb/musb_core.h index 93de517a32a0..f4a40f001c88 100644 --- a/drivers/usb/musb/musb_core.h +++ b/drivers/usb/musb/musb_core.h | |||
@@ -449,7 +449,7 @@ struct musb { | |||
449 | * We added this flag to forcefully disable double | 449 | * We added this flag to forcefully disable double |
450 | * buffering until we get it working. | 450 | * buffering until we get it working. |
451 | */ | 451 | */ |
452 | unsigned double_buffer_not_ok:1 __deprecated; | 452 | unsigned double_buffer_not_ok:1; |
453 | 453 | ||
454 | struct musb_hdrc_config *config; | 454 | struct musb_hdrc_config *config; |
455 | 455 | ||
diff --git a/drivers/usb/musb/musb_host.c b/drivers/usb/musb/musb_host.c index 79cb0af779fa..ef8d744800ac 100644 --- a/drivers/usb/musb/musb_host.c +++ b/drivers/usb/musb/musb_host.c | |||
@@ -2098,7 +2098,7 @@ static int musb_cleanup_urb(struct urb *urb, struct musb_qh *qh) | |||
2098 | } | 2098 | } |
2099 | 2099 | ||
2100 | /* turn off DMA requests, discard state, stop polling ... */ | 2100 | /* turn off DMA requests, discard state, stop polling ... */ |
2101 | if (is_in) { | 2101 | if (ep->epnum && is_in) { |
2102 | /* giveback saves bulk toggle */ | 2102 | /* giveback saves bulk toggle */ |
2103 | csr = musb_h_flush_rxfifo(ep, 0); | 2103 | csr = musb_h_flush_rxfifo(ep, 0); |
2104 | 2104 | ||
diff --git a/drivers/usb/musb/omap2430.c b/drivers/usb/musb/omap2430.c index 2ae0bb309994..c7785e81254c 100644 --- a/drivers/usb/musb/omap2430.c +++ b/drivers/usb/musb/omap2430.c | |||
@@ -282,7 +282,8 @@ static void musb_otg_notifier_work(struct work_struct *data_notifier_work) | |||
282 | 282 | ||
283 | static int omap2430_musb_init(struct musb *musb) | 283 | static int omap2430_musb_init(struct musb *musb) |
284 | { | 284 | { |
285 | u32 l, status = 0; | 285 | u32 l; |
286 | int status = 0; | ||
286 | struct device *dev = musb->controller; | 287 | struct device *dev = musb->controller; |
287 | struct musb_hdrc_platform_data *plat = dev->platform_data; | 288 | struct musb_hdrc_platform_data *plat = dev->platform_data; |
288 | struct omap_musb_board_data *data = plat->board_data; | 289 | struct omap_musb_board_data *data = plat->board_data; |
@@ -301,7 +302,7 @@ static int omap2430_musb_init(struct musb *musb) | |||
301 | 302 | ||
302 | status = pm_runtime_get_sync(dev); | 303 | status = pm_runtime_get_sync(dev); |
303 | if (status < 0) { | 304 | if (status < 0) { |
304 | dev_err(dev, "pm_runtime_get_sync FAILED"); | 305 | dev_err(dev, "pm_runtime_get_sync FAILED %d\n", status); |
305 | goto err1; | 306 | goto err1; |
306 | } | 307 | } |
307 | 308 | ||
@@ -333,6 +334,7 @@ static int omap2430_musb_init(struct musb *musb) | |||
333 | 334 | ||
334 | setup_timer(&musb_idle_timer, musb_do_idle, (unsigned long) musb); | 335 | setup_timer(&musb_idle_timer, musb_do_idle, (unsigned long) musb); |
335 | 336 | ||
337 | pm_runtime_put_noidle(musb->controller); | ||
336 | return 0; | 338 | return 0; |
337 | 339 | ||
338 | err1: | 340 | err1: |
@@ -452,14 +454,14 @@ static int __devinit omap2430_probe(struct platform_device *pdev) | |||
452 | goto err2; | 454 | goto err2; |
453 | } | 455 | } |
454 | 456 | ||
457 | pm_runtime_enable(&pdev->dev); | ||
458 | |||
455 | ret = platform_device_add(musb); | 459 | ret = platform_device_add(musb); |
456 | if (ret) { | 460 | if (ret) { |
457 | dev_err(&pdev->dev, "failed to register musb device\n"); | 461 | dev_err(&pdev->dev, "failed to register musb device\n"); |
458 | goto err2; | 462 | goto err2; |
459 | } | 463 | } |
460 | 464 | ||
461 | pm_runtime_enable(&pdev->dev); | ||
462 | |||
463 | return 0; | 465 | return 0; |
464 | 466 | ||
465 | err2: | 467 | err2: |
@@ -478,7 +480,6 @@ static int __devexit omap2430_remove(struct platform_device *pdev) | |||
478 | 480 | ||
479 | platform_device_del(glue->musb); | 481 | platform_device_del(glue->musb); |
480 | platform_device_put(glue->musb); | 482 | platform_device_put(glue->musb); |
481 | pm_runtime_put(&pdev->dev); | ||
482 | kfree(glue); | 483 | kfree(glue); |
483 | 484 | ||
484 | return 0; | 485 | return 0; |
@@ -491,11 +492,13 @@ static int omap2430_runtime_suspend(struct device *dev) | |||
491 | struct omap2430_glue *glue = dev_get_drvdata(dev); | 492 | struct omap2430_glue *glue = dev_get_drvdata(dev); |
492 | struct musb *musb = glue_to_musb(glue); | 493 | struct musb *musb = glue_to_musb(glue); |
493 | 494 | ||
494 | musb->context.otg_interfsel = musb_readl(musb->mregs, | 495 | if (musb) { |
495 | OTG_INTERFSEL); | 496 | musb->context.otg_interfsel = musb_readl(musb->mregs, |
497 | OTG_INTERFSEL); | ||
496 | 498 | ||
497 | omap2430_low_level_exit(musb); | 499 | omap2430_low_level_exit(musb); |
498 | usb_phy_set_suspend(musb->xceiv, 1); | 500 | usb_phy_set_suspend(musb->xceiv, 1); |
501 | } | ||
499 | 502 | ||
500 | return 0; | 503 | return 0; |
501 | } | 504 | } |
@@ -505,11 +508,13 @@ static int omap2430_runtime_resume(struct device *dev) | |||
505 | struct omap2430_glue *glue = dev_get_drvdata(dev); | 508 | struct omap2430_glue *glue = dev_get_drvdata(dev); |
506 | struct musb *musb = glue_to_musb(glue); | 509 | struct musb *musb = glue_to_musb(glue); |
507 | 510 | ||
508 | omap2430_low_level_init(musb); | 511 | if (musb) { |
509 | musb_writel(musb->mregs, OTG_INTERFSEL, | 512 | omap2430_low_level_init(musb); |
510 | musb->context.otg_interfsel); | 513 | musb_writel(musb->mregs, OTG_INTERFSEL, |
514 | musb->context.otg_interfsel); | ||
511 | 515 | ||
512 | usb_phy_set_suspend(musb->xceiv, 0); | 516 | usb_phy_set_suspend(musb->xceiv, 0); |
517 | } | ||
513 | 518 | ||
514 | return 0; | 519 | return 0; |
515 | } | 520 | } |
diff --git a/drivers/usb/otg/gpio_vbus.c b/drivers/usb/otg/gpio_vbus.c index 3ece43a2e4c1..a0a2178974fe 100644 --- a/drivers/usb/otg/gpio_vbus.c +++ b/drivers/usb/otg/gpio_vbus.c | |||
@@ -96,7 +96,7 @@ static void gpio_vbus_work(struct work_struct *work) | |||
96 | struct gpio_vbus_data *gpio_vbus = | 96 | struct gpio_vbus_data *gpio_vbus = |
97 | container_of(work, struct gpio_vbus_data, work); | 97 | container_of(work, struct gpio_vbus_data, work); |
98 | struct gpio_vbus_mach_info *pdata = gpio_vbus->dev->platform_data; | 98 | struct gpio_vbus_mach_info *pdata = gpio_vbus->dev->platform_data; |
99 | int gpio; | 99 | int gpio, status; |
100 | 100 | ||
101 | if (!gpio_vbus->phy.otg->gadget) | 101 | if (!gpio_vbus->phy.otg->gadget) |
102 | return; | 102 | return; |
@@ -108,7 +108,9 @@ static void gpio_vbus_work(struct work_struct *work) | |||
108 | */ | 108 | */ |
109 | gpio = pdata->gpio_pullup; | 109 | gpio = pdata->gpio_pullup; |
110 | if (is_vbus_powered(pdata)) { | 110 | if (is_vbus_powered(pdata)) { |
111 | status = USB_EVENT_VBUS; | ||
111 | gpio_vbus->phy.state = OTG_STATE_B_PERIPHERAL; | 112 | gpio_vbus->phy.state = OTG_STATE_B_PERIPHERAL; |
113 | gpio_vbus->phy.last_event = status; | ||
112 | usb_gadget_vbus_connect(gpio_vbus->phy.otg->gadget); | 114 | usb_gadget_vbus_connect(gpio_vbus->phy.otg->gadget); |
113 | 115 | ||
114 | /* drawing a "unit load" is *always* OK, except for OTG */ | 116 | /* drawing a "unit load" is *always* OK, except for OTG */ |
@@ -117,6 +119,9 @@ static void gpio_vbus_work(struct work_struct *work) | |||
117 | /* optionally enable D+ pullup */ | 119 | /* optionally enable D+ pullup */ |
118 | if (gpio_is_valid(gpio)) | 120 | if (gpio_is_valid(gpio)) |
119 | gpio_set_value(gpio, !pdata->gpio_pullup_inverted); | 121 | gpio_set_value(gpio, !pdata->gpio_pullup_inverted); |
122 | |||
123 | atomic_notifier_call_chain(&gpio_vbus->phy.notifier, | ||
124 | status, gpio_vbus->phy.otg->gadget); | ||
120 | } else { | 125 | } else { |
121 | /* optionally disable D+ pullup */ | 126 | /* optionally disable D+ pullup */ |
122 | if (gpio_is_valid(gpio)) | 127 | if (gpio_is_valid(gpio)) |
@@ -125,7 +130,12 @@ static void gpio_vbus_work(struct work_struct *work) | |||
125 | set_vbus_draw(gpio_vbus, 0); | 130 | set_vbus_draw(gpio_vbus, 0); |
126 | 131 | ||
127 | usb_gadget_vbus_disconnect(gpio_vbus->phy.otg->gadget); | 132 | usb_gadget_vbus_disconnect(gpio_vbus->phy.otg->gadget); |
133 | status = USB_EVENT_NONE; | ||
128 | gpio_vbus->phy.state = OTG_STATE_B_IDLE; | 134 | gpio_vbus->phy.state = OTG_STATE_B_IDLE; |
135 | gpio_vbus->phy.last_event = status; | ||
136 | |||
137 | atomic_notifier_call_chain(&gpio_vbus->phy.notifier, | ||
138 | status, gpio_vbus->phy.otg->gadget); | ||
129 | } | 139 | } |
130 | } | 140 | } |
131 | 141 | ||
@@ -287,6 +297,9 @@ static int __init gpio_vbus_probe(struct platform_device *pdev) | |||
287 | irq, err); | 297 | irq, err); |
288 | goto err_irq; | 298 | goto err_irq; |
289 | } | 299 | } |
300 | |||
301 | ATOMIC_INIT_NOTIFIER_HEAD(&gpio_vbus->phy.notifier); | ||
302 | |||
290 | INIT_WORK(&gpio_vbus->work, gpio_vbus_work); | 303 | INIT_WORK(&gpio_vbus->work, gpio_vbus_work); |
291 | 304 | ||
292 | gpio_vbus->vbus_draw = regulator_get(&pdev->dev, "vbus_draw"); | 305 | gpio_vbus->vbus_draw = regulator_get(&pdev->dev, "vbus_draw"); |
diff --git a/drivers/usb/serial/cp210x.c b/drivers/usb/serial/cp210x.c index 0310e2df59f5..ec30f95ef399 100644 --- a/drivers/usb/serial/cp210x.c +++ b/drivers/usb/serial/cp210x.c | |||
@@ -287,7 +287,8 @@ static int cp210x_get_config(struct usb_serial_port *port, u8 request, | |||
287 | /* Issue the request, attempting to read 'size' bytes */ | 287 | /* Issue the request, attempting to read 'size' bytes */ |
288 | result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0), | 288 | result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0), |
289 | request, REQTYPE_DEVICE_TO_HOST, 0x0000, | 289 | request, REQTYPE_DEVICE_TO_HOST, 0x0000, |
290 | port_priv->bInterfaceNumber, buf, size, 300); | 290 | port_priv->bInterfaceNumber, buf, size, |
291 | USB_CTRL_GET_TIMEOUT); | ||
291 | 292 | ||
292 | /* Convert data into an array of integers */ | 293 | /* Convert data into an array of integers */ |
293 | for (i = 0; i < length; i++) | 294 | for (i = 0; i < length; i++) |
@@ -340,12 +341,14 @@ static int cp210x_set_config(struct usb_serial_port *port, u8 request, | |||
340 | result = usb_control_msg(serial->dev, | 341 | result = usb_control_msg(serial->dev, |
341 | usb_sndctrlpipe(serial->dev, 0), | 342 | usb_sndctrlpipe(serial->dev, 0), |
342 | request, REQTYPE_HOST_TO_DEVICE, 0x0000, | 343 | request, REQTYPE_HOST_TO_DEVICE, 0x0000, |
343 | port_priv->bInterfaceNumber, buf, size, 300); | 344 | port_priv->bInterfaceNumber, buf, size, |
345 | USB_CTRL_SET_TIMEOUT); | ||
344 | } else { | 346 | } else { |
345 | result = usb_control_msg(serial->dev, | 347 | result = usb_control_msg(serial->dev, |
346 | usb_sndctrlpipe(serial->dev, 0), | 348 | usb_sndctrlpipe(serial->dev, 0), |
347 | request, REQTYPE_HOST_TO_DEVICE, data[0], | 349 | request, REQTYPE_HOST_TO_DEVICE, data[0], |
348 | port_priv->bInterfaceNumber, NULL, 0, 300); | 350 | port_priv->bInterfaceNumber, NULL, 0, |
351 | USB_CTRL_SET_TIMEOUT); | ||
349 | } | 352 | } |
350 | 353 | ||
351 | kfree(buf); | 354 | kfree(buf); |
diff --git a/drivers/usb/serial/sierra.c b/drivers/usb/serial/sierra.c index fdd5aa2c8d82..8c8bf806f6fa 100644 --- a/drivers/usb/serial/sierra.c +++ b/drivers/usb/serial/sierra.c | |||
@@ -221,7 +221,7 @@ static const struct sierra_iface_info typeB_interface_list = { | |||
221 | }; | 221 | }; |
222 | 222 | ||
223 | /* 'blacklist' of interfaces not served by this driver */ | 223 | /* 'blacklist' of interfaces not served by this driver */ |
224 | static const u8 direct_ip_non_serial_ifaces[] = { 7, 8, 9, 10, 11 }; | 224 | static const u8 direct_ip_non_serial_ifaces[] = { 7, 8, 9, 10, 11, 19, 20 }; |
225 | static const struct sierra_iface_info direct_ip_interface_blacklist = { | 225 | static const struct sierra_iface_info direct_ip_interface_blacklist = { |
226 | .infolen = ARRAY_SIZE(direct_ip_non_serial_ifaces), | 226 | .infolen = ARRAY_SIZE(direct_ip_non_serial_ifaces), |
227 | .ifaceinfo = direct_ip_non_serial_ifaces, | 227 | .ifaceinfo = direct_ip_non_serial_ifaces, |
@@ -289,7 +289,6 @@ static const struct usb_device_id id_table[] = { | |||
289 | { USB_DEVICE(0x1199, 0x6856) }, /* Sierra Wireless AirCard 881 U */ | 289 | { USB_DEVICE(0x1199, 0x6856) }, /* Sierra Wireless AirCard 881 U */ |
290 | { USB_DEVICE(0x1199, 0x6859) }, /* Sierra Wireless AirCard 885 E */ | 290 | { USB_DEVICE(0x1199, 0x6859) }, /* Sierra Wireless AirCard 885 E */ |
291 | { USB_DEVICE(0x1199, 0x685A) }, /* Sierra Wireless AirCard 885 E */ | 291 | { USB_DEVICE(0x1199, 0x685A) }, /* Sierra Wireless AirCard 885 E */ |
292 | { USB_DEVICE(0x1199, 0x68A2) }, /* Sierra Wireless MC7710 */ | ||
293 | /* Sierra Wireless C885 */ | 292 | /* Sierra Wireless C885 */ |
294 | { USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x6880, 0xFF, 0xFF, 0xFF)}, | 293 | { USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x6880, 0xFF, 0xFF, 0xFF)}, |
295 | /* Sierra Wireless C888, Air Card 501, USB 303, USB 304 */ | 294 | /* Sierra Wireless C888, Air Card 501, USB 303, USB 304 */ |
@@ -299,6 +298,9 @@ static const struct usb_device_id id_table[] = { | |||
299 | /* Sierra Wireless HSPA Non-Composite Device */ | 298 | /* Sierra Wireless HSPA Non-Composite Device */ |
300 | { USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x6892, 0xFF, 0xFF, 0xFF)}, | 299 | { USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x6892, 0xFF, 0xFF, 0xFF)}, |
301 | { USB_DEVICE(0x1199, 0x6893) }, /* Sierra Wireless Device */ | 300 | { USB_DEVICE(0x1199, 0x6893) }, /* Sierra Wireless Device */ |
301 | { USB_DEVICE(0x1199, 0x68A2), /* Sierra Wireless MC77xx in QMI mode */ | ||
302 | .driver_info = (kernel_ulong_t)&direct_ip_interface_blacklist | ||
303 | }, | ||
302 | { USB_DEVICE(0x1199, 0x68A3), /* Sierra Wireless Direct IP modems */ | 304 | { USB_DEVICE(0x1199, 0x68A3), /* Sierra Wireless Direct IP modems */ |
303 | .driver_info = (kernel_ulong_t)&direct_ip_interface_blacklist | 305 | .driver_info = (kernel_ulong_t)&direct_ip_interface_blacklist |
304 | }, | 306 | }, |