Commit a4faa54e authored by Stephen Warren's avatar Stephen Warren Committed by Greg Kroah-Hartman

USB: EHCI: tegra: remove all power management

The PM routines in ehci-tegra.c use APIs such as ehci_reset(),
ehci_halt(), and ehci_tdi_reset() that would need to be exported to
convert ehci-tegra.c into a separate module from ehci-hcd.c. However,
we'd prefer not to export them.

Instead, simply remove all power management functionality. Runtime PM
was disabled since it didn't work correctly, and system suspend isn't
yet supported in a meaningful way. So, this change doesn't lose any
functionality.

Hopefully the power management logic can be reimplemented in a cleaner
way in the future.
Signed-off-by: default avatarStephen Warren <swarren@nvidia.com>
Acked-by: default avatarArnd Bergmann <arnd@arndb.de>
Acked-by: default avatarAlan Stern <stern@rowland.harvard.edu>
Tested-by: default avatarThierry Reding <thierry.reding@gmail.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent 2f3a6b86
...@@ -46,30 +46,11 @@ struct tegra_ehci_hcd { ...@@ -46,30 +46,11 @@ struct tegra_ehci_hcd {
struct tegra_usb_phy *phy; struct tegra_usb_phy *phy;
struct clk *clk; struct clk *clk;
struct usb_phy *transceiver; struct usb_phy *transceiver;
int host_resumed;
int port_resuming; int port_resuming;
bool needs_double_reset; bool needs_double_reset;
enum tegra_usb_phy_port_speed port_speed; enum tegra_usb_phy_port_speed port_speed;
}; };
static void tegra_ehci_power_up(struct usb_hcd *hcd)
{
struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
clk_prepare_enable(tegra->clk);
usb_phy_set_suspend(hcd->phy, 0);
tegra->host_resumed = 1;
}
static void tegra_ehci_power_down(struct usb_hcd *hcd)
{
struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
tegra->host_resumed = 0;
usb_phy_set_suspend(hcd->phy, 1);
clk_disable_unprepare(tegra->clk);
}
static int tegra_ehci_internal_port_reset( static int tegra_ehci_internal_port_reset(
struct ehci_hcd *ehci, struct ehci_hcd *ehci,
u32 __iomem *portsc_reg u32 __iomem *portsc_reg
...@@ -248,39 +229,6 @@ static int tegra_ehci_hub_control( ...@@ -248,39 +229,6 @@ static int tegra_ehci_hub_control(
return retval; return retval;
} }
static void tegra_ehci_restart(struct usb_hcd *hcd)
{
struct ehci_hcd *ehci = hcd_to_ehci(hcd);
ehci_reset(ehci);
/* setup the frame list and Async q heads */
ehci_writel(ehci, ehci->periodic_dma, &ehci->regs->frame_list);
ehci_writel(ehci, (u32)ehci->async->qh_dma, &ehci->regs->async_next);
/* setup the command register and set the controller in RUN mode */
ehci->command &= ~(CMD_LRESET|CMD_IAAD|CMD_PSE|CMD_ASE|CMD_RESET);
ehci->command |= CMD_RUN;
ehci_writel(ehci, ehci->command, &ehci->regs->command);
down_write(&ehci_cf_port_reset_rwsem);
ehci_writel(ehci, FLAG_CF, &ehci->regs->configured_flag);
/* flush posted writes */
ehci_readl(ehci, &ehci->regs->command);
up_write(&ehci_cf_port_reset_rwsem);
}
static void tegra_ehci_shutdown(struct usb_hcd *hcd)
{
struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
/* ehci_shutdown touches the USB controller registers, make sure
* controller has clocks to it */
if (!tegra->host_resumed)
tegra_ehci_power_up(hcd);
ehci_shutdown(hcd);
}
static int tegra_ehci_setup(struct usb_hcd *hcd) static int tegra_ehci_setup(struct usb_hcd *hcd)
{ {
struct ehci_hcd *ehci = hcd_to_ehci(hcd); struct ehci_hcd *ehci = hcd_to_ehci(hcd);
...@@ -395,7 +343,7 @@ static const struct hc_driver tegra_ehci_hc_driver = { ...@@ -395,7 +343,7 @@ static const struct hc_driver tegra_ehci_hc_driver = {
/* modified ehci functions for tegra */ /* modified ehci functions for tegra */
.reset = tegra_ehci_setup, .reset = tegra_ehci_setup,
.shutdown = tegra_ehci_shutdown, .shutdown = ehci_shutdown,
.map_urb_for_dma = tegra_ehci_map_urb_for_dma, .map_urb_for_dma = tegra_ehci_map_urb_for_dma,
.unmap_urb_for_dma = tegra_ehci_unmap_urb_for_dma, .unmap_urb_for_dma = tegra_ehci_unmap_urb_for_dma,
.hub_control = tegra_ehci_hub_control, .hub_control = tegra_ehci_hub_control,
...@@ -432,182 +380,6 @@ static int setup_vbus_gpio(struct platform_device *pdev, ...@@ -432,182 +380,6 @@ static int setup_vbus_gpio(struct platform_device *pdev,
return err; return err;
} }
#ifdef CONFIG_PM
static int controller_suspend(struct device *dev)
{
struct tegra_ehci_hcd *tegra =
platform_get_drvdata(to_platform_device(dev));
struct ehci_hcd *ehci = tegra->ehci;
struct usb_hcd *hcd = ehci_to_hcd(ehci);
struct ehci_regs __iomem *hw = ehci->regs;
unsigned long flags;
if (time_before(jiffies, ehci->next_statechange))
msleep(10);
ehci_halt(ehci);
spin_lock_irqsave(&ehci->lock, flags);
tegra->port_speed = (readl(&hw->port_status[0]) >> 26) & 0x3;
clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
spin_unlock_irqrestore(&ehci->lock, flags);
tegra_ehci_power_down(hcd);
return 0;
}
static int controller_resume(struct device *dev)
{
struct tegra_ehci_hcd *tegra =
platform_get_drvdata(to_platform_device(dev));
struct ehci_hcd *ehci = tegra->ehci;
struct usb_hcd *hcd = ehci_to_hcd(ehci);
struct ehci_regs __iomem *hw = ehci->regs;
unsigned long val;
set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
tegra_ehci_power_up(hcd);
if (tegra->port_speed > TEGRA_USB_PHY_PORT_SPEED_HIGH) {
/* Wait for the phy to detect new devices
* before we restart the controller */
msleep(10);
goto restart;
}
/* Force the phy to keep data lines in suspend state */
tegra_ehci_phy_restore_start(hcd->phy, tegra->port_speed);
/* Enable host mode */
tdi_reset(ehci);
/* Enable Port Power */
val = readl(&hw->port_status[0]);
val |= PORT_POWER;
writel(val, &hw->port_status[0]);
udelay(10);
/* Check if the phy resume from LP0. When the phy resume from LP0
* USB register will be reset. */
if (!readl(&hw->async_next)) {
/* Program the field PTC based on the saved speed mode */
val = readl(&hw->port_status[0]);
val &= ~PORT_TEST(~0);
if (tegra->port_speed == TEGRA_USB_PHY_PORT_SPEED_HIGH)
val |= PORT_TEST_FORCE;
else if (tegra->port_speed == TEGRA_USB_PHY_PORT_SPEED_FULL)
val |= PORT_TEST(6);
else if (tegra->port_speed == TEGRA_USB_PHY_PORT_SPEED_LOW)
val |= PORT_TEST(7);
writel(val, &hw->port_status[0]);
udelay(10);
/* Disable test mode by setting PTC field to NORMAL_OP */
val = readl(&hw->port_status[0]);
val &= ~PORT_TEST(~0);
writel(val, &hw->port_status[0]);
udelay(10);
}
/* Poll until CCS is enabled */
if (ehci_handshake(ehci, &hw->port_status[0], PORT_CONNECT,
PORT_CONNECT, 2000)) {
pr_err("%s: timeout waiting for PORT_CONNECT\n", __func__);
goto restart;
}
/* Poll until PE is enabled */
if (ehci_handshake(ehci, &hw->port_status[0], PORT_PE,
PORT_PE, 2000)) {
pr_err("%s: timeout waiting for USB_PORTSC1_PE\n", __func__);
goto restart;
}
/* Clear the PCI status, to avoid an interrupt taken upon resume */
val = readl(&hw->status);
val |= STS_PCD;
writel(val, &hw->status);
/* Put controller in suspend mode by writing 1 to SUSP bit of PORTSC */
val = readl(&hw->port_status[0]);
if ((val & PORT_POWER) && (val & PORT_PE)) {
val |= PORT_SUSPEND;
writel(val, &hw->port_status[0]);
/* Wait until port suspend completes */
if (ehci_handshake(ehci, &hw->port_status[0], PORT_SUSPEND,
PORT_SUSPEND, 1000)) {
pr_err("%s: timeout waiting for PORT_SUSPEND\n",
__func__);
goto restart;
}
}
tegra_ehci_phy_restore_end(hcd->phy);
goto done;
restart:
if (tegra->port_speed <= TEGRA_USB_PHY_PORT_SPEED_HIGH)
tegra_ehci_phy_restore_end(hcd->phy);
tegra_ehci_restart(hcd);
done:
tegra_usb_phy_preresume(hcd->phy);
tegra->port_resuming = 1;
return 0;
}
static int tegra_ehci_suspend(struct device *dev)
{
struct tegra_ehci_hcd *tegra =
platform_get_drvdata(to_platform_device(dev));
struct usb_hcd *hcd = ehci_to_hcd(tegra->ehci);
int rc = 0;
/*
* When system sleep is supported and USB controller wakeup is
* implemented: If the controller is runtime-suspended and the
* wakeup setting needs to be changed, call pm_runtime_resume().
*/
if (HCD_HW_ACCESSIBLE(hcd))
rc = controller_suspend(dev);
return rc;
}
static int tegra_ehci_resume(struct device *dev)
{
int rc;
rc = controller_resume(dev);
if (rc == 0) {
pm_runtime_disable(dev);
pm_runtime_set_active(dev);
pm_runtime_enable(dev);
}
return rc;
}
static int tegra_ehci_runtime_suspend(struct device *dev)
{
return controller_suspend(dev);
}
static int tegra_ehci_runtime_resume(struct device *dev)
{
return controller_resume(dev);
}
static const struct dev_pm_ops tegra_ehci_pm_ops = {
.suspend = tegra_ehci_suspend,
.resume = tegra_ehci_resume,
.runtime_suspend = tegra_ehci_runtime_suspend,
.runtime_resume = tegra_ehci_runtime_resume,
};
#endif
/* Bits of PORTSC1, which will get cleared by writing 1 into them */ /* Bits of PORTSC1, which will get cleared by writing 1 into them */
#define TEGRA_PORTSC1_RWC_BITS (PORT_CSC | PORT_PEC | PORT_OCC) #define TEGRA_PORTSC1_RWC_BITS (PORT_CSC | PORT_PEC | PORT_OCC)
...@@ -746,7 +518,6 @@ static int tegra_ehci_probe(struct platform_device *pdev) ...@@ -746,7 +518,6 @@ static int tegra_ehci_probe(struct platform_device *pdev)
goto cleanup_phy; goto cleanup_phy;
} }
tegra->host_resumed = 1;
tegra->ehci = hcd_to_ehci(hcd); tegra->ehci = hcd_to_ehci(hcd);
irq = platform_get_irq(pdev, 0); irq = platform_get_irq(pdev, 0);
...@@ -773,14 +544,6 @@ static int tegra_ehci_probe(struct platform_device *pdev) ...@@ -773,14 +544,6 @@ static int tegra_ehci_probe(struct platform_device *pdev)
goto cleanup_phy; goto cleanup_phy;
} }
pm_runtime_set_active(&pdev->dev);
pm_runtime_get_noresume(&pdev->dev);
/* Don't skip the pm_runtime_forbid call if wakeup isn't working */
/* if (!pdata->power_down_on_bus_suspend) */
pm_runtime_forbid(&pdev->dev);
pm_runtime_enable(&pdev->dev);
pm_runtime_put_sync(&pdev->dev);
return err; return err;
cleanup_phy: cleanup_phy:
...@@ -800,10 +563,6 @@ static int tegra_ehci_remove(struct platform_device *pdev) ...@@ -800,10 +563,6 @@ static int tegra_ehci_remove(struct platform_device *pdev)
struct tegra_ehci_hcd *tegra = platform_get_drvdata(pdev); struct tegra_ehci_hcd *tegra = platform_get_drvdata(pdev);
struct usb_hcd *hcd = ehci_to_hcd(tegra->ehci); struct usb_hcd *hcd = ehci_to_hcd(tegra->ehci);
pm_runtime_get_sync(&pdev->dev);
pm_runtime_disable(&pdev->dev);
pm_runtime_put_noidle(&pdev->dev);
if (!IS_ERR(tegra->transceiver)) if (!IS_ERR(tegra->transceiver))
otg_set_host(tegra->transceiver->otg, NULL); otg_set_host(tegra->transceiver->otg, NULL);
...@@ -837,8 +596,5 @@ static struct platform_driver tegra_ehci_driver = { ...@@ -837,8 +596,5 @@ static struct platform_driver tegra_ehci_driver = {
.driver = { .driver = {
.name = "tegra-ehci", .name = "tegra-ehci",
.of_match_table = tegra_ehci_of_match, .of_match_table = tegra_ehci_of_match,
#ifdef CONFIG_PM
.pm = &tegra_ehci_pm_ops,
#endif
} }
}; };
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment