android/android_kernel_cmhtcleo
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

usb: added usb-host functionality for MSM devices amd Leo config file

Browse Source
This commit is contained in:
Markinus 2011-03-06 12:43:57 +01:00 committed by tytung
parent 27f7fd8972
commit f42b4692d6
6 changed files with 2692 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2225
arch/arm/configs/htcleo-usbhost_defconfig Normal file
View File

File diff suppressed because it is too large Load Diff

3
drivers/usb/Kconfig
View File

@ -58,6 +58,9 @@ config USB_ARCH_HAS_EHCI
default y if PPC_83xx
default y if SOC_AU1200
default y if ARCH_IXP4XX
default y if ARCH_MSM7XXX
default y if ARCH_MSM
default y if ARCH_MSM7X00A
default y if ARCH_W90X900
default y if ARCH_AT91SAM9G45
default PCI

7
drivers/usb/host/Kconfig
View File

@ -105,6 +105,13 @@ config USB_EHCI_FSL
---help---
Variation of ARC USB block used in some Freescale chips.
config USB_EHCI_MSM7201
bool "Support for Qualcomm MSM7201/QSD8X50 on-chip EHCI USB controller"
depends on USB_EHCI_HCD && (ARCH_MSM7XXX || ARCH_MSM || ARCH_MSM7X00A) && (!USB_FUNCTION)
select USB_EHCI_ROOT_HUB_TT
---help---
Variation of ARC USB block used in Qualcomm MSM7201/QSD8X50 chips.
config USB_EHCI_HCD_PPC_OF
bool "EHCI support for PPC USB controller on OF platform bus"
depends on USB_EHCI_HCD && PPC_OF

5
drivers/usb/host/ehci-hcd.c
View File

@ -1131,6 +1131,11 @@ MODULE_LICENSE ("GPL");
#define PLATFORM_DRIVER ixp4xx_ehci_driver
#endif
#ifdef CONFIG_USB_EHCI_MSM7201
#include "ehci-msm7201.c"
#define PLATFORM_DRIVER ehci_msm7201_driver
#endif
#ifdef CONFIG_USB_W90X900_EHCI
#include "ehci-w90x900.c"
#define PLATFORM_DRIVER ehci_hcd_w90x900_driver

399
drivers/usb/host/ehci-msm7201.c Normal file
View File

