drivers/staging/comedi/drivers/ii_pci20kc.c

   1 /*
   2  *      comedi/drivers/ii_pci20kc.c
   3  *      Driver for Intelligent Instruments PCI-20001C carrier board
   4  *      and modules.
   5  *
   6  *      Copyright (C) 2000 Markus Kempf <kempf@matsci.uni-sb.de>
   7  *      with suggestions from David Schleef
   8  *                      16.06.2000
   9  *
  10  *      Linux device driver for COMEDI
  11  *      Intelligent Instrumentation
  12  *      PCI-20001 C-2A Carrier Board
  13  *      PCI-20341 M-1A 16-Bit analog input module
  14  *                              - differential
  15  *                              - range (-5V - +5V)
  16  *                              - 16 bit
  17  *      PCI-20006 M-2 16-Bit analog output module
  18  *                              - ranges (-10V - +10V) (0V - +10V) (-5V - +5V)
  19  *                              - 16 bit
  20  *
  21  *      only ONE PCI-20341 module possible
  22  *      only ONE PCI-20006 module possible
  23  *      no extern trigger implemented
  24  *
  25  *      NOT WORKING (but soon) only 4 on-board differential channels supported
  26  *      NOT WORKING (but soon) only ONE di-port and ONE do-port supported
  27  *                             instead of 4 digital ports
  28  *      di-port == Port 0
  29  *      do-port == Port 1
  30  *
  31  *      The state of this driver is only a starting point for a complete
  32  *      COMEDI-driver. The final driver should support all features of the
  33  *      carrier board and modules.
  34  *
  35  *      The test configuration:
  36  *
  37  *      kernel 2.2.14 with RTAI v1.2  and patch-2.2.14rthal2
  38  *      COMEDI 0.7.45
  39  *      COMEDILIB 0.7.9
  40  *
  41  */
  42 /*
  43 Driver: ii_pci20kc
  44 Description: Intelligent Instruments PCI-20001C carrier board
  45 Author: Markus Kempf <kempf@matsci.uni-sb.de>
  46 Devices: [Intelligent Instrumentation] PCI-20001C (ii_pci20kc)
  47 Status: works
  48
  49 Supports the PCI-20001 C-2a Carrier board, and could probably support
  50 the other carrier boards with small modifications.  Modules supported
  51 are:
  52         PCI-20006 M-2 16-bit analog output module
  53         PCI-20341 M-1A 16-bit analog input module
  54
  55 Options:
  56   0   Board base address
  57   1   IRQ
  58   2   first option for module 1
  59   3   second option for module 1
  60   4   first option for module 2
  61   5   second option for module 2
  62   6   first option for module 3
  63   7   second option for module 3
  64
  65 options for PCI-20006M:
  66   first:   Analog output channel 0 range configuration
  67              0  bipolar 10  (-10V -- +10V)
  68              1  unipolar 10  (0V -- +10V)
  69              2  bipolar 5  (-5V -- 5V)
  70   second:  Analog output channel 1 range configuration
  71
  72 options for PCI-20341M:
  73   first:   Analog input gain configuration
  74              0  1
  75              1  10
  76              2  100
  77              3  200
  78 */
  79
  80 /* XXX needs to use ioremap() for compatibility with 2.4 kernels.  Should also
  81  * check_mem_region() etc. - fmhess */
  82
  83 #include "../comedidev.h"
  84
  85 #define PCI20000_ID                     0x1d
  86 #define PCI20341_ID                     0x77
  87 #define PCI20006_ID                     0xe3
  88 #define PCI20xxx_EMPTY_ID               0xff
  89
  90 #define PCI20000_OFFSET                 0x100
  91 #define PCI20000_MODULES                3
  92
  93 #define PCI20000_DIO_0                  0x80
  94 #define PCI20000_DIO_1                  0x81
  95 #define PCI20000_DIO_2                  0xc0
  96 #define PCI20000_DIO_3                  0xc1
  97 #define PCI20000_DIO_CONTROL_01         0x83    /* port 0, 1 control */
  98 #define PCI20000_DIO_CONTROL_23         0xc3    /* port 2, 3 control */
  99 #define PCI20000_DIO_BUFFER             0x82    /* buffer direction & enable */
 100 #define PCI20000_DIO_EOC                0xef    /* even port, control output */
 101 #define PCI20000_DIO_OOC                0xfd    /* odd port, control output */
 102 #define PCI20000_DIO_EIC                0x90    /* even port, control input */
 103 #define PCI20000_DIO_OIC                0x82    /* odd port, control input */
 104 #define DIO_CAND                        0x12    /* and bit 1 & 4 of control */
 105 #define DIO_BE                          0x01    /* buffer: port enable */
 106 #define DIO_BO                          0x04    /* buffer: output */
 107 #define DIO_BI                          0x05    /* buffer: input */
 108 #define DIO_PS_0                        0x00    /* buffer: port shift 0 */
 109 #define DIO_PS_1                        0x01    /* buffer: port shift 1 */
 110 #define DIO_PS_2                        0x04    /* buffer: port shift 2 */
 111 #define DIO_PS_3                        0x05    /* buffer: port shift 3 */
 112
 113 #define PCI20006_LCHAN0                 0x0d
 114 #define PCI20006_STROBE0                0x0b
 115 #define PCI20006_LCHAN1                 0x15
 116 #define PCI20006_STROBE1                0x13
 117
 118 #define PCI20341_INIT                   0x04
 119 #define PCI20341_REPMODE                0x00    /* single shot mode */
 120 #define PCI20341_PACER                  0x00    /* Hardware Pacer disabled */
 121 #define PCI20341_CHAN_NR                0x04    /* number of input channels */
 122 #define PCI20341_CONFIG_REG             0x10
 123 #define PCI20341_MOD_STATUS             0x01
 124 #define PCI20341_OPT_REG                0x11
 125 #define PCI20341_SET_TIME_REG           0x15
 126 #define PCI20341_LCHAN_ADDR_REG         0x13
 127 #define PCI20341_CHAN_LIST              0x80
 128 #define PCI20341_CC_RESET               0x1b
 129 #define PCI20341_CHAN_RESET             0x19
 130 #define PCI20341_SOFT_PACER             0x04
 131 #define PCI20341_STATUS_REG             0x12
 132 #define PCI20341_LDATA                  0x02
 133 #define PCI20341_DAISY_CHAIN            0x20    /* On-board inputs only */
 134 #define PCI20341_MUX                    0x04    /* Enable on-board MUX */
 135 #define PCI20341_SCANLIST               0x80    /* Channel/Gain Scan List */
 136
 137 union pci20xxx_subdev_private {
 138         void *iobase;
 139         struct {
 140                 void *iobase;
 141                 const struct comedi_lrange *ao_range_list[2];
 142                                         /* range of channels of ao module */
 143                 unsigned int last_data[2];
 144         } pci20006;
 145         struct {
 146                 void *iobase;
 147                 int timebase;
 148                 int settling_time;
 149                 int ai_gain;
 150         } pci20341;
 151 };
 152
 153 struct pci20xxx_private {
 154
 155         void *ioaddr;
 156         union pci20xxx_subdev_private subdev_private[PCI20000_MODULES];
 157 };
 158
 159 #define devpriv ((struct pci20xxx_private *)dev->private)
 160 #define CHAN (CR_CHAN(it->chanlist[0]))
 161
 162 static int pci20xxx_attach(struct comedi_device *dev,
 163                            struct comedi_devconfig *it);
 164 static int pci20xxx_detach(struct comedi_device *dev);
 165
 166 static struct comedi_driver driver_pci20xxx = {
 167         .driver_name = "ii_pci20kc",
 168         .module = THIS_MODULE,
 169         .attach = pci20xxx_attach,
 170         .detach = pci20xxx_detach,
 171 };
 172
 173 static int pci20006_init(struct comedi_device *dev, struct comedi_subdevice *s,
 174                          int opt0, int opt1);
 175 static int pci20341_init(struct comedi_device *dev, struct comedi_subdevice *s,
 176                          int opt0, int opt1);
 177 static int pci20xxx_dio_init(struct comedi_device *dev,
 178                              struct comedi_subdevice *s);
 179
 180 /*
 181   options[0]    Board base address
 182   options[1]    IRQ
 183   options[2]    first option for module 1
 184   options[3]    second option for module 1
 185   options[4]    first option for module 2
 186   options[5]    second option for module 2
 187   options[6]    first option for module 3
 188   options[7]    second option for module 3
 189
 190   options for PCI-20341M:
 191   first         Analog input gain configuration
 192                 0 == 1
 193                 1 == 10
 194                 2 == 100
 195                 3 == 200
 196
 197   options for PCI-20006M:
 198   first         Analog output channel 0 range configuration
 199                 0 == bipolar 10  (-10V -- +10V)
 200                 1 == unipolar 10V  (0V -- +10V)
 201                 2 == bipolar 5V  (-5V -- +5V)
 202   second        Analog output channel 1 range configuration
 203                 0 == bipolar 10  (-10V -- +10V)
 204                 1 == unipolar 10V  (0V -- +10V)
 205                 2 == bipolar 5V  (-5V -- +5V)
 206 */
 207 static int pci20xxx_attach(struct comedi_device *dev,
 208                            struct comedi_devconfig *it)
 209 {
 210         unsigned char i;
 211         int ret;
 212         int id;
 213         struct comedi_subdevice *s;
 214         union pci20xxx_subdev_private *sdp;
 215
 216         ret = alloc_subdevices(dev, 1 + PCI20000_MODULES);
 217         if (ret < 0)
 218                 return ret;
 219
 220         ret = alloc_private(dev, sizeof(struct pci20xxx_private));
 221         if (ret < 0)
 222                 return ret;
 223
 224         devpriv->ioaddr = (void *)(unsigned long)it->options[0];
 225         dev->board_name = "pci20kc";
 226
 227         /* Check PCI-20001 C-2A Carrier Board ID */
 228         if ((readb(devpriv->ioaddr) & PCI20000_ID) != PCI20000_ID) {
 229                 printk(KERN_WARNING "comedi%d: ii_pci20kc PCI-20001"
 230                        " C-2A Carrier Board at base=0x%p not found !\n",
 231                        dev->minor, devpriv->ioaddr);
 232                 return -EINVAL;
 233         }
 234         printk(KERN_INFO "comedi%d: ii_pci20kc: PCI-20001 C-2A at base=0x%p\n",
 235                dev->minor, devpriv->ioaddr);
 236
 237         for (i = 0; i < PCI20000_MODULES; i++) {
 238                 s = dev->subdevices + i;
 239                 id = readb(devpriv->ioaddr + (i + 1) * PCI20000_OFFSET);
 240                 s->private = devpriv->subdev_private + i;
 241                 sdp = s->private;
 242                 switch (id) {
 243                 case PCI20006_ID:
 244                         sdp->pci20006.iobase =
 245                             devpriv->ioaddr + (i + 1) * PCI20000_OFFSET;
 246                         pci20006_init(dev, s, it->options[2 * i + 2],
 247                                       it->options[2 * i + 3]);
 248                         printk(KERN_INFO "comedi%d: "
 249                                "ii_pci20kc PCI-20006 module in slot %d\n",
 250                                dev->minor, i + 1);
 251                         break;
 252                 case PCI20341_ID:
 253                         sdp->pci20341.iobase =
 254                             devpriv->ioaddr + (i + 1) * PCI20000_OFFSET;
 255                         pci20341_init(dev, s, it->options[2 * i + 2],
 256                                       it->options[2 * i + 3]);
 257                         printk(KERN_INFO "comedi%d: "
 258                                "ii_pci20kc PCI-20341 module in slot %d\n",
 259                                dev->minor, i + 1);
 260                         break;
 261                 default:
 262                         printk(KERN_WARNING "ii_pci20kc: unknown module "
 263                                "code 0x%02x in slot %d: module disabled\n",
 264                                id, i); /* XXX this looks like a bug! i + 1 ?? */
 265                         /* fall through */
 266                 case PCI20xxx_EMPTY_ID:
 267                         s->type = COMEDI_SUBD_UNUSED;
 268                         break;
 269                 }
 270         }
 271
 272         /* initialize struct pci20xxx_private */
 273         pci20xxx_dio_init(dev, dev->subdevices + PCI20000_MODULES);
 274
 275         return 1;
 276 }
 277
 278 static int pci20xxx_detach(struct comedi_device *dev)
 279 {
 280         printk(KERN_INFO "comedi%d: pci20xxx: remove\n", dev->minor);
 281
 282         return 0;
 283 }
 284
 285 /* pci20006m */
 286
 287 static int pci20006_insn_read(struct comedi_device *dev,
 288                               struct comedi_subdevice *s,
 289                               struct comedi_insn *insn, unsigned int *data);
 290 static int pci20006_insn_write(struct comedi_device *dev,
 291                                struct comedi_subdevice *s,
 292                                struct comedi_insn *insn, unsigned int *data);
 293
 294 static const struct comedi_lrange *pci20006_range_list[] = {
 295         &range_bipolar10,
 296         &range_unipolar10,
 297         &range_bipolar5,
 298 };
 299
 300 static int pci20006_init(struct comedi_device *dev, struct comedi_subdevice *s,
 301                          int opt0, int opt1)
 302 {
 303         union pci20xxx_subdev_private *sdp = s->private;
 304
 305         if (opt0 < 0 || opt0 > 2)
 306                 opt0 = 0;
 307         if (opt1 < 0 || opt1 > 2)
 308                 opt1 = 0;
 309
 310         sdp->pci20006.ao_range_list[0] = pci20006_range_list[opt0];
 311         sdp->pci20006.ao_range_list[1] = pci20006_range_list[opt1];
 312
 313         /* ao subdevice */
 314         s->type = COMEDI_SUBD_AO;
 315         s->subdev_flags = SDF_WRITABLE;
 316         s->n_chan = 2;
 317         s->len_chanlist = 2;
 318         s->insn_read = pci20006_insn_read;
 319         s->insn_write = pci20006_insn_write;
 320         s->maxdata = 0xffff;
 321         s->range_table_list = sdp->pci20006.ao_range_list;
 322         return 0;
 323 }
 324
 325 static int pci20006_insn_read(struct comedi_device *dev,
 326                               struct comedi_subdevice *s,
 327                               struct comedi_insn *insn, unsigned int *data)
 328 {
 329         union pci20xxx_subdev_private *sdp = s->private;
 330
 331         data[0] = sdp->pci20006.last_data[CR_CHAN(insn->chanspec)];
 332
 333         return 1;
 334 }
 335
 336 static int pci20006_insn_write(struct comedi_device *dev,
 337                                struct comedi_subdevice *s,
 338                                struct comedi_insn *insn, unsigned int *data)
 339 {
 340         union pci20xxx_subdev_private *sdp = s->private;
 341         int hi, lo;
 342         unsigned int boarddata;
 343
 344         sdp->pci20006.last_data[CR_CHAN(insn->chanspec)] = data[0];
 345         boarddata = (((unsigned int)data[0] + 0x8000) & 0xffff);
 346                                                 /* comedi-data -> board-data */
 347         lo = (boarddata & 0xff);
 348         hi = ((boarddata >> 8) & 0xff);
 349
 350         switch (CR_CHAN(insn->chanspec)) {
 351         case 0:
 352                 writeb(lo, sdp->iobase + PCI20006_LCHAN0);
 353                 writeb(hi, sdp->iobase + PCI20006_LCHAN0 + 1);
 354                 writeb(0x00, sdp->iobase + PCI20006_STROBE0);
 355                 break;
 356         case 1:
 357                 writeb(lo, sdp->iobase + PCI20006_LCHAN1);
 358                 writeb(hi, sdp->iobase + PCI20006_LCHAN1 + 1);
 359                 writeb(0x00, sdp->iobase + PCI20006_STROBE1);
 360                 break;
 361         default:
 362                 printk(KERN_WARNING
 363                        " comedi%d: pci20xxx: ao channel Error!\n", dev->minor);
 364                 return -EINVAL;
 365         }
 366
 367         return 1;
 368 }
 369
 370 /* PCI20341M */
 371
 372 static int pci20341_insn_read(struct comedi_device *dev,
 373                               struct comedi_subdevice *s,
 374                               struct comedi_insn *insn, unsigned int *data);
 375
 376 static const int pci20341_timebase[] = { 0x00, 0x00, 0x00, 0x04 };
 377 static const int pci20341_settling_time[] = { 0x58, 0x58, 0x93, 0x99 };
 378
 379 static const struct comedi_lrange range_bipolar0_5 = {
 380         1,
 381         {BIP_RANGE(0.5)}
 382 };
 383
 384 static const struct comedi_lrange range_bipolar0_05 = {
 385         1,
 386         {BIP_RANGE(0.05)}
 387 };
 388
 389 static const struct comedi_lrange range_bipolar0_025 = {
 390         1,
 391         {BIP_RANGE(0.025)}
 392 };
 393
 394 static const struct comedi_lrange *const pci20341_ranges[] = {
 395         &range_bipolar5,
 396         &range_bipolar0_5,
 397         &range_bipolar0_05,
 398         &range_bipolar0_025,
 399 };
 400
 401 static int pci20341_init(struct comedi_device *dev, struct comedi_subdevice *s,
 402                          int opt0, int opt1)
 403 {
 404         union pci20xxx_subdev_private *sdp = s->private;
 405         int option;
 406
 407         /* options handling */
 408         if (opt0 < 0 || opt0 > 3)
 409                 opt0 = 0;
 410         sdp->pci20341.timebase = pci20341_timebase[opt0];
 411         sdp->pci20341.settling_time = pci20341_settling_time[opt0];
 412
 413         /* ai subdevice */
 414         s->type = COMEDI_SUBD_AI;
 415         s->subdev_flags = SDF_READABLE;
 416         s->n_chan = PCI20341_CHAN_NR;
 417         s->len_chanlist = PCI20341_SCANLIST;
 418         s->insn_read = pci20341_insn_read;
 419         s->maxdata = 0xffff;
 420         s->range_table = pci20341_ranges[opt0];
 421
 422         /* depends on gain, trigger, repetition mode */
 423         option = sdp->pci20341.timebase | PCI20341_REPMODE;
 424
 425         /* initialize Module */
 426         writeb(PCI20341_INIT, sdp->iobase + PCI20341_CONFIG_REG);
 427         /* set Pacer */
 428         writeb(PCI20341_PACER, sdp->iobase + PCI20341_MOD_STATUS);
 429         /* option register */
 430         writeb(option, sdp->iobase + PCI20341_OPT_REG);
 431         /* settling time counter */
 432         writeb(sdp->pci20341.settling_time,
 433                 sdp->iobase + PCI20341_SET_TIME_REG);
 434         /* trigger not implemented */
 435         return 0;
 436 }
 437
 438 static int pci20341_insn_read(struct comedi_device *dev,
 439                               struct comedi_subdevice *s,
 440                               struct comedi_insn *insn, unsigned int *data)
 441 {
 442         union pci20xxx_subdev_private *sdp = s->private;
 443         unsigned int i = 0, j = 0;
 444         int lo, hi;
 445         unsigned char eoc;      /* end of conversion */
 446         unsigned int clb;       /* channel list byte */
 447         unsigned int boarddata;
 448
 449         /* write number of input channels */
 450         writeb(1, sdp->iobase + PCI20341_LCHAN_ADDR_REG);
 451         clb = PCI20341_DAISY_CHAIN | PCI20341_MUX | (sdp->pci20341.ai_gain << 3)
 452             | CR_CHAN(insn->chanspec);
 453         writeb(clb, sdp->iobase + PCI20341_CHAN_LIST);
 454
 455         /* reset settling time counter and trigger delay counter */
 456         writeb(0x00, sdp->iobase + PCI20341_CC_RESET);
 457
 458         writeb(0x00, sdp->iobase + PCI20341_CHAN_RESET);
 459
 460         /* generate Pacer */
 461
 462         for (i = 0; i < insn->n; i++) {
 463                 /* data polling isn't the niciest way to get the data, I know,
 464                  * but there are only 6 cycles (mean) and it is easier than
 465                  * the whole interrupt stuff
 466                  */
 467                 j = 0;
 468                 /* generate Pacer */
 469                 readb(sdp->iobase + PCI20341_SOFT_PACER);
 470
 471                 eoc = readb(sdp->iobase + PCI20341_STATUS_REG);
 472                 /* poll Interrupt Flag */
 473                 while ((eoc < 0x80) && j < 100) {
 474                         j++;
 475                         eoc = readb(sdp->iobase + PCI20341_STATUS_REG);
 476                 }
 477                 if (j >= 100) {
 478                         printk(KERN_WARNING
 479                                "comedi%d:  pci20xxx: "
 480                                "AI interrupt channel %i polling exit !\n",
 481                                dev->minor, i);
 482                         return -EINVAL;
 483                 }
 484                 lo = readb(sdp->iobase + PCI20341_LDATA);
 485                 hi = readb(sdp->iobase + PCI20341_LDATA + 1);
 486                 boarddata = lo + 0x100 * hi;
 487
 488                 /* board-data -> comedi-data */
 489                 data[i] = (short)((boarddata + 0x8000) & 0xffff);
 490         }
 491
 492         return i;
 493 }
 494
 495 /* native DIO */
 496
 497 static void pci20xxx_dio_config(struct comedi_device *dev,
 498                                 struct comedi_subdevice *s);
 499 static int pci20xxx_dio_insn_bits(struct comedi_device *dev,
 500                                   struct comedi_subdevice *s,
 501                                   struct comedi_insn *insn, unsigned int *data);
 502 static int pci20xxx_dio_insn_config(struct comedi_device *dev,
 503                                     struct comedi_subdevice *s,
 504                                     struct comedi_insn *insn,
 505                                     unsigned int *data);
 506
 507 /* initialize struct pci20xxx_private */
 508 static int pci20xxx_dio_init(struct comedi_device *dev,
 509                              struct comedi_subdevice *s)
 510 {
 511
 512         s->type = COMEDI_SUBD_DIO;
 513         s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
 514         s->n_chan = 32;
 515         s->insn_bits = pci20xxx_dio_insn_bits;
 516         s->insn_config = pci20xxx_dio_insn_config;
 517         s->maxdata = 1;
 518         s->len_chanlist = 32;
 519         s->range_table = &range_digital;
 520         s->io_bits = 0;
 521
 522         /* digital I/O lines default to input on board reset. */
 523         pci20xxx_dio_config(dev, s);
 524
 525         return 0;
 526 }
 527
 528 static int pci20xxx_dio_insn_config(struct comedi_device *dev,
 529                                     struct comedi_subdevice *s,
 530                                     struct comedi_insn *insn,
 531                                     unsigned int *data)
 532 {
 533         int mask, bits;
 534
 535         mask = 1 << CR_CHAN(insn->chanspec);
 536         if (mask & 0x000000ff)
 537                 bits = 0x000000ff;
 538         else if (mask & 0x0000ff00)
 539                 bits = 0x0000ff00;
 540         else if (mask & 0x00ff0000)
 541                 bits = 0x00ff0000;
 542         else
 543                 bits = 0xff000000;
 544         if (data[0])
 545                 s->io_bits |= bits;
 546         else
 547                 s->io_bits &= ~bits;
 548         pci20xxx_dio_config(dev, s);
 549
 550         return 1;
 551 }
 552
 553 static int pci20xxx_dio_insn_bits(struct comedi_device *dev,
 554                                   struct comedi_subdevice *s,
 555                                   struct comedi_insn *insn, unsigned int *data)
 556 {
 557         unsigned int mask = data[0];
 558
 559         s->state &= ~mask;
 560         s->state |= (mask & data[1]);
 561
 562         mask &= s->io_bits;
 563         if (mask & 0x000000ff)
 564                 writeb((s->state >> 0) & 0xff,
 565                        devpriv->ioaddr + PCI20000_DIO_0);
 566         if (mask & 0x0000ff00)
 567                 writeb((s->state >> 8) & 0xff,
 568                        devpriv->ioaddr + PCI20000_DIO_1);
 569         if (mask & 0x00ff0000)
 570                 writeb((s->state >> 16) & 0xff,
 571                        devpriv->ioaddr + PCI20000_DIO_2);
 572         if (mask & 0xff000000)
 573                 writeb((s->state >> 24) & 0xff,
 574                        devpriv->ioaddr + PCI20000_DIO_3);
 575
 576         data[1] = readb(devpriv->ioaddr + PCI20000_DIO_0);
 577         data[1] |= readb(devpriv->ioaddr + PCI20000_DIO_1) << 8;
 578         data[1] |= readb(devpriv->ioaddr + PCI20000_DIO_2) << 16;
 579         data[1] |= readb(devpriv->ioaddr + PCI20000_DIO_3) << 24;
 580
 581         return 2;
 582 }
 583
 584 static void pci20xxx_dio_config(struct comedi_device *dev,
 585                                 struct comedi_subdevice *s)
 586 {
 587         unsigned char control_01;
 588         unsigned char control_23;
 589         unsigned char buffer;
 590
 591         control_01 = readb(devpriv->ioaddr + PCI20000_DIO_CONTROL_01);
 592         control_23 = readb(devpriv->ioaddr + PCI20000_DIO_CONTROL_23);
 593         buffer = readb(devpriv->ioaddr + PCI20000_DIO_BUFFER);
 594
 595         if (s->io_bits & 0x000000ff) {
 596                 /* output port 0 */
 597                 control_01 &= PCI20000_DIO_EOC;
 598                 buffer = (buffer & (~(DIO_BE << DIO_PS_0))) | (DIO_BO <<
 599                                                                DIO_PS_0);
 600         } else {
 601                 /* input port 0 */
 602                 control_01 = (control_01 & DIO_CAND) | PCI20000_DIO_EIC;
 603                 buffer = (buffer & (~(DIO_BI << DIO_PS_0)));
 604         }
 605         if (s->io_bits & 0x0000ff00) {
 606                 /* output port 1 */
 607                 control_01 &= PCI20000_DIO_OOC;
 608                 buffer = (buffer & (~(DIO_BE << DIO_PS_1))) | (DIO_BO <<
 609                                                                DIO_PS_1);
 610         } else {
 611                 /* input port 1 */
 612                 control_01 = (control_01 & DIO_CAND) | PCI20000_DIO_OIC;
 613                 buffer = (buffer & (~(DIO_BI << DIO_PS_1)));
 614         }
 615         if (s->io_bits & 0x00ff0000) {
 616                 /* output port 2 */
 617                 control_23 &= PCI20000_DIO_EOC;
 618                 buffer = (buffer & (~(DIO_BE << DIO_PS_2))) | (DIO_BO <<
 619                                                                DIO_PS_2);
 620         } else {
 621                 /* input port 2 */
 622                 control_23 = (control_23 & DIO_CAND) | PCI20000_DIO_EIC;
 623                 buffer = (buffer & (~(DIO_BI << DIO_PS_2)));
 624         }
 625         if (s->io_bits & 0xff000000) {
 626                 /* output port 3 */
 627                 control_23 &= PCI20000_DIO_OOC;
 628                 buffer = (buffer & (~(DIO_BE << DIO_PS_3))) | (DIO_BO <<
 629                                                                DIO_PS_3);
 630         } else {
 631                 /* input port 3 */
 632                 control_23 = (control_23 & DIO_CAND) | PCI20000_DIO_OIC;
 633                 buffer = (buffer & (~(DIO_BI << DIO_PS_3)));
 634         }
 635         writeb(control_01, devpriv->ioaddr + PCI20000_DIO_CONTROL_01);
 636         writeb(control_23, devpriv->ioaddr + PCI20000_DIO_CONTROL_23);
 637         writeb(buffer, devpriv->ioaddr + PCI20000_DIO_BUFFER);
 638 }
 639
 640 #if 0
 641 static void pci20xxx_do(struct comedi_device *dev, struct comedi_subdevice *s)
 642 {
 643         /* XXX if the channel is configured for input, does this
 644            do bad things? */
 645         /* XXX it would be a good idea to only update the registers
 646            that _need_ to be updated.  This requires changes to
 647            comedi, however. */
 648         writeb((s->state >> 0) & 0xff, devpriv->ioaddr + PCI20000_DIO_0);
 649         writeb((s->state >> 8) & 0xff, devpriv->ioaddr + PCI20000_DIO_1);
 650         writeb((s->state >> 16) & 0xff, devpriv->ioaddr + PCI20000_DIO_2);
 651         writeb((s->state >> 24) & 0xff, devpriv->ioaddr + PCI20000_DIO_3);
 652 }
 653
 654 static unsigned int pci20xxx_di(struct comedi_device *dev,
 655                                 struct comedi_subdevice *s)
 656 {
 657         /* XXX same note as above */
 658         unsigned int bits;
 659
 660         bits = readb(devpriv->ioaddr + PCI20000_DIO_0);
 661         bits |= readb(devpriv->ioaddr + PCI20000_DIO_1) << 8;
 662         bits |= readb(devpriv->ioaddr + PCI20000_DIO_2) << 16;
 663         bits |= readb(devpriv->ioaddr + PCI20000_DIO_3) << 24;
 664
 665         return bits;
 666 }
 667 #endif
 668
 669 static int __init driver_pci20xxx_init_module(void)
 670 {
 671         return comedi_driver_register(&driver_pci20xxx);
 672 }
 673
 674 static void __exit driver_pci20xxx_cleanup_module(void)
 675 {
 676         comedi_driver_unregister(&driver_pci20xxx);
 677 }
 678
 679 module_init(driver_pci20xxx_init_module);
 680 module_exit(driver_pci20xxx_cleanup_module);
 681
 682 MODULE_AUTHOR("Comedi http://www.comedi.org");
 683 MODULE_DESCRIPTION("Comedi low-level driver");
 684 MODULE_LICENSE("GPL");