[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / usb / host / ehci-ixp4xx.c

/*
 * IXP4XX EHCI Host Controller Driver
 *
 * Author: Vladimir Barinov <vbarinov@embeddedalley.com>
 *
 * Based on "ehci-fsl.c" by Randy Vinson <rvinson@mvista.com>
 *
 * 2007 (c) MontaVista Software, Inc. 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/platform_device.h>

static int ixp4xx_ehci_init(struct usb_hcd *hcd)
{
	struct ehci_hcd *ehci = hcd_to_ehci(hcd);
	int retval = 0;

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

	ehci->caps = hcd->regs + 0x100;

	hcd->has_tt = 1;

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

	ehci_port_power(ehci, 0);

	return retval;
}

static const struct hc_driver ixp4xx_ehci_hc_driver = {
	.description		= hcd_name,
	.product_desc		= "IXP4XX EHCI Host Controller",
	.hcd_priv_size		= sizeof(struct ehci_hcd),
	.irq			= ehci_irq,
	.flags			= HCD_MEMORY | HCD_USB2,
	.reset			= ixp4xx_ehci_init,
	.start			= ehci_run,
	.stop			= ehci_stop,
	.shutdown		= ehci_shutdown,
	.urb_enqueue		= ehci_urb_enqueue,
	.urb_dequeue		= ehci_urb_dequeue,
	.endpoint_disable	= ehci_endpoint_disable,
	.endpoint_reset		= ehci_endpoint_reset,
	.get_frame_number	= ehci_get_frame,
	.hub_status_data	= ehci_hub_status_data,
	.hub_control		= ehci_hub_control,
#if defined(CONFIG_PM)
	.bus_suspend		= ehci_bus_suspend,
	.bus_resume		= ehci_bus_resume,
#endif
	.relinquish_port	= ehci_relinquish_port,
	.port_handed_over	= ehci_port_handed_over,

	.clear_tt_buffer_complete	= ehci_clear_tt_buffer_complete,
};

static int ixp4xx_ehci_probe(struct platform_device *pdev)
{
	struct usb_hcd *hcd;
	const struct hc_driver *driver = &ixp4xx_ehci_hc_driver;
	struct resource *res;
	int irq;
	int retval;

	if (usb_disabled())
		return -ENODEV;

	res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
	if (!res) {
		dev_err(&pdev->dev,
			"Found HC with no IRQ. Check %s setup!\n",
			dev_name(&pdev->dev));
		return -ENODEV;
	}
	irq = res->start;

	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) {
		dev_err(&pdev->dev,
			"Found HC with no register addr. Check %s setup!\n",
			dev_name(&pdev->dev));
		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)) {
		dev_dbg(&pdev->dev, "controller already in use\n");
		retval = -EBUSY;
		goto fail_request_resource;
	}

	hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len);
	if (hcd->regs == NULL) {
		dev_dbg(&pdev->dev, "error mapping memory\n");
		retval = -EFAULT;
		goto fail_ioremap;
	}

	retval = usb_add_hcd(hcd, irq, IRQF_SHARED);
	if (retval)
		goto fail_add_hcd;

	return retval;

fail_add_hcd:
	iounmap(hcd->regs);
fail_ioremap:
	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
fail_request_resource:
	usb_put_hcd(hcd);
fail_create_hcd:
	dev_err(&pdev->dev, "init %s fail, %d\n", dev_name(&pdev->dev), retval);
	return retval;
}

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

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

	return 0;
}

MODULE_ALIAS("platform:ixp4xx-ehci");

static struct platform_driver ixp4xx_ehci_driver = {
	.probe = ixp4xx_ehci_probe,
	.remove = ixp4xx_ehci_remove,
	.driver = {
		.name = "ixp4xx-ehci",
	},
};
Commit	Line	Data
91bc4d31 VB	1	/*
	2	* IXP4XX EHCI Host Controller Driver
	3	*
d6b52039	4	* Author: Vladimir Barinov <vbarinov@embeddedalley.com>
91bc4d31 VB	5	*
	6	* Based on "ehci-fsl.c" by Randy Vinson <rvinson@mvista.com>
	7	*
	8	* 2007 (c) MontaVista Software, Inc. This file is licensed under
	9	* the terms of the GNU General Public License version 2. This program
	10	* is licensed "as is" without any warranty of any kind, whether express
	11	* or implied.
	12	*/
	13
	14	#include <linux/platform_device.h>
	15
	16	static int ixp4xx_ehci_init(struct usb_hcd *hcd)
	17	{
	18	struct ehci_hcd *ehci = hcd_to_ehci(hcd);
	19	int retval = 0;
	20
	21	ehci->big_endian_desc = 1;
	22	ehci->big_endian_mmio = 1;
	23
	24	ehci->caps = hcd->regs + 0x100;
91bc4d31	25
a8e51775	26	hcd->has_tt = 1;
91bc4d31	27
1a49e2ac	28	retval = ehci_setup(hcd);
91bc4d31 VB	29	if (retval)
	30	return retval;
	31
	32	ehci_port_power(ehci, 0);
	33
	34	return retval;
	35	}
	36
	37	static const struct hc_driver ixp4xx_ehci_hc_driver = {
	38	.description = hcd_name,
	39	.product_desc = "IXP4XX EHCI Host Controller",
	40	.hcd_priv_size = sizeof(struct ehci_hcd),
	41	.irq = ehci_irq,
	42	.flags = HCD_MEMORY \| HCD_USB2,
	43	.reset = ixp4xx_ehci_init,
	44	.start = ehci_run,
	45	.stop = ehci_stop,
	46	.shutdown = ehci_shutdown,
	47	.urb_enqueue = ehci_urb_enqueue,
	48	.urb_dequeue = ehci_urb_dequeue,
	49	.endpoint_disable = ehci_endpoint_disable,
b18ffd49	50	.endpoint_reset = ehci_endpoint_reset,
91bc4d31 VB	51	.get_frame_number = ehci_get_frame,
	52	.hub_status_data = ehci_hub_status_data,
	53	.hub_control = ehci_hub_control,
	54	#if defined(CONFIG_PM)
	55	.bus_suspend = ehci_bus_suspend,
	56	.bus_resume = ehci_bus_resume,
	57	#endif
a8e51775	58	.relinquish_port = ehci_relinquish_port,
3a31155c	59	.port_handed_over = ehci_port_handed_over,
914b7012 AS	60
914b7012 AS	61	.clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
91bc4d31 VB	62	};
	63
	64	static int ixp4xx_ehci_probe(struct platform_device *pdev)
	65	{
	66	struct usb_hcd *hcd;
	67	const struct hc_driver *driver = &ixp4xx_ehci_hc_driver;
	68	struct resource *res;
	69	int irq;
	70	int retval;
	71
	72	if (usb_disabled())
	73	return -ENODEV;
	74
	75	res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
	76	if (!res) {
	77	dev_err(&pdev->dev,
	78	"Found HC with no IRQ. Check %s setup!\n",
7071a3ce	79	dev_name(&pdev->dev));
91bc4d31 VB	80	return -ENODEV;
	81	}
	82	irq = res->start;
	83
7071a3ce	84	hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));
91bc4d31 VB	85	if (!hcd) {
	86	retval = -ENOMEM;
	87	goto fail_create_hcd;
	88	}
	89
	90	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	91	if (!res) {
	92	dev_err(&pdev->dev,
	93	"Found HC with no register addr. Check %s setup!\n",
7071a3ce	94	dev_name(&pdev->dev));
91bc4d31 VB	95	retval = -ENODEV;
	96	goto fail_request_resource;
	97	}
	98	hcd->rsrc_start = res->start;
