Commit | Line | Data |
---|---|---|
db11e47d SS |
1 | /* |
2 | * Glue code for the ISP1760 driver and bus | |
3 | * Currently there is support for | |
4 | * - OpenFirmware | |
5 | * - PCI | |
9da69c60 | 6 | * - PDEV (generic platform device centralized driver model) |
db11e47d SS |
7 | * |
8 | * (c) 2007 Sebastian Siewior <bigeasy@linutronix.de> | |
9 | * | |
10 | */ | |
11 | ||
12 | #include <linux/usb.h> | |
13 | #include <linux/io.h> | |
6eb0de82 | 14 | #include <linux/module.h> |
f7e7aa58 | 15 | #include <linux/platform_device.h> |
9da69c60 | 16 | #include <linux/usb/isp1760.h> |
27729aad | 17 | #include <linux/usb/hcd.h> |
db11e47d | 18 | |
db11e47d SS |
19 | #include "isp1760-hcd.h" |
20 | ||
abf058e1 | 21 | #if defined(CONFIG_OF) && defined(CONFIG_OF_IRQ) |
3a7655fc | 22 | #include <linux/slab.h> |
db11e47d SS |
23 | #include <linux/of.h> |
24 | #include <linux/of_platform.h> | |
8f5d6215 JF |
25 | #include <linux/of_address.h> |
26 | #include <linux/of_irq.h> | |
3a7655fc | 27 | #include <linux/of_gpio.h> |
db11e47d SS |
28 | #endif |
29 | ||
ff30bf1c | 30 | #ifdef CONFIG_PCI |
db11e47d SS |
31 | #include <linux/pci.h> |
32 | #endif | |
33 | ||
abf058e1 | 34 | #if defined(CONFIG_OF) && defined(CONFIG_OF_IRQ) |
3a7655fc JF |
35 | struct isp1760 { |
36 | struct usb_hcd *hcd; | |
37 | int rst_gpio; | |
38 | }; | |
39 | ||
d35fb641 | 40 | static int of_isp1760_probe(struct platform_device *dev) |
db11e47d | 41 | { |
3a7655fc | 42 | struct isp1760 *drvdata; |
61c7a080 | 43 | struct device_node *dp = dev->dev.of_node; |
db11e47d SS |
44 | struct resource *res; |
45 | struct resource memory; | |
db11e47d | 46 | int virq; |
e07afd3f | 47 | resource_size_t res_len; |
db11e47d | 48 | int ret; |
3faefc88 | 49 | unsigned int devflags = 0; |
3a7655fc | 50 | enum of_gpio_flags gpio_flags; |
8ad028bd | 51 | u32 bus_width = 0; |
3a7655fc JF |
52 | |
53 | drvdata = kzalloc(sizeof(*drvdata), GFP_KERNEL); | |
54 | if (!drvdata) | |
55 | return -ENOMEM; | |
db11e47d SS |
56 | |
57 | ret = of_address_to_resource(dp, 0, &memory); | |
30a0dee7 JL |
58 | if (ret) { |
59 | ret = -ENXIO; | |
60 | goto free_data; | |
61 | } | |
db11e47d | 62 | |
e07afd3f TK |
63 | res_len = resource_size(&memory); |
64 | ||
65 | res = request_mem_region(memory.start, res_len, dev_name(&dev->dev)); | |
30a0dee7 JL |
66 | if (!res) { |
67 | ret = -EBUSY; | |
68 | goto free_data; | |
69 | } | |
db11e47d | 70 | |
d124a60d NI |
71 | virq = irq_of_parse_and_map(dp, 0); |
72 | if (!virq) { | |
db11e47d SS |
73 | ret = -ENODEV; |
74 | goto release_reg; | |
75 | } | |
76 | ||
3faefc88 NC |
77 | if (of_device_is_compatible(dp, "nxp,usb-isp1761")) |
78 | devflags |= ISP1760_FLAG_ISP1761; | |
79 | ||
3faefc88 | 80 | /* Some systems wire up only 16 of the 32 data lines */ |
8ad028bd DM |
81 | of_property_read_u32(dp, "bus-width", &bus_width); |
82 | if (bus_width == 16) | |
3faefc88 NC |
83 | devflags |= ISP1760_FLAG_BUS_WIDTH_16; |
84 | ||
85 | if (of_get_property(dp, "port1-otg", NULL) != NULL) | |
86 | devflags |= ISP1760_FLAG_OTG_EN; | |
87 | ||
88 | if (of_get_property(dp, "analog-oc", NULL) != NULL) | |
89 | devflags |= ISP1760_FLAG_ANALOG_OC; | |
90 | ||
91 | if (of_get_property(dp, "dack-polarity", NULL) != NULL) | |
92 | devflags |= ISP1760_FLAG_DACK_POL_HIGH; | |
93 | ||
94 | if (of_get_property(dp, "dreq-polarity", NULL) != NULL) | |
95 | devflags |= ISP1760_FLAG_DREQ_POL_HIGH; | |
96 | ||
3a7655fc JF |
97 | drvdata->rst_gpio = of_get_gpio_flags(dp, 0, &gpio_flags); |
98 | if (gpio_is_valid(drvdata->rst_gpio)) { | |
99 | ret = gpio_request(drvdata->rst_gpio, dev_name(&dev->dev)); | |
100 | if (!ret) { | |
101 | if (!(gpio_flags & OF_GPIO_ACTIVE_LOW)) { | |
102 | devflags |= ISP1760_FLAG_RESET_ACTIVE_HIGH; | |
103 | gpio_direction_output(drvdata->rst_gpio, 0); | |
104 | } else { | |
105 | gpio_direction_output(drvdata->rst_gpio, 1); | |
106 | } | |
107 | } else { | |
108 | drvdata->rst_gpio = ret; | |
109 | } | |
db11e47d SS |
110 | } |
111 | ||
3a7655fc JF |
112 | drvdata->hcd = isp1760_register(memory.start, res_len, virq, |
113 | IRQF_SHARED, drvdata->rst_gpio, | |
114 | &dev->dev, dev_name(&dev->dev), | |
115 | devflags); | |
116 | if (IS_ERR(drvdata->hcd)) { | |
117 | ret = PTR_ERR(drvdata->hcd); | |
118 | goto free_gpio; | |
119 | } | |
120 | ||
121 | dev_set_drvdata(&dev->dev, drvdata); | |
db11e47d SS |
122 | return ret; |
123 | ||
3a7655fc JF |
124 | free_gpio: |
125 | if (gpio_is_valid(drvdata->rst_gpio)) | |
126 | gpio_free(drvdata->rst_gpio); | |
db11e47d | 127 | release_reg: |
e07afd3f | 128 | release_mem_region(memory.start, res_len); |
30a0dee7 | 129 | free_data: |
3a7655fc | 130 | kfree(drvdata); |
db11e47d SS |
131 | return ret; |
132 | } | |
133 | ||
2dc11581 | 134 | static int of_isp1760_remove(struct platform_device *dev) |
db11e47d | 135 | { |
3a7655fc | 136 | struct isp1760 *drvdata = dev_get_drvdata(&dev->dev); |
db11e47d SS |
137 | |
138 | dev_set_drvdata(&dev->dev, NULL); | |
139 | ||
3a7655fc JF |
140 | usb_remove_hcd(drvdata->hcd); |
141 | iounmap(drvdata->hcd->regs); | |
142 | release_mem_region(drvdata->hcd->rsrc_start, drvdata->hcd->rsrc_len); | |
143 | usb_put_hcd(drvdata->hcd); | |
144 | ||
145 | if (gpio_is_valid(drvdata->rst_gpio)) | |
146 | gpio_free(drvdata->rst_gpio); | |
147 | ||
148 | kfree(drvdata); | |
db11e47d SS |
149 | return 0; |
150 | } | |
151 | ||
c4386ad0 | 152 | static const struct of_device_id of_isp1760_match[] = { |
db11e47d SS |
153 | { |
154 | .compatible = "nxp,usb-isp1760", | |
155 | }, | |
3faefc88 NC |
156 | { |
157 | .compatible = "nxp,usb-isp1761", | |
158 | }, | |
db11e47d SS |
159 | { }, |
160 | }; | |
161 | MODULE_DEVICE_TABLE(of, of_isp1760_match); | |
162 | ||
d35fb641 | 163 | static struct platform_driver isp1760_of_driver = { |
4018294b GL |
164 | .driver = { |
165 | .name = "nxp-isp1760", | |
166 | .owner = THIS_MODULE, | |
167 | .of_match_table = of_isp1760_match, | |
168 | }, | |
db11e47d SS |
169 | .probe = of_isp1760_probe, |
170 | .remove = of_isp1760_remove, | |
171 | }; | |
172 | #endif | |
173 | ||
ff30bf1c | 174 | #ifdef CONFIG_PCI |
41ac7b3a | 175 | static int isp1761_pci_probe(struct pci_dev *dev, |
db11e47d SS |
176 | const struct pci_device_id *id) |
177 | { | |
178 | u8 latency, limit; | |
179 | __u32 reg_data; | |
180 | int retry_count; | |
db11e47d | 181 | struct usb_hcd *hcd; |
3faefc88 | 182 | unsigned int devflags = 0; |
6013bbba KB |
183 | int ret_status = 0; |
184 | ||
185 | resource_size_t pci_mem_phy0; | |
186 | resource_size_t memlength; | |
187 | ||
188 | u8 __iomem *chip_addr; | |
189 | u8 __iomem *iobase; | |
190 | resource_size_t nxp_pci_io_base; | |
191 | resource_size_t iolength; | |
db11e47d SS |
192 | |
193 | if (usb_disabled()) | |
194 | return -ENODEV; | |
195 | ||
196 | if (pci_enable_device(dev) < 0) | |
197 | return -ENODEV; | |
198 | ||
199 | if (!dev->irq) | |
200 | return -ENODEV; | |
201 | ||
202 | /* Grab the PLX PCI mem maped port start address we need */ | |
203 | nxp_pci_io_base = pci_resource_start(dev, 0); | |
204 | iolength = pci_resource_len(dev, 0); | |
205 | ||
206 | if (!request_mem_region(nxp_pci_io_base, iolength, "ISP1761 IO MEM")) { | |
207 | printk(KERN_ERR "request region #1\n"); | |
208 | return -EBUSY; | |
209 | } | |
210 | ||
211 | iobase = ioremap_nocache(nxp_pci_io_base, iolength); | |
212 | if (!iobase) { | |
213 | printk(KERN_ERR "ioremap #1\n"); | |
6013bbba KB |
214 | ret_status = -ENOMEM; |
215 | goto cleanup1; | |
db11e47d SS |
216 | } |
217 | /* Grab the PLX PCI shared memory of the ISP 1761 we need */ | |
218 | pci_mem_phy0 = pci_resource_start(dev, 3); | |
6013bbba KB |
219 | memlength = pci_resource_len(dev, 3); |
220 | if (memlength < 0xffff) { | |
221 | printk(KERN_ERR "memory length for this resource is wrong\n"); | |
222 | ret_status = -ENOMEM; | |
223 | goto cleanup2; | |
db11e47d SS |
224 | } |
225 | ||
6013bbba | 226 | if (!request_mem_region(pci_mem_phy0, memlength, "ISP-PCI")) { |
db11e47d | 227 | printk(KERN_ERR "host controller already in use\n"); |
6013bbba KB |
228 | ret_status = -EBUSY; |
229 | goto cleanup2; | |
230 | } | |
231 | ||
232 | /* map available memory */ | |
233 | chip_addr = ioremap_nocache(pci_mem_phy0,memlength); | |
234 | if (!chip_addr) { | |
235 | printk(KERN_ERR "Error ioremap failed\n"); | |
236 | ret_status = -ENOMEM; | |
237 | goto cleanup3; | |
db11e47d SS |
238 | } |
239 | ||
240 | /* bad pci latencies can contribute to overruns */ | |
241 | pci_read_config_byte(dev, PCI_LATENCY_TIMER, &latency); | |
242 | if (latency) { | |
243 | pci_read_config_byte(dev, PCI_MAX_LAT, &limit); | |
244 | if (limit && limit < latency) | |
245 | pci_write_config_byte(dev, PCI_LATENCY_TIMER, limit); | |
246 | } | |
247 | ||
248 | /* Try to check whether we can access Scratch Register of | |
249 | * Host Controller or not. The initial PCI access is retried until | |
250 | * local init for the PCI bridge is completed | |
251 | */ | |
252 | retry_count = 20; | |
253 | reg_data = 0; | |
254 | while ((reg_data != 0xFACE) && retry_count) { | |
255 | /*by default host is in 16bit mode, so | |
256 | * io operations at this stage must be 16 bit | |
257 | * */ | |
258 | writel(0xface, chip_addr + HC_SCRATCH_REG); | |
259 | udelay(100); | |
6013bbba | 260 | reg_data = readl(chip_addr + HC_SCRATCH_REG) & 0x0000ffff; |
db11e47d SS |
261 | retry_count--; |
262 | } | |
263 | ||
6013bbba KB |
264 | iounmap(chip_addr); |
265 | ||
db11e47d SS |
266 | /* Host Controller presence is detected by writing to scratch register |
267 | * and reading back and checking the contents are same or not | |
268 | */ | |
269 | if (reg_data != 0xFACE) { | |
802f389a | 270 | dev_err(&dev->dev, "scratch register mismatch %x\n", reg_data); |
6013bbba KB |
271 | ret_status = -ENOMEM; |
272 | goto cleanup3; | |
db11e47d SS |
273 | } |
274 | ||
275 | pci_set_master(dev); | |
276 | ||
6013bbba KB |
277 | /* configure PLX PCI chip to pass interrupts */ |
278 | #define PLX_INT_CSR_REG 0x68 | |
279 | reg_data = readl(iobase + PLX_INT_CSR_REG); | |
280 | reg_data |= 0x900; | |
281 | writel(reg_data, iobase + PLX_INT_CSR_REG); | |
db11e47d SS |
282 | |
283 | dev->dev.dma_mask = NULL; | |
6013bbba | 284 | hcd = isp1760_register(pci_mem_phy0, memlength, dev->irq, |
3a7655fc | 285 | IRQF_SHARED, -ENOENT, &dev->dev, dev_name(&dev->dev), |
3faefc88 | 286 | devflags); |
6013bbba KB |
287 | if (IS_ERR(hcd)) { |
288 | ret_status = -ENODEV; | |
289 | goto cleanup3; | |
ce5dee50 | 290 | } |
6013bbba KB |
291 | |
292 | /* done with PLX IO access */ | |
db11e47d | 293 | iounmap(iobase); |
db11e47d | 294 | release_mem_region(nxp_pci_io_base, iolength); |
6013bbba KB |
295 | |
296 | pci_set_drvdata(dev, hcd); | |
297 | return 0; | |
298 | ||
299 | cleanup3: | |
300 | release_mem_region(pci_mem_phy0, memlength); | |
301 | cleanup2: | |
302 | iounmap(iobase); | |
303 | cleanup1: | |
304 | release_mem_region(nxp_pci_io_base, iolength); | |
305 | return ret_status; | |
db11e47d | 306 | } |
6013bbba | 307 | |
db11e47d SS |
308 | static void isp1761_pci_remove(struct pci_dev *dev) |
309 | { | |
310 | struct usb_hcd *hcd; | |
311 | ||
312 | hcd = pci_get_drvdata(dev); | |
313 | ||
314 | usb_remove_hcd(hcd); | |
315 | iounmap(hcd->regs); | |
316 | release_mem_region(hcd->rsrc_start, hcd->rsrc_len); | |
317 | usb_put_hcd(hcd); | |
318 | ||
319 | pci_disable_device(dev); | |
db11e47d SS |
320 | } |
321 | ||
322 | static void isp1761_pci_shutdown(struct pci_dev *dev) | |
323 | { | |
324 | printk(KERN_ERR "ips1761_pci_shutdown\n"); | |
325 | } | |
326 | ||
6c073568 SAS |
327 | static const struct pci_device_id isp1760_plx [] = { |
328 | { | |
329 | .class = PCI_CLASS_BRIDGE_OTHER << 8, | |
330 | .class_mask = ~0, | |
331 | .vendor = PCI_VENDOR_ID_PLX, | |
332 | .device = 0x5406, | |
333 | .subvendor = PCI_VENDOR_ID_PLX, | |
334 | .subdevice = 0x9054, | |
335 | }, | |
336 | { } | |
db11e47d SS |
337 | }; |
338 | MODULE_DEVICE_TABLE(pci, isp1760_plx); | |
339 | ||
340 | static struct pci_driver isp1761_pci_driver = { | |
341 | .name = "isp1760", | |
342 | .id_table = isp1760_plx, | |
343 | .probe = isp1761_pci_probe, | |
344 | .remove = isp1761_pci_remove, | |
345 | .shutdown = isp1761_pci_shutdown, | |
346 | }; | |
347 | #endif | |
348 | ||
41ac7b3a | 349 | static int isp1760_plat_probe(struct platform_device *pdev) |
f7e7aa58 CM |
350 | { |
351 | int ret = 0; | |
352 | struct usb_hcd *hcd; | |
353 | struct resource *mem_res; | |
354 | struct resource *irq_res; | |
355 | resource_size_t mem_size; | |
9da69c60 MH |
356 | struct isp1760_platform_data *priv = pdev->dev.platform_data; |
357 | unsigned int devflags = 0; | |
b5dd18d8 | 358 | unsigned long irqflags = IRQF_SHARED; |
f7e7aa58 CM |
359 | |
360 | mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0); | |
361 | if (!mem_res) { | |
362 | pr_warning("isp1760: Memory resource not available\n"); | |
363 | ret = -ENODEV; | |
364 | goto out; | |
365 | } | |
366 | mem_size = resource_size(mem_res); | |
367 | if (!request_mem_region(mem_res->start, mem_size, "isp1760")) { | |
368 | pr_warning("isp1760: Cannot reserve the memory resource\n"); | |
369 | ret = -EBUSY; | |
370 | goto out; | |
371 | } | |
372 | ||
373 | irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); | |
374 | if (!irq_res) { | |
375 | pr_warning("isp1760: IRQ resource not available\n"); | |
72d9c8b6 LC |
376 | ret = -ENODEV; |
377 | goto cleanup; | |
f7e7aa58 | 378 | } |
72d9c8b6 | 379 | |
f7e7aa58 CM |
380 | irqflags |= irq_res->flags & IRQF_TRIGGER_MASK; |
381 | ||
9da69c60 MH |
382 | if (priv) { |
383 | if (priv->is_isp1761) | |
384 | devflags |= ISP1760_FLAG_ISP1761; | |
385 | if (priv->bus_width_16) | |
386 | devflags |= ISP1760_FLAG_BUS_WIDTH_16; | |
387 | if (priv->port1_otg) | |
388 | devflags |= ISP1760_FLAG_OTG_EN; | |
389 | if (priv->analog_oc) | |
390 | devflags |= ISP1760_FLAG_ANALOG_OC; | |
391 | if (priv->dack_polarity_high) | |
392 | devflags |= ISP1760_FLAG_DACK_POL_HIGH; | |
393 | if (priv->dreq_polarity_high) | |
394 | devflags |= ISP1760_FLAG_DREQ_POL_HIGH; | |
395 | } | |
396 | ||
f7e7aa58 | 397 | hcd = isp1760_register(mem_res->start, mem_size, irq_res->start, |
3a7655fc JF |
398 | irqflags, -ENOENT, |
399 | &pdev->dev, dev_name(&pdev->dev), devflags); | |
310e9e33 MG |
400 | |
401 | dev_set_drvdata(&pdev->dev, hcd); | |
402 | ||
f7e7aa58 CM |
403 | if (IS_ERR(hcd)) { |
404 | pr_warning("isp1760: Failed to register the HCD device\n"); | |
405 | ret = -ENODEV; | |
406 | goto cleanup; | |
407 | } | |
408 | ||
409 | pr_info("ISP1760 USB device initialised\n"); | |
410 | return ret; | |
411 | ||
412 | cleanup: | |
413 | release_mem_region(mem_res->start, mem_size); | |
414 | out: | |
415 | return ret; | |
416 | } | |
417 | ||
fb4e98ab | 418 | static int isp1760_plat_remove(struct platform_device *pdev) |
f7e7aa58 CM |
419 | { |
420 | struct resource *mem_res; | |
421 | resource_size_t mem_size; | |
310e9e33 MG |
422 | struct usb_hcd *hcd = dev_get_drvdata(&pdev->dev); |
423 | ||
424 | usb_remove_hcd(hcd); | |
f7e7aa58 CM |
425 | |
426 | mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0); | |
427 | mem_size = resource_size(mem_res); | |
428 | release_mem_region(mem_res->start, mem_size); | |
429 | ||
310e9e33 MG |
430 | usb_put_hcd(hcd); |
431 | ||
f7e7aa58 CM |
432 | return 0; |
433 | } | |
434 | ||
435 | static struct platform_driver isp1760_plat_driver = { | |
436 | .probe = isp1760_plat_probe, | |
7690417d | 437 | .remove = isp1760_plat_remove, |
f7e7aa58 CM |
438 | .driver = { |
439 | .name = "isp1760", | |
440 | }, | |
441 | }; | |
442 | ||
db11e47d SS |
443 | static int __init isp1760_init(void) |
444 | { | |
f7e7aa58 | 445 | int ret, any_ret = -ENODEV; |
db11e47d SS |
446 | |
447 | init_kmem_once(); | |
448 | ||
f7e7aa58 CM |
449 | ret = platform_driver_register(&isp1760_plat_driver); |
450 | if (!ret) | |
451 | any_ret = 0; | |
abf058e1 | 452 | #if defined(CONFIG_OF) && defined(CONFIG_OF_IRQ) |
d35fb641 | 453 | ret = platform_driver_register(&isp1760_of_driver); |
f7e7aa58 CM |
454 | if (!ret) |
455 | any_ret = 0; | |
db11e47d | 456 | #endif |
ff30bf1c | 457 | #ifdef CONFIG_PCI |
db11e47d | 458 | ret = pci_register_driver(&isp1761_pci_driver); |
f7e7aa58 CM |
459 | if (!ret) |
460 | any_ret = 0; | |
db11e47d | 461 | #endif |
db11e47d | 462 | |
f7e7aa58 CM |
463 | if (any_ret) |
464 | deinit_kmem_cache(); | |
465 | return any_ret; | |
db11e47d SS |
466 | } |
467 | module_init(isp1760_init); | |
468 | ||
469 | static void __exit isp1760_exit(void) | |
470 | { | |
f7e7aa58 | 471 | platform_driver_unregister(&isp1760_plat_driver); |
abf058e1 | 472 | #if defined(CONFIG_OF) && defined(CONFIG_OF_IRQ) |
d35fb641 | 473 | platform_driver_unregister(&isp1760_of_driver); |
db11e47d | 474 | #endif |
ff30bf1c | 475 | #ifdef CONFIG_PCI |
db11e47d SS |
476 | pci_unregister_driver(&isp1761_pci_driver); |
477 | #endif | |
478 | deinit_kmem_cache(); | |
479 | } | |
480 | module_exit(isp1760_exit); |