Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'usb-4.9-rc7' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb
Pull USB fixes from Greg KH:
"Here are a few small USB fixes and new device ids for 4.9-rc7.
The majority of these fixes are in the musb driver, fixing a number of
regressions that have been reported but took a while to resolve. The
other fixes are all small ones, to resolve other reported minor
issues.
All have been in linux-next for a while with no reported issues"
* tag 'usb-4.9-rc7' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb:
usb: gadget: f_fs: fix wrong parenthesis in ffs_func_req_match()
phy: twl4030-usb: Fix for musb session bit based PM
usb: musb: Drop pointless PM runtime code for dsps glue
usb: musb: Add missing pm_runtime_disable and drop 2430 PM timeout
usb: musb: Fix PM for hub disconnect
usb: musb: Fix sleeping function called from invalid context for hdrc glue
usb: musb: Fix broken use of static variable for multiple instances
USB: serial: cp210x: add ID for the Zone DPMX
usb: chipidea: move the lock initialization to core file
Fix USB CB/CBI storage devices with CONFIG_VMAP_STACK=y
USB: serial: ftdi_sio: add support for TI CC3200 LaunchPad
+229
-75
+2
-2
drivers/phy/phy-twl4030-usb.c
+2
-2
drivers/phy/phy-twl4030-usb.c
···
459
459
struct twl4030_usb *twl = phy_get_drvdata(phy);
460
460
461
461
dev_dbg(twl->dev, "%s\n", __func__);
462
-
pm_runtime_mark_last_busy(twl->dev);
463
-
pm_runtime_put_autosuspend(twl->dev);
464
462
465
463
return 0;
466
464
}
···
470
472
dev_dbg(twl->dev, "%s\n", __func__);
471
473
pm_runtime_get_sync(twl->dev);
472
474
schedule_delayed_work(&twl->id_workaround_work, HZ);
475
+
pm_runtime_mark_last_busy(twl->dev);
476
+
pm_runtime_put_autosuspend(twl->dev);
473
477
474
478
return 0;
475
479
}
+1
drivers/usb/chipidea/core.c
+1
drivers/usb/chipidea/core.c
-2
drivers/usb/chipidea/udc.c
-2
drivers/usb/chipidea/udc.c
+4
-4
drivers/usb/gadget/function/f_fs.c
+4
-4
drivers/usb/gadget/function/f_fs.c
···
3225
3225
3226
3226
switch (creq->bRequestType & USB_RECIP_MASK) {
3227
3227
case USB_RECIP_INTERFACE:
3228
-
return ffs_func_revmap_intf(func,
3229
-
le16_to_cpu(creq->wIndex) >= 0);
3228
+
return (ffs_func_revmap_intf(func,
3229
+
le16_to_cpu(creq->wIndex)) >= 0);
3230
3230
case USB_RECIP_ENDPOINT:
3231
-
return ffs_func_revmap_ep(func,
3232
-
le16_to_cpu(creq->wIndex) >= 0);
3231
+
return (ffs_func_revmap_ep(func,
3232
+
le16_to_cpu(creq->wIndex)) >= 0);
3233
3233
default:
3234
3234
return (bool) (func->ffs->user_flags &
3235
3235
FUNCTIONFS_ALL_CTRL_RECIP);
+129
-18
drivers/usb/musb/musb_core.c
+129
-18
drivers/usb/musb/musb_core.c
···
986
986
}
987
987
#endif
988
988
989
-
schedule_work(&musb->irq_work);
989
+
schedule_delayed_work(&musb->irq_work, 0);
990
990
991
991
return handled;
992
992
}
···
1855
1855
MUSB_DEVCTL_HR;
1856
1856
switch (devctl & ~s) {
1857
1857
case MUSB_QUIRK_B_INVALID_VBUS_91:
1858
-
if (!musb->session && !musb->quirk_invalid_vbus) {
1859
-
musb->quirk_invalid_vbus = true;
1858
+
if (musb->quirk_retries--) {
1860
1859
musb_dbg(musb,
1861
-
"First invalid vbus, assume no session");
1860
+
"Poll devctl on invalid vbus, assume no session");
1861
+
schedule_delayed_work(&musb->irq_work,
1862
+
msecs_to_jiffies(1000));
1863
+
1862
1864
return;
1863
1865
}
1864
-
break;
1865
1866
case MUSB_QUIRK_A_DISCONNECT_19:
1867
+
if (musb->quirk_retries--) {
1868
+
musb_dbg(musb,
1869
+
"Poll devctl on possible host mode disconnect");
1870
+
schedule_delayed_work(&musb->irq_work,
1871
+
msecs_to_jiffies(1000));
1872
+
1873
+
return;
1874
+
}
1866
1875
if (!musb->session)
1867
1876
break;
1868
1877
musb_dbg(musb, "Allow PM on possible host mode disconnect");
···
1895
1886
if (error < 0)
1896
1887
dev_err(musb->controller, "Could not enable: %i\n",
1897
1888
error);
1889
+
musb->quirk_retries = 3;
1898
1890
} else {
1899
1891
musb_dbg(musb, "Allow PM with no session: %02x", devctl);
1900
-
musb->quirk_invalid_vbus = false;
1901
1892
pm_runtime_mark_last_busy(musb->controller);
1902
1893
pm_runtime_put_autosuspend(musb->controller);
1903
1894
}
···
1908
1899
/* Only used to provide driver mode change events */
1909
1900
static void musb_irq_work(struct work_struct *data)
1910
1901
{
1911
-
struct musb *musb = container_of(data, struct musb, irq_work);
1902
+
struct musb *musb = container_of(data, struct musb, irq_work.work);
1912
1903
1913
1904
musb_pm_runtime_check_session(musb);
1914
1905
···
1978
1969
INIT_LIST_HEAD(&musb->control);
1979
1970
INIT_LIST_HEAD(&musb->in_bulk);
1980
1971
INIT_LIST_HEAD(&musb->out_bulk);
1972
+
INIT_LIST_HEAD(&musb->pending_list);
1981
1973
1982
1974
musb->vbuserr_retry = VBUSERR_RETRY_COUNT;
1983
1975
musb->a_wait_bcon = OTG_TIME_A_WAIT_BCON;
···
2028
2018
musb_host_free(musb);
2029
2019
}
2030
2020
2021
+
struct musb_pending_work {
2022
+
int (*callback)(struct musb *musb, void *data);
2023
+
void *data;
2024
+
struct list_head node;
2025
+
};
2026
+
2027
+
/*
2028
+
* Called from musb_runtime_resume(), musb_resume(), and
2029
+
* musb_queue_resume_work(). Callers must take musb->lock.
2030
+
*/
2031
+
static int musb_run_resume_work(struct musb *musb)
2032
+
{
2033
+
struct musb_pending_work *w, *_w;
2034
+
unsigned long flags;
2035
+
int error = 0;
2036
+
2037
+
spin_lock_irqsave(&musb->list_lock, flags);
2038
+
list_for_each_entry_safe(w, _w, &musb->pending_list, node) {
2039
+
if (w->callback) {
2040
+
error = w->callback(musb, w->data);
2041
+
if (error < 0) {
2042
+
dev_err(musb->controller,
2043
+
"resume callback %p failed: %i\n",
2044
+
w->callback, error);
2045
+
}
2046
+
}
2047
+
list_del(&w->node);
2048
+
devm_kfree(musb->controller, w);
2049
+
}
2050
+
spin_unlock_irqrestore(&musb->list_lock, flags);
2051
+
2052
+
return error;
2053
+
}
2054
+
2055
+
/*
2056
+
* Called to run work if device is active or else queue the work to happen
2057
+
* on resume. Caller must take musb->lock and must hold an RPM reference.
2058
+
*
2059
+
* Note that we cowardly refuse queuing work after musb PM runtime
2060
+
* resume is done calling musb_run_resume_work() and return -EINPROGRESS
2061
+
* instead.
2062
+
*/
2063
+
int musb_queue_resume_work(struct musb *musb,
2064
+
int (*callback)(struct musb *musb, void *data),
2065
+
void *data)
2066
+
{
2067
+
struct musb_pending_work *w;
2068
+
unsigned long flags;
2069
+
int error;
2070
+
2071
+
if (WARN_ON(!callback))
2072
+
return -EINVAL;
2073
+
2074
+
if (pm_runtime_active(musb->controller))
2075
+
return callback(musb, data);
2076
+
2077
+
w = devm_kzalloc(musb->controller, sizeof(*w), GFP_ATOMIC);
2078
+
if (!w)
2079
+
return -ENOMEM;
2080
+
2081
+
w->callback = callback;
2082
+
w->data = data;
2083
+
spin_lock_irqsave(&musb->list_lock, flags);
2084
+
if (musb->is_runtime_suspended) {
2085
+
list_add_tail(&w->node, &musb->pending_list);
2086
+
error = 0;
2087
+
} else {
2088
+
dev_err(musb->controller, "could not add resume work %p\n",
2089
+
callback);
2090
+
devm_kfree(musb->controller, w);
2091
+
error = -EINPROGRESS;
2092
+
}
2093
+
spin_unlock_irqrestore(&musb->list_lock, flags);
2094
+
2095
+
return error;
2096
+
}
2097
+
EXPORT_SYMBOL_GPL(musb_queue_resume_work);
2098
+
2031
2099
static void musb_deassert_reset(struct work_struct *work)
2032
2100
{
2033
2101
struct musb *musb;
···
2153
2065
}
2154
2066
2155
2067
spin_lock_init(&musb->lock);
2068
+
spin_lock_init(&musb->list_lock);
2156
2069
musb->board_set_power = plat->set_power;
2157
2070
musb->min_power = plat->min_power;
2158
2071
musb->ops = plat->platform_ops;
···
2297
2208
musb_generic_disable(musb);
2298
2209
2299
2210
/* Init IRQ workqueue before request_irq */
2300
-
INIT_WORK(&musb->irq_work, musb_irq_work);
2211
+
INIT_DELAYED_WORK(&musb->irq_work, musb_irq_work);
2301
2212
INIT_DELAYED_WORK(&musb->deassert_reset_work, musb_deassert_reset);
2302
2213
INIT_DELAYED_WORK(&musb->finish_resume_work, musb_host_finish_resume);
2303
2214
···
2380
2291
if (status)
2381
2292
goto fail5;
2382
2293
2294
+
musb->is_initialized = 1;
2383
2295
pm_runtime_mark_last_busy(musb->controller);
2384
2296
pm_runtime_put_autosuspend(musb->controller);
2385
2297
···
2394
2304
musb_host_cleanup(musb);
2395
2305
2396
2306
fail3:
2397
-
cancel_work_sync(&musb->irq_work);
2307
+
cancel_delayed_work_sync(&musb->irq_work);
2398
2308
cancel_delayed_work_sync(&musb->finish_resume_work);
2399
2309
cancel_delayed_work_sync(&musb->deassert_reset_work);
2400
2310
if (musb->dma_controller)
···
2461
2371
*/
2462
2372
musb_exit_debugfs(musb);
2463
2373
2464
-
cancel_work_sync(&musb->irq_work);
2374
+
cancel_delayed_work_sync(&musb->irq_work);
2465
2375
cancel_delayed_work_sync(&musb->finish_resume_work);
2466
2376
cancel_delayed_work_sync(&musb->deassert_reset_work);
2467
2377
pm_runtime_get_sync(musb->controller);
···
2647
2557
2648
2558
musb_platform_disable(musb);
2649
2559
musb_generic_disable(musb);
2560
+
WARN_ON(!list_empty(&musb->pending_list));
2650
2561
2651
2562
spin_lock_irqsave(&musb->lock, flags);
2652
2563
···
2669
2578
2670
2579
static int musb_resume(struct device *dev)
2671
2580
{
2672
-
struct musb *musb = dev_to_musb(dev);
2673
-
u8 devctl;
2674
-
u8 mask;
2581
+
struct musb *musb = dev_to_musb(dev);
2582
+
unsigned long flags;
2583
+
int error;
2584
+
u8 devctl;
2585
+
u8 mask;
2675
2586
2676
2587
/*
2677
2588
* For static cmos like DaVinci, register values were preserved
···
2707
2614
2708
2615
musb_start(musb);
2709
2616
2617
+
spin_lock_irqsave(&musb->lock, flags);
2618
+
error = musb_run_resume_work(musb);
2619
+
if (error)
2620
+
dev_err(musb->controller, "resume work failed with %i\n",
2621
+
error);
2622
+
spin_unlock_irqrestore(&musb->lock, flags);
2623
+
2710
2624
return 0;
2711
2625
}
2712
2626
···
2722
2622
struct musb *musb = dev_to_musb(dev);
2723
2623
2724
2624
musb_save_context(musb);
2625
+
musb->is_runtime_suspended = 1;
2725
2626
2726
2627
return 0;
2727
2628
}
2728
2629
2729
2630
static int musb_runtime_resume(struct device *dev)
2730
2631
{
2731
-
struct musb *musb = dev_to_musb(dev);
2732
-
static int first = 1;
2632
+
struct musb *musb = dev_to_musb(dev);
2633
+
unsigned long flags;
2634
+
int error;
2733
2635
2734
2636
/*
2735
2637
* When pm_runtime_get_sync called for the first time in driver
···
2742
2640
* Also context restore without save does not make
2743
2641
* any sense
2744
2642
*/
2745
-
if (!first)
2746
-
musb_restore_context(musb);
2747
-
first = 0;
2643
+
if (!musb->is_initialized)
2644
+
return 0;
2645
+
2646
+
musb_restore_context(musb);
2748
2647
2749
2648
if (musb->need_finish_resume) {
2750
2649
musb->need_finish_resume = 0;
2751
2650
schedule_delayed_work(&musb->finish_resume_work,
2752
2651
msecs_to_jiffies(USB_RESUME_TIMEOUT));
2753
2652
}
2653
+
2654
+
spin_lock_irqsave(&musb->lock, flags);
2655
+
error = musb_run_resume_work(musb);
2656
+
if (error)
2657
+
dev_err(musb->controller, "resume work failed with %i\n",
2658
+
error);
2659
+
musb->is_runtime_suspended = 0;
2660
+
spin_unlock_irqrestore(&musb->lock, flags);
2754
2661
2755
2662
return 0;
2756
2663
}
+11
-2
drivers/usb/musb/musb_core.h
+11
-2
drivers/usb/musb/musb_core.h
···
303
303
struct musb {
304
304
/* device lock */
305
305
spinlock_t lock;
306
+
spinlock_t list_lock; /* resume work list lock */
306
307
307
308
struct musb_io io;
308
309
const struct musb_platform_ops *ops;
309
310
struct musb_context_registers context;
310
311
311
312
irqreturn_t (*isr)(int, void *);
312
-
struct work_struct irq_work;
313
+
struct delayed_work irq_work;
313
314
struct delayed_work deassert_reset_work;
314
315
struct delayed_work finish_resume_work;
315
316
struct delayed_work gadget_work;
···
338
337
struct list_head control; /* of musb_qh */
339
338
struct list_head in_bulk; /* of musb_qh */
340
339
struct list_head out_bulk; /* of musb_qh */
340
+
struct list_head pending_list; /* pending work list */
341
341
342
342
struct timer_list otg_timer;
343
343
struct notifier_block nb;
···
381
379
382
380
int port_mode; /* MUSB_PORT_MODE_* */
383
381
bool session;
384
-
bool quirk_invalid_vbus;
382
+
unsigned long quirk_retries;
385
383
bool is_host;
386
384
387
385
int a_wait_bcon; /* VBUS timeout in msecs */
388
386
unsigned long idle_timeout; /* Next timeout in jiffies */
387
+
388
+
unsigned is_initialized:1;
389
+
unsigned is_runtime_suspended:1;
389
390
390
391
/* active means connected and not suspended */
391
392
unsigned is_active:1;
···
544
539
extern irqreturn_t musb_interrupt(struct musb *);
545
540
546
541
extern void musb_hnp_stop(struct musb *musb);
542
+
543
+
int musb_queue_resume_work(struct musb *musb,
544
+
int (*callback)(struct musb *musb, void *data),
545
+
void *data);
547
546
548
547
static inline void musb_platform_set_vbus(struct musb *musb, int is_on)
549
548
{
+28
-30
drivers/usb/musb/musb_dsps.c
+28
-30
drivers/usb/musb/musb_dsps.c
···
185
185
musb_writel(reg_base, wrp->coreintr_clear, wrp->usb_bitmap);
186
186
musb_writel(reg_base, wrp->epintr_clear,
187
187
wrp->txep_bitmap | wrp->rxep_bitmap);
188
+
del_timer_sync(&glue->timer);
188
189
musb_writeb(musb->mregs, MUSB_DEVCTL, 0);
189
190
}
190
191
191
-
static void otg_timer(unsigned long _musb)
192
+
/* Caller must take musb->lock */
193
+
static int dsps_check_status(struct musb *musb, void *unused)
192
194
{
193
-
struct musb *musb = (void *)_musb;
194
195
void __iomem *mregs = musb->mregs;
195
196
struct device *dev = musb->controller;
196
197
struct dsps_glue *glue = dev_get_drvdata(dev->parent);
197
198
const struct dsps_musb_wrapper *wrp = glue->wrp;
198
199
u8 devctl;
199
-
unsigned long flags;
200
200
int skip_session = 0;
201
-
int err;
202
-
203
-
err = pm_runtime_get_sync(dev);
204
-
if (err < 0)
205
-
dev_err(dev, "Poll could not pm_runtime_get: %i\n", err);
206
201
207
202
/*
208
203
* We poll because DSPS IP's won't expose several OTG-critical
···
207
212
dev_dbg(musb->controller, "Poll devctl %02x (%s)\n", devctl,
208
213
usb_otg_state_string(musb->xceiv->otg->state));
209
214
210
-
spin_lock_irqsave(&musb->lock, flags);
211
215
switch (musb->xceiv->otg->state) {
212
216
case OTG_STATE_A_WAIT_VRISE:
213
217
mod_timer(&glue->timer, jiffies +
···
239
245
default:
240
246
break;
241
247
}
242
-
spin_unlock_irqrestore(&musb->lock, flags);
243
248
249
+
return 0;
250
+
}
251
+
252
+
static void otg_timer(unsigned long _musb)
253
+
{
254
+
struct musb *musb = (void *)_musb;
255
+
struct device *dev = musb->controller;
256
+
unsigned long flags;
257
+
int err;
258
+
259
+
err = pm_runtime_get(dev);
260
+
if ((err != -EINPROGRESS) && err < 0) {
261
+
dev_err(dev, "Poll could not pm_runtime_get: %i\n", err);
262
+
pm_runtime_put_noidle(dev);
263
+
264
+
return;
265
+
}
266
+
267
+
spin_lock_irqsave(&musb->lock, flags);
268
+
err = musb_queue_resume_work(musb, dsps_check_status, NULL);
269
+
if (err < 0)
270
+
dev_err(dev, "%s resume work: %i\n", __func__, err);
271
+
spin_unlock_irqrestore(&musb->lock, flags);
244
272
pm_runtime_mark_last_busy(dev);
245
273
pm_runtime_put_autosuspend(dev);
246
274
}
···
783
767
784
768
platform_set_drvdata(pdev, glue);
785
769
pm_runtime_enable(&pdev->dev);
786
-
pm_runtime_use_autosuspend(&pdev->dev);
787
-
pm_runtime_set_autosuspend_delay(&pdev->dev, 200);
788
-
789
-
ret = pm_runtime_get_sync(&pdev->dev);
790
-
if (ret < 0) {
791
-
dev_err(&pdev->dev, "pm_runtime_get_sync FAILED");
792
-
goto err2;
793
-
}
794
-
795
770
ret = dsps_create_musb_pdev(glue, pdev);
796
771
if (ret)
797
-
goto err3;
798
-
799
-
pm_runtime_mark_last_busy(&pdev->dev);
800
-
pm_runtime_put_autosuspend(&pdev->dev);
772
+
goto err;
801
773
802
774
return 0;
803
775
804
-
err3:
805
-
pm_runtime_put_sync(&pdev->dev);
806
-
err2:
807
-
pm_runtime_dont_use_autosuspend(&pdev->dev);
776
+
err:
808
777
pm_runtime_disable(&pdev->dev);
809
778
return ret;
810
779
}
···
800
799
801
800
platform_device_unregister(glue->musb);
802
801
803
-
/* disable usbss clocks */
804
-
pm_runtime_dont_use_autosuspend(&pdev->dev);
805
-
pm_runtime_put_sync(&pdev->dev);
806
802
pm_runtime_disable(&pdev->dev);
807
803
808
804
return 0;
+32
-7
drivers/usb/musb/musb_gadget.c
+32
-7
drivers/usb/musb/musb_gadget.c
···
1114
1114
musb_ep->dma ? "dma, " : "",
1115
1115
musb_ep->packet_sz);
1116
1116
1117
-
schedule_work(&musb->irq_work);
1117
+
schedule_delayed_work(&musb->irq_work, 0);
1118
1118
1119
1119
fail:
1120
1120
spin_unlock_irqrestore(&musb->lock, flags);
···
1158
1158
musb_ep->desc = NULL;
1159
1159
musb_ep->end_point.desc = NULL;
1160
1160
1161
-
schedule_work(&musb->irq_work);
1161
+
schedule_delayed_work(&musb->irq_work, 0);
1162
1162
1163
1163
spin_unlock_irqrestore(&(musb->lock), flags);
1164
1164
···
1222
1222
rxstate(musb, req);
1223
1223
}
1224
1224
1225
+
static int musb_ep_restart_resume_work(struct musb *musb, void *data)
1226
+
{
1227
+
struct musb_request *req = data;
1228
+
1229
+
musb_ep_restart(musb, req);
1230
+
1231
+
return 0;
1232
+
}
1233
+
1225
1234
static int musb_gadget_queue(struct usb_ep *ep, struct usb_request *req,
1226
1235
gfp_t gfp_flags)
1227
1236
{
1228
1237
struct musb_ep *musb_ep;
1229
1238
struct musb_request *request;
1230
1239
struct musb *musb;
1231
-
int status = 0;
1240
+
int status;
1232
1241
unsigned long lockflags;
1233
1242
1234
1243
if (!ep || !req)
···
1254
1245
if (request->ep != musb_ep)
1255
1246
return -EINVAL;
1256
1247
1248
+
status = pm_runtime_get(musb->controller);
1249
+
if ((status != -EINPROGRESS) && status < 0) {
1250
+
dev_err(musb->controller,
1251
+
"pm runtime get failed in %s\n",
1252
+
__func__);
1253
+
pm_runtime_put_noidle(musb->controller);
1254
+
1255
+
return status;
1256
+
}
1257
+
status = 0;
1258
+
1257
1259
trace_musb_req_enq(request);
1258
1260
1259
1261
/* request is mine now... */
···
1275
1255
1276
1256
map_dma_buffer(request, musb, musb_ep);
1277
1257
1278
-
pm_runtime_get_sync(musb->controller);
1279
1258
spin_lock_irqsave(&musb->lock, lockflags);
1280
1259
1281
1260
/* don't queue if the ep is down */
···
1290
1271
list_add_tail(&request->list, &musb_ep->req_list);
1291
1272
1292
1273
/* it this is the head of the queue, start i/o ... */
1293
-
if (!musb_ep->busy && &request->list == musb_ep->req_list.next)
1294
-
musb_ep_restart(musb, request);
1274
+
if (!musb_ep->busy && &request->list == musb_ep->req_list.next) {
1275
+
status = musb_queue_resume_work(musb,
1276
+
musb_ep_restart_resume_work,
1277
+
request);
1278
+
if (status < 0)
1279
+
dev_err(musb->controller, "%s resume work: %i\n",
1280
+
__func__, status);
1281
+
}
1295
1282
1296
1283
unlock:
1297
1284
spin_unlock_irqrestore(&musb->lock, lockflags);
···
1994
1969
*/
1995
1970
1996
1971
/* Force check of devctl register for PM runtime */
1997
-
schedule_work(&musb->irq_work);
1972
+
schedule_delayed_work(&musb->irq_work, 0);
1998
1973
1999
1974
pm_runtime_mark_last_busy(musb->controller);
2000
1975
pm_runtime_put_autosuspend(musb->controller);
+4
-6
drivers/usb/musb/omap2430.c
+4
-6
drivers/usb/musb/omap2430.c
···
513
513
}
514
514
515
515
pm_runtime_enable(glue->dev);
516
-
pm_runtime_use_autosuspend(glue->dev);
517
-
pm_runtime_set_autosuspend_delay(glue->dev, 100);
518
516
519
517
ret = platform_device_add(musb);
520
518
if (ret) {
521
519
dev_err(&pdev->dev, "failed to register musb device\n");
522
-
goto err2;
520
+
goto err3;
523
521
}
524
522
525
523
return 0;
524
+
525
+
err3:
526
+
pm_runtime_disable(glue->dev);
526
527
527
528
err2:
528
529
platform_device_put(musb);
···
536
535
{
537
536
struct omap2430_glue *glue = platform_get_drvdata(pdev);
538
537
539
-
pm_runtime_get_sync(glue->dev);
540
538
platform_device_unregister(glue->musb);
541
-
pm_runtime_put_sync(glue->dev);
542
-
pm_runtime_dont_use_autosuspend(glue->dev);
543
539
pm_runtime_disable(glue->dev);
544
540
545
541
return 0;
+3
-3
drivers/usb/musb/tusb6010.c
+3
-3
drivers/usb/musb/tusb6010.c
···
724
724
dev_dbg(musb->controller, "vbus change, %s, otg %03x\n",
725
725
usb_otg_state_string(musb->xceiv->otg->state), otg_stat);
726
726
idle_timeout = jiffies + (1 * HZ);
727
-
schedule_work(&musb->irq_work);
727
+
schedule_delayed_work(&musb->irq_work, 0);
728
728
729
729
} else /* A-dev state machine */ {
730
730
dev_dbg(musb->controller, "vbus change, %s, otg %03x\n",
···
814
814
break;
815
815
}
816
816
}
817
-
schedule_work(&musb->irq_work);
817
+
schedule_delayed_work(&musb->irq_work, 0);
818
818
819
819
return idle_timeout;
820
820
}
···
864
864
musb_writel(tbase, TUSB_PRCM_WAKEUP_CLEAR, reg);
865
865
if (reg & ~TUSB_PRCM_WNORCS) {
866
866
musb->is_active = 1;
867
-
schedule_work(&musb->irq_work);
867
+
schedule_delayed_work(&musb->irq_work, 0);
868
868
}
869
869
dev_dbg(musb->controller, "wake %sactive %02x\n",
870
870
musb->is_active ? "" : "in", reg);
+1
drivers/usb/serial/cp210x.c
+1
drivers/usb/serial/cp210x.c
···
131
131
{ USB_DEVICE(0x10C4, 0x88A4) }, /* MMB Networks ZigBee USB Device */
132
132
{ USB_DEVICE(0x10C4, 0x88A5) }, /* Planet Innovation Ingeni ZigBee USB Device */
133
133
{ USB_DEVICE(0x10C4, 0x8946) }, /* Ketra N1 Wireless Interface */
134
+
{ USB_DEVICE(0x10C4, 0x8962) }, /* Brim Brothers charging dock */
134
135
{ USB_DEVICE(0x10C4, 0x8977) }, /* CEL MeshWorks DevKit Device */
135
136
{ USB_DEVICE(0x10C4, 0x8998) }, /* KCF Technologies PRN */
136
137
{ USB_DEVICE(0x10C4, 0x8A2A) }, /* HubZ dual ZigBee and Z-Wave dongle */
+2
drivers/usb/serial/ftdi_sio.c
+2
drivers/usb/serial/ftdi_sio.c
···
1012
1012
{ USB_DEVICE(ICPDAS_VID, ICPDAS_I7561U_PID) },
1013
1013
{ USB_DEVICE(ICPDAS_VID, ICPDAS_I7563U_PID) },
1014
1014
{ USB_DEVICE(WICED_VID, WICED_USB20706V2_PID) },
1015
+
{ USB_DEVICE(TI_VID, TI_CC3200_LAUNCHPAD_PID),
1016
+
.driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
1015
1017
{ } /* Terminating entry */
1016
1018
};
1017
1019
+6
drivers/usb/serial/ftdi_sio_ids.h
+6
drivers/usb/serial/ftdi_sio_ids.h
···
596
596
#define STK541_PID 0x2109 /* Zigbee Controller */
597
597
598
598
/*
599
+
* Texas Instruments
600
+
*/
601
+
#define TI_VID 0x0451
602
+
#define TI_CC3200_LAUNCHPAD_PID 0xC32A /* SimpleLink Wi-Fi CC3200 LaunchPad */
603
+
604
+
/*
599
605
* Blackfin gnICE JTAG
600
606
* http://docs.blackfin.uclinux.org/doku.php?id=hw:jtag:gnice
601
607
*/
+6
-1
drivers/usb/storage/transport.c
+6
-1
drivers/usb/storage/transport.c
···
954
954
955
955
/* COMMAND STAGE */
956
956
/* let's send the command via the control pipe */
957
+
/*
958
+
* Command is sometime (f.e. after scsi_eh_prep_cmnd) on the stack.
959
+
* Stack may be vmallocated. So no DMA for us. Make a copy.
960
+
*/
961
+
memcpy(us->iobuf, srb->cmnd, srb->cmd_len);
957
962
result = usb_stor_ctrl_transfer(us, us->send_ctrl_pipe,
958
963
US_CBI_ADSC,
959
964
USB_TYPE_CLASS | USB_RECIP_INTERFACE, 0,
960
-
us->ifnum, srb->cmnd, srb->cmd_len);
965
+
us->ifnum, us->iobuf, srb->cmd_len);
961
966
962
967
/* check the return code for the command */
963
968
usb_stor_dbg(us, "Call to usb_stor_ctrl_transfer() returned %d\n",