Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit c8c38de9 authored by Deepak Sikri's avatar Deepak Sikri Committed by Greg Kroah-Hartman
Browse files

USB host: Adding USB ehci & ohci support for spear platform 



This patch adds support for ehci and ohci controller in the SPEAr platform.

Changes since V2:
added clear_tt_buffer_complete in ehci_spear_hc_driver

Signed-off-by: default avatarDeepak Sikri <deepak.sikri@st.com>
Signed-off-by: default avatarViresh Kumar <viresh.kumar@st.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent ad78acaf

drivers/usb/Kconfig

+2 −0
Original line number Diff line number Diff line
@@ -41,6 +41,7 @@ config USB_ARCH_HAS_OHCI 
	default y if MFD_TC6393XB

	default y if ARCH_W90X900

	default y if ARCH_DAVINCI_DA8XX

	default y if PLAT_SPEAR

	# PPC:

	default y if STB03xxx

	default y if PPC_MPC52xx
@@ -67,6 +68,7 @@ config USB_ARCH_HAS_EHCI 
	default y if ARCH_MXC

	default y if ARCH_OMAP3

	default y if ARCH_VT8500

	default y if PLAT_SPEAR

	default PCI



# ARM SA1111 chips have a non-PCI based "OHCI-compatible" USB host interface.

drivers/usb/host/ehci-hcd.c

+5 −0
Original line number Diff line number Diff line
@@ -1221,6 +1221,11 @@ MODULE_LICENSE ("GPL"); 
#define	PLATFORM_DRIVER		vt8500_ehci_driver

#endif



#ifdef CONFIG_PLAT_SPEAR

#include "ehci-spear.c"

#define PLATFORM_DRIVER		spear_ehci_hcd_driver

#endif



#if !defined(PCI_DRIVER) && !defined(PLATFORM_DRIVER) && \

    !defined(PS3_SYSTEM_BUS_DRIVER) && !defined(OF_PLATFORM_DRIVER) && \

    !defined(XILINX_OF_PLATFORM_DRIVER)

drivers/usb/host/ehci-spear.c

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

* Driver for EHCI HCD on SPEAR SOC

*

* Copyright (C) 2010 ST Micro Electronics,

* Deepak Sikri <deepak.sikri@st.com>

*

* Based on various ehci-*.c drivers

*

* This file is subject to the terms and conditions of the GNU General Public

* License. See the file COPYING in the main directory of this archive for

* more details.

*/



#include <linux/platform_device.h>

#include <linux/clk.h>



struct spear_ehci {

	struct ehci_hcd ehci;

	struct clk *clk;

};



#define to_spear_ehci(hcd)	(struct spear_ehci *)hcd_to_ehci(hcd)



static void spear_start_ehci(struct spear_ehci *ehci)

{

	clk_enable(ehci->clk);

}



static void spear_stop_ehci(struct spear_ehci *ehci)

{

	clk_disable(ehci->clk);

}



static int ehci_spear_setup(struct usb_hcd *hcd)

