[deliverable/linux.git] / drivers / usb / c67x00 / c67x00-drv.c

/*
 * c67x00-drv.c: Cypress C67X00 USB Common infrastructure
 *
 * Copyright (C) 2006-2008 Barco N.V.
 *    Derived from the Cypress cy7c67200/300 ezusb linux driver and
 *    based on multiple host controller drivers inside the linux kernel.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 * MA  02110-1301  USA.
 */

/*
 * This file implements the common infrastructure for using the c67x00.
 * It is both the link between the platform configuration and subdrivers and
 * the link between the common hardware parts and the subdrivers (e.g.
 * interrupt handling).
 *
 * The c67x00 has 2 SIE's (serial interface engine) wich can be configured
 * to be host, device or OTG (with some limitations, E.G. only SIE1 can be OTG).
 *
 * Depending on the platform configuration, the SIE's are created and
 * the corresponding subdriver is initialized (c67x00_probe_sie).
 */

#include <linux/device.h>
#include <linux/io.h>
#include <linux/list.h>
#include <linux/usb.h>
#include <linux/usb/c67x00.h>

#include "c67x00.h"
#include "c67x00-hcd.h"

static void c67x00_probe_sie(struct c67x00_sie *sie,
			     struct c67x00_device *dev, int sie_num)
{
	spin_lock_init(&sie->lock);
	sie->dev = dev;
	sie->sie_num = sie_num;
	sie->mode = c67x00_sie_config(dev->pdata->sie_config, sie_num);

	switch (sie->mode) {
	case C67X00_SIE_HOST:
		c67x00_hcd_probe(sie);
		break;

	case C67X00_SIE_UNUSED:
		dev_info(sie_dev(sie),
			 "Not using SIE %d as requested\n", sie->sie_num);
		break;

	default:
		dev_err(sie_dev(sie),
			"Unsupported configuration: 0x%x for SIE %d\n",
			sie->mode, sie->sie_num);
		break;
	}
}

static void c67x00_remove_sie(struct c67x00_sie *sie)
{
	switch (sie->mode) {
	case C67X00_SIE_HOST:
		c67x00_hcd_remove(sie);
		break;

	default:
		break;
	}
}

static irqreturn_t c67x00_irq(int irq, void *__dev)
{
	struct c67x00_device *c67x00 = __dev;
	struct c67x00_sie *sie;
	u16 msg, int_status;
	int i, count = 8;

	int_status = c67x00_ll_hpi_status(c67x00);
	if (!int_status)
		return IRQ_NONE;

	while (int_status != 0 && (count-- >= 0)) {
		c67x00_ll_irq(c67x00, int_status);
		for (i = 0; i < C67X00_SIES; i++) {
			sie = &c67x00->sie[i];
			msg = 0;
			if (int_status & SIEMSG_FLG(i))
				msg = c67x00_ll_fetch_siemsg(c67x00, i);
			if (sie->irq)
				sie->irq(sie, int_status, msg);
		}
		int_status = c67x00_ll_hpi_status(c67x00);
	}

	if (int_status)
		dev_warn(&c67x00->pdev->dev, "Not all interrupts handled! "
			 "status = 0x%04x\n", int_status);

	return IRQ_HANDLED;
}

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

static int __devinit c67x00_drv_probe(struct platform_device *pdev)
{
	struct c67x00_device *c67x00;
	struct c67x00_platform_data *pdata;
	struct resource *res, *res2;
	int ret, i;

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!res)
		return -ENODEV;

	res2 = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
	if (!res2)
		return -ENODEV;

	pdata = pdev->dev.platform_data;
	if (!pdata)
		return -ENODEV;

	c67x00 = kzalloc(sizeof(*c67x00), GFP_KERNEL);
	if (!c67x00)
		return -ENOMEM;

	if (!request_mem_region(res->start, res->end - res->start + 1,
				pdev->name)) {
		dev_err(&pdev->dev, "Memory region busy\n");
		ret = -EBUSY;
		goto request_mem_failed;
	}
	c67x00->hpi.base = ioremap(res->start, res->end - res->start + 1);
	if (!c67x00->hpi.base) {
		dev_err(&pdev->dev, "Unable to map HPI registers\n");
		ret = -EIO;
		goto map_failed;
	}

	spin_lock_init(&c67x00->hpi.lock);
	c67x00->hpi.regstep = pdata->hpi_regstep;
	c67x00->pdata = pdev->dev.platform_data;
	c67x00->pdev = pdev;

	c67x00_ll_init(c67x00);
	c67x00_ll_hpi_reg_init(c67x00);

	ret = request_irq(res2->start, c67x00_irq, 0, pdev->name, c67x00);
	if (ret) {
		dev_err(&pdev->dev, "Cannot claim IRQ\n");
		goto request_irq_failed;
	}

	ret = c67x00_ll_reset(c67x00);
	if (ret) {
		dev_err(&pdev->dev, "Device reset failed\n");
		goto reset_failed;
	}

	for (i = 0; i < C67X00_SIES; i++)
		c67x00_probe_sie(&c67x00->sie[i], c67x00, i);

	platform_set_drvdata(pdev, c67x00);

	return 0;

 reset_failed:
	free_irq(res2->start, c67x00);
 request_irq_failed:
	iounmap(c67x00->hpi.base);
 map_failed:
	release_mem_region(res->start, res->end - res->start + 1);
 request_mem_failed:
	kfree(c67x00);

	return ret;
}

