static int __devinit ehci_msm2_probe(struct platform_device *pdev)
{
struct usb_hcd *hcd;
struct resource *res;
struct msm_hcd *mhcd;
const struct msm_usb_host_platform_data *pdata;
char pdev_name[PDEV_NAME_LEN];
int ret;
dev_dbg(&pdev->dev, "ehci_msm2 probe\n");
hcd = usb_create_hcd(&msm_hc2_driver, &pdev->dev,
dev_name(&pdev->dev));
if (!hcd) {
dev_err(&pdev->dev, "Unable to create HCD\n");
return -ENOMEM;
}
hcd->irq = platform_get_irq(pdev, 0);
if (hcd->irq < 0) {
dev_err(&pdev->dev, "Unable to get IRQ resource\n");
ret = hcd->irq;
goto put_hcd;
}
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
dev_err(&pdev->dev, "Unable to get memory resource\n");
ret = -ENODEV;
goto put_hcd;
}
hcd->rsrc_start = res->start;
hcd->rsrc_len = resource_size(res);
hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
if (!hcd->regs) {
dev_err(&pdev->dev, "ioremap failed\n");
ret = -ENOMEM;
goto put_hcd;
}
mhcd = hcd_to_mhcd(hcd);
mhcd->dev = &pdev->dev;
snprintf(pdev_name, PDEV_NAME_LEN, "%s.%d", pdev->name, pdev->id);
mhcd->xo_handle = msm_xo_get(MSM_XO_TCXO_D0, pdev_name);
if (IS_ERR(mhcd->xo_handle)) {
dev_err(&pdev->dev, "%s not able to get the handle "
"to vote for TCXO D0 buffer\n", __func__);
ret = PTR_ERR(mhcd->xo_handle);
goto unmap;
}
ret = msm_xo_mode_vote(mhcd->xo_handle, MSM_XO_MODE_ON);
if (ret) {
dev_err(&pdev->dev, "%s failed to vote for TCXO "
"D0 buffer%d\n", __func__, ret);
goto free_xo_handle;
}
ret = msm_ehci_init_clocks(mhcd, 1);
if (ret) {
dev_err(&pdev->dev, "unable to initialize clocks\n");
ret = -ENODEV;
goto devote_xo_handle;
}
ret = msm_ehci_init_vddcx(mhcd, 1);
if (ret) {
dev_err(&pdev->dev, "unable to initialize VDDCX\n");
ret = -ENODEV;
goto deinit_clocks;
}
ret = msm_ehci_config_vddcx(mhcd, 1);
if (ret) {
dev_err(&pdev->dev, "hsusb vddcx configuration failed\n");
goto deinit_vddcx;
}
ret = msm_ehci_ldo_init(mhcd, 1);
if (ret) {
dev_err(&pdev->dev, "hsusb vreg configuration failed\n");
goto deinit_vddcx;
}
ret = msm_ehci_ldo_enable(mhcd, 1);
if (ret) {
dev_err(&pdev->dev, "hsusb vreg enable failed\n");
goto deinit_ldo;
}
ret = msm_ehci_init_vbus(mhcd, 1);
if (ret) {
dev_err(&pdev->dev, "unable to get vbus\n");
goto disable_ldo;
}
ret = msm_hsusb_reset(mhcd);
if (ret) {
dev_err(&pdev->dev, "hsusb PHY initialization failed\n");
goto vbus_deinit;
}
ret = usb_add_hcd(hcd, hcd->irq, IRQF_SHARED);
if (ret) {
dev_err(&pdev->dev, "unable to register HCD\n");
goto vbus_deinit;
}
pdata = mhcd->dev->platform_data;
if (pdata && (!pdata->dock_connect_irq ||
!irq_read_line(pdata->dock_connect_irq)))
msm_ehci_vbus_power(mhcd, 1);
device_init_wakeup(&pdev->dev, 1);
wake_lock_init(&mhcd->wlock, WAKE_LOCK_SUSPEND, dev_name(&pdev->dev));
wake_lock(&mhcd->wlock);
INIT_WORK(&mhcd->phy_susp_fail_work, msm_ehci_phy_susp_fail_work);
/*
* This pdev->dev is assigned parent of root-hub by USB core,
* hence, runtime framework automatically calls this driver's
* runtime APIs based on root-hub's state.
*/
/* configure pmic_gpio_irq for D+ change */
if (pdata && pdata->pmic_gpio_dp_irq)
mhcd->pmic_gpio_dp_irq = pdata->pmic_gpio_dp_irq;
if (mhcd->pmic_gpio_dp_irq) {
ret = request_threaded_irq(mhcd->pmic_gpio_dp_irq, NULL,
msm_ehci_host_wakeup_irq,
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
"msm_ehci_host_wakeup", mhcd);
if (!ret) {
disable_irq_nosync(mhcd->pmic_gpio_dp_irq);
} else {
dev_err(&pdev->dev, "request_irq(%d) failed: %d\n",
mhcd->pmic_gpio_dp_irq, ret);
mhcd->pmic_gpio_dp_irq = 0;
}
}
pm_runtime_set_active(&pdev->dev);
pm_runtime_enable(&pdev->dev);
//ASUS_BSP+++ BennyCheng "implement ehci3 phy power collapse mode"
the_msm_hcd = mhcd;
usb_ehci_phy_power_control(0);
mutex_init(&mhcd->ehci_mutex);
//ASUS_BSP--- BennyCheng "implement ehci3 phy power collapse mode"
return 0;
vbus_deinit:
msm_ehci_init_vbus(mhcd, 0);
disable_ldo:
msm_ehci_ldo_enable(mhcd, 0);
deinit_ldo:
msm_ehci_ldo_init(mhcd, 0);
deinit_vddcx:
msm_ehci_init_vddcx(mhcd, 0);
deinit_clocks:
msm_ehci_init_clocks(mhcd, 0);
devote_xo_handle:
msm_xo_mode_vote(mhcd->xo_handle, MSM_XO_MODE_OFF);
free_xo_handle:
msm_xo_put(mhcd->xo_handle);
unmap:
iounmap(hcd->regs);
put_hcd:
usb_put_hcd(hcd);
return ret;
}
static int msm_ehci_suspend(struct msm_hcd *mhcd)
{
struct usb_hcd *hcd = mhcd_to_hcd(mhcd);
unsigned long timeout;
int ret;
u32 portsc;
if (atomic_read(&mhcd->in_lpm)) {
dev_dbg(mhcd->dev, "%s called in lpm\n", __func__);
return 0;
}
//ASUS_BSP+++ BennyCheng "implement ehci3 phy power collapse mode"
mutex_lock(&mhcd->ehci_mutex);
//ASUS_BSP--- BennyCheng "implement ehci3 phy power collapse mode"
disable_irq(hcd->irq);
/* Set the PHCD bit, only if it is not set by the controller.
* PHY may take some time or even fail to enter into low power
* mode (LPM). Hence poll for 500 msec and reset the PHY and link
* in failure case.
*/
portsc = readl_relaxed(USB_PORTSC);
if (!(portsc & PORTSC_PHCD)) {
writel_relaxed(portsc | PORTSC_PHCD,
USB_PORTSC);
timeout = jiffies + usecs_to_jiffies(PHY_SUSPEND_TIMEOUT_USEC);
while (!(readl_relaxed(USB_PORTSC) & PORTSC_PHCD)) {
if (time_after(jiffies, timeout)) {
dev_err(mhcd->dev, "Unable to suspend PHY\n");
schedule_work(&mhcd->phy_susp_fail_work);
return -ETIMEDOUT;
}
udelay(1);
}
}
/*
* PHY has capability to generate interrupt asynchronously in low
* power mode (LPM). This interrupt is level triggered. So USB IRQ
* line must be disabled till async interrupt enable bit is cleared
* in USBCMD register. Assert STP (ULPI interface STOP signal) to
* block data communication from PHY.
*/
writel_relaxed(readl_relaxed(USB_USBCMD) | ASYNC_INTR_CTRL |
ULPI_STP_CTRL, USB_USBCMD);
/*
* Ensure that hardware is put in low power mode before
* clocks are turned OFF and VDD is allowed to minimize.
*/
mb();
clk_disable_unprepare(mhcd->iface_clk);
clk_disable_unprepare(mhcd->core_clk);
/* usb phy does not require TCXO clock, hence vote for TCXO disable */
ret = msm_xo_mode_vote(mhcd->xo_handle, MSM_XO_MODE_OFF);
if (ret)
dev_err(mhcd->dev, "%s failed to devote for "
"TCXO D0 buffer%d\n", __func__, ret);
//ASUS_BSP+++ BennyCheng "implement ehci3 phy power collapse mode"
if (!test_bit(PHY_POWER, &mhcd->phy_power)) {
msm_ehci_ldo_enable(mhcd, 0);
mhcd->lpm_flags |= PHY_PWR_COLLAPSED;
}
//ASUS_BSP--- BennyCheng "implement ehci3 phy power collapse mode"
msm_ehci_config_vddcx(mhcd, 0);
atomic_set(&mhcd->in_lpm, 1);
enable_irq(hcd->irq);
if (mhcd->pmic_gpio_dp_irq) {
mhcd->pmic_gpio_dp_irq_enabled = 1;
enable_irq_wake(mhcd->pmic_gpio_dp_irq);
enable_irq(mhcd->pmic_gpio_dp_irq);
}
wake_unlock(&mhcd->wlock);
//ASUS_BSP+++ BennyCheng "implement ehci3 phy power collapse mode"
mutex_unlock(&mhcd->ehci_mutex);
//ASUS_BSP--- BennyCheng "implement ehci3 phy power collapse mode"
dev_info(mhcd->dev, "EHCI USB in low power mode\n");
return 0;
}
static int msm_ehci_resume(struct msm_hcd *mhcd)
{
struct usb_hcd *hcd = mhcd_to_hcd(mhcd);
unsigned long timeout;
unsigned temp;
int ret;
if (!atomic_read(&mhcd->in_lpm)) {
dev_dbg(mhcd->dev, "%s called in !in_lpm\n", __func__);
return 0;
}
//ASUS_BSP+++ BennyCheng "implement ehci3 phy power collapse mode"
mutex_lock(&mhcd->ehci_mutex);
//ASUS_BSP--- BennyCheng "implement ehci3 phy power collapse mode"
if (mhcd->pmic_gpio_dp_irq_enabled) {
disable_irq_wake(mhcd->pmic_gpio_dp_irq);
disable_irq_nosync(mhcd->pmic_gpio_dp_irq);
mhcd->pmic_gpio_dp_irq_enabled = 0;
}
wake_lock(&mhcd->wlock);
/* Vote for TCXO when waking up the phy */
ret = msm_xo_mode_vote(mhcd->xo_handle, MSM_XO_MODE_ON);
if (ret)
dev_err(mhcd->dev, "%s failed to vote for "
"TCXO D0 buffer%d\n", __func__, ret);
clk_prepare_enable(mhcd->core_clk);
clk_prepare_enable(mhcd->iface_clk);
msm_ehci_config_vddcx(mhcd, 1);
//ASUS_BSP+++ BennyCheng "implement ehci3 phy power collapse mode"
if (mhcd->lpm_flags & PHY_PWR_COLLAPSED) {
msm_ehci_ldo_enable(mhcd, 1);
mhcd->lpm_flags &= ~PHY_PWR_COLLAPSED;
}
//ASUS_BSP--- BennyCheng "implement ehci3 phy power collapse mode"
temp = readl_relaxed(USB_USBCMD);
temp &= ~ASYNC_INTR_CTRL;
temp &= ~ULPI_STP_CTRL;
writel_relaxed(temp, USB_USBCMD);
if (!(readl_relaxed(USB_PORTSC) & PORTSC_PHCD))
goto skip_phy_resume;
temp = readl_relaxed(USB_PORTSC) & ~PORTSC_PHCD;
writel_relaxed(temp, USB_PORTSC);
timeout = jiffies + usecs_to_jiffies(PHY_RESUME_TIMEOUT_USEC);
while ((readl_relaxed(USB_PORTSC) & PORTSC_PHCD) ||
!(readl_relaxed(USB_ULPI_VIEWPORT) & ULPI_SYNC_STATE)) {
if (time_after(jiffies, timeout)) {
/*This is a fatal error. Reset the link and PHY*/
dev_err(mhcd->dev, "Unable to resume USB. Resetting the h/w\n");
msm_hsusb_reset(mhcd);
break;
}
udelay(1);
}
skip_phy_resume:
usb_hcd_resume_root_hub(hcd);
atomic_set(&mhcd->in_lpm, 0);
if (mhcd->async_int) {
mhcd->async_int = false;
pm_runtime_put_noidle(mhcd->dev);
enable_irq(hcd->irq);
}
if (atomic_read(&mhcd->pm_usage_cnt)) {
atomic_set(&mhcd->pm_usage_cnt, 0);
pm_runtime_put_noidle(mhcd->dev);
}
//ASUS_BSP+++ BennyCheng "implement ehci3 phy power collapse mode"
mutex_unlock(&mhcd->ehci_mutex);
//ASUS_BSP--- BennyCheng "implement ehci3 phy power collapse mode"
dev_info(mhcd->dev, "EHCI USB exited from low power mode\n");
return 0;
}
static int msm_ehci_suspend(struct msm_hcd *mhcd)
{
struct usb_hcd *hcd = mhcd_to_hcd(mhcd);
unsigned long timeout;
u32 portsc;
const struct msm_usb_host_platform_data *pdata;
u32 func_ctrl;
if (atomic_read(&mhcd->in_lpm)) {
dev_dbg(mhcd->dev, "%s called in lpm\n", __func__);
return 0;
}
disable_irq(hcd->irq);
/* make sure we don't race against a remote wakeup */
if (test_bit(HCD_FLAG_WAKEUP_PENDING, &hcd->flags) ||
readl_relaxed(USB_PORTSC) & PORT_RESUME) {
dev_dbg(mhcd->dev, "wakeup pending, aborting suspend\n");
enable_irq(hcd->irq);
return -EBUSY;
}
pdata = mhcd->dev->platform_data;
if (pdata && pdata->is_uicc) {
/* put the controller in non-driving mode */
func_ctrl = msm_ulpi_read(mhcd, ULPI_FUNC_CTRL);
func_ctrl &= ~ULPI_FUNC_CTRL_OPMODE_MASK;
func_ctrl |= ULPI_FUNC_CTRL_OPMODE_NONDRIVING;
msm_ulpi_write(mhcd, func_ctrl, ULPI_FUNC_CTRL);
}
/* If port is enabled wait 5ms for PHCD to come up. Reset PHY
* and link if it fails to do so.
* If port is not enabled set the PHCD bit and poll for it to
* come up with in 500ms. Reset phy and link if it fails to do so.
*/
portsc = readl_relaxed(USB_PORTSC);
if (portsc & PORT_PE) {
usleep_range(5000, 5000);
if (!(readl_relaxed(USB_PORTSC) & PORTSC_PHCD)) {
dev_err(mhcd->dev,
"Unable to suspend PHY. portsc: %8x\n",
readl_relaxed(USB_PORTSC));
goto reset_phy_and_link;
}
} else {
writel_relaxed(portsc | PORTSC_PHCD, USB_PORTSC);
timeout = jiffies + msecs_to_jiffies(PHY_SUSP_TIMEOUT_MSEC);
while (!(readl_relaxed(USB_PORTSC) & PORTSC_PHCD)) {
if (time_after(jiffies, timeout)) {
dev_err(mhcd->dev,
"Unable to suspend PHY. portsc: %8x\n",
readl_relaxed(USB_PORTSC));
goto reset_phy_and_link;
}
usleep_range(10000, 10000);
}
}
/*
* PHY has capability to generate interrupt asynchronously in low
* power mode (LPM). This interrupt is level triggered. So USB IRQ
* line must be disabled till async interrupt enable bit is cleared
* in USBCMD register. Assert STP (ULPI interface STOP signal) to
* block data communication from PHY. Enable asynchronous interrupt
* only when wakeup gpio IRQ is not present.
*/
if (mhcd->wakeup_irq)
writel_relaxed(readl_relaxed(USB_USBCMD) | ULPI_STP_CTRL,
USB_USBCMD);
else
writel_relaxed(readl_relaxed(USB_USBCMD) | ASYNC_INTR_CTRL |
ULPI_STP_CTRL, USB_USBCMD);
/*
* Ensure that hardware is put in low power mode before
* clocks are turned OFF and VDD is allowed to minimize.
*/
mb();
clk_disable_unprepare(mhcd->iface_clk);
clk_disable_unprepare(mhcd->core_clk);
/* usb phy does not require TCXO clock, hence vote for TCXO disable */
if (mhcd->xo_clk)
clk_disable_unprepare(mhcd->xo_clk);
clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
msm_ehci_config_vddcx(mhcd, 0);
atomic_set(&mhcd->in_lpm, 1);
enable_irq(hcd->irq);
if (mhcd->wakeup_irq) {
mhcd->wakeup_irq_enabled = 1;
enable_irq_wake(mhcd->wakeup_irq);
enable_irq(mhcd->wakeup_irq);
}
if (mhcd->pmic_gpio_dp_irq) {
mhcd->pmic_gpio_dp_irq_enabled = 1;
enable_irq_wake(mhcd->pmic_gpio_dp_irq);
enable_irq(mhcd->pmic_gpio_dp_irq);
}
if (mhcd->async_irq) {
mhcd->async_irq_enabled = 1;
enable_irq_wake(mhcd->async_irq);
enable_irq(mhcd->async_irq);
}
pm_relax(mhcd->dev);
dev_info(mhcd->dev, "EHCI USB in low power mode\n");
return 0;
reset_phy_and_link:
schedule_work(&mhcd->phy_susp_fail_work);
return -ETIMEDOUT;
}
static int msm_ehci_resume(struct msm_hcd *mhcd)
{
struct usb_hcd *hcd = mhcd_to_hcd(mhcd);
unsigned long timeout;
unsigned temp;
unsigned long flags;
u32 func_ctrl;
const struct msm_usb_host_platform_data *pdata;
if (!atomic_read(&mhcd->in_lpm)) {
dev_dbg(mhcd->dev, "%s called in !in_lpm\n", __func__);
return 0;
}
/* Handles race with Async interrupt */
disable_irq(hcd->irq);
if (mhcd->pmic_gpio_dp_irq_enabled) {
disable_irq_wake(mhcd->pmic_gpio_dp_irq);
disable_irq_nosync(mhcd->pmic_gpio_dp_irq);
mhcd->pmic_gpio_dp_irq_enabled = 0;
}
spin_lock_irqsave(&mhcd->wakeup_lock, flags);
if (mhcd->async_irq_enabled) {
disable_irq_wake(mhcd->async_irq);
disable_irq_nosync(mhcd->async_irq);
mhcd->async_irq_enabled = 0;
}
if (mhcd->wakeup_irq) {
if (mhcd->wakeup_irq_enabled) {
disable_irq_wake(mhcd->wakeup_irq);
disable_irq_nosync(mhcd->wakeup_irq);
mhcd->wakeup_irq_enabled = 0;
}
}
spin_unlock_irqrestore(&mhcd->wakeup_lock, flags);
pm_stay_awake(mhcd->dev);
/* Vote for TCXO when waking up the phy */
if (mhcd->xo_clk)
clk_prepare_enable(mhcd->xo_clk);
clk_prepare_enable(mhcd->core_clk);
clk_prepare_enable(mhcd->iface_clk);
msm_ehci_config_vddcx(mhcd, 1);
temp = readl_relaxed(USB_USBCMD);
temp &= ~ASYNC_INTR_CTRL;
temp &= ~ULPI_STP_CTRL;
writel_relaxed(temp, USB_USBCMD);
if (!(readl_relaxed(USB_PORTSC) & PORTSC_PHCD))
goto skip_phy_resume;
temp = readl_relaxed(USB_PORTSC) & ~PORTSC_PHCD;
writel_relaxed(temp, USB_PORTSC);
timeout = jiffies + usecs_to_jiffies(PHY_RESUME_TIMEOUT_USEC);
while ((readl_relaxed(USB_PORTSC) & PORTSC_PHCD) ||
!(readl_relaxed(USB_ULPI_VIEWPORT) & ULPI_SYNC_STATE)) {
if (time_after(jiffies, timeout)) {
/*This is a fatal error. Reset the link and PHY*/
dev_err(mhcd->dev, "Unable to resume USB. Resetting the h/w\n");
msm_hsusb_reset(mhcd);
break;
}
udelay(1);
}
skip_phy_resume:
pdata = mhcd->dev->platform_data;
if (pdata && pdata->is_uicc) {
/* put the controller in normal mode */
func_ctrl = msm_ulpi_read(mhcd, ULPI_FUNC_CTRL);
func_ctrl &= ~ULPI_FUNC_CTRL_OPMODE_MASK;
func_ctrl |= ULPI_FUNC_CTRL_OPMODE_NORMAL;
msm_ulpi_write(mhcd, func_ctrl, ULPI_FUNC_CTRL);
}
set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
usb_hcd_resume_root_hub(hcd);
atomic_set(&mhcd->in_lpm, 0);
if (atomic_read(&mhcd->pm_usage_cnt)) {
atomic_set(&mhcd->pm_usage_cnt, 0);
pm_runtime_put_noidle(mhcd->dev);
}
enable_irq(hcd->irq);
dev_info(mhcd->dev, "EHCI USB exited from low power mode\n");
return 0;
}
static int ehci_msm2_probe(struct platform_device *pdev)
{
struct usb_hcd *hcd;
struct resource *res;
struct msm_hcd *mhcd;
struct pinctrl_state *set_state;
const struct msm_usb_host_platform_data *pdata;
char pdev_name[PDEV_NAME_LEN];
int ret;
dev_dbg(&pdev->dev, "ehci_msm2 probe\n");
/*
* Fail probe in case of uicc till userspace activates driver through
* sysfs entry.
*/
if (!uicc_card_present && pdev->dev.of_node && of_property_read_bool(
pdev->dev.of_node, "qcom,usb2-enable-uicc"))
return -ENODEV;
hcd = usb_create_hcd(&ehci_msm2_hc_driver, &pdev->dev,
dev_name(&pdev->dev));
if (!hcd) {
dev_err(&pdev->dev, "Unable to create HCD\n");
return -ENOMEM;
}
mhcd = hcd_to_mhcd(hcd);
mhcd->dev = &pdev->dev;
mhcd->xo_clk = clk_get(&pdev->dev, "xo");
if (IS_ERR(mhcd->xo_clk)) {
ret = PTR_ERR(mhcd->xo_clk);
mhcd->xo_clk = NULL;
if (ret == -EPROBE_DEFER)
goto put_hcd;
}
ret = msm_ehci_init_clocks(mhcd, 1);
if (ret)
goto xo_put;
if (pdev->dev.of_node) {
dev_dbg(&pdev->dev, "device tree enabled\n");
pdev->dev.platform_data = ehci_msm2_dt_to_pdata(pdev);
}
if (!pdev->dev.platform_data)
dev_dbg(&pdev->dev, "No platform data given\n");
pdata = pdev->dev.platform_data;
if (!pdev->dev.dma_mask)
pdev->dev.dma_mask = &ehci_msm_dma_mask;
if (!pdev->dev.coherent_dma_mask)
pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
hcd_to_bus(hcd)->skip_resume = true;
hcd->irq = platform_get_irq(pdev, 0);
if (hcd->irq < 0) {
dev_err(&pdev->dev, "Unable to get IRQ resource\n");
ret = hcd->irq;
goto deinit_clocks;
}
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
dev_err(&pdev->dev, "Unable to get memory resource\n");
ret = -ENODEV;
goto deinit_clocks;
}
hcd->rsrc_start = res->start;
hcd->rsrc_len = resource_size(res);
hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
if (!hcd->regs) {
dev_err(&pdev->dev, "ioremap failed\n");
ret = -ENOMEM;
goto deinit_clocks;
}
spin_lock_init(&mhcd->wakeup_lock);
mhcd->async_irq = platform_get_irq_byname(pdev, "async_irq");
if (mhcd->async_irq < 0) {
dev_dbg(&pdev->dev, "platform_get_irq for async_int failed\n");
mhcd->async_irq = 0;
} else {
ret = request_irq(mhcd->async_irq, msm_async_irq,
IRQF_TRIGGER_RISING, "msm_ehci_host", mhcd);
if (ret) {
dev_err(&pdev->dev, "request irq failed (ASYNC INT)\n");
goto unmap;
}
disable_irq(mhcd->async_irq);
}
snprintf(pdev_name, PDEV_NAME_LEN, "%s.%d", pdev->name, pdev->id);
if (mhcd->xo_clk)
ret = clk_prepare_enable(mhcd->xo_clk);
if (ret) {
dev_err(&pdev->dev, "%s failed to vote for TCXO %d\n",
__func__, ret);
goto free_xo_handle;
}
/* Get pinctrl if target uses pinctrl */
mhcd->hsusb_pinctrl = devm_pinctrl_get(&pdev->dev);
if (IS_ERR(mhcd->hsusb_pinctrl)) {
if (of_property_read_bool(pdev->dev.of_node, "pinctrl-names")) {
dev_err(&pdev->dev, "Error encountered while getting pinctrl");
ret = PTR_ERR(mhcd->hsusb_pinctrl);
goto devote_xo_handle;
}
pr_debug("Target does not use pinctrl\n");
mhcd->hsusb_pinctrl = NULL;
}
if (mhcd->hsusb_pinctrl) {
set_state = pinctrl_lookup_state(mhcd->hsusb_pinctrl,
"ehci_active");
if (IS_ERR(set_state)) {
pr_err("cannot get hsusb pinctrl active state\n");
ret = PTR_ERR(set_state);
goto devote_xo_handle;
}
ret = pinctrl_select_state(mhcd->hsusb_pinctrl, set_state);
if (ret) {
pr_err("cannot set hsusb pinctrl active state\n");
goto devote_xo_handle;
}
}
if (pdata && gpio_is_valid(pdata->resume_gpio)) {
mhcd->resume_gpio = pdata->resume_gpio;
ret = devm_gpio_request(&pdev->dev, mhcd->resume_gpio,
"hsusb_resume");
if (ret) {
dev_err(&pdev->dev,
"resume gpio(%d) request failed:%d\n",
mhcd->resume_gpio, ret);
mhcd->resume_gpio = -EINVAL;
} else {
/* to override ehci_bus_resume from ehci-hcd library */
ehci_bus_resume_func = ehci_msm2_hc_driver.bus_resume;
ehci_msm2_hc_driver.bus_resume =
msm_ehci_bus_resume_with_gpio;
}
}
if (pdata && gpio_is_valid(pdata->ext_hub_reset_gpio)) {
ret = devm_gpio_request(&pdev->dev, pdata->ext_hub_reset_gpio,
"hsusb_reset");
if (ret) {
dev_err(&pdev->dev,
"reset gpio(%d) request failed:%d\n",
pdata->ext_hub_reset_gpio, ret);
goto pinctrl_sleep;
} else {
/* reset external hub */
gpio_direction_output(pdata->ext_hub_reset_gpio, 0);
/*
* Hub reset should be asserted for minimum 5microsec
* before deasserting.
*/
usleep_range(5, 1000);
gpio_direction_output(pdata->ext_hub_reset_gpio, 1);
}
}
spin_lock_init(&mhcd->wakeup_lock);
ret = msm_ehci_init_vddcx(mhcd, 1);
if (ret) {
dev_err(&pdev->dev, "unable to initialize VDDCX\n");
ret = -ENODEV;
goto pinctrl_sleep;
}
ret = msm_ehci_config_vddcx(mhcd, 1);
if (ret) {
dev_err(&pdev->dev, "hsusb vddcx configuration failed\n");
goto deinit_vddcx;
}
ret = msm_ehci_ldo_init(mhcd, 1);
if (ret) {
dev_err(&pdev->dev, "hsusb vreg configuration failed\n");
goto deinit_vddcx;
}
ret = msm_ehci_ldo_enable(mhcd, 1);
if (ret) {
dev_err(&pdev->dev, "hsusb vreg enable failed\n");
goto deinit_ldo;
}
ret = msm_ehci_init_vbus(mhcd, 1);
if (ret)
goto disable_ldo;
hcd->phy = devm_usb_get_phy_by_phandle(&pdev->dev, "usb-phy", 0);
if (IS_ERR(hcd->phy)) {
if (PTR_ERR(hcd->phy) == -EPROBE_DEFER) {
dev_dbg(&pdev->dev, "usb-phy not probed yet\n");
ret = -EPROBE_DEFER;
goto vbus_deinit;
}
hcd->phy = NULL;
}
if (hcd->phy)
usb_phy_init(hcd->phy);
else if (pdata && pdata->use_sec_phy)
mhcd->usb_phy_ctrl_reg = USB_PHY_CTRL2;
else
mhcd->usb_phy_ctrl_reg = USB_PHY_CTRL;
ret = msm_hsusb_reset(mhcd);
if (ret) {
dev_err(&pdev->dev, "hsusb PHY initialization failed\n");
goto vbus_deinit;
}
ret = usb_add_hcd(hcd, hcd->irq, IRQF_SHARED);
if (ret) {
dev_err(&pdev->dev, "unable to register HCD\n");
goto vbus_deinit;
}
pdata = mhcd->dev->platform_data;
if (pdata && (!pdata->dock_connect_irq ||
!irq_read_line(pdata->dock_connect_irq)))
msm_ehci_vbus_power(mhcd, 1);
/* For peripherals directly conneted to downstream port of root hub
* and require to drive suspend and resume by controller driver instead
* of root hub.
*/
if (pdata)
mhcd->ehci.no_selective_suspend = pdata->no_selective_suspend;
mhcd->wakeup_irq = platform_get_irq_byname(pdev, "wakeup_irq");
if (mhcd->wakeup_irq > 0) {
dev_dbg(&pdev->dev, "wakeup irq:%d\n", mhcd->wakeup_irq);
irq_set_status_flags(mhcd->wakeup_irq, IRQ_NOAUTOEN);
ret = request_irq(mhcd->wakeup_irq, msm_hsusb_wakeup_irq,
IRQF_TRIGGER_HIGH,
"msm_hsusb_wakeup", mhcd);
if (ret) {
dev_err(&pdev->dev, "request_irq(%d) failed:%d\n",
mhcd->wakeup_irq, ret);
mhcd->wakeup_irq = 0;
}
} else {
mhcd->wakeup_irq = 0;
}
device_init_wakeup(&pdev->dev, 1);
wakeup_source_init(&mhcd->ws, dev_name(&pdev->dev));
pm_stay_awake(mhcd->dev);
INIT_WORK(&mhcd->phy_susp_fail_work, msm_ehci_phy_susp_fail_work);
/*
* This pdev->dev is assigned parent of root-hub by USB core,
* hence, runtime framework automatically calls this driver's
* runtime APIs based on root-hub's state.
*/
/* configure pmic_gpio_irq for D+ change */
if (pdata && pdata->pmic_gpio_dp_irq)
mhcd->pmic_gpio_dp_irq = pdata->pmic_gpio_dp_irq;
if (mhcd->pmic_gpio_dp_irq) {
ret = request_threaded_irq(mhcd->pmic_gpio_dp_irq, NULL,
msm_ehci_host_wakeup_irq,
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
"msm_ehci_host_wakeup", mhcd);
if (!ret) {
disable_irq_nosync(mhcd->pmic_gpio_dp_irq);
} else {
dev_err(&pdev->dev, "request_irq(%d) failed: %d\n",
mhcd->pmic_gpio_dp_irq, ret);
mhcd->pmic_gpio_dp_irq = 0;
}
}
pm_runtime_set_active(&pdev->dev);
pm_runtime_enable(&pdev->dev);
if (ehci_debugfs_init(mhcd) < 0)
dev_err(mhcd->dev, "%s: debugfs init failed\n", __func__);
return 0;
vbus_deinit:
msm_ehci_init_vbus(mhcd, 0);
disable_ldo:
msm_ehci_ldo_enable(mhcd, 0);
deinit_ldo:
msm_ehci_ldo_init(mhcd, 0);
deinit_vddcx:
msm_ehci_init_vddcx(mhcd, 0);
pinctrl_sleep:
if (mhcd->hsusb_pinctrl) {
set_state = pinctrl_lookup_state(mhcd->hsusb_pinctrl,
"ehci_sleep");
if (IS_ERR(set_state))
pr_err("cannot get hsusb pinctrl sleep state\n");
else
pinctrl_select_state(mhcd->hsusb_pinctrl, set_state);
}
devote_xo_handle:
if (mhcd->xo_clk)
clk_disable_unprepare(mhcd->xo_clk);
free_xo_handle:
if (mhcd->xo_clk) {
clk_put(mhcd->xo_clk);
mhcd->xo_clk = NULL;
}
if (mhcd->async_irq)
free_irq(mhcd->async_irq, mhcd);
unmap:
iounmap(hcd->regs);
deinit_clocks:
msm_ehci_init_clocks(mhcd, 0);
xo_put:
if (mhcd->xo_clk)
clk_put(mhcd->xo_clk);
put_hcd:
usb_put_hcd(hcd);
return ret;
}
static int msm_ehci_resume(struct msm_hcd *mhcd)
{
struct usb_hcd *hcd = mhcd_to_hcd(mhcd);
unsigned long timeout;
unsigned temp;
int ret;
if (!atomic_read(&mhcd->in_lpm)) {
dev_dbg(mhcd->dev, "%s called in !in_lpm\n", __func__);
return 0;
}
wake_lock(&mhcd->wlock);
/* Vote for TCXO when waking up the phy */
ret = msm_xo_mode_vote(mhcd->xo_handle, MSM_XO_MODE_ON);
if (ret)
dev_err(mhcd->dev, "%s failed to vote for "
"TCXO D0 buffer%d\n", __func__, ret);
clk_prepare_enable(mhcd->core_clk);
clk_prepare_enable(mhcd->iface_clk);
msm_ehci_config_vddcx(mhcd, 1);
temp = readl_relaxed(USB_USBCMD);
temp &= ~ASYNC_INTR_CTRL;
temp &= ~ULPI_STP_CTRL;
writel_relaxed(temp, USB_USBCMD);
if (!(readl_relaxed(USB_PORTSC) & PORTSC_PHCD))
goto skip_phy_resume;
temp = readl_relaxed(USB_PORTSC) & ~PORTSC_PHCD;
writel_relaxed(temp, USB_PORTSC);
timeout = jiffies + usecs_to_jiffies(PHY_RESUME_TIMEOUT_USEC);
while ((readl_relaxed(USB_PORTSC) & PORTSC_PHCD) ||
!(readl_relaxed(USB_ULPI_VIEWPORT) & ULPI_SYNC_STATE)) {
if (time_after(jiffies, timeout)) {
/*This is a fatal error. Reset the link and PHY*/
dev_err(mhcd->dev, "Unable to resume USB. Resetting the h/w\n");
msm_hsusb_reset(mhcd);
break;
}
udelay(1);
}
skip_phy_resume:
atomic_set(&mhcd->in_lpm, 0);
if (mhcd->async_int) {
mhcd->async_int = false;
pm_runtime_put_noidle(mhcd->dev);
enable_irq(hcd->irq);
}
dev_info(mhcd->dev, "EHCI USB exited from low power mode\n");
return 0;
}
static int msm_ehci_resume(struct msm_hcd *mhcd)
{
struct usb_hcd *hcd = mhcd_to_hcd(mhcd);
unsigned long timeout;
unsigned temp;
int ret;
unsigned long flags;
if (!atomic_read(&mhcd->in_lpm)) {
dev_dbg(mhcd->dev, "%s called in !in_lpm\n", __func__);
return 0;
}
spin_lock_irqsave(&mhcd->wakeup_lock, flags);
if (mhcd->wakeup_irq_enabled) {
disable_irq_wake(mhcd->wakeup_irq);
disable_irq_nosync(mhcd->wakeup_irq);
mhcd->wakeup_irq_enabled = 0;
}
spin_unlock_irqrestore(&mhcd->wakeup_lock, flags);
/* Handles race with Async interrupt */
disable_irq(hcd->irq);
if (mhcd->pmic_gpio_dp_irq_enabled) {
disable_irq_wake(mhcd->pmic_gpio_dp_irq);
disable_irq_nosync(mhcd->pmic_gpio_dp_irq);
mhcd->pmic_gpio_dp_irq_enabled = 0;
}
spin_lock_irqsave(&mhcd->wakeup_lock, flags);
if (mhcd->async_irq_enabled) {
disable_irq_wake(mhcd->async_irq);
disable_irq_nosync(mhcd->async_irq);
mhcd->async_irq_enabled = 0;
}
spin_unlock_irqrestore(&mhcd->wakeup_lock, flags);
wake_lock(&mhcd->wlock);
/* Vote for TCXO when waking up the phy */
if (!IS_ERR(mhcd->xo_clk)) {
clk_prepare_enable(mhcd->xo_clk);
} else {
ret = msm_xo_mode_vote(mhcd->xo_handle, MSM_XO_MODE_ON);
if (ret)
dev_err(mhcd->dev, "%s failed to vote for TCXO D0 %d\n",
__func__, ret);
}
clk_prepare_enable(mhcd->core_clk);
clk_prepare_enable(mhcd->iface_clk);
msm_ehci_config_vddcx(mhcd, 1);
if (mhcd->flags & ALLOW_EHCI_RETENTION) {
u32 phy_ctrl_val;
phy_ctrl_val = readl_relaxed(USB_PHY_CTRL);
phy_ctrl_val |= PHY_RETEN;
writel_relaxed(phy_ctrl_val, USB_PHY_CTRL);
}
temp = readl_relaxed(USB_USBCMD);
temp &= ~ASYNC_INTR_CTRL;
temp &= ~ULPI_STP_CTRL;
writel_relaxed(temp, USB_USBCMD);
if (!(readl_relaxed(USB_PORTSC) & PORTSC_PHCD))
goto skip_phy_resume;
temp = readl_relaxed(USB_PORTSC) & ~(PORTSC_PHCD | PORT_RWC_BITS);
writel_relaxed(temp, USB_PORTSC);
timeout = jiffies + usecs_to_jiffies(PHY_RESUME_TIMEOUT_USEC);
while ((readl_relaxed(USB_PORTSC) & PORTSC_PHCD) ||
!(readl_relaxed(USB_ULPI_VIEWPORT) & ULPI_SYNC_STATE)) {
if (time_after(jiffies, timeout)) {
/*This is a fatal error. Reset the link and PHY*/
dev_err(mhcd->dev, "Unable to resume USB. Resetting the h/w\n");
msm_hsusb_reset(mhcd);
break;
}
udelay(1);
}
skip_phy_resume:
usb_hcd_resume_root_hub(hcd);
atomic_set(&mhcd->in_lpm, 0);
if (mhcd->async_int) {
mhcd->async_int = false;
pm_runtime_put_noidle(mhcd->dev);
enable_irq(hcd->irq);
}
if (atomic_read(&mhcd->pm_usage_cnt)) {
atomic_set(&mhcd->pm_usage_cnt, 0);
pm_runtime_put_noidle(mhcd->dev);
}
enable_irq(hcd->irq);
dev_info(mhcd->dev, "EHCI USB exited from low power mode\n");
return 0;
}
static int msm_ehci_suspend(struct msm_hcd *mhcd)
{
struct usb_hcd *hcd = mhcd_to_hcd(mhcd);
unsigned long timeout;
int ret;
u32 portsc;
if (atomic_read(&mhcd->in_lpm)) {
dev_dbg(mhcd->dev, "%s called in lpm\n", __func__);
return 0;
}
disable_irq(hcd->irq);
/* make sure we don't race against a remote wakeup */
if (test_bit(HCD_FLAG_WAKEUP_PENDING, &hcd->flags) ||
readl_relaxed(USB_PORTSC) & PORT_RESUME) {
dev_dbg(mhcd->dev, "wakeup pending, aborting suspend\n");
enable_irq(hcd->irq);
return -EBUSY;
}
/* If port is enabled wait 5ms for PHCD to come up. Reset PHY
* and link if it fails to do so.
* If port is not enabled set the PHCD bit and poll for it to
* come up with in 500ms. Reset phy and link if it fails to do so.
*/
portsc = readl_relaxed(USB_PORTSC);
if (portsc & PORT_PE) {
usleep_range(5000, 5000);
if (!(readl_relaxed(USB_PORTSC) & PORTSC_PHCD)) {
dev_err(mhcd->dev,
"Unable to suspend PHY. portsc: %8x\n",
readl_relaxed(USB_PORTSC));
goto reset_phy_and_link;
}
} else {
writel_relaxed(portsc | PORTSC_PHCD, USB_PORTSC);
timeout = jiffies + msecs_to_jiffies(PHY_SUSP_TIMEOUT_MSEC);
while (!(readl_relaxed(USB_PORTSC) & PORTSC_PHCD)) {
if (time_after(jiffies, timeout)) {
dev_err(mhcd->dev,
"Unable to suspend PHY. portsc: %8x\n",
readl_relaxed(USB_PORTSC));
goto reset_phy_and_link;
}
usleep_range(10000, 10000);
}
}
/*
* PHY has capability to generate interrupt asynchronously in low
* power mode (LPM). This interrupt is level triggered. So USB IRQ
* line must be disabled till async interrupt enable bit is cleared
* in USBCMD register. Assert STP (ULPI interface STOP signal) to
* block data communication from PHY. Enable asynchronous interrupt
* only when wakeup gpio IRQ is not present.
*/
//if (mhcd->wakeup_irq)
// writel_relaxed(readl_relaxed(USB_USBCMD) | ULPI_STP_CTRL,
// USB_USBCMD);
//else
writel_relaxed(readl_relaxed(USB_USBCMD) | ASYNC_INTR_CTRL |
ULPI_STP_CTRL, USB_USBCMD);
/* Enable retention mode */
if (mhcd->flags & ALLOW_EHCI_RETENTION) {
u32 phy_ctrl_val;
phy_ctrl_val = readl_relaxed(USB_PHY_CTRL);
phy_ctrl_val &= ~PHY_RETEN;
writel_relaxed(phy_ctrl_val, USB_PHY_CTRL);
}
/*
* Ensure that hardware is put in low power mode before
* clocks are turned OFF and VDD is allowed to minimize.
*/
mb();
clk_disable_unprepare(mhcd->iface_clk);
clk_disable_unprepare(mhcd->core_clk);
/* usb phy does not require TCXO clock, hence vote for TCXO disable */
if (!IS_ERR(mhcd->xo_clk)) {
clk_disable_unprepare(mhcd->xo_clk);
} else {
ret = msm_xo_mode_vote(mhcd->xo_handle, MSM_XO_MODE_OFF);
if (ret)
dev_err(mhcd->dev, "%s failed to devote for TCXO %d\n",
__func__, ret);
}
msm_ehci_config_vddcx(mhcd, 0);
atomic_set(&mhcd->in_lpm, 1);
enable_irq(hcd->irq);
if (mhcd->wakeup_irq) {
mhcd->wakeup_irq_enabled = 1;
enable_irq_wake(mhcd->wakeup_irq);
enable_irq(mhcd->wakeup_irq);
}
if (mhcd->pmic_gpio_dp_irq) {
mhcd->pmic_gpio_dp_irq_enabled = 1;
enable_irq_wake(mhcd->pmic_gpio_dp_irq);
enable_irq(mhcd->pmic_gpio_dp_irq);
}
if (mhcd->async_irq) {
mhcd->async_irq_enabled = 1;
enable_irq_wake(mhcd->async_irq);
enable_irq(mhcd->async_irq);
}
wake_unlock(&mhcd->wlock);
dev_info(mhcd->dev, "EHCI USB in low power mode\n");
return 0;
reset_phy_and_link:
schedule_work(&mhcd->phy_susp_fail_work);
return -ETIMEDOUT;
}
static int __devinit ehci_msm2_probe(struct platform_device *pdev)
{
struct usb_hcd *hcd;
struct resource *res;
struct msm_hcd *mhcd;
const struct msm_usb_host_platform_data *pdata;
char pdev_name[PDEV_NAME_LEN];
int ret;
int res_gpio;
dev_info(&pdev->dev, "ehci_msm2 probe\n");
/* If there is no WAN device present, we don't need to start the EHCI stack */
if(!wan_present())
return -ENODEV;
if (pdev->dev.of_node) {
dev_dbg(&pdev->dev, "device tree enabled\n");
pdev->dev.platform_data = ehci_msm2_dt_to_pdata(pdev);
}
if (!pdev->dev.platform_data)
dev_dbg(&pdev->dev, "No platform data given\n");
if (!pdev->dev.dma_mask)
pdev->dev.dma_mask = &ehci_msm_dma_mask;
if (!pdev->dev.coherent_dma_mask)
pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
hcd = usb_create_hcd(&msm_hc2_driver, &pdev->dev,
dev_name(&pdev->dev));
if (!hcd) {
dev_err(&pdev->dev, "Unable to create HCD\n");
return -ENOMEM;
}
hcd_to_bus(hcd)->skip_resume = true;
hcd->irq = platform_get_irq(pdev, 0);
if (hcd->irq < 0) {
dev_err(&pdev->dev, "Unable to get IRQ resource\n");
ret = hcd->irq;
goto put_hcd;
}
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
dev_err(&pdev->dev, "Unable to get memory resource\n");
ret = -ENODEV;
goto put_hcd;
}
hcd->rsrc_start = res->start;
hcd->rsrc_len = resource_size(res);
hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
if (!hcd->regs) {
dev_err(&pdev->dev, "ioremap failed\n");
ret = -ENOMEM;
goto put_hcd;
}
mhcd = hcd_to_mhcd(hcd);
mhcd->dev = &pdev->dev;
spin_lock_init(&mhcd->wakeup_lock);
mhcd->async_irq = platform_get_irq_byname(pdev, "async_irq");
if (mhcd->async_irq < 0) {
dev_dbg(&pdev->dev, "platform_get_irq for async_int failed\n");
mhcd->async_irq = 0;
} else {
ret = request_irq(mhcd->async_irq, msm_async_irq,
IRQF_TRIGGER_RISING, "msm_ehci_host", mhcd);
if (ret) {
dev_err(&pdev->dev, "request irq failed (ASYNC INT)\n");
goto unmap;
}
disable_irq(mhcd->async_irq);
}
snprintf(pdev_name, PDEV_NAME_LEN, "%s.%d", pdev->name, pdev->id);
mhcd->xo_clk = clk_get(&pdev->dev, "xo");
if (!IS_ERR(mhcd->xo_clk)) {
ret = clk_prepare_enable(mhcd->xo_clk);
} else {
mhcd->xo_handle = msm_xo_get(MSM_XO_TCXO_D0, pdev_name);
if (IS_ERR(mhcd->xo_handle)) {
dev_err(&pdev->dev, "%s fail to get handle for X0 D0\n",
__func__);
ret = PTR_ERR(mhcd->xo_handle);
goto free_async_irq;
} else {
ret = msm_xo_mode_vote(mhcd->xo_handle, MSM_XO_MODE_ON);
}
}
if (ret) {
dev_err(&pdev->dev, "%s failed to vote for TCXO %d\n",
__func__, ret);
goto free_xo_handle;
}
if (pdev->dev.of_node) {
res_gpio = of_get_named_gpio(pdev->dev.of_node, "usb2,resume-gpio", 0);
if (res_gpio < 0){
res_gpio = 0;
goto devote_xo_handle;
}
mhcd->resume_gpio = res_gpio;
gpio_request(mhcd->resume_gpio, "USB2_RESUME");
} else {
res = platform_get_resource_byname(pdev, IORESOURCE_IO, "resume_gpio");
if (res) {
dev_dbg(&pdev->dev, "resume_gpio:%d\n", res->start);
mhcd->resume_gpio = res->start;
}
}
if(pdev->dev.of_node){
res_gpio = of_get_named_gpio(pdev->dev.of_node, "usb2,wakeup-gpio", 0);
if (res_gpio < 0){
res_gpio = 0;
goto devote_xo_handle;
}
mhcd->wakeup_gpio = res_gpio;
} else {
res = platform_get_resource_byname(pdev, IORESOURCE_IO, "wakeup_gpio");
if (res) {
dev_dbg(&pdev->dev, "wakeup gpio:%d\n", res->start);
mhcd->wakeup_gpio = res->start;
}
}
if (pdev->dev.of_node)
mhcd->wakeup_irq = gpio_to_irq(mhcd->wakeup_gpio);
else
mhcd->wakeup_irq = platform_get_irq_byname(pdev, "wakeup_irq");
if (mhcd->wakeup_irq > 0) {
dev_dbg(&pdev->dev, "wakeup irq:%d\n", res->start);
irq_set_status_flags(mhcd->wakeup_irq, IRQ_NOAUTOEN);
ret = request_irq(mhcd->wakeup_irq, msm_hsusb_wakeup_irq,
IRQF_TRIGGER_HIGH,
"msm_hsusb_wakeup", mhcd);
if (ret) {
dev_err(&pdev->dev, "request_irq(%d) failed:%d\n",
mhcd->wakeup_irq, ret);
mhcd->wakeup_irq = 0;
}
} else {
mhcd->wakeup_irq = 0;
}
spin_lock_init(&mhcd->wakeup_lock);
ret = msm_ehci_init_clocks(mhcd, 1);
if (ret) {
dev_err(&pdev->dev, "unable to initialize clocks\n");
ret = -ENODEV;
goto devote_xo_handle;
}
ret = msm_ehci_init_vddcx(mhcd, 1);
if (ret) {
dev_err(&pdev->dev, "unable to initialize VDDCX\n");
ret = -ENODEV;
goto deinit_clocks;
}
ret = msm_ehci_config_vddcx(mhcd, 1);
if (ret) {
dev_err(&pdev->dev, "hsusb vddcx configuration failed\n");
goto deinit_vddcx;
}
ret = msm_ehci_ldo_init(mhcd, 1);
if (ret) {
dev_err(&pdev->dev, "hsusb vreg configuration failed\n");
goto deinit_vddcx;
}
ret = msm_ehci_ldo_enable(mhcd, 1);
if (ret) {
dev_err(&pdev->dev, "hsusb vreg enable failed\n");
goto deinit_ldo;
}
ret = msm_ehci_init_vbus(mhcd, 1);
if (ret) {
dev_err(&pdev->dev, "unable to get vbus\n");
goto disable_ldo;
}
pdata = mhcd->dev->platform_data;
if (pdata && pdata->use_sec_phy)
mhcd->usb_phy_ctrl_reg = USB_PHY_CTRL2;
else
mhcd->usb_phy_ctrl_reg = USB_PHY_CTRL;
ret = msm_hsusb_reset(mhcd);
if (ret) {
dev_err(&pdev->dev, "hsusb PHY initialization failed\n");
goto vbus_deinit;
}
if( pdata && pdata->phy_sof_workaround) {
/* defer bus suspend until RH suspend */
mhcd->ehci.susp_sof_bug = 1;
mhcd->ehci.resume_sof_bug = 1;
}
ret = usb_add_hcd(hcd, hcd->irq, IRQF_SHARED);
if (ret) {
dev_err(&pdev->dev, "unable to register HCD\n");
goto vbus_deinit;
}
if (pdata && (!pdata->dock_connect_irq ||
!irq_read_line(pdata->dock_connect_irq)))
msm_ehci_vbus_power(mhcd, 1);
device_init_wakeup(&pdev->dev, 1);
wake_lock_init(&mhcd->wlock, WAKE_LOCK_SUSPEND, dev_name(&pdev->dev));
wake_lock(&mhcd->wlock);
INIT_WORK(&mhcd->phy_susp_fail_work, msm_ehci_phy_susp_fail_work);
/*
* This pdev->dev is assigned parent of root-hub by USB core,
* hence, runtime framework automatically calls this driver's
* runtime APIs based on root-hub's state.
*/
/* configure pmic_gpio_irq for D+ change */
if (pdata && pdata->pmic_gpio_dp_irq)
mhcd->pmic_gpio_dp_irq = pdata->pmic_gpio_dp_irq;
if (mhcd->pmic_gpio_dp_irq) {
ret = request_threaded_irq(mhcd->pmic_gpio_dp_irq, NULL,
msm_ehci_host_wakeup_irq,
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
"msm_ehci_host_wakeup", mhcd);
if (!ret) {
disable_irq_nosync(mhcd->pmic_gpio_dp_irq);
} else {
dev_err(&pdev->dev, "request_irq(%d) failed: %d\n",
mhcd->pmic_gpio_dp_irq, ret);
mhcd->pmic_gpio_dp_irq = 0;
}
}
if (pdata && pdata->pd_rework_installed)
mhcd->flags |= ALLOW_EHCI_RETENTION;
pm_runtime_set_active(&pdev->dev);
pm_runtime_enable(&pdev->dev);
return 0;
vbus_deinit:
msm_ehci_init_vbus(mhcd, 0);
disable_ldo:
msm_ehci_ldo_enable(mhcd, 0);
deinit_ldo:
msm_ehci_ldo_init(mhcd, 0);
deinit_vddcx:
msm_ehci_init_vddcx(mhcd, 0);
deinit_clocks:
msm_ehci_init_clocks(mhcd, 0);
devote_xo_handle:
if (!IS_ERR(mhcd->xo_clk))
clk_disable_unprepare(mhcd->xo_clk);
else
msm_xo_mode_vote(mhcd->xo_handle, MSM_XO_MODE_OFF);
if(mhcd->wakeup_irq)
free_irq(mhcd->wakeup_irq, mhcd);
if(mhcd->resume_gpio)
gpio_free(mhcd->resume_gpio);
free_xo_handle:
if (!IS_ERR(mhcd->xo_clk))
clk_put(mhcd->xo_clk);
else
msm_xo_put(mhcd->xo_handle);
free_async_irq:
if (mhcd->async_irq)
free_irq(mhcd->async_irq, mhcd);
unmap:
iounmap(hcd->regs);
put_hcd:
usb_put_hcd(hcd);
return ret;
}
