[linux-2.6-block.git] / drivers / usb / host / ehci-orion.c

/*
 * drivers/usb/host/ehci-orion.c
 *
 * Tzachi Perelstein <tzachi@marvell.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/kernel.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/mbus.h>
#include <linux/clk.h>
#include <linux/platform_data/usb-ehci-orion.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/of_irq.h>

#define rdl(off)	__raw_readl(hcd->regs + (off))
#define wrl(off, val)	__raw_writel((val), hcd->regs + (off))

#define USB_CMD			0x140
#define USB_MODE		0x1a8
#define USB_CAUSE		0x310
#define USB_MASK		0x314
#define USB_WINDOW_CTRL(i)	(0x320 + ((i) << 4))
#define USB_WINDOW_BASE(i)	(0x324 + ((i) << 4))
#define USB_IPG			0x360
#define USB_PHY_PWR_CTRL	0x400
#define USB_PHY_TX_CTRL		0x420
#define USB_PHY_RX_CTRL		0x430
#define USB_PHY_IVREF_CTRL	0x440
#define USB_PHY_TST_GRP_CTRL	0x450

/*
 * Implement Orion USB controller specification guidelines
 */
static void orion_usb_phy_v1_setup(struct usb_hcd *hcd)
{
	/* The below GLs are according to the Orion Errata document */
	/*
	 * Clear interrupt cause and mask
	 */
	wrl(USB_CAUSE, 0);
	wrl(USB_MASK, 0);

	/*
	 * Reset controller
	 */
	wrl(USB_CMD, rdl(USB_CMD) | 0x2);
	while (rdl(USB_CMD) & 0x2);

	/*
	 * GL# USB-10: Set IPG for non start of frame packets
	 * Bits[14:8]=0xc
	 */
	wrl(USB_IPG, (rdl(USB_IPG) & ~0x7f00) | 0xc00);

	/*
	 * GL# USB-9: USB 2.0 Power Control
	 * BG_VSEL[7:6]=0x1
	 */
	wrl(USB_PHY_PWR_CTRL, (rdl(USB_PHY_PWR_CTRL) & ~0xc0)| 0x40);

	/*
	 * GL# USB-1: USB PHY Tx Control - force calibration to '8'
	 * TXDATA_BLOCK_EN[21]=0x1, EXT_RCAL_EN[13]=0x1, IMP_CAL[6:3]=0x8
	 */
	wrl(USB_PHY_TX_CTRL, (rdl(USB_PHY_TX_CTRL) & ~0x78) | 0x202040);

	/*
	 * GL# USB-3 GL# USB-9: USB PHY Rx Control
	 * RXDATA_BLOCK_LENGHT[31:30]=0x3, EDGE_DET_SEL[27:26]=0,
	 * CDR_FASTLOCK_EN[21]=0, DISCON_THRESHOLD[9:8]=0, SQ_THRESH[7:4]=0x1
	 */
	wrl(USB_PHY_RX_CTRL, (rdl(USB_PHY_RX_CTRL) & ~0xc2003f0) | 0xc0000010);

	/*
	 * GL# USB-3 GL# USB-9: USB PHY IVREF Control
	 * PLLVDD12[1:0]=0x2, RXVDD[5:4]=0x3, Reserved[19]=0
	 */
	wrl(USB_PHY_IVREF_CTRL, (rdl(USB_PHY_IVREF_CTRL) & ~0x80003 ) | 0x32);

	/*
	 * GL# USB-3 GL# USB-9: USB PHY Test Group Control
	 * REG_FIFO_SQ_RST[15]=0
	 */
	wrl(USB_PHY_TST_GRP_CTRL, rdl(USB_PHY_TST_GRP_CTRL) & ~0x8000);

	/*
	 * Stop and reset controller
	 */
	wrl(USB_CMD, rdl(USB_CMD) & ~0x1);
	wrl(USB_CMD, rdl(USB_CMD) | 0x2);
	while (rdl(USB_CMD) & 0x2);

	/*
	 * GL# USB-5 Streaming disable REG_USB_MODE[4]=1
	 * TBD: This need to be done after each reset!
	 * GL# USB-4 Setup USB Host mode
	 */
	wrl(USB_MODE, 0x13);
}