@ -0,0 +1,399 @@
/*
* Nexus One support added by Sven Killig <sven@killig.de>
*
* Copyright (c) 2010 Andrew de Quincey
*
* (heavily) based on ehci-fsl.c, which is:
*
* Copyright (c) 2005 MontaVista Software
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
* Ported to 834x by Randy Vinson <rvinson@mvista.com> using code provided
* by Hunter Wu.
*/
#include <linux/platform_device.h>
#include <linux/clk.h>
#include <mach/msm_hsusb.h>
#include "ehci-msm7201.h"
static void ulpi_write(struct usb_hcd *hcd, unsigned val, unsigned reg)
{
unsigned timeout = 10000;
/* initiate write operation */
writel(ULPI_RUN | ULPI_WRITE |
ULPI_ADDR(reg) | ULPI_DATA(val),
USB_ULPI_VIEWPORT);
/* wait for completion */
while ((readl(USB_ULPI_VIEWPORT) & ULPI_RUN) && (--timeout)) ;
if (timeout == 0)
printk(KERN_WARNING "%s: timeout: reg: 0x%X, var: 0x%X\n",
__func__, reg, val);
}
static void msm7201_setup_phy(struct usb_hcd *hcd)
{
struct msm7201_usb_priv *msm7201 = hcd_to_msm7201(hcd);
int *seq = msm7201->phy_init_seq;
if (!seq)
return;
while (seq[0] >= 0) {
ulpi_write(hcd, seq[0], seq[1]);
seq += 2;
}
}
static void msm7201_shutdown_phy(struct usb_hcd *hcd)
{
struct msm7201_usb_priv *msm7201 = hcd_to_msm7201(hcd);
if (msm7201->phy_shutdown)
msm7201->phy_shutdown();
/* disable interface protect circuit to drop current consumption */
ulpi_write(hcd, (1 << 7), 0x08);
/* clear the SuspendM bit -> suspend the PHY */
ulpi_write(hcd, ULPI_FUNC_SUSPENDM, ULPI_FUNC_CTRL_CLR);
}
static void msm7201_usb_setup(struct usb_hcd *hcd)
{
struct msm7201_usb_priv *msm7201 = hcd_to_msm7201(hcd);
#ifdef CONFIG_ARCH_QSD8X50
/* bursts of unspecified length. */
writel(0x0, USB_AHBBURST);
/* Use the AHB transactor */
writel(0x0, USB_AHBMODE);
#else
/* INCR8 BURST mode */
writel(0x02, USB_SBUSCFG); /*boost performance to fix CRC error.*/
#endif
/* select ULPI phy */
writel(0x80000000, USB_PORTSC);
if (msm7201->phy_reset)
msm7201->phy_reset();
msm7201_setup_phy(hcd);
}
/* called after powerup, by probe or system-pm "wakeup" */
static int ehci_msm7201_reinit(struct ehci_hcd *ehci)
{
msm7201_usb_setup(ehci_to_hcd(ehci));
ehci_port_power(ehci, 0);
return 0;
}
/* called during probe() after chip reset completes */
static int ehci_msm7201_setup(struct usb_hcd *hcd)
{
struct ehci_hcd *ehci = hcd_to_ehci(hcd);
int retval;
ehci->caps = USB_CAPLENGTH;
ehci->regs = USB_CAPLENGTH +
HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
/* configure other settings */
ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
hcd->has_tt = 1;
ehci->sbrn = HCD_USB2;
/* reset and halt controller */
ehci_reset(ehci);
retval = ehci_halt(ehci);
if (retval)
return retval;
/* data structure init */
retval = ehci_init(hcd);
if (retval)
return retval;
ehci_reset(ehci);
retval = ehci_msm7201_reinit(ehci);
return retval;
}
// mainly a copy of ehci_run(), can perhaps be reduced:
static int ehci_msm_run(struct usb_hcd *hcd)
{
struct ehci_hcd *ehci = hcd_to_ehci(hcd);
int retval = 0;
int port = HCS_N_PORTS(ehci->hcs_params);
u32 __iomem *reg_ptr;
u32 hcc_params;
hcd->uses_new_polling = 1;
hcd->poll_rh = 0;
/* set hostmode */
reg_ptr = (u32 __iomem *)(((u8 __iomem *)ehci->regs) + USBMODE);
ehci_writel(ehci, (USBMODE_VBUS | USBMODE_SDIS), reg_ptr);
/* port configuration - phy, port speed, port power, port enable */
while (port--)
ehci_writel(ehci, (PORTSC_PTS_ULPI | PORT_POWER |
PORT_PE), &ehci->regs->port_status[port]);
ehci_writel(ehci, ehci->periodic_dma, &ehci->regs->frame_list);
ehci_writel(ehci, (u32)ehci->async->qh_dma, &ehci->regs->async_next);
hcc_params = ehci_readl(ehci, &ehci->caps->hcc_params);
if (HCC_64BIT_ADDR(hcc_params))
ehci_writel(ehci, 0, &ehci->regs->segment);
ehci->command &= ~(CMD_LRESET|CMD_IAAD|CMD_PSE|CMD_ASE|CMD_RESET);
ehci->command |= CMD_RUN;
ehci_writel(ehci, ehci->command, &ehci->regs->command);
/*
* Start, enabling full USB 2.0 functionality ... usb 1.1 devices
* are explicitly handed to companion controller(s), so no TT is
* involved with the root hub. (Except where one is integrated,
* and there's no companion controller unless maybe for USB OTG.)
*
* Turning on the CF flag will transfer ownership of all ports
* from the companions to the EHCI controller. If any of the
* companions are in the middle of a port reset at the time, it
* could cause trouble. Write-locking ehci_cf_port_reset_rwsem
* guarantees that no resets are in progress. After we set CF,
* a short delay lets the hardware catch up; new resets shouldn't
* be started before the port switching actions could complete.
*/
down_write(&ehci_cf_port_reset_rwsem);
hcd->state = HC_STATE_RUNNING;
ehci_writel(ehci, FLAG_CF, &ehci->regs->configured_flag);
ehci_readl(ehci, &ehci->regs->command); /* unblock posted writes */
msleep(5);
up_write(&ehci_cf_port_reset_rwsem);
/*Enable appropriate Interrupts*/
ehci_writel(ehci, INTR_MASK,
&ehci->regs->intr_enable);
return retval;
}
static const struct hc_driver ehci_msm7201_hc_driver = {
.description = hcd_name,
.product_desc = "Qualcomm MSM7201 On-Chip EHCI Host Controller",
.hcd_priv_size = sizeof(struct ehci_hcd) + sizeof(struct msm7201_usb_priv),
/*
* generic hardware linkage
*/
.irq = ehci_irq,
.flags = HCD_USB2 | HCD_MEMORY | HCD_LOCAL_MEM,
/*
* basic lifecycle operations
*/
.reset = ehci_msm7201_setup,
.start = ehci_msm_run,
.stop = ehci_stop,
.shutdown = ehci_shutdown,
/*
* managing i/o requests and associated device resources
*/
.urb_enqueue = ehci_urb_enqueue,
.urb_dequeue = ehci_urb_dequeue,
.endpoint_disable = ehci_endpoint_disable,
/*
* scheduling support
*/
.get_frame_number = ehci_get_frame,
/*
* root hub support
*/
.hub_status_data = ehci_hub_status_data,
.hub_control = ehci_hub_control,
.bus_suspend = ehci_bus_suspend,
.bus_resume = ehci_bus_resume,
.relinquish_port = ehci_relinquish_port,
.port_handed_over = ehci_port_handed_over,
// maybe neccessary:
//.clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
};
/**
* usb_hcd_msm7201_remove - shutdown processing for MSM7201-based HCDs
* @pdev: USB Host Controller being removed
* Context: !in_interrupt()
*
* Reverses the effect of usb_hcd_msm7201_probe().
*
*/
static int usb_hcd_msm7201_remove(struct platform_device *pdev)
{
struct usb_hcd *hcd = platform_get_drvdata(pdev);
struct msm7201_usb_priv *msm7201 = hcd_to_msm7201(hcd);
usb_remove_hcd(hcd);
msm7201_shutdown_phy(hcd);
clk_put(msm7201->clk);
clk_put(msm7201->pclk);
iounmap(hcd->regs);
release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
usb_put_hcd(hcd);
return 0;
}
/**
* usb_hcd_msm7201_probe - initialize MSM7201-based HCDs
* @pdev: USB Host Controller being probed
* Context: !in_interrupt()
*
* Allocates basic resources for this USB host controller.
*
*/
static int usb_hcd_msm7201_probe(struct platform_device *pdev)
{
struct usb_hcd *hcd;
struct resource *res;
struct msm7201_usb_priv *msm7201;
int irq;
int retval;
const struct hc_driver *driver = &ehci_msm7201_hc_driver;
struct msm_hsusb_platform_data *pdata = pdev->dev.platform_data;
if (usb_disabled())
return -ENODEV;
pr_debug("initializing MSM7201 USB Controller\n");
irq = platform_get_irq(pdev, 0);
if (irq < 0) {
dev_err(&pdev->dev, "irq < 0. Check %s setup!\n", dev_name(&pdev->dev));
return -ENODEV;
}
hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));
if (!hcd) {
retval = -ENOMEM;
goto err1;
}
msm7201 = hcd_to_msm7201(hcd);
if (pdata) {
msm7201->phy_reset = pdata->phy_reset;
#ifndef CONFIG_ARCH_QSD8X50
msm7201->phy_shutdown = pdata->phy_shutdown;
#endif
msm7201->phy_init_seq = pdata->phy_init_seq;
}
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
dev_err(&pdev->dev,
"Found HC with no register addr. Check %s setup!\n",
dev_name(&pdev->dev));
retval = -ENODEV;
goto err2;
}
hcd->rsrc_start = res->start;
hcd->rsrc_len = res->end - res->start + 1;
if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len,
driver->description)) {
dev_dbg(&pdev->dev, "controller already in use\n");
retval = -EBUSY;
goto err2;
}
hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
if (hcd->regs == NULL) {
dev_dbg(&pdev->dev, "error mapping memory\n");
retval = -EFAULT;
goto err3;
}
msm7201->clk = clk_get(&pdev->dev, "usb_hs_clk");
if (IS_ERR(msm7201->clk)) {
dev_dbg(&pdev->dev, "error getting usb_hs_clk\n");
retval = -EFAULT;
goto err4;
}
msm7201->pclk = clk_get(&pdev->dev, "usb_hs_pclk");
if (IS_ERR(msm7201->pclk)) {
dev_dbg(&pdev->dev, "error getting usb_hs_pclk\n");
retval = -EFAULT;
goto err5;
}
clk_enable(msm7201->clk);
clk_enable(msm7201->pclk);
/* wait for a while after enable usb clk*/
msleep(5);
/* clear interrupts before requesting irq */
writel(0, USB_USBINTR);
writel(0, USB_OTGSC);
disable_irq(irq);
retval = usb_add_hcd(hcd, irq, IRQF_SHARED);
enable_irq(irq); // Unbalanced (?)
/* enable interrupts */
writel(STS_URI | STS_SLI | STS_UI | STS_PCI, USB_USBINTR);
if (retval != 0)
goto err6;
return retval;
err6:
clk_put(msm7201->pclk);
err5:
clk_put(msm7201->clk);
err4:
iounmap(hcd->regs);
err3:
release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
err2:
usb_put_hcd(hcd);
err1:
dev_err(&pdev->dev, "init %s fail, %d\n", dev_name(&pdev->dev), retval);
return retval;
}
MODULE_ALIAS("platform:msm_hsusb");
static struct platform_driver ehci_msm7201_driver = {
.probe = usb_hcd_msm7201_probe,
.remove = usb_hcd_msm7201_remove,
.shutdown = usb_hcd_platform_shutdown,
.driver = {
.name = "msm_hsusb",
},
};

53
drivers/usb/host/ehci-msm7201.h Normal file
View File

@ -0,0 +1,53 @@
/*
* Nexus One support added by Sven Killig <sven@killig.de>
*
* Copyright (c) 2010 Andrew de Quincey
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifndef _EHCI_MSM7201_H
#define _EHCI_MSM7201_H
struct msm7201_usb_priv
{
struct clk *clk;
struct clk *pclk;
int *phy_init_seq;
void (*phy_reset)(void);
void (*phy_shutdown)(void);
};
static inline struct msm7201_usb_priv *hcd_to_msm7201(struct usb_hcd *hcd)
{
return (struct msm7201_usb_priv *) (((unsigned char*) (hcd->hcd_priv)) + sizeof(struct ehci_hcd));
}
#define MSM_USB_BASE (hcd->regs)
#include <mach/msm_hsusb_hw.h>
#define USBMODE_VBUS (1 << 5) /* vbus power select */
/* Redefining SDIS bit as it defined incorrectly in ehci.h. */
#ifdef USBMODE_SDIS
#undef USBMODE_SDIS
#endif
#define USBMODE_SDIS (1 << 4) /* stream disable */
#endif /* _EHCI_MSM7201_H */