drivers/staging/comedi/drivers/pcmmio.c

   1 /*
   2     comedi/drivers/pcmmio.c
   3     Driver for Winsystems PC-104 based multifunction IO board.
   4
   5     COMEDI - Linux Control and Measurement Device Interface
   6     Copyright (C) 2007 Calin A. Culianu <calin@ajvar.org>
   7
   8     This program is free software; you can redistribute it and/or modify
   9     it under the terms of the GNU General Public License as published by
  10     the Free Software Foundation; either version 2 of the License, or
  11     (at your option) any later version.
  12
  13     This program is distributed in the hope that it will be useful,
  14     but WITHOUT ANY WARRANTY; without even the implied warranty of
  15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16     GNU General Public License for more details.
  17
  18     You should have received a copy of the GNU General Public License
  19     along with this program; if not, write to the Free Software
  20     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22 /*
  23 Driver: pcmmio
  24 Description: A driver for the PCM-MIO multifunction board
  25 Devices: [Winsystems] PCM-MIO (pcmmio)
  26 Author: Calin Culianu <calin@ajvar.org>
  27 Updated: Wed, May 16 2007 16:21:10 -0500
  28 Status: works
  29
  30 A driver for the relatively new PCM-MIO multifunction board from
  31 Winsystems.  This board is a PC-104 based I/O board.  It contains
  32 four subdevices:
  33   subdevice 0 - 16 channels of 16-bit AI
  34   subdevice 1 - 8 channels of 16-bit AO
  35   subdevice 2 - first 24 channels of the 48 channel of DIO
  36         (with edge-triggered interrupt support)
  37   subdevice 3 - last 24 channels of the 48 channel DIO
  38         (no interrupt support for this bank of channels)
  39
  40   Some notes:
  41
  42   Synchronous reads and writes are the only things implemented for AI and AO,
  43   even though the hardware itself can do streaming acquisition, etc.  Anyone
  44   want to add asynchronous I/O for AI/AO as a feature?  Be my guest...
  45
  46   Asynchronous I/O for the DIO subdevices *is* implemented, however!  They are
  47   basically edge-triggered interrupts for any configuration of the first
  48   24 DIO-lines.
  49
  50   Also note that this interrupt support is untested.
  51
  52   A few words about edge-detection IRQ support (commands on DIO):
  53
  54   * To use edge-detection IRQ support for the DIO subdevice, pass the IRQ
  55     of the board to the comedi_config command.  The board IRQ is not jumpered
  56     but rather configured through software, so any IRQ from 1-15 is OK.
  57
  58   * Due to the genericity of the comedi API, you need to create a special
  59     comedi_command in order to use edge-triggered interrupts for DIO.
  60
  61   * Use comedi_commands with TRIG_NOW.  Your callback will be called each
  62     time an edge is detected on the specified DIO line(s), and the data
  63     values will be two sample_t's, which should be concatenated to form
  64     one 32-bit unsigned int.  This value is the mask of channels that had
  65     edges detected from your channel list.  Note that the bits positions
  66     in the mask correspond to positions in your chanlist when you
  67     specified the command and *not* channel id's!
  68
  69  *  To set the polarity of the edge-detection interrupts pass a nonzero value
  70     for either CR_RANGE or CR_AREF for edge-up polarity, or a zero
  71     value for both CR_RANGE and CR_AREF if you want edge-down polarity.
  72
  73 Configuration Options:
  74   [0] - I/O port base address
  75   [1] - IRQ (optional -- for edge-detect interrupt support only,
  76         leave out if you don't need this feature)
  77 */
  78
  79 #include <linux/interrupt.h>
  80 #include <linux/slab.h>
  81 #include "../comedidev.h"
  82 #include "pcm_common.h"
  83 #include <linux/pci.h>          /* for PCI devices */
  84
  85 /* This stuff is all from pcmuio.c -- it refers to the DIO subdevices only */
  86 #define CHANS_PER_PORT   8
  87 #define PORTS_PER_ASIC   6
  88 #define INTR_PORTS_PER_ASIC   3
  89 #define MAX_CHANS_PER_SUBDEV 24 /* number of channels per comedi subdevice */
  90 #define PORTS_PER_SUBDEV (MAX_CHANS_PER_SUBDEV/CHANS_PER_PORT)
  91 #define CHANS_PER_ASIC (CHANS_PER_PORT*PORTS_PER_ASIC)
  92 #define INTR_CHANS_PER_ASIC 24
  93 #define INTR_PORTS_PER_SUBDEV (INTR_CHANS_PER_ASIC/CHANS_PER_PORT)
  94 #define MAX_DIO_CHANS   (PORTS_PER_ASIC*1*CHANS_PER_PORT)
  95 #define MAX_ASICS       (MAX_DIO_CHANS/CHANS_PER_ASIC)
  96 #define SDEV_NO ((int)(s - dev->subdevices))
  97 #define CALC_N_DIO_SUBDEVS(nchans) ((nchans)/MAX_CHANS_PER_SUBDEV + (!!((nchans)%MAX_CHANS_PER_SUBDEV)) /*+ (nchans > INTR_CHANS_PER_ASIC ? 2 : 1)*/)
  98 /* IO Memory sizes */
  99 #define ASIC_IOSIZE (0x0B)
 100 #define PCMMIO48_IOSIZE ASIC_IOSIZE
 101
 102 /* Some offsets - these are all in the 16byte IO memory offset from
 103    the base address.  Note that there is a paging scheme to swap out
 104    offsets 0x8-0xA using the PAGELOCK register.  See the table below.
 105
 106   Register(s)       Pages        R/W?        Description
 107   --------------------------------------------------------------
 108   REG_PORTx         All          R/W         Read/Write/Configure IO
 109   REG_INT_PENDING   All          ReadOnly    Quickly see which INT_IDx has int.
 110   REG_PAGELOCK      All          WriteOnly   Select a page
 111   REG_POLx          Pg. 1 only   WriteOnly   Select edge-detection polarity
 112   REG_ENABx         Pg. 2 only   WriteOnly   Enable/Disable edge-detect. int.
 113   REG_INT_IDx       Pg. 3 only   R/W         See which ports/bits have ints.
 114  */
 115 #define REG_PORT0 0x0
 116 #define REG_PORT1 0x1
 117 #define REG_PORT2 0x2
 118 #define REG_PORT3 0x3
 119 #define REG_PORT4 0x4
 120 #define REG_PORT5 0x5
 121 #define REG_INT_PENDING 0x6
 122 #define REG_PAGELOCK 0x7        /*
 123                                  * page selector register, upper 2 bits select
 124                                  * a page and bits 0-5 are used to 'lock down'
 125                                  * a particular port above to make it readonly.
 126                                  */
 127 #define REG_POL0 0x8
 128 #define REG_POL1 0x9
 129 #define REG_POL2 0xA
 130 #define REG_ENAB0 0x8
 131 #define REG_ENAB1 0x9
 132 #define REG_ENAB2 0xA
 133 #define REG_INT_ID0 0x8
 134 #define REG_INT_ID1 0x9
 135 #define REG_INT_ID2 0xA
 136
 137 #define NUM_PAGED_REGS 3
 138 #define NUM_PAGES 4
 139 #define FIRST_PAGED_REG 0x8
 140 #define REG_PAGE_BITOFFSET 6
 141 #define REG_LOCK_BITOFFSET 0
 142 #define REG_PAGE_MASK (~((0x1<<REG_PAGE_BITOFFSET)-1))
 143 #define REG_LOCK_MASK (~(REG_PAGE_MASK))
 144 #define PAGE_POL 1
 145 #define PAGE_ENAB 2
 146 #define PAGE_INT_ID 3
 147
 148 typedef int (*comedi_insn_fn_t) (struct comedi_device *,
 149                                  struct comedi_subdevice *,
 150                                  struct comedi_insn *, unsigned int *);
 151
 152 static int ai_rinsn(struct comedi_device *, struct comedi_subdevice *,
 153                     struct comedi_insn *, unsigned int *);
 154 static int ao_rinsn(struct comedi_device *, struct comedi_subdevice *,
 155                     struct comedi_insn *, unsigned int *);
 156 static int ao_winsn(struct comedi_device *, struct comedi_subdevice *,
 157                     struct comedi_insn *, unsigned int *);
 158
 159 /*
 160  * Board descriptions for two imaginary boards.  Describing the
 161  * boards in this way is optional, and completely driver-dependent.
 162  * Some drivers use arrays such as this, other do not.
 163  */
 164 struct pcmmio_board {
 165         const char *name;
 166         const int dio_num_asics;
 167         const int dio_num_ports;
 168         const int total_iosize;
 169         const int ai_bits;
 170         const int ao_bits;
 171         const int n_ai_chans;
 172         const int n_ao_chans;
 173         const struct comedi_lrange *ai_range_table, *ao_range_table;
 174         comedi_insn_fn_t ai_rinsn, ao_rinsn, ao_winsn;
 175 };
 176
 177 static const struct comedi_lrange ranges_ai = {
 178         4, {RANGE(-5., 5.), RANGE(-10., 10.), RANGE(0., 5.), RANGE(0., 10.)}
 179 };
 180
 181 static const struct comedi_lrange ranges_ao = {
 182         6, {RANGE(0., 5.), RANGE(0., 10.), RANGE(-5., 5.), RANGE(-10., 10.),
 183           RANGE(-2.5, 2.5), RANGE(-2.5, 7.5)}
 184 };
 185
 186 static const struct pcmmio_board pcmmio_boards[] = {
 187         {
 188          .name = "pcmmio",
 189          .dio_num_asics = 1,
 190          .dio_num_ports = 6,
 191          .total_iosize = 32,
 192          .ai_bits = 16,
 193          .ao_bits = 16,
 194          .n_ai_chans = 16,
 195          .n_ao_chans = 8,
 196          .ai_range_table = &ranges_ai,
 197          .ao_range_table = &ranges_ao,
 198          .ai_rinsn = ai_rinsn,
 199          .ao_rinsn = ao_rinsn,
 200          .ao_winsn = ao_winsn},
 201 };
 202
 203 /*
 204  * Useful for shorthand access to the particular board structure
 205  */
 206 #define thisboard ((const struct pcmmio_board *)dev->board_ptr)
 207
 208 /* this structure is for data unique to this subdevice.  */
 209 struct pcmmio_subdev_private {
 210
 211         union {
 212                 /* for DIO: mapping of halfwords (bytes)
 213                    in port/chanarray to iobase */
 214                 unsigned long iobases[PORTS_PER_SUBDEV];
 215
 216                 /* for AI/AO */
 217                 unsigned long iobase;
 218         };
 219         union {
 220                 struct {
 221
 222                         /* The below is only used for intr subdevices */
 223                         struct {
 224                                 /*
 225                                  * if non-negative, this subdev has an
 226                                  * interrupt asic
 227                                  */
 228                                 int asic;
 229                                 /*
 230                                  * if nonnegative, the first channel id for
 231                                  * interrupts.
 232                                  */
 233                                 int first_chan;
 234                                 /*
 235                                  * the number of asic channels in this subdev
 236                                  * that have interrutps
 237                                  */
 238                                 int num_asic_chans;
 239                                 /*
 240                                  * if nonnegative, the first channel id with
 241                                  * respect to the asic that has interrupts
 242                                  */
 243                                 int asic_chan;
 244                                 /*
 245                                  * subdev-relative channel mask for channels
 246                                  * we are interested in
 247                                  */
 248                                 int enabled_mask;
 249                                 int active;
 250                                 int stop_count;
 251                                 int continuous;
 252                                 spinlock_t spinlock;
 253                         } intr;
 254                 } dio;
 255                 struct {
 256                         /* the last unsigned int data written */
 257                         unsigned int shadow_samples[8];
 258                 } ao;
 259         };
 260 };
 261
 262 /*
 263  * this structure is for data unique to this hardware driver.  If
 264  * several hardware drivers keep similar information in this structure,
 265  * feel free to suggest moving the variable to the struct comedi_device struct.
 266  */
 267 struct pcmmio_private {
 268         /* stuff for DIO */
 269         struct {
 270                 unsigned char pagelock; /* current page and lock */
 271                 /* shadow of POLx registers */
 272                 unsigned char pol[NUM_PAGED_REGS];
 273                 /* shadow of ENABx registers */
 274                 unsigned char enab[NUM_PAGED_REGS];
 275                 int num;
 276                 unsigned long iobase;
 277                 unsigned int irq;
 278                 spinlock_t spinlock;
 279         } asics[MAX_ASICS];
 280         struct pcmmio_subdev_private *sprivs;
 281 };
 282
 283 /*
 284  * most drivers define the following macro to make it easy to
 285  * access the private structure.
 286  */
 287 #define devpriv ((struct pcmmio_private *)dev->private)
 288 #define subpriv ((struct pcmmio_subdev_private *)s->private)
 289 /*
 290  * The struct comedi_driver structure tells the Comedi core module
 291  * which functions to call to configure/deconfigure (attach/detach)
 292  * the board, and also about the kernel module that contains
 293  * the device code.
 294  */
 295 static int pcmmio_attach(struct comedi_device *dev,
 296                          struct comedi_devconfig *it);
 297 static int pcmmio_detach(struct comedi_device *dev);
 298
 299 static struct comedi_driver driver = {
 300         .driver_name = "pcmmio",
 301         .module = THIS_MODULE,
 302         .attach = pcmmio_attach,
 303         .detach = pcmmio_detach,
 304 /* It is not necessary to implement the following members if you are
 305  * writing a driver for a ISA PnP or PCI card */
 306         /* Most drivers will support multiple types of boards by
 307          * having an array of board structures.  These were defined
 308          * in pcmmio_boards[] above.  Note that the element 'name'
 309          * was first in the structure -- Comedi uses this fact to
 310          * extract the name of the board without knowing any details
 311          * about the structure except for its length.
 312          * When a device is attached (by comedi_config), the name
 313          * of the device is given to Comedi, and Comedi tries to
 314          * match it by going through the list of board names.  If
 315          * there is a match, the address of the pointer is put
 316          * into dev->board_ptr and driver->attach() is called.
 317          *
 318          * Note that these are not necessary if you can determine
 319          * the type of board in software.  ISA PnP, PCI, and PCMCIA
 320          * devices are such boards.
 321          */
 322         .board_name = &pcmmio_boards[0].name,
 323         .offset = sizeof(struct pcmmio_board),
 324         .num_names = ARRAY_SIZE(pcmmio_boards),
 325 };
 326
 327 static int pcmmio_dio_insn_bits(struct comedi_device *dev,
 328                                 struct comedi_subdevice *s,
 329                                 struct comedi_insn *insn, unsigned int *data);
 330 static int pcmmio_dio_insn_config(struct comedi_device *dev,
 331                                   struct comedi_subdevice *s,
 332                                   struct comedi_insn *insn, unsigned int *data);
 333
 334 static irqreturn_t interrupt_pcmmio(int irq, void *d);
 335 static void pcmmio_stop_intr(struct comedi_device *, struct comedi_subdevice *);
 336 static int pcmmio_cancel(struct comedi_device *dev, struct comedi_subdevice *s);
 337 static int pcmmio_cmd(struct comedi_device *dev, struct comedi_subdevice *s);
 338 static int pcmmio_cmdtest(struct comedi_device *dev, struct comedi_subdevice *s,
 339                           struct comedi_cmd *cmd);
 340
 341 /* some helper functions to deal with specifics of this device's registers */
 342 /* sets up/clears ASIC chips to defaults */
 343 static void init_asics(struct comedi_device *dev);
 344 static void switch_page(struct comedi_device *dev, int asic, int page);
 345 #ifdef notused
 346 static void lock_port(struct comedi_device *dev, int asic, int port);
 347 static void unlock_port(struct comedi_device *dev, int asic, int port);
 348 #endif
 349
 350 /*
 351  * Attach is called by the Comedi core to configure the driver
 352  * for a particular board.  If you specified a board_name array
 353  * in the driver structure, dev->board_ptr contains that
 354  * address.
 355  */
 356 static int pcmmio_attach(struct comedi_device *dev, struct comedi_devconfig *it)
 357 {
 358         struct comedi_subdevice *s;
 359         int sdev_no, chans_left, n_dio_subdevs, n_subdevs, port, asic,
 360             thisasic_chanct = 0;
 361         unsigned long iobase;
 362         unsigned int irq[MAX_ASICS];
 363
 364         iobase = it->options[0];
 365         irq[0] = it->options[1];
 366
 367         printk("comedi%d: %s: io: %lx ", dev->minor, driver.driver_name,
 368                iobase);
 369
 370         dev->iobase = iobase;
 371
 372         if (!iobase || !request_region(iobase,
 373                                        thisboard->total_iosize,
 374                                        driver.driver_name)) {
 375                 printk("I/O port conflict\n");
 376                 return -EIO;
 377         }
 378
 379 /*
 380  * Initialize dev->board_name.  Note that we can use the "thisboard"
 381  * macro now, since we just initialized it in the last line.
 382  */
 383         dev->board_name = thisboard->name;
 384
 385 /*
 386  * Allocate the private structure area.  alloc_private() is a
 387  * convenient macro defined in comedidev.h.
 388  */
 389         if (alloc_private(dev, sizeof(struct pcmmio_private)) < 0) {
 390                 printk("cannot allocate private data structure\n");
 391                 return -ENOMEM;
 392         }
 393
 394         for (asic = 0; asic < MAX_ASICS; ++asic) {
 395                 devpriv->asics[asic].num = asic;
 396                 devpriv->asics[asic].iobase =
 397                     dev->iobase + 16 + asic * ASIC_IOSIZE;
 398                 /*
 399                  * this gets actually set at the end of this function when we
 400                  * request_irqs
 401                  */
 402                 devpriv->asics[asic].irq = 0;
 403                 spin_lock_init(&devpriv->asics[asic].spinlock);
 404         }
 405
 406         chans_left = CHANS_PER_ASIC * thisboard->dio_num_asics;
 407         n_dio_subdevs = CALC_N_DIO_SUBDEVS(chans_left);
 408         n_subdevs = n_dio_subdevs + 2;
 409         devpriv->sprivs =
 410             kcalloc(n_subdevs, sizeof(struct pcmmio_subdev_private),
 411                     GFP_KERNEL);
 412         if (!devpriv->sprivs) {
 413                 printk("cannot allocate subdevice private data structures\n");
 414                 return -ENOMEM;
 415         }
 416         /*
 417          * Allocate the subdevice structures.  alloc_subdevice() is a
 418          * convenient macro defined in comedidev.h.
 419          *
 420          * Allocate 1 AI + 1 AO + 2 DIO subdevs (24 lines per DIO)
 421          */
 422         if (alloc_subdevices(dev, n_subdevs) < 0) {
 423                 printk("cannot allocate subdevice data structures\n");
 424                 return -ENOMEM;
 425         }
 426
 427         /* First, AI */
 428         sdev_no = 0;
 429         s = dev->subdevices + sdev_no;
 430         s->private = devpriv->sprivs + sdev_no;
 431         s->maxdata = (1 << thisboard->ai_bits) - 1;
 432         s->range_table = thisboard->ai_range_table;
 433         s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_DIFF;
 434         s->type = COMEDI_SUBD_AI;
 435         s->n_chan = thisboard->n_ai_chans;
 436         s->len_chanlist = s->n_chan;
 437         s->insn_read = thisboard->ai_rinsn;
 438         subpriv->iobase = dev->iobase + 0;
 439         /* initialize the resource enable register by clearing it */
 440         outb(0, subpriv->iobase + 3);
 441         outb(0, subpriv->iobase + 4 + 3);
 442
 443         /* Next, AO */
 444         ++sdev_no;
 445         s = dev->subdevices + sdev_no;
 446         s->private = devpriv->sprivs + sdev_no;
 447         s->maxdata = (1 << thisboard->ao_bits) - 1;
 448         s->range_table = thisboard->ao_range_table;
 449         s->subdev_flags = SDF_READABLE;
 450         s->type = COMEDI_SUBD_AO;
 451         s->n_chan = thisboard->n_ao_chans;
 452         s->len_chanlist = s->n_chan;
 453         s->insn_read = thisboard->ao_rinsn;
 454         s->insn_write = thisboard->ao_winsn;
 455         subpriv->iobase = dev->iobase + 8;
 456         /* initialize the resource enable register by clearing it */
 457         outb(0, subpriv->iobase + 3);
 458         outb(0, subpriv->iobase + 4 + 3);
 459
 460         ++sdev_no;
 461         port = 0;
 462         asic = 0;
 463         for (; sdev_no < (int)dev->n_subdevices; ++sdev_no) {
 464                 int byte_no;
 465
 466                 s = dev->subdevices + sdev_no;
 467                 s->private = devpriv->sprivs + sdev_no;
 468                 s->maxdata = 1;
 469                 s->range_table = &range_digital;
 470                 s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
 471                 s->type = COMEDI_SUBD_DIO;
 472                 s->insn_bits = pcmmio_dio_insn_bits;
 473                 s->insn_config = pcmmio_dio_insn_config;
 474                 s->n_chan = min(chans_left, MAX_CHANS_PER_SUBDEV);
 475                 subpriv->dio.intr.asic = -1;
 476                 subpriv->dio.intr.first_chan = -1;
 477                 subpriv->dio.intr.asic_chan = -1;
 478                 subpriv->dio.intr.num_asic_chans = -1;
 479                 subpriv->dio.intr.active = 0;
 480                 s->len_chanlist = 1;
 481
 482                 /* save the ioport address for each 'port' of 8 channels in the
 483                    subdevice */
 484                 for (byte_no = 0; byte_no < PORTS_PER_SUBDEV; ++byte_no, ++port) {
 485                         if (port >= PORTS_PER_ASIC) {
 486                                 port = 0;
 487                                 ++asic;
 488                                 thisasic_chanct = 0;
 489                         }
 490                         subpriv->iobases[byte_no] =
 491                             devpriv->asics[asic].iobase + port;
 492
 493                         if (thisasic_chanct <
 494                             CHANS_PER_PORT * INTR_PORTS_PER_ASIC
 495                             && subpriv->dio.intr.asic < 0) {
 496                                 /*
 497                                  * this is an interrupt subdevice,
 498                                  * so setup the struct
 499                                  */
 500                                 subpriv->dio.intr.asic = asic;
 501                                 subpriv->dio.intr.active = 0;
 502                                 subpriv->dio.intr.stop_count = 0;
 503                                 subpriv->dio.intr.first_chan = byte_no * 8;
 504                                 subpriv->dio.intr.asic_chan = thisasic_chanct;
 505                                 subpriv->dio.intr.num_asic_chans =
 506                                     s->n_chan - subpriv->dio.intr.first_chan;
 507                                 s->cancel = pcmmio_cancel;
 508                                 s->do_cmd = pcmmio_cmd;
 509                                 s->do_cmdtest = pcmmio_cmdtest;
 510                                 s->len_chanlist =
 511                                     subpriv->dio.intr.num_asic_chans;
 512                         }
 513                         thisasic_chanct += CHANS_PER_PORT;
 514                 }
 515                 spin_lock_init(&subpriv->dio.intr.spinlock);
 516
 517                 chans_left -= s->n_chan;
 518
 519                 if (!chans_left) {
 520                         /*
 521                          * reset the asic to our first asic,
 522                          * to do intr subdevs
 523                          */
 524                         asic = 0;
 525                         port = 0;
 526                 }
 527
 528         }
 529
 530         init_asics(dev);        /* clear out all the registers, basically */
 531
 532         for (asic = 0; irq[0] && asic < MAX_ASICS; ++asic) {
 533                 if (irq[asic]
 534                     && request_irq(irq[asic], interrupt_pcmmio,
 535                                    IRQF_SHARED, thisboard->name, dev)) {
 536                         int i;
 537                         /* unroll the allocated irqs.. */
 538                         for (i = asic - 1; i >= 0; --i) {
 539                                 free_irq(irq[i], dev);
 540                                 devpriv->asics[i].irq = irq[i] = 0;
 541                         }
 542                         irq[asic] = 0;
 543                 }
 544                 devpriv->asics[asic].irq = irq[asic];
 545         }
 546
 547         dev->irq = irq[0];      /*
 548                                  * grr.. wish comedi dev struct supported
 549                                  * multiple irqs..
 550                                  */
 551
 552         if (irq[0]) {
 553                 printk("irq: %u ", irq[0]);
 554                 if (thisboard->dio_num_asics == 2 && irq[1])
 555                         printk("second ASIC irq: %u ", irq[1]);
 556         } else {
 557                 printk("(IRQ mode disabled) ");
 558         }
 559
 560         printk("attached\n");
 561
 562         return 1;
 563 }
 564
 565 /*
 566  * _detach is called to deconfigure a device.  It should deallocate
 567  * resources.
 568  * This function is also called when _attach() fails, so it should be
 569  * careful not to release resources that were not necessarily
 570  * allocated by _attach().  dev->private and dev->subdevices are
 571  * deallocated automatically by the core.
 572  */
 573 static int pcmmio_detach(struct comedi_device *dev)
 574 {
 575         int i;
 576
 577         printk("comedi%d: %s: remove\n", dev->minor, driver.driver_name);
 578         if (dev->iobase)
 579                 release_region(dev->iobase, thisboard->total_iosize);
 580
 581         for (i = 0; i < MAX_ASICS; ++i) {
 582                 if (devpriv && devpriv->asics[i].irq)
 583                         free_irq(devpriv->asics[i].irq, dev);
 584         }
 585
 586         if (devpriv && devpriv->sprivs)
 587                 kfree(devpriv->sprivs);
 588
 589         return 0;
 590 }
 591
 592 /* DIO devices are slightly special.  Although it is possible to
 593  * implement the insn_read/insn_write interface, it is much more
 594  * useful to applications if you implement the insn_bits interface.
 595  * This allows packed reading/writing of the DIO channels.  The
 596  * comedi core can convert between insn_bits and insn_read/write */
 597 static int pcmmio_dio_insn_bits(struct comedi_device *dev,
 598                                 struct comedi_subdevice *s,
 599                                 struct comedi_insn *insn, unsigned int *data)
 600 {
 601         int byte_no;
 602         if (insn->n != 2)
 603                 return -EINVAL;
 604
 605         /* NOTE:
 606            reading a 0 means this channel was high
 607            writine a 0 sets the channel high
 608            reading a 1 means this channel was low
 609            writing a 1 means set this channel low
 610
 611            Therefore everything is always inverted. */
 612
 613         /* The insn data is a mask in data[0] and the new data
 614          * in data[1], each channel cooresponding to a bit. */
 615
 616 #ifdef DAMMIT_ITS_BROKEN
 617         /* DEBUG */
 618         printk("write mask: %08x  data: %08x\n", data[0], data[1]);
 619 #endif
 620
 621         s->state = 0;
 622
 623         for (byte_no = 0; byte_no < s->n_chan / CHANS_PER_PORT; ++byte_no) {
 624                 /* address of 8-bit port */
 625                 unsigned long ioaddr = subpriv->iobases[byte_no],
 626                     /* bit offset of port in 32-bit doubleword */
 627                     offset = byte_no * 8;
 628                 /* this 8-bit port's data */
 629                 unsigned char byte = 0,
 630                     /* The write mask for this port (if any) */
 631                     write_mask_byte = (data[0] >> offset) & 0xff,
 632                     /* The data byte for this port */
 633                     data_byte = (data[1] >> offset) & 0xff;
 634
 635                 byte = inb(ioaddr);     /* read all 8-bits for this port */
 636
 637 #ifdef DAMMIT_ITS_BROKEN
 638                 /* DEBUG */
 639                 printk
 640                     ("byte %d wmb %02x db %02x offset %02d io %04x, data_in %02x ",
 641                      byte_no, (unsigned)write_mask_byte, (unsigned)data_byte,
 642                      offset, ioaddr, (unsigned)byte);
 643 #endif
 644
 645                 if (write_mask_byte) {
 646                         /*
 647                          * this byte has some write_bits
 648                          * -- so set the output lines
 649                          */
 650                         /* clear bits for write mask */
 651                         byte &= ~write_mask_byte;
 652                         /* set to inverted data_byte */
 653                         byte |= ~data_byte & write_mask_byte;
 654                         /* Write out the new digital output state */
 655                         outb(byte, ioaddr);
 656                 }
 657 #ifdef DAMMIT_ITS_BROKEN
 658                 /* DEBUG */
 659                 printk("data_out_byte %02x\n", (unsigned)byte);
 660 #endif
 661                 /* save the digital input lines for this byte.. */
 662                 s->state |= ((unsigned int)byte) << offset;
 663         }
 664
 665         /* now return the DIO lines to data[1] - note they came inverted! */
 666         data[1] = ~s->state;
 667
 668 #ifdef DAMMIT_ITS_BROKEN
 669         /* DEBUG */
 670         printk("s->state %08x data_out %08x\n", s->state, data[1]);
 671 #endif
 672
 673         return 2;
 674 }
 675
 676 /* The input or output configuration of each digital line is
 677  * configured by a special insn_config instruction.  chanspec
 678  * contains the channel to be changed, and data[0] contains the
 679  * value COMEDI_INPUT or COMEDI_OUTPUT. */
 680 static int pcmmio_dio_insn_config(struct comedi_device *dev,
 681                                   struct comedi_subdevice *s,
 682                                   struct comedi_insn *insn, unsigned int *data)
 683 {
 684         int chan = CR_CHAN(insn->chanspec), byte_no = chan / 8, bit_no =
 685             chan % 8;
 686         unsigned long ioaddr;
 687         unsigned char byte;
 688
 689         /* Compute ioaddr for this channel */
 690         ioaddr = subpriv->iobases[byte_no];
 691
 692         /* NOTE:
 693            writing a 0 an IO channel's bit sets the channel to INPUT
 694            and pulls the line high as well
 695
 696            writing a 1 to an IO channel's  bit pulls the line low
 697
 698            All channels are implicitly always in OUTPUT mode -- but when
 699            they are high they can be considered to be in INPUT mode..
 700
 701            Thus, we only force channels low if the config request was INPUT,
 702            otherwise we do nothing to the hardware.    */
 703
 704         switch (data[0]) {
 705         case INSN_CONFIG_DIO_OUTPUT:
 706                 /* save to io_bits -- don't actually do anything since
 707                    all input channels are also output channels... */
 708                 s->io_bits |= 1 << chan;
 709                 break;
 710         case INSN_CONFIG_DIO_INPUT:
 711                 /* write a 0 to the actual register representing the channel
 712                    to set it to 'input'.  0 means "float high". */
 713                 byte = inb(ioaddr);
 714                 byte &= ~(1 << bit_no);
 715                                 /**< set input channel to '0' */
 716
 717                 /*
 718                  * write out byte -- this is the only time we actually affect
 719                  * the hardware as all channels are implicitly output
 720                  * -- but input channels are set to float-high
 721                  */
 722                 outb(byte, ioaddr);
 723
 724                 /* save to io_bits */
 725                 s->io_bits &= ~(1 << chan);
 726                 break;
 727
 728         case INSN_CONFIG_DIO_QUERY:
 729                 /* retreive from shadow register */
 730                 data[1] =
 731                     (s->io_bits & (1 << chan)) ? COMEDI_OUTPUT : COMEDI_INPUT;
 732                 return insn->n;
 733                 break;
 734
 735         default:
 736                 return -EINVAL;
 737                 break;
 738         }
 739
 740         return insn->n;
 741 }
 742
 743 static void init_asics(struct comedi_device *dev)
 744 {                               /* sets up an
 745                                    ASIC chip to defaults */
 746         int asic;
 747
 748         for (asic = 0; asic < thisboard->dio_num_asics; ++asic) {
 749                 int port, page;
 750                 unsigned long baseaddr = devpriv->asics[asic].iobase;
 751
 752                 switch_page(dev, asic, 0);      /* switch back to page 0 */
 753
 754                 /* first, clear all the DIO port bits */
 755                 for (port = 0; port < PORTS_PER_ASIC; ++port)
 756                         outb(0, baseaddr + REG_PORT0 + port);
 757
 758                 /* Next, clear all the paged registers for each page */
 759                 for (page = 1; page < NUM_PAGES; ++page) {
 760                         int reg;
 761                         /* now clear all the paged registers */
 762                         switch_page(dev, asic, page);
 763                         for (reg = FIRST_PAGED_REG;
 764                              reg < FIRST_PAGED_REG + NUM_PAGED_REGS; ++reg)
 765                                 outb(0, baseaddr + reg);
 766                 }
 767
 768                 /* DEBUG  set rising edge interrupts on port0 of both asics */
 769                 /*switch_page(dev, asic, PAGE_POL);
 770                    outb(0xff, baseaddr + REG_POL0);
 771                    switch_page(dev, asic, PAGE_ENAB);
 772                    outb(0xff, baseaddr + REG_ENAB0); */
 773                 /* END DEBUG */
 774
 775                 /* switch back to default page 0 */
 776                 switch_page(dev, asic, 0);
 777         }
 778 }
 779
 780 static void switch_page(struct comedi_device *dev, int asic, int page)
 781 {
 782         if (asic < 0 || asic >= thisboard->dio_num_asics)
 783                 return;         /* paranoia */
 784         if (page < 0 || page >= NUM_PAGES)
 785                 return;         /* more paranoia */
 786
 787         devpriv->asics[asic].pagelock &= ~REG_PAGE_MASK;
 788         devpriv->asics[asic].pagelock |= page << REG_PAGE_BITOFFSET;
 789
 790         /* now write out the shadow register */
 791         outb(devpriv->asics[asic].pagelock,
 792              devpriv->asics[asic].iobase + REG_PAGELOCK);
 793 }
 794
 795 #ifdef notused
 796 static void lock_port(struct comedi_device *dev, int asic, int port)
 797 {
 798         if (asic < 0 || asic >= thisboard->dio_num_asics)
 799                 return;         /* paranoia */
 800         if (port < 0 || port >= PORTS_PER_ASIC)
 801                 return;         /* more paranoia */
 802
 803         devpriv->asics[asic].pagelock |= 0x1 << port;
 804         /* now write out the shadow register */
 805         outb(devpriv->asics[asic].pagelock,
 806              devpriv->asics[asic].iobase + REG_PAGELOCK);
 807         return;
 808 }
 809
 810 static void unlock_port(struct comedi_device *dev, int asic, int port)
 811 {
 812         if (asic < 0 || asic >= thisboard->dio_num_asics)
 813                 return;         /* paranoia */
 814         if (port < 0 || port >= PORTS_PER_ASIC)
 815                 return;         /* more paranoia */
 816         devpriv->asics[asic].pagelock &= ~(0x1 << port) | REG_LOCK_MASK;
 817         /* now write out the shadow register */
 818         outb(devpriv->asics[asic].pagelock,
 819              devpriv->asics[asic].iobase + REG_PAGELOCK);
 820 }
 821 #endif /* notused */
 822
 823 static irqreturn_t interrupt_pcmmio(int irq, void *d)
 824 {
 825         int asic, got1 = 0;
 826         struct comedi_device *dev = (struct comedi_device *)d;
 827
 828         for (asic = 0; asic < MAX_ASICS; ++asic) {
 829                 if (irq == devpriv->asics[asic].irq) {
 830                         unsigned long flags;
 831                         unsigned triggered = 0;
 832                         unsigned long iobase = devpriv->asics[asic].iobase;
 833                         /* it is an interrupt for ASIC #asic */
 834                         unsigned char int_pend;
 835
 836                         spin_lock_irqsave(&devpriv->asics[asic].spinlock,
 837                                           flags);
 838
 839                         int_pend = inb(iobase + REG_INT_PENDING) & 0x07;
 840
 841                         if (int_pend) {
 842                                 int port;
 843                                 for (port = 0; port < INTR_PORTS_PER_ASIC;
 844                                      ++port) {
 845                                         if (int_pend & (0x1 << port)) {
 846                                                 unsigned char
 847                                                     io_lines_with_edges = 0;
 848                                                 switch_page(dev, asic,
 849                                                             PAGE_INT_ID);
 850                                                 io_lines_with_edges =
 851                                                     inb(iobase +
 852                                                         REG_INT_ID0 + port);
 853
 854                                                 if (io_lines_with_edges)
 855                                                         /*
 856                                                          * clear pending
 857                                                          * interrupt
 858                                                          */
 859                                                         outb(0, iobase +
 860                                                              REG_INT_ID0 +
 861                                                              port);
 862
 863                                                 triggered |=
 864                                                     io_lines_with_edges <<
 865                                                     port * 8;
 866                                         }
 867                                 }
 868
 869                                 ++got1;
 870                         }
 871
 872                         spin_unlock_irqrestore(&devpriv->asics[asic].spinlock,
 873                                                flags);
 874
 875                         if (triggered) {
 876                                 struct comedi_subdevice *s;
 877                                 /*
 878                                  * TODO here: dispatch io lines to subdevs
 879                                  * with commands..
 880                                  */
 881                                 printk
 882                                     ("PCMMIO DEBUG: got edge detect interrupt %d asic %d which_chans: %06x\n",
 883                                      irq, asic, triggered);
 884                                 for (s = dev->subdevices + 2;
 885                                      s < dev->subdevices + dev->n_subdevices;
 886                                      ++s) {
 887                                         /*
 888                                          * this is an interrupt subdev,
 889                                          * and it matches this asic!
 890                                          */
 891                                         if (subpriv->dio.intr.asic == asic) {
 892                                                 unsigned long flags;
 893                                                 unsigned oldevents;
 894
 895                                                 spin_lock_irqsave(&subpriv->dio.
 896                                                                   intr.spinlock,
 897                                                                   flags);
 898
 899                                                 oldevents = s->async->events;
 900
 901                                                 if (subpriv->dio.intr.active) {
 902                                                         unsigned mytrig =
 903                                                             ((triggered >>
 904                                                               subpriv->dio.intr.asic_chan)
 905                                                              &
 906                                                              ((0x1 << subpriv->
 907                                                                dio.intr.
 908                                                                num_asic_chans) -
 909                                                               1)) << subpriv->
 910                                                             dio.intr.first_chan;
 911                                                         if (mytrig &
 912                                                             subpriv->dio.
 913                                                             intr.enabled_mask) {
 914                                                                 unsigned int val
 915                                                                     = 0;
 916                                                                 unsigned int n,
 917                                                                     ch, len;
 918
 919                                                                 len =
 920                                                                     s->
 921                                                                     async->cmd.chanlist_len;
 922                                                                 for (n = 0;
 923                                                                      n < len;
 924                                                                      n++) {
 925                                                                         ch = CR_CHAN(s->async->cmd.chanlist[n]);
 926                                                                         if (mytrig & (1U << ch))
 927                                                                                 val |= (1U << n);
 928                                                                 }
 929                                                                 /* Write the scan to the buffer. */
 930                                                                 if (comedi_buf_put(s->async, ((short *)&val)[0])
 931                                                                     &&
 932                                                                     comedi_buf_put
 933                                                                     (s->async,
 934                                                                      ((short *)
 935                                                                       &val)[1])) {
 936                                                                         s->async->events |= (COMEDI_CB_BLOCK | COMEDI_CB_EOS);
 937                                                                 } else {
 938                                                                         /* Overflow! Stop acquisition!! */
 939                                                                         /* TODO: STOP_ACQUISITION_CALL_HERE!! */
 940                                                                         pcmmio_stop_intr
 941                                                                             (dev,
 942                                                                              s);
 943                                                                 }
 944
 945                                                                 /* Check for end of acquisition. */
 946                                                                 if (!subpriv->dio.intr.continuous) {
 947                                                                         /* stop_src == TRIG_COUNT */
 948                                                                         if (subpriv->dio.intr.stop_count > 0) {
 949                                                                                 subpriv->dio.intr.stop_count--;
 950                                                                                 if (subpriv->dio.intr.stop_count == 0) {
 951                                                                                         s->async->events |= COMEDI_CB_EOA;
 952                                                                                         /* TODO: STOP_ACQUISITION_CALL_HERE!! */
 953                                                                                         pcmmio_stop_intr
 954                                                                                             (dev,
 955                                                                                              s);
 956                                                                                 }
 957                                                                         }
 958                                                                 }
 959                                                         }
 960                                                 }
 961
 962                                                 spin_unlock_irqrestore
 963                                                     (&subpriv->dio.intr.
 964                                                      spinlock, flags);
 965
 966                                                 if (oldevents !=
 967                                                     s->async->events) {
 968                                                         comedi_event(dev, s);
 969                                                 }
 970
 971                                         }
 972
 973                                 }
 974                         }
 975
 976                 }
 977         }
 978         if (!got1)
 979                 return IRQ_NONE;        /* interrupt from other source */
 980         return IRQ_HANDLED;
 981 }
 982
 983 static void pcmmio_stop_intr(struct comedi_device *dev,
 984                              struct comedi_subdevice *s)
 985 {
 986         int nports, firstport, asic, port;
 987
 988         asic = subpriv->dio.intr.asic;
 989         if (asic < 0)
 990                 return;         /* not an interrupt subdev */
 991
 992         subpriv->dio.intr.enabled_mask = 0;
 993         subpriv->dio.intr.active = 0;
 994         s->async->inttrig = 0;
 995         nports = subpriv->dio.intr.num_asic_chans / CHANS_PER_PORT;
 996         firstport = subpriv->dio.intr.asic_chan / CHANS_PER_PORT;
 997         switch_page(dev, asic, PAGE_ENAB);
 998         for (port = firstport; port < firstport + nports; ++port) {
 999                 /* disable all intrs for this subdev.. */
1000                 outb(0, devpriv->asics[asic].iobase + REG_ENAB0 + port);
1001         }
1002 }
1003
1004 static int pcmmio_start_intr(struct comedi_device *dev,
1005                              struct comedi_subdevice *s)
1006 {
1007         if (!subpriv->dio.intr.continuous && subpriv->dio.intr.stop_count == 0) {
1008                 /* An empty acquisition! */
1009                 s->async->events |= COMEDI_CB_EOA;
1010                 subpriv->dio.intr.active = 0;
1011                 return 1;
1012         } else {
1013                 unsigned bits = 0, pol_bits = 0, n;
1014                 int nports, firstport, asic, port;
1015                 struct comedi_cmd *cmd = &s->async->cmd;
1016
1017                 asic = subpriv->dio.intr.asic;
1018                 if (asic < 0)
1019                         return 1;       /* not an interrupt
1020                                            subdev */
1021                 subpriv->dio.intr.enabled_mask = 0;
1022                 subpriv->dio.intr.active = 1;
1023                 nports = subpriv->dio.intr.num_asic_chans / CHANS_PER_PORT;
1024                 firstport = subpriv->dio.intr.asic_chan / CHANS_PER_PORT;
1025                 if (cmd->chanlist) {
1026                         for (n = 0; n < cmd->chanlist_len; n++) {
1027                                 bits |= (1U << CR_CHAN(cmd->chanlist[n]));
1028                                 pol_bits |= (CR_AREF(cmd->chanlist[n])
1029                                              || CR_RANGE(cmd->
1030                                                          chanlist[n]) ? 1U : 0U)
1031                                     << CR_CHAN(cmd->chanlist[n]);
1032                         }
1033                 }
1034                 bits &= ((0x1 << subpriv->dio.intr.num_asic_chans) -
1035                          1) << subpriv->dio.intr.first_chan;
1036                 subpriv->dio.intr.enabled_mask = bits;
1037
1038                 {
1039                         /*
1040                          * the below code configures the board
1041                          * to use a specific IRQ from 0-15.
1042                          */
1043                         unsigned char b;
1044                         /*
1045                          * set resource enable register
1046                          * to enable IRQ operation
1047                          */
1048                         outb(1 << 4, dev->iobase + 3);
1049                         /* set bits 0-3 of b to the irq number from 0-15 */
1050                         b = dev->irq & ((1 << 4) - 1);
1051                         outb(b, dev->iobase + 2);
1052                         /* done, we told the board what irq to use */
1053                 }
1054
1055                 switch_page(dev, asic, PAGE_ENAB);
1056                 for (port = firstport; port < firstport + nports; ++port) {
1057                         unsigned enab =
1058                             bits >> (subpriv->dio.intr.first_chan + (port -
1059                                                                      firstport)
1060                                      * 8) & 0xff, pol =
1061                             pol_bits >> (subpriv->dio.intr.first_chan +
1062                                          (port - firstport) * 8) & 0xff;
1063                         /* set enab intrs for this subdev.. */
1064                         outb(enab,
1065                              devpriv->asics[asic].iobase + REG_ENAB0 + port);
1066                         switch_page(dev, asic, PAGE_POL);
1067                         outb(pol,
1068                              devpriv->asics[asic].iobase + REG_ENAB0 + port);
1069                 }
1070         }
1071         return 0;
1072 }
1073
1074 static int pcmmio_cancel(struct comedi_device *dev, struct comedi_subdevice *s)
1075 {
1076         unsigned long flags;
1077
1078         spin_lock_irqsave(&subpriv->dio.intr.spinlock, flags);
1079         if (subpriv->dio.intr.active)
1080                 pcmmio_stop_intr(dev, s);
1081         spin_unlock_irqrestore(&subpriv->dio.intr.spinlock, flags);
1082
1083         return 0;
1084 }
1085
1086 /*
1087  * Internal trigger function to start acquisition for an 'INTERRUPT' subdevice.
1088  */
1089 static int
1090 pcmmio_inttrig_start_intr(struct comedi_device *dev, struct comedi_subdevice *s,
1091                           unsigned int trignum)
1092 {
1093         unsigned long flags;
1094         int event = 0;
1095
1096         if (trignum != 0)
1097                 return -EINVAL;
1098
1099         spin_lock_irqsave(&subpriv->dio.intr.spinlock, flags);
1100         s->async->inttrig = 0;
1101         if (subpriv->dio.intr.active)
1102                 event = pcmmio_start_intr(dev, s);
1103         spin_unlock_irqrestore(&subpriv->dio.intr.spinlock, flags);
1104
1105         if (event)
1106                 comedi_event(dev, s);
1107
1108         return 1;
1109 }
1110
1111 /*
1112  * 'do_cmd' function for an 'INTERRUPT' subdevice.
1113  */
1114 static int pcmmio_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
1115 {
1116         struct comedi_cmd *cmd = &s->async->cmd;
1117         unsigned long flags;
1118         int event = 0;
1119
1120         spin_lock_irqsave(&subpriv->dio.intr.spinlock, flags);
1121         subpriv->dio.intr.active = 1;
1122
1123         /* Set up end of acquisition. */
1124         switch (cmd->stop_src) {
1125         case TRIG_COUNT:
1126                 subpriv->dio.intr.continuous = 0;
1127                 subpriv->dio.intr.stop_count = cmd->stop_arg;
1128                 break;
1129         default:
1130                 /* TRIG_NONE */
1131                 subpriv->dio.intr.continuous = 1;
1132                 subpriv->dio.intr.stop_count = 0;
1133                 break;
1134         }
1135
1136         /* Set up start of acquisition. */
1137         switch (cmd->start_src) {
1138         case TRIG_INT:
1139                 s->async->inttrig = pcmmio_inttrig_start_intr;
1140                 break;
1141         default:
1142                 /* TRIG_NOW */
1143                 event = pcmmio_start_intr(dev, s);
1144                 break;
1145         }
1146         spin_unlock_irqrestore(&subpriv->dio.intr.spinlock, flags);
1147
1148         if (event)
1149                 comedi_event(dev, s);
1150
1151         return 0;
1152 }
1153
1154 static int
1155 pcmmio_cmdtest(struct comedi_device *dev, struct comedi_subdevice *s,
1156                struct comedi_cmd *cmd)
1157 {
1158         return comedi_pcm_cmdtest(dev, s, cmd);
1159 }
1160
1161 static int adc_wait_ready(unsigned long iobase)
1162 {
1163         unsigned long retry = 100000;
1164         while (retry--)
1165                 if (inb(iobase + 3) & 0x80)
1166                         return 0;
1167         return 1;
1168 }
1169
1170 /* All this is for AI and AO */
1171 static int ai_rinsn(struct comedi_device *dev, struct comedi_subdevice *s,
1172                     struct comedi_insn *insn, unsigned int *data)
1173 {
1174         int n;
1175         unsigned long iobase = subpriv->iobase;
1176
1177         /*
1178            1. write the CMD byte (to BASE+2)
1179            2. read junk lo byte (BASE+0)
1180            3. read junk hi byte (BASE+1)
1181            4. (mux settled so) write CMD byte again (BASE+2)
1182            5. read valid lo byte(BASE+0)
1183            6. read valid hi byte(BASE+1)
1184
1185            Additionally note that the BASE += 4 if the channel >= 8
1186          */
1187
1188         /* convert n samples */
1189         for (n = 0; n < insn->n; n++) {
1190                 unsigned chan = CR_CHAN(insn->chanspec), range =
1191                     CR_RANGE(insn->chanspec), aref = CR_AREF(insn->chanspec);
1192                 unsigned char command_byte = 0;
1193                 unsigned iooffset = 0;
1194                 short sample, adc_adjust = 0;
1195
1196                 if (chan > 7)
1197                         chan -= 8, iooffset = 4;        /*
1198                                                          * use the second dword
1199                                                          * for channels > 7
1200                                                          */
1201
1202                 if (aref != AREF_DIFF) {
1203                         aref = AREF_GROUND;
1204                         command_byte |= 1 << 7; /*
1205                                                  * set bit 7 to indicate
1206                                                  * single-ended
1207                                                  */
1208                 }
1209                 if (range < 2)
1210                         adc_adjust = 0x8000;    /*
1211                                                  * bipolar ranges
1212                                                  * (-5,5 .. -10,10 need to be
1213                                                  * adjusted -- that is.. they
1214                                                  * need to wrap around by
1215                                                  * adding 0x8000
1216                                                  */
1217
1218                 if (chan % 2) {
1219                         command_byte |= 1 << 6; /*
1220                                                  * odd-numbered channels
1221                                                  * have bit 6 set
1222                                                  */
1223                 }
1224
1225                 /* select the channel, bits 4-5 == chan/2 */
1226                 command_byte |= ((chan / 2) & 0x3) << 4;
1227
1228                 /* set the range, bits 2-3 */
1229                 command_byte |= (range & 0x3) << 2;
1230
1231                 /* need to do this twice to make sure mux settled */
1232                 /* chan/range/aref select */
1233                 outb(command_byte, iobase + iooffset + 2);
1234
1235                 /* wait for the adc to say it finised the conversion */
1236                 adc_wait_ready(iobase + iooffset);
1237
1238                 /* select the chan/range/aref AGAIN */
1239                 outb(command_byte, iobase + iooffset + 2);
1240
1241                 adc_wait_ready(iobase + iooffset);
1242
1243                 /* read data lo byte */
1244                 sample = inb(iobase + iooffset + 0);
1245
1246                 /* read data hi byte */
1247                 sample |= inb(iobase + iooffset + 1) << 8;
1248                 sample += adc_adjust;   /* adjustment .. munge data */
1249                 data[n] = sample;
1250         }
1251         /* return the number of samples read/written */
1252         return n;
1253 }
1254
1255 static int ao_rinsn(struct comedi_device *dev, struct comedi_subdevice *s,
1256                     struct comedi_insn *insn, unsigned int *data)
1257 {
1258         int n;
1259         for (n = 0; n < insn->n; n++) {
1260                 unsigned chan = CR_CHAN(insn->chanspec);
1261                 if (chan < s->n_chan)
1262                         data[n] = subpriv->ao.shadow_samples[chan];
1263         }
1264         return n;
1265 }
1266
1267 static int wait_dac_ready(unsigned long iobase)
1268 {
1269         unsigned long retry = 100000L;
1270
1271         /* This may seem like an absurd way to handle waiting and violates the
1272            "no busy waiting" policy. The fact is that the hardware is
1273            normally so fast that we usually only need one time through the loop
1274            anyway. The longer timeout is for rare occasions and for detecting
1275            non-existant hardware.  */
1276
1277         while (retry--) {
1278                 if (inb(iobase + 3) & 0x80)
1279                         return 0;
1280
1281         }
1282         return 1;
1283 }
1284
1285 static int ao_winsn(struct comedi_device *dev, struct comedi_subdevice *s,
1286                     struct comedi_insn *insn, unsigned int *data)
1287 {
1288         int n;
1289         unsigned iobase = subpriv->iobase, iooffset = 0;
1290
1291         for (n = 0; n < insn->n; n++) {
1292                 unsigned chan = CR_CHAN(insn->chanspec), range =
1293                     CR_RANGE(insn->chanspec);
1294                 if (chan < s->n_chan) {
1295                         unsigned char command_byte = 0, range_byte =
1296                             range & ((1 << 4) - 1);
1297                         if (chan >= 4)
1298                                 chan -= 4, iooffset += 4;
1299                         /* set the range.. */
1300                         outb(range_byte, iobase + iooffset + 0);
1301                         outb(0, iobase + iooffset + 1);
1302
1303                         /* tell it to begin */
1304                         command_byte = (chan << 1) | 0x60;
1305                         outb(command_byte, iobase + iooffset + 2);
1306
1307                         wait_dac_ready(iobase + iooffset);
1308
1309                         /* low order byte */
1310                         outb(data[n] & 0xff, iobase + iooffset + 0);
1311
1312                         /* high order byte */
1313                         outb((data[n] >> 8) & 0xff, iobase + iooffset + 1);
1314
1315                         /*
1316                          * set bit 4 of command byte to indicate
1317                          * data is loaded and trigger conversion
1318                          */
1319                         command_byte = 0x70 | (chan << 1);
1320                         /* trigger converion */
1321                         outb(command_byte, iobase + iooffset + 2);
1322
1323                         wait_dac_ready(iobase + iooffset);
1324
1325                         /* save to shadow register for ao_rinsn */
1326                         subpriv->ao.shadow_samples[chan] = data[n];
1327                 }
1328         }
1329         return n;
1330 }
1331
1332 /*
1333  * A convenient macro that defines init_module() and cleanup_module(),
1334  * as necessary.
1335  */
1336 COMEDI_INITCLEANUP(driver);