static const struct hc_driver ehci_orion_hc_driver = {
	.description = hcd_name,
	.product_desc = "Marvell Orion EHCI",
	.hcd_priv_size = sizeof(struct ehci_hcd),

	/*
	 * generic hardware linkage
	 */
	.irq = ehci_irq,
	.flags = HCD_MEMORY | HCD_USB2,

	/*
	 * basic lifecycle operations
	 */
	.reset = ehci_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 void
ehci_orion_conf_mbus_windows(struct usb_hcd *hcd,
			     const struct mbus_dram_target_info *dram)
{
	int i;

	for (i = 0; i < 4; i++) {
		wrl(USB_WINDOW_CTRL(i), 0);
		wrl(USB_WINDOW_BASE(i), 0);
	}

	for (i = 0; i < dram->num_cs; i++) {
		const struct mbus_dram_window *cs = dram->cs + i;

		wrl(USB_WINDOW_CTRL(i), ((cs->size - 1) & 0xffff0000) |
					(cs->mbus_attr << 8) |
					(dram->mbus_dram_target_id << 4) | 1);
		wrl(USB_WINDOW_BASE(i), cs->base);
	}
}

static u64 ehci_orion_dma_mask = DMA_BIT_MASK(32);

static int ehci_orion_drv_probe(struct platform_device *pdev)
{
	struct orion_ehci_data *pd = pdev->dev.platform_data;
	const struct mbus_dram_target_info *dram;
	struct resource *res;
	struct usb_hcd *hcd;
	struct ehci_hcd *ehci;
	struct clk *clk;
	void __iomem *regs;
	int irq, err;
	enum orion_ehci_phy_ver phy_version;

	if (usb_disabled())
		return -ENODEV;

	pr_debug("Initializing Orion-SoC USB Host Controller\n");

	if (pdev->dev.of_node)
		irq = irq_of_parse_and_map(pdev->dev.of_node, 0);
	else
		irq = platform_get_irq(pdev, 0);
	if (irq <= 0) {
		dev_err(&pdev->dev,
			"Found HC with no IRQ. Check %s setup!\n",
			dev_name(&pdev->dev));
		err = -ENODEV;
		goto err1;
	}

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!res) {
		dev_err(&pdev->dev,
			"Found HC with no register addr. Check %s setup!\n",
			dev_name(&pdev->dev));
		err = -ENODEV;
		goto err1;
	}

	/*
	 * Right now device-tree probed devices don't get dma_mask
	 * set. Since shared usb code relies on it, set it here for
	 * now. Once we have dma capability bindings this can go away.
	 */
	if (!pdev->dev.dma_mask)
		pdev->dev.dma_mask = &ehci_orion_dma_mask;

	if (!request_mem_region(res->start, resource_size(res),
				ehci_orion_hc_driver.description)) {
		dev_dbg(&pdev->dev, "controller already in use\n");
		err = -EBUSY;
		goto err1;
	}

	regs = ioremap(res->start, resource_size(res));
	if (regs == NULL) {
		dev_dbg(&pdev->dev, "error mapping memory\n");
		err = -EFAULT;
		goto err2;
	}

	/* Not all platforms can gate the clock, so it is not
	   an error if the clock does not exists. */
	clk = clk_get(&pdev->dev, NULL);
	if (!IS_ERR(clk)) {
		clk_prepare_enable(clk);
		clk_put(clk);
	}

	hcd = usb_create_hcd(&ehci_orion_hc_driver,
			&pdev->dev, dev_name(&pdev->dev));
	if (!hcd) {
		err = -ENOMEM;
		goto err3;
	}

	hcd->rsrc_start = res->start;
	hcd->rsrc_len = resource_size(res);
	hcd->regs = regs;

	ehci = hcd_to_ehci(hcd);
	ehci->caps = hcd->regs + 0x100;
	hcd->has_tt = 1;

	/*
	 * (Re-)program MBUS remapping windows if we are asked to.
	 */
	dram = mv_mbus_dram_info();
	if (dram)
		ehci_orion_conf_mbus_windows(hcd, dram);

	/*
	 * setup Orion USB controller.
	 */
	if (pdev->dev.of_node)
		phy_version = EHCI_PHY_NA;
	else
		phy_version = pd->phy_version;

	switch (phy_version) {
	case EHCI_PHY_NA:	/* dont change USB phy settings */
		break;
	case EHCI_PHY_ORION:
		orion_usb_phy_v1_setup(hcd);
		break;
	case EHCI_PHY_DD:
	case EHCI_PHY_KW:
	default:
		printk(KERN_WARNING "Orion ehci -USB phy version isn't supported.\n");
	}

	err = usb_add_hcd(hcd, irq, IRQF_SHARED);
	if (err)
		goto err4;

	return 0;

err4:
	usb_put_hcd(hcd);
err3:
	if (!IS_ERR(clk)) {
		clk_disable_unprepare(clk);
		clk_put(clk);
	}
	iounmap(regs);
err2:
	release_mem_region(res->start, resource_size(res));
err1:
	dev_err(&pdev->dev, "init %s fail, %d\n",
		dev_name(&pdev->dev), err);

	return err;
}

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

	usb_remove_hcd(hcd);
	iounmap(hcd->regs);
	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
	usb_put_hcd(hcd);

	clk = clk_get(&pdev->dev, NULL);
	if (!IS_ERR(clk)) {
		clk_disable_unprepare(clk);
		clk_put(clk);
	}
	return 0;
}

