Commit a5b7474a authored by Lennert Buytenhek's avatar Lennert Buytenhek Committed by Greg Kroah-Hartman
Browse files

[PATCH] USB: ohci bits for the cirrus ep93xx 



This patch adds OHCI glue bits for the USB host interface in the
Cirrus ep93xx (arm920t) CPU.

Signed-off-by: default avatarLennert Buytenhek <buytenh@wantstofly.org>
Acked-by: default avatarDavid Brownell <david-b@pacbell.net>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent d14feb5e

drivers/usb/Kconfig

+1 −0
Original line number Diff line number Diff line
@@ -23,6 +23,7 @@ config USB_ARCH_HAS_OHCI 
	default y if ARCH_LH7A404

	default y if ARCH_S3C2410

	default y if PXA27x

	default y if ARCH_EP93XX

	default y if ARCH_AT91RM9200

	# PPC:

	default y if STB03xxx

drivers/usb/host/ohci-ep93xx.c

0 → 100644
+225 −0
Original line number Diff line number Diff line 
/*

 * 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 ep93xx.

 *

 * 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 ep93xx 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/clk.h>

#include <linux/device.h>

#include <linux/signal.h>

#include <linux/platform_device.h>



#include <asm/mach-types.h>

#include <asm/hardware.h>



static struct clk *usb_host_clock;



static void ep93xx_start_hc(struct device *dev)

{

	clk_enable(usb_host_clock);

}



static void ep93xx_stop_hc(struct device *dev)

{

	clk_disable(usb_host_clock);

}



static int usb_hcd_ep93xx_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, "ep93xx");

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

	if (hcd->regs == NULL) {

		pr_debug("ioremap failed");

		retval = -ENOMEM;

		goto err2;

	}



	usb_host_clock = clk_get(&pdev->dev, "usb_host");

	ep93xx_start_hc(&pdev->dev);



	ohci_hcd_init(hcd_to_ohci(hcd));



	retval = usb_add_hcd(hcd, pdev->resource[1].start, SA_INTERRUPT);

	if (retval == 0)

		return retval;



	ep93xx_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_ep93xx_remove(struct usb_hcd *hcd,

			struct platform_device *pdev)

{

	usb_remove_hcd(hcd);

	ep93xx_stop_hc(&pdev->dev);

	clk_put(usb_host_clock);

	iounmap(hcd->regs);

	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);

	usb_put_hcd(hcd);

}



static int __devinit ohci_ep93xx_start(struct usb_hcd *hcd)

{

	struct ohci_hcd *ohci = hcd_to_ohci(hcd);

	int ret;



	if ((ret = ohci_init(ohci)) < 0)

		return ret;



	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_ep93xx_hc_driver = {

	.description		= hcd_name,

	.product_desc		= "EP93xx OHCI",

	.hcd_priv_size		= sizeof(struct ohci_hcd),

	.irq			= ohci_irq,

	.flags			= HCD_USB11 | HCD_MEMORY,

	.start			= ohci_ep93xx_start,

	.stop			= ohci_stop,

	.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,

#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_ep93xx_drv_probe(struct platform_device *pdev)

{

	int ret;



	ret = -ENODEV;

	if (!usb_disabled())

		ret = usb_hcd_ep93xx_probe(&ohci_ep93xx_hc_driver, pdev);



	return ret;

}



static int ohci_hcd_ep93xx_drv_remove(struct platform_device *pdev)

{

	struct usb_hcd *hcd = platform_get_drvdata(pdev);



	usb_hcd_ep93xx_remove(hcd, pdev);



	return 0;

}



#ifdef CONFIG_PM

static int ohci_hcd_ep93xx_drv_suspend(struct platform_device *pdev, pm_message_t state)

{

	struct usb_hcd *hcd = platform_get_drvdata(pdev);

	struct ochi_hcd *ohci = hcd_to_ohci(hcd);



	if (time_before(jiffies, ohci->next_statechange))

		msleep(5);

	ohci->next_statechange = jiffies;



	ep93xx_stop_hc(&pdev->dev);

	hcd->state = HC_STATE_SUSPENDED;

	pdev->dev.power.power_state = PMSG_SUSPEND;



	return 0;

}



static int ohci_hcd_ep93xx_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;



	ep93xx_start_hc(&pdev->dev);

	pdev->dev.power.power_state = PMSG_ON;

	usb_hcd_resume_root_hub(hcd);



	return 0;

}

#endif





static struct platform_driver ohci_hcd_ep93xx_driver = {

	.probe		= ohci_hcd_ep93xx_drv_probe,

	.remove		= ohci_hcd_ep93xx_drv_remove,

#ifdef CONFIG_PM

	.suspend	= ohci_hcd_ep93xx_drv_suspend,

	.resume		= ohci_hcd_ep93xx_drv_resume,

#endif

	.driver		= {

		.name	= "ep93xx-ohci",

	},

};



static int __init ohci_hcd_ep93xx_init(void)

{

	return platform_driver_register(&ohci_hcd_ep93xx_driver);

}



static void __exit ohci_hcd_ep93xx_cleanup(void)

{

	platform_driver_unregister(&ohci_hcd_ep93xx_driver);

}



module_init(ohci_hcd_ep93xx_init);

module_exit(ohci_hcd_ep93xx_cleanup);

drivers/usb/host/ohci-hcd.c

+5 −0
Original line number Diff line number Diff line
@@ -901,6 +901,10 @@ MODULE_LICENSE ("GPL"); 
#include "ohci-pxa27x.c"

#endif



#ifdef CONFIG_ARCH_EP93XX

#include "ohci-ep93xx.c"

#endif



#ifdef CONFIG_SOC_AU1X00

#include "ohci-au1xxx.c"

#endif
@@ -919,6 +923,7 @@ MODULE_LICENSE ("GPL"); 
      || defined(CONFIG_ARCH_OMAP) \

      || defined (CONFIG_ARCH_LH7A404) \

      || defined (CONFIG_PXA27x) \

      || defined (CONFIG_ARCH_EP93XX) \

      || defined (CONFIG_SOC_AU1X00) \

      || defined (CONFIG_USB_OHCI_HCD_PPC_SOC) \

      || defined (CONFIG_ARCH_AT91RM9200) \