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 | * | |
25985edc | 30 | * The c67x00 has 2 SIE's (serial interface engine) which can be configured |
b02b371e PK |
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> | |
5a0e3ad6 | 40 | #include <linux/slab.h> |
b02b371e PK |
41 | #include <linux/usb.h> |
42 | #include <linux/usb/c67x00.h> | |
43 | ||
44 | #include "c67x00.h" | |
e9b29ffc | 45 | #include "c67x00-hcd.h" |
b02b371e PK |
46 | |
47 | static void c67x00_probe_sie(struct c67x00_sie *sie, | |
48 | struct c67x00_device *dev, int sie_num) | |
49 | { | |
50 | spin_lock_init(&sie->lock); | |
51 | sie->dev = dev; | |
52 | sie->sie_num = sie_num; | |
53 | sie->mode = c67x00_sie_config(dev->pdata->sie_config, sie_num); | |
54 | ||
55 | switch (sie->mode) { | |
e9b29ffc PK |
56 | case C67X00_SIE_HOST: |
57 | c67x00_hcd_probe(sie); | |
58 | break; | |
59 | ||
b02b371e PK |
60 | case C67X00_SIE_UNUSED: |
61 | dev_info(sie_dev(sie), | |
62 | "Not using SIE %d as requested\n", sie->sie_num); | |
63 | break; | |
64 | ||
65 | default: | |
66 | dev_err(sie_dev(sie), | |
67 | "Unsupported configuration: 0x%x for SIE %d\n", | |
68 | sie->mode, sie->sie_num); | |
69 | break; | |
70 | } | |
71 | } | |
72 | ||
73 | static void c67x00_remove_sie(struct c67x00_sie *sie) | |
74 | { | |
e9b29ffc PK |
75 | switch (sie->mode) { |
76 | case C67X00_SIE_HOST: | |
77 | c67x00_hcd_remove(sie); | |
78 | break; | |
79 | ||
80 | default: | |
81 | break; | |
82 | } | |
b02b371e PK |
83 | } |
84 | ||
85 | static irqreturn_t c67x00_irq(int irq, void *__dev) | |
86 | { | |
87 | struct c67x00_device *c67x00 = __dev; | |
88 | struct c67x00_sie *sie; | |
89 | u16 msg, int_status; | |
90 | int i, count = 8; | |
91 | ||
92 | int_status = c67x00_ll_hpi_status(c67x00); | |
93 | if (!int_status) | |
94 | return IRQ_NONE; | |
95 | ||
96 | while (int_status != 0 && (count-- >= 0)) { | |
97 | c67x00_ll_irq(c67x00, int_status); | |
98 | for (i = 0; i < C67X00_SIES; i++) { | |
99 | sie = &c67x00->sie[i]; | |
100 | msg = 0; | |
101 | if (int_status & SIEMSG_FLG(i)) | |
102 | msg = c67x00_ll_fetch_siemsg(c67x00, i); | |
103 | if (sie->irq) | |
104 | sie->irq(sie, int_status, msg); | |
105 | } | |
106 | int_status = c67x00_ll_hpi_status(c67x00); | |
107 | } | |
108 | ||
109 | if (int_status) | |
110 | dev_warn(&c67x00->pdev->dev, "Not all interrupts handled! " | |
111 | "status = 0x%04x\n", int_status); | |
112 | ||
113 | return IRQ_HANDLED; | |
114 | } | |
115 | ||
116 | /* ------------------------------------------------------------------------- */ | |
117 | ||
118 | static int __devinit c67x00_drv_probe(struct platform_device *pdev) | |
119 | { | |
120 | struct c67x00_device *c67x00; | |
121 | struct c67x00_platform_data *pdata; | |
122 | struct resource *res, *res2; | |
123 | int ret, i; | |
124 | ||
125 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); | |
126 | if (!res) | |
127 | return -ENODEV; | |
128 | ||
129 | res2 = platform_get_resource(pdev, IORESOURCE_IRQ, 0); | |
130 | if (!res2) | |
131 | return -ENODEV; | |
132 | ||
133 | pdata = pdev->dev.platform_data; | |
134 | if (!pdata) | |
135 | return -ENODEV; | |
136 | ||
137 | c67x00 = kzalloc(sizeof(*c67x00), GFP_KERNEL); | |
138 | if (!c67x00) | |
139 | return -ENOMEM; | |
140 | ||
c38b9401 | 141 | if (!request_mem_region(res->start, resource_size(res), |
b02b371e PK |
142 | pdev->name)) { |
143 | dev_err(&pdev->dev, "Memory region busy\n"); | |
144 | ret = -EBUSY; | |
145 | goto request_mem_failed; | |
146 | } | |
c38b9401 | 147 | c67x00->hpi.base = ioremap(res->start, resource_size(res)); |
b02b371e PK |
148 | if (!c67x00->hpi.base) { |
149 | dev_err(&pdev->dev, "Unable to map HPI registers\n"); | |
150 | ret = -EIO; | |
151 | goto map_failed; | |
152 | } | |
153 | ||
154 | spin_lock_init(&c67x00->hpi.lock); | |
155 | c67x00->hpi.regstep = pdata->hpi_regstep; | |
156 | c67x00->pdata = pdev->dev.platform_data; | |
157 | c67x00->pdev = pdev; | |
158 | ||
159 | c67x00_ll_init(c67x00); | |
160 | c67x00_ll_hpi_reg_init(c67x00); | |
161 | ||
162 | ret = request_irq(res2->start, c67x00_irq, 0, pdev->name, c67x00); | |
163 | if (ret) { | |
164 | dev_err(&pdev->dev, "Cannot claim IRQ\n"); | |
165 | goto request_irq_failed; | |
166 | } | |
167 | ||
168 | ret = c67x00_ll_reset(c67x00); | |
169 | if (ret) { | |
170 | dev_err(&pdev->dev, "Device reset failed\n"); | |
171 | goto reset_failed; | |
172 | } | |
173 | ||
174 | for (i = 0; i < C67X00_SIES; i++) | |
175 | c67x00_probe_sie(&c67x00->sie[i], c67x00, i); | |
176 | ||
177 | platform_set_drvdata(pdev, c67x00); | |
178 | ||
179 | return 0; | |
180 | ||
181 | reset_failed: | |
182 | free_irq(res2->start, c67x00); | |
183 | request_irq_failed: | |
184 | iounmap(c67x00->hpi.base); | |
185 | map_failed: | |
c38b9401 | 186 | release_mem_region(res->start, resource_size(res)); |
b02b371e PK |
187 | request_mem_failed: |
188 | kfree(c67x00); | |
189 | ||
190 | return ret; | |
191 | } | |
192 | ||
193 | static int __devexit c67x00_drv_remove(struct platform_device *pdev) | |
194 | { | |
195 | struct c67x00_device *c67x00 = platform_get_drvdata(pdev); | |
196 | struct resource *res; | |
197 | int i; | |
198 | ||
199 | for (i = 0; i < C67X00_SIES; i++) | |
200 | c67x00_remove_sie(&c67x00->sie[i]); | |
201 | ||
202 | c67x00_ll_release(c67x00); | |
203 | ||
204 | res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); | |
205 | if (res) | |
206 | free_irq(res->start, c67x00); | |
207 | ||
208 | iounmap(c67x00->hpi.base); | |
209 | ||
210 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); | |
211 | if (res) | |
c38b9401 | 212 | release_mem_region(res->start, resource_size(res)); |
b02b371e PK |
213 | |
214 | kfree(c67x00); | |
215 | ||
216 | return 0; | |
217 | } | |
218 | ||
219 | static struct platform_driver c67x00_driver = { | |
220 | .probe = c67x00_drv_probe, | |
221 | .remove = __devexit_p(c67x00_drv_remove), | |
222 | .driver = { | |
223 | .owner = THIS_MODULE, | |
224 | .name = "c67x00", | |
225 | }, | |
226 | }; | |
227 | MODULE_ALIAS("platform:c67x00"); | |
228 | ||
229 | static int __init c67x00_init(void) | |
230 | { | |
231 | return platform_driver_register(&c67x00_driver); | |
232 | } | |
233 | ||
234 | static void __exit c67x00_exit(void) | |
235 | { | |
236 | platform_driver_unregister(&c67x00_driver); | |
237 | } | |
238 | ||
239 | module_init(c67x00_init); | |
240 | module_exit(c67x00_exit); | |
241 | ||
242 | MODULE_AUTHOR("Peter Korsgaard, Jan Veldeman, Grant Likely"); | |
243 | MODULE_DESCRIPTION("Cypress C67X00 USB Controller Driver"); | |
244 | MODULE_LICENSE("GPL"); |