MODULE_ALIAS("platform:orion-ehci");

static const struct of_device_id ehci_orion_dt_ids[] = {
	{ .compatible = "marvell,orion-ehci", },
	{},
};
MODULE_DEVICE_TABLE(of, ehci_orion_dt_ids);

static struct platform_driver ehci_orion_driver = {
	.probe		= ehci_orion_drv_probe,
	.remove		= ehci_orion_drv_remove,
	.shutdown	= usb_hcd_platform_shutdown,
	.driver = {
		.name	= "orion-ehci",
		.owner  = THIS_MODULE,
		.of_match_table = of_match_ptr(ehci_orion_dt_ids),
	},
};
Commit	Line	Data
e96ffe2f TP	1	/*
	2	* drivers/usb/host/ehci-orion.c
	3	*
	4	* Tzachi Perelstein <tzachi@marvell.com>
	5	*
	6	* This file is licensed under the terms of the GNU General Public
	7	* License version 2. This program is licensed "as is" without any
	8	* warranty of any kind, whether express or implied.
	9	*/
	10
	11	#include <linux/kernel.h>
	12	#include <linux/module.h>
	13	#include <linux/platform_device.h>
92aecfa9	14	#include <linux/mbus.h>
8c869eda	15	#include <linux/clk.h>
c02cecb9	16	#include <linux/platform_data/usb-ehci-orion.h>
77dae54a AL	17	#include <linux/of.h>
	18	#include <linux/of_device.h>
	19	#include <linux/of_irq.h>
e96ffe2f TP	20
	21	#define rdl(off) __raw_readl(hcd->regs + (off))
	22	#define wrl(off, val) __raw_writel((val), hcd->regs + (off))
	23
e96ffe2f TP	24	#define USB_CMD 0x140
e96ffe2f TP	25	#define USB_MODE 0x1a8
92aecfa9 LB	26	#define USB_CAUSE 0x310
	27	#define USB_MASK 0x314
	28	#define USB_WINDOW_CTRL(i) (0x320 + ((i) << 4))
	29	#define USB_WINDOW_BASE(i) (0x324 + ((i) << 4))
e96ffe2f TP	30	#define USB_IPG 0x360
	31	#define USB_PHY_PWR_CTRL 0x400
	32	#define USB_PHY_TX_CTRL 0x420
	33	#define USB_PHY_RX_CTRL 0x430
	34	#define USB_PHY_IVREF_CTRL 0x440
	35	#define USB_PHY_TST_GRP_CTRL 0x450
	36
	37	/*
	38	* Implement Orion USB controller specification guidelines
	39	*/
