[deliverable/linux.git] / drivers / usb / host / ehci-pmcmsp.c

/*
 * PMC MSP EHCI (Host Controller Driver) for USB.
 *
 * (C) Copyright 2006-2010 PMC-Sierra Inc
 *
 * 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.
 *
 */

/* includes */
#include <linux/platform_device.h>
#include <linux/gpio.h>
#include <linux/usb.h>
#include <msp_usb.h>

/* stream disable*/
#define USB_CTRL_MODE_STREAM_DISABLE	0x10

/* threshold */
#define USB_CTRL_FIFO_THRESH		0x00300000

/* register offset for usb_mode */
#define USB_EHCI_REG_USB_MODE		0x68

/* register offset for usb fifo */
#define USB_EHCI_REG_USB_FIFO		0x24

/* register offset for usb status */
#define USB_EHCI_REG_USB_STATUS		0x44

/* serial/parallel transceiver */
#define USB_EHCI_REG_BIT_STAT_STS	(1<<29)

/* TWI USB0 host device pin */
#define MSP_PIN_USB0_HOST_DEV		49

/* TWI USB1 host device pin */
#define MSP_PIN_USB1_HOST_DEV		50


static void usb_hcd_tdi_set_mode(struct ehci_hcd *ehci)
{
	u8 *base;
	u8 *statreg;
	u8 *fiforeg;
	u32 val;
	struct ehci_regs *reg_base = ehci->regs;

	/* get register base */
	base = (u8 *)reg_base + USB_EHCI_REG_USB_MODE;
	statreg = (u8 *)reg_base + USB_EHCI_REG_USB_STATUS;
	fiforeg = (u8 *)reg_base + USB_EHCI_REG_USB_FIFO;

	/* Disable controller mode stream */
	val = ehci_readl(ehci, (u32 *)base);
	ehci_writel(ehci, (val | USB_CTRL_MODE_STREAM_DISABLE),
			(u32 *)base);

	/* clear STS to select parallel transceiver interface */
	val = ehci_readl(ehci, (u32 *)statreg);
	val = val & ~USB_EHCI_REG_BIT_STAT_STS;
	ehci_writel(ehci, val, (u32 *)statreg);

	/* write to set the proper fifo threshold */
	ehci_writel(ehci, USB_CTRL_FIFO_THRESH, (u32 *)fiforeg);

	/* set TWI GPIO USB_HOST_DEV pin high */
	gpio_direction_output(MSP_PIN_USB0_HOST_DEV, 1);
#ifdef CONFIG_MSP_HAS_DUAL_USB
	gpio_direction_output(MSP_PIN_USB1_HOST_DEV, 1);
#endif
}

/* called during probe() after chip reset completes */
static int ehci_msp_setup(struct usb_hcd *hcd)
{
	struct ehci_hcd		*ehci = hcd_to_ehci(hcd);
	int			retval;

	ehci->big_endian_mmio = 1;
	ehci->big_endian_desc = 1;

	ehci->caps = hcd->regs;
	hcd->has_tt = 1;

	retval = ehci_setup(hcd);
	if (retval)
		return retval;

	usb_hcd_tdi_set_mode(ehci);

	return retval;
}


/* configure so an HC device and id are always provided
 * always called with process context; sleeping is OK
 */

static int usb_hcd_msp_map_regs(struct mspusb_device *dev)
{
	struct resource *res;
	struct platform_device *pdev = &dev->dev;
	u32 res_len;
	int retval;

	/* MAB register space */
	res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
	if (res == NULL)
		return -ENOMEM;
	res_len = resource_size(res);
	if (!request_mem_region(res->start, res_len, "mab regs"))
		return -EBUSY;

	dev->mab_regs = ioremap_nocache(res->start, res_len);
	if (dev->mab_regs == NULL) {
		retval = -ENOMEM;
		goto err1;
	}

	/* MSP USB register space */
	res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
	if (res == NULL) {
		retval = -ENOMEM;
		goto err2;
	}
	res_len = resource_size(res);
	if (!request_mem_region(res->start, res_len, "usbid regs")) {
		retval = -EBUSY;
		goto err2;
	}
	dev->usbid_regs = ioremap_nocache(res->start, res_len);
	if (dev->usbid_regs == NULL) {
		retval = -ENOMEM;
		goto err3;
	}

	return 0;
err3:
	res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
	res_len = resource_size(res);
	release_mem_region(res->start, res_len);
err2:
	iounmap(dev->mab_regs);
err1:
	res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
	res_len = resource_size(res);
	release_mem_region(res->start, res_len);
	dev_err(&pdev->dev, "Failed to map non-EHCI regs.\n");
	return retval;
}

