SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/staging/comedi/drivers/das08.c

   1 /*
   2     comedi/drivers/das08.c
   3     DAS08 driver
   4
   5     COMEDI - Linux Control and Measurement Device Interface
   6     Copyright (C) 2000 David A. Schleef <ds@schleef.org>
   7     Copyright (C) 2001,2002,2003 Frank Mori Hess <fmhess@users.sourceforge.net>
   8     Copyright (C) 2004 Salvador E. Tropea <set@users.sf.net> <set@ieee.org>
   9
  10     This program is free software; you can redistribute it and/or modify
  11     it under the terms of the GNU General Public License as published by
  12     the Free Software Foundation; either version 2 of the License, or
  13     (at your option) any later version.
  14
  15     This program is distributed in the hope that it will be useful,
  16     but WITHOUT ANY WARRANTY; without even the implied warranty of
  17     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18     GNU General Public License for more details.
  19
  20     You should have received a copy of the GNU General Public License
  21     along with this program; if not, write to the Free Software
  22     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23
  24 *****************************************************************
  25
  26 */
  27 /*
  28 Driver: das08
  29 Description: DAS-08 compatible boards
  30 Author: Warren Jasper, ds, Frank Hess
  31 Devices: [Keithley Metrabyte] DAS08 (isa-das08), [ComputerBoards] DAS08 (isa-das08),
  32   DAS08-PGM (das08-pgm),
  33   DAS08-PGH (das08-pgh), DAS08-PGL (das08-pgl), DAS08-AOH (das08-aoh),
  34   DAS08-AOL (das08-aol), DAS08-AOM (das08-aom), DAS08/JR-AO (das08/jr-ao),
  35   DAS08/JR-16-AO (das08jr-16-ao), PCI-DAS08 (das08),
  36   PC104-DAS08 (pc104-das08), DAS08/JR/16 (das08jr/16)
  37 Status: works
  38
  39 This is a rewrite of the das08 and das08jr drivers.
  40
  41 Options (for ISA cards):
  42         [0] - base io address
  43
  44 Options (for pci-das08):
  45         [0] - bus  (optional)
  46         [1] = slot (optional)
  47
  48 The das08 driver doesn't support asynchronous commands, since
  49 the cheap das08 hardware doesn't really support them.  The
  50 comedi_rt_timer driver can be used to emulate commands for this
  51 driver.
  52 */
  53
  54 #include "../comedidev.h"
  55
  56 #include <linux/delay.h>
  57
  58 #include "comedi_pci.h"
  59 #include "8255.h"
  60 #include "das08.h"
  61
  62 #define DRV_NAME "das08"
  63
  64 #define PCI_VENDOR_ID_COMPUTERBOARDS 0x1307
  65 #define PCI_DEVICE_ID_PCIDAS08 0x29
  66 #define PCIDAS08_SIZE 0x54
  67
  68 /* pci configuration registers */
  69 #define INTCSR               0x4c
  70 #define   INTR1_ENABLE         0x1
  71 #define   INTR1_HIGH_POLARITY  0x2
  72 #define   PCI_INTR_ENABLE      0x40
  73 #define   INTR1_EDGE_TRIG      0x100    /*  requires high polarity */
  74 #define CNTRL                0x50
  75 #define   CNTRL_DIR            0x2
  76 #define   CNTRL_INTR           0x4
  77
  78 /*
  79     cio-das08.pdf
  80
  81   "isa-das08"
  82
  83   0     a/d bits 0-3            start 8 bit
  84   1     a/d bits 4-11           start 12 bit
  85   2     eoc, ip1-3, irq, mux    op1-4, inte, mux
  86   3     unused                  unused
  87   4567  8254
  88   89ab  8255
  89
  90   requires hard-wiring for async ai
  91
  92 */
  93
  94 #define DAS08_LSB               0
  95 #define DAS08_MSB               1
  96 #define DAS08_TRIG_12BIT        1
  97 #define DAS08_STATUS            2
  98 #define   DAS08_EOC                     (1<<7)
  99 #define   DAS08_IRQ                     (1<<3)
 100 #define   DAS08_IP(x)                   (((x)>>4)&0x7)
 101 #define DAS08_CONTROL           2
 102 #define   DAS08_MUX_MASK        0x7
 103 #define   DAS08_MUX(x)          ((x) & DAS08_MUX_MASK)
 104 #define   DAS08_INTE                    (1<<3)
 105 #define   DAS08_DO_MASK         0xf0
 106 #define   DAS08_OP(x)           (((x) << 4) & DAS08_DO_MASK)
 107
 108 /*
 109     cio-das08jr.pdf
 110
 111   "das08/jr-ao"
 112
 113   0     a/d bits 0-3            unused
 114   1     a/d bits 4-11           start 12 bit
 115   2     eoc, mux                mux
 116   3     di                      do
 117   4     unused                  ao0_lsb
 118   5     unused                  ao0_msb
 119   6     unused                  ao1_lsb
 120   7     unused                  ao1_msb
 121
 122 */
 123
 124 #define DAS08JR_DIO             3
 125 #define DAS08JR_AO_LSB(x)       ((x)?6:4)
 126 #define DAS08JR_AO_MSB(x)       ((x)?7:5)
 127
 128 /*
 129     cio-das08_aox.pdf
 130
 131   "das08-aoh"
 132   "das08-aol"
 133   "das08-aom"
 134
 135   0     a/d bits 0-3            start 8 bit
 136   1     a/d bits 4-11           start 12 bit
 137   2     eoc, ip1-3, irq, mux    op1-4, inte, mux
 138   3     mux, gain status        gain control
 139   4567  8254
 140   8     unused                  ao0_lsb
 141   9     unused                  ao0_msb
 142   a     unused                  ao1_lsb
 143   b     unused                  ao1_msb
 144   89ab
 145   cdef  8255
 146 */
 147
 148 #define DAS08AO_GAIN_CONTROL    3
 149 #define DAS08AO_GAIN_STATUS     3
 150
 151 #define DAS08AO_AO_LSB(x)       ((x)?0xa:8)
 152 #define DAS08AO_AO_MSB(x)       ((x)?0xb:9)
 153 #define DAS08AO_AO_UPDATE       8
 154
 155 /* gainlist same as _pgx_ below */
 156
 157 static int das08_ai_rinsn(struct comedi_device *dev, struct comedi_subdevice *s,
 158                           struct comedi_insn *insn, unsigned int *data);
 159 static int das08_di_rbits(struct comedi_device *dev, struct comedi_subdevice *s,
 160                           struct comedi_insn *insn, unsigned int *data);
 161 static int das08_do_wbits(struct comedi_device *dev, struct comedi_subdevice *s,
 162                           struct comedi_insn *insn, unsigned int *data);
 163 static int das08jr_di_rbits(struct comedi_device *dev,
 164                             struct comedi_subdevice *s,
 165                             struct comedi_insn *insn, unsigned int *data);
 166 static int das08jr_do_wbits(struct comedi_device *dev,
 167                             struct comedi_subdevice *s,
 168                             struct comedi_insn *insn, unsigned int *data);
 169 static int das08jr_ao_winsn(struct comedi_device *dev,
 170                             struct comedi_subdevice *s,
 171                             struct comedi_insn *insn, unsigned int *data);
 172 static int das08ao_ao_winsn(struct comedi_device *dev,
 173                             struct comedi_subdevice *s,
 174                             struct comedi_insn *insn, unsigned int *data);
 175 static void i8254_set_mode_low(unsigned int base, int channel,
 176                                unsigned int mode);
 177
 178 static const struct comedi_lrange range_das08_pgl = { 9, {
 179                                                           BIP_RANGE(10),
 180                                                           BIP_RANGE(5),
 181                                                           BIP_RANGE(2.5),
 182                                                           BIP_RANGE(1.25),
 183                                                           BIP_RANGE(0.625),
 184                                                           UNI_RANGE(10),
 185                                                           UNI_RANGE(5),
 186                                                           UNI_RANGE(2.5),
 187                                                           UNI_RANGE(1.25)
 188                                                           }
 189 };
 190
 191 static const struct comedi_lrange range_das08_pgh = { 12, {
 192                                                            BIP_RANGE(10),
 193                                                            BIP_RANGE(5),
 194                                                            BIP_RANGE(1),
 195                                                            BIP_RANGE(0.5),
 196                                                            BIP_RANGE(0.1),
 197                                                            BIP_RANGE(0.05),
 198                                                            BIP_RANGE(0.01),
 199                                                            BIP_RANGE(0.005),
 200                                                            UNI_RANGE(10),
 201                                                            UNI_RANGE(1),
 202                                                            UNI_RANGE(0.1),
 203                                                            UNI_RANGE(0.01),
 204                                                            }
 205 };
 206
 207 static const struct comedi_lrange range_das08_pgm = { 9, {
 208                                                           BIP_RANGE(10),
 209                                                           BIP_RANGE(5),
 210                                                           BIP_RANGE(0.5),
 211                                                           BIP_RANGE(0.05),
 212                                                           BIP_RANGE(0.01),
 213                                                           UNI_RANGE(10),
 214                                                           UNI_RANGE(1),
 215                                                           UNI_RANGE(0.1),
 216                                                           UNI_RANGE(0.01)
 217                                                           }
 218 };                              /*
 219                                    cio-das08jr.pdf
 220
 221                                    "das08/jr-ao"
 222
 223                                    0 a/d bits 0-3            unused
 224                                    1 a/d bits 4-11           start 12 bit
 225                                    2 eoc, mux                mux
 226                                    3 di                      do
 227                                    4 unused                  ao0_lsb
 228                                    5 unused                  ao0_msb
 229                                    6 unused                  ao1_lsb
 230                                    7 unused                  ao1_msb
 231
 232                                  */
 233
 234 static const struct comedi_lrange *const das08_ai_lranges[] = {
 235         &range_unknown,
 236         &range_bipolar5,
 237         &range_das08_pgh,
 238         &range_das08_pgl,
 239         &range_das08_pgm,
 240 };
 241
 242 static const int das08_pgh_gainlist[] =
 243     { 8, 0, 10, 2, 12, 4, 14, 6, 1, 3, 5, 7 };
 244 static const int das08_pgl_gainlist[] = { 8, 0, 2, 4, 6, 1, 3, 5, 7 };
 245 static const int das08_pgm_gainlist[] = { 8, 0, 10, 12, 14, 9, 11, 13, 15 };
 246
 247 static const int *const das08_gainlists[] = {
 248         NULL,
 249         NULL,
 250         das08_pgh_gainlist,
 251         das08_pgl_gainlist,
 252         das08_pgm_gainlist,
 253 };
 254
 255 static const struct das08_board_struct das08_boards[] = {
 256         {
 257          .name = "isa-das08",   /*  cio-das08.pdf */
 258          .bustype = isa,
 259          .ai = das08_ai_rinsn,
 260          .ai_nbits = 12,
 261          .ai_pg = das08_pg_none,
 262          .ai_encoding = das08_encode12,
 263          .ao = NULL,
 264          .ao_nbits = 12,
 265          .di = das08_di_rbits,
 266          .do_ = das08_do_wbits,
 267          .do_nchan = 4,
 268          .i8255_offset = 8,
 269          .i8254_offset = 4,
 270          .iosize = 16,          /*  unchecked */
 271          },
 272         {
 273          .name = "das08-pgm",   /*  cio-das08pgx.pdf */
 274          .bustype = isa,
 275          .ai = das08_ai_rinsn,
 276          .ai_nbits = 12,
 277          .ai_pg = das08_pgm,
 278          .ai_encoding = das08_encode12,
 279          .ao = NULL,
 280          .di = das08_di_rbits,
 281          .do_ = das08_do_wbits,
 282          .do_nchan = 4,
 283          .i8255_offset = 0,
 284          .i8254_offset = 0x04,
 285          .iosize = 16,          /*  unchecked */
 286          },
 287         {
 288          .name = "das08-pgh",   /*  cio-das08pgx.pdf */
 289          .bustype = isa,
 290          .ai = das08_ai_rinsn,
 291          .ai_nbits = 12,
 292          .ai_pg = das08_pgh,
 293          .ai_encoding = das08_encode12,
 294          .ao = NULL,
 295          .di = das08_di_rbits,
 296          .do_ = das08_do_wbits,
 297          .do_nchan = 4,
 298          .i8255_offset = 0,
 299          .i8254_offset = 0x04,
 300          .iosize = 16,          /*  unchecked */
 301          },
 302         {
 303          .name = "das08-pgl",   /*  cio-das08pgx.pdf */
 304          .bustype = isa,
 305          .ai = das08_ai_rinsn,
 306          .ai_nbits = 12,
 307          .ai_pg = das08_pgl,
 308          .ai_encoding = das08_encode12,
 309          .ao = NULL,
 310          .di = das08_di_rbits,
 311          .do_ = das08_do_wbits,
 312          .do_nchan = 4,
 313          .i8255_offset = 0,
 314          .i8254_offset = 0x04,
 315          .iosize = 16,          /*  unchecked */
 316          },
 317         {
 318          .name = "das08-aoh",   /*  cio-das08_aox.pdf */
 319          .bustype = isa,
 320          .ai = das08_ai_rinsn,
 321          .ai_nbits = 12,
 322          .ai_pg = das08_pgh,
 323          .ai_encoding = das08_encode12,
 324          .ao = das08ao_ao_winsn,        /*  8 */
 325          .ao_nbits = 12,
 326          .di = das08_di_rbits,
 327          .do_ = das08_do_wbits,
 328          .do_nchan = 4,
 329          .i8255_offset = 0x0c,
 330          .i8254_offset = 0x04,
 331          .iosize = 16,          /*  unchecked */
 332          },
 333         {
 334          .name = "das08-aol",   /*  cio-das08_aox.pdf */
 335          .bustype = isa,
 336          .ai = das08_ai_rinsn,
 337          .ai_nbits = 12,
 338          .ai_pg = das08_pgl,
 339          .ai_encoding = das08_encode12,
 340          .ao = das08ao_ao_winsn,        /*  8 */
 341          .ao_nbits = 12,
 342          .di = das08_di_rbits,
 343          .do_ = das08_do_wbits,
 344          .do_nchan = 4,
 345          .i8255_offset = 0x0c,
 346          .i8254_offset = 0x04,
 347          .iosize = 16,          /*  unchecked */
 348          },
 349         {
 350          .name = "das08-aom",   /*  cio-das08_aox.pdf */
 351          .bustype = isa,
 352          .ai = das08_ai_rinsn,
 353          .ai_nbits = 12,
 354          .ai_pg = das08_pgm,
 355          .ai_encoding = das08_encode12,
 356          .ao = das08ao_ao_winsn,        /*  8 */
 357          .ao_nbits = 12,
 358          .di = das08_di_rbits,
 359          .do_ = das08_do_wbits,
 360          .do_nchan = 4,
 361          .i8255_offset = 0x0c,
 362          .i8254_offset = 0x04,
 363          .iosize = 16,          /*  unchecked */
 364          },
 365         {
 366          .name = "das08/jr-ao", /*  cio-das08-jr-ao.pdf */
 367          .bustype = isa,
 368          .ai = das08_ai_rinsn,
 369          .ai_nbits = 12,
 370          .ai_pg = das08_pg_none,
 371          .ai_encoding = das08_encode12,
 372          .ao = das08jr_ao_winsn,
 373          .ao_nbits = 12,
 374          .di = das08jr_di_rbits,
 375          .do_ = das08jr_do_wbits,
 376          .do_nchan = 8,
 377          .i8255_offset = 0,
 378          .i8254_offset = 0,
 379          .iosize = 16,          /*  unchecked */
 380          },
 381         {
 382          .name = "das08jr-16-ao",       /*  cio-das08jr-16-ao.pdf */
 383          .bustype = isa,
 384          .ai = das08_ai_rinsn,
 385          .ai_nbits = 16,
 386          .ai_pg = das08_pg_none,
 387          .ai_encoding = das08_encode12,
 388          .ao = das08jr_ao_winsn,
 389          .ao_nbits = 16,
 390          .di = das08jr_di_rbits,
 391          .do_ = das08jr_do_wbits,
 392          .do_nchan = 8,
 393          .i8255_offset = 0,
 394          .i8254_offset = 0x04,
 395          .iosize = 16,          /*  unchecked */
 396          },
 397 #ifdef CONFIG_COMEDI_PCI
 398         {
 399          .name = "das08",       /*  pci-das08 */
 400          .id = PCI_DEVICE_ID_PCIDAS08,
 401          .bustype = pci,
 402          .ai = das08_ai_rinsn,
 403          .ai_nbits = 12,
 404          .ai_pg = das08_bipolar5,
 405          .ai_encoding = das08_encode12,
 406          .ao = NULL,
 407          .ao_nbits = 0,
 408          .di = das08_di_rbits,
 409          .do_ = das08_do_wbits,
 410          .do_nchan = 4,
 411          .i8255_offset = 0,
 412          .i8254_offset = 4,
 413          .iosize = 8,
 414          },
 415 #endif
 416         {
 417          .name = "pc104-das08",
 418          .bustype = pc104,
 419          .ai = das08_ai_rinsn,
 420          .ai_nbits = 12,
 421          .ai_pg = das08_pg_none,
 422          .ai_encoding = das08_encode12,
 423          .ao = NULL,
 424          .ao_nbits = 0,
 425          .di = das08_di_rbits,
 426          .do_ = das08_do_wbits,
 427          .do_nchan = 4,
 428          .i8255_offset = 0,
 429          .i8254_offset = 4,
 430          .iosize = 16,          /*  unchecked */
 431          },
 432 #if 0
 433         {
 434          .name = "das08/f",
 435          },
 436         {
 437          .name = "das08jr",
 438          },
 439 #endif
 440         {
 441          .name = "das08jr/16",
 442          .bustype = isa,
 443          .ai = das08_ai_rinsn,
 444          .ai_nbits = 16,
 445          .ai_pg = das08_pg_none,
 446          .ai_encoding = das08_encode16,
 447          .ao = NULL,
 448          .ao_nbits = 0,
 449          .di = das08jr_di_rbits,
 450          .do_ = das08jr_do_wbits,
 451          .do_nchan = 8,
 452          .i8255_offset = 0,
 453          .i8254_offset = 0,
 454          .iosize = 16,          /*  unchecked */
 455          },
 456 #if 0
 457         {
 458          .name = "das48-pga",   /*  cio-das48-pga.pdf */
 459          },
 460         {
 461          .name = "das08-pga-g2",        /*  a KM board */
 462          },
 463 #endif
 464 };
 465
 466 #ifdef CONFIG_COMEDI_PCMCIA
 467 struct das08_board_struct das08_cs_boards[NUM_DAS08_CS_BOARDS] = {
 468         {
 469          .name = "pcm-das08",
 470          .id = 0x0,             /*  XXX */
 471          .bustype = pcmcia,
 472          .ai = das08_ai_rinsn,
 473          .ai_nbits = 12,
 474          .ai_pg = das08_bipolar5,
 475          .ai_encoding = das08_pcm_encode12,
 476          .ao = NULL,
 477          .ao_nbits = 0,
 478          .di = das08_di_rbits,
 479          .do_ = das08_do_wbits,
 480          .do_nchan = 3,
 481          .i8255_offset = 0,
 482          .i8254_offset = 0,
 483          .iosize = 16,
 484          },
 485         /*  duplicate so driver name can be used also */
 486         {
 487          .name = "das08_cs",
 488          .id = 0x0,             /*  XXX */
 489          .bustype = pcmcia,
 490          .ai = das08_ai_rinsn,
 491          .ai_nbits = 12,
 492          .ai_pg = das08_bipolar5,
 493          .ai_encoding = das08_pcm_encode12,
 494          .ao = NULL,
 495          .ao_nbits = 0,
 496          .di = das08_di_rbits,
 497          .do_ = das08_do_wbits,
 498          .do_nchan = 3,
 499          .i8255_offset = 0,
 500          .i8254_offset = 0,
 501          .iosize = 16,
 502          },
 503 };
 504 #endif
 505
 506 #ifdef CONFIG_COMEDI_PCI
 507 static DEFINE_PCI_DEVICE_TABLE(das08_pci_table) = {
 508         {
 509         PCI_VENDOR_ID_COMPUTERBOARDS, PCI_DEVICE_ID_PCIDAS08,
 510                     PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
 511         0}
 512 };
 513
 514 MODULE_DEVICE_TABLE(pci, das08_pci_table);
 515 #endif
 516
 517 #define devpriv ((struct das08_private_struct *)dev->private)
 518 #define thisboard ((const struct das08_board_struct *)dev->board_ptr)
 519
 520 #define TIMEOUT 100000
 521
 522 static int das08_ai_rinsn(struct comedi_device *dev, struct comedi_subdevice *s,
 523                           struct comedi_insn *insn, unsigned int *data)
 524 {
 525         int i, n;
 526         int chan;
 527         int range;
 528         int lsb, msb;
 529
 530         chan = CR_CHAN(insn->chanspec);
 531         range = CR_RANGE(insn->chanspec);
 532
 533         /* clear crap */
 534         inb(dev->iobase + DAS08_LSB);
 535         inb(dev->iobase + DAS08_MSB);
 536
 537         /* set multiplexer */
 538         spin_lock(&dev->spinlock);      /*  lock to prevent race with digital output */
 539         devpriv->do_mux_bits &= ~DAS08_MUX_MASK;
 540         devpriv->do_mux_bits |= DAS08_MUX(chan);
 541         outb(devpriv->do_mux_bits, dev->iobase + DAS08_CONTROL);
 542         spin_unlock(&dev->spinlock);
 543
 544         if (s->range_table->length > 1) {
 545                 /* set gain/range */
 546                 range = CR_RANGE(insn->chanspec);
 547                 outb(devpriv->pg_gainlist[range],
 548                      dev->iobase + DAS08AO_GAIN_CONTROL);
 549         }
 550
 551         for (n = 0; n < insn->n; n++) {
 552                 /* clear over-range bits for 16-bit boards */
 553                 if (thisboard->ai_nbits == 16)
 554                         if (inb(dev->iobase + DAS08_MSB) & 0x80)
 555                                 printk("das08: over-range\n");
 556
 557                 /* trigger conversion */
 558                 outb_p(0, dev->iobase + DAS08_TRIG_12BIT);
 559
 560                 for (i = 0; i < TIMEOUT; i++) {
 561                         if (!(inb(dev->iobase + DAS08_STATUS) & DAS08_EOC))
 562                                 break;
 563                 }
 564                 if (i == TIMEOUT) {
 565                         printk("das08: timeout\n");
 566                         return -ETIME;
 567                 }
 568                 msb = inb(dev->iobase + DAS08_MSB);
 569                 lsb = inb(dev->iobase + DAS08_LSB);
 570                 if (thisboard->ai_encoding == das08_encode12) {
 571                         data[n] = (lsb >> 4) | (msb << 4);
 572                 } else if (thisboard->ai_encoding == das08_pcm_encode12) {
 573                         data[n] = (msb << 8) + lsb;
 574                 } else if (thisboard->ai_encoding == das08_encode16) {
 575                         /* FPOS 16-bit boards are sign-magnitude */
 576                         if (msb & 0x80)
 577                                 data[n] = (1 << 15) | lsb | ((msb & 0x7f) << 8);
 578                         else
 579                                 data[n] = (1 << 15) - (lsb | (msb & 0x7f) << 8);
 580                 } else {
 581                         comedi_error(dev, "bug! unknown ai encoding");
 582                         return -1;
 583                 }
 584         }
 585
 586         return n;
 587 }
 588
 589 static int das08_di_rbits(struct comedi_device *dev, struct comedi_subdevice *s,
 590                           struct comedi_insn *insn, unsigned int *data)
 591 {
 592         data[0] = 0;
 593         data[1] = DAS08_IP(inb(dev->iobase + DAS08_STATUS));
 594
 595         return 2;
 596 }
 597
 598 static int das08_do_wbits(struct comedi_device *dev, struct comedi_subdevice *s,
 599                           struct comedi_insn *insn, unsigned int *data)
 600 {
 601         int wbits;
 602
 603         /*  get current settings of digital output lines */
 604         wbits = (devpriv->do_mux_bits >> 4) & 0xf;
 605         /*  null bits we are going to set */
 606         wbits &= ~data[0];
 607         /*  set new bit values */
 608         wbits |= data[0] & data[1];
 609         /*  remember digital output bits */
 610         spin_lock(&dev->spinlock);      /*  prevent race with setting of analog input mux */
 611         devpriv->do_mux_bits &= ~DAS08_DO_MASK;
 612         devpriv->do_mux_bits |= DAS08_OP(wbits);
 613         outb(devpriv->do_mux_bits, dev->iobase + DAS08_CONTROL);
 614         spin_unlock(&dev->spinlock);
 615
 616         data[1] = wbits;
 617
 618         return 2;
 619 }
 620
 621 static int das08jr_di_rbits(struct comedi_device *dev,
 622                             struct comedi_subdevice *s,
 623                             struct comedi_insn *insn, unsigned int *data)
 624 {
 625         data[0] = 0;
 626         data[1] = inb(dev->iobase + DAS08JR_DIO);
 627
 628         return 2;
 629 }
 630
 631 static int das08jr_do_wbits(struct comedi_device *dev,
 632                             struct comedi_subdevice *s,
 633                             struct comedi_insn *insn, unsigned int *data)
 634 {
 635         /*  null bits we are going to set */
 636         devpriv->do_bits &= ~data[0];
 637         /*  set new bit values */
 638         devpriv->do_bits |= data[0] & data[1];
 639         outb(devpriv->do_bits, dev->iobase + DAS08JR_DIO);
 640
 641         data[1] = devpriv->do_bits;
 642
 643         return 2;
 644 }
 645
 646 static int das08jr_ao_winsn(struct comedi_device *dev,
 647                             struct comedi_subdevice *s,
 648                             struct comedi_insn *insn, unsigned int *data)
 649 {
 650         int n;
 651         int lsb, msb;
 652         int chan;
 653
 654         lsb = data[0] & 0xff;
 655         msb = (data[0] >> 8) & 0xf;
 656
 657         chan = CR_CHAN(insn->chanspec);
 658
 659         for (n = 0; n < insn->n; n++) {
 660 #if 0
 661                 outb(lsb, dev->iobase + devpriv->ao_offset_lsb[chan]);
 662                 outb(msb, dev->iobase + devpriv->ao_offset_msb[chan]);
 663 #else
 664                 outb(lsb, dev->iobase + DAS08JR_AO_LSB(chan));
 665                 outb(msb, dev->iobase + DAS08JR_AO_MSB(chan));
 666 #endif
 667
 668                 /* load DACs */
 669                 inb(dev->iobase + DAS08JR_DIO);
 670         }
 671
 672         return n;
 673 }
 674
 675 /*
 676  *
 677  * The -aox boards have the DACs at a different offset and use
 678  * a different method to force an update.
 679  *
 680  */
 681 static int das08ao_ao_winsn(struct comedi_device *dev,
 682                             struct comedi_subdevice *s,
 683                             struct comedi_insn *insn, unsigned int *data)
 684 {
 685         int n;
 686         int lsb, msb;
 687         int chan;
 688
 689         lsb = data[0] & 0xff;
 690         msb = (data[0] >> 8) & 0xf;
 691
 692         chan = CR_CHAN(insn->chanspec);
 693
 694         for (n = 0; n < insn->n; n++) {
 695 #if 0
 696                 outb(lsb, dev->iobase + devpriv->ao_offset_lsb[chan]);
 697                 outb(msb, dev->iobase + devpriv->ao_offset_msb[chan]);
 698 #else
 699                 outb(lsb, dev->iobase + DAS08AO_AO_LSB(chan));
 700                 outb(msb, dev->iobase + DAS08AO_AO_MSB(chan));
 701 #endif
 702
 703                 /* load DACs */
 704                 inb(dev->iobase + DAS08AO_AO_UPDATE);
 705         }
 706
 707         return n;
 708 }
 709
 710 static unsigned int i8254_read_channel_low(unsigned int base, int chan)
 711 {
 712         unsigned int msb, lsb;
 713
 714         /* The following instructions must be in order.
 715            We must avoid other process reading the counter's value in the
 716            middle.
 717            The spin_lock isn't needed since ioctl calls grab the big kernel
 718            lock automatically */
 719         /*spin_lock(sp); */
 720         outb(chan << 6, base + I8254_CTRL);
 721         base += chan;
 722         lsb = inb(base);
 723         msb = inb(base);
 724         /*spin_unlock(sp); */
 725
 726         return lsb | (msb << 8);
 727 }
 728
 729 static void i8254_write_channel_low(unsigned int base, int chan,
 730                                     unsigned int value)
 731 {
 732         unsigned int msb, lsb;
 733
 734         lsb = value & 0xFF;
 735         msb = value >> 8;
 736
 737         /* write lsb, then msb */
 738         base += chan;
 739         /* See comments in i8254_read_channel_low */
 740         /*spin_lock(sp); */
 741         outb(lsb, base);
 742         outb(msb, base);
 743         /*spin_unlock(sp); */
 744 }
 745
 746 static unsigned int i8254_read_channel(struct i8254_struct *st, int channel)
 747 {
 748         int chan = st->logic2phys[channel];
 749
 750         return i8254_read_channel_low(st->iobase, chan);
 751 }
 752
 753 static void i8254_write_channel(struct i8254_struct *st, int channel,
 754                                 unsigned int value)
 755 {
 756         int chan = st->logic2phys[channel];
 757
 758         i8254_write_channel_low(st->iobase, chan, value);
 759 }
 760
 761 static void i8254_initialize(struct i8254_struct *st)
 762 {
 763         int i;
 764         for (i = 0; i < 3; ++i)
 765                 i8254_set_mode_low(st->iobase, i, st->mode[i]);
 766 }
 767
 768 static void i8254_set_mode_low(unsigned int base, int channel,
 769                                unsigned int mode)
 770 {
 771         outb((channel << 6) | 0x30 | (mode & 0x0F), base + I8254_CTRL);
 772 }
 773
 774 static void i8254_set_mode(struct i8254_struct *st, int channel,
 775                            unsigned int mode)
 776 {
 777         int chan = st->logic2phys[channel];
 778
 779         st->mode[chan] = mode;
 780         return i8254_set_mode_low(st->iobase, chan, mode);
 781 }
 782
 783 static unsigned int i8254_read_status_low(unsigned int base, int channel)
 784 {
 785         outb(0xE0 | (2 << channel), base + I8254_CTRL);
 786         return inb(base + channel);
 787 }
 788
 789 static unsigned int i8254_read_status(struct i8254_struct *st, int channel)
 790 {
 791         int chan = st->logic2phys[channel];
 792
 793         return i8254_read_status_low(st->iobase, chan);
 794 }
 795
 796 static int das08_counter_read(struct comedi_device *dev,
 797                               struct comedi_subdevice *s,
 798                               struct comedi_insn *insn, unsigned int *data)
 799 {
 800         int chan = insn->chanspec;
 801
 802         /* printk("Reading counter channel %d ",chan); */
 803         data[0] = i8254_read_channel(&devpriv->i8254, chan);
 804         /* printk("=> 0x%08X\n",data[0]); */
 805
 806         return 1;
 807 }
 808
 809 static int das08_counter_write(struct comedi_device *dev,
 810                                struct comedi_subdevice *s,
 811                                struct comedi_insn *insn, unsigned int *data)
 812 {
 813         int chan = insn->chanspec;
 814
 815         /* printk("Writing counter channel %d with 0x%04X\n",chan,data[0]); */
 816         i8254_write_channel(&devpriv->i8254, chan, data[0]);
 817
 818         return 1;
 819 }
 820
 821 static int das08_counter_config(struct comedi_device *dev,
 822                                 struct comedi_subdevice *s,
 823                                 struct comedi_insn *insn, unsigned int *data)
 824 {
 825         int chan = insn->chanspec;
 826
 827         if (insn->n != 2)
 828                 return -EINVAL;
 829
 830         switch (data[0]) {
 831         case INSN_CONFIG_SET_COUNTER_MODE:
 832                 i8254_set_mode(&devpriv->i8254, chan, data[1]);
 833                 break;
 834         case INSN_CONFIG_8254_READ_STATUS:
 835                 data[1] = i8254_read_status(&devpriv->i8254, chan);
 836                 break;
 837         default:
 838                 return -EINVAL;
 839                 break;
 840         }
 841         return 2;
 842 }
 843
 844 static int das08_attach(struct comedi_device *dev, struct comedi_devconfig *it);
 845
 846 static struct comedi_driver driver_das08 = {
 847         .driver_name = DRV_NAME,
 848         .module = THIS_MODULE,
 849         .attach = das08_attach,
 850         .detach = das08_common_detach,
 851         .board_name = &das08_boards[0].name,
 852         .num_names = sizeof(das08_boards) / sizeof(struct das08_board_struct),
 853         .offset = sizeof(struct das08_board_struct),
 854 };
 855
 856 int das08_common_attach(struct comedi_device *dev, unsigned long iobase)
 857 {
 858         struct comedi_subdevice *s;
 859         int ret;
 860
 861         /*  allocate ioports for non-pcmcia, non-pci boards */
 862         if ((thisboard->bustype != pcmcia) && (thisboard->bustype != pci)) {
 863                 printk(" iobase 0x%lx\n", iobase);
 864                 if (!request_region(iobase, thisboard->iosize, DRV_NAME)) {
 865                         printk(" I/O port conflict\n");
 866                         return -EIO;
 867                 }
 868         }
 869         dev->iobase = iobase;
 870
 871         dev->board_name = thisboard->name;
 872
 873         ret = alloc_subdevices(dev, 6);
 874         if (ret < 0)
 875                 return ret;
 876
 877         s = dev->subdevices + 0;
 878         /* ai */
 879         if (thisboard->ai) {
 880                 s->type = COMEDI_SUBD_AI;
 881                 /* XXX some boards actually have differential inputs instead of single ended.
 882                  *  The driver does nothing with arefs though, so it's no big deal. */
 883                 s->subdev_flags = SDF_READABLE | SDF_GROUND;
 884                 s->n_chan = 8;
 885                 s->maxdata = (1 << thisboard->ai_nbits) - 1;
 886                 s->range_table = das08_ai_lranges[thisboard->ai_pg];
 887                 s->insn_read = thisboard->ai;
 888                 devpriv->pg_gainlist = das08_gainlists[thisboard->ai_pg];
 889         } else {
 890                 s->type = COMEDI_SUBD_UNUSED;
 891         }
 892
 893         s = dev->subdevices + 1;
 894         /* ao */
 895         if (thisboard->ao) {
 896                 s->type = COMEDI_SUBD_AO;
 897 /* XXX lacks read-back insn */
 898                 s->subdev_flags = SDF_WRITABLE;
 899                 s->n_chan = 2;
 900                 s->maxdata = (1 << thisboard->ao_nbits) - 1;
 901                 s->range_table = &range_bipolar5;
 902                 s->insn_write = thisboard->ao;
 903         } else {
 904                 s->type = COMEDI_SUBD_UNUSED;
 905         }
 906
 907         s = dev->subdevices + 2;
 908         /* di */
 909         if (thisboard->di) {
 910                 s->type = COMEDI_SUBD_DI;
 911                 s->subdev_flags = SDF_READABLE;
 912                 s->n_chan = (thisboard->di == das08_di_rbits) ? 3 : 8;
 913                 s->maxdata = 1;
 914                 s->range_table = &range_digital;
 915                 s->insn_bits = thisboard->di;
 916         } else {
 917                 s->type = COMEDI_SUBD_UNUSED;
 918         }
 919
 920         s = dev->subdevices + 3;
 921         /* do */
 922         if (thisboard->do_) {
 923                 s->type = COMEDI_SUBD_DO;
 924                 s->subdev_flags = SDF_WRITABLE | SDF_READABLE;
 925                 s->n_chan = thisboard->do_nchan;
 926                 s->maxdata = 1;
 927                 s->range_table = &range_digital;
 928                 s->insn_bits = thisboard->do_;
 929         } else {
 930                 s->type = COMEDI_SUBD_UNUSED;
 931         }
 932
 933         s = dev->subdevices + 4;
 934         /* 8255 */
 935         if (thisboard->i8255_offset != 0) {
 936                 subdev_8255_init(dev, s, NULL, (unsigned long)(dev->iobase +
 937                                                                thisboard->
 938                                                                i8255_offset));
 939         } else {
 940                 s->type = COMEDI_SUBD_UNUSED;
 941         }
 942
 943         s = dev->subdevices + 5;
 944         /* 8254 */
 945         if (thisboard->i8254_offset != 0) {
 946                 s->type = COMEDI_SUBD_COUNTER;
 947                 s->subdev_flags = SDF_WRITABLE | SDF_READABLE;
 948                 s->n_chan = 3;
 949                 s->maxdata = 0xFFFF;
 950                 s->insn_read = das08_counter_read;
 951                 s->insn_write = das08_counter_write;
 952                 s->insn_config = das08_counter_config;
 953                 /* Set-up the 8254 structure */
 954                 devpriv->i8254.channels = 3;
 955                 devpriv->i8254.logic2phys[0] = 0;
 956                 devpriv->i8254.logic2phys[1] = 1;
 957                 devpriv->i8254.logic2phys[2] = 2;
 958                 devpriv->i8254.iobase = iobase + thisboard->i8254_offset;
 959                 devpriv->i8254.mode[0] =
 960                     devpriv->i8254.mode[1] =
 961                     devpriv->i8254.mode[2] = I8254_MODE0 | I8254_BINARY;
 962                 i8254_initialize(&devpriv->i8254);
 963         } else {
 964                 s->type = COMEDI_SUBD_UNUSED;
 965         }
 966
 967         return 0;
 968 }
 969
 970 static int das08_attach(struct comedi_device *dev, struct comedi_devconfig *it)
 971 {
 972         int ret;
 973         unsigned long iobase;
 974 #ifdef CONFIG_COMEDI_PCI
 975         unsigned long pci_iobase = 0;
 976         struct pci_dev *pdev;
 977 #endif
 978
 979         ret = alloc_private(dev, sizeof(struct das08_private_struct));
 980         if (ret < 0)
 981                 return ret;
 982
 983         printk("comedi%d: das08: ", dev->minor);
 984         /*  deal with a pci board */
 985         if (thisboard->bustype == pci) {
 986 #ifdef CONFIG_COMEDI_PCI
 987                 if (it->options[0] || it->options[1]) {
 988                         printk("bus %i slot %i ",
 989                                it->options[0], it->options[1]);
 990                 }
 991                 printk("\n");
 992                 /*  find card */
 993                 for (pdev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, NULL);
 994                      pdev != NULL;
 995                      pdev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, pdev)) {
 996                         if (pdev->vendor == PCI_VENDOR_ID_COMPUTERBOARDS
 997                             && pdev->device == PCI_DEVICE_ID_PCIDAS08) {
 998                                 if (it->options[0] || it->options[1]) {
 999                                         if (pdev->bus->number == it->options[0]
1000                                             && PCI_SLOT(pdev->devfn) ==
1001                                             it->options[1]) {
1002                                                 break;
1003                                         }
1004                                 } else {
1005                                         break;
1006                                 }
1007                         }
1008                 }
1009                 if (!pdev) {
1010                         printk("No pci das08 cards found\n");
1011                         return -EIO;
1012                 }
1013                 devpriv->pdev = pdev;
1014                 /*  enable PCI device and reserve I/O spaces */
1015                 if (comedi_pci_enable(pdev, DRV_NAME)) {
1016                         printk
1017                             (" Error enabling PCI device and requesting regions\n");
1018                         return -EIO;
1019                 }
1020                 /*  read base addresses */
1021                 pci_iobase = pci_resource_start(pdev, 1);
1022                 iobase = pci_resource_start(pdev, 2);
1023                 printk("pcibase 0x%lx  iobase 0x%lx\n", pci_iobase, iobase);
1024                 devpriv->pci_iobase = pci_iobase;
1025 #if 0
1026 /* We could enable to pci-das08's interrupt here to make it possible
1027  * to do timed input in this driver, but there is little point since
1028  * conversions would have to be started by the interrupt handler
1029  * so you might as well use comedi_rt_timer to emulate commands
1030  */
1031                 /* set source of interrupt trigger to counter2 output */
1032                 outb(CNTRL_INTR | CNTRL_DIR, pci_iobase + CNTRL);
1033                 /* Enable local interrupt 1 and pci interrupt */
1034                 outw(INTR1_ENABLE | PCI_INTR_ENABLE, pci_iobase + INTCSR);
1035 #endif
1036 #else /* CONFIG_COMEDI_PCI */
1037                 printk("this driver has not been built with PCI support.\n");
1038                 return -EINVAL;
1039 #endif /* CONFIG_COMEDI_PCI */
1040         } else {
1041                 iobase = it->options[0];
1042         }
1043         printk("\n");
1044
1045         return das08_common_attach(dev, iobase);
1046 }
1047
1048 int das08_common_detach(struct comedi_device *dev)
1049 {
1050         printk(KERN_INFO "comedi%d: das08: remove\n", dev->minor);
1051
1052         if (dev->subdevices)
1053                 subdev_8255_cleanup(dev, dev->subdevices + 4);
1054
1055         /*  deallocate ioports for non-pcmcia, non-pci boards */
1056         if ((thisboard->bustype != pcmcia) && (thisboard->bustype != pci)) {
1057                 if (dev->iobase)
1058                         release_region(dev->iobase, thisboard->iosize);
1059         }
1060 #ifdef CONFIG_COMEDI_PCI
1061         if (devpriv) {
1062                 if (devpriv->pdev) {
1063                         if (devpriv->pci_iobase) {
1064                                 comedi_pci_disable(devpriv->pdev);
1065                         }
1066                         pci_dev_put(devpriv->pdev);
1067                 }
1068         }
1069 #endif
1070
1071         return 0;
1072 }
1073
1074 #ifdef CONFIG_COMEDI_PCI
1075 COMEDI_PCI_INITCLEANUP(driver_das08, das08_pci_table);
1076 #else
1077 COMEDI_INITCLEANUP(driver_das08);
1078 #endif
1079
1080 EXPORT_SYMBOL_GPL(das08_common_attach);
1081 EXPORT_SYMBOL_GPL(das08_common_detach);
1082 #ifdef CONFIG_COMEDI_PCMCIA
1083 EXPORT_SYMBOL_GPL(das08_cs_boards);
1084 #endif