fb6f5529	40	static void orion_usb_phy_v1_setup(struct usb_hcd *hcd)
e96ffe2f	41	{
fb6f5529	42	/* The below GLs are according to the Orion Errata document */
e96ffe2f TP	43	/*
	44	* Clear interrupt cause and mask
	45	*/
	46	wrl(USB_CAUSE, 0);
	47	wrl(USB_MASK, 0);
	48
	49	/*
	50	* Reset controller
	51	*/
	52	wrl(USB_CMD, rdl(USB_CMD) \| 0x2);
	53	while (rdl(USB_CMD) & 0x2);
	54
	55	/*
	56	* GL# USB-10: Set IPG for non start of frame packets
	57	* Bits[14:8]=0xc
	58	*/
	59	wrl(USB_IPG, (rdl(USB_IPG) & ~0x7f00) \| 0xc00);
	60
	61	/*
	62	* GL# USB-9: USB 2.0 Power Control
	63	* BG_VSEL[7:6]=0x1
	64	*/
	65	wrl(USB_PHY_PWR_CTRL, (rdl(USB_PHY_PWR_CTRL) & ~0xc0)\| 0x40);
	66
	67	/*
	68	* GL# USB-1: USB PHY Tx Control - force calibration to '8'
	69	* TXDATA_BLOCK_EN[21]=0x1, EXT_RCAL_EN[13]=0x1, IMP_CAL[6:3]=0x8
	70	*/
	71	wrl(USB_PHY_TX_CTRL, (rdl(USB_PHY_TX_CTRL) & ~0x78) \| 0x202040);
	72
	73	/*
	74	* GL# USB-3 GL# USB-9: USB PHY Rx Control
	75	* RXDATA_BLOCK_LENGHT[31:30]=0x3, EDGE_DET_SEL[27:26]=0,
	76	* CDR_FASTLOCK_EN[21]=0, DISCON_THRESHOLD[9:8]=0, SQ_THRESH[7:4]=0x1
	77	*/
	78	wrl(USB_PHY_RX_CTRL, (rdl(USB_PHY_RX_CTRL) & ~0xc2003f0) \| 0xc0000010);
	79
	80	/*
	81	* GL# USB-3 GL# USB-9: USB PHY IVREF Control
	82	* PLLVDD12[1:0]=0x2, RXVDD[5:4]=0x3, Reserved[19]=0
	83	*/
	84	wrl(USB_PHY_IVREF_CTRL, (rdl(USB_PHY_IVREF_CTRL) & ~0x80003 ) \| 0x32);
	85
	86	/*
	87	* GL# USB-3 GL# USB-9: USB PHY Test Group Control
	88	* REG_FIFO_SQ_RST[15]=0
	89	*/
	90	wrl(USB_PHY_TST_GRP_CTRL, rdl(USB_PHY_TST_GRP_CTRL) & ~0x8000);
	91
	92	/*
	93	* Stop and reset controller
	94	*/
	95	wrl(USB_CMD, rdl(USB_CMD) & ~0x1);
	96	wrl(USB_CMD, rdl(USB_CMD) \| 0x2);
	97	while (rdl(USB_CMD) & 0x2);
	98
	99	/*
	100	* GL# USB-5 Streaming disable REG_USB_MODE[4]=1
	101	* TBD: This need to be done after each reset!
	102	* GL# USB-4 Setup USB Host mode
	103	*/
	104	wrl(USB_MODE, 0x13);
	105	}
	106
e96ffe2f TP	107	static const struct hc_driver ehci_orion_hc_driver = {
	108	.description = hcd_name,
	109	.product_desc = "Marvell Orion EHCI",
	110	.hcd_priv_size = sizeof(struct ehci_hcd),
	111
	112	/*
	113	* generic hardware linkage
	114	*/
	115	.irq = ehci_irq,
	116	.flags = HCD_MEMORY \| HCD_USB2,
	117
	118	/*
	119	* basic lifecycle operations
	120	*/
c73cee71	121	.reset = ehci_setup,
e96ffe2f	122	.start = ehci_run,
e96ffe2f TP	123	.stop = ehci_stop,
	124	.shutdown = ehci_shutdown,
	125
	126	/*
	127	* managing i/o requests and associated device resources
	128	*/
	129	.urb_enqueue = ehci_urb_enqueue,
	130	.urb_dequeue = ehci_urb_dequeue,
	131	.endpoint_disable = ehci_endpoint_disable,
b18ffd49	132	.endpoint_reset = ehci_endpoint_reset,
e96ffe2f TP	133
	134	/*
	135	* scheduling support
	136	*/
	137	.get_frame_number = ehci_get_frame,
	138
	139	/*
	140	* root hub support
	141	*/
	142	.hub_status_data = ehci_hub_status_data,
	143	.hub_control = ehci_hub_control,
	144	.bus_suspend = ehci_bus_suspend,
	145	.bus_resume = ehci_bus_resume,
a8e51775	146	.relinquish_port = ehci_relinquish_port,
3a31155c	147	.port_handed_over = ehci_port_handed_over,
914b7012 AS	148
914b7012 AS	149	.clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
e96ffe2f TP	150	};
e96ffe2f TP	151
41ac7b3a	152	static void
92aecfa9	153	ehci_orion_conf_mbus_windows(struct usb_hcd *hcd,
63a9332b	154	const struct mbus_dram_target_info *dram)
92aecfa9 LB	155	{
	156	int i;
	157
	158	for (i = 0; i < 4; i++) {
	159	wrl(USB_WINDOW_CTRL(i), 0);
	160	wrl(USB_WINDOW_BASE(i), 0);
	161	}
	162
	163	for (i = 0; i < dram->num_cs; i++) {
63a9332b	164	const struct mbus_dram_window *cs = dram->cs + i;
92aecfa9 LB	165
	166	wrl(USB_WINDOW_CTRL(i), ((cs->size - 1) & 0xffff0000) \|
	167	(cs->mbus_attr << 8) \|
	168	(dram->mbus_dram_target_id << 4) \| 1);
	169	wrl(USB_WINDOW_BASE(i), cs->base);
	170	}
	171	}
	172