/**
 * usb_hcd_msp_probe - initialize PMC MSP-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.
 *
 */
int usb_hcd_msp_probe(const struct hc_driver *driver,
			  struct platform_device *dev)
{
	int retval;
	struct usb_hcd *hcd;
	struct resource *res;
	struct ehci_hcd		*ehci ;

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

	res = platform_get_resource(dev, IORESOURCE_MEM, 0);
	if (res == NULL) {
		pr_debug("No IOMEM resource info for %s.\n", dev->name);
		retval = -ENOMEM;
		goto err1;
	}
	hcd->rsrc_start = res->start;
	hcd->rsrc_len = resource_size(res);
	if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, dev->name)) {
		retval = -EBUSY;
		goto err1;
	}
	hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len);
	if (!hcd->regs) {
		pr_debug("ioremap failed");
		retval = -ENOMEM;
		goto err2;
	}

	res = platform_get_resource(dev, IORESOURCE_IRQ, 0);
	if (res == NULL) {
		dev_err(&dev->dev, "No IRQ resource info for %s.\n", dev->name);
		retval = -ENOMEM;
		goto err3;
	}

	/* Map non-EHCI register spaces */
	retval = usb_hcd_msp_map_regs(to_mspusb_device(dev));
	if (retval != 0)
		goto err3;

	ehci = hcd_to_ehci(hcd);
	ehci->big_endian_mmio = 1;
	ehci->big_endian_desc = 1;


	retval = usb_add_hcd(hcd, res->start, IRQF_SHARED);
	if (retval == 0)
		return 0;

	usb_remove_hcd(hcd);
err3:
	iounmap(hcd->regs);
err2:
	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
err1:
	usb_put_hcd(hcd);

	return retval;
}


/**
 * usb_hcd_msp_remove - shutdown processing for PMC MSP-based HCDs
 * @dev: USB Host Controller being removed
 * Context: !in_interrupt()
 *
 * Reverses the effect of usb_hcd_msp_probe(), first invoking
 * the HCD's stop() method.  It is always called from a thread
 * context, normally "rmmod", "apmd", or something similar.
 *
 * may be called without controller electrically present
 * may be called with controller, bus, and devices active
 */
void usb_hcd_msp_remove(struct usb_hcd *hcd, struct platform_device *dev)
{
	usb_remove_hcd(hcd);
	iounmap(hcd->regs);
	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
	usb_put_hcd(hcd);
}

#ifdef CONFIG_MSP_HAS_DUAL_USB
/*
 * Wrapper around the main ehci_irq.  Since both USB host controllers are
 * sharing the same IRQ, need to first determine whether we're the intended
 * recipient of this interrupt.
 */
static irqreturn_t ehci_msp_irq(struct usb_hcd *hcd)
{
	u32 int_src;
	struct device *dev = hcd->self.controller;
	struct platform_device *pdev;
	struct mspusb_device *mdev;
	struct ehci_hcd	*ehci = hcd_to_ehci(hcd);
	/* need to reverse-map a couple of containers to get our device */
	pdev = to_platform_device(dev);
	mdev = to_mspusb_device(pdev);

	/* Check to see if this interrupt is for this host controller */
	int_src = ehci_readl(ehci, &mdev->mab_regs->int_stat);
	if (int_src & (1 << pdev->id))
		return ehci_irq(hcd);

	/* Not for this device */
	return IRQ_NONE;
}
#endif /* DUAL_USB */

