drivers/staging/comedi/drivers/cb_pcidda.c

   1 /*
   2     comedi/drivers/cb_pcidda.c
   3     This intends to be a driver for the ComputerBoards / MeasurementComputing
   4     PCI-DDA series.
   5
   6          Copyright (C) 2001 Ivan Martinez <ivanmr@altavista.com>
   7     Copyright (C) 2001 Frank Mori Hess <fmhess@users.sourceforge.net>
   8
   9     COMEDI - Linux Control and Measurement Device Interface
  10     Copyright (C) 1997-8 David A. Schleef <ds@schleef.org>
  11
  12     This program is free software; you can redistribute it and/or modify
  13     it under the terms of the GNU General Public License as published by
  14     the Free Software Foundation; either version 2 of the License, or
  15     (at your option) any later version.
  16
  17     This program is distributed in the hope that it will be useful,
  18     but WITHOUT ANY WARRANTY; without even the implied warranty of
  19     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20     GNU General Public License for more details.
  21
  22     You should have received a copy of the GNU General Public License
  23     along with this program; if not, write to the Free Software
  24     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  25
  26 */
  27 /*
  28 Driver: cb_pcidda
  29 Description: MeasurementComputing PCI-DDA series
  30 Author: Ivan Martinez <ivanmr@altavista.com>, Frank Mori Hess <fmhess@users.sourceforge.net>
  31 Status: Supports 08/16, 04/16, 02/16, 08/12, 04/12, and 02/12
  32 Devices: [Measurement Computing] PCI-DDA08/12 (cb_pcidda), PCI-DDA04/12,
  33   PCI-DDA02/12, PCI-DDA08/16, PCI-DDA04/16, PCI-DDA02/16
  34
  35 Configuration options:
  36   [0] - PCI bus of device (optional)
  37   [1] - PCI slot of device (optional)
  38   If bus/slot is not specified, the first available PCI
  39   device will be used.
  40
  41 Only simple analog output writing is supported.
  42
  43 So far it has only been tested with:
  44   - PCI-DDA08/12
  45 Please report success/failure with other different cards to
  46 <comedi@comedi.org>.
  47 */
  48
  49 #include "../comedidev.h"
  50
  51 #include "comedi_pci.h"
  52 #include "8255.h"
  53
  54 #define PCI_VENDOR_ID_CB        0x1307  /*  PCI vendor number of ComputerBoards */
  55 #define N_BOARDS        10      /*  Number of boards in cb_pcidda_boards */
  56 #define EEPROM_SIZE     128     /*  number of entries in eeprom */
  57 #define MAX_AO_CHANNELS 8       /*  maximum number of ao channels for supported boards */
  58
  59 /* PCI-DDA base addresses */
  60 #define DIGITALIO_BADRINDEX     2
  61         /*  DIGITAL I/O is pci_dev->resource[2] */
  62 #define DIGITALIO_SIZE 8
  63         /*  DIGITAL I/O uses 8 I/O port addresses */
  64 #define DAC_BADRINDEX   3
  65         /*  DAC is pci_dev->resource[3] */
  66
  67 /* Digital I/O registers */
  68 #define PORT1A 0                /*  PORT 1A DATA */
  69
  70 #define PORT1B 1                /*  PORT 1B DATA */
  71
  72 #define PORT1C 2                /*  PORT 1C DATA */
  73
  74 #define CONTROL1 3              /*  CONTROL REGISTER 1 */
  75
  76 #define PORT2A 4                /*  PORT 2A DATA */
  77
  78 #define PORT2B 5                /*  PORT 2B DATA */
  79
  80 #define PORT2C 6                /*  PORT 2C DATA */
  81
  82 #define CONTROL2 7              /*  CONTROL REGISTER 2 */
  83
  84 /* DAC registers */
  85 #define DACONTROL       0       /*  D/A CONTROL REGISTER */
  86 #define SU      0000001         /*  Simultaneous update enabled */
  87 #define NOSU    0000000         /*  Simultaneous update disabled */
  88 #define ENABLEDAC       0000002 /*  Enable specified DAC */
  89 #define DISABLEDAC      0000000 /*  Disable specified DAC */
  90 #define RANGE2V5        0000000 /*  2.5V */
  91 #define RANGE5V 0000200         /*  5V */
  92 #define RANGE10V        0000300 /*  10V */
  93 #define UNIP    0000400         /*  Unipolar outputs */
  94 #define BIP     0000000         /*  Bipolar outputs */
  95
  96 #define DACALIBRATION1  4       /*  D/A CALIBRATION REGISTER 1 */
  97 /* write bits */
  98 #define SERIAL_IN_BIT   0x1     /*  serial data input for eeprom, caldacs, reference dac */
  99 #define CAL_CHANNEL_MASK        (0x7 << 1)
 100 #define CAL_CHANNEL_BITS(channel)       (((channel) << 1) & CAL_CHANNEL_MASK)
 101 /* read bits */
 102 #define CAL_COUNTER_MASK        0x1f
 103 #define CAL_COUNTER_OVERFLOW_BIT        0x20    /*  calibration counter overflow status bit */
 104 #define AO_BELOW_REF_BIT        0x40    /*  analog output is less than reference dac voltage */
 105 #define SERIAL_OUT_BIT  0x80    /*  serial data out, for reading from eeprom */
 106
 107 #define DACALIBRATION2  6       /*  D/A CALIBRATION REGISTER 2 */
 108 #define SELECT_EEPROM_BIT       0x1     /*  send serial data in to eeprom */
 109 #define DESELECT_REF_DAC_BIT    0x2     /*  don't send serial data to MAX542 reference dac */
 110 #define DESELECT_CALDAC_BIT(n)  (0x4 << (n))    /*  don't send serial data to caldac n */
 111 #define DUMMY_BIT       0x40    /*  manual says to set this bit with no explanation */
 112
 113 #define DADATA  8               /*  FIRST D/A DATA REGISTER (0) */
 114
 115 static const struct comedi_lrange cb_pcidda_ranges = {
 116         6,
 117         {
 118                         BIP_RANGE(10),
 119                         BIP_RANGE(5),
 120                         BIP_RANGE(2.5),
 121                         UNI_RANGE(10),
 122                         UNI_RANGE(5),
 123                         UNI_RANGE(2.5),
 124                 }
 125 };
 126
 127 /*
 128  * Board descriptions for two imaginary boards.  Describing the
 129  * boards in this way is optional, and completely driver-dependent.
 130  * Some drivers use arrays such as this, other do not.
 131  */
 132 struct cb_pcidda_board {
 133         const char *name;
 134         char status;            /*  Driver status: */
 135
 136         /*
 137          * 0 - tested
 138          * 1 - manual read, not tested
 139          * 2 - manual not read
 140          */
 141
 142         unsigned short device_id;
 143         int ao_chans;
 144         int ao_bits;
 145         const struct comedi_lrange *ranges;
 146 };
 147
 148 static const struct cb_pcidda_board cb_pcidda_boards[] = {
 149         {
 150         .name = "pci-dda02/12",
 151         .status = 1,
 152         .device_id = 0x20,
 153         .ao_chans = 2,
 154         .ao_bits = 12,
 155         .ranges = &cb_pcidda_ranges,
 156                 },
 157         {
 158         .name = "pci-dda04/12",
 159         .status = 1,
 160         .device_id = 0x21,
 161         .ao_chans = 4,
 162         .ao_bits = 12,
 163         .ranges = &cb_pcidda_ranges,
 164                 },
 165         {
 166         .name = "pci-dda08/12",
 167         .status = 0,
 168         .device_id = 0x22,
 169         .ao_chans = 8,
 170         .ao_bits = 12,
 171         .ranges = &cb_pcidda_ranges,
 172                 },
 173         {
 174         .name = "pci-dda02/16",
 175         .status = 2,
 176         .device_id = 0x23,
 177         .ao_chans = 2,
 178         .ao_bits = 16,
 179         .ranges = &cb_pcidda_ranges,
 180                 },
 181         {
 182         .name = "pci-dda04/16",
 183         .status = 2,
 184         .device_id = 0x24,
 185         .ao_chans = 4,
 186         .ao_bits = 16,
 187         .ranges = &cb_pcidda_ranges,
 188                 },
 189         {
 190         .name = "pci-dda08/16",
 191         .status = 0,
 192         .device_id = 0x25,
 193         .ao_chans = 8,
 194         .ao_bits = 16,
 195         .ranges = &cb_pcidda_ranges,
 196                 },
 197 };
 198
 199 static DEFINE_PCI_DEVICE_TABLE(cb_pcidda_pci_table) = {
 200         {PCI_VENDOR_ID_CB, 0x0020, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 201         {PCI_VENDOR_ID_CB, 0x0021, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 202         {PCI_VENDOR_ID_CB, 0x0022, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 203         {PCI_VENDOR_ID_CB, 0x0023, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 204         {PCI_VENDOR_ID_CB, 0x0024, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 205         {PCI_VENDOR_ID_CB, 0x0025, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 206         {0}
 207 };
 208
 209 MODULE_DEVICE_TABLE(pci, cb_pcidda_pci_table);
 210
 211 /*
 212  * Useful for shorthand access to the particular board structure
 213  */
 214 #define thisboard ((const struct cb_pcidda_board *)dev->board_ptr)
 215
 216 /* this structure is for data unique to this hardware driver.  If
 217    several hardware drivers keep similar information in this structure,
 218    feel free to suggest moving the variable to the struct comedi_device struct.  */
 219 struct cb_pcidda_private {
 220         int data;
 221
 222         /* would be useful for a PCI device */
 223         struct pci_dev *pci_dev;
 224
 225         unsigned long digitalio;
 226         unsigned long dac;
 227
 228         /* unsigned long control_status; */
 229         /* unsigned long adc_fifo; */
 230
 231         unsigned int dac_cal1_bits;     /*  bits last written to da calibration register 1 */
 232         unsigned int ao_range[MAX_AO_CHANNELS]; /*  current range settings for output channels */
 233         u16 eeprom_data[EEPROM_SIZE];   /*  software copy of board's eeprom */
 234 };
 235
 236 /*
 237  * most drivers define the following macro to make it easy to
 238  * access the private structure.
 239  */
 240 #define devpriv ((struct cb_pcidda_private *)dev->private)
 241
 242 static int cb_pcidda_attach(struct comedi_device *dev, struct comedi_devconfig *it);
 243 static int cb_pcidda_detach(struct comedi_device *dev);
 244 /* static int cb_pcidda_ai_rinsn(struct comedi_device *dev,struct comedi_subdevice *s,struct comedi_insn *insn,unsigned int *data); */
 245 static int cb_pcidda_ao_winsn(struct comedi_device *dev, struct comedi_subdevice *s,
 246         struct comedi_insn *insn, unsigned int *data);
 247
 248 /* static int cb_pcidda_ai_cmd(struct comedi_device *dev, struct *comedi_subdevice *s);*/
 249 /* static int cb_pcidda_ai_cmdtest(struct comedi_device *dev, struct comedi_subdevice *s, struct comedi_cmd *cmd); */
 250 /* static int cb_pcidda_ns_to_timer(unsigned int *ns,int *round); */
 251
 252 static unsigned int cb_pcidda_serial_in(struct comedi_device *dev);
 253 static void cb_pcidda_serial_out(struct comedi_device *dev, unsigned int value,
 254         unsigned int num_bits);
 255 static unsigned int cb_pcidda_read_eeprom(struct comedi_device *dev,
 256         unsigned int address);
 257 static void cb_pcidda_calibrate(struct comedi_device *dev, unsigned int channel,
 258         unsigned int range);
 259
 260 /*
 261  * The struct comedi_driver structure tells the Comedi core module
 262  * which functions to call to configure/deconfigure (attach/detach)
 263  * the board, and also about the kernel module that contains
 264  * the device code.
 265  */
 266 static struct comedi_driver driver_cb_pcidda = {
 267         .driver_name = "cb_pcidda",
 268         .module = THIS_MODULE,
 269         .attach = cb_pcidda_attach,
 270         .detach = cb_pcidda_detach,
 271 };
 272
 273 /*
 274  * Attach is called by the Comedi core to configure the driver
 275  * for a particular board.
 276  */
 277 static int cb_pcidda_attach(struct comedi_device *dev, struct comedi_devconfig *it)
 278 {
 279         struct comedi_subdevice *s;
 280         struct pci_dev *pcidev;
 281         int index;
 282
 283         printk("comedi%d: cb_pcidda: ", dev->minor);
 284
 285 /*
 286  * Allocate the private structure area.
 287  */
 288         if (alloc_private(dev, sizeof(struct cb_pcidda_private)) < 0)
 289                 return -ENOMEM;
 290
 291 /*
 292  * Probe the device to determine what device in the series it is.
 293  */
 294         printk("\n");
 295
 296         for (pcidev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, NULL);
 297                 pcidev != NULL;
 298                 pcidev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, pcidev)) {
 299                 if (pcidev->vendor == PCI_VENDOR_ID_CB) {
 300                         if (it->options[0] || it->options[1]) {
 301                                 if (pcidev->bus->number != it->options[0] ||
 302                                         PCI_SLOT(pcidev->devfn) !=
 303                                         it->options[1]) {
 304                                         continue;
 305                                 }
 306                         }
 307                         for (index = 0; index < N_BOARDS; index++) {
 308                                 if (cb_pcidda_boards[index].device_id ==
 309                                         pcidev->device) {
 310                                         goto found;
 311                                 }
 312                         }
 313                 }
 314         }
 315         if (!pcidev) {
 316                 printk("Not a ComputerBoards/MeasurementComputing card on requested position\n");
 317                 return -EIO;
 318         }
 319       found:
 320         devpriv->pci_dev = pcidev;
 321         dev->board_ptr = cb_pcidda_boards + index;
 322         /*  "thisboard" macro can be used from here. */
 323         printk("Found %s at requested position\n", thisboard->name);
 324
 325         /*
 326          * Enable PCI device and request regions.
 327          */
 328         if (comedi_pci_enable(pcidev, thisboard->name)) {
 329                 printk("cb_pcidda: failed to enable PCI device and request regions\n");
 330                 return -EIO;
 331         }
 332
 333 /*
 334  * Allocate the I/O ports.
 335  */
 336         devpriv->digitalio =
 337                 pci_resource_start(devpriv->pci_dev, DIGITALIO_BADRINDEX);
 338         devpriv->dac = pci_resource_start(devpriv->pci_dev, DAC_BADRINDEX);
 339
 340 /*
 341  * Warn about the status of the driver.
 342  */
 343         if (thisboard->status == 2)
 344                 printk("WARNING: DRIVER FOR THIS BOARD NOT CHECKED WITH MANUAL. " "WORKS ASSUMING FULL COMPATIBILITY WITH PCI-DDA08/12. " "PLEASE REPORT USAGE TO <ivanmr@altavista.com>.\n");
 345
 346 /*
 347  * Initialize dev->board_name.
 348  */
 349         dev->board_name = thisboard->name;
 350
 351 /*
 352  * Allocate the subdevice structures.
 353  */
 354         if (alloc_subdevices(dev, 3) < 0)
 355                 return -ENOMEM;
 356
 357         s = dev->subdevices + 0;
 358         /* analog output subdevice */
 359         s->type = COMEDI_SUBD_AO;
 360         s->subdev_flags = SDF_WRITABLE;
 361         s->n_chan = thisboard->ao_chans;
 362         s->maxdata = (1 << thisboard->ao_bits) - 1;
 363         s->range_table = thisboard->ranges;
 364         s->insn_write = cb_pcidda_ao_winsn;
 365
 366         /* s->subdev_flags |= SDF_CMD_READ; */
 367         /* s->do_cmd = cb_pcidda_ai_cmd; */
 368         /* s->do_cmdtest = cb_pcidda_ai_cmdtest; */
 369
 370         /*  two 8255 digital io subdevices */
 371         s = dev->subdevices + 1;
 372         subdev_8255_init(dev, s, NULL, devpriv->digitalio);
 373         s = dev->subdevices + 2;
 374         subdev_8255_init(dev, s, NULL, devpriv->digitalio + PORT2A);
 375
 376         printk(" eeprom:");
 377         for (index = 0; index < EEPROM_SIZE; index++) {
 378                 devpriv->eeprom_data[index] = cb_pcidda_read_eeprom(dev, index);
 379                 printk(" %i:0x%x ", index, devpriv->eeprom_data[index]);
 380         }
 381         printk("\n");
 382
 383         /*  set calibrations dacs */
 384         for (index = 0; index < thisboard->ao_chans; index++)
 385                 cb_pcidda_calibrate(dev, index, devpriv->ao_range[index]);
 386
 387         return 1;
 388 }
 389
 390 /*
 391  * _detach is called to deconfigure a device.  It should deallocate
 392  * resources.
 393  * This function is also called when _attach() fails, so it should be
 394  * careful not to release resources that were not necessarily
 395  * allocated by _attach().  dev->private and dev->subdevices are
 396  * deallocated automatically by the core.
 397  */
 398 static int cb_pcidda_detach(struct comedi_device *dev)
 399 {
 400 /*
 401  * Deallocate the I/O ports.
 402  */
 403         if (devpriv) {
 404                 if (devpriv->pci_dev) {
 405                         if (devpriv->dac) {
 406                                 comedi_pci_disable(devpriv->pci_dev);
 407                         }
 408                         pci_dev_put(devpriv->pci_dev);
 409                 }
 410         }
 411         /*  cleanup 8255 */
 412         if (dev->subdevices) {
 413                 subdev_8255_cleanup(dev, dev->subdevices + 1);
 414                 subdev_8255_cleanup(dev, dev->subdevices + 2);
 415         }
 416
 417         printk("comedi%d: cb_pcidda: remove\n", dev->minor);
 418
 419         return 0;
 420 }
 421
 422 /*
 423  * I will program this later... ;-)
 424  */
 425 #if 0
 426 static int cb_pcidda_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
 427 {
 428         printk("cb_pcidda_ai_cmd\n");
 429         printk("subdev: %d\n", cmd->subdev);
 430         printk("flags: %d\n", cmd->flags);
 431         printk("start_src: %d\n", cmd->start_src);
 432         printk("start_arg: %d\n", cmd->start_arg);
 433         printk("scan_begin_src: %d\n", cmd->scan_begin_src);
 434         printk("convert_src: %d\n", cmd->convert_src);
 435         printk("convert_arg: %d\n", cmd->convert_arg);
 436         printk("scan_end_src: %d\n", cmd->scan_end_src);
 437         printk("scan_end_arg: %d\n", cmd->scan_end_arg);
 438         printk("stop_src: %d\n", cmd->stop_src);
 439         printk("stop_arg: %d\n", cmd->stop_arg);
 440         printk("chanlist_len: %d\n", cmd->chanlist_len);
 441 }
 442 #endif
 443
 444 #if 0
 445 static int cb_pcidda_ai_cmdtest(struct comedi_device *dev, struct comedi_subdevice *s,
 446         struct comedi_cmd *cmd)
 447 {
 448         int err = 0;
 449         int tmp;
 450
 451         /* cmdtest tests a particular command to see if it is valid.
 452          * Using the cmdtest ioctl, a user can create a valid cmd
 453          * and then have it executes by the cmd ioctl.
 454          *
 455          * cmdtest returns 1,2,3,4 or 0, depending on which tests
 456          * the command passes. */
 457
 458         /* step 1: make sure trigger sources are trivially valid */
 459
 460         tmp = cmd->start_src;
 461         cmd->start_src &= TRIG_NOW;
 462         if (!cmd->start_src || tmp != cmd->start_src)
 463                 err++;
 464
 465         tmp = cmd->scan_begin_src;
 466         cmd->scan_begin_src &= TRIG_TIMER | TRIG_EXT;
 467         if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
 468                 err++;
 469
 470         tmp = cmd->convert_src;
 471         cmd->convert_src &= TRIG_TIMER | TRIG_EXT;
 472         if (!cmd->convert_src || tmp != cmd->convert_src)
 473                 err++;
 474
 475         tmp = cmd->scan_end_src;
 476         cmd->scan_end_src &= TRIG_COUNT;
 477         if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
 478                 err++;
 479
 480         tmp = cmd->stop_src;
 481         cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
 482         if (!cmd->stop_src || tmp != cmd->stop_src)
 483                 err++;
 484
 485         if (err)
 486                 return 1;
 487
 488         /* step 2: make sure trigger sources are unique and mutually compatible */
 489
 490         /* note that mutual compatiblity is not an issue here */
 491         if (cmd->scan_begin_src != TRIG_TIMER
 492                 && cmd->scan_begin_src != TRIG_EXT)
 493                 err++;
 494         if (cmd->convert_src != TRIG_TIMER && cmd->convert_src != TRIG_EXT)
 495                 err++;
 496         if (cmd->stop_src != TRIG_TIMER && cmd->stop_src != TRIG_EXT)
 497                 err++;
 498
 499         if (err)
 500                 return 2;
 501
 502         /* step 3: make sure arguments are trivially compatible */
 503
 504         if (cmd->start_arg != 0) {
 505                 cmd->start_arg = 0;
 506                 err++;
 507         }
 508 #define MAX_SPEED       10000   /* in nanoseconds */
 509 #define MIN_SPEED       1000000000      /* in nanoseconds */
 510
 511         if (cmd->scan_begin_src == TRIG_TIMER) {
 512                 if (cmd->scan_begin_arg < MAX_SPEED) {
 513                         cmd->scan_begin_arg = MAX_SPEED;
 514                         err++;
 515                 }
 516                 if (cmd->scan_begin_arg > MIN_SPEED) {
 517                         cmd->scan_begin_arg = MIN_SPEED;
 518                         err++;
 519                 }
 520         } else {
 521                 /* external trigger */
 522                 /* should be level/edge, hi/lo specification here */
 523                 /* should specify multiple external triggers */
 524                 if (cmd->scan_begin_arg > 9) {
 525                         cmd->scan_begin_arg = 9;
 526                         err++;
 527                 }
 528         }
 529         if (cmd->convert_src == TRIG_TIMER) {
 530                 if (cmd->convert_arg < MAX_SPEED) {
 531                         cmd->convert_arg = MAX_SPEED;
 532                         err++;
 533                 }
 534                 if (cmd->convert_arg > MIN_SPEED) {
 535                         cmd->convert_arg = MIN_SPEED;
 536                         err++;
 537                 }
 538         } else {
 539                 /* external trigger */
 540                 /* see above */
 541                 if (cmd->convert_arg > 9) {
 542                         cmd->convert_arg = 9;
 543                         err++;
 544                 }
 545         }
 546
 547         if (cmd->scan_end_arg != cmd->chanlist_len) {
 548                 cmd->scan_end_arg = cmd->chanlist_len;
 549                 err++;
 550         }
 551         if (cmd->stop_src == TRIG_COUNT) {
 552                 if (cmd->stop_arg > 0x00ffffff) {
 553                         cmd->stop_arg = 0x00ffffff;
 554                         err++;
 555                 }
 556         } else {
 557                 /* TRIG_NONE */
 558                 if (cmd->stop_arg != 0) {
 559                         cmd->stop_arg = 0;
 560                         err++;
 561                 }
 562         }
 563
 564         if (err)
 565                 return 3;
 566
 567         /* step 4: fix up any arguments */
 568
 569         if (cmd->scan_begin_src == TRIG_TIMER) {
 570                 tmp = cmd->scan_begin_arg;
 571                 cb_pcidda_ns_to_timer(&cmd->scan_begin_arg,
 572                         cmd->flags & TRIG_ROUND_MASK);
 573                 if (tmp != cmd->scan_begin_arg)
 574                         err++;
 575         }
 576         if (cmd->convert_src == TRIG_TIMER) {
 577                 tmp = cmd->convert_arg;
 578                 cb_pcidda_ns_to_timer(&cmd->convert_arg,
 579                         cmd->flags & TRIG_ROUND_MASK);
 580                 if (tmp != cmd->convert_arg)
 581                         err++;
 582                 if (cmd->scan_begin_src == TRIG_TIMER &&
 583                         cmd->scan_begin_arg <
 584                         cmd->convert_arg * cmd->scan_end_arg) {
 585                         cmd->scan_begin_arg =
 586                                 cmd->convert_arg * cmd->scan_end_arg;
 587                         err++;
 588                 }
 589         }
 590
 591         if (err)
 592                 return 4;
 593
 594         return 0;
 595 }
 596 #endif
 597
 598 /* This function doesn't require a particular form, this is just
 599  * what happens to be used in some of the drivers.  It should
 600  * convert ns nanoseconds to a counter value suitable for programming
 601  * the device.  Also, it should adjust ns so that it cooresponds to
 602  * the actual time that the device will use. */
 603 #if 0
 604 static int cb_pcidda_ns_to_timer(unsigned int *ns, int round)
 605 {
 606         /* trivial timer */
 607         return *ns;
 608 }
 609 #endif
 610
 611 static int cb_pcidda_ao_winsn(struct comedi_device *dev, struct comedi_subdevice *s,
 612         struct comedi_insn *insn, unsigned int *data)
 613 {
 614         unsigned int command;
 615         unsigned int channel, range;
 616
 617         channel = CR_CHAN(insn->chanspec);
 618         range = CR_RANGE(insn->chanspec);
 619
 620         /*  adjust calibration dacs if range has changed */
 621         if (range != devpriv->ao_range[channel])
 622                 cb_pcidda_calibrate(dev, channel, range);
 623
 624         /* output channel configuration */
 625         command = NOSU | ENABLEDAC;
 626
 627         /* output channel range */
 628         switch (range) {
 629         case 0:
 630                 command |= BIP | RANGE10V;
 631                 break;
 632         case 1:
 633                 command |= BIP | RANGE5V;
 634                 break;
 635         case 2:
 636                 command |= BIP | RANGE2V5;
 637                 break;
 638         case 3:
 639                 command |= UNIP | RANGE10V;
 640                 break;
 641         case 4:
 642                 command |= UNIP | RANGE5V;
 643                 break;
 644         case 5:
 645                 command |= UNIP | RANGE2V5;
 646                 break;
 647         };
 648
 649         /* output channel specification */
 650         command |= channel << 2;
 651         outw(command, devpriv->dac + DACONTROL);
 652
 653         /* write data */
 654         outw(data[0], devpriv->dac + DADATA + channel * 2);
 655
 656         /* return the number of samples read/written */
 657         return 1;
 658 }
 659
 660 /* lowlevel read from eeprom */
 661 static unsigned int cb_pcidda_serial_in(struct comedi_device *dev)
 662 {
 663         unsigned int value = 0;
 664         int i;
 665         const int value_width = 16;     /*  number of bits wide values are */
 666
 667         for (i = 1; i <= value_width; i++) {
 668                 /*  read bits most significant bit first */
 669                 if (inw_p(devpriv->dac + DACALIBRATION1) & SERIAL_OUT_BIT) {
 670                         value |= 1 << (value_width - i);
 671                 }
 672         }
 673
 674         return value;
 675 }
 676
 677 /* lowlevel write to eeprom/dac */
 678 static void cb_pcidda_serial_out(struct comedi_device *dev, unsigned int value,
 679         unsigned int num_bits)
 680 {
 681         int i;
 682
 683         for (i = 1; i <= num_bits; i++) {
 684                 /*  send bits most significant bit first */
 685                 if (value & (1 << (num_bits - i)))
 686                         devpriv->dac_cal1_bits |= SERIAL_IN_BIT;
 687                 else
 688                         devpriv->dac_cal1_bits &= ~SERIAL_IN_BIT;
 689                 outw_p(devpriv->dac_cal1_bits, devpriv->dac + DACALIBRATION1);
 690         }
 691 }
 692
 693 /* reads a 16 bit value from board's eeprom */
 694 static unsigned int cb_pcidda_read_eeprom(struct comedi_device *dev,
 695         unsigned int address)
 696 {
 697         unsigned int i;
 698         unsigned int cal2_bits;
 699         unsigned int value;
 700         const int max_num_caldacs = 4;  /*  one caldac for every two dac channels */
 701         const int read_instruction = 0x6;       /*  bits to send to tell eeprom we want to read */
 702         const int instruction_length = 3;
 703         const int address_length = 8;
 704
 705         /*  send serial output stream to eeprom */
 706         cal2_bits = SELECT_EEPROM_BIT | DESELECT_REF_DAC_BIT | DUMMY_BIT;
 707         /*  deactivate caldacs (one caldac for every two channels) */
 708         for (i = 0; i < max_num_caldacs; i++) {
 709                 cal2_bits |= DESELECT_CALDAC_BIT(i);
 710         }
 711         outw_p(cal2_bits, devpriv->dac + DACALIBRATION2);
 712
 713         /*  tell eeprom we want to read */
 714         cb_pcidda_serial_out(dev, read_instruction, instruction_length);
 715         /*  send address we want to read from */
 716         cb_pcidda_serial_out(dev, address, address_length);
 717
 718         value = cb_pcidda_serial_in(dev);
 719
 720         /*  deactivate eeprom */
 721         cal2_bits &= ~SELECT_EEPROM_BIT;
 722         outw_p(cal2_bits, devpriv->dac + DACALIBRATION2);
 723
 724         return value;
 725 }
 726
 727 /* writes to 8 bit calibration dacs */
 728 static void cb_pcidda_write_caldac(struct comedi_device *dev, unsigned int caldac,
 729         unsigned int channel, unsigned int value)
 730 {
 731         unsigned int cal2_bits;
 732         unsigned int i;
 733         const int num_channel_bits = 3; /*  caldacs use 3 bit channel specification */
 734         const int num_caldac_bits = 8;  /*  8 bit calibration dacs */
 735         const int max_num_caldacs = 4;  /*  one caldac for every two dac channels */
 736
 737         /* write 3 bit channel */
 738         cb_pcidda_serial_out(dev, channel, num_channel_bits);
 739         /*  write 8 bit caldac value */
 740         cb_pcidda_serial_out(dev, value, num_caldac_bits);
 741
 742 /*
 743 * latch stream into appropriate caldac deselect reference dac
 744 */
 745         cal2_bits = DESELECT_REF_DAC_BIT | DUMMY_BIT;
 746         /*  deactivate caldacs (one caldac for every two channels) */
 747         for (i = 0; i < max_num_caldacs; i++) {
 748                 cal2_bits |= DESELECT_CALDAC_BIT(i);
 749         }
 750         /*  activate the caldac we want */
 751         cal2_bits &= ~DESELECT_CALDAC_BIT(caldac);
 752         outw_p(cal2_bits, devpriv->dac + DACALIBRATION2);
 753         /*  deactivate caldac */
 754         cal2_bits |= DESELECT_CALDAC_BIT(caldac);
 755         outw_p(cal2_bits, devpriv->dac + DACALIBRATION2);
 756 }
 757
 758 /* returns caldac that calibrates given analog out channel */
 759 static unsigned int caldac_number(unsigned int channel)
 760 {
 761         return channel / 2;
 762 }
 763
 764 /* returns caldac channel that provides fine gain for given ao channel */
 765 static unsigned int fine_gain_channel(unsigned int ao_channel)
 766 {
 767         return 4 * (ao_channel % 2);
 768 }
 769
 770 /* returns caldac channel that provides coarse gain for given ao channel */
 771 static unsigned int coarse_gain_channel(unsigned int ao_channel)
 772 {
 773         return 1 + 4 * (ao_channel % 2);
 774 }
 775
 776 /* returns caldac channel that provides coarse offset for given ao channel */
 777 static unsigned int coarse_offset_channel(unsigned int ao_channel)
 778 {
 779         return 2 + 4 * (ao_channel % 2);
 780 }
 781
 782 /* returns caldac channel that provides fine offset for given ao channel */
 783 static unsigned int fine_offset_channel(unsigned int ao_channel)
 784 {
 785         return 3 + 4 * (ao_channel % 2);
 786 }
 787
 788 /* returns eeprom address that provides offset for given ao channel and range */
 789 static unsigned int offset_eeprom_address(unsigned int ao_channel,
 790         unsigned int range)
 791 {
 792         return 0x7 + 2 * range + 12 * ao_channel;
 793 }
 794
 795 /* returns eeprom address that provides gain calibration for given ao channel and range */
 796 static unsigned int gain_eeprom_address(unsigned int ao_channel,
 797         unsigned int range)
 798 {
 799         return 0x8 + 2 * range + 12 * ao_channel;
 800 }
 801
 802 /* returns upper byte of eeprom entry, which gives the coarse adjustment values */
 803 static unsigned int eeprom_coarse_byte(unsigned int word)
 804 {
 805         return (word >> 8) & 0xff;
 806 }
 807
 808 /* returns lower byte of eeprom entry, which gives the fine adjustment values */
 809 static unsigned int eeprom_fine_byte(unsigned int word)
 810 {
 811         return word & 0xff;
 812 }
 813
 814 /* set caldacs to eeprom values for given channel and range */
 815 static void cb_pcidda_calibrate(struct comedi_device *dev, unsigned int channel,
 816         unsigned int range)
 817 {
 818         unsigned int coarse_offset, fine_offset, coarse_gain, fine_gain;
 819
 820         /*  remember range so we can tell when we need to readjust calibration */
 821         devpriv->ao_range[channel] = range;
 822
 823         /*  get values from eeprom data */
 824         coarse_offset =
 825                 eeprom_coarse_byte(devpriv->
 826                 eeprom_data[offset_eeprom_address(channel, range)]);
 827         fine_offset =
 828                 eeprom_fine_byte(devpriv->
 829                 eeprom_data[offset_eeprom_address(channel, range)]);
 830         coarse_gain =
 831                 eeprom_coarse_byte(devpriv->
 832                 eeprom_data[gain_eeprom_address(channel, range)]);
 833         fine_gain =
 834                 eeprom_fine_byte(devpriv->
 835                 eeprom_data[gain_eeprom_address(channel, range)]);
 836
 837         /*  set caldacs */
 838         cb_pcidda_write_caldac(dev, caldac_number(channel),
 839                 coarse_offset_channel(channel), coarse_offset);
 840         cb_pcidda_write_caldac(dev, caldac_number(channel),
 841                 fine_offset_channel(channel), fine_offset);
 842         cb_pcidda_write_caldac(dev, caldac_number(channel),
 843                 coarse_gain_channel(channel), coarse_gain);
 844         cb_pcidda_write_caldac(dev, caldac_number(channel),
 845                 fine_gain_channel(channel), fine_gain);
 846 }
 847
 848 /*
 849  * A convenient macro that defines init_module() and cleanup_module(),
 850  * as necessary.
 851  */
 852 COMEDI_PCI_INITCLEANUP(driver_cb_pcidda, cb_pcidda_pci_table);