77dae54a AL	173	static u64 ehci_orion_dma_mask = DMA_BIT_MASK(32);
77dae54a AL	174
41ac7b3a	175	static int ehci_orion_drv_probe(struct platform_device *pdev)
e96ffe2f	176	{
92aecfa9	177	struct orion_ehci_data *pd = pdev->dev.platform_data;
63a9332b	178	const struct mbus_dram_target_info *dram;
e96ffe2f TP	179	struct resource *res;
	180	struct usb_hcd *hcd;
	181	struct ehci_hcd *ehci;
8c869eda	182	struct clk *clk;
e96ffe2f TP	183	void __iomem *regs;
e96ffe2f TP	184	int irq, err;
77dae54a	185	enum orion_ehci_phy_ver phy_version;
e96ffe2f TP	186
	187	if (usb_disabled())
	188	return -ENODEV;
	189
	190	pr_debug("Initializing Orion-SoC USB Host Controller\n");
	191
77dae54a AL	192	if (pdev->dev.of_node)
	193	irq = irq_of_parse_and_map(pdev->dev.of_node, 0);
	194	else
	195	irq = platform_get_irq(pdev, 0);
e96ffe2f TP	196	if (irq <= 0) {
	197	dev_err(&pdev->dev,
	198	"Found HC with no IRQ. Check %s setup!\n",
7071a3ce	199	dev_name(&pdev->dev));
e96ffe2f TP	200	err = -ENODEV;
	201	goto err1;
	202	}
	203
	204	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	205	if (!res) {
	206	dev_err(&pdev->dev,
	207	"Found HC with no register addr. Check %s setup!\n",
7071a3ce	208	dev_name(&pdev->dev));
e96ffe2f TP	209	err = -ENODEV;
	210	goto err1;
	211	}
	212
77dae54a AL	213	/*
	214	* Right now device-tree probed devices don't get dma_mask
	215	* set. Since shared usb code relies on it, set it here for
	216	* now. Once we have dma capability bindings this can go away.
	217	*/
	218	if (!pdev->dev.dma_mask)
	219	pdev->dev.dma_mask = &ehci_orion_dma_mask;
	220
5672b7e6	221	if (!request_mem_region(res->start, resource_size(res),
e96ffe2f TP	222	ehci_orion_hc_driver.description)) {
	223	dev_dbg(&pdev->dev, "controller already in use\n");
	224	err = -EBUSY;
	225	goto err1;
	226	}
	227
5672b7e6	228	regs = ioremap(res->start, resource_size(res));
e96ffe2f TP	229	if (regs == NULL) {
	230	dev_dbg(&pdev->dev, "error mapping memory\n");
	231	err = -EFAULT;
	232	goto err2;
	233	}
	234
8c869eda AL	235	/* Not all platforms can gate the clock, so it is not
	236	an error if the clock does not exists. */
	237	clk = clk_get(&pdev->dev, NULL);
	238	if (!IS_ERR(clk)) {
	239	clk_prepare_enable(clk);
	240	clk_put(clk);
	241	}
	242
e96ffe2f	243	hcd = usb_create_hcd(&ehci_orion_hc_driver,
7071a3ce	244	&pdev->dev, dev_name(&pdev->dev));
e96ffe2f TP	245	if (!hcd) {
	246	err = -ENOMEM;
	247	goto err3;
	248	}
	249
	250	hcd->rsrc_start = res->start;
5672b7e6	251	hcd->rsrc_len = resource_size(res);
e96ffe2f TP	252	hcd->regs = regs;
	253
	254	ehci = hcd_to_ehci(hcd);
	255	ehci->caps = hcd->regs + 0x100;
a8e51775	256	hcd->has_tt = 1;
e96ffe2f	257
92aecfa9 LB	258	/*
	259	* (Re-)program MBUS remapping windows if we are asked to.
	260	*/
63a9332b AL	261	dram = mv_mbus_dram_info();
	262	if (dram)
	263	ehci_orion_conf_mbus_windows(hcd, dram);
92aecfa9	264
e96ffe2f	265	/*
fb6f5529	266	* setup Orion USB controller.
e96ffe2f	267	*/
77dae54a AL	268	if (pdev->dev.of_node)
	269	phy_version = EHCI_PHY_NA;
	270	else
	271	phy_version = pd->phy_version;
	272
	273	switch (phy_version) {
fb6f5529 RS	274	case EHCI_PHY_NA: /* dont change USB phy settings */
	275	break;
	276	case EHCI_PHY_ORION:
	277	orion_usb_phy_v1_setup(hcd);
	278	break;
	279	case EHCI_PHY_DD:
	280	case EHCI_PHY_KW:
	281	default:
	282	printk(KERN_WARNING "Orion ehci -USB phy version isn't supported.\n");
	283	}
e96ffe2f	284
b5dd18d8	285	err = usb_add_hcd(hcd, irq, IRQF_SHARED);
e96ffe2f TP	286	if (err)
	287	goto err4;
	288
	289	return 0;
	290
	291	err4:
	292	usb_put_hcd(hcd);
	293	err3:
baffab28 SB	294	if (!IS_ERR(clk)) {
	295	clk_disable_unprepare(clk);
	296	clk_put(clk);
	297	}
e96ffe2f TP	298	iounmap(regs);
e96ffe2f TP	299	err2:
5672b7e6	300	release_mem_region(res->start, resource_size(res));
e96ffe2f TP	301	err1:
e96ffe2f TP	302	dev_err(&pdev->dev, "init %s fail, %d\n",
7071a3ce	303	dev_name(&pdev->dev), err);
e96ffe2f TP	304
	305	return err;
	306	}
	307
