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