mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2025-01-18 12:06:22 +07:00
USB: changes for v5.5
We have TI's glue layer for the Cadence USB3 controller going upstream. Tegra's XUDC driver is also going upstream with this pull request. Apart from these two big features, we have a bunch of patches switching over to devm_platform_ioremap_resource() in order to simplify code a little; and a non-critical fix for DWC3 usage via kexec. -----BEGIN PGP SIGNATURE----- iQJFBAABCAAvFiEElLzh7wn96CXwjh2IzL64meEamQYFAl3SQhkRHGJhbGJpQGtl cm5lbC5vcmcACgkQzL64meEamQbmLg//eAGrYSdEpachXFRVFyPWVBlrxahD9U2Q Y+0Bix/UWEhVc4ar367vPzZwN8idVRGbGzWbZi5csWnry8yzzzCKOKEZTvljXTf7 1uKK9YW/oY4CFKwflp+VjRLVC0fvnwjNzjLrhPoc1ZyANhZCaw1L3d3XQzy8BUY5 O8Uywg6AqXCdNJORb2ndu+0kUDnB9JzPGFtvB9fwpxoWn5lxaHmpWzl3Xz2nlFBP aBhnU5f2P/893pJNEezqA9b1H8ouF8CjDztDUeVLDS4XF3aCmtzbqAMlovWwv+zY t/9cX0pXDc21equInPN3wG9aojFyDiZSegIZUQuN7nF75G7U+PIDroYFM0X1zbn5 vjnaOdFCgEHyrRY6wcoz59dic3vO4azNOV88y7gJaV6AU/5zwezihyGSDc+nMLG1 ZGC0rTjQeeQQgPl9fyM6rAWR8nTK2Qtb0t/eBTN8M+vbdsVis3fFYmGMFz6tM4Eo qbDG5EG85SE84yDtUelrGX6lNszQwSBJTqyERWX7NERPKFCe/6WNlrtQPpGcFXqa iGEJIeGNTLSKCYfLscjAxqhKcIko/kE2PtYqqBMQGd8Dj7wrll/yrnLLsWey06e0 2NAj90bR+eykg5IDfH0WDXhpN2sNzXRN5ibYl1L6iA09hWEhG2gtLsaeXbRs85Pl YHFqJYy+NCk= =Xyc8 -----END PGP SIGNATURE----- Merge tag 'usb-for-v5.5' of git://git.kernel.org/pub/scm/linux/kernel/git/balbi/usb into usb-next Felipe writes: USB: changes for v5.5 We have TI's glue layer for the Cadence USB3 controller going upstream. Tegra's XUDC driver is also going upstream with this pull request. Apart from these two big features, we have a bunch of patches switching over to devm_platform_ioremap_resource() in order to simplify code a little; and a non-critical fix for DWC3 usage via kexec. * tag 'usb-for-v5.5' of git://git.kernel.org/pub/scm/linux/kernel/git/balbi/usb: (44 commits) usb: dwc3: of-simple: add a shutdown usb: cdns3: Add TI specific wrapper driver dt-bindings: usb: Add binding for the TI wrapper for Cadence USB3 controller usb: mtu3: fix race condition about delayed_status usb: gadget: Add UDC driver for tegra XUSB device mode controller usb: dwc3: debug: Remove newline printout usb: dwc2: use a longer core rest timeout in dwc2_core_reset() usb: gadget: udc: lpc32xx: Use devm_platform_ioremap_resource() in lpc32xx_udc_probe() USB: gadget: udc: clean up an indentation issue usb: gadget: Quieten gadget config message phy: renesas: rcar-gen3-usb2: Use platform_get_irq_optional() for optional irq usb: gadget: Remove set but not used variable 'opts' in msg_do_config usb: gadget: Remove set but not used variable 'opts' in acm_ms_do_config usb: mtu3: add a new function to do status stage usb: gadget: configfs: fix concurrent issue between composite APIs usb: gadget: f_tcm: Provide support to get alternate setting in tcm function usb: gadget: Correct NULL pointer checking in fsl gadget usb: fsl: Remove unused variable USB: dummy-hcd: use usb_urb_dir_in instead of usb_pipein USB: dummy-hcd: increase max number of devices to 32 ...
This commit is contained in:
Greg Kroah-Hartman
commit
7170d1a4cc
86
Documentation/devicetree/bindings/usb/ti,j721e-usb.yaml
Normal file
86
Documentation/devicetree/bindings/usb/ti,j721e-usb.yaml
Normal file
@ -0,0 +1,86 @@
|
||||
# SPDX-License-Identifier: GPL-2.0
|
||||
%YAML 1.2
|
||||
---
|
||||
$id: "http://devicetree.org/schemas/usb/ti,j721e-usb.yaml#"
|
||||
$schema: "http://devicetree.org/meta-schemas/core.yaml#"
|
||||
|
||||
title: Bindings for the TI wrapper module for the Cadence USBSS-DRD controller
|
||||
|
||||
maintainers:
|
||||
- Roger Quadros <rogerq@ti.com>
|
||||
|
||||
properties:
|
||||
compatible:
|
||||
items:
|
||||
- const: ti,j721e-usb
|
||||
|
||||
reg:
|
||||
description: module registers
|
||||
|
||||
power-domains:
|
||||
description:
|
||||
PM domain provider node and an args specifier containing
|
||||
the USB device id value. See,
|
||||
Documentation/devicetree/bindings/soc/ti/sci-pm-domain.txt
|
||||
|
||||
clocks:
|
||||
description: Clock phandles to usb2_refclk and lpm_clk
|
||||
minItems: 2
|
||||
maxItems: 2
|
||||
|
||||
clock-names:
|
||||
items:
|
||||
- const: ref
|
||||
- const: lpm
|
||||
|
||||
ti,usb2-only:
|
||||
description:
|
||||
If present, it restricts the controller to USB2.0 mode of
|
||||
operation. Must be present if USB3 PHY is not available
|
||||
for USB.
|
||||
type: boolean
|
||||
|
||||
ti,vbus-divider:
|
||||
description:
|
||||
Should be present if USB VBUS line is connected to the
|
||||
VBUS pin of the SoC via a 1/3 voltage divider.
|
||||
type: boolean
|
||||
|
||||
required:
|
||||
- compatible
|
||||
- reg
|
||||
- power-domains
|
||||
- clocks
|
||||
- clock-names
|
||||
|
||||
examples:
|
||||
- |
|
||||
#include <dt-bindings/soc/ti,sci_pm_domain.h>
|
||||
#include <dt-bindings/interrupt-controller/arm-gic.h>
|
||||
cdns_usb@4104000 {
|
||||
compatible = "ti,j721e-usb";
|
||||
reg = <0x00 0x4104000 0x00 0x100>;
|
||||
power-domains = <&k3_pds 288 TI_SCI_PD_EXCLUSIVE>;
|
||||
clocks = <&k3_clks 288 15>, <&k3_clks 288 3>;
|
||||
clock-names = "ref", "lpm";
|
||||
assigned-clocks = <&k3_clks 288 15>; /* USB2_REFCLK */
|
||||
assigned-clock-parents = <&k3_clks 288 16>; /* HFOSC0 */
|
||||
#address-cells = <2>;
|
||||
#size-cells = <2>;
|
||||
|
||||
usb@6000000 {
|
||||
compatible = "cdns,usb3";
|
||||
reg = <0x00 0x6000000 0x00 0x10000>,
|
||||
<0x00 0x6010000 0x00 0x10000>,
|
||||
<0x00 0x6020000 0x00 0x10000>;
|
||||
reg-names = "otg", "xhci", "dev";
|
||||
interrupts = <GIC_SPI 96 IRQ_TYPE_LEVEL_HIGH>, /* irq.0 */
|
||||
<GIC_SPI 102 IRQ_TYPE_LEVEL_HIGH>, /* irq.6 */
|
||||
<GIC_SPI 120 IRQ_TYPE_LEVEL_HIGH>; /* otgirq.0 */
|
||||
interrupt-names = "host",
|
||||
"peripheral",
|
||||
"otg";
|
||||
maximum-speed = "super-speed";
|
||||
dr_mode = "otg";
|
||||
};
|
||||
};
|
||||
@ -614,7 +614,7 @@ static int rcar_gen3_phy_usb2_probe(struct platform_device *pdev)
|
||||
return PTR_ERR(channel->base);
|
||||
|
||||
/* call request_irq for OTG */
|
||||
irq = platform_get_irq(pdev, 0);
|
||||
irq = platform_get_irq_optional(pdev, 0);
|
||||
if (irq >= 0) {
|
||||
INIT_WORK(&channel->work, rcar_gen3_phy_usb2_work);
|
||||
irq = devm_request_irq(dev, irq, rcar_gen3_phy_usb2_irq,
|
||||
|
||||
@ -43,4 +43,14 @@ config USB_CDNS3_PCI_WRAP
|
||||
If you choose to build this driver as module it will
|
||||
be dynamically linked and module will be called cdns3-pci.ko
|
||||
|
||||
config USB_CDNS3_TI
|
||||
tristate "Cadence USB3 support on TI platforms"
|
||||
depends on ARCH_K3 || COMPILE_TEST
|
||||
default USB_CDNS3
|
||||
help
|
||||
Say 'Y' or 'M' here if you are building for Texas Instruments
|
||||
platforms that contain Cadence USB3 controller core.
|
||||
|
||||
e.g. J721e.
|
||||
|
||||
endif
|
||||
|
||||
@ -14,3 +14,4 @@ endif
|
||||
cdns3-$(CONFIG_USB_CDNS3_HOST) += host.o
|
||||
|
||||
obj-$(CONFIG_USB_CDNS3_PCI_WRAP) += cdns3-pci-wrap.o
|
||||
obj-$(CONFIG_USB_CDNS3_TI) += cdns3-ti.o
|
||||
|
||||
236
drivers/usb/cdns3/cdns3-ti.c
Normal file
236
drivers/usb/cdns3/cdns3-ti.c
Normal file
@ -0,0 +1,236 @@
|
||||
// SPDX-License-Identifier: GPL-2.0
|
||||
/**
|
||||
* cdns3-ti.c - TI specific Glue layer for Cadence USB Controller
|
||||
*
|
||||
* Copyright (C) 2019 Texas Instruments Incorporated - http://www.ti.com
|
||||
*/
|
||||
|
||||
#include <linux/bits.h>
|
||||
#include <linux/clk.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/interrupt.h>
|
||||
#include <linux/platform_device.h>
|
||||
#include <linux/dma-mapping.h>
|
||||
#include <linux/io.h>
|
||||
#include <linux/of_platform.h>
|
||||
#include <linux/pm_runtime.h>
|
||||
|
||||
/* USB Wrapper register offsets */
|
||||
#define USBSS_PID 0x0
|
||||
#define USBSS_W1 0x4
|
||||
#define USBSS_STATIC_CONFIG 0x8
|
||||
#define USBSS_PHY_TEST 0xc
|
||||
#define USBSS_DEBUG_CTRL 0x10
|
||||
#define USBSS_DEBUG_INFO 0x14
|
||||
#define USBSS_DEBUG_LINK_STATE 0x18
|
||||
#define USBSS_DEVICE_CTRL 0x1c
|
||||
|
||||
/* Wrapper 1 register bits */
|
||||
#define USBSS_W1_PWRUP_RST BIT(0)
|
||||
#define USBSS_W1_OVERCURRENT_SEL BIT(8)
|
||||
#define USBSS_W1_MODESTRAP_SEL BIT(9)
|
||||
#define USBSS_W1_OVERCURRENT BIT(16)
|
||||
#define USBSS_W1_MODESTRAP_MASK GENMASK(18, 17)
|
||||
#define USBSS_W1_MODESTRAP_SHIFT 17
|
||||
#define USBSS_W1_USB2_ONLY BIT(19)
|
||||
|
||||
/* Static config register bits */
|
||||
#define USBSS1_STATIC_PLL_REF_SEL_MASK GENMASK(8, 5)
|
||||
#define USBSS1_STATIC_PLL_REF_SEL_SHIFT 5
|
||||
#define USBSS1_STATIC_LOOPBACK_MODE_MASK GENMASK(4, 3)
|
||||
#define USBSS1_STATIC_LOOPBACK_MODE_SHIFT 3
|
||||
#define USBSS1_STATIC_VBUS_SEL_MASK GENMASK(2, 1)
|
||||
#define USBSS1_STATIC_VBUS_SEL_SHIFT 1
|
||||
#define USBSS1_STATIC_LANE_REVERSE BIT(0)
|
||||
|
||||
/* Modestrap modes */
|
||||
enum modestrap_mode { USBSS_MODESTRAP_MODE_NONE,
|
||||
USBSS_MODESTRAP_MODE_HOST,
|
||||
USBSS_MODESTRAP_MODE_PERIPHERAL};
|
||||
|
||||
struct cdns_ti {
|
||||
struct device *dev;
|
||||
void __iomem *usbss;
|
||||
int usb2_only:1;
|
||||
int vbus_divider:1;
|
||||
struct clk *usb2_refclk;
|
||||
struct clk *lpm_clk;
|
||||
};
|
||||
|
||||
static const int cdns_ti_rate_table[] = { /* in KHZ */
|
||||
9600,
|
||||
10000,
|
||||
12000,
|
||||
19200,
|
||||
20000,
|
||||
24000,
|
||||
25000,
|
||||
26000,
|
||||
38400,
|
||||
40000,
|
||||
58000,
|
||||
50000,
|
||||
52000,
|
||||
};
|
||||
|
||||
static inline u32 cdns_ti_readl(struct cdns_ti *data, u32 offset)
|
||||
{
|
||||
return readl(data->usbss + offset);
|
||||
}
|
||||
|
||||
static inline void cdns_ti_writel(struct cdns_ti *data, u32 offset, u32 value)
|
||||
{
|
||||
writel(value, data->usbss + offset);
|
||||
}
|
||||
|
||||
static int cdns_ti_probe(struct platform_device *pdev)
|
||||
{
|
||||
struct device *dev = &pdev->dev;
|
||||
struct device_node *node = pdev->dev.of_node;
|
||||
struct cdns_ti *data;
|
||||
int error;
|
||||
u32 reg;
|
||||
int rate_code, i;
|
||||
unsigned long rate;
|
||||
|
||||
data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
|
||||
if (!data)
|
||||
return -ENOMEM;
|
||||
|
||||
platform_set_drvdata(pdev, data);
|
||||
|
||||
data->dev = dev;
|
||||
|
||||
data->usbss = devm_platform_ioremap_resource(pdev, 0);
|
||||
if (IS_ERR(data->usbss)) {
|
||||
dev_err(dev, "can't map IOMEM resource\n");
|
||||
return PTR_ERR(data->usbss);
|
||||
}
|
||||
|
||||
data->usb2_refclk = devm_clk_get(dev, "ref");
|
||||
if (IS_ERR(data->usb2_refclk)) {
|
||||
dev_err(dev, "can't get usb2_refclk\n");
|
||||
return PTR_ERR(data->usb2_refclk);
|
||||
}
|
||||
|
||||
data->lpm_clk = devm_clk_get(dev, "lpm");
|
||||
if (IS_ERR(data->lpm_clk)) {
|
||||
dev_err(dev, "can't get lpm_clk\n");
|
||||
return PTR_ERR(data->lpm_clk);
|
||||
}
|
||||
|
||||
rate = clk_get_rate(data->usb2_refclk);
|
||||
rate /= 1000; /* To KHz */
|
||||
for (i = 0; i < ARRAY_SIZE(cdns_ti_rate_table); i++) {
|
||||
if (cdns_ti_rate_table[i] == rate)
|
||||
break;
|
||||
}
|
||||
|
||||
if (i == ARRAY_SIZE(cdns_ti_rate_table)) {
|
||||
dev_err(dev, "unsupported usb2_refclk rate: %lu KHz\n", rate);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
rate_code = i;
|
||||
|
||||
pm_runtime_enable(dev);
|
||||
error = pm_runtime_get_sync(dev);
|
||||
if (error < 0) {
|
||||
dev_err(dev, "pm_runtime_get_sync failed: %d\n", error);
|
||||
goto err_get;
|
||||
}
|
||||
|
||||
/* assert RESET */
|
||||
reg = cdns_ti_readl(data, USBSS_W1);
|
||||
reg &= ~USBSS_W1_PWRUP_RST;
|
||||
cdns_ti_writel(data, USBSS_W1, reg);
|
||||
|
||||
/* set static config */
|
||||
reg = cdns_ti_readl(data, USBSS_STATIC_CONFIG);
|
||||
reg &= ~USBSS1_STATIC_PLL_REF_SEL_MASK;
|
||||
reg |= rate_code << USBSS1_STATIC_PLL_REF_SEL_SHIFT;
|
||||
|
||||
reg &= ~USBSS1_STATIC_VBUS_SEL_MASK;
|
||||
data->vbus_divider = device_property_read_bool(dev, "ti,vbus-divider");
|
||||
if (data->vbus_divider)
|
||||
reg |= 1 << USBSS1_STATIC_VBUS_SEL_SHIFT;
|
||||
|
||||
cdns_ti_writel(data, USBSS_STATIC_CONFIG, reg);
|
||||
reg = cdns_ti_readl(data, USBSS_STATIC_CONFIG);
|
||||
|
||||
/* set USB2_ONLY mode if requested */
|
||||
reg = cdns_ti_readl(data, USBSS_W1);
|
||||
data->usb2_only = device_property_read_bool(dev, "ti,usb2-only");
|
||||
if (data->usb2_only)
|
||||
reg |= USBSS_W1_USB2_ONLY;
|
||||
|
||||
/* set default modestrap */
|
||||
reg |= USBSS_W1_MODESTRAP_SEL;
|
||||
reg &= ~USBSS_W1_MODESTRAP_MASK;
|
||||
reg |= USBSS_MODESTRAP_MODE_NONE << USBSS_W1_MODESTRAP_SHIFT;
|
||||
cdns_ti_writel(data, USBSS_W1, reg);
|
||||
|
||||
/* de-assert RESET */
|
||||
reg |= USBSS_W1_PWRUP_RST;
|
||||
cdns_ti_writel(data, USBSS_W1, reg);
|
||||
|
||||
error = of_platform_populate(node, NULL, NULL, dev);
|
||||
if (error) {
|
||||
dev_err(dev, "failed to create children: %d\n", error);
|
||||
goto err;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
err:
|
||||
pm_runtime_put_sync(data->dev);
|
||||
err_get:
|
||||
pm_runtime_disable(data->dev);
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
static int cdns_ti_remove_core(struct device *dev, void *c)
|
||||
{
|
||||
struct platform_device *pdev = to_platform_device(dev);
|
||||
|
||||
platform_device_unregister(pdev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int cdns_ti_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct device *dev = &pdev->dev;
|
||||
|
||||
device_for_each_child(dev, NULL, cdns_ti_remove_core);
|
||||
pm_runtime_put_sync(dev);
|
||||
pm_runtime_disable(dev);
|
||||
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct of_device_id cdns_ti_of_match[] = {
|
||||
{ .compatible = "ti,j721e-usb", },
|
||||
{},
|
||||
};
|
||||
MODULE_DEVICE_TABLE(of, cdns_ti_of_match);
|
||||
|
||||
static struct platform_driver cdns_ti_driver = {
|
||||
.probe = cdns_ti_probe,
|
||||
.remove = cdns_ti_remove,
|
||||
.driver = {
|
||||
.name = "cdns3-ti",
|
||||
.of_match_table = cdns_ti_of_match,
|
||||
},
|
||||
};
|
||||
|
||||
module_platform_driver(cdns_ti_driver);
|
||||
|
||||
MODULE_ALIAS("platform:cdns3-ti");
|
||||
MODULE_AUTHOR("Roger Quadros <rogerq@ti.com>");
|
||||
MODULE_LICENSE("GPL v2");
|
||||
MODULE_DESCRIPTION("Cadence USB3 TI Glue Layer");
|
||||
@ -524,7 +524,7 @@ int dwc2_core_reset(struct dwc2_hsotg *hsotg, bool skip_wait)
|
||||
greset |= GRSTCTL_CSFTRST;
|
||||
dwc2_writel(hsotg, greset, GRSTCTL);
|
||||
|
||||
if (dwc2_hsotg_wait_bit_clear(hsotg, GRSTCTL, GRSTCTL_CSFTRST, 50)) {
|
||||
if (dwc2_hsotg_wait_bit_clear(hsotg, GRSTCTL, GRSTCTL_CSFTRST, 10000)) {
|
||||
dev_warn(hsotg->dev, "%s: HANG! Soft Reset timeout GRSTCTL GRSTCTL_CSFTRST\n",
|
||||
__func__);
|
||||
return -EBUSY;
|
||||
|
||||
@ -566,8 +566,11 @@ static int dwc3_core_ulpi_init(struct dwc3 *dwc)
|
||||
*/
|
||||
static int dwc3_phy_setup(struct dwc3 *dwc)
|
||||
{
|
||||
unsigned int hw_mode;
|
||||
u32 reg;
|
||||
|
||||
hw_mode = DWC3_GHWPARAMS0_MODE(dwc->hwparams.hwparams0);
|
||||
|
||||
reg = dwc3_readl(dwc->regs, DWC3_GUSB3PIPECTL(0));
|
||||
|
||||
/*
|
||||
@ -585,6 +588,14 @@ static int dwc3_phy_setup(struct dwc3 *dwc)
|
||||
if (dwc->revision > DWC3_REVISION_194A)
|
||||
reg |= DWC3_GUSB3PIPECTL_SUSPHY;
|
||||
|
||||
/*
|
||||
* For DRD controllers, GUSB3PIPECTL.SUSPENDENABLE must be cleared after
|
||||
* power-on reset, and it can be set after core initialization, which is
|
||||
* after device soft-reset during initialization.
|
||||
*/
|
||||
if (hw_mode == DWC3_GHWPARAMS0_MODE_DRD)
|
||||
reg &= ~DWC3_GUSB3PIPECTL_SUSPHY;
|
||||
|
||||
if (dwc->u2ss_inp3_quirk)
|
||||
reg |= DWC3_GUSB3PIPECTL_U2SSINP3OK;
|
||||
|
||||
@ -668,6 +679,14 @@ static int dwc3_phy_setup(struct dwc3 *dwc)
|
||||
if (dwc->revision > DWC3_REVISION_194A)
|
||||
reg |= DWC3_GUSB2PHYCFG_SUSPHY;
|
||||
|
||||
/*
|
||||
* For DRD controllers, GUSB2PHYCFG.SUSPHY must be cleared after
|
||||
* power-on reset, and it can be set after core initialization, which is
|
||||
* after device soft-reset during initialization.
|
||||
*/
|
||||
if (hw_mode == DWC3_GHWPARAMS0_MODE_DRD)
|
||||
reg &= ~DWC3_GUSB2PHYCFG_SUSPHY;
|
||||
|
||||
if (dwc->dis_u2_susphy_quirk)
|
||||
reg &= ~DWC3_GUSB2PHYCFG_SUSPHY;
|
||||
|
||||
@ -902,9 +921,12 @@ static void dwc3_set_incr_burst_type(struct dwc3 *dwc)
|
||||
*/
|
||||
static int dwc3_core_init(struct dwc3 *dwc)
|
||||
{
|
||||
unsigned int hw_mode;
|
||||
u32 reg;
|
||||
int ret;
|
||||
|
||||
hw_mode = DWC3_GHWPARAMS0_MODE(dwc->hwparams.hwparams0);
|
||||
|
||||
/*
|
||||
* Write Linux Version Code to our GUID register so it's easy to figure
|
||||
* out which kernel version a bug was found.
|
||||
@ -940,6 +962,21 @@ static int dwc3_core_init(struct dwc3 *dwc)
|
||||
if (ret)
|
||||
goto err0a;
|
||||
|
||||
if (hw_mode == DWC3_GHWPARAMS0_MODE_DRD &&
|
||||
dwc->revision > DWC3_REVISION_194A) {
|
||||
if (!dwc->dis_u3_susphy_quirk) {
|
||||
reg = dwc3_readl(dwc->regs, DWC3_GUSB3PIPECTL(0));
|
||||
reg |= DWC3_GUSB3PIPECTL_SUSPHY;
|
||||
dwc3_writel(dwc->regs, DWC3_GUSB3PIPECTL(0), reg);
|
||||
}
|
||||
|
||||
if (!dwc->dis_u2_susphy_quirk) {
|
||||
reg = dwc3_readl(dwc->regs, DWC3_GUSB2PHYCFG(0));
|
||||
reg |= DWC3_GUSB2PHYCFG_SUSPHY;
|
||||
dwc3_writel(dwc->regs, DWC3_GUSB2PHYCFG(0), reg);
|
||||
}
|
||||
}
|
||||
|
||||
dwc3_core_setup_global_control(dwc);
|
||||
dwc3_core_num_eps(dwc);
|
||||
|
||||
|
||||
@ -112,7 +112,7 @@ dwc3_gadget_link_string(enum dwc3_link_state link_state)
|
||||
case DWC3_LINK_STATE_RESUME:
|
||||
return "Resume";
|
||||
default:
|
||||
return "UNKNOWN link state\n";
|
||||
return "UNKNOWN link state";
|
||||
}
|
||||
}
|
||||
|
||||
@ -141,7 +141,7 @@ dwc3_gadget_hs_link_string(enum dwc3_link_state link_state)
|
||||
case DWC3_LINK_STATE_RESUME:
|
||||
return "Resume";
|
||||
default:
|
||||
return "UNKNOWN link state\n";
|
||||
return "UNKNOWN link state";
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -110,12 +110,9 @@ static int dwc3_of_simple_probe(struct platform_device *pdev)
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int dwc3_of_simple_remove(struct platform_device *pdev)
|
||||
static void __dwc3_of_simple_teardown(struct dwc3_of_simple *simple)
|
||||
{
|
||||
struct dwc3_of_simple *simple = platform_get_drvdata(pdev);
|
||||
struct device *dev = &pdev->dev;
|
||||
|
||||
of_platform_depopulate(dev);
|
||||
of_platform_depopulate(simple->dev);
|
||||
|
||||
clk_bulk_disable_unprepare(simple->num_clocks, simple->clks);
|
||||
clk_bulk_put_all(simple->num_clocks, simple->clks);
|
||||
@ -126,13 +123,27 @@ static int dwc3_of_simple_remove(struct platform_device *pdev)
|
||||
|
||||
reset_control_put(simple->resets);
|
||||
|
||||
pm_runtime_disable(dev);
|
||||
pm_runtime_put_noidle(dev);
|
||||
pm_runtime_set_suspended(dev);
|
||||
pm_runtime_disable(simple->dev);
|
||||
pm_runtime_put_noidle(simple->dev);
|
||||
pm_runtime_set_suspended(simple->dev);
|
||||
}
|
||||
|
||||
static int dwc3_of_simple_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct dwc3_of_simple *simple = platform_get_drvdata(pdev);
|
||||
|
||||
__dwc3_of_simple_teardown(simple);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void dwc3_of_simple_shutdown(struct platform_device *pdev)
|
||||
{
|
||||
struct dwc3_of_simple *simple = platform_get_drvdata(pdev);
|
||||
|
||||
__dwc3_of_simple_teardown(simple);
|
||||
}
|
||||
|
||||
static int __maybe_unused dwc3_of_simple_runtime_suspend(struct device *dev)
|
||||
{
|
||||
struct dwc3_of_simple *simple = dev_get_drvdata(dev);
|
||||
@ -190,6 +201,7 @@ MODULE_DEVICE_TABLE(of, of_dwc3_simple_match);
|
||||
static struct platform_driver dwc3_of_simple_driver = {
|
||||
.probe = dwc3_of_simple_probe,
|
||||
.remove = dwc3_of_simple_remove,
|
||||
.shutdown = dwc3_of_simple_shutdown,
|
||||
.driver = {
|
||||
.name = "dwc3-of-simple",
|
||||
.of_match_table = of_dwc3_simple_match,
|
||||
|
||||
@ -794,9 +794,9 @@ static int set_config(struct usb_composite_dev *cdev,
|
||||
result = 0;
|
||||
}
|
||||
|
||||
INFO(cdev, "%s config #%d: %s\n",
|
||||
usb_speed_string(gadget->speed),
|
||||
number, c ? c->label : "unconfigured");
|
||||
DBG(cdev, "%s config #%d: %s\n",
|
||||
usb_speed_string(gadget->speed),
|
||||
number, c ? c->label : "unconfigured");
|
||||
|
||||
if (!c)
|
||||
goto done;
|
||||
|
||||
@ -771,6 +771,24 @@ static struct configfs_item_operations acm_item_ops = {
|
||||
.release = acm_attr_release,
|
||||
};
|
||||
|
||||
#ifdef CONFIG_U_SERIAL_CONSOLE
|
||||
|
||||
static ssize_t f_acm_console_store(struct config_item *item,
|
||||
const char *page, size_t count)
|
||||
{
|
||||
return gserial_set_console(to_f_serial_opts(item)->port_num,
|
||||
page, count);
|
||||
}
|
||||
|
||||
static ssize_t f_acm_console_show(struct config_item *item, char *page)
|
||||
{
|
||||
return gserial_get_console(to_f_serial_opts(item)->port_num, page);
|
||||
}
|
||||
|
||||
CONFIGFS_ATTR(f_acm_, console);
|
||||
|
||||
#endif /* CONFIG_U_SERIAL_CONSOLE */
|
||||
|
||||
static ssize_t f_acm_port_num_show(struct config_item *item, char *page)
|
||||
{
|
||||
return sprintf(page, "%u\n", to_f_serial_opts(item)->port_num);
|
||||
@ -779,6 +797,9 @@ static ssize_t f_acm_port_num_show(struct config_item *item, char *page)
|
||||
CONFIGFS_ATTR_RO(f_acm_, port_num);
|
||||
|
||||
static struct configfs_attribute *acm_attrs[] = {
|
||||
#ifdef CONFIG_U_SERIAL_CONSOLE
|
||||
&f_acm_attr_console,
|
||||
#endif
|
||||
&f_acm_attr_port_num,
|
||||
NULL,
|
||||
};
|
||||
|
||||
@ -432,7 +432,7 @@ static struct usb_function_instance *obex_alloc_inst(void)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
|
||||
opts->func_inst.free_func_inst = obex_free_inst;
|
||||
ret = gserial_alloc_line(&opts->port_num);
|
||||
ret = gserial_alloc_line_no_console(&opts->port_num);
|
||||
if (ret) {
|
||||
kfree(opts);
|
||||
return ERR_PTR(ret);
|
||||
|
||||
@ -266,6 +266,24 @@ static struct configfs_item_operations serial_item_ops = {
|
||||
.release = serial_attr_release,
|
||||
};
|
||||
|
||||
#ifdef CONFIG_U_SERIAL_CONSOLE
|
||||
|
||||
static ssize_t f_serial_console_store(struct config_item *item,
|
||||
const char *page, size_t count)
|
||||
{
|
||||
return gserial_set_console(to_f_serial_opts(item)->port_num,
|
||||
page, count);
|
||||
}
|
||||
|
||||
static ssize_t f_serial_console_show(struct config_item *item, char *page)
|
||||
{
|
||||
return gserial_get_console(to_f_serial_opts(item)->port_num, page);
|
||||
}
|
||||
|
||||
CONFIGFS_ATTR(f_serial_, console);
|
||||
|
||||
#endif /* CONFIG_U_SERIAL_CONSOLE */
|
||||
|
||||
static ssize_t f_serial_port_num_show(struct config_item *item, char *page)
|
||||
{
|
||||
return sprintf(page, "%u\n", to_f_serial_opts(item)->port_num);
|
||||
@ -274,6 +292,9 @@ static ssize_t f_serial_port_num_show(struct config_item *item, char *page)
|
||||
CONFIGFS_ATTR_RO(f_serial_, port_num);
|
||||
|
||||
static struct configfs_attribute *acm_attrs[] = {
|
||||
#ifdef CONFIG_U_SERIAL_CONSOLE
|
||||
&f_serial_attr_console,
|
||||
#endif
|
||||
&f_serial_attr_port_num,
|
||||
NULL,
|
||||
};
|
||||
|
||||
@ -846,7 +846,7 @@ static void uasp_set_alt(struct f_uas *fu)
|
||||
|
||||
fu->flags = USBG_IS_UAS;
|
||||
|
||||
if (gadget->speed == USB_SPEED_SUPER)
|
||||
if (gadget->speed >= USB_SPEED_SUPER)
|
||||
fu->flags |= USBG_USE_STREAMS;
|
||||
|
||||
config_ep_by_speed(gadget, f, fu->ep_in);
|
||||
@ -2093,6 +2093,16 @@ static void tcm_delayed_set_alt(struct work_struct *wq)
|
||||
usb_composite_setup_continue(fu->function.config->cdev);
|
||||
}
|
||||
|
||||
static int tcm_get_alt(struct usb_function *f, unsigned intf)
|
||||
{
|
||||
if (intf == bot_intf_desc.bInterfaceNumber)
|
||||
return USB_G_ALT_INT_BBB;
|
||||
if (intf == uasp_intf_desc.bInterfaceNumber)
|
||||
return USB_G_ALT_INT_UAS;
|
||||
|
||||
return -EOPNOTSUPP;
|
||||
}
|
||||
|
||||
static int tcm_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
|
||||
{
|
||||
struct f_uas *fu = to_f_uas(f);
|
||||
@ -2300,6 +2310,7 @@ static struct usb_function *tcm_alloc(struct usb_function_instance *fi)
|
||||
fu->function.bind = tcm_bind;
|
||||
fu->function.unbind = tcm_unbind;
|
||||
fu->function.set_alt = tcm_set_alt;
|
||||
fu->function.get_alt = tcm_get_alt;
|
||||
fu->function.setup = tcm_setup;
|
||||
fu->function.disable = tcm_disable;
|
||||
fu->function.free_func = tcm_free;
|
||||
|
||||
@ -82,14 +82,13 @@
|
||||
#define GS_CONSOLE_BUF_SIZE 8192
|
||||
|
||||
/* console info */
|
||||
struct gscons_info {
|
||||
struct gs_port *port;
|
||||
struct task_struct *console_thread;
|
||||
struct kfifo con_buf;
|
||||
/* protect the buf and busy flag */
|
||||
spinlock_t con_lock;
|
||||
int req_busy;
|
||||
struct usb_request *console_req;
|
||||
struct gs_console {
|
||||
struct console console;
|
||||
struct work_struct work;
|
||||
spinlock_t lock;
|
||||
struct usb_request *req;
|
||||
struct kfifo buf;
|
||||
size_t missed;
|
||||
};
|
||||
|
||||
/*
|
||||
@ -101,8 +100,10 @@ struct gs_port {
|
||||
spinlock_t port_lock; /* guard port_* access */
|
||||
|
||||
struct gserial *port_usb;
|
||||
#ifdef CONFIG_U_SERIAL_CONSOLE
|
||||
struct gs_console *console;
|
||||
#endif
|
||||
|
||||
bool openclose; /* open/close in progress */
|
||||
u8 port_num;
|
||||
|
||||
struct list_head read_pool;
|
||||
@ -586,82 +587,45 @@ static int gs_open(struct tty_struct *tty, struct file *file)
|
||||
{
|
||||
int port_num = tty->index;
|
||||
struct gs_port *port;
|
||||
int status;
|
||||
int status = 0;
|
||||
|
||||
do {
|
||||
mutex_lock(&ports[port_num].lock);
|
||||
port = ports[port_num].port;
|
||||
if (!port)
|
||||
status = -ENODEV;
|
||||
else {
|
||||
spin_lock_irq(&port->port_lock);
|
||||
mutex_lock(&ports[port_num].lock);
|
||||
port = ports[port_num].port;
|
||||
if (!port) {
|
||||
status = -ENODEV;
|
||||
goto out;
|
||||
}
|
||||
|
||||
/* already open? Great. */
|
||||
if (port->port.count) {
|
||||
status = 0;
|
||||
port->port.count++;
|
||||
|
||||
/* currently opening/closing? wait ... */
|
||||
} else if (port->openclose) {
|
||||
status = -EBUSY;
|
||||
|
||||
/* ... else we do the work */
|
||||
} else {
|
||||
status = -EAGAIN;
|
||||
port->openclose = true;
|
||||
}
|
||||
spin_unlock_irq(&port->port_lock);
|
||||
}
|
||||
mutex_unlock(&ports[port_num].lock);
|
||||
|
||||
switch (status) {
|
||||
default:
|
||||
/* fully handled */
|
||||
return status;
|
||||
case -EAGAIN:
|
||||
/* must do the work */
|
||||
break;
|
||||
case -EBUSY:
|
||||
/* wait for EAGAIN task to finish */
|
||||
msleep(1);
|
||||
/* REVISIT could have a waitchannel here, if
|
||||
* concurrent open performance is important
|
||||
*/
|
||||
break;
|
||||
}
|
||||
} while (status != -EAGAIN);
|
||||
|
||||
/* Do the "real open" */
|
||||
spin_lock_irq(&port->port_lock);
|
||||
|
||||
/* allocate circular buffer on first open */
|
||||
if (!kfifo_initialized(&port->port_write_buf)) {
|
||||
|
||||
spin_unlock_irq(&port->port_lock);
|
||||
|
||||
/*
|
||||
* portmaster's mutex still protects from simultaneous open(),
|
||||
* and close() can't happen, yet.
|
||||
*/
|
||||
|
||||
status = kfifo_alloc(&port->port_write_buf,
|
||||
WRITE_BUF_SIZE, GFP_KERNEL);
|
||||
spin_lock_irq(&port->port_lock);
|
||||
|
||||
if (status) {
|
||||
pr_debug("gs_open: ttyGS%d (%p,%p) no buffer\n",
|
||||
port->port_num, tty, file);
|
||||
port->openclose = false;
|
||||
goto exit_unlock_port;
|
||||
port_num, tty, file);
|
||||
goto out;
|
||||
}
|
||||
|
||||
spin_lock_irq(&port->port_lock);
|
||||
}
|
||||
|
||||
/* REVISIT if REMOVED (ports[].port NULL), abort the open
|
||||
* to let rmmod work faster (but this way isn't wrong).
|
||||
*/
|
||||
|
||||
/* REVISIT maybe wait for "carrier detect" */
|
||||
/* already open? Great. */
|
||||
if (port->port.count++)
|
||||
goto exit_unlock_port;
|
||||
|
||||
tty->driver_data = port;
|
||||
port->port.tty = tty;
|
||||
|
||||
port->port.count = 1;
|
||||
port->openclose = false;
|
||||
|
||||
/* if connected, start the I/O stream */
|
||||
if (port->port_usb) {
|
||||
struct gserial *gser = port->port_usb;
|
||||
@ -675,20 +639,21 @@ static int gs_open(struct tty_struct *tty, struct file *file)
|
||||
|
||||
pr_debug("gs_open: ttyGS%d (%p,%p)\n", port->port_num, tty, file);
|
||||
|
||||
status = 0;
|
||||
|
||||
exit_unlock_port:
|
||||
spin_unlock_irq(&port->port_lock);
|
||||
out:
|
||||
mutex_unlock(&ports[port_num].lock);
|
||||
return status;
|
||||
}
|
||||
|
||||
static int gs_writes_finished(struct gs_port *p)
|
||||
static int gs_close_flush_done(struct gs_port *p)
|
||||
{
|
||||
int cond;
|
||||
|
||||
/* return true on disconnect or empty buffer */
|
||||
/* return true on disconnect or empty buffer or if raced with open() */
|
||||
spin_lock_irq(&p->port_lock);
|
||||
cond = (p->port_usb == NULL) || !kfifo_len(&p->port_write_buf);
|
||||
cond = p->port_usb == NULL || !kfifo_len(&p->port_write_buf) ||
|
||||
p->port.count > 1;
|
||||
spin_unlock_irq(&p->port_lock);
|
||||
|
||||
return cond;
|
||||
@ -702,6 +667,7 @@ static void gs_close(struct tty_struct *tty, struct file *file)
|
||||
spin_lock_irq(&port->port_lock);
|
||||
|
||||
if (port->port.count != 1) {
|
||||
raced_with_open:
|
||||
if (port->port.count == 0)
|
||||
WARN_ON(1);
|
||||
else
|
||||
@ -711,12 +677,6 @@ static void gs_close(struct tty_struct *tty, struct file *file)
|
||||
|
||||
pr_debug("gs_close: ttyGS%d (%p,%p) ...\n", port->port_num, tty, file);
|
||||
|
||||
/* mark port as closing but in use; we can drop port lock
|
||||
* and sleep if necessary
|
||||
*/
|
||||
port->openclose = true;
|
||||
port->port.count = 0;
|
||||
|
||||
gser = port->port_usb;
|
||||
if (gser && gser->disconnect)
|
||||
gser->disconnect(gser);
|
||||
@ -727,9 +687,13 @@ static void gs_close(struct tty_struct *tty, struct file *file)
|
||||
if (kfifo_len(&port->port_write_buf) > 0 && gser) {
|
||||
spin_unlock_irq(&port->port_lock);
|
||||
wait_event_interruptible_timeout(port->drain_wait,
|
||||
gs_writes_finished(port),
|
||||
gs_close_flush_done(port),
|
||||
GS_CLOSE_TIMEOUT * HZ);
|
||||
spin_lock_irq(&port->port_lock);
|
||||
|
||||
if (port->port.count != 1)
|
||||
goto raced_with_open;
|
||||
|
||||
gser = port->port_usb;
|
||||
}
|
||||
|
||||
@ -742,10 +706,9 @@ static void gs_close(struct tty_struct *tty, struct file *file)
|
||||
else
|
||||
kfifo_reset(&port->port_write_buf);
|
||||
|
||||
port->port.count = 0;
|
||||
port->port.tty = NULL;
|
||||
|
||||
port->openclose = false;
|
||||
|
||||
pr_debug("gs_close: ttyGS%d (%p,%p) done!\n",
|
||||
port->port_num, tty, file);
|
||||
|
||||
@ -889,36 +852,9 @@ static struct tty_driver *gs_tty_driver;
|
||||
|
||||
#ifdef CONFIG_U_SERIAL_CONSOLE
|
||||
|
||||
static struct gscons_info gscons_info;
|
||||
static struct console gserial_cons;
|
||||
|
||||
static struct usb_request *gs_request_new(struct usb_ep *ep)
|
||||
static void gs_console_complete_out(struct usb_ep *ep, struct usb_request *req)
|
||||
{
|
||||
struct usb_request *req = usb_ep_alloc_request(ep, GFP_ATOMIC);
|
||||
if (!req)
|
||||
return NULL;
|
||||
|
||||
req->buf = kmalloc(ep->maxpacket, GFP_ATOMIC);
|
||||
if (!req->buf) {
|
||||
usb_ep_free_request(ep, req);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return req;
|
||||
}
|
||||
|
||||
static void gs_request_free(struct usb_request *req, struct usb_ep *ep)
|
||||
{
|
||||
if (!req)
|
||||
return;
|
||||
|
||||
kfree(req->buf);
|
||||
usb_ep_free_request(ep, req);
|
||||
}
|
||||
|
||||
static void gs_complete_out(struct usb_ep *ep, struct usb_request *req)
|
||||
{
|
||||
struct gscons_info *info = &gscons_info;
|
||||
struct gs_console *cons = req->context;
|
||||
|
||||
switch (req->status) {
|
||||
default:
|
||||
@ -927,12 +863,12 @@ static void gs_complete_out(struct usb_ep *ep, struct usb_request *req)
|
||||
/* fall through */
|
||||
case 0:
|
||||
/* normal completion */
|
||||
spin_lock(&info->con_lock);
|
||||
info->req_busy = 0;
|
||||
spin_unlock(&info->con_lock);
|
||||
|
||||
wake_up_process(info->console_thread);
|
||||
spin_lock(&cons->lock);
|
||||
req->length = 0;
|
||||
schedule_work(&cons->work);
|
||||
spin_unlock(&cons->lock);
|
||||
break;
|
||||
case -ECONNRESET:
|
||||
case -ESHUTDOWN:
|
||||
/* disconnect */
|
||||
pr_vdebug("%s: %s shutdown\n", __func__, ep->name);
|
||||
@ -940,190 +876,250 @@ static void gs_complete_out(struct usb_ep *ep, struct usb_request *req)
|
||||
}
|
||||
}
|
||||
|
||||
static int gs_console_connect(int port_num)
|
||||
static void __gs_console_push(struct gs_console *cons)
|
||||
{
|
||||
struct gscons_info *info = &gscons_info;
|
||||
struct gs_port *port;
|
||||
struct usb_request *req = cons->req;
|
||||
struct usb_ep *ep;
|
||||
size_t size;
|
||||
|
||||
if (port_num != gserial_cons.index) {
|
||||
pr_err("%s: port num [%d] is not support console\n",
|
||||
__func__, port_num);
|
||||
return -ENXIO;
|
||||
if (!req)
|
||||
return; /* disconnected */
|
||||
|
||||
if (req->length)
|
||||
return; /* busy */
|
||||
|
||||
ep = cons->console.data;
|
||||
size = kfifo_out(&cons->buf, req->buf, ep->maxpacket);
|
||||
if (!size)
|
||||
return;
|
||||
|
||||
if (cons->missed && ep->maxpacket >= 64) {
|
||||
char buf[64];
|
||||
size_t len;
|
||||
|
||||
len = sprintf(buf, "\n[missed %zu bytes]\n", cons->missed);
|
||||
kfifo_in(&cons->buf, buf, len);
|
||||
cons->missed = 0;
|
||||
}
|
||||
|
||||
port = ports[port_num].port;
|
||||
ep = port->port_usb->in;
|
||||
if (!info->console_req) {
|
||||
info->console_req = gs_request_new(ep);
|
||||
if (!info->console_req)
|
||||
return -ENOMEM;
|
||||
info->console_req->complete = gs_complete_out;
|
||||
}
|
||||
|
||||
info->port = port;
|
||||
spin_lock(&info->con_lock);
|
||||
info->req_busy = 0;
|
||||
spin_unlock(&info->con_lock);
|
||||
pr_vdebug("port[%d] console connect!\n", port_num);
|
||||
return 0;
|
||||
req->length = size;
|
||||
if (usb_ep_queue(ep, req, GFP_ATOMIC))
|
||||
req->length = 0;
|
||||
}
|
||||
|
||||
static void gs_console_disconnect(struct usb_ep *ep)
|
||||
static void gs_console_work(struct work_struct *work)
|
||||
{
|
||||
struct gscons_info *info = &gscons_info;
|
||||
struct usb_request *req = info->console_req;
|
||||
struct gs_console *cons = container_of(work, struct gs_console, work);
|
||||
|
||||
gs_request_free(req, ep);
|
||||
info->console_req = NULL;
|
||||
}
|
||||
spin_lock_irq(&cons->lock);
|
||||
|
||||
static int gs_console_thread(void *data)
|
||||
{
|
||||
struct gscons_info *info = &gscons_info;
|
||||
struct gs_port *port;
|
||||
struct usb_request *req;
|
||||
struct usb_ep *ep;
|
||||
int xfer, ret, count, size;
|
||||
__gs_console_push(cons);
|
||||
|
||||
do {
|
||||
port = info->port;
|
||||
set_current_state(TASK_INTERRUPTIBLE);
|
||||
if (!port || !port->port_usb
|
||||
|| !port->port_usb->in || !info->console_req)
|
||||
goto sched;
|
||||
|
||||
req = info->console_req;
|
||||
ep = port->port_usb->in;
|
||||
|
||||
spin_lock_irq(&info->con_lock);
|
||||
count = kfifo_len(&info->con_buf);
|
||||
size = ep->maxpacket;
|
||||
|
||||
if (count > 0 && !info->req_busy) {
|
||||
set_current_state(TASK_RUNNING);
|
||||
if (count < size)
|
||||
size = count;
|
||||
|
||||
xfer = kfifo_out(&info->con_buf, req->buf, size);
|
||||
req->length = xfer;
|
||||
|
||||
spin_unlock(&info->con_lock);
|
||||
ret = usb_ep_queue(ep, req, GFP_ATOMIC);
|
||||
spin_lock(&info->con_lock);
|
||||
if (ret < 0)
|
||||
info->req_busy = 0;
|
||||
else
|
||||
info->req_busy = 1;
|
||||
|
||||
spin_unlock_irq(&info->con_lock);
|
||||
} else {
|
||||
spin_unlock_irq(&info->con_lock);
|
||||
sched:
|
||||
if (kthread_should_stop()) {
|
||||
set_current_state(TASK_RUNNING);
|
||||
break;
|
||||
}
|
||||
schedule();
|
||||
}
|
||||
} while (1);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int gs_console_setup(struct console *co, char *options)
|
||||
{
|
||||
struct gscons_info *info = &gscons_info;
|
||||
int status;
|
||||
|
||||
info->port = NULL;
|
||||
info->console_req = NULL;
|
||||
info->req_busy = 0;
|
||||
spin_lock_init(&info->con_lock);
|
||||
|
||||
status = kfifo_alloc(&info->con_buf, GS_CONSOLE_BUF_SIZE, GFP_KERNEL);
|
||||
if (status) {
|
||||
pr_err("%s: allocate console buffer failed\n", __func__);
|
||||
return status;
|
||||
}
|
||||
|
||||
info->console_thread = kthread_create(gs_console_thread,
|
||||
co, "gs_console");
|
||||
if (IS_ERR(info->console_thread)) {
|
||||
pr_err("%s: cannot create console thread\n", __func__);
|
||||
kfifo_free(&info->con_buf);
|
||||
return PTR_ERR(info->console_thread);
|
||||
}
|
||||
wake_up_process(info->console_thread);
|
||||
|
||||
return 0;
|
||||
spin_unlock_irq(&cons->lock);
|
||||
}
|
||||
|
||||
static void gs_console_write(struct console *co,
|
||||
const char *buf, unsigned count)
|
||||
{
|
||||
struct gscons_info *info = &gscons_info;
|
||||
struct gs_console *cons = container_of(co, struct gs_console, console);
|
||||
unsigned long flags;
|
||||
size_t n;
|
||||
|
||||
spin_lock_irqsave(&info->con_lock, flags);
|
||||
kfifo_in(&info->con_buf, buf, count);
|
||||
spin_unlock_irqrestore(&info->con_lock, flags);
|
||||
spin_lock_irqsave(&cons->lock, flags);
|
||||
|
||||
wake_up_process(info->console_thread);
|
||||
n = kfifo_in(&cons->buf, buf, count);
|
||||
if (n < count)
|
||||
cons->missed += count - n;
|
||||
|
||||
if (cons->req && !cons->req->length)
|
||||
schedule_work(&cons->work);
|
||||
|
||||
spin_unlock_irqrestore(&cons->lock, flags);
|
||||
}
|
||||
|
||||
static struct tty_driver *gs_console_device(struct console *co, int *index)
|
||||
{
|
||||
struct tty_driver **p = (struct tty_driver **)co->data;
|
||||
|
||||
if (!*p)
|
||||
return NULL;
|
||||
|
||||
*index = co->index;
|
||||
return *p;
|
||||
return gs_tty_driver;
|
||||
}
|
||||
|
||||
static struct console gserial_cons = {
|
||||
.name = "ttyGS",
|
||||
.write = gs_console_write,
|
||||
.device = gs_console_device,
|
||||
.setup = gs_console_setup,
|
||||
.flags = CON_PRINTBUFFER,
|
||||
.index = -1,
|
||||
.data = &gs_tty_driver,
|
||||
};
|
||||
|
||||
static void gserial_console_init(void)
|
||||
static int gs_console_connect(struct gs_port *port)
|
||||
{
|
||||
register_console(&gserial_cons);
|
||||
struct gs_console *cons = port->console;
|
||||
struct usb_request *req;
|
||||
struct usb_ep *ep;
|
||||
|
||||
if (!cons)
|
||||
return 0;
|
||||
|
||||
ep = port->port_usb->in;
|
||||
req = gs_alloc_req(ep, ep->maxpacket, GFP_ATOMIC);
|
||||
if (!req)
|
||||
return -ENOMEM;
|
||||
req->complete = gs_console_complete_out;
|
||||
req->context = cons;
|
||||
req->length = 0;
|
||||
|
||||
spin_lock(&cons->lock);
|
||||
cons->req = req;
|
||||
cons->console.data = ep;
|
||||
spin_unlock(&cons->lock);
|
||||
|
||||
pr_debug("ttyGS%d: console connected!\n", port->port_num);
|
||||
|
||||
schedule_work(&cons->work);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void gserial_console_exit(void)
|
||||
static void gs_console_disconnect(struct gs_port *port)
|
||||
{
|
||||
struct gscons_info *info = &gscons_info;
|
||||
struct gs_console *cons = port->console;
|
||||
struct usb_request *req;
|
||||
struct usb_ep *ep;
|
||||
|
||||
unregister_console(&gserial_cons);
|
||||
if (!IS_ERR_OR_NULL(info->console_thread))
|
||||
kthread_stop(info->console_thread);
|
||||
kfifo_free(&info->con_buf);
|
||||
if (!cons)
|
||||
return;
|
||||
|
||||
spin_lock(&cons->lock);
|
||||
|
||||
req = cons->req;
|
||||
ep = cons->console.data;
|
||||
cons->req = NULL;
|
||||
|
||||
spin_unlock(&cons->lock);
|
||||
|
||||
if (!req)
|
||||
return;
|
||||
|
||||
usb_ep_dequeue(ep, req);
|
||||
gs_free_req(ep, req);
|
||||
}
|
||||
|
||||
static int gs_console_init(struct gs_port *port)
|
||||
{
|
||||
struct gs_console *cons;
|
||||
int err;
|
||||
|
||||
if (port->console)
|
||||
return 0;
|
||||
|
||||
cons = kzalloc(sizeof(*port->console), GFP_KERNEL);
|
||||
if (!cons)
|
||||
return -ENOMEM;
|
||||
|
||||
strcpy(cons->console.name, "ttyGS");
|
||||
cons->console.write = gs_console_write;
|
||||
cons->console.device = gs_console_device;
|
||||
cons->console.flags = CON_PRINTBUFFER;
|
||||
cons->console.index = port->port_num;
|
||||
|
||||
INIT_WORK(&cons->work, gs_console_work);
|
||||
spin_lock_init(&cons->lock);
|
||||
|
||||
err = kfifo_alloc(&cons->buf, GS_CONSOLE_BUF_SIZE, GFP_KERNEL);
|
||||
if (err) {
|
||||
pr_err("ttyGS%d: allocate console buffer failed\n", port->port_num);
|
||||
kfree(cons);
|
||||
return err;
|
||||
}
|
||||
|
||||
port->console = cons;
|
||||
register_console(&cons->console);
|
||||
|
||||
spin_lock_irq(&port->port_lock);
|
||||
if (port->port_usb)
|
||||
gs_console_connect(port);
|
||||
spin_unlock_irq(&port->port_lock);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void gs_console_exit(struct gs_port *port)
|
||||
{
|
||||
struct gs_console *cons = port->console;
|
||||
|
||||
if (!cons)
|
||||
return;
|
||||
|
||||
unregister_console(&cons->console);
|
||||
|
||||
spin_lock_irq(&port->port_lock);
|
||||
if (cons->req)
|
||||
gs_console_disconnect(port);
|
||||
spin_unlock_irq(&port->port_lock);
|
||||
|
||||
cancel_work_sync(&cons->work);
|
||||
kfifo_free(&cons->buf);
|
||||
kfree(cons);
|
||||
port->console = NULL;
|
||||
}
|
||||
|
||||
ssize_t gserial_set_console(unsigned char port_num, const char *page, size_t count)
|
||||
{
|
||||
struct gs_port *port;
|
||||
bool enable;
|
||||
int ret;
|
||||
|
||||
ret = strtobool(page, &enable);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
mutex_lock(&ports[port_num].lock);
|
||||
port = ports[port_num].port;
|
||||
|
||||
if (WARN_ON(port == NULL)) {
|
||||
ret = -ENXIO;
|
||||
goto out;
|
||||
}
|
||||
|
||||
if (enable)
|
||||
ret = gs_console_init(port);
|
||||
else
|
||||
gs_console_exit(port);
|
||||
out:
|
||||
mutex_unlock(&ports[port_num].lock);
|
||||
|
||||
return ret < 0 ? ret : count;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(gserial_set_console);
|
||||
|
||||
ssize_t gserial_get_console(unsigned char port_num, char *page)
|
||||
{
|
||||
struct gs_port *port;
|
||||
ssize_t ret;
|
||||
|
||||
mutex_lock(&ports[port_num].lock);
|
||||
port = ports[port_num].port;
|
||||
|
||||
if (WARN_ON(port == NULL))
|
||||
ret = -ENXIO;
|
||||
else
|
||||
ret = sprintf(page, "%u\n", !!port->console);
|
||||
|
||||
mutex_unlock(&ports[port_num].lock);
|
||||
|
||||
return ret;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(gserial_get_console);
|
||||
|
||||
#else
|
||||
|
||||
static int gs_console_connect(int port_num)
|
||||
static int gs_console_connect(struct gs_port *port)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void gs_console_disconnect(struct usb_ep *ep)
|
||||
static void gs_console_disconnect(struct gs_port *port)
|
||||
{
|
||||
}
|
||||
|
||||
static void gserial_console_init(void)
|
||||
static int gs_console_init(struct gs_port *port)
|
||||
{
|
||||
return -ENOSYS;
|
||||
}
|
||||
|
||||
static void gserial_console_exit(void)
|
||||
static void gs_console_exit(struct gs_port *port)
|
||||
{
|
||||
}
|
||||
|
||||
@ -1172,8 +1168,9 @@ static int gs_closed(struct gs_port *port)
|
||||
int cond;
|
||||
|
||||
spin_lock_irq(&port->port_lock);
|
||||
cond = (port->port.count == 0) && !port->openclose;
|
||||
cond = port->port.count == 0;
|
||||
spin_unlock_irq(&port->port_lock);
|
||||
|
||||
return cond;
|
||||
}
|
||||
|
||||
@ -1197,18 +1194,19 @@ void gserial_free_line(unsigned char port_num)
|
||||
return;
|
||||
}
|
||||
port = ports[port_num].port;
|
||||
gs_console_exit(port);
|
||||
ports[port_num].port = NULL;
|
||||
mutex_unlock(&ports[port_num].lock);
|
||||
|
||||
gserial_free_port(port);
|
||||
tty_unregister_device(gs_tty_driver, port_num);
|
||||
gserial_console_exit();
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(gserial_free_line);
|
||||
|
||||
int gserial_alloc_line(unsigned char *line_num)
|
||||
int gserial_alloc_line_no_console(unsigned char *line_num)
|
||||
{
|
||||
struct usb_cdc_line_coding coding;
|
||||
struct gs_port *port;
|
||||
struct device *tty_dev;
|
||||
int ret;
|
||||
int port_num;
|
||||
@ -1231,24 +1229,35 @@ int gserial_alloc_line(unsigned char *line_num)
|
||||
|
||||
/* ... and sysfs class devices, so mdev/udev make /dev/ttyGS* */
|
||||
|
||||
tty_dev = tty_port_register_device(&ports[port_num].port->port,
|
||||
port = ports[port_num].port;
|
||||
tty_dev = tty_port_register_device(&port->port,
|
||||
gs_tty_driver, port_num, NULL);
|
||||
if (IS_ERR(tty_dev)) {
|
||||
struct gs_port *port;
|
||||
pr_err("%s: failed to register tty for port %d, err %ld\n",
|
||||
__func__, port_num, PTR_ERR(tty_dev));
|
||||
|
||||
ret = PTR_ERR(tty_dev);
|
||||
port = ports[port_num].port;
|
||||
mutex_lock(&ports[port_num].lock);
|
||||
ports[port_num].port = NULL;
|
||||
mutex_unlock(&ports[port_num].lock);
|
||||
gserial_free_port(port);
|
||||
goto err;
|
||||
}
|
||||
*line_num = port_num;
|
||||
gserial_console_init();
|
||||
err:
|
||||
return ret;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(gserial_alloc_line_no_console);
|
||||
|
||||
int gserial_alloc_line(unsigned char *line_num)
|
||||
{
|
||||
int ret = gserial_alloc_line_no_console(line_num);
|
||||
|
||||
if (!ret && !*line_num)
|
||||
gs_console_init(ports[*line_num].port);
|
||||
|
||||
return ret;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(gserial_alloc_line);
|
||||
|
||||
/**
|
||||
@ -1327,7 +1336,7 @@ int gserial_connect(struct gserial *gser, u8 port_num)
|
||||
gser->disconnect(gser);
|
||||
}
|
||||
|
||||
status = gs_console_connect(port_num);
|
||||
status = gs_console_connect(port);
|
||||
spin_unlock_irqrestore(&port->port_lock, flags);
|
||||
|
||||
return status;
|
||||
@ -1359,12 +1368,14 @@ void gserial_disconnect(struct gserial *gser)
|
||||
/* tell the TTY glue not to do I/O here any more */
|
||||
spin_lock_irqsave(&port->port_lock, flags);
|
||||
|
||||
gs_console_disconnect(port);
|
||||
|
||||
/* REVISIT as above: how best to track this? */
|
||||
port->port_line_coding = gser->port_line_coding;
|
||||
|
||||
port->port_usb = NULL;
|
||||
gser->ioport = NULL;
|
||||
if (port->port.count > 0 || port->openclose) {
|
||||
if (port->port.count > 0) {
|
||||
wake_up_interruptible(&port->drain_wait);
|
||||
if (port->port.tty)
|
||||
tty_hangup(port->port.tty);
|
||||
@ -1377,7 +1388,7 @@ void gserial_disconnect(struct gserial *gser)
|
||||
|
||||
/* finally, free any unused/unusable I/O buffers */
|
||||
spin_lock_irqsave(&port->port_lock, flags);
|
||||
if (port->port.count == 0 && !port->openclose)
|
||||
if (port->port.count == 0)
|
||||
kfifo_free(&port->port_write_buf);
|
||||
gs_free_requests(gser->out, &port->read_pool, NULL);
|
||||
gs_free_requests(gser->out, &port->read_queue, NULL);
|
||||
@ -1386,7 +1397,6 @@ void gserial_disconnect(struct gserial *gser)
|
||||
port->read_allocated = port->read_started =
|
||||
port->write_allocated = port->write_started = 0;
|
||||
|
||||
gs_console_disconnect(gser->in);
|
||||
spin_unlock_irqrestore(&port->port_lock, flags);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(gserial_disconnect);
|
||||
|
||||
@ -54,9 +54,17 @@ struct usb_request *gs_alloc_req(struct usb_ep *ep, unsigned len, gfp_t flags);
|
||||
void gs_free_req(struct usb_ep *, struct usb_request *req);
|
||||
|
||||
/* management of individual TTY ports */
|
||||
int gserial_alloc_line_no_console(unsigned char *port_line);
|
||||
int gserial_alloc_line(unsigned char *port_line);
|
||||
void gserial_free_line(unsigned char port_line);
|
||||
|
||||
#ifdef CONFIG_U_SERIAL_CONSOLE
|
||||
|
||||
ssize_t gserial_set_console(unsigned char port_num, const char *page, size_t count);
|
||||
ssize_t gserial_get_console(unsigned char port_num, char *page);
|
||||
|
||||
#endif /* CONFIG_U_SERIAL_CONSOLE */
|
||||
|
||||
/* connect/disconnect is handled by individual functions */
|
||||
int gserial_connect(struct gserial *, u8 port_num);
|
||||
void gserial_disconnect(struct gserial *);
|
||||
|
||||
@ -97,6 +97,36 @@ static unsigned n_ports = 1;
|
||||
module_param(n_ports, uint, 0);
|
||||
MODULE_PARM_DESC(n_ports, "number of ports to create, default=1");
|
||||
|
||||
static bool enable = true;
|
||||
|
||||
static int switch_gserial_enable(bool do_enable);
|
||||
|
||||
static int enable_set(const char *s, const struct kernel_param *kp)
|
||||
{
|
||||
bool do_enable;
|
||||
int ret;
|
||||
|
||||
if (!s) /* called for no-arg enable == default */
|
||||
return 0;
|
||||
|
||||
ret = strtobool(s, &do_enable);
|
||||
if (ret || enable == do_enable)
|
||||
return ret;
|
||||
|
||||
ret = switch_gserial_enable(do_enable);
|
||||
if (!ret)
|
||||
enable = do_enable;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static const struct kernel_param_ops enable_ops = {
|
||||
.set = enable_set,
|
||||
.get = param_get_bool,
|
||||
};
|
||||
|
||||
module_param_cb(enable, &enable_ops, &enable, 0644);
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
static struct usb_configuration serial_config_driver = {
|
||||
@ -240,6 +270,19 @@ static struct usb_composite_driver gserial_driver = {
|
||||
.unbind = gs_unbind,
|
||||
};
|
||||
|
||||
static int switch_gserial_enable(bool do_enable)
|
||||
{
|
||||
if (!serial_config_driver.label)
|
||||
/* init() was not called, yet */
|
||||
return 0;
|
||||
|
||||
if (do_enable)
|
||||
return usb_composite_probe(&gserial_driver);
|
||||
|
||||
usb_composite_unregister(&gserial_driver);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int __init init(void)
|
||||
{
|
||||
/* We *could* export two configs; that'd be much cleaner...
|
||||
@ -266,12 +309,16 @@ static int __init init(void)
|
||||
}
|
||||
strings_dev[STRING_DESCRIPTION_IDX].s = serial_config_driver.label;
|
||||
|
||||
if (!enable)
|
||||
return 0;
|
||||
|
||||
return usb_composite_probe(&gserial_driver);
|
||||
}
|
||||
module_init(init);
|
||||
|
||||
static void __exit cleanup(void)
|
||||
{
|
||||
usb_composite_unregister(&gserial_driver);
|
||||
if (enable)
|
||||
usb_composite_unregister(&gserial_driver);
|
||||
}
|
||||
module_exit(cleanup);
|
||||
|
||||
@ -441,6 +441,17 @@ config USB_GADGET_XILINX
|
||||
dynamically linked module called "udc-xilinx" and force all
|
||||
gadget drivers to also be dynamically linked.
|
||||
|
||||
config USB_TEGRA_XUDC
|
||||
tristate "NVIDIA Tegra Superspeed USB 3.0 Device Controller"
|
||||
depends on ARCH_TEGRA || COMPILE_TEST
|
||||
depends on PHY_TEGRA_XUSB
|
||||
help
|
||||
Enables NVIDIA Tegra USB 3.0 device mode controller driver.
|
||||
|
||||
Say "y" to link the driver statically, or "m" to build a
|
||||
dynamically linked module called "tegra_xudc" and force all
|
||||
gadget drivers to also be dynamically linked.
|
||||
|
||||
source "drivers/usb/gadget/udc/aspeed-vhub/Kconfig"
|
||||
|
||||
#
|
||||
|
||||
@ -24,6 +24,7 @@ obj-$(CONFIG_USB_BCM63XX_UDC) += bcm63xx_udc.o
|
||||
obj-$(CONFIG_USB_FSL_USB2) += fsl_usb2_udc.o
|
||||
fsl_usb2_udc-y := fsl_udc_core.o
|
||||
fsl_usb2_udc-$(CONFIG_ARCH_MXC) += fsl_mxc_udc.o
|
||||
obj-$(CONFIG_USB_TEGRA_XUDC) += tegra-xudc.o
|
||||
obj-$(CONFIG_USB_M66592) += m66592-udc.o
|
||||
obj-$(CONFIG_USB_R8A66597) += r8a66597-udc.o
|
||||
obj-$(CONFIG_USB_RENESAS_USB3) += renesas_usb3.o
|
||||
|
||||
@ -1052,10 +1052,11 @@ static int fsl_ep_fifo_status(struct usb_ep *_ep)
|
||||
u32 bitmask;
|
||||
struct ep_queue_head *qh;
|
||||
|
||||
ep = container_of(_ep, struct fsl_ep, ep);
|
||||
if (!_ep || (!ep->ep.desc && ep_index(ep) != 0))
|
||||
if (!_ep || _ep->desc || !(_ep->desc->bEndpointAddress&0xF))
|
||||
return -ENODEV;
|
||||
|
||||
ep = container_of(_ep, struct fsl_ep, ep);
|
||||
|
||||
udc = (struct fsl_udc *)ep->udc;
|
||||
|
||||
if (!udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN)
|
||||
@ -1595,14 +1596,13 @@ static int process_ep_req(struct fsl_udc *udc, int pipe,
|
||||
struct fsl_req *curr_req)
|
||||
{
|
||||
struct ep_td_struct *curr_td;
|
||||
int td_complete, actual, remaining_length, j, tmp;
|
||||
int actual, remaining_length, j, tmp;
|
||||
int status = 0;
|
||||
int errors = 0;
|
||||
struct ep_queue_head *curr_qh = &udc->ep_qh[pipe];
|
||||
int direction = pipe % 2;
|
||||
|
||||
curr_td = curr_req->head;
|
||||
td_complete = 0;
|
||||
actual = curr_req->req.length;
|
||||
|
||||
for (j = 0; j < curr_req->dtd_count; j++) {
|
||||
@ -1647,11 +1647,9 @@ static int process_ep_req(struct fsl_udc *udc, int pipe,
|
||||
status = -EPROTO;
|
||||
break;
|
||||
} else {
|
||||
td_complete++;
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
td_complete++;
|
||||
VDBG("dTD transmitted successful");
|
||||
}
|
||||
|
||||
|
||||
@ -3000,7 +3000,6 @@ static int lpc32xx_udc_probe(struct platform_device *pdev)
|
||||
struct device *dev = &pdev->dev;
|
||||
struct lpc32xx_udc *udc;
|
||||
int retval, i;
|
||||
struct resource *res;
|
||||
dma_addr_t dma_handle;
|
||||
struct device_node *isp1301_node;
|
||||
|
||||
@ -3048,9 +3047,6 @@ static int lpc32xx_udc_probe(struct platform_device *pdev)
|
||||
* IORESOURCE_IRQ, USB device interrupt number
|
||||
* IORESOURCE_IRQ, USB transceiver interrupt number
|
||||
*/
|
||||
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
||||
if (!res)
|
||||
return -ENXIO;
|
||||
|
||||
spin_lock_init(&udc->lock);
|
||||
|
||||
@ -3061,7 +3057,7 @@ static int lpc32xx_udc_probe(struct platform_device *pdev)
|
||||
return udc->udp_irq[i];
|
||||
}
|
||||
|
||||
udc->udp_baseaddr = devm_ioremap_resource(dev, res);
|
||||
udc->udp_baseaddr = devm_platform_ioremap_resource(pdev, 0);
|
||||
if (IS_ERR(udc->udp_baseaddr)) {
|
||||
dev_err(udc->dev, "IO map failure\n");
|
||||
return PTR_ERR(udc->udp_baseaddr);
|
||||
|
||||
@ -775,6 +775,18 @@ static void usb3_irq_epc_int_1_resume(struct renesas_usb3 *usb3)
|
||||
usb3_transition_to_default_state(usb3, false);
|
||||
}
|
||||
|
||||
static void usb3_irq_epc_int_1_suspend(struct renesas_usb3 *usb3)
|
||||
{
|
||||
usb3_disable_irq_1(usb3, USB_INT_1_B2_SPND);
|
||||
|
||||
if (usb3->gadget.speed != USB_SPEED_UNKNOWN &&
|
||||
usb3->gadget.state != USB_STATE_NOTATTACHED) {
|
||||
if (usb3->driver && usb3->driver->suspend)
|
||||
usb3->driver->suspend(&usb3->gadget);
|
||||
usb_gadget_set_state(&usb3->gadget, USB_STATE_SUSPENDED);
|
||||
}
|
||||
}
|
||||
|
||||
static void usb3_irq_epc_int_1_disable(struct renesas_usb3 *usb3)
|
||||
{
|
||||
usb3_stop_usb3_connection(usb3);
|
||||
@ -860,6 +872,9 @@ static void usb3_irq_epc_int_1(struct renesas_usb3 *usb3, u32 int_sta_1)
|
||||
if (int_sta_1 & USB_INT_1_B2_RSUM)
|
||||
usb3_irq_epc_int_1_resume(usb3);
|
||||
|
||||
if (int_sta_1 & USB_INT_1_B2_SPND)
|
||||
usb3_irq_epc_int_1_suspend(usb3);
|
||||
|
||||
if (int_sta_1 & USB_INT_1_SPEED)
|
||||
usb3_irq_epc_int_1_speed(usb3);
|
||||
|
||||
|
||||
3810
drivers/usb/gadget/udc/tegra-xudc.c
Normal file
3810
drivers/usb/gadget/udc/tegra-xudc.c
Normal file
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue
Block a user