39d35681	308	static int ehci_orion_drv_remove(struct platform_device *pdev)
e96ffe2f TP	309	{
e96ffe2f TP	310	struct usb_hcd *hcd = platform_get_drvdata(pdev);
8c869eda	311	struct clk *clk;
e96ffe2f TP	312
	313	usb_remove_hcd(hcd);
	314	iounmap(hcd->regs);
	315	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
	316	usb_put_hcd(hcd);
	317
8c869eda AL	318	clk = clk_get(&pdev->dev, NULL);
	319	if (!IS_ERR(clk)) {
	320	clk_disable_unprepare(clk);
	321	clk_put(clk);
	322	}
e96ffe2f TP	323	return 0;
	324	}
	325
	326	MODULE_ALIAS("platform:orion-ehci");
	327
59a609a9	328	static const struct of_device_id ehci_orion_dt_ids[] = {
77dae54a AL	329	{ .compatible = "marvell,orion-ehci", },
	330	{},
	331	};
	332	MODULE_DEVICE_TABLE(of, ehci_orion_dt_ids);
	333
e96ffe2f TP	334	static struct platform_driver ehci_orion_driver = {
e96ffe2f TP	335	.probe = ehci_orion_drv_probe,
39d35681	336	.remove = ehci_orion_drv_remove,
e96ffe2f	337	.shutdown = usb_hcd_platform_shutdown,
77dae54a AL	338	.driver = {
	339	.name = "orion-ehci",
	340	.owner = THIS_MODULE,
	341	.of_match_table = of_match_ptr(ehci_orion_dt_ids),
	342	},
e96ffe2f	343	};