mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
495 lines
12 KiB
495 lines
12 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
/* |
|
* Cadence USBSS and USBSSP DRD Driver. |
|
* |
|
* Copyright (C) 2018-2020 Cadence. |
|
* Copyright (C) 2019 Texas Instruments |
|
* |
|
* Author: Pawel Laszczak <[email protected]> |
|
* Roger Quadros <[email protected]> |
|
* |
|
*/ |
|
#include <linux/kernel.h> |
|
#include <linux/interrupt.h> |
|
#include <linux/delay.h> |
|
#include <linux/iopoll.h> |
|
#include <linux/usb/otg.h> |
|
|
|
#include "drd.h" |
|
#include "core.h" |
|
|
|
/** |
|
* cdns_set_mode - change mode of OTG Core |
|
* @cdns: pointer to context structure |
|
* @mode: selected mode from cdns_role |
|
* |
|
* Returns 0 on success otherwise negative errno |
|
*/ |
|
static int cdns_set_mode(struct cdns *cdns, enum usb_dr_mode mode) |
|
{ |
|
void __iomem *override_reg; |
|
u32 reg; |
|
|
|
switch (mode) { |
|
case USB_DR_MODE_PERIPHERAL: |
|
break; |
|
case USB_DR_MODE_HOST: |
|
break; |
|
case USB_DR_MODE_OTG: |
|
dev_dbg(cdns->dev, "Set controller to OTG mode\n"); |
|
|
|
if (cdns->version == CDNSP_CONTROLLER_V2) |
|
override_reg = &cdns->otg_cdnsp_regs->override; |
|
else if (cdns->version == CDNS3_CONTROLLER_V1) |
|
override_reg = &cdns->otg_v1_regs->override; |
|
else |
|
override_reg = &cdns->otg_v0_regs->ctrl1; |
|
|
|
reg = readl(override_reg); |
|
|
|
if (cdns->version != CDNS3_CONTROLLER_V0) |
|
reg |= OVERRIDE_IDPULLUP; |
|
else |
|
reg |= OVERRIDE_IDPULLUP_V0; |
|
|
|
writel(reg, override_reg); |
|
|
|
if (cdns->version == CDNS3_CONTROLLER_V1) { |
|
/* |
|
* Enable work around feature built into the |
|
* controller to address issue with RX Sensitivity |
|
* est (EL_17) for USB2 PHY. The issue only occures |
|
* for 0x0002450D controller version. |
|
*/ |
|
if (cdns->phyrst_a_enable) { |
|
reg = readl(&cdns->otg_v1_regs->phyrst_cfg); |
|
reg |= PHYRST_CFG_PHYRST_A_ENABLE; |
|
writel(reg, &cdns->otg_v1_regs->phyrst_cfg); |
|
} |
|
} |
|
|
|
/* |
|
* Hardware specification says: "ID_VALUE must be valid within |
|
* 50ms after idpullup is set to '1" so driver must wait |
|
* 50ms before reading this pin. |
|
*/ |
|
usleep_range(50000, 60000); |
|
break; |
|
default: |
|
dev_err(cdns->dev, "Unsupported mode of operation %d\n", mode); |
|
return -EINVAL; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
int cdns_get_id(struct cdns *cdns) |
|
{ |
|
int id; |
|
|
|
id = readl(&cdns->otg_regs->sts) & OTGSTS_ID_VALUE; |
|
dev_dbg(cdns->dev, "OTG ID: %d", id); |
|
|
|
return id; |
|
} |
|
|
|
int cdns_get_vbus(struct cdns *cdns) |
|
{ |
|
int vbus; |
|
|
|
vbus = !!(readl(&cdns->otg_regs->sts) & OTGSTS_VBUS_VALID); |
|
dev_dbg(cdns->dev, "OTG VBUS: %d", vbus); |
|
|
|
return vbus; |
|
} |
|
|
|
void cdns_clear_vbus(struct cdns *cdns) |
|
{ |
|
u32 reg; |
|
|
|
if (cdns->version != CDNSP_CONTROLLER_V2) |
|
return; |
|
|
|
reg = readl(&cdns->otg_cdnsp_regs->override); |
|
reg |= OVERRIDE_SESS_VLD_SEL; |
|
writel(reg, &cdns->otg_cdnsp_regs->override); |
|
} |
|
EXPORT_SYMBOL_GPL(cdns_clear_vbus); |
|
|
|
void cdns_set_vbus(struct cdns *cdns) |
|
{ |
|
u32 reg; |
|
|
|
if (cdns->version != CDNSP_CONTROLLER_V2) |
|
return; |
|
|
|
reg = readl(&cdns->otg_cdnsp_regs->override); |
|
reg &= ~OVERRIDE_SESS_VLD_SEL; |
|
writel(reg, &cdns->otg_cdnsp_regs->override); |
|
} |
|
EXPORT_SYMBOL_GPL(cdns_set_vbus); |
|
|
|
bool cdns_is_host(struct cdns *cdns) |
|
{ |
|
if (cdns->dr_mode == USB_DR_MODE_HOST) |
|
return true; |
|
else if (cdns_get_id(cdns) == CDNS3_ID_HOST) |
|
return true; |
|
|
|
return false; |
|
} |
|
|
|
bool cdns_is_device(struct cdns *cdns) |
|
{ |
|
if (cdns->dr_mode == USB_DR_MODE_PERIPHERAL) |
|
return true; |
|
else if (cdns->dr_mode == USB_DR_MODE_OTG) |
|
if (cdns_get_id(cdns) == CDNS3_ID_PERIPHERAL) |
|
return true; |
|
|
|
return false; |
|
} |
|
|
|
/** |
|
* cdns_otg_disable_irq - Disable all OTG interrupts |
|
* @cdns: Pointer to controller context structure |
|
*/ |
|
static void cdns_otg_disable_irq(struct cdns *cdns) |
|
{ |
|
writel(0, &cdns->otg_irq_regs->ien); |
|
} |
|
|
|
/** |
|
* cdns_otg_enable_irq - enable id and sess_valid interrupts |
|
* @cdns: Pointer to controller context structure |
|
*/ |
|
static void cdns_otg_enable_irq(struct cdns *cdns) |
|
{ |
|
writel(OTGIEN_ID_CHANGE_INT | OTGIEN_VBUSVALID_RISE_INT | |
|
OTGIEN_VBUSVALID_FALL_INT, &cdns->otg_irq_regs->ien); |
|
} |
|
|
|
/** |
|
* cdns_drd_host_on - start host. |
|
* @cdns: Pointer to controller context structure. |
|
* |
|
* Returns 0 on success otherwise negative errno. |
|
*/ |
|
int cdns_drd_host_on(struct cdns *cdns) |
|
{ |
|
u32 val, ready_bit; |
|
int ret; |
|
|
|
/* Enable host mode. */ |
|
writel(OTGCMD_HOST_BUS_REQ | OTGCMD_OTG_DIS, |
|
&cdns->otg_regs->cmd); |
|
|
|
if (cdns->version == CDNSP_CONTROLLER_V2) |
|
ready_bit = OTGSTS_CDNSP_XHCI_READY; |
|
else |
|
ready_bit = OTGSTS_CDNS3_XHCI_READY; |
|
|
|
dev_dbg(cdns->dev, "Waiting till Host mode is turned on\n"); |
|
ret = readl_poll_timeout_atomic(&cdns->otg_regs->sts, val, |
|
val & ready_bit, 1, 100000); |
|
|
|
if (ret) |
|
dev_err(cdns->dev, "timeout waiting for xhci_ready\n"); |
|
|
|
phy_set_mode(cdns->usb3_phy, PHY_MODE_USB_HOST); |
|
return ret; |
|
} |
|
|
|
/** |
|
* cdns_drd_host_off - stop host. |
|
* @cdns: Pointer to controller context structure. |
|
*/ |
|
void cdns_drd_host_off(struct cdns *cdns) |
|
{ |
|
u32 val; |
|
|
|
writel(OTGCMD_HOST_BUS_DROP | OTGCMD_DEV_BUS_DROP | |
|
OTGCMD_DEV_POWER_OFF | OTGCMD_HOST_POWER_OFF, |
|
&cdns->otg_regs->cmd); |
|
|
|
/* Waiting till H_IDLE state.*/ |
|
readl_poll_timeout_atomic(&cdns->otg_regs->state, val, |
|
!(val & OTGSTATE_HOST_STATE_MASK), |
|
1, 2000000); |
|
phy_set_mode(cdns->usb3_phy, PHY_MODE_INVALID); |
|
} |
|
|
|
/** |
|
* cdns_drd_gadget_on - start gadget. |
|
* @cdns: Pointer to controller context structure. |
|
* |
|
* Returns 0 on success otherwise negative errno |
|
*/ |
|
int cdns_drd_gadget_on(struct cdns *cdns) |
|
{ |
|
u32 reg = OTGCMD_OTG_DIS; |
|
u32 ready_bit; |
|
int ret, val; |
|
|
|
/* switch OTG core */ |
|
writel(OTGCMD_DEV_BUS_REQ | reg, &cdns->otg_regs->cmd); |
|
|
|
dev_dbg(cdns->dev, "Waiting till Device mode is turned on\n"); |
|
|
|
if (cdns->version == CDNSP_CONTROLLER_V2) |
|
ready_bit = OTGSTS_CDNSP_DEV_READY; |
|
else |
|
ready_bit = OTGSTS_CDNS3_DEV_READY; |
|
|
|
ret = readl_poll_timeout_atomic(&cdns->otg_regs->sts, val, |
|
val & ready_bit, 1, 100000); |
|
if (ret) { |
|
dev_err(cdns->dev, "timeout waiting for dev_ready\n"); |
|
return ret; |
|
} |
|
|
|
phy_set_mode(cdns->usb3_phy, PHY_MODE_USB_DEVICE); |
|
return 0; |
|
} |
|
EXPORT_SYMBOL_GPL(cdns_drd_gadget_on); |
|
|
|
/** |
|
* cdns_drd_gadget_off - stop gadget. |
|
* @cdns: Pointer to controller context structure. |
|
*/ |
|
void cdns_drd_gadget_off(struct cdns *cdns) |
|
{ |
|
u32 val; |
|
|
|
/* |
|
* Driver should wait at least 10us after disabling Device |
|
* before turning-off Device (DEV_BUS_DROP). |
|
*/ |
|
usleep_range(20, 30); |
|
writel(OTGCMD_HOST_BUS_DROP | OTGCMD_DEV_BUS_DROP | |
|
OTGCMD_DEV_POWER_OFF | OTGCMD_HOST_POWER_OFF, |
|
&cdns->otg_regs->cmd); |
|
/* Waiting till DEV_IDLE state.*/ |
|
readl_poll_timeout_atomic(&cdns->otg_regs->state, val, |
|
!(val & OTGSTATE_DEV_STATE_MASK), |
|
1, 2000000); |
|
phy_set_mode(cdns->usb3_phy, PHY_MODE_INVALID); |
|
} |
|
EXPORT_SYMBOL_GPL(cdns_drd_gadget_off); |
|
|
|
/** |
|
* cdns_init_otg_mode - initialize drd controller |
|
* @cdns: Pointer to controller context structure |
|
* |
|
* Returns 0 on success otherwise negative errno |
|
*/ |
|
static int cdns_init_otg_mode(struct cdns *cdns) |
|
{ |
|
int ret; |
|
|
|
cdns_otg_disable_irq(cdns); |
|
/* clear all interrupts */ |
|
writel(~0, &cdns->otg_irq_regs->ivect); |
|
|
|
ret = cdns_set_mode(cdns, USB_DR_MODE_OTG); |
|
if (ret) |
|
return ret; |
|
|
|
cdns_otg_enable_irq(cdns); |
|
|
|
return 0; |
|
} |
|
|
|
/** |
|
* cdns_drd_update_mode - initialize mode of operation |
|
* @cdns: Pointer to controller context structure |
|
* |
|
* Returns 0 on success otherwise negative errno |
|
*/ |
|
int cdns_drd_update_mode(struct cdns *cdns) |
|
{ |
|
int ret; |
|
|
|
switch (cdns->dr_mode) { |
|
case USB_DR_MODE_PERIPHERAL: |
|
ret = cdns_set_mode(cdns, USB_DR_MODE_PERIPHERAL); |
|
break; |
|
case USB_DR_MODE_HOST: |
|
ret = cdns_set_mode(cdns, USB_DR_MODE_HOST); |
|
break; |
|
case USB_DR_MODE_OTG: |
|
ret = cdns_init_otg_mode(cdns); |
|
break; |
|
default: |
|
dev_err(cdns->dev, "Unsupported mode of operation %d\n", |
|
cdns->dr_mode); |
|
return -EINVAL; |
|
} |
|
|
|
return ret; |
|
} |
|
|
|
static irqreturn_t cdns_drd_thread_irq(int irq, void *data) |
|
{ |
|
struct cdns *cdns = data; |
|
|
|
cdns_hw_role_switch(cdns); |
|
|
|
return IRQ_HANDLED; |
|
} |
|
|
|
/** |
|
* cdns_drd_irq - interrupt handler for OTG events |
|
* |
|
* @irq: irq number for cdns core device |
|
* @data: structure of cdns |
|
* |
|
* Returns IRQ_HANDLED or IRQ_NONE |
|
*/ |
|
static irqreturn_t cdns_drd_irq(int irq, void *data) |
|
{ |
|
irqreturn_t ret = IRQ_NONE; |
|
struct cdns *cdns = data; |
|
u32 reg; |
|
|
|
if (cdns->dr_mode != USB_DR_MODE_OTG) |
|
return IRQ_NONE; |
|
|
|
if (cdns->in_lpm) |
|
return ret; |
|
|
|
reg = readl(&cdns->otg_irq_regs->ivect); |
|
|
|
if (!reg) |
|
return IRQ_NONE; |
|
|
|
if (reg & OTGIEN_ID_CHANGE_INT) { |
|
dev_dbg(cdns->dev, "OTG IRQ: new ID: %d\n", |
|
cdns_get_id(cdns)); |
|
|
|
ret = IRQ_WAKE_THREAD; |
|
} |
|
|
|
if (reg & (OTGIEN_VBUSVALID_RISE_INT | OTGIEN_VBUSVALID_FALL_INT)) { |
|
dev_dbg(cdns->dev, "OTG IRQ: new VBUS: %d\n", |
|
cdns_get_vbus(cdns)); |
|
|
|
ret = IRQ_WAKE_THREAD; |
|
} |
|
|
|
writel(~0, &cdns->otg_irq_regs->ivect); |
|
return ret; |
|
} |
|
|
|
int cdns_drd_init(struct cdns *cdns) |
|
{ |
|
void __iomem *regs; |
|
u32 state; |
|
int ret; |
|
|
|
regs = devm_ioremap_resource(cdns->dev, &cdns->otg_res); |
|
if (IS_ERR(regs)) |
|
return PTR_ERR(regs); |
|
|
|
/* Detection of DRD version. Controller has been released |
|
* in three versions. All are very similar and are software compatible, |
|
* but they have same changes in register maps. |
|
* The first register in oldest version is command register and it's |
|
* read only. Driver should read 0 from it. On the other hand, in v1 |
|
* and v2 the first register contains device ID number which is not |
|
* set to 0. Driver uses this fact to detect the proper version of |
|
* controller. |
|
*/ |
|
cdns->otg_v0_regs = regs; |
|
if (!readl(&cdns->otg_v0_regs->cmd)) { |
|
cdns->version = CDNS3_CONTROLLER_V0; |
|
cdns->otg_v1_regs = NULL; |
|
cdns->otg_cdnsp_regs = NULL; |
|
cdns->otg_regs = regs; |
|
cdns->otg_irq_regs = (struct cdns_otg_irq_regs __iomem *) |
|
&cdns->otg_v0_regs->ien; |
|
writel(1, &cdns->otg_v0_regs->simulate); |
|
dev_dbg(cdns->dev, "DRD version v0 (%08x)\n", |
|
readl(&cdns->otg_v0_regs->version)); |
|
} else { |
|
cdns->otg_v0_regs = NULL; |
|
cdns->otg_v1_regs = regs; |
|
cdns->otg_cdnsp_regs = regs; |
|
|
|
cdns->otg_regs = (void __iomem *)&cdns->otg_v1_regs->cmd; |
|
|
|
if (readl(&cdns->otg_cdnsp_regs->did) == OTG_CDNSP_DID) { |
|
cdns->otg_irq_regs = (struct cdns_otg_irq_regs __iomem *) |
|
&cdns->otg_cdnsp_regs->ien; |
|
cdns->version = CDNSP_CONTROLLER_V2; |
|
} else { |
|
cdns->otg_irq_regs = (struct cdns_otg_irq_regs __iomem *) |
|
&cdns->otg_v1_regs->ien; |
|
writel(1, &cdns->otg_v1_regs->simulate); |
|
cdns->version = CDNS3_CONTROLLER_V1; |
|
} |
|
|
|
dev_dbg(cdns->dev, "DRD version v1 (ID: %08x, rev: %08x)\n", |
|
readl(&cdns->otg_v1_regs->did), |
|
readl(&cdns->otg_v1_regs->rid)); |
|
} |
|
|
|
state = OTGSTS_STRAP(readl(&cdns->otg_regs->sts)); |
|
|
|
/* Update dr_mode according to STRAP configuration. */ |
|
cdns->dr_mode = USB_DR_MODE_OTG; |
|
|
|
if ((cdns->version == CDNSP_CONTROLLER_V2 && |
|
state == OTGSTS_CDNSP_STRAP_HOST) || |
|
(cdns->version != CDNSP_CONTROLLER_V2 && |
|
state == OTGSTS_STRAP_HOST)) { |
|
dev_dbg(cdns->dev, "Controller strapped to HOST\n"); |
|
cdns->dr_mode = USB_DR_MODE_HOST; |
|
} else if ((cdns->version == CDNSP_CONTROLLER_V2 && |
|
state == OTGSTS_CDNSP_STRAP_GADGET) || |
|
(cdns->version != CDNSP_CONTROLLER_V2 && |
|
state == OTGSTS_STRAP_GADGET)) { |
|
dev_dbg(cdns->dev, "Controller strapped to PERIPHERAL\n"); |
|
cdns->dr_mode = USB_DR_MODE_PERIPHERAL; |
|
} |
|
|
|
ret = devm_request_threaded_irq(cdns->dev, cdns->otg_irq, |
|
cdns_drd_irq, |
|
cdns_drd_thread_irq, |
|
IRQF_SHARED, |
|
dev_name(cdns->dev), cdns); |
|
if (ret) { |
|
dev_err(cdns->dev, "couldn't get otg_irq\n"); |
|
return ret; |
|
} |
|
|
|
state = readl(&cdns->otg_regs->sts); |
|
if (OTGSTS_OTG_NRDY(state)) { |
|
dev_err(cdns->dev, "Cadence USB3 OTG device not ready\n"); |
|
return -ENODEV; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
int cdns_drd_exit(struct cdns *cdns) |
|
{ |
|
cdns_otg_disable_irq(cdns); |
|
|
|
return 0; |
|
} |
|
|
|
|
|
/* Indicate the cdns3 core was power lost before */ |
|
bool cdns_power_is_lost(struct cdns *cdns) |
|
{ |
|
if (cdns->version == CDNS3_CONTROLLER_V1) { |
|
if (!(readl(&cdns->otg_v1_regs->simulate) & BIT(0))) |
|
return true; |
|
} else { |
|
if (!(readl(&cdns->otg_v0_regs->simulate) & BIT(0))) |
|
return true; |
|
} |
|
return false; |
|
} |
|
EXPORT_SYMBOL_GPL(cdns_power_is_lost);
|
|
|