diff options
Diffstat (limited to 'target/linux/realtek/files/drivers/usb/host')
4 files changed, 1048 insertions, 0 deletions
diff --git a/target/linux/realtek/files/drivers/usb/host/ehci-dwc.c b/target/linux/realtek/files/drivers/usb/host/ehci-dwc.c new file mode 100644 index 000000000..a45c34802 --- /dev/null +++ b/target/linux/realtek/files/drivers/usb/host/ehci-dwc.c @@ -0,0 +1,193 @@ +/* + * Realtek Semiconductor Corp. + * + * ehci-dwc.c: DWC USB host controller + * + * Tony Wu (tonywu@realtek.com) + * Jan. 10, 2009 + */ + +#include <linux/platform_device.h> + +#define EHCI_DWC_NAME "dwc_ehci" + +/* called during probe() after chip reset completes */ +static int +ehci_dwc_setup (struct usb_hcd *hcd) +{ + struct ehci_hcd *ehci = hcd_to_ehci (hcd); + int retval = 0; + + retval = ehci_halt (ehci); + if (retval) + return retval; + + /* data structure init */ + retval = ehci_init (hcd); + if (retval) + return retval; + + if (ehci_is_TDI (ehci)) + ehci_reset (ehci); + +#ifdef CONFIG_USB_SUSPEND + /* REVISIT: the controller works fine for wakeup iff the root hub + * itself is "globally" suspended, but usbcore currently doesn't + * understand such things. + * + * System suspend currently expects to be able to suspend the entire + * device tree, device-at-a-time. If we failed selective suspend + * reports, system suspend would fail; so the root hub code must claim + * success. That's lying to usbcore, and it matters for for runtime + * PM scenarios with selective suspend and remote wakeup... + */ + if (ehci->no_selective_suspend && device_can_wakeup (&pdev->dev)) + ehci_warn (ehci, "selective suspend/wakeup unavailable\n"); +#endif + + ehci_port_power(ehci, 0); + return retval; +} + +struct hc_driver ehci_dwc_hc_driver = { + .description = hcd_name, + .product_desc = "EHCI Host Controller", + .hcd_priv_size = sizeof (struct ehci_hcd), + /* + * generic hardware linkage + */ + .irq = ehci_irq, + .flags = HCD_MEMORY | HCD_USB2, + + /* + * basic lifecycle operations + */ + .reset = ehci_dwc_setup, + .start = ehci_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, + +#ifdef CONFIG_PM + .bus_suspend = ehci_bus_suspend, + .bus_resume = ehci_bus_resume, +#endif + + .relinquish_port = ehci_relinquish_port, + .port_handed_over = ehci_port_handed_over, +}; + +int +ehci_dwc_drv_probe (struct platform_device *pdev) +{ + struct hc_driver *phcd; + struct usb_hcd *hcd; + struct ehci_hcd *ehci; + struct resource *res; + int retval; + u32 dwc_usb_irq; + + phcd = &ehci_dwc_hc_driver; + + res = platform_get_resource (pdev, IORESOURCE_IRQ, 0); + if (res == NULL) + { + printk (KERN_ERR __FILE__ ": get irq resource failed!\n"); + retval = -ENOMEM; + return retval; + } + + dwc_usb_irq = res->start; + + hcd = usb_create_hcd (phcd, &pdev->dev, dev_name(&pdev->dev)); + if (hcd == NULL) + { + retval = -ENOMEM; + return retval; + } + + res = platform_get_resource (pdev, IORESOURCE_MEM, 0); + if (res == NULL) + { + printk (KERN_ERR __FILE__ ": get memory resource failed!\n"); + retval = -ENOMEM; + return retval; + } + + hcd->rsrc_start = res->start; + hcd->rsrc_len = res->end - res->start + 1; + if (request_mem_region (hcd->rsrc_start, hcd->rsrc_len, EHCI_DWC_NAME) == NULL) + { + printk (KERN_ERR __FILE__ ": request_mem_region failed\n"); + retval = -ENOMEM; + return retval; + } + + hcd->regs = (void *) ioremap(hcd->rsrc_start, hcd->rsrc_len); + if (!hcd->regs) + { + printk(KERN_ERR __FILE__ ": ioremap failed\n"); + release_mem_region (hcd->rsrc_start, hcd->rsrc_len); + retval = -ENOMEM; + return retval; + } + + ehci = hcd_to_ehci (hcd); + ehci->caps = hcd->regs; + ehci->regs = hcd->regs + HC_LENGTH (readl (&ehci->caps->hc_capbase)); + ehci->hcs_params = readl (&ehci->caps->hcs_params); + + retval = usb_add_hcd (hcd, dwc_usb_irq, IRQF_SHARED); + if (retval != 0) + { + release_mem_region (hcd->rsrc_start, hcd->rsrc_len); + iounmap(hcd->regs); + } + + return retval; +} + +static int +ehci_dwc_drv_remove (struct platform_device *pdev) +{ + struct usb_hcd *hcd; + + hcd = platform_get_drvdata (pdev); + usb_remove_hcd (hcd); + if (hcd->driver->flags & HCD_MEMORY) + { + iounmap (hcd->regs); + release_mem_region (hcd->rsrc_start, hcd->rsrc_len); + } + else + release_region (hcd->rsrc_start, hcd->rsrc_len); + + usb_put_hcd (hcd); + return 0; +} + +struct platform_driver ehci_dwc_driver = { + .probe = ehci_dwc_drv_probe, + .remove = ehci_dwc_drv_remove, + .shutdown = usb_hcd_platform_shutdown, + .driver = { + .name = "dwc_ehci", + }, +}; diff --git a/target/linux/realtek/files/drivers/usb/host/ehci-rtl8652.c b/target/linux/realtek/files/drivers/usb/host/ehci-rtl8652.c new file mode 100644 index 000000000..1be39ae22 --- /dev/null +++ b/target/linux/realtek/files/drivers/usb/host/ehci-rtl8652.c @@ -0,0 +1,533 @@ +/* + * (C) Copyright David Brownell 2000-2002 + * 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/rtl8652_devices.h> + +#include "bspchip.h" +#include "usb-rtl8652.h" + +/* FIXME: Power Managment is un-ported so temporarily disable it */ +#undef CONFIG_PM + +/* PCI-based HCs are common, but plenty of non-PCI HCs are used too */ + +/* configure so an HC device and id are always provided */ +/* always called with process context; sleeping is OK */ + +/** + * usb_hcd_rtl8652_probe - initialize FSL-based HCDs + * @drvier: Driver to be used for this HCD + * @pdev: USB Host Controller being probed + * Context: !in_interrupt() + * + * Allocates basic resources for this USB host controller. + * + */ +int usb_hcd_rtl8652_probe(const struct hc_driver *driver, + struct platform_device *pdev) +{ + struct usb_hcd *hcd; + struct resource *res; + int irq; + int retval; + + pr_debug("initializing RTL-SOC USB Controller\n"); + + res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); + if (!res) { + dev_err(&pdev->dev, + "Found HC with no IRQ. Check %s setup!\n", + dev_name(&pdev->dev)); + return -ENODEV; + } + irq = res->start; + hcd = usb_create_hcd(driver, &pdev->dev,dev_name(&pdev->dev)); + if (!hcd) { + retval = -ENOMEM; + goto err1; + } + + 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 = (void *) KSEG1ADDR(hcd->rsrc_start); + //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; + } + + + retval = usb_add_hcd(hcd, irq, IRQF_SHARED); + if (retval != 0) + goto err4; + + return retval; + + 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; +} + +/* may be called without controller electrically present */ +/* may be called with controller, bus, and devices active */ + +/** + * usb_hcd_rtl8652_remove - shutdown processing for FSL-based HCDs + * @dev: USB Host Controller being removed + * Context: !in_interrupt() + * + * Reverses the effect of usb_hcd_rtl8652_probe(). + * + */ +void usb_hcd_rtl8652_remove(struct usb_hcd *hcd, struct platform_device *pdev) +{ + usb_remove_hcd(hcd); + iounmap(hcd->regs); + release_mem_region(hcd->rsrc_start, hcd->rsrc_len); + usb_put_hcd(hcd); +} + +#if 0 +static void mpc83xx_setup_phy(struct ehci_hcd *ehci, + enum rtl8652_usb2_phy_modes phy_mode, + unsigned int port_offset) +{ + u32 portsc = 0; + switch (phy_mode) { + case FSL_USB2_PHY_ULPI: + portsc |= PORT_PTS_ULPI; + break; + case FSL_USB2_PHY_SERIAL: + portsc |= PORT_PTS_SERIAL; + break; + case FSL_USB2_PHY_UTMI_WIDE: + portsc |= PORT_PTS_PTW; + /* fall through */ + case FSL_USB2_PHY_UTMI: + portsc |= PORT_PTS_UTMI; + break; + case FSL_USB2_PHY_NONE: + break; + } + writel(portsc, &ehci->regs->port_status[port_offset]); +} +static void mpc83xx_usb_setup(struct usb_hcd *hcd) +{ + struct ehci_hcd *ehci = hcd_to_ehci(hcd); + struct rtl8652_usb2_platform_data *pdata; + void __iomem *non_ehci = hcd->regs; + + pdata = + (struct rtl8652_usb2_platform_data *)hcd->self.controller-> + platform_data; + /* Enable PHY interface in the control reg. */ + out_be32(non_ehci + FSL_SOC_USB_CTRL, 0x00000004); + out_be32(non_ehci + FSL_SOC_USB_SNOOP1, 0x0000001b); + + if (pdata->operating_mode == FSL_USB2_DR_HOST) + mpc83xx_setup_phy(ehci, pdata->phy_mode, 0); + + if (pdata->operating_mode == FSL_USB2_MPH_HOST) { + unsigned int chip, rev, svr; + + svr = mfspr(SPRN_SVR); + chip = svr >> 16; + rev = (svr >> 4) & 0xf; + + /* Deal with USB Erratum #14 on MPC834x Rev 1.0 & 1.1 chips */ + if ((rev == 1) && (chip >= 0x8050) && (chip <= 0x8055)) + ehci->has_rtl8652_port_bug = 1; + + if (pdata->port_enables & FSL_USB2_PORT0_ENABLED) + mpc83xx_setup_phy(ehci, pdata->phy_mode, 0); + if (pdata->port_enables & FSL_USB2_PORT1_ENABLED) + mpc83xx_setup_phy(ehci, pdata->phy_mode, 1); + } + + /* put controller in host mode. */ + writel(0x00000003, non_ehci + FSL_SOC_USB_USBMODE); + out_be32(non_ehci + FSL_SOC_USB_PRICTRL, 0x0000000c); + out_be32(non_ehci + FSL_SOC_USB_AGECNTTHRSH, 0x00000040); + out_be32(non_ehci + FSL_SOC_USB_SICTRL, 0x00000001); +} +#endif +static int synopsys_usb_setup(struct ehci_hcd *ehci) +{ +#if 1 //tony: patch for synopsys + printk("read synopsys=%x\n",readl (&ehci->regs->command+0x84)); + writel(0x01fd0020,&ehci->regs->command+0x84); + printk("read synopsys2=%x\n",readl (&ehci->regs->command+0x84)); +#endif + return 0; +} + +/* called after powerup, by probe or system-pm "wakeup" */ +static int ehci_rtl8652_reinit(struct ehci_hcd *ehci) +{ + synopsys_usb_setup(ehci); + ehci_port_power(ehci, 0); + return 0; +} + +/* called during probe() after chip reset completes */ +static int ehci_rtl8652_setup(struct usb_hcd *hcd) +{ + struct ehci_hcd *ehci = hcd_to_ehci(hcd); + int retval; + /* EHCI registers start */ + ehci->caps = hcd->regs; + ehci->regs = hcd->regs + + HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase)); + + + dbg_hcs_params(ehci, "reset"); + dbg_hcc_params(ehci, "reset"); + + /* cache this readonly data; minimize chip reads */ + ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params); + + retval = ehci_halt(ehci); + if (retval) + return retval; + + /* data structure init */ + retval = ehci_init(hcd); + if (retval) + return retval; + + ehci_reset(ehci); + + retval = ehci_rtl8652_reinit(ehci); + return retval; +} + +static const struct hc_driver ehci_rtl8652_hc_driver = { + .description = hcd_name, + .product_desc = "RTL8652 On-Chip EHCI Host Controller", + .hcd_priv_size = sizeof(struct ehci_hcd), + + /* + * generic hardware linkage + */ + .irq = ehci_irq, + .flags = HCD_USB2, + + /* + * basic lifecycle operations + */ + .reset = ehci_rtl8652_setup, + .start = ehci_run, +#ifdef CONFIG_PM + .suspend = ehci_bus_suspend, + .resume = ehci_bus_resume, +#endif + .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, + .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete, +}; + +static int ehci_rtl8652_drv_probe(struct platform_device *pdev) +{ + if (usb_disabled()) + return -ENODEV; + + return usb_hcd_rtl8652_probe(&ehci_rtl8652_hc_driver, pdev); +} + +static int ehci_rtl8652_drv_remove(struct platform_device *pdev) +{ + struct usb_hcd *hcd = platform_get_drvdata(pdev); + + usb_hcd_rtl8652_remove(hcd, pdev); + + return 0; +} + +MODULE_ALIAS("platform:rtl8652-ehci"); + +static struct platform_driver ehci_rtl8652_driver = { + .probe = ehci_rtl8652_drv_probe, + .remove = ehci_rtl8652_drv_remove, + .shutdown = usb_hcd_platform_shutdown, + .driver = { + .name = "rtl8652-ehci", + }, +}; +#if defined(CONFIG_RTL_8196C) +void SetUSBPhy(unsigned char reg, unsigned char val) +{ + + #define USB2_PHY_DELAY {mdelay(5);} + //8196C demo board: 0xE0:99, 0xE1:A8, 0xE2:98, 0xE3:C1, 0xE5:91, + REG32(0xb8000034) = (0x1f00 | val); USB2_PHY_DELAY; + //printk("0xb8000034=%08x\n", REG32(0xb8000034)); + + unsigned char reg_h=(reg &0xf0)>>4; + unsigned char reg_l=(reg &0x0f); + + mdelay(100); + REG32(0xb80210A4) = (0x00300000 | (reg_l<<16)); USB2_PHY_DELAY; + REG32(0xb80210A4) = (0x00200000 | (reg_l<<16)); USB2_PHY_DELAY; + REG32(0xb80210A4) = (0x00300000 | (reg_l<<16)); USB2_PHY_DELAY; + REG32(0xb80210A4) = (0x00300000 | (reg_h<<16)); USB2_PHY_DELAY; + REG32(0xb80210A4) = (0x00200000 | (reg_h<<16)); USB2_PHY_DELAY; + REG32(0xb80210A4) = (0x00300000 | (reg_h<<16)); USB2_PHY_DELAY; + +} + +unsigned char GetUSBPhy(unsigned char reg) +{ + #define USB2_PHY_DELAY {mdelay(5);} + + unsigned char reg_h=((reg &0xf0)>>4)-2; + unsigned char reg_l=(reg &0x0f); + + REG32(0xb80210A4) = (0x00300000 | (reg_l<<16)); USB2_PHY_DELAY; + REG32(0xb80210A4) = (0x00200000 | (reg_l<<16)); USB2_PHY_DELAY; + REG32(0xb80210A4) = (0x00300000 | (reg_l<<16)); USB2_PHY_DELAY; + REG32(0xb80210A4) = (0x00300000 | (reg_h<<16)); USB2_PHY_DELAY; + REG32(0xb80210A4) = (0x00200000 | (reg_h<<16)); USB2_PHY_DELAY; + REG32(0xb80210A4) = (0x00300000 | (reg_h<<16)); USB2_PHY_DELAY; + + unsigned char val; + val=REG32(0xb80210A4)>>24; + //printk("reg=%x val=%x\n",reg, val); + return val; +} +#endif + +static void synopsys_usb_patch(void) +{ + +#ifndef REG32(reg) +#define REG32(reg) (*(volatile unsigned int *)(reg)) +#endif + +#define USB2_PHY_DELAY {int i=100; while(i>0) {i--;}} + /* Patch: for USB 2.0 PHY */ +#if !defined(CONFIG_RTL_8196C) +#if 0 + /* For Port-0 */ + writel(0x0000000E,0xb8003314) ; USB2_PHY_DELAY; + writel(0x00340000,0xb80210A4) ; USB2_PHY_DELAY; + writel(0x00240000,0xb80210A4) ; USB2_PHY_DELAY; + writel(0x00340000,0xb80210A4) ; USB2_PHY_DELAY; + writel(0x003E0000,0xb80210A4) ; USB2_PHY_DELAY; + writel(0x002E0000,0xb80210A4) ; USB2_PHY_DELAY; + writel(0x003E0000,0xb80210A4) ; USB2_PHY_DELAY; + writel(0x000000D8,0xb8003314) ; USB2_PHY_DELAY; + writel(0x00360000,0xb80210A4) ; USB2_PHY_DELAY; + writel(0x00260000,0xb80210A4) ; USB2_PHY_DELAY; + writel(0x00360000,0xb80210A4) ; USB2_PHY_DELAY; + writel(0x003E0000,0xb80210A4) ; USB2_PHY_DELAY; + writel(0x002E0000,0xb80210A4) ; USB2_PHY_DELAY; + writel(0x003E0000,0xb80210A4) ; USB2_PHY_DELAY; + + /* For Port-1 */ + writel(0x000E0000,0xb8003314) ; USB2_PHY_DELAY; + writel(0x00540000,0xb80210A4) ; USB2_PHY_DELAY; + writel(0x00440000,0xb80210A4) ; USB2_PHY_DELAY; + writel(0x00540000,0xb80210A4) ; USB2_PHY_DELAY; + writel(0x005E0000,0xb80210A4) ; USB2_PHY_DELAY; + writel(0x004E0000,0xb80210A4) ; USB2_PHY_DELAY; + writel(0x005E0000,0xb80210A4) ; USB2_PHY_DELAY; + writel(0x00D80000,0xb8003314) ; USB2_PHY_DELAY; + writel(0x00560000,0xb80210A4) ; USB2_PHY_DELAY; + writel(0x00460000,0xb80210A4) ; USB2_PHY_DELAY; + writel(0x00560000,0xb80210A4) ; USB2_PHY_DELAY; + writel(0x005E0000,0xb80210A4) ; USB2_PHY_DELAY; + writel(0x004E0000,0xb80210A4) ; USB2_PHY_DELAY; + writel(0x005E0000,0xb80210A4) ; USB2_PHY_DELAY; +#else + /* For Port-0 */ + REG32(0xb8003314) = 0x0000000E; USB2_PHY_DELAY; + REG32(0xb80210A4) = 0x00340000; USB2_PHY_DELAY; + REG32(0xb80210A4) = 0x00240000; USB2_PHY_DELAY; + REG32(0xb80210A4) = 0x00340000; USB2_PHY_DELAY; + REG32(0xb80210A4) = 0x003E0000; USB2_PHY_DELAY; + REG32(0xb80210A4) = 0x002E0000; USB2_PHY_DELAY; + REG32(0xb80210A4) = 0x003E0000; USB2_PHY_DELAY; + REG32(0xb8003314) = 0x000000D8; USB2_PHY_DELAY; + REG32(0xb80210A4) = 0x00360000; USB2_PHY_DELAY; + REG32(0xb80210A4) = 0x00260000; USB2_PHY_DELAY; + REG32(0xb80210A4) = 0x00360000; USB2_PHY_DELAY; + REG32(0xb80210A4) = 0x003E0000; USB2_PHY_DELAY; + REG32(0xb80210A4) = 0x002E0000; USB2_PHY_DELAY; + REG32(0xb80210A4) = 0x003E0000; USB2_PHY_DELAY; + + /* For Port-1 */ + REG32(0xb8003314) = 0x000E0000; USB2_PHY_DELAY; + REG32(0xb80210A4) = 0x00540000; USB2_PHY_DELAY; + REG32(0xb80210A4) = 0x00440000; USB2_PHY_DELAY; + REG32(0xb80210A4) = 0x00540000; USB2_PHY_DELAY; + REG32(0xb80210A4) = 0x005E0000; USB2_PHY_DELAY; + REG32(0xb80210A4) = 0x004E0000; USB2_PHY_DELAY; + REG32(0xb80210A4) = 0x005E0000; USB2_PHY_DELAY; + REG32(0xb8003314) = 0x00D80000; USB2_PHY_DELAY; + REG32(0xb80210A4) = 0x00560000; USB2_PHY_DELAY; + REG32(0xb80210A4) = 0x00460000; USB2_PHY_DELAY; + REG32(0xb80210A4) = 0x00560000; USB2_PHY_DELAY; + REG32(0xb80210A4) = 0x005E0000; USB2_PHY_DELAY; + REG32(0xb80210A4) = 0x004E0000; USB2_PHY_DELAY; + REG32(0xb80210A4) = 0x005E0000; USB2_PHY_DELAY; + + printk("USB 2.0 Phy Patch(D): &0xb80210A4 = %08x\n", REG32(0xb80210A4)); /* A85E0000 */ +#endif +#elif defined(CONFIG_RTL_8196C) + + //disable Host chirp J-K + SetUSBPhy(0xf4,0xe3); GetUSBPhy(0xf4); + //8196C demo board: 0xE0:99, 0xE1:A8, 0xE2:98, 0xE3:C1, 0xE5:91, + SetUSBPhy(0xe0,0x99); if(GetUSBPhy(0xe0)!=0x99) printk("reg 0xe0 not correct\n"); + SetUSBPhy(0xe1,0xa8); if(GetUSBPhy(0xe1)!=0xa8) printk("reg 0xe1 not correct\n"); + SetUSBPhy(0xe2,0x98); if(GetUSBPhy(0xe2)!=0x98) printk("reg 0xe2 not correct\n"); + SetUSBPhy(0xe3,0xc1); if(GetUSBPhy(0xe3)!=0xc1) printk("reg 0xe3 not correct\n"); + SetUSBPhy(0xe5,0x91); if(GetUSBPhy(0xe5)!=0x91) printk("reg 0xe5 not correct\n"); + + //test packet. + /* + REG32(0xb8021054)=0x85100000; + REG32(0xb8021010)=0x08000100; + REG32(0xb8021054)=0x85180400; + */ + printk("USB 2.0 PHY Patch Done.\n"); + +#else + printk("========================== NO PATCH USB 2.0 PHY =====================\n"); +#endif + return; +} + +/*here register platform rtl8652 usb device. + do it in kernel boot is a good choice*/ + static struct platform_device *usb_dev_host = NULL; //wei add + //---------------------------------------------------------------------- +static int ehci_rtl8652_init(void) +{ + REG32(0xb8000010)=REG32(0xb8000010)|0x20000; + /*register platform device*/ + int retval; + //static struct platform_device *usb_dev_host = NULL; + + if(usb_dev_host!=NULL) + { printk("Ehci-rtl8652.c: EHCI device already init\n"); + return -1; + } + + + struct resource r[2]; + memset(&r, 0, sizeof(r)); + + r[0].start = PADDR(EHCI_RTL8652_USB_BASE); + r[0].end = PADDR(EHCI_RTL8652_USB_BASE)+sizeof(struct ehci_regs); + r[0].flags = IORESOURCE_MEM; + + r[1].start = r[1].end = RTL8652_USB_IRQ; + r[1].flags = IORESOURCE_IRQ; + + usb_dev_host = platform_device_register_simple("rtl8652-ehci",0, r, 2); + + usb_dev_host->dev.coherent_dma_mask = 0xffffffffUL; + usb_dev_host->dev.dma_mask = &usb_dev_host->dev.coherent_dma_mask; + + if (IS_ERR(usb_dev_host)) + { + retval = PTR_ERR(usb_dev_host); + usb_dev_host=NULL; //wei add + goto err; + } +#if defined(CONFIG_RTL_8198) +#ifdef CONFIG_RTL8198_REVISION_B + // rock: pin_mux for USB over-current detection in rtl8198_rev_a + if (REG32(BSP_REVR) == BSP_RTL8198_REVISION_A) + REG32(0xb8000040) = 0x03; +#else + // rock: pin_mux for USB over-current detection + REG32(0xb8000040) = 0x03; +#endif +#else + synopsys_usb_patch(); +#endif + + return 0; + err: + return retval; +} +//---------------------------------------------------------------------- +void ehci_rtl8652_cleanup(void) +{ + if(usb_dev_host==NULL) + { + printk("EHCI already cleanup\n"); + return; + } + + platform_device_unregister( usb_dev_host); + usb_dev_host=NULL; + +} + diff --git a/target/linux/realtek/files/drivers/usb/host/ohci-rtl8652.c b/target/linux/realtek/files/drivers/usb/host/ohci-rtl8652.c new file mode 100644 index 000000000..58f4fd79d --- /dev/null +++ b/target/linux/realtek/files/drivers/usb/host/ohci-rtl8652.c @@ -0,0 +1,293 @@ +/* + * OHCI HCD (Host Controller Driver) for USB. + * + * (C) Copyright 1999 Roman Weissgaerber <weissg@vienna.at> + * (C) Copyright 2000-2002 David Brownell <dbrownell@users.sourceforge.net> + * (C) Copyright 2002 Hewlett-Packard Company + * + * Bus Glue for rtl8652. + * + * Written by Christopher Hoover <ch@hpl.hp.com> + * Based on fragments of previous driver by Russell King et al. + * + * Modified for LH7A404 from ohci-sa1111.c + * by Durgesh Pattamatta <pattamattad@sharpsec.com> + * + * Modified for pxa27x from ohci-lh7a404.c + * by Nick Bane <nick@cecomputing.co.uk> 26-8-2004 + * + * Modified for rtl8652 from ohci-pxa27x.c + * by Lennert Buytenhek <buytenh@wantstofly.org> 28-2-2006 + * Based on an earlier driver by Ray Lehtiniemi + * + * This file is licenced under the GPL. + */ +#include <linux/device.h> +#include <linux/signal.h> +#include <linux/platform_device.h> +#include "usb-rtl8652.h" + +static void rtl8652_start_hc(struct device *dev) +{ + return 0; +} + +static void rtl8652_stop_hc(struct device *dev) +{ + return 0; +} + +static int usb_hcd_rtl8652_probe(const struct hc_driver *driver, + struct platform_device *pdev) +{ + int retval; + struct usb_hcd *hcd; + + if (pdev->resource[1].flags != IORESOURCE_IRQ) { + pr_debug("resource[1] is not IORESOURCE_IRQ"); + return -ENOMEM; + } + + hcd = usb_create_hcd(driver, &pdev->dev, "rtl8652"); + if (hcd == NULL) + return -ENOMEM; + + hcd->rsrc_start = pdev->resource[0].start; + hcd->rsrc_len = pdev->resource[0].end - pdev->resource[0].start + 1; + if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) { + usb_put_hcd(hcd); + retval = -EBUSY; + goto err1; + } + +// hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len); + hcd->regs = (void *)KSEG1ADDR(pdev->resource[0].start); + if (hcd->regs == NULL) { + pr_debug("ioremap failed"); + retval = -ENOMEM; + goto err2; + } + rtl8652_start_hc(&pdev->dev); + + ohci_hcd_init(hcd_to_ohci(hcd)); + + retval = usb_add_hcd(hcd, pdev->resource[1].start, IRQF_SHARED); + + if (retval == 0) + return retval; + + rtl8652_stop_hc(&pdev->dev); +// iounmap(hcd->regs); +err2: + release_mem_region(hcd->rsrc_start, hcd->rsrc_len); +err1: + usb_put_hcd(hcd); + + return retval; +} + +static void usb_hcd_rtl8652_remove(struct usb_hcd *hcd, + struct platform_device *pdev) +{ + usb_remove_hcd(hcd); + rtl8652_stop_hc(&pdev->dev); + iounmap(hcd->regs); + release_mem_region(hcd->rsrc_start, hcd->rsrc_len); + usb_put_hcd(hcd); +} + +static int __devinit ohci_rtl8652_start(struct usb_hcd *hcd) +{ + struct ohci_hcd *ohci = hcd_to_ohci(hcd); + int ret; + unsigned int fminterval; + + if ((ret = ohci_init(ohci)) < 0) + return ret; + + fminterval = 0x2edf; + ohci_writel (ohci,(fminterval * 9) / 10, &ohci->regs->periodicstart); + fminterval |= ((((fminterval - 210) * 6) / 7) << 16); + ohci_writel (ohci,fminterval, &ohci->regs->fminterval); + ohci_writel (ohci,0x628, &ohci->regs->lsthresh); + ohci_writel(ohci,0x3e67,&ohci->regs->periodicstart); + if ((ret = ohci_run(ohci)) < 0) { + err("can't start %s", hcd->self.bus_name); + ohci_stop(hcd); + return ret; + } + + return 0; +} + +static struct hc_driver ohci_rtl8652_hc_driver = { + .description = hcd_name, + .product_desc = "RTL8652 OHCI", + .hcd_priv_size = sizeof(struct ohci_hcd), + .irq = ohci_irq, + .flags = HCD_USB11 | HCD_MEMORY, + .start = ohci_rtl8652_start, + .stop = ohci_stop, + .shutdown = ohci_shutdown, + .urb_enqueue = ohci_urb_enqueue, + .urb_dequeue = ohci_urb_dequeue, + .endpoint_disable = ohci_endpoint_disable, + .get_frame_number = ohci_get_frame, + .hub_status_data = ohci_hub_status_data, + .hub_control = ohci_hub_control, +#if 0 + .hub_irq_enable = ohci_rhsc_enable, +#endif +#ifdef CONFIG_PM + .bus_suspend = ohci_bus_suspend, + .bus_resume = ohci_bus_resume, +#endif + .start_port_reset = ohci_start_port_reset, +}; + +extern int usb_disabled(void); + +static int ohci_hcd_rtl8652_drv_probe(struct platform_device *pdev) +{ + int ret; + + ret = -ENODEV; + if (!usb_disabled()) + { + ret = usb_hcd_rtl8652_probe(&ohci_rtl8652_hc_driver, pdev); + } + return ret; +} + +static int ohci_hcd_rtl8652_drv_remove(struct platform_device *pdev) +{ + struct usb_hcd *hcd = platform_get_drvdata(pdev); + + usb_hcd_rtl8652_remove(hcd, pdev); + + return 0; +} + +#ifdef CONFIG_PM +static int ohci_hcd_rtl8652_drv_suspend(struct platform_device *pdev, pm_message_t state) +{ + struct usb_hcd *hcd = platform_get_drvdata(pdev); + struct ohci_hcd *ohci = hcd_to_ohci(hcd); + + if (time_before(jiffies, ohci->next_statechange)) + msleep(5); + ohci->next_statechange = jiffies; + + rtl8652_stop_hc(&pdev->dev); + hcd->state = HC_STATE_SUSPENDED; + pdev->dev.power.power_state = PMSG_SUSPEND; + + return 0; +} + +static int ohci_hcd_rtl8652_drv_resume(struct platform_device *pdev) +{ + struct usb_hcd *hcd = platform_get_drvdata(pdev); + struct ohci_hcd *ohci = hcd_to_ohci(hcd); + int status; + + if (time_before(jiffies, ohci->next_statechange)) + msleep(5); + ohci->next_statechange = jiffies; + + rtl8652_start_hc(&pdev->dev); + pdev->dev.power.power_state = PMSG_ON; + usb_hcd_resume_root_hub(hcd); + + return 0; +} +#endif + +/* work with hotplug and coldplug */ +MODULE_ALIAS("platform:rtl8652-ohci"); + +static struct platform_driver ohci_hcd_rtl8652_driver = { + .probe = ohci_hcd_rtl8652_drv_probe, + .remove = ohci_hcd_rtl8652_drv_remove, + .shutdown = usb_hcd_platform_shutdown, +#ifdef CONFIG_PM + .suspend = ohci_hcd_rtl8652_drv_suspend, + .resume = ohci_hcd_rtl8652_drv_resume, +#endif + .driver = { + .name = "rtl8652-ohci", + .owner = THIS_MODULE, + }, +}; + +/*here register platform rtl8652 usb device. + do it in kernel boot is a good choice*/ + static struct platform_device *usb_dev_host = NULL; +static int ohci_rtl8652_init(void) +{ + /*register platform device*/ + int retval; + //static struct platform_device *usb_dev_host = NULL; + + if(usb_dev_host!=NULL) + { printk("Ohci-rtl8652.c: OHCI device already init\n"); + return -1; + } + struct resource r[2]; + memset(&r, 0, sizeof(r)); + + r[0].start = PADDR(OHCI_RTL8652_USB_BASE); + r[0].end = PADDR(OHCI_RTL8652_USB_BASE)+sizeof(struct ohci_regs); + r[0].flags = IORESOURCE_MEM; + + r[1].start = r[1].end = RTL8652_USB_IRQ; + r[1].flags = IORESOURCE_IRQ; + + usb_dev_host = platform_device_register_simple("rtl8652-ohci", 0, r, 2); + + usb_dev_host->dev.coherent_dma_mask = 0xffffffffUL; + usb_dev_host->dev.dma_mask = &usb_dev_host->dev.coherent_dma_mask; + + if (IS_ERR(usb_dev_host)) + { + retval = PTR_ERR(usb_dev_host); + usb_dev_host=NULL; //wei add + goto err; + } + + return 0; + err: + return retval; +} + + +static void ohci_rtl8652_cleanup(void) +{ + if(usb_dev_host==NULL) + { + printk("OHCI already cleanup\n"); + return; + } + + platform_device_unregister( usb_dev_host); + usb_dev_host=NULL; + + +} +#if 0 +static int __init ohci_hcd_rtl8652_init(void) +{ + ohci_rtl8652_init(); + return platform_driver_register(&ohci_hcd_rtl8652_driver); +} + +static void __exit ohci_hcd_rtl8652_cleanup(void) +{ + platform_driver_unregister(&ohci_hcd_rtl8652_driver); +} + + +module_init(ohci_hcd_rtl8652_init); +module_exit(ohci_hcd_rtl8652_cleanup); +#endif + diff --git a/target/linux/realtek/files/drivers/usb/host/usb-rtl8652.h b/target/linux/realtek/files/drivers/usb/host/usb-rtl8652.h new file mode 100644 index 000000000..35ee5cd8c --- /dev/null +++ b/target/linux/realtek/files/drivers/usb/host/usb-rtl8652.h @@ -0,0 +1,29 @@ +/* Copyright (c) 2005 freescale semiconductor + * 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. + */ +#include <bsp/bspchip.h> +#ifndef _USB_RTL8652_H +#define _USB_RTL8652_H +#define PADDR(addr) ((addr) & 0x1FFFFFFF) +#define REG32(reg) (*((volatile unsigned int *)(reg))) +#define OHCI_RTL8652_USB_BASE 0xb8020000 +#define OHCI_RTL8652_USB_REG_SIZE sizeof(struct ohci_regs) +/* offsets for the non-ehci registers in the FSL SOC USB controller */ +#define EHCI_RTL8652_USB_BASE 0xb8021000 +#define EHCI_RTL8652_USB_REG_SIZE sizeof(struct ehci_regs) +#define RTL8652_USB_IRQ BSP_USB_IRQ +#endif /* _USB_RTL8652_H_ */ |