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         // 0 - tested
 136         // 1 - manual read, not tested
 137         // 2 - manual not read
 138         unsigned short device_id;
 139         int ao_chans;
 140         int ao_bits;
 141         const struct comedi_lrange *ranges;
 142 };
 143 static const struct cb_pcidda_board cb_pcidda_boards[] = {
 144         {
 145               name:     "pci-dda02/12",
 146               status:   1,
 147               device_id:0x20,
 148               ao_chans:2,
 149               ao_bits:  12,
 150               ranges:   &cb_pcidda_ranges,
 151                 },
 152         {
 153               name:     "pci-dda04/12",
 154               status:   1,
 155               device_id:0x21,
 156               ao_chans:4,
 157               ao_bits:  12,
 158               ranges:   &cb_pcidda_ranges,
 159                 },
 160         {
 161               name:     "pci-dda08/12",
 162               status:   0,
 163               device_id:0x22,
 164               ao_chans:8,
 165               ao_bits:  12,
 166               ranges:   &cb_pcidda_ranges,
 167                 },
 168         {
 169               name:     "pci-dda02/16",
 170               status:   2,
 171               device_id:0x23,
 172               ao_chans:2,
 173               ao_bits:  16,
 174               ranges:   &cb_pcidda_ranges,
 175                 },
 176         {
 177               name:     "pci-dda04/16",
 178               status:   2,
 179               device_id:0x24,
 180               ao_chans:4,
 181               ao_bits:  16,
 182               ranges:   &cb_pcidda_ranges,
 183                 },
 184         {
 185               name:     "pci-dda08/16",
 186               status:   0,
 187               device_id:0x25,
 188               ao_chans:8,
 189               ao_bits:  16,
 190               ranges:   &cb_pcidda_ranges,
 191                 },
 192 };
 193
 194 static DEFINE_PCI_DEVICE_TABLE(cb_pcidda_pci_table) = {
 195         {PCI_VENDOR_ID_CB, 0x0020, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 196         {PCI_VENDOR_ID_CB, 0x0021, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 197         {PCI_VENDOR_ID_CB, 0x0022, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 198         {PCI_VENDOR_ID_CB, 0x0023, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 199         {PCI_VENDOR_ID_CB, 0x0024, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 200         {PCI_VENDOR_ID_CB, 0x0025, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 201         {0}
 202 };
 203
 204 MODULE_DEVICE_TABLE(pci, cb_pcidda_pci_table);
 205
 206 /*
 207  * Useful for shorthand access to the particular board structure
 208  */
 209 #define thisboard ((const struct cb_pcidda_board *)dev->board_ptr)
 210
 211 /* this structure is for data unique to this hardware driver.  If
 212    several hardware drivers keep similar information in this structure,
 213    feel free to suggest moving the variable to the struct comedi_device struct.  */
 214 struct cb_pcidda_private {
 215         int data;
 216
 217         /* would be useful for a PCI device */
 218         struct pci_dev *pci_dev;
 219
 220         unsigned long digitalio;
 221         unsigned long dac;
 222         //unsigned long control_status;
 223         //unsigned long adc_fifo;
 224         unsigned int dac_cal1_bits;     // bits last written to da calibration register 1
 225         unsigned int ao_range[MAX_AO_CHANNELS]; // current range settings for output channels
 226         u16 eeprom_data[EEPROM_SIZE];   // software copy of board's eeprom
 227 };
 228
 229 /*
 230  * most drivers define the following macro to make it easy to
 231  * access the private structure.
 232  */
 233 #define devpriv ((struct cb_pcidda_private *)dev->private)
 234
 235 static int cb_pcidda_attach(struct comedi_device * dev, struct comedi_devconfig * it);
 236 static int cb_pcidda_detach(struct comedi_device * dev);
 237 //static int cb_pcidda_ai_rinsn(struct comedi_device *dev,struct comedi_subdevice *s,struct comedi_insn *insn,unsigned int *data);
 238 static int cb_pcidda_ao_winsn(struct comedi_device * dev, struct comedi_subdevice * s,
 239         struct comedi_insn * insn, unsigned int * data);
 240 //static int cb_pcidda_ai_cmd(struct comedi_device *dev,struct comedi_subdevice *s);
 241 //static int cb_pcidda_ai_cmdtest(struct comedi_device *dev,struct comedi_subdevice *s, struct comedi_cmd *cmd);
 242 //static int cb_pcidda_ns_to_timer(unsigned int *ns,int round);
 243 static unsigned int cb_pcidda_serial_in(struct comedi_device * dev);
 244 static void cb_pcidda_serial_out(struct comedi_device * dev, unsigned int value,
 245         unsigned int num_bits);
 246 static unsigned int cb_pcidda_read_eeprom(struct comedi_device * dev,
 247         unsigned int address);
 248 static void cb_pcidda_calibrate(struct comedi_device * dev, unsigned int channel,
 249         unsigned int range);
 250
 251 /*
 252  * The struct comedi_driver structure tells the Comedi core module
 253  * which functions to call to configure/deconfigure (attach/detach)
 254  * the board, and also about the kernel module that contains
 255  * the device code.
 256  */
 257 static struct comedi_driver driver_cb_pcidda = {
 258       driver_name:"cb_pcidda",
 259       module:THIS_MODULE,
 260       attach:cb_pcidda_attach,
 261       detach:cb_pcidda_detach,
 262 };
 263
 264 /*
 265  * Attach is called by the Comedi core to configure the driver
 266  * for a particular board.
 267  */
 268 static int cb_pcidda_attach(struct comedi_device * dev, struct comedi_devconfig * it)
 269 {
 270         struct comedi_subdevice *s;
 271         struct pci_dev *pcidev;
 272         int index;
 273
 274         printk("comedi%d: cb_pcidda: ", dev->minor);
 275
 276 /*
 277  * Allocate the private structure area.
 278  */
 279         if (alloc_private(dev, sizeof(struct cb_pcidda_private)) < 0)
 280                 return -ENOMEM;
 281
 282 /*
 283  * Probe the device to determine what device in the series it is.
 284  */
 285         printk("\n");
 286
 287         for (pcidev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, NULL);
 288                 pcidev != NULL;
 289                 pcidev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, pcidev)) {
 290                 if (pcidev->vendor == PCI_VENDOR_ID_CB) {
 291                         if (it->options[0] || it->options[1]) {
 292                                 if (pcidev->bus->number != it->options[0] ||
 293                                         PCI_SLOT(pcidev->devfn) !=
 294                                         it->options[1]) {
 295                                         continue;
 296                                 }
 297                         }
 298                         for (index = 0; index < N_BOARDS; index++) {
 299                                 if (cb_pcidda_boards[index].device_id ==
 300                                         pcidev->device) {
 301                                         goto found;
 302                                 }
 303                         }
 304                 }
 305         }
 306         if (!pcidev) {
 307                 printk("Not a ComputerBoards/MeasurementComputing card on requested position\n");
 308                 return -EIO;
 309         }
 310       found:
 311         devpriv->pci_dev = pcidev;
 312         dev->board_ptr = cb_pcidda_boards + index;
 313         // "thisboard" macro can be used from here.
 314         printk("Found %s at requested position\n", thisboard->name);
 315
 316         /*
 317          * Enable PCI device and request regions.
 318          */
 319         if (comedi_pci_enable(pcidev, thisboard->name)) {
 320                 printk("cb_pcidda: failed to enable PCI device and request regions\n");
 321                 return -EIO;
 322         }
 323
 324 /*
 325  * Allocate the I/O ports.
 326  */
 327         devpriv->digitalio =
 328                 pci_resource_start(devpriv->pci_dev, DIGITALIO_BADRINDEX);
 329         devpriv->dac = pci_resource_start(devpriv->pci_dev, DAC_BADRINDEX);
 330
 331 /*
 332  * Warn about the status of the driver.
 333  */
 334         if (thisboard->status == 2)
 335                 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");
 336
 337 /*
 338  * Initialize dev->board_name.
 339  */
 340         dev->board_name = thisboard->name;
 341
 342 /*
 343  * Allocate the subdevice structures.
 344  */
 345         if (alloc_subdevices(dev, 3) < 0)
 346                 return -ENOMEM;
 347
 348         s = dev->subdevices + 0;
 349         /* analog output subdevice */
 350         s->type = COMEDI_SUBD_AO;
 351         s->subdev_flags = SDF_WRITABLE;
 352         s->n_chan = thisboard->ao_chans;
 353         s->maxdata = (1 << thisboard->ao_bits) - 1;
 354         s->range_table = thisboard->ranges;
 355         s->insn_write = cb_pcidda_ao_winsn;
 356 //      s->subdev_flags |= SDF_CMD_READ;
 357 //      s->do_cmd = cb_pcidda_ai_cmd;
 358 //      s->do_cmdtest = cb_pcidda_ai_cmdtest;
 359
 360         // two 8255 digital io subdevices
 361         s = dev->subdevices + 1;
 362         subdev_8255_init(dev, s, NULL, devpriv->digitalio);
 363         s = dev->subdevices + 2;
 364         subdev_8255_init(dev, s, NULL, devpriv->digitalio + PORT2A);
 365
 366         printk(" eeprom:");
 367         for (index = 0; index < EEPROM_SIZE; index++) {
 368                 devpriv->eeprom_data[index] = cb_pcidda_read_eeprom(dev, index);
 369                 printk(" %i:0x%x ", index, devpriv->eeprom_data[index]);
 370         }
 371         printk("\n");
 372
 373         // set calibrations dacs
 374         for (index = 0; index < thisboard->ao_chans; index++)
 375                 cb_pcidda_calibrate(dev, index, devpriv->ao_range[index]);
 376
 377         return 1;
 378 }
 379
 380 /*
 381  * _detach is called to deconfigure a device.  It should deallocate
 382  * resources.
 383  * This function is also called when _attach() fails, so it should be
 384  * careful not to release resources that were not necessarily
 385  * allocated by _attach().  dev->private and dev->subdevices are
 386  * deallocated automatically by the core.
 387  */
 388 static int cb_pcidda_detach(struct comedi_device * dev)
 389 {
 390 /*
 391  * Deallocate the I/O ports.
 392  */
 393         if (devpriv) {
 394                 if (devpriv->pci_dev) {
 395                         if (devpriv->dac) {
 396                                 comedi_pci_disable(devpriv->pci_dev);
 397                         }
 398                         pci_dev_put(devpriv->pci_dev);
 399                 }
 400         }
 401         // cleanup 8255
 402         if (dev->subdevices) {
 403                 subdev_8255_cleanup(dev, dev->subdevices + 1);
 404                 subdev_8255_cleanup(dev, dev->subdevices + 2);
 405         }
 406
 407         printk("comedi%d: cb_pcidda: remove\n", dev->minor);
 408
 409         return 0;
 410 }
 411
 412 /*
 413  * I will program this later... ;-)
 414  */
 415 #if 0
 416 static int cb_pcidda_ai_cmd(struct comedi_device * dev, struct comedi_subdevice * s)
 417 {
 418         printk("cb_pcidda_ai_cmd\n");
 419         printk("subdev: %d\n", cmd->subdev);
 420         printk("flags: %d\n", cmd->flags);
 421         printk("start_src: %d\n", cmd->start_src);
 422         printk("start_arg: %d\n", cmd->start_arg);
 423         printk("scan_begin_src: %d\n", cmd->scan_begin_src);
 424         printk("convert_src: %d\n", cmd->convert_src);
 425         printk("convert_arg: %d\n", cmd->convert_arg);
 426         printk("scan_end_src: %d\n", cmd->scan_end_src);
 427         printk("scan_end_arg: %d\n", cmd->scan_end_arg);
 428         printk("stop_src: %d\n", cmd->stop_src);
 429         printk("stop_arg: %d\n", cmd->stop_arg);
 430         printk("chanlist_len: %d\n", cmd->chanlist_len);
 431 }
 432 #endif
 433
 434 #if 0
 435 static int cb_pcidda_ai_cmdtest(struct comedi_device * dev, struct comedi_subdevice * s,
 436         struct comedi_cmd * cmd)
 437 {
 438         int err = 0;
 439         int tmp;
 440
 441         /* cmdtest tests a particular command to see if it is valid.
 442          * Using the cmdtest ioctl, a user can create a valid cmd
 443          * and then have it executes by the cmd ioctl.
 444          *
 445          * cmdtest returns 1,2,3,4 or 0, depending on which tests
 446          * the command passes. */
 447
 448         /* step 1: make sure trigger sources are trivially valid */
 449
 450         tmp = cmd->start_src;
 451         cmd->start_src &= TRIG_NOW;
 452         if (!cmd->start_src || tmp != cmd->start_src)
 453                 err++;
 454
 455         tmp = cmd->scan_begin_src;
 456         cmd->scan_begin_src &= TRIG_TIMER | TRIG_EXT;
 457         if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
 458                 err++;
 459
 460         tmp = cmd->convert_src;
 461         cmd->convert_src &= TRIG_TIMER | TRIG_EXT;
 462         if (!cmd->convert_src || tmp != cmd->convert_src)
 463                 err++;
 464
 465         tmp = cmd->scan_end_src;
 466         cmd->scan_end_src &= TRIG_COUNT;
 467         if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
 468                 err++;
 469
 470         tmp = cmd->stop_src;
 471         cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
 472         if (!cmd->stop_src || tmp != cmd->stop_src)
 473                 err++;
 474
 475         if (err)
 476                 return 1;
 477
 478         /* step 2: make sure trigger sources are unique and mutually compatible */
 479
 480         /* note that mutual compatiblity is not an issue here */
 481         if (cmd->scan_begin_src != TRIG_TIMER
 482                 && cmd->scan_begin_src != TRIG_EXT)
 483                 err++;
 484         if (cmd->convert_src != TRIG_TIMER && cmd->convert_src != TRIG_EXT)
 485                 err++;
 486         if (cmd->stop_src != TRIG_TIMER && cmd->stop_src != TRIG_EXT)
 487                 err++;
 488
 489         if (err)
 490                 return 2;
 491
 492         /* step 3: make sure arguments are trivially compatible */
 493
 494         if (cmd->start_arg != 0) {
 495                 cmd->start_arg = 0;
 496                 err++;
 497         }
 498 #define MAX_SPEED       10000   /* in nanoseconds */
 499 #define MIN_SPEED       1000000000      /* in nanoseconds */
 500
 501         if (cmd->scan_begin_src == TRIG_TIMER) {
 502                 if (cmd->scan_begin_arg < MAX_SPEED) {
 503                         cmd->scan_begin_arg = MAX_SPEED;
 504                         err++;
 505                 }
 506                 if (cmd->scan_begin_arg > MIN_SPEED) {
 507                         cmd->scan_begin_arg = MIN_SPEED;
 508                         err++;
 509                 }
 510         } else {
 511                 /* external trigger */
 512                 /* should be level/edge, hi/lo specification here */
 513                 /* should specify multiple external triggers */
 514                 if (cmd->scan_begin_arg > 9) {
 515                         cmd->scan_begin_arg = 9;
 516                         err++;
 517                 }
 518         }
 519         if (cmd->convert_src == TRIG_TIMER) {
 520                 if (cmd->convert_arg < MAX_SPEED) {
 521                         cmd->convert_arg = MAX_SPEED;
 522                         err++;
 523                 }
 524                 if (cmd->convert_arg > MIN_SPEED) {
 525                         cmd->convert_arg = MIN_SPEED;
 526                         err++;
 527                 }
 528         } else {
 529                 /* external trigger */
 530                 /* see above */
 531                 if (cmd->convert_arg > 9) {
 532                         cmd->convert_arg = 9;
 533                         err++;
 534                 }
 535         }
 536
 537         if (cmd->scan_end_arg != cmd->chanlist_len) {
 538                 cmd->scan_end_arg = cmd->chanlist_len;
 539                 err++;
 540         }
 541         if (cmd->stop_src == TRIG_COUNT) {
 542                 if (cmd->stop_arg > 0x00ffffff) {
 543                         cmd->stop_arg = 0x00ffffff;
 544                         err++;
 545                 }
 546         } else {
 547                 /* TRIG_NONE */
 548                 if (cmd->stop_arg != 0) {
 549                         cmd->stop_arg = 0;
 550                         err++;
 551                 }
 552         }
 553
 554         if (err)
 555                 return 3;
 556
 557         /* step 4: fix up any arguments */
 558
 559         if (cmd->scan_begin_src == TRIG_TIMER) {
 560                 tmp = cmd->scan_begin_arg;
 561                 cb_pcidda_ns_to_timer(&cmd->scan_begin_arg,
 562                         cmd->flags & TRIG_ROUND_MASK);
 563                 if (tmp != cmd->scan_begin_arg)
 564                         err++;
 565         }
 566         if (cmd->convert_src == TRIG_TIMER) {
 567                 tmp = cmd->convert_arg;
 568                 cb_pcidda_ns_to_timer(&cmd->convert_arg,
 569                         cmd->flags & TRIG_ROUND_MASK);
 570                 if (tmp != cmd->convert_arg)
 571                         err++;
 572                 if (cmd->scan_begin_src == TRIG_TIMER &&
 573                         cmd->scan_begin_arg <
 574                         cmd->convert_arg * cmd->scan_end_arg) {
 575                         cmd->scan_begin_arg =
 576                                 cmd->convert_arg * cmd->scan_end_arg;
 577                         err++;
 578                 }
 579         }
 580
 581         if (err)
 582                 return 4;
 583
 584         return 0;
 585 }
 586 #endif
 587
 588 /* This function doesn't require a particular form, this is just
 589  * what happens to be used in some of the drivers.  It should
 590  * convert ns nanoseconds to a counter value suitable for programming
 591  * the device.  Also, it should adjust ns so that it cooresponds to
 592  * the actual time that the device will use. */
 593 #if 0
 594 static int cb_pcidda_ns_to_timer(unsigned int *ns, int round)
 595 {
 596         /* trivial timer */
 597         return *ns;
 598 }
 599 #endif
 600
 601 static int cb_pcidda_ao_winsn(struct comedi_device * dev, struct comedi_subdevice * s,
 602         struct comedi_insn * insn, unsigned int * data)
 603 {
 604         unsigned int command;
 605         unsigned int channel, range;
 606
 607         channel = CR_CHAN(insn->chanspec);
 608         range = CR_RANGE(insn->chanspec);
 609
 610         // adjust calibration dacs if range has changed
 611         if (range != devpriv->ao_range[channel])
 612                 cb_pcidda_calibrate(dev, channel, range);
 613
 614         /* output channel configuration */
 615         command = NOSU | ENABLEDAC;
 616
 617         /* output channel range */
 618         switch (range) {
 619         case 0:
 620                 command |= BIP | RANGE10V;
 621                 break;
 622         case 1:
 623                 command |= BIP | RANGE5V;
 624                 break;
 625         case 2:
 626                 command |= BIP | RANGE2V5;
 627                 break;
 628         case 3:
 629                 command |= UNIP | RANGE10V;
 630                 break;
 631         case 4:
 632                 command |= UNIP | RANGE5V;
 633                 break;
 634         case 5:
 635                 command |= UNIP | RANGE2V5;
 636                 break;
 637         };
 638
 639         /* output channel specification */
 640         command |= channel << 2;
 641         outw(command, devpriv->dac + DACONTROL);
 642
 643         /* write data */
 644         outw(data[0], devpriv->dac + DADATA + channel * 2);
 645
 646         /* return the number of samples read/written */
 647         return 1;
 648 }
 649
 650 // lowlevel read from eeprom
 651 static unsigned int cb_pcidda_serial_in(struct comedi_device * dev)
 652 {
 653         unsigned int value = 0;
 654         int i;
 655         const int value_width = 16;     // number of bits wide values are
 656
 657         for (i = 1; i <= value_width; i++) {
 658                 // read bits most significant bit first
 659                 if (inw_p(devpriv->dac + DACALIBRATION1) & SERIAL_OUT_BIT) {
 660                         value |= 1 << (value_width - i);
 661                 }
 662         }
 663
 664         return value;
 665 }
 666
 667 // lowlevel write to eeprom/dac
 668 static void cb_pcidda_serial_out(struct comedi_device * dev, unsigned int value,
 669         unsigned int num_bits)
 670 {
 671         int i;
 672
 673         for (i = 1; i <= num_bits; i++) {
 674                 // send bits most significant bit first
 675                 if (value & (1 << (num_bits - i)))
 676                         devpriv->dac_cal1_bits |= SERIAL_IN_BIT;
 677                 else
 678                         devpriv->dac_cal1_bits &= ~SERIAL_IN_BIT;
 679                 outw_p(devpriv->dac_cal1_bits, devpriv->dac + DACALIBRATION1);
 680         }
 681 }
 682
 683 // reads a 16 bit value from board's eeprom
 684 static unsigned int cb_pcidda_read_eeprom(struct comedi_device * dev,
 685         unsigned int address)
 686 {
 687         unsigned int i;
 688         unsigned int cal2_bits;
 689         unsigned int value;
 690         const int max_num_caldacs = 4;  // one caldac for every two dac channels
 691         const int read_instruction = 0x6;       // bits to send to tell eeprom we want to read
 692         const int instruction_length = 3;
 693         const int address_length = 8;
 694
 695         // send serial output stream to eeprom
 696         cal2_bits = SELECT_EEPROM_BIT | DESELECT_REF_DAC_BIT | DUMMY_BIT;
 697         // deactivate caldacs (one caldac for every two channels)
 698         for (i = 0; i < max_num_caldacs; i++) {
 699                 cal2_bits |= DESELECT_CALDAC_BIT(i);
 700         }
 701         outw_p(cal2_bits, devpriv->dac + DACALIBRATION2);
 702
 703         // tell eeprom we want to read
 704         cb_pcidda_serial_out(dev, read_instruction, instruction_length);
 705         // send address we want to read from
 706         cb_pcidda_serial_out(dev, address, address_length);
 707
 708         value = cb_pcidda_serial_in(dev);
 709
 710         // deactivate eeprom
 711         cal2_bits &= ~SELECT_EEPROM_BIT;
 712         outw_p(cal2_bits, devpriv->dac + DACALIBRATION2);
 713
 714         return value;
 715 }
 716
 717 // writes to 8 bit calibration dacs
 718 static void cb_pcidda_write_caldac(struct comedi_device * dev, unsigned int caldac,
 719         unsigned int channel, unsigned int value)
 720 {
 721         unsigned int cal2_bits;
 722         unsigned int i;
 723         const int num_channel_bits = 3; // caldacs use 3 bit channel specification
 724         const int num_caldac_bits = 8;  // 8 bit calibration dacs
 725         const int max_num_caldacs = 4;  // one caldac for every two dac channels
 726
 727         /* write 3 bit channel */
 728         cb_pcidda_serial_out(dev, channel, num_channel_bits);
 729         // write 8 bit caldac value
 730         cb_pcidda_serial_out(dev, value, num_caldac_bits);
 731
 732         // latch stream into appropriate caldac
 733         // deselect reference dac
 734         cal2_bits = DESELECT_REF_DAC_BIT | DUMMY_BIT;
 735         // deactivate caldacs (one caldac for every two channels)
 736         for (i = 0; i < max_num_caldacs; i++) {
 737                 cal2_bits |= DESELECT_CALDAC_BIT(i);
 738         }
 739         // activate the caldac we want
 740         cal2_bits &= ~DESELECT_CALDAC_BIT(caldac);
 741         outw_p(cal2_bits, devpriv->dac + DACALIBRATION2);
 742         // deactivate caldac
 743         cal2_bits |= DESELECT_CALDAC_BIT(caldac);
 744         outw_p(cal2_bits, devpriv->dac + DACALIBRATION2);
 745 }
 746
 747 // returns caldac that calibrates given analog out channel
 748 static unsigned int caldac_number(unsigned int channel)
 749 {
 750         return channel / 2;
 751 }
 752
 753 // returns caldac channel that provides fine gain for given ao channel
 754 static unsigned int fine_gain_channel(unsigned int ao_channel)
 755 {
 756         return 4 * (ao_channel % 2);
 757 }
 758
 759 // returns caldac channel that provides coarse gain for given ao channel
 760 static unsigned int coarse_gain_channel(unsigned int ao_channel)
 761 {
 762         return 1 + 4 * (ao_channel % 2);
 763 }
 764
 765 // returns caldac channel that provides coarse offset for given ao channel
 766 static unsigned int coarse_offset_channel(unsigned int ao_channel)
 767 {
 768         return 2 + 4 * (ao_channel % 2);
 769 }
 770
 771 // returns caldac channel that provides fine offset for given ao channel
 772 static unsigned int fine_offset_channel(unsigned int ao_channel)
 773 {
 774         return 3 + 4 * (ao_channel % 2);
 775 }
 776
 777 // returns eeprom address that provides offset for given ao channel and range
 778 static unsigned int offset_eeprom_address(unsigned int ao_channel,
 779         unsigned int range)
 780 {
 781         return 0x7 + 2 * range + 12 * ao_channel;
 782 }
 783
 784 // returns eeprom address that provides gain calibration for given ao channel and range
 785 static unsigned int gain_eeprom_address(unsigned int ao_channel,
 786         unsigned int range)
 787 {
 788         return 0x8 + 2 * range + 12 * ao_channel;
 789 }
 790
 791 // returns upper byte of eeprom entry, which gives the coarse adjustment values
 792 static unsigned int eeprom_coarse_byte(unsigned int word)
 793 {
 794         return (word >> 8) & 0xff;
 795 }
 796
 797 // returns lower byte of eeprom entry, which gives the fine adjustment values
 798 static unsigned int eeprom_fine_byte(unsigned int word)
 799 {
 800         return word & 0xff;
 801 }
 802
 803 // set caldacs to eeprom values for given channel and range
 804 static void cb_pcidda_calibrate(struct comedi_device * dev, unsigned int channel,
 805         unsigned int range)
 806 {
 807         unsigned int coarse_offset, fine_offset, coarse_gain, fine_gain;
 808
 809         // remember range so we can tell when we need to readjust calibration
 810         devpriv->ao_range[channel] = range;
 811
 812         // get values from eeprom data
 813         coarse_offset =
 814                 eeprom_coarse_byte(devpriv->
 815                 eeprom_data[offset_eeprom_address(channel, range)]);
 816         fine_offset =
 817                 eeprom_fine_byte(devpriv->
 818                 eeprom_data[offset_eeprom_address(channel, range)]);
 819         coarse_gain =
 820                 eeprom_coarse_byte(devpriv->
 821                 eeprom_data[gain_eeprom_address(channel, range)]);
 822         fine_gain =
 823                 eeprom_fine_byte(devpriv->
 824                 eeprom_data[gain_eeprom_address(channel, range)]);
 825
 826         // set caldacs
 827         cb_pcidda_write_caldac(dev, caldac_number(channel),
 828                 coarse_offset_channel(channel), coarse_offset);
 829         cb_pcidda_write_caldac(dev, caldac_number(channel),
 830                 fine_offset_channel(channel), fine_offset);
 831         cb_pcidda_write_caldac(dev, caldac_number(channel),
 832                 coarse_gain_channel(channel), coarse_gain);
 833         cb_pcidda_write_caldac(dev, caldac_number(channel),
 834                 fine_gain_channel(channel), fine_gain);
 835 }
 836
 837 /*
 838  * A convenient macro that defines init_module() and cleanup_module(),
 839  * as necessary.
 840  */
 841 COMEDI_PCI_INITCLEANUP(driver_cb_pcidda, cb_pcidda_pci_table);