[linux-2.6-block.git] / drivers / usb / host / ohci-sm501.c

/*
 * OHCI HCD (Host Controller Driver) for USB.
 *
 * (C) Copyright 1999 Roman Weissgaerber <weissg@vienna.at>
 * (C) Copyright 2000-2005 David Brownell
 * (C) Copyright 2002 Hewlett-Packard Company
 * (C) Copyright 2008 Magnus Damm
 *
 * SM501 Bus Glue - based on ohci-omap.c
 *
 * This file is licenced under the GPL.
 */

#include <linux/interrupt.h>
#include <linux/jiffies.h>
#include <linux/platform_device.h>
#include <linux/dma-mapping.h>
#include <linux/sm501.h>
#include <linux/sm501-regs.h>

static int ohci_sm501_init(struct usb_hcd *hcd)
{
	return ohci_init(hcd_to_ohci(hcd));
}

static int ohci_sm501_start(struct usb_hcd *hcd)
{
	struct device *dev = hcd->self.controller;
	int ret;

	ret = ohci_run(hcd_to_ohci(hcd));
	if (ret < 0) {
		dev_err(dev, "can't start %s", hcd->self.bus_name);
		ohci_stop(hcd);
	}

	return ret;
}

/*-------------------------------------------------------------------------*/

static const struct hc_driver ohci_sm501_hc_driver = {
	.description =		hcd_name,
	.product_desc =		"SM501 OHCI",
	.hcd_priv_size =	sizeof(struct ohci_hcd),

	/*
	 * generic hardware linkage
	 */
	.irq =			ohci_irq,
	.flags =		HCD_USB11 | HCD_MEMORY | HCD_LOCAL_MEM,

	/*
	 * basic lifecycle operations
	 */
	.reset =		ohci_sm501_init,
	.start =		ohci_sm501_start,
	.stop =			ohci_stop,
	.shutdown =		ohci_shutdown,

	/*
	 * 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,
#ifdef	CONFIG_PM
	.bus_suspend =		ohci_bus_suspend,
	.bus_resume =		ohci_bus_resume,
#endif
	.start_port_reset =	ohci_start_port_reset,
};

/*-------------------------------------------------------------------------*/

static int ohci_hcd_sm501_drv_probe(struct platform_device *pdev)
{
	const struct hc_driver *driver = &ohci_sm501_hc_driver;
	struct device *dev = &pdev->dev;
	struct resource	*res, *mem;
	int retval, irq;
	struct usb_hcd *hcd = NULL;

	irq = retval = platform_get_irq(pdev, 0);
	if (retval < 0)
		goto err0;

	mem = platform_get_resource(pdev, IORESOURCE_MEM, 1);
	if (mem == NULL) {
		dev_err(dev, "no resource definition for memory\n");
		retval = -ENOENT;
		goto err0;
	}

	if (!request_mem_region(mem->start, mem->end - mem->start + 1,
				pdev->name)) {
		dev_err(dev, "request_mem_region failed\n");
		retval = -EBUSY;
		goto err0;
	}

	/* The sm501 chip is equipped with local memory that may be used
	 * by on-chip devices such as the video controller and the usb host.
	 * This driver uses dma_declare_coherent_memory() to make sure
	 * usb allocations with dma_alloc_coherent() allocate from
	 * this local memory. The dma_handle returned by dma_alloc_coherent()
	 * will be an offset starting from 0 for the first local memory byte.
	 *
	 * So as long as data is allocated using dma_alloc_coherent() all is
	 * fine. This is however not always the case - buffers may be allocated
	 * using kmalloc() - so the usb core needs to be told that it must copy
	 * data into our local memory if the buffers happen to be placed in
	 * regular memory. The HCD_LOCAL_MEM flag does just that.
	 */

	if (!dma_declare_coherent_memory(dev, mem->start,
					 mem->start - mem->parent->start,
					 (mem->end - mem->start) + 1,
					 DMA_MEMORY_MAP |
					 DMA_MEMORY_EXCLUSIVE)) {
		dev_err(dev, "cannot declare coherent memory\n");
		retval = -ENXIO;
		goto err1;
	}

	/* allocate, reserve and remap resources for registers */
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (res == NULL) {
		dev_err(dev, "no resource definition for registers\n");
		retval = -ENOENT;
		goto err2;
	}

	hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));
	if (!hcd) {
		retval = -ENOMEM;
		goto err2;
	}

	hcd->rsrc_start = res->start;
	hcd->rsrc_len = res->end - res->start + 1;

	if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len,	pdev->name)) {
		dev_err(dev, "request_mem_region failed\n");
		retval = -EBUSY;
		goto err3;
	}

	hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
	if (hcd->regs == NULL) {
		dev_err(dev, "cannot remap registers\n");
		retval = -ENXIO;
		goto err4;
	}

	ohci_hcd_init(hcd_to_ohci(hcd));

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

	/* enable power and unmask interrupts */

	sm501_unit_power(dev->parent, SM501_GATE_USB_HOST, 1);
	sm501_modify_reg(dev->parent, SM501_IRQ_MASK, 1 << 6, 0);

	return 0;
