| /* |
| * OHCI HCD (Host Controller Driver) for USB. |
| * |
| * TI DA8xx (OMAP-L1x) Bus Glue |
| * |
| * Derived from: ohci-omap.c and ohci-s3c2410.c |
| * Copyright (C) 2008-2009 MontaVista Software, Inc. <source@mvista.com> |
| * |
| * This file is licensed under the terms of the GNU General Public License |
| * version 2. This program is licensed "as is" without any warranty of any |
| * kind, whether express or implied. |
| */ |
| |
| #include <linux/interrupt.h> |
| #include <linux/jiffies.h> |
| #include <linux/platform_device.h> |
| #include <linux/clk.h> |
| |
| #include <mach/da8xx.h> |
| #include <mach/usb.h> |
| |
| #ifndef CONFIG_ARCH_DAVINCI_DA8XX |
| #error "This file is DA8xx bus glue. Define CONFIG_ARCH_DAVINCI_DA8XX." |
| #endif |
| |
| #define CFGCHIP2 DA8XX_SYSCFG0_VIRT(DA8XX_CFGCHIP2_REG) |
| |
| static struct clk *usb11_clk; |
| static struct clk *usb20_clk; |
| |
| /* Over-current indicator change bitmask */ |
| static volatile u16 ocic_mask; |
| |
| static void ohci_da8xx_clock(int on) |
| { |
| u32 cfgchip2; |
| |
| cfgchip2 = __raw_readl(CFGCHIP2); |
| if (on) { |
| clk_enable(usb11_clk); |
| |
| /* |
| * If USB 1.1 reference clock is sourced from USB 2.0 PHY, we |
| * need to enable the USB 2.0 module clocking, start its PHY, |
| * and not allow it to stop the clock during USB 2.0 suspend. |
| */ |
| if (!(cfgchip2 & CFGCHIP2_USB1PHYCLKMUX)) { |
| clk_enable(usb20_clk); |
| |
| cfgchip2 &= ~(CFGCHIP2_RESET | CFGCHIP2_PHYPWRDN); |
| cfgchip2 |= CFGCHIP2_PHY_PLLON; |
| __raw_writel(cfgchip2, CFGCHIP2); |
| |
| pr_info("Waiting for USB PHY clock good...\n"); |
| while (!(__raw_readl(CFGCHIP2) & CFGCHIP2_PHYCLKGD)) |
| cpu_relax(); |
| } |
| |
| /* Enable USB 1.1 PHY */ |
| cfgchip2 |= CFGCHIP2_USB1SUSPENDM; |
| } else { |
| clk_disable(usb11_clk); |
| if (!(cfgchip2 & CFGCHIP2_USB1PHYCLKMUX)) |
| clk_disable(usb20_clk); |
| |
| /* Disable USB 1.1 PHY */ |
| cfgchip2 &= ~CFGCHIP2_USB1SUSPENDM; |
| } |
| __raw_writel(cfgchip2, CFGCHIP2); |
| } |
| |
| /* |
| * Handle the port over-current indicator change. |
| */ |
| static void ohci_da8xx_ocic_handler(struct da8xx_ohci_root_hub *hub, |
| unsigned port) |
| { |
| ocic_mask |= 1 << port; |
| |
| /* Once over-current is detected, the port needs to be powered down */ |
| if (hub->get_oci(port) > 0) |
| hub->set_power(port, 0); |
| } |
| |
| static int ohci_da8xx_init(struct usb_hcd *hcd) |
| { |
| struct device *dev = hcd->self.controller; |
| struct da8xx_ohci_root_hub *hub = dev->platform_data; |
| struct ohci_hcd *ohci = hcd_to_ohci(hcd); |
| int result; |
| u32 rh_a; |
| |
| dev_dbg(dev, "starting USB controller\n"); |
| |
| ohci_da8xx_clock(1); |
| |
| /* |
| * DA8xx only have 1 port connected to the pins but the HC root hub |
| * register A reports 2 ports, thus we'll have to override it... |
| */ |
| ohci->num_ports = 1; |
| |
| result = ohci_init(ohci); |
| if (result < 0) |
| return result; |
| |
| /* |
| * Since we're providing a board-specific root hub port power control |
| * and over-current reporting, we have to override the HC root hub A |
| * register's default value, so that ohci_hub_control() could return |
| * the correct hub descriptor... |
| */ |
| rh_a = ohci_readl(ohci, &ohci->regs->roothub.a); |
| if (hub->set_power) { |
| rh_a &= ~RH_A_NPS; |
| rh_a |= RH_A_PSM; |
| } |
| if (hub->get_oci) { |
| rh_a &= ~RH_A_NOCP; |
| rh_a |= RH_A_OCPM; |
| } |
| rh_a &= ~RH_A_POTPGT; |
| rh_a |= hub->potpgt << 24; |
| ohci_writel(ohci, rh_a, &ohci->regs->roothub.a); |
| |
| return result; |
| } |
| |
| static void ohci_da8xx_stop(struct usb_hcd *hcd) |
| { |
| ohci_stop(hcd); |
| ohci_da8xx_clock(0); |
| } |
| |
| static int ohci_da8xx_start(struct usb_hcd *hcd) |
| { |
| struct ohci_hcd *ohci = hcd_to_ohci(hcd); |
| int result; |
| |
| result = ohci_run(ohci); |
| if (result < 0) |
| ohci_da8xx_stop(hcd); |
| |
| return result; |
| } |
| |
| /* |
| * Update the status data from the hub with the over-current indicator change. |
| */ |
| static int ohci_da8xx_hub_status_data(struct usb_hcd *hcd, char *buf) |
| { |
| int length = ohci_hub_status_data(hcd, buf); |
| |
| /* See if we have OCIC bit set on port 1 */ |
| if (ocic_mask & (1 << 1)) { |
| dev_dbg(hcd->self.controller, "over-current indicator change " |
| "on port 1\n"); |
| |
| if (!length) |
| length = 1; |
| |
| buf[0] |= 1 << 1; |
| } |
| return length; |
| } |
| |
| /* |
| * Look at the control requests to the root hub and see if we need to override. |
| */ |
| static int ohci_da8xx_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, |
| u16 wIndex, char *buf, u16 wLength) |
| { |
| struct device *dev = hcd->self.controller; |
| struct da8xx_ohci_root_hub *hub = dev->platform_data; |
| int temp; |
| |
| switch (typeReq) { |
| case GetPortStatus: |
| /* Check the port number */ |
| if (wIndex != 1) |
| break; |
| |
| dev_dbg(dev, "GetPortStatus(%u)\n", wIndex); |
| |
| temp = roothub_portstatus(hcd_to_ohci(hcd), wIndex - 1); |
| |
| /* The port power status (PPS) bit defaults to 1 */ |
| if (hub->get_power && hub->get_power(wIndex) == 0) |
| temp &= ~RH_PS_PPS; |
| |
| /* The port over-current indicator (POCI) bit is always 0 */ |
| if (hub->get_oci && hub->get_oci(wIndex) > 0) |
| temp |= RH_PS_POCI; |
| |
| /* The over-current indicator change (OCIC) bit is 0 too */ |
| if (ocic_mask & (1 << wIndex)) |
| temp |= RH_PS_OCIC; |
| |
| put_unaligned(cpu_to_le32(temp), (__le32 *)buf); |
| return 0; |
| case SetPortFeature: |
| temp = 1; |
| goto check_port; |
| case ClearPortFeature: |
| temp = 0; |
| |
| check_port: |
| /* Check the port number */ |
| if (wIndex != 1) |
| break; |
| |
| switch (wValue) { |
| case USB_PORT_FEAT_POWER: |
| dev_dbg(dev, "%sPortFeature(%u): %s\n", |
| temp ? "Set" : "Clear", wIndex, "POWER"); |
| |
| if (!hub->set_power) |
| return -EPIPE; |
| |
| return hub->set_power(wIndex, temp) ? -EPIPE : 0; |
| case USB_PORT_FEAT_C_OVER_CURRENT: |
| dev_dbg(dev, "%sPortFeature(%u): %s\n", |
| temp ? "Set" : "Clear", wIndex, |
| "C_OVER_CURRENT"); |
| |
| if (temp) |
| ocic_mask |= 1 << wIndex; |
| else |
| ocic_mask &= ~(1 << wIndex); |
| return 0; |
| } |
| } |
| |
| return ohci_hub_control(hcd, typeReq, wValue, wIndex, buf, wLength); |
| } |
| |
| static const struct hc_driver ohci_da8xx_hc_driver = { |
| .description = hcd_name, |
| .product_desc = "DA8xx OHCI", |
| .hcd_priv_size = sizeof(struct ohci_hcd), |
| |
| /* |
| * generic hardware linkage |
| */ |
| .irq = ohci_irq, |
| .flags = HCD_USB11 | HCD_MEMORY, |
| |
| /* |
| * basic lifecycle operations |
| */ |
| .reset = ohci_da8xx_init, |
| .start = ohci_da8xx_start, |
| .stop = ohci_da8xx_stop, |
| .shutdown = ohci_shutdown, |
| |
| /* |
| * managing i/o requests and associated device resources |
| */ |
| .urb_enqueue = ohci_urb_enqueue, |
| .urb_dequeue = ohci_urb_dequeue, |
| .endpoint_disable = ohci_endpoint_disable, |
| |
| /* |
| * scheduling support |
| */ |
| .get_frame_number = ohci_get_frame, |
| |
| /* |
| * root hub support |
| */ |
| .hub_status_data = ohci_da8xx_hub_status_data, |
| .hub_control = ohci_da8xx_hub_control, |
| |
| #ifdef CONFIG_PM |
| .bus_suspend = ohci_bus_suspend, |
| .bus_resume = ohci_bus_resume, |
| #endif |
| .start_port_reset = ohci_start_port_reset, |
| }; |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| |
| /** |
| * usb_hcd_da8xx_probe - initialize DA8xx-based HCDs |
| * Context: !in_interrupt() |
| * |
| * Allocates basic resources for this USB host controller, and |
| * then invokes the start() method for the HCD associated with it |
| * through the hotplug entry's driver_data. |
| */ |
| static int usb_hcd_da8xx_probe(const struct hc_driver *driver, |
| struct platform_device *pdev) |
| { |
| struct da8xx_ohci_root_hub *hub = pdev->dev.platform_data; |
| struct usb_hcd *hcd; |
| struct resource *mem; |
| int error, irq; |
| |
| if (hub == NULL) |
| return -ENODEV; |
| |
| usb11_clk = clk_get(&pdev->dev, "usb11"); |
| if (IS_ERR(usb11_clk)) |
| return PTR_ERR(usb11_clk); |
| |
| usb20_clk = clk_get(&pdev->dev, "usb20"); |
| if (IS_ERR(usb20_clk)) { |
| error = PTR_ERR(usb20_clk); |
| goto err0; |
| } |
| |
| hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev)); |
| if (!hcd) { |
| error = -ENOMEM; |
| goto err1; |
| } |
| |
| mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
| if (!mem) { |
| error = -ENODEV; |
| goto err2; |
| } |
| hcd->rsrc_start = mem->start; |
| hcd->rsrc_len = resource_size(mem); |
| |
| if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) { |
| dev_dbg(&pdev->dev, "request_mem_region failed\n"); |
| error = -EBUSY; |
| goto err2; |
| } |
| |
| hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len); |
| if (!hcd->regs) { |
| dev_err(&pdev->dev, "ioremap failed\n"); |
| error = -ENOMEM; |
| goto err3; |
| } |
| |
| ohci_hcd_init(hcd_to_ohci(hcd)); |
| |
| irq = platform_get_irq(pdev, 0); |
| if (irq < 0) { |
| error = -ENODEV; |
| goto err4; |
| } |
| error = usb_add_hcd(hcd, irq, 0); |
| if (error) |
| goto err4; |
| |
| if (hub->ocic_notify) { |
| error = hub->ocic_notify(ohci_da8xx_ocic_handler); |
| if (!error) |
| return 0; |
| } |
| |
| usb_remove_hcd(hcd); |
| err4: |
| iounmap(hcd->regs); |
| err3: |
| release_mem_region(hcd->rsrc_start, hcd->rsrc_len); |
| err2: |
| usb_put_hcd(hcd); |
| err1: |
| clk_put(usb20_clk); |
| err0: |
| clk_put(usb11_clk); |
| return error; |
| } |
| |
| /** |
| * usb_hcd_da8xx_remove - shutdown processing for DA8xx-based HCDs |
| * @dev: USB Host Controller being removed |
| * Context: !in_interrupt() |
| * |
| * Reverses the effect of usb_hcd_da8xx_probe(), first invoking |
| * the HCD's stop() method. It is always called from a thread |
| * context, normally "rmmod", "apmd", or something similar. |
| */ |
| static inline void |
| usb_hcd_da8xx_remove(struct usb_hcd *hcd, struct platform_device *pdev) |
| { |
| struct da8xx_ohci_root_hub *hub = pdev->dev.platform_data; |
| |
| hub->ocic_notify(NULL); |
| usb_remove_hcd(hcd); |
| iounmap(hcd->regs); |
| release_mem_region(hcd->rsrc_start, hcd->rsrc_len); |
| usb_put_hcd(hcd); |
| clk_put(usb20_clk); |
| clk_put(usb11_clk); |
| } |
| |
| static int ohci_hcd_da8xx_drv_probe(struct platform_device *dev) |
| { |
| return usb_hcd_da8xx_probe(&ohci_da8xx_hc_driver, dev); |
| } |
| |
| static int ohci_hcd_da8xx_drv_remove(struct platform_device *dev) |
| { |
| struct usb_hcd *hcd = platform_get_drvdata(dev); |
| |
| usb_hcd_da8xx_remove(hcd, dev); |
| platform_set_drvdata(dev, NULL); |
| |
| return 0; |
| } |
| |
| #ifdef CONFIG_PM |
| static int ohci_da8xx_suspend(struct platform_device *dev, pm_message_t message) |
| { |
| struct usb_hcd *hcd = platform_get_drvdata(dev); |
| struct ohci_hcd *ohci = hcd_to_ohci(hcd); |
| |
| if (time_before(jiffies, ohci->next_statechange)) |
| msleep(5); |
| ohci->next_statechange = jiffies; |
| |
| ohci_da8xx_clock(0); |
| hcd->state = HC_STATE_SUSPENDED; |
| dev->dev.power.power_state = PMSG_SUSPEND; |
| return 0; |
| } |
| |
| static int ohci_da8xx_resume(struct platform_device *dev) |
| { |
| struct usb_hcd *hcd = platform_get_drvdata(dev); |
| struct ohci_hcd *ohci = hcd_to_ohci(hcd); |
| |
| if (time_before(jiffies, ohci->next_statechange)) |
| msleep(5); |
| ohci->next_statechange = jiffies; |
| |
| ohci_da8xx_clock(1); |
| dev->dev.power.power_state = PMSG_ON; |
| usb_hcd_resume_root_hub(hcd); |
| return 0; |
| } |
| #endif |
| |
| /* |
| * Driver definition to register with platform structure. |
| */ |
| static struct platform_driver ohci_hcd_da8xx_driver = { |
| .probe = ohci_hcd_da8xx_drv_probe, |
| .remove = ohci_hcd_da8xx_drv_remove, |
| .shutdown = usb_hcd_platform_shutdown, |
| #ifdef CONFIG_PM |
| .suspend = ohci_da8xx_suspend, |
| .resume = ohci_da8xx_resume, |
| #endif |
| .driver = { |
| .owner = THIS_MODULE, |
| .name = "ohci", |
| }, |
| }; |
| |
| MODULE_ALIAS("platform:ohci"); |