Add ar7-2.6 port (marked as broken for now).
[openwrt/svn-archive/archive.git] / target / linux / ar7-2.6 / files / arch / mips / ar7 / vlynq.c
1 /*
2 * $Id$
3 *
4 * Copyright (C) 2006, 2007 OpenWrt.org
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include <linux/init.h>
22 #include <linux/types.h>
23 #include <linux/kernel.h>
24 #include <linux/string.h>
25 #include <linux/delay.h>
26 #include <linux/device.h>
27 #include <linux/ioport.h>
28 #include <linux/errno.h>
29 #include <linux/platform_device.h>
30 #include <linux/irq.h>
31 #include <linux/interrupt.h>
32 #include <linux/device.h>
33 #include <asm/addrspace.h>
34 #include <asm/io.h>
35 #include <asm/ar7/vlynq.h>
36
37 #define PER_DEVICE_IRQS 32
38
39 #define VLYNQ_CTRL_PM_ENABLE 0x80000000
40 #define VLYNQ_CTRL_CLOCK_INT 0x00008000
41 #define VLYNQ_CTRL_CLOCK_DIV(x) ((x & 7) << 16)
42 #define VLYNQ_CTRL_INT_LOCAL 0x00004000
43 #define VLYNQ_CTRL_INT_ENABLE 0x00002000
44 #define VLYNQ_CTRL_INT_VECTOR(x) ((x & 0x1f) << 8)
45 #define VLYNQ_CTRL_INT2CFG 0x00000080
46 #define VLYNQ_CTRL_RESET 0x00000001
47
48 #define VLYNQ_STATUS_RERROR 0x00000100
49 #define VLYNQ_STATUS_LERROR 0x00000080
50 #define VLYNQ_STATUS_LINK 0x00000001
51
52 #define VINT_ENABLE 0x00000100
53 #define VINT_TYPE_EDGE 0x00000080
54 #define VINT_LEVEL_LOW 0x00000040
55 #define VINT_VECTOR(x) (x & 0x1f)
56 #define VINT_OFFSET(irq) (8 * ((irq) % 4))
57
58 #define VLYNQ_AUTONEGO_V2 0x00010000
59
60 struct vlynq_regs {
61 volatile u32 revision;
62 volatile u32 control;
63 volatile u32 status;
64 volatile u32 int_prio;
65 volatile u32 int_status;
66 volatile u32 int_pending;
67 volatile u32 int_ptr;
68 volatile u32 tx_offset;
69 volatile struct vlynq_mapping rx_mapping[4];
70 volatile u32 chip;
71 volatile u32 autonego;
72 volatile u32 unused[6];
73 volatile u32 int_device[8];
74 } __attribute__ ((packed));
75
76 #ifdef VLYNQ_DEBUG
77 static void vlynq_dump_regs(struct vlynq_device *dev)
78 {
79 int i;
80 printk("VLYNQ local=%p remote=%p\n", dev->local, dev->remote);
81 for (i = 0; i < 32; i++) {
82 printk("VLYNQ: local %d: %08x\n", i + 1, ((u32 *)dev->local)[i]);
83 printk("VLYNQ: remote %d: %08x\n", i + 1, ((u32 *)dev->remote)[i]);
84 }
85 }
86
87 static void vlynq_dump_mem(u32 *base, int count)
88 {
89 int i;
90 for (i = 0; i < (count + 3) / 4; i++) {
91 if (i % 4 == 0) printk("\nMEM[0x%04x]:", i * 4);
92 printk(" 0x%08x", *(base + i));
93 }
94 printk("\n");
95 }
96 #endif
97
98 int vlynq_linked(struct vlynq_device *dev)
99 {
100 int i;
101 for (i = 0; i < 10; i++)
102 if (dev->local->status & VLYNQ_STATUS_LINK) {
103 printk("%s: linked\n", dev->dev.bus_id);
104 return 1;
105 } else {
106 mdelay(1);
107 }
108 return 0;
109 }
110
111 static void vlynq_irq_unmask(unsigned int irq)
112 {
113 volatile u32 val;
114 struct vlynq_device *dev = irq_desc[irq].chip_data;
115 int virq;
116
117 BUG_ON(!dev);
118 virq = irq - dev->irq_start;
119 val = dev->remote->int_device[virq >> 2];
120 val |= VINT_ENABLE << VINT_OFFSET(virq);
121 dev->remote->int_device[virq >> 2] = val;
122 }
123
124 static void vlynq_irq_mask(unsigned int irq)
125 {
126 volatile u32 val;
127 struct vlynq_device *dev = irq_desc[irq].chip_data;
128 int virq;
129
130 BUG_ON(!dev);
131 virq = irq - dev->irq_start;
132 val = dev->remote->int_device[virq >> 2];
133 val &= ~(VINT_ENABLE << VINT_OFFSET(virq));
134 dev->remote->int_device[virq >> 2] = val;
135 }
136
137 static int vlynq_irq_type(unsigned int irq, unsigned int flow_type)
138 {
139 volatile u32 val;
140 struct vlynq_device *dev = irq_desc[irq].chip_data;
141 int virq;
142
143 BUG_ON(!dev);
144 virq = irq - dev->irq_start;
145 val = dev->remote->int_device[virq >> 2];
146 switch (flow_type & IRQ_TYPE_SENSE_MASK) {
147 case IRQ_TYPE_EDGE_RISING:
148 case IRQ_TYPE_EDGE_FALLING:
149 case IRQ_TYPE_EDGE_BOTH:
150 val |= VINT_TYPE_EDGE << VINT_OFFSET(virq);
151 val &= ~(VINT_LEVEL_LOW << VINT_OFFSET(virq));
152 break;
153 case IRQ_TYPE_LEVEL_HIGH:
154 val &= ~(VINT_TYPE_EDGE << VINT_OFFSET(virq));
155 val &= ~(VINT_LEVEL_LOW << VINT_OFFSET(virq));
156 break;
157 case IRQ_TYPE_LEVEL_LOW:
158 val &= ~(VINT_TYPE_EDGE << VINT_OFFSET(virq));
159 val |= VINT_LEVEL_LOW << VINT_OFFSET(virq);
160 break;
161 default:
162 return -EINVAL;
163 }
164 dev->remote->int_device[virq >> 2] = val;
165 return 0;
166 }
167
168 static irqreturn_t vlynq_irq(int irq, void *dev_id)
169 {
170 struct vlynq_device *dev = dev_id;
171 u32 status, ack;
172 int virq = 0;
173
174 status = dev->local->int_status;
175 dev->local->int_status = status;
176
177 if (status & (1 << dev->local_irq)) { /* Local vlynq IRQ. Ack */
178 ack = dev->local->status;
179 dev->local->status = ack;
180 }
181
182 if (status & (1 << dev->remote_irq)) { /* Remote vlynq IRQ. Ack */
183 ack = dev->remote->status;
184 dev->remote->status = ack;
185 }
186
187 status &= ~((1 << dev->local_irq) | (1 << dev->remote_irq));
188 while (status) {
189 if (status & 1) /* Remote device IRQ. Pass. */
190 do_IRQ(dev->irq_start + virq);
191 status >>= 1;
192 virq++;
193 }
194
195 return IRQ_HANDLED;
196 }
197
198 static struct irq_chip vlynq_irq_chip = {
199 .name = "vlynq",
200 .unmask = vlynq_irq_unmask,
201 .mask = vlynq_irq_mask,
202 .set_type = vlynq_irq_type,
203 };
204
205 static int vlynq_setup_irq(struct vlynq_device *dev)
206 {
207 u32 val;
208 int i;
209
210 if (dev->local_irq == dev->remote_irq) {
211 printk("%s: local vlynq irq should be different from remote\n",
212 dev->dev.bus_id);
213 return -EINVAL;
214 }
215
216 val = VLYNQ_CTRL_INT_VECTOR(dev->local_irq);
217 val |= VLYNQ_CTRL_INT_ENABLE | VLYNQ_CTRL_INT_LOCAL |
218 VLYNQ_CTRL_INT2CFG;
219 dev->local->int_ptr = 0x14;
220 dev->local->control |= val;
221
222 val = VLYNQ_CTRL_INT_VECTOR(dev->remote_irq);
223 val |= VLYNQ_CTRL_INT_ENABLE;
224 dev->remote->int_ptr = 0x14;
225 dev->remote->control |= val;
226
227 for (i = 0; i < PER_DEVICE_IRQS; i++) {
228 if ((i == dev->local_irq) || (i == dev->remote_irq))
229 continue;
230 irq_desc[dev->irq_start + i].status = IRQ_DISABLED;
231 irq_desc[dev->irq_start + i].action = 0;
232 irq_desc[dev->irq_start + i].depth = 1;
233 irq_desc[dev->irq_start + i].chip = &vlynq_irq_chip;
234 irq_desc[dev->irq_start + i].chip_data = dev;
235 dev->remote->int_device[i >> 2] = 0;
236 }
237
238 if (request_irq(dev->irq, vlynq_irq, SA_SHIRQ, "AR7 VLYNQ", dev)) {
239 printk("%s: request_irq failed\n", dev->dev.bus_id);
240 return -EAGAIN;
241 }
242
243 return 0;
244 }
245
246 static void vlynq_free_irq(struct vlynq_device *dev)
247 {
248 free_irq(dev->irq, dev);
249 }
250
251 static void vlynq_device_release(struct device *dev)
252 {
253 struct vlynq_device *vdev = to_vlynq_device(dev);
254 kfree(vdev);
255 }
256
257 static int vlynq_device_probe(struct device *dev)
258 {
259 struct vlynq_driver *drv = to_vlynq_driver(dev->driver);
260 if (drv->probe)
261 return drv->probe(to_vlynq_device(dev));
262 return 0;
263 }
264
265 static int vlynq_device_remove(struct device *dev)
266 {
267 struct vlynq_driver *drv = to_vlynq_driver(dev->driver);
268 if (drv->remove)
269 return drv->remove(to_vlynq_device(dev));
270 return 0;
271 }
272
273 int __vlynq_register_driver(struct vlynq_driver *driver, struct module *owner)
274 {
275 driver->driver.name = driver->name;
276 driver->driver.bus = &vlynq_bus_type;
277 /* driver->driver.owner = owner;*/
278 return driver_register(&driver->driver);
279 }
280 EXPORT_SYMBOL(__vlynq_register_driver);
281
282 void vlynq_unregister_driver(struct vlynq_driver *driver)
283 {
284 driver_unregister(&driver->driver);
285 }
286 EXPORT_SYMBOL(vlynq_unregister_driver);
287
288 int vlynq_device_enable(struct vlynq_device *dev)
289 {
290 u32 val;
291 int result;
292 struct plat_vlynq_ops *ops = dev->dev.platform_data;
293
294 result = ops->on(dev);
295 if (result)
296 return result;
297
298 dev->local->control = 0;
299 dev->remote->control = 0;
300
301 if (vlynq_linked(dev))
302 return vlynq_setup_irq(dev);
303
304 for (val = 0; val < 8; val++) {
305 dev->local->control = VLYNQ_CTRL_CLOCK_DIV(val) |
306 VLYNQ_CTRL_CLOCK_INT;
307 if (vlynq_linked(dev))
308 return vlynq_setup_irq(dev);
309 }
310 }
311
312 void vlynq_device_disable(struct vlynq_device *dev)
313 {
314 struct plat_vlynq_ops *ops = dev->dev.platform_data;
315
316 vlynq_free_irq(dev);
317 ops->off(dev);
318 }
319
320 u32 vlynq_local_id(struct vlynq_device *dev)
321 {
322 return dev->local->chip;
323 }
324
325 u32 vlynq_remote_id(struct vlynq_device *dev)
326 {
327 return dev->remote->chip;
328 }
329
330 void vlynq_set_local_mapping(struct vlynq_device *dev, u32 tx_offset,
331 struct vlynq_mapping *mapping)
332 {
333 int i;
334
335 dev->local->tx_offset = tx_offset;
336 for (i = 0; i < 4; i++) {
337 dev->local->rx_mapping[i].offset = mapping[i].offset;
338 dev->local->rx_mapping[i].size = mapping[i].size;
339 }
340 }
341
342 void vlynq_set_remote_mapping(struct vlynq_device *dev, u32 tx_offset,
343 struct vlynq_mapping *mapping)
344 {
345 int i;
346
347 dev->remote->tx_offset = tx_offset;
348 for (i = 0; i < 4; i++) {
349 dev->remote->rx_mapping[i].offset = mapping[i].offset;
350 dev->remote->rx_mapping[i].size = mapping[i].size;
351 }
352 }
353
354 int vlynq_virq_to_irq(struct vlynq_device *dev, int virq)
355 {
356 if ((virq < 0) || (virq >= PER_DEVICE_IRQS))
357 return -EINVAL;
358
359 if ((virq == dev->local_irq) || (virq == dev->remote_irq))
360 return -EINVAL;
361
362 return dev->irq_start + virq;
363 }
364
365 int vlynq_irq_to_virq(struct vlynq_device *dev, int irq)
366 {
367 if ((irq < dev->irq_start) || (irq >= dev->irq_start + PER_DEVICE_IRQS))
368 return -EINVAL;
369
370 return irq - dev->irq_start;
371 }
372
373 int vlynq_set_local_irq(struct vlynq_device *dev, int virq)
374 {
375 if ((virq < 0) || (virq >= PER_DEVICE_IRQS))
376 return -EINVAL;
377
378 if (virq == dev->remote_irq)
379 return -EINVAL;
380
381 dev->local_irq = virq;
382
383 return 0;
384 }
385
386 int vlynq_set_remote_irq(struct vlynq_device *dev, int virq)
387 {
388 if ((virq < 0) || (virq >= PER_DEVICE_IRQS))
389 return -EINVAL;
390
391 if (virq == dev->local_irq)
392 return -EINVAL;
393
394 dev->remote_irq = virq;
395
396 return 0;
397 }
398
399 static int vlynq_probe(struct platform_device *pdev)
400 {
401 struct vlynq_device *dev;
402 struct resource *regs_res, *mem_res, *irq_res;
403 int len, result;
404
405 if (strcmp(pdev->name, "vlynq"))
406 return -ENODEV;
407
408 regs_res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "regs");
409 if (!regs_res)
410 return -ENODEV;
411
412 mem_res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "mem");
413 if (!mem_res)
414 return -ENODEV;
415
416 irq_res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "devirq");
417 if (!irq_res)
418 return -ENODEV;
419
420 dev = kmalloc(sizeof(struct vlynq_device), GFP_KERNEL);
421 if (!dev) {
422 printk(KERN_ERR "vlynq: failed to allocate device structure\n");
423 return -ENOMEM;
424 }
425
426 memset(dev, 0, sizeof(struct vlynq_device));
427
428 dev->id = pdev->id;
429 dev->dev.bus = &vlynq_bus_type;
430 dev->dev.parent = &pdev->dev;
431 snprintf(dev->dev.bus_id, BUS_ID_SIZE, "vlynq%d", dev->id);
432 dev->dev.bus_id[BUS_ID_SIZE - 1] = 0;
433 dev->dev.platform_data = pdev->dev.platform_data;
434 dev->dev.release = vlynq_device_release;
435
436 dev->regs_start = regs_res->start;
437 dev->regs_end = regs_res->end;
438 dev->mem_start = mem_res->start;
439 dev->mem_end = mem_res->end;
440
441 len = regs_res->end - regs_res->start;
442 if (!request_mem_region(regs_res->start, len, dev->dev.bus_id)) {
443 printk("%s: Can't request vlynq registers\n", dev->dev.bus_id);
444 result = -ENXIO;
445 goto fail_request;
446 }
447
448 dev->local = ioremap_nocache(regs_res->start, len);
449 if (!dev->local) {
450 printk("%s: Can't remap vlynq registers\n", dev->dev.bus_id);
451 result = -ENXIO;
452 goto fail_remap;
453 }
454
455 dev->remote = (struct vlynq_regs *)((u32)dev->local + 128);
456
457 dev->irq = platform_get_irq_byname(pdev, "irq");
458 dev->irq_start = irq_res->start;
459 dev->irq_end = irq_res->end;
460 dev->local_irq = 31;
461 dev->remote_irq = 30;
462
463 if (device_register(&dev->dev))
464 goto fail_register;
465 platform_set_drvdata(pdev, dev);
466
467 printk("%s: regs 0x%p, irq %d, mem 0x%p\n",
468 dev->dev.bus_id, (void *)dev->regs_start, dev->irq,
469 (void *)dev->mem_start);
470
471 return 0;
472
473 fail_register:
474 fail_remap:
475 iounmap(dev->local);
476 fail_request:
477 release_mem_region(regs_res->start, len);
478 kfree(dev);
479 return result;
480 }
481
482 static int vlynq_remove(struct platform_device *pdev)
483 {
484 struct vlynq_device *dev = platform_get_drvdata(pdev);
485
486 device_unregister(&dev->dev);
487 release_mem_region(dev->regs_start, dev->regs_end - dev->regs_start);
488
489 kfree(dev);
490
491 return 0;
492 }
493
494 static struct platform_driver vlynq_driver = {
495 .driver.name = "vlynq",
496 .probe = vlynq_probe,
497 .remove = vlynq_remove,
498 };
499
500 struct bus_type vlynq_bus_type = {
501 .name = "vlynq",
502 .probe = vlynq_device_probe,
503 .remove = vlynq_device_remove,
504 };
505 EXPORT_SYMBOL(vlynq_bus_type);
506
507 #ifdef CONFIG_PCI
508 extern void vlynq_pci_init(void);
509 #endif
510 int __init vlynq_init(void)
511 {
512 int res = 0;
513
514 res = bus_register(&vlynq_bus_type);
515 if (res)
516 goto fail_bus;
517
518 res = platform_driver_register(&vlynq_driver);
519 if (res)
520 goto fail_platform;
521
522 #ifdef CONFIG_PCI
523 vlynq_pci_init();
524 #endif
525
526 return 0;
527
528 fail_platform:
529 bus_unregister(&vlynq_bus_type);
530 fail_bus:
531 return res;
532 }
533
534 /*
535 void __devexit vlynq_exit(void)
536 {
537 platform_driver_unregister(&vlynq_driver);
538 bus_unregister(&vlynq_bus_type);
539 }
540 */
541
542
543 subsys_initcall(vlynq_init);