{

	struct ehci_hcd *ehci = hcd_to_ehci(hcd);

	int retval = 0;



	/* registers start at offset 0x0 */

	ehci->caps = hcd->regs;

	ehci->regs = hcd->regs + HC_LENGTH(ehci_readl(ehci,

				&ehci->caps->hc_capbase));

	/* 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;



	retval = ehci_init(hcd);

	if (retval)

		return retval;



	ehci_reset(ehci);

	ehci_port_power(ehci, 0);



	return retval;

}



static const struct hc_driver ehci_spear_hc_driver = {

	.description			= hcd_name,

	.product_desc			= "SPEAr EHCI",

	.hcd_priv_size			= sizeof(struct spear_ehci),



	/* generic hardware linkage */

	.irq				= ehci_irq,

	.flags				= HCD_MEMORY | HCD_USB2,



	/* basic lifecycle operations */

	.reset				= ehci_spear_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,

	.endpoint_reset			= ehci_endpoint_reset,



	/* 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 spear_ehci_hcd_drv_probe(struct platform_device *pdev)

{

	struct usb_hcd *hcd ;

	struct spear_ehci *ehci;

	struct resource *res;

	struct clk *usbh_clk;

	const struct hc_driver *driver = &ehci_spear_hc_driver;

	int *pdata = pdev->dev.platform_data;

	int irq, retval;

	char clk_name[20] = "usbh_clk";



	if (pdata == NULL)

		return -EFAULT;



	if (usb_disabled())

		return -ENODEV;



	irq = platform_get_irq(pdev, 0);

	if (irq < 0) {

		retval = irq;

		goto fail_irq_get;

	}



	if (*pdata >= 0)

		sprintf(clk_name, "usbh.%01d_clk", *pdata);



	usbh_clk = clk_get(NULL, clk_name);

	if (IS_ERR(usbh_clk)) {

		dev_err(&pdev->dev, "Error getting interface clock\n");

		retval = PTR_ERR(usbh_clk);

		goto fail_get_usbh_clk;

	}



	hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));

	if (!hcd) {

		retval = -ENOMEM;

		goto fail_create_hcd;

	}



	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

	if (!res) {

		retval = -ENODEV;

		goto fail_request_resource;

	}



	hcd->rsrc_start = res->start;

	hcd->rsrc_len = resource_size(res);

	if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len,

				driver->description)) {

		retval = -EBUSY;

		goto fail_request_resource;

	}



	hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);

	if (hcd->regs == NULL) {

		dev_dbg(&pdev->dev, "error mapping memory\n");

		retval = -ENOMEM;

		goto fail_ioremap;

	}



	ehci = (struct spear_ehci *)hcd_to_ehci(hcd);

	ehci->clk = usbh_clk;



	spear_start_ehci(ehci);

	retval = usb_add_hcd(hcd, irq, IRQF_SHARED | IRQF_DISABLED);

	if (retval)

		goto fail_add_hcd;



	return retval;



fail_add_hcd:

	spear_stop_ehci(ehci);

	iounmap(hcd->regs);

fail_ioremap:

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

fail_request_resource:

	usb_put_hcd(hcd);

fail_create_hcd:

	clk_put(usbh_clk);

fail_get_usbh_clk:

fail_irq_get:

	dev_err(&pdev->dev, "init fail, %d\n", retval);



	return retval ;

}



static int spear_ehci_hcd_drv_remove(struct platform_device *pdev)

{

	struct usb_hcd *hcd = platform_get_drvdata(pdev);

	struct spear_ehci *ehci_p = to_spear_ehci(hcd);



	if (!hcd)

		return 0;

	if (in_interrupt())

		BUG();

	usb_remove_hcd(hcd);



	if (ehci_p->clk)

		spear_stop_ehci(ehci_p);

	iounmap(hcd->regs);

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

	usb_put_hcd(hcd);



	if (ehci_p->clk)

		clk_put(ehci_p->clk);



	return 0;

}



static struct platform_driver spear_ehci_hcd_driver = {

	.probe		= spear_ehci_hcd_drv_probe,

	.remove		= spear_ehci_hcd_drv_remove,

	.shutdown	= usb_hcd_platform_shutdown,

	.driver		= {

		.name = "spear-ehci",

		.bus = &platform_bus_type

	}

};



MODULE_ALIAS("platform:spear-ehci");

drivers/usb/host/ohci-hcd.c

+5 −0
Original line number Diff line number Diff line
@@ -1081,6 +1081,11 @@ MODULE_LICENSE ("GPL"); 
#define OF_PLATFORM_DRIVER	ohci_hcd_ppc_of_driver

#endif



#ifdef CONFIG_PLAT_SPEAR

#include "ohci-spear.c"

#define PLATFORM_DRIVER		spear_ohci_hcd_driver

#endif



#ifdef CONFIG_PPC_PS3

#include "ohci-ps3.c"

#define PS3_SYSTEM_BUS_DRIVER	ps3_ohci_driver

drivers/usb/host/ohci-spear.c

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

* OHCI HCD (Host Controller Driver) for USB.

*

* Copyright (C) 2010 ST Microelectronics.

* Deepak Sikri<deepak.sikri@st.com>

*

* Based on various ohci-*.c drivers

*

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

#include <linux/platform_device.h>

#include <linux/clk.h>



struct spear_ohci {

	struct ohci_hcd ohci;

	struct clk *clk;

};



#define to_spear_ohci(hcd)	(struct spear_ohci *)hcd_to_ohci(hcd)



static void spear_start_ohci(struct spear_ohci *ohci)

{

	clk_enable(ohci->clk);

}



static void spear_stop_ohci(struct spear_ohci *ohci)

{

	clk_disable(ohci->clk);

}



static int __devinit ohci_spear_start(struct usb_hcd *hcd)

{

	struct ohci_hcd *ohci = hcd_to_ohci(hcd);

	int ret;



	ret = ohci_init(ohci);

	if (ret < 0)

		return ret;

	ohci->regs = hcd->regs;



	ret = ohci_run(ohci);

	if (ret < 0) {

		dev_err(hcd->self.controller, "can't start\n");

		ohci_stop(hcd);

		return ret;

	}



	create_debug_files(ohci);



#ifdef DEBUG

	ohci_dump(ohci, 1);

#endif

	return 0;

}



static const struct hc_driver ohci_spear_hc_driver = {

	.description		= hcd_name,

	.product_desc		= "SPEAr OHCI",

	.hcd_priv_size		= sizeof(struct spear_ohci),



	/* generic hardware linkage */

	.irq			= ohci_irq,

	.flags			= HCD_USB11 | HCD_MEMORY,



	/* basic lifecycle operations */

	.start			= ohci_spear_start,

	.stop			= ohci_stop,

	.shutdown		= ohci_shutdown,

#ifdef	CONFIG_PM

	.bus_suspend		= ohci_bus_suspend,

	.bus_resume		= ohci_bus_resume,

#endif



	/* 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_hub_status_data,

	.hub_control		= ohci_hub_control,



	.start_port_reset	= ohci_start_port_reset,

};



static int spear_ohci_hcd_drv_probe(struct platform_device *pdev)

{

	const struct hc_driver *driver = &ohci_spear_hc_driver;

	struct usb_hcd *hcd = NULL;

	struct clk *usbh_clk;

	struct spear_ohci *ohci_p;

	struct resource *res;

	int retval, irq;

	int *pdata = pdev->dev.platform_data;

	char clk_name[20] = "usbh_clk";



	if (pdata == NULL)

		return -EFAULT;



	irq = platform_get_irq(pdev, 0);

	if (irq < 0) {

		retval = irq;

		goto fail_irq_get;

	}



	if (*pdata >= 0)

		sprintf(clk_name, "usbh.%01d_clk", *pdata);



	usbh_clk = clk_get(NULL, clk_name);

	if (IS_ERR(usbh_clk)) {

		dev_err(&pdev->dev, "Error getting interface clock\n");

		retval = PTR_ERR(usbh_clk);

		goto fail_get_usbh_clk;

	}



	hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));

	if (!hcd) {

		retval = -ENOMEM;

		goto fail_create_hcd;

	}



	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

	if (!res) {

		retval = -ENODEV;

		goto fail_request_resource;

	}



	hcd->rsrc_start = pdev->resource[0].start;

	hcd->rsrc_len = resource_size(res);

	if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {

		dev_dbg(&pdev->dev, "request_mem_region failed\n");

		retval = -EBUSY;

		goto fail_request_resource;

	}



	hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);

	if (!hcd->regs) {

		dev_dbg(&pdev->dev, "ioremap failed\n");

		retval = -ENOMEM;

		goto fail_ioremap;

	}



	ohci_p = (struct spear_ohci *)hcd_to_ohci(hcd);

	ohci_p->clk = usbh_clk;

	spear_start_ohci(ohci_p);

	ohci_hcd_init(hcd_to_ohci(hcd));



	retval = usb_add_hcd(hcd, platform_get_irq(pdev, 0), IRQF_DISABLED);

	if (retval == 0)

		return retval;



	spear_stop_ohci(ohci_p);

	iounmap(hcd->regs);

fail_ioremap:

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

fail_request_resource:

	usb_put_hcd(hcd);

fail_create_hcd:

	clk_put(usbh_clk);

fail_get_usbh_clk:

fail_irq_get:

	dev_err(&pdev->dev, "init fail, %d\n", retval);



	return retval;

}



static int spear_ohci_hcd_drv_remove(struct platform_device *pdev)

{

	struct usb_hcd *hcd = platform_get_drvdata(pdev);

	struct spear_ohci *ohci_p = to_spear_ohci(hcd);



	usb_remove_hcd(hcd);

	if (ohci_p->clk)

		spear_stop_ohci(ohci_p);



	iounmap(hcd->regs);

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

	usb_put_hcd(hcd);



	if (ohci_p->clk)

		clk_put(ohci_p->clk);

	platform_set_drvdata(pdev, NULL);

	return 0;

}



#if defined(CONFIG_PM)

static int spear_ohci_hcd_drv_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);

	struct spear_ohci *ohci_p = to_spear_ohci(hcd);



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

		msleep(5);

	ohci->next_statechange = jiffies;



	spear_stop_ohci(ohci_p);

	ohci_to_hcd(ohci)->state = HC_STATE_SUSPENDED;

	return 0;

}



static int spear_ohci_hcd_drv_resume(struct platform_device *dev)

{

	struct usb_hcd *hcd = platform_get_drvdata(dev);

	struct ohci_hcd	*ohci = hcd_to_ohci(hcd);

	struct spear_ohci *ohci_p = to_spear_ohci(hcd);



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

		msleep(5);

	ohci->next_statechange = jiffies;



	spear_start_ohci(ohci_p);

	ohci_finish_controller_resume(hcd);

	return 0;

}

#endif



/* Driver definition to register with the platform bus */

static struct platform_driver spear_ohci_hcd_driver = {

	.probe =	spear_ohci_hcd_drv_probe,

	.remove =	spear_ohci_hcd_drv_remove,

#ifdef CONFIG_PM

	.suspend =	spear_ohci_hcd_drv_suspend,

	.resume =	spear_ohci_hcd_drv_resume,

#endif

	.driver = {

		.owner = THIS_MODULE,

		.name = "spear-ohci",

	},

};



MODULE_ALIAS("platform:spear-ohci");