static int __devexit c67x00_drv_remove(struct platform_device *pdev)
{
	struct c67x00_device *c67x00 = platform_get_drvdata(pdev);
	struct resource *res;
	int i;

	for (i = 0; i < C67X00_SIES; i++)
		c67x00_remove_sie(&c67x00->sie[i]);

	c67x00_ll_release(c67x00);

	res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
	if (res)
		free_irq(res->start, c67x00);

	iounmap(c67x00->hpi.base);

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (res)
		release_mem_region(res->start, res->end - res->start + 1);

	kfree(c67x00);

	return 0;
}

static struct platform_driver c67x00_driver = {
	.probe	= c67x00_drv_probe,
	.remove	= __devexit_p(c67x00_drv_remove),
	.driver	= {
		.owner = THIS_MODULE,
		.name = "c67x00",
	},
};
MODULE_ALIAS("platform:c67x00");

static int __init c67x00_init(void)
{
	return platform_driver_register(&c67x00_driver);
}

static void __exit c67x00_exit(void)
{
	platform_driver_unregister(&c67x00_driver);
}

module_init(c67x00_init);
module_exit(c67x00_exit);

MODULE_AUTHOR("Peter Korsgaard, Jan Veldeman, Grant Likely");
MODULE_DESCRIPTION("Cypress C67X00 USB Controller Driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
b02b371e PK	1	/*
	2	* c67x00-drv.c: Cypress C67X00 USB Common infrastructure
	3	*
	4	* Copyright (C) 2006-2008 Barco N.V.
	5	* Derived from the Cypress cy7c67200/300 ezusb linux driver and
	6	* based on multiple host controller drivers inside the linux kernel.
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; either version 2 of the License, or
	11	* (at your option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program; if not, write to the Free Software
	20	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
	21	* MA 02110-1301 USA.
	22	*/
	23
	24	/*
	25	* This file implements the common infrastructure for using the c67x00.
	26	* It is both the link between the platform configuration and subdrivers and
	27	* the link between the common hardware parts and the subdrivers (e.g.
	28	* interrupt handling).
	29	*
	30	* The c67x00 has 2 SIE's (serial interface engine) wich can be configured
	31	* to be host, device or OTG (with some limitations, E.G. only SIE1 can be OTG).
	32	*
	33	* Depending on the platform configuration, the SIE's are created and
	34	* the corresponding subdriver is initialized (c67x00_probe_sie).
	35	*/
	36
	37	#include <linux/device.h>
	38	#include <linux/io.h>
	39	#include <linux/list.h>
	40	#include <linux/usb.h>
	41	#include <linux/usb/c67x00.h>
	42
	43	#include "c67x00.h"
e9b29ffc	44	#include "c67x00-hcd.h"
b02b371e PK	45
	46	static void c67x00_probe_sie(struct c67x00_sie *sie,
	47	struct c67x00_device *dev, int sie_num)
	48	{
	49	spin_lock_init(&sie->lock);
	50	sie->dev = dev;
	51	sie->sie_num = sie_num;
	52	sie->mode = c67x00_sie_config(dev->pdata->sie_config, sie_num);
	53
	54	switch (sie->mode) {
e9b29ffc PK	55	case C67X00_SIE_HOST:
	56	c67x00_hcd_probe(sie);
	57	break;
	58
b02b371e PK	59	case C67X00_SIE_UNUSED:
	60	dev_info(sie_dev(sie),
	61	"Not using SIE %d as requested\n", sie->sie_num);
	62	break;
	63
	64	default:
	65	dev_err(sie_dev(sie),
	66	"Unsupported configuration: 0x%x for SIE %d\n",
	67	sie->mode, sie->sie_num);
	68	break;
	69	}
	70	}
	71
	72	static void c67x00_remove_sie(struct c67x00_sie *sie)
	73	{
e9b29ffc PK	74	switch (sie->mode) {
	75	case C67X00_SIE_HOST:
	76	c67x00_hcd_remove(sie);
	77	break;
	78
	79	default:
	80	break;
	81	}
b02b371e PK	82	}
	83
	84	static irqreturn_t c67x00_irq(int irq, void *__dev)
	85	{
	86	struct c67x00_device *c67x00 = __dev;
	87	struct c67x00_sie *sie;
	88	u16 msg, int_status;
	89	int i, count = 8;
	90
	91	int_status = c67x00_ll_hpi_status(c67x00);
	92	if (!int_status)
	93	return IRQ_NONE;
	94
	95	while (int_status != 0 && (count-- >= 0)) {
	96	c67x00_ll_irq(c67x00, int_status);
	97	for (i = 0; i < C67X00_SIES; i++) {
	98	sie = &c67x00->sie[i];
	99	msg = 0;
	100	if (int_status & SIEMSG_FLG(i))
	101	msg = c67x00_ll_fetch_siemsg(c67x00, i);
	102	if (sie->irq)
	103	sie->irq(sie, int_status, msg);
	104	}
	105	int_status = c67x00_ll_hpi_status(c67x00);
	106	}
	107
	108	if (int_status)
	109	dev_warn(&c67x00->pdev->dev, "Not all interrupts handled! "
	110	"status = 0x%04x\n", int_status);
	111
	112	return IRQ_HANDLED;
	113	}
	114
	115	/* ------------------------------------------------------------------------- */
	116
	117	static int __devinit c67x00_drv_probe(struct platform_device *pdev)
	118	{
	119	struct c67x00_device *c67x00;
	120	struct c67x00_platform_data *pdata;
	121	struct resource res, res2;
	122	int ret, i;
	123
	124	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	125	if (!res)
	126	return -ENODEV;
	127
	128	res2 = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
	129	if (!res2)
	130	return -ENODEV;
	131
	132	pdata = pdev->dev.platform_data;
	133	if (!pdata)
	134	return -ENODEV;
	135
	136	c67x00 = kzalloc(sizeof(*c67x00), GFP_KERNEL);
	137	if (!c67x00)
	138	return -ENOMEM;
	139
	140	if (!request_mem_region(res->start, res->end - res->start + 1,
	141	pdev->name)) {
	142	dev_err(&pdev->dev, "Memory region busy\n");
	143	ret = -EBUSY;
	144	goto request_mem_failed;
	145	}
146	c67x00->hpi.base = ioremap(res->start, res->end - res->start + 1);
147	if (!c67x00->hpi.base) {
148	dev_err(&pdev->dev, "Unable to map HPI registers\n");
149	ret = -EIO;
150	goto map_failed;
151	}
152
153	spin_lock_init(&c67x00->hpi.lock);
154	c67x00->hpi.regstep = pdata->hpi_regstep;
155	c67x00->pdata = pdev->dev.platform_data;
156	c67x00->pdev = pdev;
157
158	c67x00_ll_init(c67x00);
159	c67x00_ll_hpi_reg_init(c67x00);
160
161	ret = request_irq(res2->start, c67x00_irq, 0, pdev->name, c67x00);
162	if (ret) {
163	dev_err(&pdev->dev, "Cannot claim IRQ\n");
164	goto request_irq_failed;
165	}
166
167	ret = c67x00_ll_reset(c67x00);
168	if (ret) {
169	dev_err(&pdev->dev, "Device reset failed\n");
170	goto reset_failed;
171	}
172
173	for (i = 0; i < C67X00_SIES; i++)
174	c67x00_probe_sie(&c67x00->sie[i], c67x00, i);
175
176	platform_set_drvdata(pdev, c67x00);
177
178	return 0;
179
180	reset_failed:
181	free_irq(res2->start, c67x00);
182	request_irq_failed:
183	iounmap(c67x00->hpi.base);
184	map_failed:
185	release_mem_region(res->start, res->end - res->start + 1);
186	request_mem_failed:
187	kfree(c67x00);
188
189	return ret;
190	}
191
192	static int __devexit c67x00_drv_remove(struct platform_device *pdev)
193	{
194	struct c67x00_device *c67x00 = platform_get_drvdata(pdev);
195	struct resource *res;
196	int i;
197
198	for (i = 0; i < C67X00_SIES; i++)
199	c67x00_remove_sie(&c67x00->sie[i]);
200
201	c67x00_ll_release(c67x00);
202
203	res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
204	if (res)
205	free_irq(res->start, c67x00);
206
207	iounmap(c67x00->hpi.base);
208
209	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
210	if (res)
211	release_mem_region(res->start, res->end - res->start + 1);
212
213	kfree(c67x00);
214
215	return 0;
216	}
217
218	static struct platform_driver c67x00_driver = {
219	.probe = c67x00_drv_probe,
220	.remove = __devexit_p(c67x00_drv_remove),
221	.driver = {
222	.owner = THIS_MODULE,
223	.name = "c67x00",
224	},
225	};
226	MODULE_ALIAS("platform:c67x00");
227
228	static int __init c67x00_init(void)
229	{
230	return platform_driver_register(&c67x00_driver);
231	}
232
233	static void __exit c67x00_exit(void)
234	{
235	platform_driver_unregister(&c67x00_driver);
236	}
237
238	module_init(c67x00_init);
239	module_exit(c67x00_exit);
240
241	MODULE_AUTHOR("Peter Korsgaard, Jan Veldeman, Grant Likely");
242	MODULE_DESCRIPTION("Cypress C67X00 USB Controller Driver");
243	MODULE_LICENSE("GPL");