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