2 comedi/drivers/cb_pcidda.c
3 This intends to be a driver for the ComputerBoards / MeasurementComputing
6 Copyright (C) 2001 Ivan Martinez <ivanmr@altavista.com>
7 Copyright (C) 2001 Frank Mori Hess <fmhess@users.sourceforge.net>
9 COMEDI - Linux Control and Measurement Device Interface
10 Copyright (C) 1997-8 David A. Schleef <ds@schleef.org>
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.
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.
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.
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
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
41 Only simple analog output writing is supported.
43 So far it has only been tested with:
45 Please report success/failure with other different cards to
49 #include "../comedidev.h"
51 #include "comedi_pci.h"
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
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]
67 /* Digital I/O registers */
68 #define PORT1A 0 // PORT 1A DATA
70 #define PORT1B 1 // PORT 1B DATA
72 #define PORT1C 2 // PORT 1C DATA
74 #define CONTROL1 3 // CONTROL REGISTER 1
76 #define PORT2A 4 // PORT 2A DATA
78 #define PORT2B 5 // PORT 2B DATA
80 #define PORT2C 6 // PORT 2C DATA
82 #define CONTROL2 7 // CONTROL REGISTER 2
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
96 #define DACALIBRATION1 4 // D/A CALIBRATION REGISTER 1
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)
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
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
113 #define DADATA 8 // FIRST D/A DATA REGISTER (0)
115 static const struct comedi_lrange cb_pcidda_ranges = {
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.
132 typedef struct cb_pcidda_board_struct {
134 char status; // Driver status:
136 // 1 - manual read, not tested
137 // 2 - manual not read
138 unsigned short device_id;
141 const struct comedi_lrange *ranges;
143 static const cb_pcidda_board cb_pcidda_boards[] = {
145 name: "pci-dda02/12",
150 ranges: &cb_pcidda_ranges,
153 name: "pci-dda04/12",
158 ranges: &cb_pcidda_ranges,
161 name: "pci-dda08/12",
166 ranges: &cb_pcidda_ranges,
169 name: "pci-dda02/16",
174 ranges: &cb_pcidda_ranges,
177 name: "pci-dda04/16",
182 ranges: &cb_pcidda_ranges,
185 name: "pci-dda08/16",
190 ranges: &cb_pcidda_ranges,
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},
204 MODULE_DEVICE_TABLE(pci, cb_pcidda_pci_table);
207 * Useful for shorthand access to the particular board structure
209 #define thisboard ((const cb_pcidda_board *)dev->board_ptr)
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. */
217 /* would be useful for a PCI device */
218 struct pci_dev *pci_dev;
220 unsigned long digitalio;
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
230 * most drivers define the following macro to make it easy to
231 * access the private structure.
233 #define devpriv ((cb_pcidda_private *)dev->private)
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,
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
257 static struct comedi_driver driver_cb_pcidda = {
258 driver_name:"cb_pcidda",
260 attach:cb_pcidda_attach,
261 detach:cb_pcidda_detach,
265 * Attach is called by the Comedi core to configure the driver
266 * for a particular board.
268 static int cb_pcidda_attach(struct comedi_device * dev, struct comedi_devconfig * it)
270 struct comedi_subdevice *s;
271 struct pci_dev *pcidev;
274 printk("comedi%d: cb_pcidda: ", dev->minor);
277 * Allocate the private structure area.
279 if (alloc_private(dev, sizeof(cb_pcidda_private)) < 0)
283 * Probe the device to determine what device in the series it is.
287 for (pcidev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, 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) !=
298 for (index = 0; index < N_BOARDS; index++) {
299 if (cb_pcidda_boards[index].device_id ==
307 printk("Not a ComputerBoards/MeasurementComputing card on requested position\n");
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);
317 * Enable PCI device and request regions.
319 if (comedi_pci_enable(pcidev, thisboard->name)) {
320 printk("cb_pcidda: failed to enable PCI device and request regions\n");
325 * Allocate the I/O ports.
328 pci_resource_start(devpriv->pci_dev, DIGITALIO_BADRINDEX);
329 devpriv->dac = pci_resource_start(devpriv->pci_dev, DAC_BADRINDEX);
332 * Warn about the status of the driver.
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");
338 * Initialize dev->board_name.
340 dev->board_name = thisboard->name;
343 * Allocate the subdevice structures.
345 if (alloc_subdevices(dev, 3) < 0)
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;
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);
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]);
373 // set calibrations dacs
374 for (index = 0; index < thisboard->ao_chans; index++)
375 cb_pcidda_calibrate(dev, index, devpriv->ao_range[index]);
381 * _detach is called to deconfigure a device. It should deallocate
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.
388 static int cb_pcidda_detach(struct comedi_device * dev)
391 * Deallocate the I/O ports.
394 if (devpriv->pci_dev) {
396 comedi_pci_disable(devpriv->pci_dev);
398 pci_dev_put(devpriv->pci_dev);
402 if (dev->subdevices) {
403 subdev_8255_cleanup(dev, dev->subdevices + 1);
404 subdev_8255_cleanup(dev, dev->subdevices + 2);
407 printk("comedi%d: cb_pcidda: remove\n", dev->minor);
413 * I will program this later... ;-)
416 static int cb_pcidda_ai_cmd(struct comedi_device * dev, struct comedi_subdevice * s)
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);
435 static int cb_pcidda_ai_cmdtest(struct comedi_device * dev, struct comedi_subdevice * s,
436 struct comedi_cmd * cmd)
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.
445 * cmdtest returns 1,2,3,4 or 0, depending on which tests
446 * the command passes. */
448 /* step 1: make sure trigger sources are trivially valid */
450 tmp = cmd->start_src;
451 cmd->start_src &= TRIG_NOW;
452 if (!cmd->start_src || tmp != cmd->start_src)
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)
460 tmp = cmd->convert_src;
461 cmd->convert_src &= TRIG_TIMER | TRIG_EXT;
462 if (!cmd->convert_src || tmp != cmd->convert_src)
465 tmp = cmd->scan_end_src;
466 cmd->scan_end_src &= TRIG_COUNT;
467 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
471 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
472 if (!cmd->stop_src || tmp != cmd->stop_src)
478 /* step 2: make sure trigger sources are unique and mutually compatible */
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)
484 if (cmd->convert_src != TRIG_TIMER && cmd->convert_src != TRIG_EXT)
486 if (cmd->stop_src != TRIG_TIMER && cmd->stop_src != TRIG_EXT)
492 /* step 3: make sure arguments are trivially compatible */
494 if (cmd->start_arg != 0) {
498 #define MAX_SPEED 10000 /* in nanoseconds */
499 #define MIN_SPEED 1000000000 /* in nanoseconds */
501 if (cmd->scan_begin_src == TRIG_TIMER) {
502 if (cmd->scan_begin_arg < MAX_SPEED) {
503 cmd->scan_begin_arg = MAX_SPEED;
506 if (cmd->scan_begin_arg > MIN_SPEED) {
507 cmd->scan_begin_arg = MIN_SPEED;
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;
519 if (cmd->convert_src == TRIG_TIMER) {
520 if (cmd->convert_arg < MAX_SPEED) {
521 cmd->convert_arg = MAX_SPEED;
524 if (cmd->convert_arg > MIN_SPEED) {
525 cmd->convert_arg = MIN_SPEED;
529 /* external trigger */
531 if (cmd->convert_arg > 9) {
532 cmd->convert_arg = 9;
537 if (cmd->scan_end_arg != cmd->chanlist_len) {
538 cmd->scan_end_arg = cmd->chanlist_len;
541 if (cmd->stop_src == TRIG_COUNT) {
542 if (cmd->stop_arg > 0x00ffffff) {
543 cmd->stop_arg = 0x00ffffff;
548 if (cmd->stop_arg != 0) {
557 /* step 4: fix up any arguments */
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)
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)
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;
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. */
594 static int cb_pcidda_ns_to_timer(unsigned int *ns, int round)
601 static int cb_pcidda_ao_winsn(struct comedi_device * dev, struct comedi_subdevice * s,
602 struct comedi_insn * insn, unsigned int * data)
604 unsigned int command;
605 unsigned int channel, range;
607 channel = CR_CHAN(insn->chanspec);
608 range = CR_RANGE(insn->chanspec);
610 // adjust calibration dacs if range has changed
611 if (range != devpriv->ao_range[channel])
612 cb_pcidda_calibrate(dev, channel, range);
614 /* output channel configuration */
615 command = NOSU | ENABLEDAC;
617 /* output channel range */
620 command |= BIP | RANGE10V;
623 command |= BIP | RANGE5V;
626 command |= BIP | RANGE2V5;
629 command |= UNIP | RANGE10V;
632 command |= UNIP | RANGE5V;
635 command |= UNIP | RANGE2V5;
639 /* output channel specification */
640 command |= channel << 2;
641 outw(command, devpriv->dac + DACONTROL);
644 outw(data[0], devpriv->dac + DADATA + channel * 2);
646 /* return the number of samples read/written */
650 // lowlevel read from eeprom
651 static unsigned int cb_pcidda_serial_in(struct comedi_device * dev)
653 unsigned int value = 0;
655 const int value_width = 16; // number of bits wide values are
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);
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)
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;
678 devpriv->dac_cal1_bits &= ~SERIAL_IN_BIT;
679 outw_p(devpriv->dac_cal1_bits, devpriv->dac + DACALIBRATION1);
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)
688 unsigned int cal2_bits;
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;
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);
701 outw_p(cal2_bits, devpriv->dac + DACALIBRATION2);
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);
708 value = cb_pcidda_serial_in(dev);
711 cal2_bits &= ~SELECT_EEPROM_BIT;
712 outw_p(cal2_bits, devpriv->dac + DACALIBRATION2);
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)
721 unsigned int cal2_bits;
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
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);
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);
739 // activate the caldac we want
740 cal2_bits &= ~DESELECT_CALDAC_BIT(caldac);
741 outw_p(cal2_bits, devpriv->dac + DACALIBRATION2);
743 cal2_bits |= DESELECT_CALDAC_BIT(caldac);
744 outw_p(cal2_bits, devpriv->dac + DACALIBRATION2);
747 // returns caldac that calibrates given analog out channel
748 static unsigned int caldac_number(unsigned int channel)
753 // returns caldac channel that provides fine gain for given ao channel
754 static unsigned int fine_gain_channel(unsigned int ao_channel)
756 return 4 * (ao_channel % 2);
759 // returns caldac channel that provides coarse gain for given ao channel
760 static unsigned int coarse_gain_channel(unsigned int ao_channel)
762 return 1 + 4 * (ao_channel % 2);
765 // returns caldac channel that provides coarse offset for given ao channel
766 static unsigned int coarse_offset_channel(unsigned int ao_channel)
768 return 2 + 4 * (ao_channel % 2);
771 // returns caldac channel that provides fine offset for given ao channel
772 static unsigned int fine_offset_channel(unsigned int ao_channel)
774 return 3 + 4 * (ao_channel % 2);
777 // returns eeprom address that provides offset for given ao channel and range
778 static unsigned int offset_eeprom_address(unsigned int ao_channel,
781 return 0x7 + 2 * range + 12 * ao_channel;
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,
788 return 0x8 + 2 * range + 12 * ao_channel;
791 // returns upper byte of eeprom entry, which gives the coarse adjustment values
792 static unsigned int eeprom_coarse_byte(unsigned int word)
794 return (word >> 8) & 0xff;
797 // returns lower byte of eeprom entry, which gives the fine adjustment values
798 static unsigned int eeprom_fine_byte(unsigned int word)
803 // set caldacs to eeprom values for given channel and range
804 static void cb_pcidda_calibrate(struct comedi_device * dev, unsigned int channel,
807 unsigned int coarse_offset, fine_offset, coarse_gain, fine_gain;
809 // remember range so we can tell when we need to readjust calibration
810 devpriv->ao_range[channel] = range;
812 // get values from eeprom data
814 eeprom_coarse_byte(devpriv->
815 eeprom_data[offset_eeprom_address(channel, range)]);
817 eeprom_fine_byte(devpriv->
818 eeprom_data[offset_eeprom_address(channel, range)]);
820 eeprom_coarse_byte(devpriv->
821 eeprom_data[gain_eeprom_address(channel, range)]);
823 eeprom_fine_byte(devpriv->
824 eeprom_data[gain_eeprom_address(channel, range)]);
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);
838 * A convenient macro that defines init_module() and cleanup_module(),
841 COMEDI_PCI_INITCLEANUP(driver_cb_pcidda, cb_pcidda_pci_table);