err4:
	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
err3:
	usb_put_hcd(hcd);
err2:
	dma_release_declared_memory(dev);
err1:
	release_mem_region(mem->start, mem->end - mem->start + 1);
err0:
	return retval;
}

static int ohci_hcd_sm501_drv_remove(struct platform_device *pdev)
{
	struct usb_hcd *hcd = platform_get_drvdata(pdev);
	struct resource	*mem;

	usb_remove_hcd(hcd);
	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
	usb_put_hcd(hcd);
	dma_release_declared_memory(&pdev->dev);
	mem = platform_get_resource(pdev, IORESOURCE_MEM, 1);
	if (mem)
		release_mem_region(mem->start, mem->end - mem->start + 1);

	/* mask interrupts and disable power */

	sm501_modify_reg(pdev->dev.parent, SM501_IRQ_MASK, 0, 1 << 6);
	sm501_unit_power(pdev->dev.parent, SM501_GATE_USB_HOST, 0);

	platform_set_drvdata(pdev, NULL);
	return 0;
}

/*-------------------------------------------------------------------------*/

#ifdef CONFIG_PM
static int ohci_sm501_suspend(struct platform_device *pdev, pm_message_t msg)
{
	struct device *dev = &pdev->dev;
	struct ohci_hcd	*ohci = hcd_to_ohci(platform_get_drvdata(pdev));

	if (time_before(jiffies, ohci->next_statechange))
		msleep(5);
	ohci->next_statechange = jiffies;

	sm501_unit_power(dev->parent, SM501_GATE_USB_HOST, 0);
	ohci_to_hcd(ohci)->state = HC_STATE_SUSPENDED;
	return 0;
}

static int ohci_sm501_resume(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct usb_hcd	*hcd = platform_get_drvdata(pdev);
	struct ohci_hcd	*ohci = hcd_to_ohci(hcd);

	if (time_before(jiffies, ohci->next_statechange))
		msleep(5);
	ohci->next_statechange = jiffies;

	sm501_unit_power(dev->parent, SM501_GATE_USB_HOST, 1);
	ohci_finish_controller_resume(hcd);
	return 0;
}
#else
#define ohci_sm501_suspend NULL
#define ohci_sm501_resume NULL
#endif

/*-------------------------------------------------------------------------*/

/*
 * Driver definition to register with the SM501 bus
 */
