1
2
3
4
5
6
7
8
9
10
11
12
13#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14
15#include <linux/module.h>
16#include <linux/moduleparam.h>
17#include <linux/types.h>
18#include <linux/kernel.h>
19#include <linux/errno.h>
20#include <linux/device.h>
21#include <linux/ctype.h>
22#include <linux/gpio.h>
23#include <linux/slab.h>
24#include <linux/vme.h>
25
26#include "vme_pio2.h"
27
28
29static const char driver_name[] = "pio2";
30
31static int bus[PIO2_CARDS_MAX];
32static int bus_num;
33static long base[PIO2_CARDS_MAX];
34static int base_num;
35static int vector[PIO2_CARDS_MAX];
36static int vector_num;
37static int level[PIO2_CARDS_MAX];
38static int level_num;
39static char *variant[PIO2_CARDS_MAX];
40static int variant_num;
41
42static bool loopback;
43
44static int pio2_match(struct vme_dev *);
45static int pio2_probe(struct vme_dev *);
46static int pio2_remove(struct vme_dev *);
47
48static int pio2_get_led(struct pio2_card *card)
49{
50
51 return card->led;
52}
53
54static int pio2_set_led(struct pio2_card *card, int state)
55{
56 u8 reg;
57 int retval;
58
59 reg = card->irq_level;
60
61
62 if (!state)
63 reg |= PIO2_LED;
64
65 if (loopback)
66 reg |= PIO2_LOOP;
67
68 retval = vme_master_write(card->window, ®, 1, PIO2_REGS_CTRL);
69 if (retval < 0)
70 return retval;
71
72 card->led = state ? 1 : 0;
73
74 return 0;
75}
76
77static void pio2_int(int level, int vector, void *ptr)
78{
79 int vec, i, channel, retval;
80 u8 reg;
81 struct pio2_card *card = ptr;
82
83 vec = vector & ~PIO2_VME_VECTOR_MASK;
84
85 switch (vec) {
86 case 0:
87 dev_warn(&card->vdev->dev, "Spurious Interrupt\n");
88 break;
89 case 1:
90 case 2:
91 case 3:
92 case 4:
93
94 retval = vme_master_read(card->window, ®, 1,
95 PIO2_REGS_INT_STAT[vec - 1]);
96 if (retval < 0) {
97 dev_err(&card->vdev->dev,
98 "Unable to read IRQ status register\n");
99 return;
100 }
101 for (i = 0; i < 8; i++) {
102 channel = ((vec - 1) * 8) + i;
103 if (reg & PIO2_CHANNEL_BIT[channel])
104 dev_info(&card->vdev->dev,
105 "Interrupt on I/O channel %d\n",
106 channel);
107 }
108 break;
109 case 5:
110 case 6:
111 case 7:
112 case 8:
113 case 9:
114 case 10:
115
116 dev_err(&card->vdev->dev,
117 "Counter interrupt\n");
118 break;
119 }
120}
121
122
123
124
125
126
127static int pio2_reset_card(struct pio2_card *card)
128{
129 int retval = 0;
130 u8 data = 0;
131
132
133 retval = vme_master_write(card->window, &data, 1, PIO2_REGS_CTRL);
134 if (retval < 0)
135 return retval;
136
137
138 retval = vme_master_write(card->window, &data, 1, PIO2_REGS_VME_VECTOR);
139 if (retval < 0)
140 return retval;
141
142
143 retval = pio2_gpio_reset(card);
144 if (retval < 0)
145 return retval;
146
147
148 retval = pio2_cntr_reset(card);
149 if (retval < 0)
150 return retval;
151
152 return 0;
153}
154
155static struct vme_driver pio2_driver = {
156 .name = driver_name,
157 .match = pio2_match,
158 .probe = pio2_probe,
159 .remove = pio2_remove,
160};
161
162
163static int __init pio2_init(void)
164{
165 if (bus_num == 0) {
166 pr_err("No cards, skipping registration\n");
167 return -ENODEV;
168 }
169
170 if (bus_num > PIO2_CARDS_MAX) {
171 pr_err("Driver only able to handle %d PIO2 Cards\n",
172 PIO2_CARDS_MAX);
173 bus_num = PIO2_CARDS_MAX;
174 }
175
176
177 return vme_register_driver(&pio2_driver, bus_num);
178}
179
180static int pio2_match(struct vme_dev *vdev)
181{
182
183 if (vdev->num >= bus_num) {
184 dev_err(&vdev->dev,
185 "The enumeration of the VMEbus to which the board is connected must be specified");
186 return 0;
187 }
188
189 if (vdev->num >= base_num) {
190 dev_err(&vdev->dev,
191 "The VME address for the cards registers must be specified");
192 return 0;
193 }
194
195 if (vdev->num >= vector_num) {
196 dev_err(&vdev->dev,
197 "The IRQ vector used by the card must be specified");
198 return 0;
199 }
200
201 if (vdev->num >= level_num) {
202 dev_err(&vdev->dev,
203 "The IRQ level used by the card must be specified");
204 return 0;
205 }
206
207 if (vdev->num >= variant_num) {
208 dev_err(&vdev->dev, "The variant of the card must be specified");
209 return 0;
210 }
211
212 return 1;
213}
214
215static int pio2_probe(struct vme_dev *vdev)
216{
217 struct pio2_card *card;
218 int retval;
219 int i;
220 u8 reg;
221 int vec;
222
223 card = kzalloc(sizeof(struct pio2_card), GFP_KERNEL);
224 if (card == NULL) {
225 retval = -ENOMEM;
226 goto err_struct;
227 }
228
229 card->id = vdev->num;
230 card->bus = bus[card->id];
231 card->base = base[card->id];
232 card->irq_vector = vector[card->id];
233 card->irq_level = level[card->id] & PIO2_VME_INT_MASK;
234 strncpy(card->variant, variant[card->id], PIO2_VARIANT_LENGTH);
235 card->vdev = vdev;
236
237 for (i = 0; i < PIO2_VARIANT_LENGTH; i++) {
238
239 if (isdigit(card->variant[i]) == 0) {
240 dev_err(&card->vdev->dev, "Variant invalid\n");
241 retval = -EINVAL;
242 goto err_variant;
243 }
244 }
245
246
247
248
249
250 if (card->irq_vector & ~PIO2_VME_VECTOR_MASK) {
251 dev_err(&card->vdev->dev,
252 "Invalid VME IRQ Vector, vector must not use lower 4 bits\n");
253 retval = -EINVAL;
254 goto err_vector;
255 }
256
257
258
259
260
261
262
263
264
265 for (i = 1; i < PIO2_VARIANT_LENGTH; i++) {
266 switch (card->variant[i]) {
267 case '0':
268 card->bank[i-1].config = NOFIT;
269 break;
270 case '1':
271 case '2':
272 case '3':
273 case '4':
274 card->bank[i-1].config = INPUT;
275 break;
276 case '5':
277 card->bank[i-1].config = OUTPUT;
278 break;
279 case '6':
280 case '7':
281 case '8':
282 case '9':
283 card->bank[i-1].config = BOTH;
284 break;
285 }
286 }
287
288
289 card->window = vme_master_request(vdev, VME_A24, VME_SCT, VME_D16);
290 if (card->window == NULL) {
291 dev_err(&card->vdev->dev,
292 "Unable to assign VME master resource\n");
293 retval = -EIO;
294 goto err_window;
295 }
296
297 retval = vme_master_set(card->window, 1, card->base, 0x10000, VME_A24,
298 (VME_SCT | VME_USER | VME_DATA), VME_D16);
299 if (retval) {
300 dev_err(&card->vdev->dev,
301 "Unable to configure VME master resource\n");
302 goto err_set;
303 }
304
305
306
307
308
309
310
311 retval = vme_master_read(card->window, ®, 1, PIO2_REGS_ID);
312 if (retval < 0) {
313 dev_err(&card->vdev->dev, "Unable to read from device\n");
314 goto err_read;
315 }
316
317 dev_dbg(&card->vdev->dev, "ID Register:%x\n", reg);
318
319
320
321
322
323
324 retval = pio2_reset_card(card);
325 if (retval) {
326 dev_err(&card->vdev->dev,
327 "Failed to reset card, is location valid?");
328 retval = -ENODEV;
329 goto err_reset;
330 }
331
332
333 reg = card->irq_level;
334 if (pio2_get_led(card))
335 reg |= PIO2_LED;
336 if (loopback)
337 reg |= PIO2_LOOP;
338 retval = vme_master_write(card->window, ®, 1, PIO2_REGS_CTRL);
339 if (retval < 0)
340 return retval;
341
342
343 retval = vme_master_write(card->window, &card->irq_vector, 1,
344 PIO2_REGS_VME_VECTOR);
345 if (retval < 0)
346 return retval;
347
348
349 vec = card->irq_vector | PIO2_VME_VECTOR_SPUR;
350
351 retval = vme_irq_request(vdev, card->irq_level, vec,
352 &pio2_int, (void *)card);
353 if (retval < 0) {
354 dev_err(&card->vdev->dev,
355 "Unable to attach VME interrupt vector0x%x, level 0x%x\n",
356 vec, card->irq_level);
357 goto err_irq;
358 }
359
360
361 for (i = 0; i < 4; i++) {
362 vec = card->irq_vector | PIO2_VECTOR_BANK[i];
363
364 retval = vme_irq_request(vdev, card->irq_level, vec,
365 &pio2_int, (void *)card);
366 if (retval < 0) {
367 dev_err(&card->vdev->dev,
368 "Unable to attach VME interrupt vector0x%x, level 0x%x\n",
369 vec, card->irq_level);
370 goto err_gpio_irq;
371 }
372 }
373
374
375 for (i = 0; i < 6; i++) {
376 vec = card->irq_vector | PIO2_VECTOR_CNTR[i];
377
378 retval = vme_irq_request(vdev, card->irq_level, vec,
379 &pio2_int, (void *)card);
380 if (retval < 0) {
381 dev_err(&card->vdev->dev,
382 "Unable to attach VME interrupt vector0x%x, level 0x%x\n",
383 vec, card->irq_level);
384 goto err_cntr_irq;
385 }
386 }
387
388
389 retval = pio2_gpio_init(card);
390 if (retval < 0) {
391 dev_err(&card->vdev->dev,
392 "Unable to register with GPIO framework\n");
393 goto err_gpio;
394 }
395
396
397 retval = pio2_set_led(card, 0);
398 if (retval < 0) {
399 dev_err(&card->vdev->dev, "Unable to set LED\n");
400 goto err_led;
401 }
402
403 dev_set_drvdata(&card->vdev->dev, card);
404
405 dev_info(&card->vdev->dev,
406 "PIO2 (variant %s) configured at 0x%lx\n", card->variant,
407 card->base);
408
409 return 0;
410
411err_led:
412 pio2_gpio_exit(card);
413err_gpio:
414 i = 6;
415err_cntr_irq:
416 while (i > 0) {
417 i--;
418 vec = card->irq_vector | PIO2_VECTOR_CNTR[i];
419 vme_irq_free(vdev, card->irq_level, vec);
420 }
421
422 i = 4;
423err_gpio_irq:
424 while (i > 0) {
425 i--;
426 vec = card->irq_vector | PIO2_VECTOR_BANK[i];
427 vme_irq_free(vdev, card->irq_level, vec);
428 }
429
430 vec = (card->irq_vector & PIO2_VME_VECTOR_MASK) | PIO2_VME_VECTOR_SPUR;
431 vme_irq_free(vdev, card->irq_level, vec);
432err_irq:
433 pio2_reset_card(card);
434err_reset:
435err_read:
436 vme_master_set(card->window, 0, 0, 0, VME_A16, 0, VME_D16);
437err_set:
438 vme_master_free(card->window);
439err_window:
440err_vector:
441err_variant:
442 kfree(card);
443err_struct:
444 return retval;
445}
446
447static int pio2_remove(struct vme_dev *vdev)
448{
449 int vec;
450 int i;
451
452 struct pio2_card *card = dev_get_drvdata(&vdev->dev);
453
454 pio2_gpio_exit(card);
455
456 for (i = 0; i < 6; i++) {
457 vec = card->irq_vector | PIO2_VECTOR_CNTR[i];
458 vme_irq_free(vdev, card->irq_level, vec);
459 }
460
461 for (i = 0; i < 4; i++) {
462 vec = card->irq_vector | PIO2_VECTOR_BANK[i];
463 vme_irq_free(vdev, card->irq_level, vec);
464 }
465
466 vec = (card->irq_vector & PIO2_VME_VECTOR_MASK) | PIO2_VME_VECTOR_SPUR;
467 vme_irq_free(vdev, card->irq_level, vec);
468
469 pio2_reset_card(card);
470
471 vme_master_set(card->window, 0, 0, 0, VME_A16, 0, VME_D16);
472
473 vme_master_free(card->window);
474
475 kfree(card);
476
477 return 0;
478}
479
480static void __exit pio2_exit(void)
481{
482 vme_unregister_driver(&pio2_driver);
483}
484
485
486
487MODULE_PARM_DESC(bus, "Enumeration of VMEbus to which the board is connected");
488module_param_array(bus, int, &bus_num, S_IRUGO);
489
490MODULE_PARM_DESC(base, "Base VME address for PIO2 Registers");
491module_param_array(base, long, &base_num, S_IRUGO);
492
493MODULE_PARM_DESC(vector, "VME IRQ Vector (Lower 4 bits masked)");
494module_param_array(vector, int, &vector_num, S_IRUGO);
495
496MODULE_PARM_DESC(level, "VME IRQ Level");
497module_param_array(level, int, &level_num, S_IRUGO);
498
499MODULE_PARM_DESC(variant, "Last 4 characters of PIO2 board variant");
500module_param_array(variant, charp, &variant_num, S_IRUGO);
501
502
503MODULE_PARM_DESC(loopback, "Enable loopback mode on all cards");
504module_param(loopback, bool, S_IRUGO);
505
506MODULE_DESCRIPTION("GE PIO2 6U VME I/O Driver");
507MODULE_AUTHOR("Martyn Welch <martyn.welch@ge.com");
508MODULE_LICENSE("GPL");
509
510module_init(pio2_init);
511module_exit(pio2_exit);
512
513