Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'usb-3.12-rc2' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb
Pull USB fixes from Greg KH:
"Here are a number of small USB fixes for 3.12-rc2.
One is a revert of a EHCI change that isn't quite ready for 3.12.
Others are minor things, gadget fixes, Kconfig fixes, and some quirks
and documentation updates.
All have been in linux-next for a bit"
* tag 'usb-3.12-rc2' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb:
USB: pl2303: distinguish between original and cloned HX chips
USB: Faraday fotg210: fix email addresses
USB: fix typo in usb serial simple driver Kconfig
Revert "USB: EHCI: support running URB giveback in tasklet context"
usb: s3c-hsotg: do not disconnect gadget when receiving ErlySusp intr
usb: s3c-hsotg: fix unregistration function
usb: gadget: f_mass_storage: reset endpoint driver data when disabled
usb: host: fsl-mph-dr-of: Staticize local symbols
usb: gadget: f_eem: Staticize eem_alloc
usb: gadget: f_ecm: Staticize ecm_alloc
usb: phy: omap-usb3: Fix return value
usb: dwc3: gadget: avoid memory leak when failing to allocate all eps
usb: dwc3: remove extcon dependency
usb: gadget: add '__ref' for rndis_config_register() and cdc_config_register()
usb: dwc3: pci: add support for BayTrail
usb: gadget: cdc2: fix conversion to new interface of f_ecm
usb: gadget: fix a bug and a WARN_ON in dummy-hcd
usb: gadget: mv_u3d_core: fix violation of locking discipline in mv_u3d_ep_disable()
+81
-72
-1
drivers/usb/dwc3/Kconfig
-1
drivers/usb/dwc3/Kconfig
+2
drivers/usb/dwc3/dwc3-pci.c
+2
drivers/usb/dwc3/dwc3-pci.c
···
28
28
/* FIXME define these in <linux/pci_ids.h> */
29
29
#define PCI_VENDOR_ID_SYNOPSYS 0x16c3
30
30
#define PCI_DEVICE_ID_SYNOPSYS_HAPSUSB3 0xabcd
31
+
#define PCI_DEVICE_ID_INTEL_BYT 0x0f37
31
32
32
33
struct dwc3_pci {
33
34
struct device *dev;
···
188
187
PCI_DEVICE(PCI_VENDOR_ID_SYNOPSYS,
189
188
PCI_DEVICE_ID_SYNOPSYS_HAPSUSB3),
190
189
},
190
+
{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_BYT), },
191
191
{ } /* Terminating Entry */
192
192
};
193
193
MODULE_DEVICE_TABLE(pci, dwc3_pci_id_table);
+2
-4
drivers/usb/dwc3/gadget.c
+2
-4
drivers/usb/dwc3/gadget.c
···
2611
2611
ret = usb_add_gadget_udc(dwc->dev, &dwc->gadget);
2612
2612
if (ret) {
2613
2613
dev_err(dwc->dev, "failed to register udc\n");
2614
-
goto err5;
2614
+
goto err4;
2615
2615
}
2616
2616
2617
2617
return 0;
2618
2618
2619
-
err5:
2620
-
dwc3_gadget_free_endpoints(dwc);
2621
-
2622
2619
err4:
2620
+
dwc3_gadget_free_endpoints(dwc);
2623
2621
dma_free_coherent(dwc->dev, DWC3_EP0_BOUNCE_SIZE,
2624
2622
dwc->ep0_bounce, dwc->ep0_bounce_addr);
2625
2623
+1
-18
drivers/usb/gadget/cdc2.c
+1
-18
drivers/usb/gadget/cdc2.c
···
113
113
c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
114
114
}
115
115
116
-
fi_ecm = usb_get_function_instance("ecm");
117
-
if (IS_ERR(fi_ecm)) {
118
-
status = PTR_ERR(fi_ecm);
119
-
goto err_func_ecm;
120
-
}
121
-
122
116
f_ecm = usb_get_function(fi_ecm);
123
117
if (IS_ERR(f_ecm)) {
124
118
status = PTR_ERR(f_ecm);
···
123
129
if (status)
124
130
goto err_add_ecm;
125
131
126
-
fi_serial = usb_get_function_instance("acm");
127
-
if (IS_ERR(fi_serial)) {
128
-
status = PTR_ERR(fi_serial);
129
-
goto err_get_acm;
130
-
}
131
-
132
132
f_acm = usb_get_function(fi_serial);
133
133
if (IS_ERR(f_acm)) {
134
134
status = PTR_ERR(f_acm);
135
-
goto err_func_acm;
135
+
goto err_get_acm;
136
136
}
137
137
138
138
status = usb_add_function(c, f_acm);
139
139
if (status)
140
140
goto err_add_acm;
141
-
142
141
return 0;
143
142
144
143
err_add_acm:
145
144
usb_put_function(f_acm);
146
-
err_func_acm:
147
-
usb_put_function_instance(fi_serial);
148
145
err_get_acm:
149
146
usb_remove_function(c, f_ecm);
150
147
err_add_ecm:
151
148
usb_put_function(f_ecm);
152
149
err_get_ecm:
153
-
usb_put_function_instance(fi_ecm);
154
-
err_func_ecm:
155
150
return status;
156
151
}
157
152
+4
-3
drivers/usb/gadget/dummy_hcd.c
+4
-3
drivers/usb/gadget/dummy_hcd.c
···
923
923
struct dummy_hcd *dum_hcd = gadget_to_dummy_hcd(g);
924
924
struct dummy *dum = dum_hcd->dum;
925
925
926
-
dev_dbg(udc_dev(dum), "unregister gadget driver '%s'\n",
927
-
driver->driver.name);
926
+
if (driver)
927
+
dev_dbg(udc_dev(dum), "unregister gadget driver '%s'\n",
928
+
driver->driver.name);
928
929
929
930
dum->driver = NULL;
930
931
···
1001
1000
{
1002
1001
struct dummy *dum = platform_get_drvdata(pdev);
1003
1002
1004
-
usb_del_gadget_udc(&dum->gadget);
1005
1003
device_remove_file(&dum->gadget.dev, &dev_attr_function);
1004
+
usb_del_gadget_udc(&dum->gadget);
1006
1005
return 0;
1007
1006
}
1008
1007
+1
-1
drivers/usb/gadget/f_ecm.c
+1
-1
drivers/usb/gadget/f_ecm.c
···
995
995
usb_ep_free_request(ecm->notify, ecm->notify_req);
996
996
}
997
997
998
-
struct usb_function *ecm_alloc(struct usb_function_instance *fi)
998
+
static struct usb_function *ecm_alloc(struct usb_function_instance *fi)
999
999
{
1000
1000
struct f_ecm *ecm;
1001
1001
struct f_ecm_opts *opts;
+1
-1
drivers/usb/gadget/f_eem.c
+1
-1
drivers/usb/gadget/f_eem.c
+2
drivers/usb/gadget/f_mass_storage.c
+2
drivers/usb/gadget/f_mass_storage.c
···
2260
2260
/* Disable the endpoints */
2261
2261
if (fsg->bulk_in_enabled) {
2262
2262
usb_ep_disable(fsg->bulk_in);
2263
+
fsg->bulk_in->driver_data = NULL;
2263
2264
fsg->bulk_in_enabled = 0;
2264
2265
}
2265
2266
if (fsg->bulk_out_enabled) {
2266
2267
usb_ep_disable(fsg->bulk_out);
2268
+
fsg->bulk_out->driver_data = NULL;
2267
2269
fsg->bulk_out_enabled = 0;
2268
2270
}
2269
2271
+1
-1
drivers/usb/gadget/fotg210-udc.c
+1
-1
drivers/usb/gadget/fotg210-udc.c
···
1214
1214
1215
1215
module_platform_driver(fotg210_driver);
1216
1216
1217
-
MODULE_AUTHOR("Yuan-Hsin Chen <yhchen@faraday-tech.com>");
1217
+
MODULE_AUTHOR("Yuan-Hsin Chen, Feng-Hsin Chiang <john453@faraday-tech.com>");
1218
1218
MODULE_LICENSE("GPL");
1219
1219
MODULE_DESCRIPTION(DRIVER_DESC);
+1
-1
drivers/usb/gadget/fusb300_udc.c
+1
-1
drivers/usb/gadget/fusb300_udc.c
···
22
22
23
23
MODULE_DESCRIPTION("FUSB300 USB gadget driver");
24
24
MODULE_LICENSE("GPL");
25
-
MODULE_AUTHOR("Yuan Hsin Chen <yhchen@faraday-tech.com>");
25
+
MODULE_AUTHOR("Yuan-Hsin Chen, Feng-Hsin Chiang <john453@faraday-tech.com>");
26
26
MODULE_ALIAS("platform:fusb300_udc");
27
27
28
28
#define DRIVER_VERSION "20 October 2010"
+4
-4
drivers/usb/gadget/multi.c
+4
-4
drivers/usb/gadget/multi.c
···
179
179
return ret;
180
180
}
181
181
182
-
static int rndis_config_register(struct usb_composite_dev *cdev)
182
+
static __ref int rndis_config_register(struct usb_composite_dev *cdev)
183
183
{
184
184
static struct usb_configuration config = {
185
185
.bConfigurationValue = MULTI_RNDIS_CONFIG_NUM,
···
194
194
195
195
#else
196
196
197
-
static int rndis_config_register(struct usb_composite_dev *cdev)
197
+
static __ref int rndis_config_register(struct usb_composite_dev *cdev)
198
198
{
199
199
return 0;
200
200
}
···
241
241
return ret;
242
242
}
243
243
244
-
static int cdc_config_register(struct usb_composite_dev *cdev)
244
+
static __ref int cdc_config_register(struct usb_composite_dev *cdev)
245
245
{
246
246
static struct usb_configuration config = {
247
247
.bConfigurationValue = MULTI_CDC_CONFIG_NUM,
···
256
256
257
257
#else
258
258
259
-
static int cdc_config_register(struct usb_composite_dev *cdev)
259
+
static __ref int cdc_config_register(struct usb_composite_dev *cdev)
260
260
{
261
261
return 0;
262
262
}
+3
drivers/usb/gadget/mv_u3d_core.c
+3
drivers/usb/gadget/mv_u3d_core.c
···
645
645
struct mv_u3d_ep *ep;
646
646
struct mv_u3d_ep_context *ep_context;
647
647
u32 epxcr, direction;
648
+
unsigned long flags;
648
649
649
650
if (!_ep)
650
651
return -EINVAL;
···
662
661
direction = mv_u3d_ep_dir(ep);
663
662
664
663
/* nuke all pending requests (does flush) */
664
+
spin_lock_irqsave(&u3d->lock, flags);
665
665
mv_u3d_nuke(ep, -ESHUTDOWN);
666
+
spin_unlock_irqrestore(&u3d->lock, flags);
666
667
667
668
/* Disable the endpoint for Rx or Tx and reset the endpoint type */
668
669
if (direction == MV_U3D_EP_DIR_OUT) {
+4
-9
drivers/usb/gadget/s3c-hsotg.c
+4
-9
drivers/usb/gadget/s3c-hsotg.c
···
2475
2475
if (gintsts & GINTSTS_ErlySusp) {
2476
2476
dev_dbg(hsotg->dev, "GINTSTS_ErlySusp\n");
2477
2477
writel(GINTSTS_ErlySusp, hsotg->regs + GINTSTS);
2478
-
2479
-
s3c_hsotg_disconnect(hsotg);
2480
2478
}
2481
2479
2482
2480
/*
···
2960
2962
if (!hsotg)
2961
2963
return -ENODEV;
2962
2964
2963
-
if (!driver || driver != hsotg->driver || !driver->unbind)
2964
-
return -EINVAL;
2965
-
2966
2965
/* all endpoints should be shutdown */
2967
2966
for (ep = 0; ep < hsotg->num_of_eps; ep++)
2968
2967
s3c_hsotg_ep_disable(&hsotg->eps[ep].ep);
···
2967
2972
spin_lock_irqsave(&hsotg->lock, flags);
2968
2973
2969
2974
s3c_hsotg_phy_disable(hsotg);
2970
-
regulator_bulk_disable(ARRAY_SIZE(hsotg->supplies), hsotg->supplies);
2971
2975
2972
-
hsotg->driver = NULL;
2976
+
if (!driver)
2977
+
hsotg->driver = NULL;
2978
+
2973
2979
hsotg->gadget.speed = USB_SPEED_UNKNOWN;
2974
2980
2975
2981
spin_unlock_irqrestore(&hsotg->lock, flags);
2976
2982
2977
-
dev_info(hsotg->dev, "unregistered gadget driver '%s'\n",
2978
-
driver->driver.name);
2983
+
regulator_bulk_disable(ARRAY_SIZE(hsotg->supplies), hsotg->supplies);
2979
2984
2980
2985
return 0;
2981
2986
}
+1
-1
drivers/usb/host/ehci-fsl.c
+1
-1
drivers/usb/host/ehci-fsl.c
+1
-1
drivers/usb/host/ehci-grlib.c
+1
-1
drivers/usb/host/ehci-grlib.c
+1
-1
drivers/usb/host/ehci-hcd.c
+1
-1
drivers/usb/host/ehci-hcd.c
+1
-1
drivers/usb/host/ehci-mv.c
+1
-1
drivers/usb/host/ehci-mv.c
+1
-1
drivers/usb/host/ehci-octeon.c
+1
-1
drivers/usb/host/ehci-octeon.c
+1
-1
drivers/usb/host/ehci-pmcmsp.c
+1
-1
drivers/usb/host/ehci-pmcmsp.c
+1
-1
drivers/usb/host/ehci-ppc-of.c
+1
-1
drivers/usb/host/ehci-ppc-of.c
+1
-1
drivers/usb/host/ehci-ps3.c
+1
-1
drivers/usb/host/ehci-ps3.c
+5
drivers/usb/host/ehci-q.c
+5
drivers/usb/host/ehci-q.c
···
247
247
248
248
static void
249
249
ehci_urb_done(struct ehci_hcd *ehci, struct urb *urb, int status)
250
+
__releases(ehci->lock)
251
+
__acquires(ehci->lock)
250
252
{
251
253
if (usb_pipetype(urb->pipe) == PIPE_INTERRUPT) {
252
254
/* ... update hc-wide periodic stats */
···
274
272
urb->actual_length, urb->transfer_buffer_length);
275
273
#endif
276
274
275
+
/* complete() can reenter this HCD */
277
276
usb_hcd_unlink_urb_from_ep(ehci_to_hcd(ehci), urb);
277
+
spin_unlock (&ehci->lock);
278
278
usb_hcd_giveback_urb(ehci_to_hcd(ehci), urb, status);
279
+
spin_lock (&ehci->lock);
279
280
}
280
281
281
282
static int qh_schedule (struct ehci_hcd *ehci, struct ehci_qh *qh);
+1
-1
drivers/usb/host/ehci-sead3.c
+1
-1
drivers/usb/host/ehci-sead3.c
+1
-1
drivers/usb/host/ehci-sh.c
+1
-1
drivers/usb/host/ehci-sh.c
+1
-1
drivers/usb/host/ehci-tilegx.c
+1
-1
drivers/usb/host/ehci-tilegx.c
+1
-1
drivers/usb/host/ehci-w90x900.c
+1
-1
drivers/usb/host/ehci-w90x900.c
+1
-1
drivers/usb/host/ehci-xilinx-of.c
+1
-1
drivers/usb/host/ehci-xilinx-of.c
+3
-3
drivers/usb/host/fsl-mph-dr-of.c
+3
-3
drivers/usb/host/fsl-mph-dr-of.c
···
24
24
enum fsl_usb2_operating_modes op_mode; /* operating mode */
25
25
};
26
26
27
-
struct fsl_usb2_dev_data dr_mode_data[] = {
27
+
static struct fsl_usb2_dev_data dr_mode_data[] = {
28
28
{
29
29
.dr_mode = "host",
30
30
.drivers = { "fsl-ehci", NULL, NULL, },
···
42
42
},
43
43
};
44
44
45
-
struct fsl_usb2_dev_data *get_dr_mode_data(struct device_node *np)
45
+
static struct fsl_usb2_dev_data *get_dr_mode_data(struct device_node *np)
46
46
{
47
47
const unsigned char *prop;
48
48
int i;
···
75
75
return FSL_USB2_PHY_NONE;
76
76
}
77
77
78
-
struct platform_device *fsl_usb2_device_register(
78
+
static struct platform_device *fsl_usb2_device_register(
79
79
struct platform_device *ofdev,
80
80
struct fsl_usb2_platform_data *pdata,
81
81
const char *name, int id)
+1
-1
drivers/usb/phy/phy-omap-usb3.c
+1
-1
drivers/usb/phy/phy-omap-usb3.c
+1
-1
drivers/usb/serial/Kconfig
+1
-1
drivers/usb/serial/Kconfig
+32
-11
drivers/usb/serial/pl2303.c
+32
-11
drivers/usb/serial/pl2303.c
···
139
139
HX_TA, /* HX(A) / X(A) / TA version */ /* TODO: improve */
140
140
HXD_EA_RA_SA, /* HXD / EA / RA / SA version */ /* TODO: improve */
141
141
TB, /* TB version */
142
+
HX_CLONE, /* Cheap and less functional clone of the HX chip */
142
143
};
143
144
/*
144
145
* NOTE: don't know the difference between type 0 and type 1,
···
207
206
* the device descriptors of the X/HX, HXD, EA, RA, SA, TA, TB
208
207
*/
209
208
if (le16_to_cpu(serial->dev->descriptor.bcdDevice) == 0x300) {
210
-
type = HX_TA;
211
-
type_str = "X/HX/TA";
209
+
/* Check if the device is a clone */
210
+
pl2303_vendor_read(0x9494, 0, serial, buf);
211
+
/*
212
+
* NOTE: Not sure if this read is really needed.
213
+
* The HX returns 0x00, the clone 0x02, but the Windows
214
+
* driver seems to ignore the value and continues.
215
+
*/
216
+
pl2303_vendor_write(0x0606, 0xaa, serial);
217
+
pl2303_vendor_read(0x8686, 0, serial, buf);
218
+
if (buf[0] != 0xaa) {
219
+
type = HX_CLONE;
220
+
type_str = "X/HX clone (limited functionality)";
221
+
} else {
222
+
type = HX_TA;
223
+
type_str = "X/HX/TA";
224
+
}
225
+
pl2303_vendor_write(0x0606, 0x00, serial);
212
226
} else if (le16_to_cpu(serial->dev->descriptor.bcdDevice)
213
227
== 0x400) {
214
228
type = HXD_EA_RA_SA;
···
321
305
{
322
306
/*
323
307
* NOTE: Only the values defined in baud_sup are supported !
324
-
* => if unsupported values are set, the PL2303 seems to
325
-
* use 9600 baud (at least my PL2303X always does)
308
+
* => if unsupported values are set, the PL2303 uses 9600 baud instead
309
+
* => HX clones just don't work at unsupported baud rates < 115200 baud,
310
+
* for baud rates > 115200 they run at 115200 baud
326
311
*/
327
312
const int baud_sup[] = { 75, 150, 300, 600, 1200, 1800, 2400, 3600,
328
313
4800, 7200, 9600, 14400, 19200, 28800, 38400,
···
333
316
* NOTE: With the exception of type_0/1 devices, the following
334
317
* additional baud rates are supported (tested with HX rev. 3A only):
335
318
* 110*, 56000*, 128000, 134400, 161280, 201600, 256000*, 268800,
336
-
* 403200, 806400. (*: not HX)
319
+
* 403200, 806400. (*: not HX and HX clones)
337
320
*
338
321
* Maximum values: HXD, TB: 12000000; HX, TA: 6000000;
339
-
* type_0+1: 1228800; RA: 921600; SA: 115200
322
+
* type_0+1: 1228800; RA: 921600; HX clones, SA: 115200
340
323
*
341
324
* As long as we are not using this encoding method for anything else
342
-
* than the type_0+1 and HX chips, there is no point in complicating
343
-
* the code to support them.
325
+
* than the type_0+1, HX and HX clone chips, there is no point in
326
+
* complicating the code to support them.
344
327
*/
345
328
int i;
346
329
···
364
347
baud = min_t(int, baud, 6000000);
365
348
else if (type == type_0 || type == type_1)
366
349
baud = min_t(int, baud, 1228800);
350
+
else if (type == HX_CLONE)
351
+
baud = min_t(int, baud, 115200);
367
352
/* Direct (standard) baud rate encoding method */
368
353
put_unaligned_le32(baud, buf);
369
354
···
378
359
/*
379
360
* Divisor based baud rate encoding method
380
361
*
381
-
* NOTE: it's not clear if the type_0/1 chips support this method
362
+
* NOTE: HX clones do NOT support this method.
363
+
* It's not clear if the type_0/1 chips support it.
382
364
*
383
365
* divisor = 12MHz * 32 / baudrate = 2^A * B
384
366
*
···
472
452
* 1) Direct method: encodes the baud rate value directly
473
453
* => supported by all chip types
474
454
* 2) Divisor based method: encodes a divisor to a base value (12MHz*32)
475
-
* => supported by HX chips (and likely not by type_0/1 chips)
455
+
* => not supported by HX clones (and likely type_0/1 chips)
476
456
*
477
457
* NOTE: Although the divisor based baud rate encoding method is much
478
458
* more flexible, some of the standard baud rate values can not be
···
480
460
* the device likely uses the same baud rate generator for both methods
481
461
* so that there is likley no difference.
482
462
*/
483
-
if (type == type_0 || type == type_1)
463
+
if (type == type_0 || type == type_1 || type == HX_CLONE)
484
464
baud = pl2303_baudrate_encode_direct(baud, type, buf);
485
465
else
486
466
baud = pl2303_baudrate_encode_divisor(baud, type, buf);
···
833
813
result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
834
814
BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
835
815
0, NULL, 0, 100);
816
+
/* NOTE: HX clones don't support sending breaks, -EPIPE is returned */
836
817
if (result)
837
818
dev_err(&port->dev, "error sending break = %d\n", result);
838
819
}