static const struct hc_driver ehci_msp_hc_driver = {
	.description =		hcd_name,
	.product_desc =		"PMC MSP EHCI",
	.hcd_priv_size =	sizeof(struct ehci_hcd),

	/*
	 * generic hardware linkage
	 */
#ifdef CONFIG_MSP_HAS_DUAL_USB
	.irq =			ehci_msp_irq,
#else
	.irq =			ehci_irq,
#endif
	.flags =		HCD_MEMORY | HCD_USB2,

	/*
	 * basic lifecycle operations
	 */
	.reset =		ehci_msp_setup,
	.start =		ehci_run,
	.shutdown		= ehci_shutdown,
	.start			= ehci_run,
	.stop			= ehci_stop,

	/*
	 * 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 ehci_hcd_msp_drv_probe(struct platform_device *pdev)
{
	int ret;

	pr_debug("In ehci_hcd_msp_drv_probe");

	if (usb_disabled())
		return -ENODEV;

	gpio_request(MSP_PIN_USB0_HOST_DEV, "USB0_HOST_DEV_GPIO");
#ifdef CONFIG_MSP_HAS_DUAL_USB
	gpio_request(MSP_PIN_USB1_HOST_DEV, "USB1_HOST_DEV_GPIO");
#endif

	ret = usb_hcd_msp_probe(&ehci_msp_hc_driver, pdev);

	return ret;
}

static int ehci_hcd_msp_drv_remove(struct platform_device *pdev)
{
	struct usb_hcd *hcd = platform_get_drvdata(pdev);

	usb_hcd_msp_remove(hcd, pdev);

	/* free TWI GPIO USB_HOST_DEV pin */
	gpio_free(MSP_PIN_USB0_HOST_DEV);
#ifdef CONFIG_MSP_HAS_DUAL_USB
	gpio_free(MSP_PIN_USB1_HOST_DEV);
#endif

	return 0;
}

MODULE_ALIAS("pmcmsp-ehci");

