drivers/usb/host/ohci-da8xx.c - arm/linux-arm64-legacy - Git at Google

 /*
  * 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 = devm_clk_get(&pdev->dev, "usb11");
 	if (IS_ERR(usb11_clk))
 		return PTR_ERR(usb11_clk);

 	usb20_clk = devm_clk_get(&pdev->dev, "usb20");
 	if (IS_ERR(usb20_clk))
 		return PTR_ERR(usb20_clk);

 	hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));
 	if (!hcd)
 		return -ENOMEM;

 	mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 	if (!mem)
 		return -ENODEV;
 	hcd->rsrc_start = mem->start;
 	hcd->rsrc_len = resource_size(mem);

 	hcd->regs = devm_ioremap_resource(&pdev->dev, mem);
 	if (IS_ERR(hcd->regs)) {
 		error = PTR_ERR(hcd->regs);
 		goto err;
 	}

 	ohci_hcd_init(hcd_to_ohci(hcd));

 	irq = platform_get_irq(pdev, 0);
 	if (irq < 0) {
 		error = -ENODEV;
 		goto err;
 	}
 	error = usb_add_hcd(hcd, irq, 0);
 	if (error)
 		goto err;

 	device_wakeup_enable(hcd->self.controller);

 	if (hub->ocic_notify) {
 		error = hub->ocic_notify(ohci_da8xx_ocic_handler);
 		if (!error)
 			return 0;
 	}

 	usb_remove_hcd(hcd);
 err:
 	usb_put_hcd(hcd);
 	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);
 	usb_put_hcd(hcd);
 }

 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 *pdev,
 				pm_message_t message)
 {
 	struct usb_hcd	*hcd	= platform_get_drvdata(pdev);
 	struct ohci_hcd	*ohci	= hcd_to_ohci(hcd);
 	bool		do_wakeup	= device_may_wakeup(&pdev->dev);
 	int		ret;


 	if (time_before(jiffies, ohci->next_statechange))
 		msleep(5);
 	ohci->next_statechange = jiffies;

 	ret = ohci_suspend(hcd, do_wakeup);
 	if (ret)
 		return ret;

 	ohci_da8xx_clock(0);
 	hcd->state = HC_STATE_SUSPENDED;

 	return ret;
 }

 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");
	/*
	* 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 = devm_clk_get(&pdev->dev, "usb11");
	if (IS_ERR(usb11_clk))
	return PTR_ERR(usb11_clk);

	usb20_clk = devm_clk_get(&pdev->dev, "usb20");
	if (IS_ERR(usb20_clk))
	return PTR_ERR(usb20_clk);

	hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));
	if (!hcd)
	return -ENOMEM;

	mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!mem)
	return -ENODEV;
	hcd->rsrc_start = mem->start;
	hcd->rsrc_len = resource_size(mem);

	hcd->regs = devm_ioremap_resource(&pdev->dev, mem);
	if (IS_ERR(hcd->regs)) {
	error = PTR_ERR(hcd->regs);
	goto err;
	}

	ohci_hcd_init(hcd_to_ohci(hcd));

	irq = platform_get_irq(pdev, 0);
	if (irq < 0) {
	error = -ENODEV;
	goto err;
	}
	error = usb_add_hcd(hcd, irq, 0);
	if (error)
	goto err;

	device_wakeup_enable(hcd->self.controller);

	if (hub->ocic_notify) {
	error = hub->ocic_notify(ohci_da8xx_ocic_handler);
	if (!error)
	return 0;
	}

	usb_remove_hcd(hcd);
	err:
	usb_put_hcd(hcd);
	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);
	usb_put_hcd(hcd);
	}

	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 *pdev,
	pm_message_t message)
	{
	struct usb_hcd *hcd = platform_get_drvdata(pdev);
	struct ohci_hcd *ohci = hcd_to_ohci(hcd);
	bool do_wakeup = device_may_wakeup(&pdev->dev);
	int ret;


	if (time_before(jiffies, ohci->next_statechange))
	msleep(5);
	ohci->next_statechange = jiffies;

	ret = ohci_suspend(hcd, do_wakeup);
	if (ret)
	return ret;

	ohci_da8xx_clock(0);
	hcd->state = HC_STATE_SUSPENDED;

	return ret;
	}

	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");