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