static struct platform_driver ehci_hcd_msp_driver = {
	.probe		= ehci_hcd_msp_drv_probe,
	.remove		= ehci_hcd_msp_drv_remove,
	.driver		= {
		.name	= "pmcmsp-ehci",
		.owner	= THIS_MODULE,
	},
};
Commit	Line	Data
22ced687 A	1	/*
	2	* PMC MSP EHCI (Host Controller Driver) for USB.
	3	*
	4	* (C) Copyright 2006-2010 PMC-Sierra Inc
	5	*
	6	* This file is subject to the terms and conditions of the GNU General Public
	7	* License. See the file "COPYING" in the main directory of this archive
	8	* for more details.
	9	*
	10	*/
	11
	12	/* includes */
	13	#include <linux/platform_device.h>
	14	#include <linux/gpio.h>
	15	#include <linux/usb.h>
	16	#include <msp_usb.h>
	17
	18	/* stream disable*/
	19	#define USB_CTRL_MODE_STREAM_DISABLE 0x10
	20
	21	/* threshold */
	22	#define USB_CTRL_FIFO_THRESH 0x00300000
	23
	24	/* register offset for usb_mode */
	25	#define USB_EHCI_REG_USB_MODE 0x68
	26
	27	/* register offset for usb fifo */
	28	#define USB_EHCI_REG_USB_FIFO 0x24
	29
	30	/* register offset for usb status */
	31	#define USB_EHCI_REG_USB_STATUS 0x44
	32
	33	/* serial/parallel transceiver */
	34	#define USB_EHCI_REG_BIT_STAT_STS (1<<29)
	35
	36	/* TWI USB0 host device pin */
	37	#define MSP_PIN_USB0_HOST_DEV 49
	38
	39	/* TWI USB1 host device pin */
	40	#define MSP_PIN_USB1_HOST_DEV 50
	41
	42
	43	static void usb_hcd_tdi_set_mode(struct ehci_hcd *ehci)
	44	{
	45	u8 *base;
	46	u8 *statreg;
	47	u8 *fiforeg;
	48	u32 val;
	49	struct ehci_regs *reg_base = ehci->regs;
	50
	51	/* get register base */
	52	base = (u8 *)reg_base + USB_EHCI_REG_USB_MODE;
	53	statreg = (u8 *)reg_base + USB_EHCI_REG_USB_STATUS;
	54	fiforeg = (u8 *)reg_base + USB_EHCI_REG_USB_FIFO;
	55
	56	/* Disable controller mode stream */
	57	val = ehci_readl(ehci, (u32 *)base);
	58	ehci_writel(ehci, (val \| USB_CTRL_MODE_STREAM_DISABLE),
	59	(u32 *)base);
	60
	61	/* clear STS to select parallel transceiver interface */
	62	val = ehci_readl(ehci, (u32 *)statreg);
	63	val = val & ~USB_EHCI_REG_BIT_STAT_STS;
	64	ehci_writel(ehci, val, (u32 *)statreg);
65
66	/* write to set the proper fifo threshold */
67	ehci_writel(ehci, USB_CTRL_FIFO_THRESH, (u32 *)fiforeg);
68
69	/* set TWI GPIO USB_HOST_DEV pin high */
70	gpio_direction_output(MSP_PIN_USB0_HOST_DEV, 1);
71	#ifdef CONFIG_MSP_HAS_DUAL_USB
72	gpio_direction_output(MSP_PIN_USB1_HOST_DEV, 1);
73	#endif
74	}
75
76	/* called during probe() after chip reset completes */
77	static int ehci_msp_setup(struct usb_hcd *hcd)
78	{
79	struct ehci_hcd *ehci = hcd_to_ehci(hcd);
80	int retval;
1a49e2ac	81
22ced687 A	82	ehci->big_endian_mmio = 1;
	83	ehci->big_endian_desc = 1;
	84
	85	ehci->caps = hcd->regs;
22ced687 A	86	hcd->has_tt = 1;
22ced687 A	87
1a49e2ac	88	retval = ehci_setup(hcd);
22ced687 A	89	if (retval)
	90	return retval;
	91
	92	usb_hcd_tdi_set_mode(ehci);
22ced687 A	93
	94	return retval;
	95	}
	96
	97
	98	/* configure so an HC device and id are always provided
	99	* always called with process context; sleeping is OK
	100	*/
	101
	102	static int usb_hcd_msp_map_regs(struct mspusb_device *dev)
	103	{
	104	struct resource *res;
	105	struct platform_device *pdev = &dev->dev;
	106	u32 res_len;
	107	int retval;
	108
	109	/* MAB register space */
	110	res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
	111	if (res == NULL)
	112	return -ENOMEM;
28f65c11	113	res_len = resource_size(res);
22ced687 A	114	if (!request_mem_region(res->start, res_len, "mab regs"))
	115	return -EBUSY;
	116
	117	dev->mab_regs = ioremap_nocache(res->start, res_len);
	118	if (dev->mab_regs == NULL) {
	119	retval = -ENOMEM;
	120	goto err1;
	121	}
	122
	123	/* MSP USB register space */
	124	res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
	125	if (res == NULL) {
	126	retval = -ENOMEM;
	127	goto err2;
	128	}
28f65c11	129	res_len = resource_size(res);
22ced687 A	130	if (!request_mem_region(res->start, res_len, "usbid regs")) {
	131	retval = -EBUSY;
	132	goto err2;
	133	}
	134	dev->usbid_regs = ioremap_nocache(res->start, res_len);
	135	if (dev->usbid_regs == NULL) {
	136	retval = -ENOMEM;
	137	goto err3;
	138	}
	139
	140	return 0;
	141	err3:
	142	res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
28f65c11	143	res_len = resource_size(res);
22ced687 A	144	release_mem_region(res->start, res_len);
	145	err2:
	146	iounmap(dev->mab_regs);
	147	err1:
	148	res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
28f65c11	149	res_len = resource_size(res);
22ced687 A	150	release_mem_region(res->start, res_len);
	151	dev_err(&pdev->dev, "Failed to map non-EHCI regs.\n");
	152	return retval;
	153	}
	154
	155	/**
	156	* usb_hcd_msp_probe - initialize PMC MSP-based HCDs
	157	* Context: !in_interrupt()
	158	*
	159	* Allocates basic resources for this USB host controller, and
	160	* then invokes the start() method for the HCD associated with it
	161	* through the hotplug entry's driver_data.
	162	*
	163	*/
	164	int usb_hcd_msp_probe(const struct hc_driver *driver,
	165	struct platform_device *dev)
	166	{
	167	int retval;
	168	struct usb_hcd *hcd;
	169	struct resource *res;
	170	struct ehci_hcd *ehci ;
	171
	172	hcd = usb_create_hcd(driver, &dev->dev, "pmcmsp");
	173	if (!hcd)
	174	return -ENOMEM;
	175
	176	res = platform_get_resource(dev, IORESOURCE_MEM, 0);
	177	if (res == NULL) {
	178	pr_debug("No IOMEM resource info for %s.\n", dev->name);
	179	retval = -ENOMEM;
	180	goto err1;
	181	}
	182	hcd->rsrc_start = res->start;
28f65c11	183	hcd->rsrc_len = resource_size(res);
22ced687 A	184	if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, dev->name)) {
	185	retval = -EBUSY;
	186	goto err1;
	187	}
	188	hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len);
	189	if (!hcd->regs) {
	190	pr_debug("ioremap failed");
	191	retval = -ENOMEM;
	192	goto err2;
	193	}
	194
	195	res = platform_get_resource(dev, IORESOURCE_IRQ, 0);
	196	if (res == NULL) {
	197	dev_err(&dev->dev, "No IRQ resource info for %s.\n", dev->name);
	198	retval = -ENOMEM;
	199	goto err3;
	200	}
	201
	202	/* Map non-EHCI register spaces */
	203	retval = usb_hcd_msp_map_regs(to_mspusb_device(dev));
	204	if (retval != 0)
	205	goto err3;
	206
	207	ehci = hcd_to_ehci(hcd);
	208	ehci->big_endian_mmio = 1;
	209	ehci->big_endian_desc = 1;
	210
	211
	212	retval = usb_add_hcd(hcd, res->start, IRQF_SHARED);
	213	if (retval == 0)
	214	return 0;
	215
	216	usb_remove_hcd(hcd);
	217	err3:
	218	iounmap(hcd->regs);
	219	err2:
	220	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
	221	err1:
	222	usb_put_hcd(hcd);
	223
	224	return retval;
	225	}
	226
	227
	228
	229	/**
	230	* usb_hcd_msp_remove - shutdown processing for PMC MSP-based HCDs
	231	* @dev: USB Host Controller being removed
	232	* Context: !in_interrupt()
	233	*
	234	* Reverses the effect of usb_hcd_msp_probe(), first invoking
	235	* the HCD's stop() method. It is always called from a thread
	236	* context, normally "rmmod", "apmd", or something similar.
	237	*
	238	* may be called without controller electrically present
	239	* may be called with controller, bus, and devices active
	240	*/
	241	void usb_hcd_msp_remove(struct usb_hcd hcd, struct platform_device dev)
	242	{
	243	usb_remove_hcd(hcd);
	244	iounmap(hcd->regs);
	245	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
	246	usb_put_hcd(hcd);
	247	}
