/* * 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 <linux/platform_data/usb-davinci.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_get_platdata(dev); 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_get_platdata(dev); 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 = dev_get_platdata(&pdev->dev); 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 = dev_get_platdata(&pdev->dev); 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); 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");