drivers/staging/vme/devices/vme_pio2_core.c

   1 /*
   2  * GE PIO2 6U VME I/O Driver
   3  *
   4  * Author: Martyn Welch <martyn.welch@ge.com>
   5  * Copyright 2009 GE Intelligent Platforms Embedded Systems, Inc.
   6  *
   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.
  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
  27 static const char driver_name[] = "pio2";
  28
  29 static int bus[PIO2_CARDS_MAX];
  30 static int bus_num;
  31 static long base[PIO2_CARDS_MAX];
  32 static int base_num;
  33 static int vector[PIO2_CARDS_MAX];
  34 static int vector_num;
  35 static int level[PIO2_CARDS_MAX];
  36 static int level_num;
  37 static char *variant[PIO2_CARDS_MAX];
  38 static int variant_num;
  39
  40 static bool loopback;
  41
  42 static int pio2_match(struct vme_dev *);
  43 static int pio2_probe(struct vme_dev *);
  44 static int pio2_remove(struct vme_dev *);
  45
  46 static int pio2_get_led(struct pio2_card *card)
  47 {
  48         /* Can't read hardware, state saved in structure */
  49         return card->led;
  50 }
  51
  52 static 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         /* Register state inverse of led state */
  60         if (!state)
  61                 reg |= PIO2_LED;
  62
  63         if (loopback)
  64                 reg |= PIO2_LOOP;
  65
  66         retval = vme_master_write(card->window, &reg, 1, PIO2_REGS_CTRL);
  67         if (retval < 0)
  68                 return retval;
  69
  70         card->led = state ? 1 : 0;
  71
  72         return 0;
  73 }
  74
  75 static 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                 /* Channels 0 to 7 */
  92                 retval = vme_master_read(card->window, &reg, 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                 /* Counters are dealt with by their own handler */
 114                 dev_err(&card->vdev->dev,
 115                         "Counter interrupt\n");
 116                 break;
 117         }
 118 }
 119
 120 /*
 121  * We return whether this has been successful - this is used in the probe to
 122  * ensure we have a valid card.
 123  */
 124 static int pio2_reset_card(struct pio2_card *card)
 125 {
 126         int retval = 0;
 127         u8 data = 0;
 128
 129         /* Clear main register*/
 130         retval = vme_master_write(card->window, &data, 1, PIO2_REGS_CTRL);
 131         if (retval < 0)
 132                 return retval;
 133
 134         /* Clear VME vector */
 135         retval = vme_master_write(card->window, &data, 1, PIO2_REGS_VME_VECTOR);
 136         if (retval < 0)
 137                 return retval;
 138
 139         /* Reset GPIO */
 140         retval = pio2_gpio_reset(card);
 141         if (retval < 0)
 142                 return retval;
 143
 144         /* Reset counters */
 145         retval = pio2_cntr_reset(card);
 146         if (retval < 0)
 147                 return retval;
 148
 149         return 0;
 150 }
 151
 152 static struct vme_driver pio2_driver = {
 153         .name = driver_name,
 154         .match = pio2_match,
 155         .probe = pio2_probe,
 156         .remove = pio2_remove,
 157 };
 158
 159 static 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         /* Register the PIO2 driver */
 173         return  vme_register_driver(&pio2_driver, bus_num);
 174 }
 175
 176 static 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
 210 static 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          * Bottom 4 bits of VME interrupt vector used to determine source,
 239          * provided vector should only use upper 4 bits.
 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          * There is no way to determine the build variant or whether each bank
 249          * is input, output or both at run time. The inputs are also inverted
 250          * if configured as both.
 251          *
 252          * We pass in the board variant and use that to determine the
 253          * configuration of the banks.
 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         /* Get a master window and position over regs */
 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          * There is also no obvious register which we can probe to determine
 296          * whether the provided base is valid. If we can read the "ID Register"
 297          * offset and the reset function doesn't error, assume we have a valid
 298          * location.
 299          */
 300         retval = vme_master_read(card->window, &reg, 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          * Ensure all the I/O is cleared. We can't read back the states, so
 310          * this is the only method we have to ensure that the I/O is in a known
 311          * state.
 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         /* Configure VME Interrupts */
 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, &reg, 1, PIO2_REGS_CTRL);
 328         if (retval < 0)
 329                 return retval;
 330
 331         /* Set VME vector */
 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         /* Attach spurious interrupt handler. */
 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         /* Attach GPIO interrupt handlers. */
 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         /* Attach counter interrupt handlers. */
 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         /* Register IO */
 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         /* Set LED - This also sets interrupt level */
 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
 400 err_led:
 401         pio2_gpio_exit(card);
 402 err_gpio:
 403         i = 6;
 404 err_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;
 412 err_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);
 421 err_irq:
 422          pio2_reset_card(card);
 423 err_reset:
 424 err_read:
 425         vme_master_set(card->window, 0, 0, 0, VME_A16, 0, VME_D16);
 426 err_set:
 427         vme_master_free(card->window);
 428         return retval;
 429 }
 430
 431 static 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
 462 static void __exit pio2_exit(void)
 463 {
 464         vme_unregister_driver(&pio2_driver);
 465 }
 466
 467 /* These are required for each board */
 468 MODULE_PARM_DESC(bus, "Enumeration of VMEbus to which the board is connected");
 469 module_param_array(bus, int, &bus_num, S_IRUGO);
 470
 471 MODULE_PARM_DESC(base, "Base VME address for PIO2 Registers");
 472 module_param_array(base, long, &base_num, S_IRUGO);
 473
 474 MODULE_PARM_DESC(vector, "VME IRQ Vector (Lower 4 bits masked)");
 475 module_param_array(vector, int, &vector_num, S_IRUGO);
 476
 477 MODULE_PARM_DESC(level, "VME IRQ Level");
 478 module_param_array(level, int, &level_num, S_IRUGO);
 479
 480 MODULE_PARM_DESC(variant, "Last 4 characters of PIO2 board variant");
 481 module_param_array(variant, charp, &variant_num, S_IRUGO);
 482
 483 /* This is for debugging */
 484 MODULE_PARM_DESC(loopback, "Enable loopback mode on all cards");
 485 module_param(loopback, bool, S_IRUGO);
 486
 487 MODULE_DESCRIPTION("GE PIO2 6U VME I/O Driver");
 488 MODULE_AUTHOR("Martyn Welch <martyn.welch@ge.com");
 489 MODULE_LICENSE("GPL");
 490
 491 module_init(pio2_init);
 492 module_exit(pio2_exit);
 493