28f65c11	99	hcd->rsrc_len = resource_size(res);
91bc4d31 VB	100
	101	if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len,
	102	driver->description)) {
	103	dev_dbg(&pdev->dev, "controller already in use\n");
	104	retval = -EBUSY;
	105	goto fail_request_resource;
	106	}
	107
	108	hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len);
	109	if (hcd->regs == NULL) {
	110	dev_dbg(&pdev->dev, "error mapping memory\n");
	111	retval = -EFAULT;
	112	goto fail_ioremap;
	113	}
	114
	115	retval = usb_add_hcd(hcd, irq, IRQF_SHARED);
	116	if (retval)
	117	goto fail_add_hcd;
	118
	119	return retval;
	120
	121	fail_add_hcd:
	122	iounmap(hcd->regs);
	123	fail_ioremap:
	124	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
	125	fail_request_resource:
	126	usb_put_hcd(hcd);
	127	fail_create_hcd:
7071a3ce	128	dev_err(&pdev->dev, "init %s fail, %d\n", dev_name(&pdev->dev), retval);
91bc4d31 VB	129	return retval;
	130	}
	131
	132	static int ixp4xx_ehci_remove(struct platform_device *pdev)
	133	{
	134	struct usb_hcd *hcd = platform_get_drvdata(pdev);
	135
	136	usb_remove_hcd(hcd);
	137	iounmap(hcd->regs);
	138	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
	139	usb_put_hcd(hcd);
	140
	141	return 0;
	142	}
	143
135db048	144	MODULE_ALIAS("platform:ixp4xx-ehci");
91bc4d31 VB	145
	146	static struct platform_driver ixp4xx_ehci_driver = {
	147	.probe = ixp4xx_ehci_probe,
	148	.remove = ixp4xx_ehci_remove,
	149	.driver = {
	150	.name = "ixp4xx-ehci",
91bc4d31 VB	151	},
91bc4d31 VB	152	};