vmod/driver/vmodttldrvr.c

   1 #include <linux/kernel.h>
   2 #include <linux/module.h>
   3 #include <linux/pci.h>
   4 #include <linux/init.h>
   5 #include <linux/cdev.h>
   6 #include <linux/fs.h>
   7 #include <linux/spinlock.h>
   8 #include <linux/list.h>
   9 #include <linux/wait.h>
  10 #include <asm/uaccess.h>        /* copy_*_user */
  11 #include <asm/semaphore.h>
  12 #include "vmodttl.h"
  13 #include "cio8536.h"
  14 #include "modulbus_register.h"
  15 #include "lunargs.h"
  16
  17 #define DRIVER_NAME     "vmodttl"
  18 #define PFX             DRIVER_NAME ": "
  19
  20 struct message_list {
  21         struct list_head list;
  22         int dev;
  23         int val;
  24 };
  25
  26 enum vmodttl_channel{
  27      VMOD_TTL_CHANNEL_A,
  28      VMOD_TTL_CHANNEL_B,
  29      VMOD_TTL_CHANNELS_AB
  30 };
  31
  32 struct vmodttl_dev{
  33         int                     created;        /* flag initialize      */
  34         int                     dev;
  35         int                     OpenCount;      /* open count */
  36         int                     io_flag;
  37         int                     us_pulse;       /* Time being up of the data strobe pulse */
  38         int                     open_collector;
  39         spinlock_t              vmodttl_spinlock;
  40         spinlock_t              vmodttl_read;
  41         struct message_list     *messages;
  42         struct vmod_dev         *config;
  43         wait_queue_head_t       wait;
  44         struct vmodttlconfig    ioconfig;
  45 };
  46
  47
  48 /* The One And Only Device (OAOD) */
  49 struct cdev                     cdev;
  50
  51 /* module config tables */
  52 static struct vmod_devices    dt, *dev_table = &dt;
  53
  54 /* The One And Only Device (OAOD) */
  55 static dev_t devno;
  56
  57 static struct vmodttl_dev       *pvmodttlDv[VMODTTL_MAX_BOARDS];
  58
  59
  60 /*
  61  * I/O operations
  62  *
  63  */
  64
  65
  66 static uint16_t vmodttl_read_word(struct vmodttl_dev *pd, int offset)
  67 {
  68
  69         unsigned long ioaddr = 0;
  70         uint16_t val = 0;
  71
  72         ioaddr = pd->config->address + offset;
  73         if (pd->config->is_big_endian)
  74                 val = ioread16be((u16 *)(ioaddr));
  75         else
  76                 val = ioread16((u16 *)(ioaddr));
  77
  78         mb();
  79         return val;
  80 }
  81
  82
  83 static void vmodttl_write_word(struct vmodttl_dev *pd, int offset, uint16_t value)
  84 {
  85         unsigned long ioaddr = pd->config->address + offset;
  86         if(pd->config->is_big_endian)
  87                 iowrite16be(value, (u16 *)ioaddr);
  88         else
  89                 iowrite16(value, (u16 *)ioaddr);
  90
  91         mb();
  92 }
  93
  94 /* Init the ports with the desired setup */
  95 static void vmodttl_def_io(struct vmodttl_dev   *pd)
  96 {
  97         unsigned char   tmp;
  98
  99         /* It has been needed reset MCCR with 0 to avoid a missing configuration of the register DDR_A */
 100         /* Do not delete this two lines! */
 101         vmodttl_write_word(pd, VMODTTL_CONTROL, MCCR);
 102         vmodttl_write_word(pd, VMODTTL_CONTROL, 0);
 103
 104         /* port A               */
 105         /* -------------------- */
 106         /* disable interrupt    */
 107         vmodttl_write_word(pd, VMODTTL_CONTROL, PCSR_A);
 108         vmodttl_write_word(pd, VMODTTL_CONTROL, CLEAR_IE);
 109         /* clear ip/ius         */
 110         vmodttl_write_word(pd, VMODTTL_CONTROL, PCSR_A);
 111         vmodttl_write_word(pd, VMODTTL_CONTROL, CLEAR_IP_IUS);
 112
 113         vmodttl_write_word(pd, VMODTTL_CONTROL, PMSR_A);
 114         vmodttl_write_word(pd, VMODTTL_CONTROL, 0x14);          /* /LPM Latch on Pattern Match  */
 115
 116         if((pd->open_collector & A_CHAN_OPEN_COLLECTOR) == A_CHAN_OPEN_COLLECTOR) {
 117                 /* open collector connection mode */
 118                 if(pd->io_flag & A_CHAN_OUT) {
 119                         vmodttl_write_word(pd, VMODTTL_CONTROL, DDR_A);
 120                         vmodttl_write_word(pd, VMODTTL_CONTROL, 0x00);          /* output       */
 121                         vmodttl_write_word(pd, VMODTTL_CONTROL, DPPR_A);
 122                         vmodttl_write_word(pd, VMODTTL_CONTROL, 0x00);
 123                 } else {
 124                         vmodttl_write_word(pd, VMODTTL_CONTROL, DDR_A);
 125                         vmodttl_write_word(pd, VMODTTL_CONTROL, 0xff);          /* input        */
 126                         vmodttl_write_word(pd, VMODTTL_CONTROL, DPPR_A);
 127
 128                         if(pd->io_flag & VMODTTL_O)
 129                                 vmodttl_write_word(pd, VMODTTL_CONTROL, 0xff);  /* invert!      */
 130                         else
 131                                 vmodttl_write_word(pd, VMODTTL_CONTROL, 0x00);
 132                 }
 133         } else {
 134                 /* normal TTL connection mode */
 135                 if(pd->io_flag & A_CHAN_OUT) {
 136                         vmodttl_write_word(pd, VMODTTL_CONTROL, DDR_A);
 137                         vmodttl_write_word(pd, VMODTTL_CONTROL, 0x00);          /* output       */
 138                 } else {
 139                         vmodttl_write_word(pd, VMODTTL_CONTROL, DDR_A);
 140                         vmodttl_write_word(pd, VMODTTL_CONTROL, 0xff);          /* input        */
 141                 }
 142
 143                 vmodttl_write_word(pd, VMODTTL_CONTROL, DPPR_A);
 144                 if(pd->io_flag & VMODTTL_O)
 145                         vmodttl_write_word(pd, VMODTTL_CONTROL, 0xff);          /* invert!      */
 146                 else
 147                         vmodttl_write_word(pd, VMODTTL_CONTROL, 0x00);
 148         }
 149
 150         vmodttl_write_word(pd, VMODTTL_CONTROL, SIOCR_A);
 151         vmodttl_write_word(pd, VMODTTL_CONTROL, 0x00);
 152
 153         /* port B               */
 154         /* -------------------- */
 155         /* disable interrupt    */
 156         vmodttl_write_word(pd, VMODTTL_CONTROL, PCSR_B);
 157         vmodttl_write_word(pd, VMODTTL_CONTROL, CLEAR_IE);
 158         /* clear ip/ius         */
 159         vmodttl_write_word(pd, VMODTTL_CONTROL, PCSR_B);
 160         vmodttl_write_word(pd, VMODTTL_CONTROL, CLEAR_IP_IUS);
 161
 162         vmodttl_write_word(pd, VMODTTL_CONTROL ,PMSR_B);
 163         vmodttl_write_word(pd, VMODTTL_CONTROL, 0x14);          /* /LPM  Latch on Pattern Match */
 164
 165         if((pd->open_collector & B_CHAN_OPEN_COLLECTOR) == B_CHAN_OPEN_COLLECTOR) {
 166                 /* open collector connection mode */
 167                 if(pd->io_flag & B_CHAN_OUT) {
 168                         vmodttl_write_word(pd, VMODTTL_CONTROL, DDR_B);
 169                         vmodttl_write_word(pd, VMODTTL_CONTROL, 0x00);  /* output               */
 170                         vmodttl_write_word(pd, VMODTTL_CONTROL, DPPR_B);
 171                         vmodttl_write_word(pd, VMODTTL_CONTROL, 0x00);
 172                 } else {
 173                         vmodttl_write_word(pd, VMODTTL_CONTROL, DDR_B);
 174                         vmodttl_write_word(pd, VMODTTL_CONTROL, 0xff);  /* input                */
 175                         vmodttl_write_word(pd, VMODTTL_CONTROL, DPPR_B);
 176                         if(pd->io_flag & VMODTTL_O)
 177                                 vmodttl_write_word(pd, VMODTTL_CONTROL, 0xff);  /* invert!      */
 178                         else
 179                                 vmodttl_write_word(pd, VMODTTL_CONTROL, 0x00);
 180                 }
 181         } else {
 182                 /* normal TTL connection mode */
 183                 if(pd->io_flag & B_CHAN_OUT) {
 184                         vmodttl_write_word(pd, VMODTTL_CONTROL, DDR_B);
 185                         vmodttl_write_word(pd, VMODTTL_CONTROL, 0x00);          /* output       */
 186                 } else {
 187                         vmodttl_write_word(pd, VMODTTL_CONTROL, DDR_B);
 188                         vmodttl_write_word(pd, VMODTTL_CONTROL, 0xff);          /* input        */
 189                 }
 190                 vmodttl_write_word(pd, VMODTTL_CONTROL, DPPR_B);
 191                 if(pd->io_flag & VMODTTL_O)
 192                         vmodttl_write_word(pd, VMODTTL_CONTROL, 0xff);          /* invert!      */
 193                 else
 194                         vmodttl_write_word(pd, VMODTTL_CONTROL, 0x00);
 195         }
 196
 197         vmodttl_write_word(pd, VMODTTL_CONTROL, SIOCR_B);
 198         vmodttl_write_word(pd, VMODTTL_CONTROL, 0x00);
 199
 200         /* port C       generates data strobe (Output) */
 201         if((pd->open_collector & C_CHAN_OPEN_COLLECTOR) == C_CHAN_OPEN_COLLECTOR) {
 202                 /* open collector connection mode */
 203                 vmodttl_write_word(pd, VMODTTL_CONTROL, DDR_C);
 204                 vmodttl_write_word(pd, VMODTTL_CONTROL, 0x00);          /* output       */
 205                 vmodttl_write_word(pd, VMODTTL_CONTROL, DPPR_C);
 206                 vmodttl_write_word(pd, VMODTTL_CONTROL, 0x00);
 207         } else {
 208                 /* normal TTL connection mode */
 209                 vmodttl_write_word(pd, VMODTTL_CONTROL, DDR_C);
 210                 vmodttl_write_word(pd, VMODTTL_CONTROL, 0x00);          /* output       */
 211
 212                 vmodttl_write_word(pd, VMODTTL_CONTROL, DPPR_C);
 213                 if(pd->io_flag & VMODTTL_O)
 214                         vmodttl_write_word(pd, VMODTTL_CONTROL, 0x0f);          /* invert!      */
 215                 else
 216                         vmodttl_write_word(pd, VMODTTL_CONTROL, 0x00);
 217         }
 218
 219         vmodttl_write_word(pd, VMODTTL_CONTROL, SIOCR_C);
 220         vmodttl_write_word(pd, VMODTTL_CONTROL, 0x00);
 221
 222         vmodttl_write_word(pd, VMODTTL_CONTROL, MCCR);
 223         tmp  = vmodttl_read_word(pd, VMODTTL_CONTROL) | PAE | PBE | PCE;
 224         vmodttl_write_word(pd, VMODTTL_CONTROL, MCCR);
 225         vmodttl_write_word(pd, VMODTTL_CONTROL, tmp);
 226 }
 227
 228 /* Configure the Zilog Z8536 CIO */
 229 static void vmodttl_default(struct vmodttl_dev  *pd)
 230 {
 231         unsigned int    dummy;
 232         int             i = 0;
 233         unsigned long   flags;
 234
 235         spin_lock_irqsave(&pd->vmodttl_spinlock, flags);
 236
 237         /* Prepare the Zilog Z8536 CIO to be configured */
 238         dummy = vmodttl_read_word(pd, VMODTTL_CONTROL);
 239         vmodttl_write_word(pd, VMODTTL_CONTROL, MCCR);
 240         vmodttl_write_word(pd, VMODTTL_CONTROL, 0);
 241         vmodttl_write_word(pd, VMODTTL_CONTROL, MICR);
 242         dummy = vmodttl_read_word(pd, VMODTTL_CONTROL);
 243         vmodttl_write_word(pd, VMODTTL_CONTROL, MICR);
 244         vmodttl_write_word(pd, VMODTTL_CONTROL, 0);
 245
 246         vmodttl_write_word(pd, VMODTTL_CONTROL, MICR);  /* reset cio                    */
 247         vmodttl_write_word(pd, VMODTTL_CONTROL, RESET);
 248         vmodttl_write_word(pd, VMODTTL_CONTROL,0);
 249
 250         vmodttl_def_io(pd);
 251
 252         /* enable master interrupts     */
 253         vmodttl_write_word(pd, VMODTTL_CONTROL, MICR);
 254         i = (vmodttl_read_word(pd, VMODTTL_CONTROL) | MIE | NV);
 255         vmodttl_write_word(pd, VMODTTL_CONTROL, MICR);
 256         vmodttl_write_word(pd, VMODTTL_CONTROL, i);
 257
 258         spin_unlock_irqrestore(&pd->vmodttl_spinlock, flags);
 259         printk(KERN_INFO PFX "board %d initialized\n", pd->dev);
 260 }
 261
 262 int vmodttl_open(struct inode *inode, struct file *filp)
 263 {
 264         unsigned int            minor = iminor(inode);
 265         struct vmodttl_dev      *pd =  (struct vmodttl_dev *)pvmodttlDv[minor];
 266
 267         pd->OpenCount++;
 268         return 0;
 269 }
 270
 271 int vmodttl_release(struct inode *inode, struct file *filp)
 272 {
 273         unsigned int            minor = iminor(inode);
 274         struct vmodttl_dev      *pd =  (struct vmodttl_dev *)pvmodttlDv[minor];
 275
 276         pd->OpenCount--;
 277         return 0;
 278 }
 279
 280 static int vmodttl_config(struct vmodttlconfig conf, struct vmodttl_dev *pd)
 281 {
 282         unsigned long flags;
 283
 284         spin_lock_irqsave(&pd->vmodttl_spinlock, flags);
 285         if((conf.io_flag > (A_CHAN_OUT + B_CHAN_OUT + C_CHAN_OUT)) ||
 286                         conf.io_flag < 0){
 287                 spin_unlock_irqrestore(&pd->vmodttl_spinlock, flags);
 288                 return -EINVAL;
 289         }
 290         pd->io_flag = conf.io_flag;
 291
 292         /* Used to keep up the strobe pulse during us_pulse time */
 293         if (conf.us_pulse < DEFAULT_DELAY)
 294                 pd->us_pulse = DEFAULT_DELAY;
 295         else
 296                 pd->us_pulse = conf.us_pulse;
 297
 298         if(conf.invert)
 299                 pd->io_flag |= VMODTTL_O;
 300
 301         pd->open_collector = conf.open_collector;
 302         vmodttl_def_io(pd);
 303         spin_unlock_irqrestore(&pd->vmodttl_spinlock, flags);
 304         return 0;
 305 }
 306
 307 static int vmodttl_read_chan(struct vmodttlarg buf, struct vmodttl_dev *pd)
 308 {
 309         int val = 0;
 310         int strobe_value = 0;
 311
 312         spin_lock(&pd->vmodttl_spinlock);
 313
 314         switch(buf.dev){
 315                 case VMOD_TTL_CHANNEL_A:
 316                         val = vmodttl_read_word(pd, VMODTTL_PORTA);
 317                         strobe_value = 0x04;
 318                         break;
 319
 320                 case VMOD_TTL_CHANNEL_B:
 321                         val = vmodttl_read_word(pd, VMODTTL_PORTB);
 322                         strobe_value = 0x08;
 323                         break;
 324
 325                 case VMOD_TTL_CHANNELS_AB:
 326                         val = vmodttl_read_word(pd, VMODTTL_PORTA) & 0x00ff;
 327                         val += (vmodttl_read_word(pd, VMODTTL_PORTB) & 0x00ff) << 8;
 328
 329                 default:
 330                         break;
 331         }
 332
 333         /* produce the strobe on C channel (pulse) */
 334         vmodttl_write_word(pd, VMODTTL_PORTC, strobe_value);
 335         udelay(pd->us_pulse);
 336         vmodttl_write_word(pd, VMODTTL_PORTC, 0);
 337         spin_unlock(&pd->vmodttl_spinlock);
 338
 339         return val;
 340
 341 }
 342
 343 static int vmodttl_write_chan(struct vmodttlarg buf, struct vmodttl_dev *pd)
 344 {
 345         int dev;
 346         uint16_t data;
 347         uint16_t tmp;
 348         int strobe_value = 0;
 349
 350         dev = buf.dev;
 351         data = buf.val;
 352
 353         if(dev < VMOD_TTL_CHANNEL_A || dev > VMOD_TTL_CHANNELS_AB)
 354                 return -EINVAL; /* invalid channel */
 355
 356         spin_lock(&pd->vmodttl_spinlock);
 357         switch(dev){
 358         case VMOD_TTL_CHANNEL_A:
 359
 360                 if((pd->io_flag & A_CHAN_OUT) == A_CHAN_IN){
 361                         spin_unlock(&pd->vmodttl_spinlock);
 362                         return -EIO;
 363                 }
 364
 365                 vmodttl_write_word(pd, VMODTTL_PORTA, data);
 366                 vmodttl_write_word(pd, VMODTTL_CONTROL, MCCR);
 367                 tmp = vmodttl_read_word(pd, VMODTTL_CONTROL);
 368
 369                 vmodttl_write_word(pd, VMODTTL_CONTROL, MCCR);
 370                 vmodttl_write_word(pd, VMODTTL_CONTROL, (tmp | PAE));
 371                 strobe_value = 0x01;
 372                 break;
 373
 374         case VMOD_TTL_CHANNEL_B:
 375
 376                 if((pd->io_flag & B_CHAN_OUT) == B_CHAN_IN){
 377                         spin_unlock(&pd->vmodttl_spinlock);
 378                         return -EIO;
 379                 }
 380
 381                 vmodttl_write_word(pd, VMODTTL_PORTB, data);
 382                 vmodttl_write_word(pd, VMODTTL_CONTROL, MCCR);
 383                 tmp = vmodttl_read_word(pd, VMODTTL_CONTROL);
 384
 385                 vmodttl_write_word(pd, VMODTTL_CONTROL, MCCR);
 386                 vmodttl_write_word(pd, VMODTTL_CONTROL, (tmp | PBE));
 387                 strobe_value = 0x02;
 388                 break;
 389
 390         case VMOD_TTL_CHANNELS_AB:
 391
 392                 if(((pd->io_flag & B_CHAN_OUT) == B_CHAN_IN) ||
 393                                 (pd->io_flag & A_CHAN_OUT) == A_CHAN_IN) {
 394                         spin_unlock(&pd->vmodttl_spinlock);
 395                         return -EIO;
 396                 }
 397
 398                 vmodttl_write_word(pd, VMODTTL_PORTA, data & 0xff);
 399                 vmodttl_write_word(pd, VMODTTL_CONTROL, MCCR);
 400                 tmp = vmodttl_read_word(pd, VMODTTL_CONTROL);
 401
 402                 vmodttl_write_word(pd, VMODTTL_PORTB, (data >> 8) & 0xff);
 403                 vmodttl_write_word(pd, VMODTTL_CONTROL, MCCR);
 404                 tmp = vmodttl_read_word(pd, VMODTTL_CONTROL);
 405
 406                 vmodttl_write_word(pd, VMODTTL_CONTROL, MCCR);
 407                 vmodttl_write_word(pd, VMODTTL_CONTROL, (tmp | PAE | PBE));
 408                 strobe_value = 0x03;
 409                 break;
 410         default:
 411                 break;
 412         }
 413
 414         /* produce the strobe on C channel (pulse) */
 415         vmodttl_write_word(pd, VMODTTL_PORTC, strobe_value);
 416         udelay(pd->us_pulse);
 417         vmodttl_write_word(pd, VMODTTL_PORTC, 0);
 418         spin_unlock(&pd->vmodttl_spinlock);
 419         return 0;
 420 }
 421
 422 static int vmodttl_ioctl(struct inode *inode, struct file *fp, unsigned op, unsigned long arg)
 423 {
 424         unsigned int minor = iminor(inode);
 425         struct vmodttl_dev *pd =  (struct vmodttl_dev *)pvmodttlDv[minor];
 426         int ret;
 427
 428         switch(op){
 429
 430         case VMODTTL_CONFIG:
 431         {
 432                 struct vmodttlconfig conf;
 433
 434                 if(copy_from_user((char *)&conf, (char *)arg, sizeof(struct vmodttlconfig)))
 435                         return -EFAULT;
 436
 437                 pd->ioconfig = conf;
 438                 ret = vmodttl_config(conf, pd);
 439                 if (ret < 0)
 440                         return ret;
 441                 break;
 442         }
 443         case VMODTTL_READ_CONFIG:
 444                 if(copy_to_user((char *)arg, (char *)&pd->ioconfig, sizeof(struct vmodttlconfig)))
 445                         return -EFAULT;
 446
 447                 break;
 448
 449         case VMODTTL_SIMPIO:
 450                 /* It's the default behaviour: Bit port simple operation without interrupts */
 451                 /* This ioctl operation resets the channels to this mode */
 452                 vmodttl_def_io(pd);
 453                 break;
 454
 455         case VMODTTL_PATTERN:
 456         {
 457                 struct vmodttl_pattern buf;
 458
 459                 if(copy_from_user((char *)&buf, (char *)arg, sizeof(struct vmodttl_pattern)))
 460                         return -EFAULT;
 461                 pd->ioconfig.bit_pattern_a[buf.pos] = buf;
 462                 break;
 463         }
 464         case VMODTTL_READ_CHAN:
 465         {
 466                 struct vmodttlarg buf;
 467                 short int dev;
 468
 469                 if(copy_from_user((char *)&buf, (char *)arg,sizeof(struct vmodttlarg)))
 470                         return -EIO;
 471
 472                 dev = buf.dev & 0x00ff; /* Get channel */
 473                 if(dev < VMOD_TTL_CHANNEL_A || dev > VMOD_TTL_CHANNELS_AB)
 474                         return -EINVAL; /* invalid channel */
 475
 476                 buf.val = vmodttl_read_chan(buf, pd);
 477                 if(copy_to_user((char *)arg, (char *)&buf, sizeof(struct vmodttlarg)))
 478                         return -EFAULT;
 479
 480                 break;
 481         }
 482         case VMODTTL_WRITE_CHAN:
 483         {
 484                 struct vmodttlarg buf;
 485
 486                 if(copy_from_user((char *)&buf, (char *)arg, sizeof(struct vmodttlarg)))
 487                         return -EIO;
 488
 489                 ret = vmodttl_write_chan(buf, pd);
 490                 if (ret < 0)
 491                         return ret;
 492                 break;
 493         }
 494         default:
 495                 printk(KERN_INFO PFX "There is no default option");
 496                 return -EINVAL;
 497         }
 498
 499         return 0;
 500
 501 }
 502 struct file_operations vmodttl_fops = {
 503         .owner          = THIS_MODULE,
 504         .read           = NULL,
 505         .ioctl          = vmodttl_ioctl,
 506         .open           = vmodttl_open,
 507         .release        = vmodttl_release
 508 };
 509
 510 static int register_module_isr(struct vmodttl_dev *dev, isrcb_t handler)
 511 {
 512         int err;
 513         risr_t register_isr;
 514         char *carrier = dev->config->carrier_name;
 515         int lun = dev->config->carrier_lun;
 516         int slot = dev->config->slot;
 517
 518         register_isr = modulbus_carrier_isr_entry(carrier);
 519         if (register_isr == NULL)
 520                 goto error;
 521
 522         err = register_isr(handler, (void *)dev, lun, slot);
 523         if (err < 0)
 524                 goto error;
 525
 526         return 0;
 527 error:
 528         printk(KERN_ERR PFX
 529                         "could not register irq handler for lun %d\n",
 530                         dev->config->lun);
 531         return -1;
 532
 533 }
 534
 535 static int unregister_module_isr(struct vmodttl_dev *dev)
 536 {
 537         return register_module_isr(dev, NULL);
 538 }
 539
 540 static int __init vmodttl_init(void)
 541 {
 542         int err;
 543         int i;
 544         struct vmodttl_dev *pd;
 545
 546         printk(KERN_INFO PFX "reading parameters\n");
 547
 548         err = read_params(DRIVER_NAME, dev_table);
 549         if (err != 0)
 550                 return -1;
 551         printk(KERN_INFO PFX "initialized driver for %d (max %d) cards\n",
 552                 dev_table->num_modules, VMODTTL_MAX_BOARDS);
 553
 554         err = alloc_chrdev_region(&devno, 0, VMODTTL_MAX_BOARDS, DRIVER_NAME);
 555         if (err != 0)
 556                 goto fail_chrdev;
 557
 558         printk(KERN_INFO PFX "allocated device %d\n", MAJOR(devno));
 559
 560         cdev_init(&cdev, &vmodttl_fops);
 561         cdev.owner = THIS_MODULE;
 562         err = cdev_add(&cdev, devno, VMODTTL_MAX_BOARDS);
 563         if (err){
 564                 printk(KERN_ERR PFX "Added cdev with err = %d\n", err);
 565                 goto fail_cdev;
 566         }
 567
 568         for(i = 0; i < dev_table->num_modules; i++){
 569                 struct vmod_dev *mod = &dev_table->module[i];
 570
 571                 pd = kzalloc(sizeof(struct vmodttl_dev), GFP_KERNEL);
 572
 573                 if (pd == 0)
 574                         goto fail_pd;
 575
 576                 pvmodttlDv[mod->lun] = (void *)pd;
 577                 pd->config = mod;
 578                 pd->dev = lun_to_index(dev_table, mod->lun);
 579                 pd->OpenCount = 0;
 580                 pd->io_flag = 0; /* All channels are inputs by default */
 581                 pd->open_collector = 0; /* All channels are TTL by default */
 582                 pd->created = 1;
 583                 spin_lock_init(&pd->vmodttl_spinlock);
 584                 spin_lock_init(&pd->vmodttl_read);
 585                 init_waitqueue_head(&pd->wait);
 586                 pd->messages = kzalloc(sizeof(struct message_list), GFP_KERNEL);
 587                 if (pd->messages == 0)
 588                         goto fail_messages;
 589
 590                 INIT_LIST_HEAD(&pd->messages->list);
 591                 vmodttl_default(pd);
 592         }
 593
 594         return 0;
 595
 596 fail_messages:
 597         {
 598                 int k;
 599                 for(k =0; k < k; k++) {
 600                         if(pvmodttlDv[k] != 0) {
 601                                 unregister_module_isr(pvmodttlDv[k]);
 602                                 kfree(pvmodttlDv[k]);
 603                         }
 604                 }
 605         }
 606 fail_pd:
 607         cdev_del(&cdev);
 608 fail_cdev:
 609         unregister_chrdev_region(devno, VMODTTL_MAX_BOARDS);
 610 fail_chrdev:    return -1;
 611
 612 }
 613
 614 static void __exit vmodttl_exit(void)
 615 {
 616         int i;
 617         struct message_list *entry, *next_entry;
 618
 619         for(i =0; i < dev_table->num_modules; i++){
 620                 if(pvmodttlDv[i] != 0){
 621                         list_for_each_entry_safe(entry, next_entry, &pvmodttlDv[i]->messages->list, list) {
 622                                 list_del(&entry->list);
 623                                 kfree(entry);
 624                         }
 625                         unregister_module_isr(pvmodttlDv[i]);
 626                         kfree(pvmodttlDv[i]);
 627                 }
 628         }
 629
 630         cdev_del(&cdev);
 631         unregister_chrdev_region(devno, VMODTTL_MAX_BOARDS);
 632         printk(KERN_INFO "VMODTTL: exit module.\n");
 633 }
 634
 635 module_init(vmodttl_init);
 636 module_exit(vmodttl_exit);
 637
 638 MODULE_LICENSE("GPL");
 639 MODULE_AUTHOR("Samuel Iglesias Gonsalvez");
 640 MODULE_DESCRIPTION("VMOD-TTL device driver");
 641 MODULE_VERSION("1.0");