Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'usb-4.1-rc7' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb
Pull USB and PHY driver fixes from Greg KH:
"Here are some USB and PHY driver fixes that resolve some reported
regressions. Also in here are some new device ids.
All of the details are in the shortlog and these patches have been in
linux-next with no problems"
* tag 'usb-4.1-rc7' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb: (22 commits)
USB: cp210x: add ID for HubZ dual ZigBee and Z-Wave dongle
usb: renesas_usbhs: Don't disable the pipe if Control write status stage
usb: renesas_usbhs: Fix fifo unclear in usbhsf_prepare_pop
usb: gadget: f_fs: fix check in read operation
usb: musb: fix order of conditions for assigning end point operations
usb: gadget: f_uac1: check return code from config_ep_by_speed
usb: gadget: ffs: fix: Always call ffs_closed() in ffs_data_clear()
usb: gadget: g_ffs: Fix counting of missing_functions
usb: s3c2410_udc: correct reversed pullup logic
usb: dwc3: gadget: Fix incorrect DEPCMD and DGCMD status macros
usb: phy: tahvo: Pass the IRQF_ONESHOT flag
usb: phy: ab8500-usb: Pass the IRQF_ONESHOT flag
usb: renesas_usbhs: Revise the binding document about the dma-names
usb: host: xhci: add mutex for non-thread-safe data
usb: make module xhci_hcd removable
USB: serial: ftdi_sio: Add support for a Motion Tracker Development Board
usb: gadget: f_midi: fix segfault when reading empty id
phy: phy-rcar-gen2: Fix USBHS_UGSTS_LOCK value
phy: omap-usb2: invoke pm_runtime_disable on error path
phy: fix Kconfig dependencies
...
+123
-63
+2
-4
Documentation/devicetree/bindings/usb/renesas_usbhs.txt
+2
-4
Documentation/devicetree/bindings/usb/renesas_usbhs.txt
···
15
15
- phys: phandle + phy specifier pair
16
16
- phy-names: must be "usb"
17
17
- dmas: Must contain a list of references to DMA specifiers.
18
-
- dma-names : Must contain a list of DMA names:
19
-
- tx0 ... tx<n>
20
-
- rx0 ... rx<n>
21
-
- This <n> means DnFIFO in USBHS module.
18
+
- dma-names : named "ch%d", where %d is the channel number ranging from zero
19
+
to the number of channels (DnFIFOs) minus one.
22
20
23
21
Example:
24
22
usbhs: usb@e6590000 {
+7
-3
drivers/phy/Kconfig
+7
-3
drivers/phy/Kconfig
···
38
38
config PHY_DM816X_USB
39
39
tristate "TI dm816x USB PHY driver"
40
40
depends on ARCH_OMAP2PLUS
41
+
depends on USB_SUPPORT
41
42
select GENERIC_PHY
43
+
select USB_PHY
42
44
help
43
45
Enable this for dm816x USB to work.
44
46
···
99
97
config OMAP_USB2
100
98
tristate "OMAP USB2 PHY Driver"
101
99
depends on ARCH_OMAP2PLUS
102
-
depends on USB_PHY
100
+
depends on USB_SUPPORT
103
101
select GENERIC_PHY
102
+
select USB_PHY
104
103
select OMAP_CONTROL_PHY
105
104
depends on OMAP_OCP2SCP
106
105
help
···
125
122
config TWL4030_USB
126
123
tristate "TWL4030 USB Transceiver Driver"
127
124
depends on TWL4030_CORE && REGULATOR_TWL4030 && USB_MUSB_OMAP2PLUS
128
-
depends on USB_PHY
125
+
depends on USB_SUPPORT
129
126
select GENERIC_PHY
127
+
select USB_PHY
130
128
help
131
129
Enable this to support the USB OTG transceiver on TWL4030
132
130
family chips (including the TWL5030 and TPS659x0 devices).
···
308
304
309
305
config PHY_QCOM_UFS
310
306
tristate "Qualcomm UFS PHY driver"
311
-
depends on OF && ARCH_MSM
307
+
depends on OF && ARCH_QCOM
312
308
select GENERIC_PHY
313
309
help
314
310
Support for UFS PHY on QCOM chipsets.
+2
-2
drivers/phy/phy-core.c
+2
-2
drivers/phy/phy-core.c
···
530
530
{
531
531
struct phy *phy = phy_get(dev, string);
532
532
533
-
if (PTR_ERR(phy) == -ENODEV)
533
+
if (IS_ERR(phy) && (PTR_ERR(phy) == -ENODEV))
534
534
phy = NULL;
535
535
536
536
return phy;
···
584
584
{
585
585
struct phy *phy = devm_phy_get(dev, string);
586
586
587
-
if (PTR_ERR(phy) == -ENODEV)
587
+
if (IS_ERR(phy) && (PTR_ERR(phy) == -ENODEV))
588
588
phy = NULL;
589
589
590
590
return phy;
+1
drivers/phy/phy-omap-usb2.c
+1
drivers/phy/phy-omap-usb2.c
+2
-2
drivers/phy/phy-rcar-gen2.c
+2
-2
drivers/phy/phy-rcar-gen2.c
···
23
23
#define USBHS_LPSTS 0x02
24
24
#define USBHS_UGCTRL 0x80
25
25
#define USBHS_UGCTRL2 0x84
26
-
#define USBHS_UGSTS 0x88 /* The manuals have 0x90 */
26
+
#define USBHS_UGSTS 0x88 /* From technical update */
27
27
28
28
/* Low Power Status register (LPSTS) */
29
29
#define USBHS_LPSTS_SUSPM 0x4000
···
41
41
#define USBHS_UGCTRL2_USB0SEL_HS_USB 0x00000030
42
42
43
43
/* USB General status register (UGSTS) */
44
-
#define USBHS_UGSTS_LOCK 0x00000300 /* The manuals have 0x3 */
44
+
#define USBHS_UGSTS_LOCK 0x00000100 /* From technical update */
45
45
46
46
#define PHYS_PER_CHANNEL 2
47
47
+2
-2
drivers/usb/dwc3/core.h
+2
-2
drivers/usb/dwc3/core.h
···
339
339
#define DWC3_DGCMD_SET_ENDPOINT_NRDY 0x0c
340
340
#define DWC3_DGCMD_RUN_SOC_BUS_LOOPBACK 0x10
341
341
342
-
#define DWC3_DGCMD_STATUS(n) (((n) >> 15) & 1)
342
+
#define DWC3_DGCMD_STATUS(n) (((n) >> 12) & 0x0F)
343
343
#define DWC3_DGCMD_CMDACT (1 << 10)
344
344
#define DWC3_DGCMD_CMDIOC (1 << 8)
345
345
···
355
355
#define DWC3_DEPCMD_PARAM_SHIFT 16
356
356
#define DWC3_DEPCMD_PARAM(x) ((x) << DWC3_DEPCMD_PARAM_SHIFT)
357
357
#define DWC3_DEPCMD_GET_RSC_IDX(x) (((x) >> DWC3_DEPCMD_PARAM_SHIFT) & 0x7f)
358
-
#define DWC3_DEPCMD_STATUS(x) (((x) >> 15) & 1)
358
+
#define DWC3_DEPCMD_STATUS(x) (((x) >> 12) & 0x0F)
359
359
#define DWC3_DEPCMD_HIPRI_FORCERM (1 << 11)
360
360
#define DWC3_DEPCMD_CMDACT (1 << 10)
361
361
#define DWC3_DEPCMD_CMDIOC (1 << 8)
+9
-6
drivers/usb/gadget/function/f_fs.c
+9
-6
drivers/usb/gadget/function/f_fs.c
···
315
315
return ret;
316
316
}
317
317
318
-
set_bit(FFS_FL_CALL_CLOSED_CALLBACK, &ffs->flags);
319
318
return len;
320
319
}
321
320
break;
···
846
847
ret = ep->status;
847
848
if (io_data->read && ret > 0) {
848
849
ret = copy_to_iter(data, ret, &io_data->data);
849
-
if (unlikely(iov_iter_count(&io_data->data)))
850
+
if (!ret)
850
851
ret = -EFAULT;
851
852
}
852
853
}
···
1462
1463
{
1463
1464
ENTER();
1464
1465
1465
-
if (test_and_clear_bit(FFS_FL_CALL_CLOSED_CALLBACK, &ffs->flags))
1466
-
ffs_closed(ffs);
1466
+
ffs_closed(ffs);
1467
1467
1468
1468
BUG_ON(ffs->gadget);
1469
1469
···
3420
3422
ffs_obj->desc_ready = true;
3421
3423
ffs_obj->ffs_data = ffs;
3422
3424
3423
-
if (ffs_obj->ffs_ready_callback)
3425
+
if (ffs_obj->ffs_ready_callback) {
3424
3426
ret = ffs_obj->ffs_ready_callback(ffs);
3427
+
if (ret)
3428
+
goto done;
3429
+
}
3425
3430
3431
+
set_bit(FFS_FL_CALL_CLOSED_CALLBACK, &ffs->flags);
3426
3432
done:
3427
3433
ffs_dev_unlock();
3428
3434
return ret;
···
3445
3443
3446
3444
ffs_obj->desc_ready = false;
3447
3445
3448
-
if (ffs_obj->ffs_closed_callback)
3446
+
if (test_and_clear_bit(FFS_FL_CALL_CLOSED_CALLBACK, &ffs->flags) &&
3447
+
ffs_obj->ffs_closed_callback)
3449
3448
ffs_obj->ffs_closed_callback(ffs);
3450
3449
3451
3450
if (!ffs_obj->opts || ffs_obj->opts->no_configfs
+7
-1
drivers/usb/gadget/function/f_midi.c
+7
-1
drivers/usb/gadget/function/f_midi.c
···
973
973
int result;
974
974
975
975
mutex_lock(&opts->lock);
976
-
result = strlcpy(page, opts->id, PAGE_SIZE);
976
+
if (opts->id) {
977
+
result = strlcpy(page, opts->id, PAGE_SIZE);
978
+
} else {
979
+
page[0] = 0;
980
+
result = 0;
981
+
}
982
+
977
983
mutex_unlock(&opts->lock);
978
984
979
985
return result;
+4
-1
drivers/usb/gadget/function/f_uac1.c
+4
-1
drivers/usb/gadget/function/f_uac1.c
···
588
588
589
589
if (intf == 1) {
590
590
if (alt == 1) {
591
-
config_ep_by_speed(cdev->gadget, f, out_ep);
591
+
err = config_ep_by_speed(cdev->gadget, f, out_ep);
592
+
if (err)
593
+
return err;
594
+
592
595
usb_ep_enable(out_ep);
593
596
out_ep->driver_data = audio;
594
597
audio->copy_buf = f_audio_buffer_alloc(audio_buf_size);
+3
-1
drivers/usb/gadget/legacy/g_ffs.c
+3
-1
drivers/usb/gadget/legacy/g_ffs.c
+1
-1
drivers/usb/gadget/udc/s3c2410_udc.c
+1
-1
drivers/usb/gadget/udc/s3c2410_udc.c
+38
-19
drivers/usb/host/xhci.c
+38
-19
drivers/usb/host/xhci.c
···
3682
3682
{
3683
3683
struct xhci_hcd *xhci = hcd_to_xhci(hcd);
3684
3684
unsigned long flags;
3685
-
int ret;
3685
+
int ret, slot_id;
3686
3686
struct xhci_command *command;
3687
3687
3688
3688
command = xhci_alloc_command(xhci, false, false, GFP_KERNEL);
3689
3689
if (!command)
3690
3690
return 0;
3691
3691
3692
+
/* xhci->slot_id and xhci->addr_dev are not thread-safe */
3693
+
mutex_lock(&xhci->mutex);
3692
3694
spin_lock_irqsave(&xhci->lock, flags);
3693
3695
command->completion = &xhci->addr_dev;
3694
3696
ret = xhci_queue_slot_control(xhci, command, TRB_ENABLE_SLOT, 0);
3695
3697
if (ret) {
3696
3698
spin_unlock_irqrestore(&xhci->lock, flags);
3699
+
mutex_unlock(&xhci->mutex);
3697
3700
xhci_dbg(xhci, "FIXME: allocate a command ring segment\n");
3698
3701
kfree(command);
3699
3702
return 0;
···
3705
3702
spin_unlock_irqrestore(&xhci->lock, flags);
3706
3703
3707
3704
wait_for_completion(command->completion);
3705
+
slot_id = xhci->slot_id;
3706
+
mutex_unlock(&xhci->mutex);
3708
3707
3709
-
if (!xhci->slot_id || command->status != COMP_SUCCESS) {
3708
+
if (!slot_id || command->status != COMP_SUCCESS) {
3710
3709
xhci_err(xhci, "Error while assigning device slot ID\n");
3711
3710
xhci_err(xhci, "Max number of devices this xHCI host supports is %u.\n",
3712
3711
HCS_MAX_SLOTS(
···
3733
3728
* xhci_discover_or_reset_device(), which may be called as part of
3734
3729
* mass storage driver error handling.
3735
3730
*/
3736
-
if (!xhci_alloc_virt_device(xhci, xhci->slot_id, udev, GFP_NOIO)) {
3731
+
if (!xhci_alloc_virt_device(xhci, slot_id, udev, GFP_NOIO)) {
3737
3732
xhci_warn(xhci, "Could not allocate xHCI USB device data structures\n");
3738
3733
goto disable_slot;
3739
3734
}
3740
-
udev->slot_id = xhci->slot_id;
3735
+
udev->slot_id = slot_id;
3741
3736
3742
3737
#ifndef CONFIG_USB_DEFAULT_PERSIST
3743
3738
/*
···
3783
3778
struct xhci_slot_ctx *slot_ctx;
3784
3779
struct xhci_input_control_ctx *ctrl_ctx;
3785
3780
u64 temp_64;
3786
-
struct xhci_command *command;
3781
+
struct xhci_command *command = NULL;
3782
+
3783
+
mutex_lock(&xhci->mutex);
3787
3784
3788
3785
if (!udev->slot_id) {
3789
3786
xhci_dbg_trace(xhci, trace_xhci_dbg_address,
3790
3787
"Bad Slot ID %d", udev->slot_id);
3791
-
return -EINVAL;
3788
+
ret = -EINVAL;
3789
+
goto out;
3792
3790
}
3793
3791
3794
3792
virt_dev = xhci->devs[udev->slot_id];
···
3804
3796
*/
3805
3797
xhci_warn(xhci, "Virt dev invalid for slot_id 0x%x!\n",
3806
3798
udev->slot_id);
3807
-
return -EINVAL;
3799
+
ret = -EINVAL;
3800
+
goto out;
3808
3801
}
3809
3802
3810
3803
if (setup == SETUP_CONTEXT_ONLY) {
···
3813
3804
if (GET_SLOT_STATE(le32_to_cpu(slot_ctx->dev_state)) ==
3814
3805
SLOT_STATE_DEFAULT) {
3815
3806
xhci_dbg(xhci, "Slot already in default state\n");
3816
-
return 0;
3807
+
goto out;
3817
3808
}
3818
3809
}
3819
3810
3820
3811
command = xhci_alloc_command(xhci, false, false, GFP_KERNEL);
3821
-
if (!command)
3822
-
return -ENOMEM;
3812
+
if (!command) {
3813
+
ret = -ENOMEM;
3814
+
goto out;
3815
+
}
3823
3816
3824
3817
command->in_ctx = virt_dev->in_ctx;
3825
3818
command->completion = &xhci->addr_dev;
···
3831
3820
if (!ctrl_ctx) {
3832
3821
xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
3833
3822
__func__);
3834
-
kfree(command);
3835
-
return -EINVAL;
3823
+
ret = -EINVAL;
3824
+
goto out;
3836
3825
}
3837
3826
/*
3838
3827
* If this is the first Set Address since device plug-in or
···
3859
3848
spin_unlock_irqrestore(&xhci->lock, flags);
3860
3849
xhci_dbg_trace(xhci, trace_xhci_dbg_address,
3861
3850
"FIXME: allocate a command ring segment");
3862
-
kfree(command);
3863
-
return ret;
3851
+
goto out;
3864
3852
}
3865
3853
xhci_ring_cmd_db(xhci);
3866
3854
spin_unlock_irqrestore(&xhci->lock, flags);
···
3906
3896
ret = -EINVAL;
3907
3897
break;
3908
3898
}
3909
-
if (ret) {
3910
-
kfree(command);
3911
-
return ret;
3912
-
}
3899
+
if (ret)
3900
+
goto out;
3913
3901
temp_64 = xhci_read_64(xhci, &xhci->op_regs->dcbaa_ptr);
3914
3902
xhci_dbg_trace(xhci, trace_xhci_dbg_address,
3915
3903
"Op regs DCBAA ptr = %#016llx", temp_64);
···
3940
3932
xhci_dbg_trace(xhci, trace_xhci_dbg_address,
3941
3933
"Internal device address = %d",
3942
3934
le32_to_cpu(slot_ctx->dev_state) & DEV_ADDR_MASK);
3935
+
out:
3936
+
mutex_unlock(&xhci->mutex);
3943
3937
kfree(command);
3944
-
return 0;
3938
+
return ret;
3945
3939
}
3946
3940
3947
3941
int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
···
4865
4855
return 0;
4866
4856
}
4867
4857
4858
+
mutex_init(&xhci->mutex);
4868
4859
xhci->cap_regs = hcd->regs;
4869
4860
xhci->op_regs = hcd->regs +
4870
4861
HC_LENGTH(readl(&xhci->cap_regs->hc_capbase));
···
5022
5011
BUILD_BUG_ON(sizeof(struct xhci_run_regs) != (8+8*128)*32/8);
5023
5012
return 0;
5024
5013
}
5014
+
5015
+
/*
5016
+
* If an init function is provided, an exit function must also be provided
5017
+
* to allow module unload.
5018
+
*/
5019
+
static void __exit xhci_hcd_fini(void) { }
5020
+
5025
5021
module_init(xhci_hcd_init);
5022
+
module_exit(xhci_hcd_fini);
+2
drivers/usb/host/xhci.h
+2
drivers/usb/host/xhci.h
···
1497
1497
struct list_head lpm_failed_devs;
1498
1498
1499
1499
/* slot enabling and address device helpers */
1500
+
/* these are not thread safe so use mutex */
1501
+
struct mutex mutex;
1500
1502
struct completion addr_dev;
1501
1503
int slot_id;
1502
1504
/* For USB 3.0 LPM enable/disable. */
+7
-7
drivers/usb/musb/musb_core.c
+7
-7
drivers/usb/musb/musb_core.c
···
2021
2021
if (musb->ops->quirks)
2022
2022
musb->io.quirks = musb->ops->quirks;
2023
2023
2024
-
/* At least tusb6010 has it's own offsets.. */
2025
-
if (musb->ops->ep_offset)
2026
-
musb->io.ep_offset = musb->ops->ep_offset;
2027
-
if (musb->ops->ep_select)
2028
-
musb->io.ep_select = musb->ops->ep_select;
2029
-
2030
-
/* ..and some devices use indexed offset or flat offset */
2024
+
/* Most devices use indexed offset or flat offset */
2031
2025
if (musb->io.quirks & MUSB_INDEXED_EP) {
2032
2026
musb->io.ep_offset = musb_indexed_ep_offset;
2033
2027
musb->io.ep_select = musb_indexed_ep_select;
···
2029
2035
musb->io.ep_offset = musb_flat_ep_offset;
2030
2036
musb->io.ep_select = musb_flat_ep_select;
2031
2037
}
2038
+
2039
+
/* At least tusb6010 has its own offsets */
2040
+
if (musb->ops->ep_offset)
2041
+
musb->io.ep_offset = musb->ops->ep_offset;
2042
+
if (musb->ops->ep_select)
2043
+
musb->io.ep_select = musb->ops->ep_select;
2032
2044
2033
2045
if (musb->ops->fifo_mode)
2034
2046
fifo_mode = musb->ops->fifo_mode;
+3
-3
drivers/usb/phy/phy-ab8500-usb.c
+3
-3
drivers/usb/phy/phy-ab8500-usb.c
···
1179
1179
}
1180
1180
err = devm_request_threaded_irq(&pdev->dev, irq, NULL,
1181
1181
ab8500_usb_link_status_irq,
1182
-
IRQF_NO_SUSPEND | IRQF_SHARED,
1182
+
IRQF_NO_SUSPEND | IRQF_SHARED | IRQF_ONESHOT,
1183
1183
"usb-link-status", ab);
1184
1184
if (err < 0) {
1185
1185
dev_err(ab->dev, "request_irq failed for link status irq\n");
···
1195
1195
}
1196
1196
err = devm_request_threaded_irq(&pdev->dev, irq, NULL,
1197
1197
ab8500_usb_disconnect_irq,
1198
-
IRQF_NO_SUSPEND | IRQF_SHARED,
1198
+
IRQF_NO_SUSPEND | IRQF_SHARED | IRQF_ONESHOT,
1199
1199
"usb-id-fall", ab);
1200
1200
if (err < 0) {
1201
1201
dev_err(ab->dev, "request_irq failed for ID fall irq\n");
···
1211
1211
}
1212
1212
err = devm_request_threaded_irq(&pdev->dev, irq, NULL,
1213
1213
ab8500_usb_disconnect_irq,
1214
-
IRQF_NO_SUSPEND | IRQF_SHARED,
1214
+
IRQF_NO_SUSPEND | IRQF_SHARED | IRQF_ONESHOT,
1215
1215
"usb-vbus-fall", ab);
1216
1216
if (err < 0) {
1217
1217
dev_err(ab->dev, "request_irq failed for Vbus fall irq\n");
+2
-1
drivers/usb/phy/phy-tahvo.c
+2
-1
drivers/usb/phy/phy-tahvo.c
···
401
401
dev_set_drvdata(&pdev->dev, tu);
402
402
403
403
tu->irq = platform_get_irq(pdev, 0);
404
-
ret = request_threaded_irq(tu->irq, NULL, tahvo_usb_vbus_interrupt, 0,
404
+
ret = request_threaded_irq(tu->irq, NULL, tahvo_usb_vbus_interrupt,
405
+
IRQF_ONESHOT,
405
406
"tahvo-vbus", tu);
406
407
if (ret) {
407
408
dev_err(&pdev->dev, "could not register tahvo-vbus irq: %d\n",
+28
-10
drivers/usb/renesas_usbhs/fifo.c
+28
-10
drivers/usb/renesas_usbhs/fifo.c
···
611
611
static int usbhsf_prepare_pop(struct usbhs_pkt *pkt, int *is_done)
612
612
{
613
613
struct usbhs_pipe *pipe = pkt->pipe;
614
+
struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
615
+
struct usbhs_fifo *fifo = usbhsf_get_cfifo(priv);
614
616
615
617
if (usbhs_pipe_is_busy(pipe))
616
618
return 0;
···
625
623
*/
626
624
usbhs_pipe_data_sequence(pipe, pkt->sequence);
627
625
pkt->sequence = -1; /* -1 sequence will be ignored */
626
+
627
+
if (usbhs_pipe_is_dcp(pipe))
628
+
usbhsf_fifo_clear(pipe, fifo);
628
629
629
630
usbhs_pipe_set_trans_count_if_bulk(pipe, pkt->length);
630
631
usbhs_pipe_enable(pipe);
···
678
673
*is_done = 1;
679
674
usbhsf_rx_irq_ctrl(pipe, 0);
680
675
usbhs_pipe_running(pipe, 0);
681
-
usbhs_pipe_disable(pipe); /* disable pipe first */
676
+
/*
677
+
* If function mode, since this controller is possible to enter
678
+
* Control Write status stage at this timing, this driver
679
+
* should not disable the pipe. If such a case happens, this
680
+
* controller is not able to complete the status stage.
681
+
*/
682
+
if (!usbhs_mod_is_host(priv) && !usbhs_pipe_is_dcp(pipe))
683
+
usbhs_pipe_disable(pipe); /* disable pipe first */
682
684
}
683
685
684
686
/*
···
1239
1227
{
1240
1228
char name[16];
1241
1229
1242
-
snprintf(name, sizeof(name), "tx%d", channel);
1243
-
fifo->tx_chan = dma_request_slave_channel_reason(dev, name);
1244
-
if (IS_ERR(fifo->tx_chan))
1245
-
fifo->tx_chan = NULL;
1246
-
1247
-
snprintf(name, sizeof(name), "rx%d", channel);
1248
-
fifo->rx_chan = dma_request_slave_channel_reason(dev, name);
1249
-
if (IS_ERR(fifo->rx_chan))
1250
-
fifo->rx_chan = NULL;
1230
+
/*
1231
+
* To avoid complex handing for DnFIFOs, the driver uses each
1232
+
* DnFIFO as TX or RX direction (not bi-direction).
1233
+
* So, the driver uses odd channels for TX, even channels for RX.
1234
+
*/
1235
+
snprintf(name, sizeof(name), "ch%d", channel);
1236
+
if (channel & 1) {
1237
+
fifo->tx_chan = dma_request_slave_channel_reason(dev, name);
1238
+
if (IS_ERR(fifo->tx_chan))
1239
+
fifo->tx_chan = NULL;
1240
+
} else {
1241
+
fifo->rx_chan = dma_request_slave_channel_reason(dev, name);
1242
+
if (IS_ERR(fifo->rx_chan))
1243
+
fifo->rx_chan = NULL;
1244
+
}
1251
1245
}
1252
1246
1253
1247
static void usbhsf_dma_init(struct usbhs_priv *priv, struct usbhs_fifo *fifo,
+1
drivers/usb/serial/cp210x.c
+1
drivers/usb/serial/cp210x.c
···
128
128
{ USB_DEVICE(0x10C4, 0x8946) }, /* Ketra N1 Wireless Interface */
129
129
{ USB_DEVICE(0x10C4, 0x8977) }, /* CEL MeshWorks DevKit Device */
130
130
{ USB_DEVICE(0x10C4, 0x8998) }, /* KCF Technologies PRN */
131
+
{ USB_DEVICE(0x10C4, 0x8A2A) }, /* HubZ dual ZigBee and Z-Wave dongle */
131
132
{ USB_DEVICE(0x10C4, 0xEA60) }, /* Silicon Labs factory default */
132
133
{ USB_DEVICE(0x10C4, 0xEA61) }, /* Silicon Labs factory default */
133
134
{ USB_DEVICE(0x10C4, 0xEA70) }, /* Silicon Labs factory default */
+1
drivers/usb/serial/ftdi_sio.c
+1
drivers/usb/serial/ftdi_sio.c
···
699
699
{ USB_DEVICE(XSENS_VID, XSENS_AWINDA_DONGLE_PID) },
700
700
{ USB_DEVICE(XSENS_VID, XSENS_AWINDA_STATION_PID) },
701
701
{ USB_DEVICE(XSENS_VID, XSENS_CONVERTER_PID) },
702
+
{ USB_DEVICE(XSENS_VID, XSENS_MTDEVBOARD_PID) },
702
703
{ USB_DEVICE(XSENS_VID, XSENS_MTW_PID) },
703
704
{ USB_DEVICE(FTDI_VID, FTDI_OMNI1509) },
704
705
{ USB_DEVICE(MOBILITY_VID, MOBILITY_USB_SERIAL_PID) },
+1
drivers/usb/serial/ftdi_sio_ids.h
+1
drivers/usb/serial/ftdi_sio_ids.h
···
155
155
#define XSENS_AWINDA_STATION_PID 0x0101
156
156
#define XSENS_AWINDA_DONGLE_PID 0x0102
157
157
#define XSENS_MTW_PID 0x0200 /* Xsens MTw */
158
+
#define XSENS_MTDEVBOARD_PID 0x0300 /* Motion Tracker Development Board */
158
159
#define XSENS_CONVERTER_PID 0xD00D /* Xsens USB-serial converter */
159
160
160
161
/* Xsens devices using FTDI VID */