static struct platform_driver ohci_hcd_sm501_driver = {
	.probe		= ohci_hcd_sm501_drv_probe,
	.remove		= ohci_hcd_sm501_drv_remove,
	.shutdown	= usb_hcd_platform_shutdown,
	.suspend	= ohci_sm501_suspend,
	.resume		= ohci_sm501_resume,
	.driver		= {
		.owner	= THIS_MODULE,
		.name	= "sm501-usb",
	},
};
MODULE_ALIAS("platform:sm501-usb");
Commit	Line	Data
f54aab6e MD	1	/*
	2	* OHCI HCD (Host Controller Driver) for USB.
	3	*
	4	* (C) Copyright 1999 Roman Weissgaerber <weissg@vienna.at>
	5	* (C) Copyright 2000-2005 David Brownell
	6	* (C) Copyright 2002 Hewlett-Packard Company
	7	* (C) Copyright 2008 Magnus Damm
	8	*
	9	* SM501 Bus Glue - based on ohci-omap.c
	10	*
	11	* This file is licenced under the GPL.
	12	*/
	13
	14	#include <linux/interrupt.h>
	15	#include <linux/jiffies.h>
	16	#include <linux/platform_device.h>
	17	#include <linux/dma-mapping.h>
	18	#include <linux/sm501.h>
	19	#include <linux/sm501-regs.h>
	20
	21	static int ohci_sm501_init(struct usb_hcd *hcd)
	22	{
	23	return ohci_init(hcd_to_ohci(hcd));
	24	}
	25
	26	static int ohci_sm501_start(struct usb_hcd *hcd)
	27	{
	28	struct device *dev = hcd->self.controller;
	29	int ret;
	30
	31	ret = ohci_run(hcd_to_ohci(hcd));
	32	if (ret < 0) {
	33	dev_err(dev, "can't start %s", hcd->self.bus_name);
	34	ohci_stop(hcd);
	35	}
	36
	37	return ret;
	38	}
	39
	40	/-------------------------------------------------------------------------/
	41
	42	static const struct hc_driver ohci_sm501_hc_driver = {
	43	.description = hcd_name,
	44	.product_desc = "SM501 OHCI",
	45	.hcd_priv_size = sizeof(struct ohci_hcd),
	46
	47	/*
	48	* generic hardware linkage
	49	*/
	50	.irq = ohci_irq,
	51	.flags = HCD_USB11 \| HCD_MEMORY \| HCD_LOCAL_MEM,
	52
	53	/*
	54	* basic lifecycle operations
	55	*/
	56	.reset = ohci_sm501_init,
	57	.start = ohci_sm501_start,
	58	.stop = ohci_stop,
	59	.shutdown = ohci_shutdown,
	60
	61	/*
	62	* managing i/o requests and associated device resources
	63	*/
	64	.urb_enqueue = ohci_urb_enqueue,
65	.urb_dequeue = ohci_urb_dequeue,
66	.endpoint_disable = ohci_endpoint_disable,
67
68	/*
69	* scheduling support
70	*/
71	.get_frame_number = ohci_get_frame,
72
73	/*
74	* root hub support
75	*/
76	.hub_status_data = ohci_hub_status_data,
77	.hub_control = ohci_hub_control,
f54aab6e MD	78	#ifdef CONFIG_PM
	79	.bus_suspend = ohci_bus_suspend,
	80	.bus_resume = ohci_bus_resume,
	81	#endif
	82	.start_port_reset = ohci_start_port_reset,
	83	};
	84
	85	/-------------------------------------------------------------------------/
	86
	87	static int ohci_hcd_sm501_drv_probe(struct platform_device *pdev)
	88	{
	89	const struct hc_driver *driver = &ohci_sm501_hc_driver;
	90	struct device *dev = &pdev->dev;
	91	struct resource res, mem;
	92	int retval, irq;
af3d305c	93	struct usb_hcd *hcd = NULL;
f54aab6e MD	94
	95	irq = retval = platform_get_irq(pdev, 0);
	96	if (retval < 0)
	97	goto err0;
	98
	99	mem = platform_get_resource(pdev, IORESOURCE_MEM, 1);
	100	if (mem == NULL) {
	101	dev_err(dev, "no resource definition for memory\n");
	102	retval = -ENOENT;
	103	goto err0;
	104	}
	105
	106	if (!request_mem_region(mem->start, mem->end - mem->start + 1,
	107	pdev->name)) {
	108	dev_err(dev, "request_mem_region failed\n");
	109	retval = -EBUSY;
	110	goto err0;
	111	}
	112
	113	/* The sm501 chip is equipped with local memory that may be used
	114	* by on-chip devices such as the video controller and the usb host.
	115	* This driver uses dma_declare_coherent_memory() to make sure
	116	* usb allocations with dma_alloc_coherent() allocate from
	117	* this local memory. The dma_handle returned by dma_alloc_coherent()
	118	* will be an offset starting from 0 for the first local memory byte.
	119	*
	120	* So as long as data is allocated using dma_alloc_coherent() all is
	121	* fine. This is however not always the case - buffers may be allocated
	122	* using kmalloc() - so the usb core needs to be told that it must copy
	123	* data into our local memory if the buffers happen to be placed in
	124	* regular memory. The HCD_LOCAL_MEM flag does just that.
	125	*/
	126
	127	if (!dma_declare_coherent_memory(dev, mem->start,
	128	mem->start - mem->parent->start,
	129	(mem->end - mem->start) + 1,
	130	DMA_MEMORY_MAP \|
	131	DMA_MEMORY_EXCLUSIVE)) {
	132	dev_err(dev, "cannot declare coherent memory\n");
	133	retval = -ENXIO;
	134	goto err1;
	135	}
	136
	137	/* allocate, reserve and remap resources for registers */
	138	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	139	if (res == NULL) {
	140	dev_err(dev, "no resource definition for registers\n");
	141	retval = -ENOENT;
	142	goto err2;
	143	}
	144
7071a3ce	145	hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));
f54aab6e MD	146	if (!hcd) {
	147	retval = -ENOMEM;
	148	goto err2;
	149	}
	150
	151	hcd->rsrc_start = res->start;
	152	hcd->rsrc_len = res->end - res->start + 1;
	153
	154	if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, pdev->name)) {
	155	dev_err(dev, "request_mem_region failed\n");
	156	retval = -EBUSY;
	157	goto err3;
	158	}
	159
	160	hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
	161	if (hcd->regs == NULL) {
	162	dev_err(dev, "cannot remap registers\n");
	163	retval = -ENXIO;
	164	goto err4;
	165	}
	166
	167	ohci_hcd_init(hcd_to_ohci(hcd));
	168
	169	retval = usb_add_hcd(hcd, irq, IRQF_DISABLED \| IRQF_SHARED);
	170	if (retval)
	171	goto err4;
	172
	173	/* enable power and unmask interrupts */
	174
	175	sm501_unit_power(dev->parent, SM501_GATE_USB_HOST, 1);
	176	sm501_modify_reg(dev->parent, SM501_IRQ_MASK, 1 << 6, 0);
	177
	178	return 0;
	179	err4:
	180	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
	181	err3:
	182	usb_put_hcd(hcd);
	183	err2:
	184	dma_release_declared_memory(dev);
	185	err1:
	186	release_mem_region(mem->start, mem->end - mem->start + 1);
	187	err0:
	188	return retval;
	189	}
	190
	191	static int ohci_hcd_sm501_drv_remove(struct platform_device *pdev)
	192	{
	193	struct usb_hcd *hcd = platform_get_drvdata(pdev);
	194	struct resource *mem;
	195
	196	usb_remove_hcd(hcd);
	197	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
	198	usb_put_hcd(hcd);
	199	dma_release_declared_memory(&pdev->dev);
	200	mem = platform_get_resource(pdev, IORESOURCE_MEM, 1);
119fc8c9 JJ	201	if (mem)
119fc8c9 JJ	202	release_mem_region(mem->start, mem->end - mem->start + 1);
f54aab6e MD	203
	204	/* mask interrupts and disable power */
	205
	206	sm501_modify_reg(pdev->dev.parent, SM501_IRQ_MASK, 0, 1 << 6);
	207	sm501_unit_power(pdev->dev.parent, SM501_GATE_USB_HOST, 0);
	208
	209	platform_set_drvdata(pdev, NULL);
	210	return 0;
	211	}
	212
	213	/-------------------------------------------------------------------------/
	214
	215	#ifdef CONFIG_PM
	216	static int ohci_sm501_suspend(struct platform_device *pdev, pm_message_t msg)
	217	{
	218	struct device *dev = &pdev->dev;
	219	struct ohci_hcd *ohci = hcd_to_ohci(platform_get_drvdata(pdev));
	220
	221	if (time_before(jiffies, ohci->next_statechange))
	222	msleep(5);
	223	ohci->next_statechange = jiffies;
	224
	225	sm501_unit_power(dev->parent, SM501_GATE_USB_HOST, 0);
	226	ohci_to_hcd(ohci)->state = HC_STATE_SUSPENDED;
f54aab6e MD	227	return 0;
	228	}
	229
	230	static int ohci_sm501_resume(struct platform_device *pdev)
	231	{
	232	struct device *dev = &pdev->dev;
43bbb7e0 AS	233	struct usb_hcd *hcd = platform_get_drvdata(pdev);
43bbb7e0 AS	234	struct ohci_hcd *ohci = hcd_to_ohci(hcd);
f54aab6e MD	235
	236	if (time_before(jiffies, ohci->next_statechange))
	237	msleep(5);
	238	ohci->next_statechange = jiffies;
	239
	240	sm501_unit_power(dev->parent, SM501_GATE_USB_HOST, 1);
43bbb7e0	241	ohci_finish_controller_resume(hcd);
f54aab6e MD	242	return 0;
f54aab6e MD	243	}
1409e8e0 AM	244	#else
	245	#define ohci_sm501_suspend NULL
	246	#define ohci_sm501_resume NULL
f54aab6e MD	247	#endif
	248
	249	/-------------------------------------------------------------------------/
	250
	251	/*
	252	* Driver definition to register with the SM501 bus
	253	*/
	254	static struct platform_driver ohci_hcd_sm501_driver = {
	255	.probe = ohci_hcd_sm501_drv_probe,
	256	.remove = ohci_hcd_sm501_drv_remove,
	257	.shutdown = usb_hcd_platform_shutdown,
f54aab6e MD	258	.suspend = ohci_sm501_suspend,
f54aab6e MD	259	.resume = ohci_sm501_resume,
f54aab6e MD	260	.driver = {
	261	.owner = THIS_MODULE,
	262	.name = "sm501-usb",
	263	},
	264	};
f4fce61d	265	MODULE_ALIAS("platform:sm501-usb");