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 EEPROM_SIZE 128 /* number of entries in eeprom */
56 #define MAX_AO_CHANNELS 8 /* maximum number of ao channels for supported boards */
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] */
66 /* Digital I/O registers */
67 #define PORT1A 0 /* PORT 1A DATA */
69 #define PORT1B 1 /* PORT 1B DATA */
71 #define PORT1C 2 /* PORT 1C DATA */
73 #define CONTROL1 3 /* CONTROL REGISTER 1 */
75 #define PORT2A 4 /* PORT 2A DATA */
77 #define PORT2B 5 /* PORT 2B DATA */
79 #define PORT2C 6 /* PORT 2C DATA */
81 #define CONTROL2 7 /* CONTROL REGISTER 2 */
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 */
95 #define DACALIBRATION1 4 /* D/A CALIBRATION REGISTER 1 */
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)
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 */
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 */
112 #define DADATA 8 /* FIRST D/A DATA REGISTER (0) */
114 static const struct comedi_lrange cb_pcidda_ranges
= {
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.
131 struct cb_pcidda_board
{
133 char status
; /* Driver status: */
137 * 1 - manual read, not tested
138 * 2 - manual not read
141 unsigned short device_id
;
144 const struct comedi_lrange
*ranges
;
147 static const struct cb_pcidda_board cb_pcidda_boards
[] = {
149 .name
= "pci-dda02/12",
154 .ranges
= &cb_pcidda_ranges
,
157 .name
= "pci-dda04/12",
162 .ranges
= &cb_pcidda_ranges
,
165 .name
= "pci-dda08/12",
170 .ranges
= &cb_pcidda_ranges
,
173 .name
= "pci-dda02/16",
178 .ranges
= &cb_pcidda_ranges
,
181 .name
= "pci-dda04/16",
186 .ranges
= &cb_pcidda_ranges
,
189 .name
= "pci-dda08/16",
194 .ranges
= &cb_pcidda_ranges
,
198 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}, {
209 MODULE_DEVICE_TABLE(pci
, cb_pcidda_pci_table
);
212 * Useful for shorthand access to the particular board structure
214 #define thisboard ((const struct cb_pcidda_board *)dev->board_ptr)
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
{
222 /* would be useful for a PCI device */
223 struct pci_dev
*pci_dev
;
225 unsigned long digitalio
;
228 /* unsigned long control_status; */
229 /* unsigned long adc_fifo; */
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 */
237 * most drivers define the following macro to make it easy to
238 * access the private structure.
240 #define devpriv ((struct cb_pcidda_private *)dev->private)
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
);
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); */
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
,
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
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
,
276 * Attach is called by the Comedi core to configure the driver
277 * for a particular board.
279 static int cb_pcidda_attach(struct comedi_device
*dev
,
280 struct comedi_devconfig
*it
)
282 struct comedi_subdevice
*s
;
283 struct pci_dev
*pcidev
= NULL
;
286 printk("comedi%d: cb_pcidda: ", dev
->minor
);
289 * Allocate the private structure area.
291 if (alloc_private(dev
, sizeof(struct cb_pcidda_private
)) < 0)
295 * Probe the device to determine what device in the series it is.
299 for_each_pci_dev(pcidev
) {
300 if (pcidev
->vendor
== PCI_VENDOR_ID_CB
) {
301 if (it
->options
[0] || it
->options
[1]) {
302 if (pcidev
->bus
->number
!= it
->options
[0] ||
303 PCI_SLOT(pcidev
->devfn
) != it
->options
[1]) {
307 for (index
= 0; index
< ARRAY_SIZE(cb_pcidda_boards
); index
++) {
308 if (cb_pcidda_boards
[index
].device_id
==
317 ("Not a ComputerBoards/MeasurementComputing card on requested position\n");
321 devpriv
->pci_dev
= pcidev
;
322 dev
->board_ptr
= cb_pcidda_boards
+ index
;
323 /* "thisboard" macro can be used from here. */
324 printk("Found %s at requested position\n", thisboard
->name
);
327 * Enable PCI device and request regions.
329 if (comedi_pci_enable(pcidev
, thisboard
->name
)) {
331 ("cb_pcidda: failed to enable PCI device and request regions\n");
336 * Allocate the I/O ports.
339 pci_resource_start(devpriv
->pci_dev
, DIGITALIO_BADRINDEX
);
340 devpriv
->dac
= pci_resource_start(devpriv
->pci_dev
, DAC_BADRINDEX
);
343 * Warn about the status of the driver.
345 if (thisboard
->status
== 2)
347 ("WARNING: DRIVER FOR THIS BOARD NOT CHECKED WITH MANUAL. "
348 "WORKS ASSUMING FULL COMPATIBILITY WITH PCI-DDA08/12. "
349 "PLEASE REPORT USAGE TO <ivanmr@altavista.com>.\n");
352 * Initialize dev->board_name.
354 dev
->board_name
= thisboard
->name
;
357 * Allocate the subdevice structures.
359 if (alloc_subdevices(dev
, 3) < 0)
362 s
= dev
->subdevices
+ 0;
363 /* analog output subdevice */
364 s
->type
= COMEDI_SUBD_AO
;
365 s
->subdev_flags
= SDF_WRITABLE
;
366 s
->n_chan
= thisboard
->ao_chans
;
367 s
->maxdata
= (1 << thisboard
->ao_bits
) - 1;
368 s
->range_table
= thisboard
->ranges
;
369 s
->insn_write
= cb_pcidda_ao_winsn
;
371 /* s->subdev_flags |= SDF_CMD_READ; */
372 /* s->do_cmd = cb_pcidda_ai_cmd; */
373 /* s->do_cmdtest = cb_pcidda_ai_cmdtest; */
375 /* two 8255 digital io subdevices */
376 s
= dev
->subdevices
+ 1;
377 subdev_8255_init(dev
, s
, NULL
, devpriv
->digitalio
);
378 s
= dev
->subdevices
+ 2;
379 subdev_8255_init(dev
, s
, NULL
, devpriv
->digitalio
+ PORT2A
);
382 for (index
= 0; index
< EEPROM_SIZE
; index
++) {
383 devpriv
->eeprom_data
[index
] = cb_pcidda_read_eeprom(dev
, index
);
384 printk(" %i:0x%x ", index
, devpriv
->eeprom_data
[index
]);
388 /* set calibrations dacs */
389 for (index
= 0; index
< thisboard
->ao_chans
; index
++)
390 cb_pcidda_calibrate(dev
, index
, devpriv
->ao_range
[index
]);
396 * _detach is called to deconfigure a device. It should deallocate
398 * This function is also called when _attach() fails, so it should be
399 * careful not to release resources that were not necessarily
400 * allocated by _attach(). dev->private and dev->subdevices are
401 * deallocated automatically by the core.
403 static int cb_pcidda_detach(struct comedi_device
*dev
)
406 * Deallocate the I/O ports.
409 if (devpriv
->pci_dev
) {
411 comedi_pci_disable(devpriv
->pci_dev
);
412 pci_dev_put(devpriv
->pci_dev
);
416 if (dev
->subdevices
) {
417 subdev_8255_cleanup(dev
, dev
->subdevices
+ 1);
418 subdev_8255_cleanup(dev
, dev
->subdevices
+ 2);
421 printk("comedi%d: cb_pcidda: remove\n", dev
->minor
);
427 * I will program this later... ;-)
430 static int cb_pcidda_ai_cmd(struct comedi_device
*dev
,
431 struct comedi_subdevice
*s
)
433 printk("cb_pcidda_ai_cmd\n");
434 printk("subdev: %d\n", cmd
->subdev
);
435 printk("flags: %d\n", cmd
->flags
);
436 printk("start_src: %d\n", cmd
->start_src
);
437 printk("start_arg: %d\n", cmd
->start_arg
);
438 printk("scan_begin_src: %d\n", cmd
->scan_begin_src
);
439 printk("convert_src: %d\n", cmd
->convert_src
);
440 printk("convert_arg: %d\n", cmd
->convert_arg
);
441 printk("scan_end_src: %d\n", cmd
->scan_end_src
);
442 printk("scan_end_arg: %d\n", cmd
->scan_end_arg
);
443 printk("stop_src: %d\n", cmd
->stop_src
);
444 printk("stop_arg: %d\n", cmd
->stop_arg
);
445 printk("chanlist_len: %d\n", cmd
->chanlist_len
);
450 static int cb_pcidda_ai_cmdtest(struct comedi_device
*dev
,
451 struct comedi_subdevice
*s
,
452 struct comedi_cmd
*cmd
)
457 /* cmdtest tests a particular command to see if it is valid.
458 * Using the cmdtest ioctl, a user can create a valid cmd
459 * and then have it executes by the cmd ioctl.
461 * cmdtest returns 1,2,3,4 or 0, depending on which tests
462 * the command passes. */
464 /* step 1: make sure trigger sources are trivially valid */
466 tmp
= cmd
->start_src
;
467 cmd
->start_src
&= TRIG_NOW
;
468 if (!cmd
->start_src
|| tmp
!= cmd
->start_src
)
471 tmp
= cmd
->scan_begin_src
;
472 cmd
->scan_begin_src
&= TRIG_TIMER
| TRIG_EXT
;
473 if (!cmd
->scan_begin_src
|| tmp
!= cmd
->scan_begin_src
)
476 tmp
= cmd
->convert_src
;
477 cmd
->convert_src
&= TRIG_TIMER
| TRIG_EXT
;
478 if (!cmd
->convert_src
|| tmp
!= cmd
->convert_src
)
481 tmp
= cmd
->scan_end_src
;
482 cmd
->scan_end_src
&= TRIG_COUNT
;
483 if (!cmd
->scan_end_src
|| tmp
!= cmd
->scan_end_src
)
487 cmd
->stop_src
&= TRIG_COUNT
| TRIG_NONE
;
488 if (!cmd
->stop_src
|| tmp
!= cmd
->stop_src
)
494 /* step 2: make sure trigger sources are unique and mutually compatible */
496 /* note that mutual compatibility is not an issue here */
497 if (cmd
->scan_begin_src
!= TRIG_TIMER
498 && cmd
->scan_begin_src
!= TRIG_EXT
)
500 if (cmd
->convert_src
!= TRIG_TIMER
&& cmd
->convert_src
!= TRIG_EXT
)
502 if (cmd
->stop_src
!= TRIG_TIMER
&& cmd
->stop_src
!= TRIG_EXT
)
508 /* step 3: make sure arguments are trivially compatible */
510 if (cmd
->start_arg
!= 0) {
514 #define MAX_SPEED 10000 /* in nanoseconds */
515 #define MIN_SPEED 1000000000 /* in nanoseconds */
517 if (cmd
->scan_begin_src
== TRIG_TIMER
) {
518 if (cmd
->scan_begin_arg
< MAX_SPEED
) {
519 cmd
->scan_begin_arg
= MAX_SPEED
;
522 if (cmd
->scan_begin_arg
> MIN_SPEED
) {
523 cmd
->scan_begin_arg
= MIN_SPEED
;
527 /* external trigger */
528 /* should be level/edge, hi/lo specification here */
529 /* should specify multiple external triggers */
530 if (cmd
->scan_begin_arg
> 9) {
531 cmd
->scan_begin_arg
= 9;
535 if (cmd
->convert_src
== TRIG_TIMER
) {
536 if (cmd
->convert_arg
< MAX_SPEED
) {
537 cmd
->convert_arg
= MAX_SPEED
;
540 if (cmd
->convert_arg
> MIN_SPEED
) {
541 cmd
->convert_arg
= MIN_SPEED
;
545 /* external trigger */
547 if (cmd
->convert_arg
> 9) {
548 cmd
->convert_arg
= 9;
553 if (cmd
->scan_end_arg
!= cmd
->chanlist_len
) {
554 cmd
->scan_end_arg
= cmd
->chanlist_len
;
557 if (cmd
->stop_src
== TRIG_COUNT
) {
558 if (cmd
->stop_arg
> 0x00ffffff) {
559 cmd
->stop_arg
= 0x00ffffff;
564 if (cmd
->stop_arg
!= 0) {
573 /* step 4: fix up any arguments */
575 if (cmd
->scan_begin_src
== TRIG_TIMER
) {
576 tmp
= cmd
->scan_begin_arg
;
577 cb_pcidda_ns_to_timer(&cmd
->scan_begin_arg
,
578 cmd
->flags
& TRIG_ROUND_MASK
);
579 if (tmp
!= cmd
->scan_begin_arg
)
582 if (cmd
->convert_src
== TRIG_TIMER
) {
583 tmp
= cmd
->convert_arg
;
584 cb_pcidda_ns_to_timer(&cmd
->convert_arg
,
585 cmd
->flags
& TRIG_ROUND_MASK
);
586 if (tmp
!= cmd
->convert_arg
)
588 if (cmd
->scan_begin_src
== TRIG_TIMER
&&
589 cmd
->scan_begin_arg
<
590 cmd
->convert_arg
* cmd
->scan_end_arg
) {
591 cmd
->scan_begin_arg
=
592 cmd
->convert_arg
* cmd
->scan_end_arg
;
604 /* This function doesn't require a particular form, this is just
605 * what happens to be used in some of the drivers. It should
606 * convert ns nanoseconds to a counter value suitable for programming
607 * the device. Also, it should adjust ns so that it cooresponds to
608 * the actual time that the device will use. */
610 static int cb_pcidda_ns_to_timer(unsigned int *ns
, int round
)
617 static int cb_pcidda_ao_winsn(struct comedi_device
*dev
,
618 struct comedi_subdevice
*s
,
619 struct comedi_insn
*insn
, unsigned int *data
)
621 unsigned int command
;
622 unsigned int channel
, range
;
624 channel
= CR_CHAN(insn
->chanspec
);
625 range
= CR_RANGE(insn
->chanspec
);
627 /* adjust calibration dacs if range has changed */
628 if (range
!= devpriv
->ao_range
[channel
])
629 cb_pcidda_calibrate(dev
, channel
, range
);
631 /* output channel configuration */
632 command
= NOSU
| ENABLEDAC
;
634 /* output channel range */
637 command
|= BIP
| RANGE10V
;
640 command
|= BIP
| RANGE5V
;
643 command
|= BIP
| RANGE2V5
;
646 command
|= UNIP
| RANGE10V
;
649 command
|= UNIP
| RANGE5V
;
652 command
|= UNIP
| RANGE2V5
;
656 /* output channel specification */
657 command
|= channel
<< 2;
658 outw(command
, devpriv
->dac
+ DACONTROL
);
661 outw(data
[0], devpriv
->dac
+ DADATA
+ channel
* 2);
663 /* return the number of samples read/written */
667 /* lowlevel read from eeprom */
668 static unsigned int cb_pcidda_serial_in(struct comedi_device
*dev
)
670 unsigned int value
= 0;
672 const int value_width
= 16; /* number of bits wide values are */
674 for (i
= 1; i
<= value_width
; i
++) {
675 /* read bits most significant bit first */
676 if (inw_p(devpriv
->dac
+ DACALIBRATION1
) & SERIAL_OUT_BIT
)
677 value
|= 1 << (value_width
- i
);
683 /* lowlevel write to eeprom/dac */
684 static void cb_pcidda_serial_out(struct comedi_device
*dev
, unsigned int value
,
685 unsigned int num_bits
)
689 for (i
= 1; i
<= num_bits
; i
++) {
690 /* send bits most significant bit first */
691 if (value
& (1 << (num_bits
- i
)))
692 devpriv
->dac_cal1_bits
|= SERIAL_IN_BIT
;
694 devpriv
->dac_cal1_bits
&= ~SERIAL_IN_BIT
;
695 outw_p(devpriv
->dac_cal1_bits
, devpriv
->dac
+ DACALIBRATION1
);
699 /* reads a 16 bit value from board's eeprom */
700 static unsigned int cb_pcidda_read_eeprom(struct comedi_device
*dev
,
701 unsigned int address
)
704 unsigned int cal2_bits
;
706 const int max_num_caldacs
= 4; /* one caldac for every two dac channels */
707 const int read_instruction
= 0x6; /* bits to send to tell eeprom we want to read */
708 const int instruction_length
= 3;
709 const int address_length
= 8;
711 /* send serial output stream to eeprom */
712 cal2_bits
= SELECT_EEPROM_BIT
| DESELECT_REF_DAC_BIT
| DUMMY_BIT
;
713 /* deactivate caldacs (one caldac for every two channels) */
714 for (i
= 0; i
< max_num_caldacs
; i
++)
715 cal2_bits
|= DESELECT_CALDAC_BIT(i
);
716 outw_p(cal2_bits
, devpriv
->dac
+ DACALIBRATION2
);
718 /* tell eeprom we want to read */
719 cb_pcidda_serial_out(dev
, read_instruction
, instruction_length
);
720 /* send address we want to read from */
721 cb_pcidda_serial_out(dev
, address
, address_length
);
723 value
= cb_pcidda_serial_in(dev
);
725 /* deactivate eeprom */
726 cal2_bits
&= ~SELECT_EEPROM_BIT
;
727 outw_p(cal2_bits
, devpriv
->dac
+ DACALIBRATION2
);
732 /* writes to 8 bit calibration dacs */
733 static void cb_pcidda_write_caldac(struct comedi_device
*dev
,
734 unsigned int caldac
, unsigned int channel
,
737 unsigned int cal2_bits
;
739 const int num_channel_bits
= 3; /* caldacs use 3 bit channel specification */
740 const int num_caldac_bits
= 8; /* 8 bit calibration dacs */
741 const int max_num_caldacs
= 4; /* one caldac for every two dac channels */
743 /* write 3 bit channel */
744 cb_pcidda_serial_out(dev
, channel
, num_channel_bits
);
745 /* write 8 bit caldac value */
746 cb_pcidda_serial_out(dev
, value
, num_caldac_bits
);
749 * latch stream into appropriate caldac deselect reference dac
751 cal2_bits
= DESELECT_REF_DAC_BIT
| DUMMY_BIT
;
752 /* deactivate caldacs (one caldac for every two channels) */
753 for (i
= 0; i
< max_num_caldacs
; i
++)
754 cal2_bits
|= DESELECT_CALDAC_BIT(i
);
755 /* activate the caldac we want */
756 cal2_bits
&= ~DESELECT_CALDAC_BIT(caldac
);
757 outw_p(cal2_bits
, devpriv
->dac
+ DACALIBRATION2
);
758 /* deactivate caldac */
759 cal2_bits
|= DESELECT_CALDAC_BIT(caldac
);
760 outw_p(cal2_bits
, devpriv
->dac
+ DACALIBRATION2
);
763 /* returns caldac that calibrates given analog out channel */
764 static unsigned int caldac_number(unsigned int channel
)
769 /* returns caldac channel that provides fine gain for given ao channel */
770 static unsigned int fine_gain_channel(unsigned int ao_channel
)
772 return 4 * (ao_channel
% 2);
775 /* returns caldac channel that provides coarse gain for given ao channel */
776 static unsigned int coarse_gain_channel(unsigned int ao_channel
)
778 return 1 + 4 * (ao_channel
% 2);
781 /* returns caldac channel that provides coarse offset for given ao channel */
782 static unsigned int coarse_offset_channel(unsigned int ao_channel
)
784 return 2 + 4 * (ao_channel
% 2);
787 /* returns caldac channel that provides fine offset for given ao channel */
788 static unsigned int fine_offset_channel(unsigned int ao_channel
)
790 return 3 + 4 * (ao_channel
% 2);
793 /* returns eeprom address that provides offset for given ao channel and range */
794 static unsigned int offset_eeprom_address(unsigned int ao_channel
,
797 return 0x7 + 2 * range
+ 12 * ao_channel
;
800 /* returns eeprom address that provides gain calibration for given ao channel and range */
801 static unsigned int gain_eeprom_address(unsigned int ao_channel
,
804 return 0x8 + 2 * range
+ 12 * ao_channel
;
807 /* returns upper byte of eeprom entry, which gives the coarse adjustment values */
808 static unsigned int eeprom_coarse_byte(unsigned int word
)
810 return (word
>> 8) & 0xff;
813 /* returns lower byte of eeprom entry, which gives the fine adjustment values */
814 static unsigned int eeprom_fine_byte(unsigned int word
)
819 /* set caldacs to eeprom values for given channel and range */
820 static void cb_pcidda_calibrate(struct comedi_device
*dev
, unsigned int channel
,
823 unsigned int coarse_offset
, fine_offset
, coarse_gain
, fine_gain
;
825 /* remember range so we can tell when we need to readjust calibration */
826 devpriv
->ao_range
[channel
] = range
;
828 /* get values from eeprom data */
830 eeprom_coarse_byte(devpriv
->eeprom_data
831 [offset_eeprom_address(channel
, range
)]);
833 eeprom_fine_byte(devpriv
->eeprom_data
834 [offset_eeprom_address(channel
, range
)]);
836 eeprom_coarse_byte(devpriv
->eeprom_data
837 [gain_eeprom_address(channel
, range
)]);
839 eeprom_fine_byte(devpriv
->eeprom_data
840 [gain_eeprom_address(channel
, range
)]);
843 cb_pcidda_write_caldac(dev
, caldac_number(channel
),
844 coarse_offset_channel(channel
), coarse_offset
);
845 cb_pcidda_write_caldac(dev
, caldac_number(channel
),
846 fine_offset_channel(channel
), fine_offset
);
847 cb_pcidda_write_caldac(dev
, caldac_number(channel
),
848 coarse_gain_channel(channel
), coarse_gain
);
849 cb_pcidda_write_caldac(dev
, caldac_number(channel
),
850 fine_gain_channel(channel
), fine_gain
);
854 * A convenient macro that defines init_module() and cleanup_module(),
857 static int __devinit
driver_cb_pcidda_pci_probe(struct pci_dev
*dev
,
858 const struct pci_device_id
*ent
)
860 return comedi_pci_auto_config(dev
, driver_cb_pcidda
.driver_name
);
863 static void __devexit
driver_cb_pcidda_pci_remove(struct pci_dev
*dev
)
865 comedi_pci_auto_unconfig(dev
);
868 static struct pci_driver driver_cb_pcidda_pci_driver
= {
869 .id_table
= cb_pcidda_pci_table
,
870 .probe
= &driver_cb_pcidda_pci_probe
,
871 .remove
= __devexit_p(&driver_cb_pcidda_pci_remove
)
874 static int __init
driver_cb_pcidda_init_module(void)
878 retval
= comedi_driver_register(&driver_cb_pcidda
);
882 driver_cb_pcidda_pci_driver
.name
= (char *)driver_cb_pcidda
.driver_name
;
883 return pci_register_driver(&driver_cb_pcidda_pci_driver
);
886 static void __exit
driver_cb_pcidda_cleanup_module(void)
888 pci_unregister_driver(&driver_cb_pcidda_pci_driver
);
889 comedi_driver_unregister(&driver_cb_pcidda
);
892 module_init(driver_cb_pcidda_init_module
);
893 module_exit(driver_cb_pcidda_cleanup_module
);
895 MODULE_AUTHOR("Comedi http://www.comedi.org");
896 MODULE_DESCRIPTION("Comedi low-level driver");
897 MODULE_LICENSE("GPL");