Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-2.6
[linux-2.6.git] / drivers / usb / c67x00 / c67x00-drv.c
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"
44 #include "c67x00-hcd.h"
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) {
55         case C67X00_SIE_HOST:
56                 c67x00_hcd_probe(sie);
57                 break;
58
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 {
74         switch (sie->mode) {
75         case C67X00_SIE_HOST:
76                 c67x00_hcd_remove(sie);
77                 break;
78
79         default:
80                 break;
81         }
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, resource_size(res),
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, resource_size(res));
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, resource_size(res));
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, resource_size(res));
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");