248
249	#ifdef CONFIG_MSP_HAS_DUAL_USB
250	/*
251	* Wrapper around the main ehci_irq. Since both USB host controllers are
252	* sharing the same IRQ, need to first determine whether we're the intended
253	* recipient of this interrupt.
254	*/
255	static irqreturn_t ehci_msp_irq(struct usb_hcd *hcd)
256	{
257	u32 int_src;
258	struct device *dev = hcd->self.controller;
259	struct platform_device *pdev;
260	struct mspusb_device *mdev;
261	struct ehci_hcd *ehci = hcd_to_ehci(hcd);
262	/* need to reverse-map a couple of containers to get our device */
263	pdev = to_platform_device(dev);
264	mdev = to_mspusb_device(pdev);
265
266	/* Check to see if this interrupt is for this host controller */
267	int_src = ehci_readl(ehci, &mdev->mab_regs->int_stat);
268	if (int_src & (1 << pdev->id))
269	return ehci_irq(hcd);
270
271	/* Not for this device */
272	return IRQ_NONE;
273	}
274	#endif /* DUAL_USB */
275
276	static const struct hc_driver ehci_msp_hc_driver = {
277	.description = hcd_name,
278	.product_desc = "PMC MSP EHCI",
279	.hcd_priv_size = sizeof(struct ehci_hcd),
280
281	/*
282	* generic hardware linkage
283	*/
284	#ifdef CONFIG_MSP_HAS_DUAL_USB
285	.irq = ehci_msp_irq,
286	#else
287	.irq = ehci_irq,
288	#endif
289	.flags = HCD_MEMORY \| HCD_USB2,
290
291	/*
292	* basic lifecycle operations
293	*/
294	.reset = ehci_msp_setup,
295	.start = ehci_run,
296	.shutdown = ehci_shutdown,
297	.start = ehci_run,
298	.stop = ehci_stop,
299
300	/*
301	* managing i/o requests and associated device resources
302	*/
303	.urb_enqueue = ehci_urb_enqueue,
304	.urb_dequeue = ehci_urb_dequeue,
305	.endpoint_disable = ehci_endpoint_disable,
306	.endpoint_reset = ehci_endpoint_reset,
307
308	/*
309	* scheduling support
310	*/
311	.get_frame_number = ehci_get_frame,
312
313	/*
314	* root hub support
315	*/
316	.hub_status_data = ehci_hub_status_data,
317	.hub_control = ehci_hub_control,
318	.bus_suspend = ehci_bus_suspend,
319	.bus_resume = ehci_bus_resume,
320	.relinquish_port = ehci_relinquish_port,
321	.port_handed_over = ehci_port_handed_over,
322
323	.clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
324	};
325
326	static int ehci_hcd_msp_drv_probe(struct platform_device *pdev)
327	{
328	int ret;
329
330	pr_debug("In ehci_hcd_msp_drv_probe");
331
332	if (usb_disabled())
333	return -ENODEV;
334
335	gpio_request(MSP_PIN_USB0_HOST_DEV, "USB0_HOST_DEV_GPIO");
336	#ifdef CONFIG_MSP_HAS_DUAL_USB
337	gpio_request(MSP_PIN_USB1_HOST_DEV, "USB1_HOST_DEV_GPIO");
338	#endif
339
340	ret = usb_hcd_msp_probe(&ehci_msp_hc_driver, pdev);
341
342	return ret;
343	}
344
345	static int ehci_hcd_msp_drv_remove(struct platform_device *pdev)
346	{
347	struct usb_hcd *hcd = platform_get_drvdata(pdev);
348
349	usb_hcd_msp_remove(hcd, pdev);
350
351	/* free TWI GPIO USB_HOST_DEV pin */
352	gpio_free(MSP_PIN_USB0_HOST_DEV);
353	#ifdef CONFIG_MSP_HAS_DUAL_USB
354	gpio_free(MSP_PIN_USB1_HOST_DEV);
355	#endif
356
357	return 0;
358	}
359
360	MODULE_ALIAS("pmcmsp-ehci");
361
362	static struct platform_driver ehci_hcd_msp_driver = {
363	.probe = ehci_hcd_msp_drv_probe,
364	.remove = ehci_hcd_msp_drv_remove,
365	.driver = {
366	.name = "pmcmsp-ehci",
367	.owner = THIS_MODULE,
368	},
369	};