2 * GE PIO2 6U VME I/O Driver
4 * Author: Martyn Welch <martyn.welch@ge.com>
5 * Copyright 2009 GE Intelligent Platforms Embedded Systems, Inc.
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2 of the License, or (at your
10 * option) any later version.
13 #include <linux/module.h>
14 #include <linux/moduleparam.h>
15 #include <linux/types.h>
16 #include <linux/kernel.h>
17 #include <linux/errno.h>
18 #include <linux/device.h>
19 #include <linux/ctype.h>
20 #include <linux/gpio.h>
21 #include <linux/slab.h>
22 #include <linux/vme.h>
27 static const char driver_name[] = "pio2";
29 static int bus[PIO2_CARDS_MAX];
31 static long base[PIO2_CARDS_MAX];
33 static int vector[PIO2_CARDS_MAX];
34 static int vector_num;
35 static int level[PIO2_CARDS_MAX];
37 static char *variant[PIO2_CARDS_MAX];
38 static int variant_num;
42 static int pio2_match(struct vme_dev *);
43 static int __devinit pio2_probe(struct vme_dev *);
44 static int __devexit pio2_remove(struct vme_dev *);
46 static int pio2_get_led(struct pio2_card *card)
48 /* Can't read hardware, state saved in structure */
52 static int pio2_set_led(struct pio2_card *card, int state)
57 reg = card->irq_level;
59 /* Register state inverse of led state */
66 retval = vme_master_write(card->window, ®, 1, PIO2_REGS_CTRL);
70 card->led = state ? 1 : 0;
75 static void pio2_int(int level, int vector, void *ptr)
77 int vec, i, channel, retval;
79 struct pio2_card *card = ptr;
81 vec = vector & ~PIO2_VME_VECTOR_MASK;
85 dev_warn(&card->vdev->dev, "Spurious Interrupt\n");
92 retval = vme_master_read(card->window, ®, 1,
93 PIO2_REGS_INT_STAT[vec - 1]);
95 dev_err(&card->vdev->dev,
96 "Unable to read IRQ status register\n");
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",
113 /* Counters are dealt with by their own handler */
114 dev_err(&card->vdev->dev,
115 "Counter interrupt\n");
122 * We return whether this has been successful - this is used in the probe to
123 * ensure we have a valid card.
125 static int pio2_reset_card(struct pio2_card *card)
130 /* Clear main register*/
131 retval = vme_master_write(card->window, &data, 1, PIO2_REGS_CTRL);
135 /* Clear VME vector */
136 retval = vme_master_write(card->window, &data, 1, PIO2_REGS_VME_VECTOR);
141 retval = pio2_gpio_reset(card);
146 retval = pio2_cntr_reset(card);
153 static struct vme_driver pio2_driver = {
157 .remove = __devexit_p(pio2_remove),
161 static int __init pio2_init(void)
166 printk(KERN_ERR "%s: No cards, skipping registration\n",
171 if (bus_num > PIO2_CARDS_MAX) {
173 "%s: Driver only able to handle %d PIO2 Cards\n",
174 driver_name, PIO2_CARDS_MAX);
175 bus_num = PIO2_CARDS_MAX;
178 /* Register the PIO2 driver */
179 retval = vme_register_driver(&pio2_driver, bus_num);
190 static int pio2_match(struct vme_dev *vdev)
193 if (vdev->num >= bus_num) {
195 "The enumeration of the VMEbus to which the board is connected must be specified");
199 if (vdev->num >= base_num) {
201 "The VME address for the cards registers must be specified");
205 if (vdev->num >= vector_num) {
207 "The IRQ vector used by the card must be specified");
211 if (vdev->num >= level_num) {
213 "The IRQ level used by the card must be specified");
217 if (vdev->num >= variant_num) {
218 dev_err(&vdev->dev, "The variant of the card must be specified");
225 static int __devinit pio2_probe(struct vme_dev *vdev)
227 struct pio2_card *card;
233 card = kzalloc(sizeof(struct pio2_card), GFP_KERNEL);
235 dev_err(&vdev->dev, "Unable to allocate card structure\n");
240 card->id = vdev->num;
241 card->bus = bus[card->id];
242 card->base = base[card->id];
243 card->irq_vector = vector[card->id];
244 card->irq_level = level[card->id] & PIO2_VME_INT_MASK;
245 strncpy(card->variant, variant[card->id], PIO2_VARIANT_LENGTH);
248 for (i = 0; i < PIO2_VARIANT_LENGTH; i++) {
250 if (isdigit(card->variant[i]) == 0) {
251 dev_err(&card->vdev->dev, "Variant invalid\n");
258 * Bottom 4 bits of VME interrupt vector used to determine source,
259 * provided vector should only use upper 4 bits.
261 if (card->irq_vector & ~PIO2_VME_VECTOR_MASK) {
262 dev_err(&card->vdev->dev,
263 "Invalid VME IRQ Vector, vector must not use lower 4 bits\n");
269 * There is no way to determine the build variant or whether each bank
270 * is input, output or both at run time. The inputs are also inverted
271 * if configured as both.
273 * We pass in the board variant and use that to determine the
274 * configuration of the banks.
276 for (i = 1; i < PIO2_VARIANT_LENGTH; i++) {
277 switch (card->variant[i]) {
279 card->bank[i-1].config = NOFIT;
285 card->bank[i-1].config = INPUT;
288 card->bank[i-1].config = OUTPUT;
294 card->bank[i-1].config = BOTH;
299 /* Get a master window and position over regs */
300 card->window = vme_master_request(vdev, VME_A24, VME_SCT, VME_D16);
301 if (card->window == NULL) {
302 dev_err(&card->vdev->dev,
303 "Unable to assign VME master resource\n");
308 retval = vme_master_set(card->window, 1, card->base, 0x10000, VME_A24,
309 (VME_SCT | VME_USER | VME_DATA), VME_D16);
311 dev_err(&card->vdev->dev,
312 "Unable to configure VME master resource\n");
317 * There is also no obvious register which we can probe to determine
318 * whether the provided base is valid. If we can read the "ID Register"
319 * offset and the reset function doesn't error, assume we have a valid
322 retval = vme_master_read(card->window, ®, 1, PIO2_REGS_ID);
324 dev_err(&card->vdev->dev, "Unable to read from device\n");
328 dev_dbg(&card->vdev->dev, "ID Register:%x\n", reg);
331 * Ensure all the I/O is cleared. We can't read back the states, so
332 * this is the only method we have to ensure that the I/O is in a known
335 retval = pio2_reset_card(card);
337 dev_err(&card->vdev->dev,
338 "Failed to reset card, is location valid?");
343 /* Configure VME Interrupts */
344 reg = card->irq_level;
345 if (pio2_get_led(card))
349 retval = vme_master_write(card->window, ®, 1, PIO2_REGS_CTRL);
354 retval = vme_master_write(card->window, &card->irq_vector, 1,
355 PIO2_REGS_VME_VECTOR);
359 /* Attach spurious interrupt handler. */
360 vec = card->irq_vector | PIO2_VME_VECTOR_SPUR;
362 retval = vme_irq_request(vdev, card->irq_level, vec,
363 &pio2_int, (void *)card);
365 dev_err(&card->vdev->dev,
366 "Unable to attach VME interrupt vector0x%x, level 0x%x\n",
367 vec, card->irq_level);
371 /* Attach GPIO interrupt handlers. */
372 for (i = 0; i < 4; i++) {
373 vec = card->irq_vector | PIO2_VECTOR_BANK[i];
375 retval = vme_irq_request(vdev, card->irq_level, vec,
376 &pio2_int, (void *)card);
378 dev_err(&card->vdev->dev,
379 "Unable to attach VME interrupt vector0x%x, level 0x%x\n",
380 vec, card->irq_level);
385 /* Attach counter interrupt handlers. */
386 for (i = 0; i < 6; i++) {
387 vec = card->irq_vector | PIO2_VECTOR_CNTR[i];
389 retval = vme_irq_request(vdev, card->irq_level, vec,
390 &pio2_int, (void *)card);
392 dev_err(&card->vdev->dev,
393 "Unable to attach VME interrupt vector0x%x, level 0x%x\n",
394 vec, card->irq_level);
400 retval = pio2_gpio_init(card);
402 dev_err(&card->vdev->dev,
403 "Unable to register with GPIO framework\n");
407 /* Set LED - This also sets interrupt level */
408 retval = pio2_set_led(card, 0);
410 dev_err(&card->vdev->dev, "Unable to set LED\n");
414 dev_set_drvdata(&card->vdev->dev, card);
416 dev_info(&card->vdev->dev,
417 "PIO2 (variant %s) configured at 0x%lx\n", card->variant,
423 pio2_gpio_exit(card);
429 vec = card->irq_vector | PIO2_VECTOR_CNTR[i];
430 vme_irq_free(vdev, card->irq_level, vec);
437 vec = card->irq_vector | PIO2_VECTOR_BANK[i];
438 vme_irq_free(vdev, card->irq_level, vec);
441 vec = (card->irq_vector & PIO2_VME_VECTOR_MASK) | PIO2_VME_VECTOR_SPUR;
442 vme_irq_free(vdev, card->irq_level, vec);
444 pio2_reset_card(card);
447 vme_master_set(card->window, 0, 0, 0, VME_A16, 0, VME_D16);
449 vme_master_free(card->window);
458 static int __devexit pio2_remove(struct vme_dev *vdev)
463 struct pio2_card *card = dev_get_drvdata(&vdev->dev);
465 pio2_gpio_exit(card);
467 for (i = 0; i < 6; i++) {
468 vec = card->irq_vector | PIO2_VECTOR_CNTR[i];
469 vme_irq_free(vdev, card->irq_level, vec);
472 for (i = 0; i < 4; i++) {
473 vec = card->irq_vector | PIO2_VECTOR_BANK[i];
474 vme_irq_free(vdev, card->irq_level, vec);
477 vec = (card->irq_vector & PIO2_VME_VECTOR_MASK) | PIO2_VME_VECTOR_SPUR;
478 vme_irq_free(vdev, card->irq_level, vec);
480 pio2_reset_card(card);
482 vme_master_set(card->window, 0, 0, 0, VME_A16, 0, VME_D16);
484 vme_master_free(card->window);
491 static void __exit pio2_exit(void)
493 vme_unregister_driver(&pio2_driver);
497 /* These are required for each board */
498 MODULE_PARM_DESC(bus, "Enumeration of VMEbus to which the board is connected");
499 module_param_array(bus, int, &bus_num, S_IRUGO);
501 MODULE_PARM_DESC(base, "Base VME address for PIO2 Registers");
502 module_param_array(base, long, &base_num, S_IRUGO);
504 MODULE_PARM_DESC(vector, "VME IRQ Vector (Lower 4 bits masked)");
505 module_param_array(vector, int, &vector_num, S_IRUGO);
507 MODULE_PARM_DESC(level, "VME IRQ Level");
508 module_param_array(level, int, &level_num, S_IRUGO);
510 MODULE_PARM_DESC(variant, "Last 4 characters of PIO2 board variant");
511 module_param_array(variant, charp, &variant_num, S_IRUGO);
513 /* This is for debugging */
514 MODULE_PARM_DESC(loopback, "Enable loopback mode on all cards");
515 module_param(loopback, bool, S_IRUGO);
517 MODULE_DESCRIPTION("GE PIO2 6U VME I/O Driver");
518 MODULE_AUTHOR("Martyn Welch <martyn.welch@ge.com");
519 MODULE_LICENSE("GPL");
521 module_init(pio2_init);
522 module_exit(pio2_exit);