| /* |
| comedi/drivers/cb_pcidda.c |
| This intends to be a driver for the ComputerBoards / MeasurementComputing |
| PCI-DDA series. |
| |
| Copyright (C) 2001 Ivan Martinez <ivanmr@altavista.com> |
| Copyright (C) 2001 Frank Mori Hess <fmhess@users.sourceforge.net> |
| |
| COMEDI - Linux Control and Measurement Device Interface |
| Copyright (C) 1997-8 David A. Schleef <ds@schleef.org> |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2 of the License, or |
| (at your option) any later version. |
| |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with this program; if not, write to the Free Software |
| Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
| |
| */ |
| /* |
| Driver: cb_pcidda |
| Description: MeasurementComputing PCI-DDA series |
| Author: Ivan Martinez <ivanmr@altavista.com>, Frank Mori Hess <fmhess@users.sourceforge.net> |
| Status: Supports 08/16, 04/16, 02/16, 08/12, 04/12, and 02/12 |
| Devices: [Measurement Computing] PCI-DDA08/12 (cb_pcidda), PCI-DDA04/12, |
| PCI-DDA02/12, PCI-DDA08/16, PCI-DDA04/16, PCI-DDA02/16 |
| |
| Configuration options: |
| [0] - PCI bus of device (optional) |
| [1] - PCI slot of device (optional) |
| If bus/slot is not specified, the first available PCI |
| device will be used. |
| |
| Only simple analog output writing is supported. |
| |
| So far it has only been tested with: |
| - PCI-DDA08/12 |
| Please report success/failure with other different cards to |
| <comedi@comedi.org>. |
| */ |
| |
| #include "../comedidev.h" |
| |
| #include "comedi_pci.h" |
| #include "8255.h" |
| |
| #define PCI_VENDOR_ID_CB 0x1307 // PCI vendor number of ComputerBoards |
| #define N_BOARDS 10 // Number of boards in cb_pcidda_boards |
| #define EEPROM_SIZE 128 // number of entries in eeprom |
| #define MAX_AO_CHANNELS 8 // maximum number of ao channels for supported boards |
| |
| /* PCI-DDA base addresses */ |
| #define DIGITALIO_BADRINDEX 2 |
| // DIGITAL I/O is pci_dev->resource[2] |
| #define DIGITALIO_SIZE 8 |
| // DIGITAL I/O uses 8 I/O port addresses |
| #define DAC_BADRINDEX 3 |
| // DAC is pci_dev->resource[3] |
| |
| /* Digital I/O registers */ |
| #define PORT1A 0 // PORT 1A DATA |
| |
| #define PORT1B 1 // PORT 1B DATA |
| |
| #define PORT1C 2 // PORT 1C DATA |
| |
| #define CONTROL1 3 // CONTROL REGISTER 1 |
| |
| #define PORT2A 4 // PORT 2A DATA |
| |
| #define PORT2B 5 // PORT 2B DATA |
| |
| #define PORT2C 6 // PORT 2C DATA |
| |
| #define CONTROL2 7 // CONTROL REGISTER 2 |
| |
| /* DAC registers */ |
| #define DACONTROL 0 // D/A CONTROL REGISTER |
| #define SU 0000001 // Simultaneous update enabled |
| #define NOSU 0000000 // Simultaneous update disabled |
| #define ENABLEDAC 0000002 // Enable specified DAC |
| #define DISABLEDAC 0000000 // Disable specified DAC |
| #define RANGE2V5 0000000 // 2.5V |
| #define RANGE5V 0000200 // 5V |
| #define RANGE10V 0000300 // 10V |
| #define UNIP 0000400 // Unipolar outputs |
| #define BIP 0000000 // Bipolar outputs |
| |
| #define DACALIBRATION1 4 // D/A CALIBRATION REGISTER 1 |
| //write bits |
| #define SERIAL_IN_BIT 0x1 // serial data input for eeprom, caldacs, reference dac |
| #define CAL_CHANNEL_MASK (0x7 << 1) |
| #define CAL_CHANNEL_BITS(channel) (((channel) << 1) & CAL_CHANNEL_MASK) |
| //read bits |
| #define CAL_COUNTER_MASK 0x1f |
| #define CAL_COUNTER_OVERFLOW_BIT 0x20 // calibration counter overflow status bit |
| #define AO_BELOW_REF_BIT 0x40 // analog output is less than reference dac voltage |
| #define SERIAL_OUT_BIT 0x80 // serial data out, for reading from eeprom |
| |
| #define DACALIBRATION2 6 // D/A CALIBRATION REGISTER 2 |
| #define SELECT_EEPROM_BIT 0x1 // send serial data in to eeprom |
| #define DESELECT_REF_DAC_BIT 0x2 // don't send serial data to MAX542 reference dac |
| #define DESELECT_CALDAC_BIT(n) (0x4 << (n)) // don't send serial data to caldac n |
| #define DUMMY_BIT 0x40 // manual says to set this bit with no explanation |
| |
| #define DADATA 8 // FIRST D/A DATA REGISTER (0) |
| |
| static const struct comedi_lrange cb_pcidda_ranges = { |
| 6, |
| { |
| BIP_RANGE(10), |
| BIP_RANGE(5), |
| BIP_RANGE(2.5), |
| UNI_RANGE(10), |
| UNI_RANGE(5), |
| UNI_RANGE(2.5), |
| } |
| }; |
| |
| /* |
| * Board descriptions for two imaginary boards. Describing the |
| * boards in this way is optional, and completely driver-dependent. |
| * Some drivers use arrays such as this, other do not. |
| */ |
| struct cb_pcidda_board { |
| const char *name; |
| char status; // Driver status: |
| // 0 - tested |
| // 1 - manual read, not tested |
| // 2 - manual not read |
| unsigned short device_id; |
| int ao_chans; |
| int ao_bits; |
| const struct comedi_lrange *ranges; |
| }; |
| static const struct cb_pcidda_board cb_pcidda_boards[] = { |
| { |
| name: "pci-dda02/12", |
| status: 1, |
| device_id:0x20, |
| ao_chans:2, |
| ao_bits: 12, |
| ranges: &cb_pcidda_ranges, |
| }, |
| { |
| name: "pci-dda04/12", |
| status: 1, |
| device_id:0x21, |
| ao_chans:4, |
| ao_bits: 12, |
| ranges: &cb_pcidda_ranges, |
| }, |
| { |
| name: "pci-dda08/12", |
| status: 0, |
| device_id:0x22, |
| ao_chans:8, |
| ao_bits: 12, |
| ranges: &cb_pcidda_ranges, |
| }, |
| { |
| name: "pci-dda02/16", |
| status: 2, |
| device_id:0x23, |
| ao_chans:2, |
| ao_bits: 16, |
| ranges: &cb_pcidda_ranges, |
| }, |
| { |
| name: "pci-dda04/16", |
| status: 2, |
| device_id:0x24, |
| ao_chans:4, |
| ao_bits: 16, |
| ranges: &cb_pcidda_ranges, |
| }, |
| { |
| name: "pci-dda08/16", |
| status: 0, |
| device_id:0x25, |
| ao_chans:8, |
| ao_bits: 16, |
| ranges: &cb_pcidda_ranges, |
| }, |
| }; |
| |
| static DEFINE_PCI_DEVICE_TABLE(cb_pcidda_pci_table) = { |
| {PCI_VENDOR_ID_CB, 0x0020, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, |
| {PCI_VENDOR_ID_CB, 0x0021, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, |
| {PCI_VENDOR_ID_CB, 0x0022, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, |
| {PCI_VENDOR_ID_CB, 0x0023, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, |
| {PCI_VENDOR_ID_CB, 0x0024, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, |
| {PCI_VENDOR_ID_CB, 0x0025, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, |
| {0} |
| }; |
| |
| MODULE_DEVICE_TABLE(pci, cb_pcidda_pci_table); |
| |
| /* |
| * Useful for shorthand access to the particular board structure |
| */ |
| #define thisboard ((const struct cb_pcidda_board *)dev->board_ptr) |
| |
| /* this structure is for data unique to this hardware driver. If |
| several hardware drivers keep similar information in this structure, |
| feel free to suggest moving the variable to the struct comedi_device struct. */ |
| struct cb_pcidda_private { |
| int data; |
| |
| /* would be useful for a PCI device */ |
| struct pci_dev *pci_dev; |
| |
| unsigned long digitalio; |
| unsigned long dac; |
| //unsigned long control_status; |
| //unsigned long adc_fifo; |
| unsigned int dac_cal1_bits; // bits last written to da calibration register 1 |
| unsigned int ao_range[MAX_AO_CHANNELS]; // current range settings for output channels |
| u16 eeprom_data[EEPROM_SIZE]; // software copy of board's eeprom |
| }; |
| |
| /* |
| * most drivers define the following macro to make it easy to |
| * access the private structure. |
| */ |
| #define devpriv ((struct cb_pcidda_private *)dev->private) |
| |
| static int cb_pcidda_attach(struct comedi_device * dev, struct comedi_devconfig * it); |
| static int cb_pcidda_detach(struct comedi_device * dev); |
| //static int cb_pcidda_ai_rinsn(struct comedi_device *dev,struct comedi_subdevice *s,struct comedi_insn *insn,unsigned int *data); |
| static int cb_pcidda_ao_winsn(struct comedi_device * dev, struct comedi_subdevice * s, |
| struct comedi_insn * insn, unsigned int * data); |
| //static int cb_pcidda_ai_cmd(struct comedi_device *dev,struct comedi_subdevice *s); |
| //static int cb_pcidda_ai_cmdtest(struct comedi_device *dev,struct comedi_subdevice *s, struct comedi_cmd *cmd); |
| //static int cb_pcidda_ns_to_timer(unsigned int *ns,int round); |
| static unsigned int cb_pcidda_serial_in(struct comedi_device * dev); |
| static void cb_pcidda_serial_out(struct comedi_device * dev, unsigned int value, |
| unsigned int num_bits); |
| static unsigned int cb_pcidda_read_eeprom(struct comedi_device * dev, |
| unsigned int address); |
| static void cb_pcidda_calibrate(struct comedi_device * dev, unsigned int channel, |
| unsigned int range); |
| |
| /* |
| * The struct comedi_driver structure tells the Comedi core module |
| * which functions to call to configure/deconfigure (attach/detach) |
| * the board, and also about the kernel module that contains |
| * the device code. |
| */ |
| static struct comedi_driver driver_cb_pcidda = { |
| driver_name:"cb_pcidda", |
| module:THIS_MODULE, |
| attach:cb_pcidda_attach, |
| detach:cb_pcidda_detach, |
| }; |
| |
| /* |
| * Attach is called by the Comedi core to configure the driver |
| * for a particular board. |
| */ |
| static int cb_pcidda_attach(struct comedi_device * dev, struct comedi_devconfig * it) |
| { |
| struct comedi_subdevice *s; |
| struct pci_dev *pcidev; |
| int index; |
| |
| printk("comedi%d: cb_pcidda: ", dev->minor); |
| |
| /* |
| * Allocate the private structure area. |
| */ |
| if (alloc_private(dev, sizeof(struct cb_pcidda_private)) < 0) |
| return -ENOMEM; |
| |
| /* |
| * Probe the device to determine what device in the series it is. |
| */ |
| printk("\n"); |
| |
| for (pcidev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, NULL); |
| pcidev != NULL; |
| pcidev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, pcidev)) { |
| if (pcidev->vendor == PCI_VENDOR_ID_CB) { |
| if (it->options[0] || it->options[1]) { |
| if (pcidev->bus->number != it->options[0] || |
| PCI_SLOT(pcidev->devfn) != |
| it->options[1]) { |
| continue; |
| } |
| } |
| for (index = 0; index < N_BOARDS; index++) { |
| if (cb_pcidda_boards[index].device_id == |
| pcidev->device) { |
| goto found; |
| } |
| } |
| } |
| } |
| if (!pcidev) { |
| printk("Not a ComputerBoards/MeasurementComputing card on requested position\n"); |
| return -EIO; |
| } |
| found: |
| devpriv->pci_dev = pcidev; |
| dev->board_ptr = cb_pcidda_boards + index; |
| // "thisboard" macro can be used from here. |
| printk("Found %s at requested position\n", thisboard->name); |
| |
| /* |
| * Enable PCI device and request regions. |
| */ |
| if (comedi_pci_enable(pcidev, thisboard->name)) { |
| printk("cb_pcidda: failed to enable PCI device and request regions\n"); |
| return -EIO; |
| } |
| |
| /* |
| * Allocate the I/O ports. |
| */ |
| devpriv->digitalio = |
| pci_resource_start(devpriv->pci_dev, DIGITALIO_BADRINDEX); |
| devpriv->dac = pci_resource_start(devpriv->pci_dev, DAC_BADRINDEX); |
| |
| /* |
| * Warn about the status of the driver. |
| */ |
| if (thisboard->status == 2) |
| 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"); |
| |
| /* |
| * Initialize dev->board_name. |
| */ |
| dev->board_name = thisboard->name; |
| |
| /* |
| * Allocate the subdevice structures. |
| */ |
| if (alloc_subdevices(dev, 3) < 0) |
| return -ENOMEM; |
| |
| s = dev->subdevices + 0; |
| /* analog output subdevice */ |
| s->type = COMEDI_SUBD_AO; |
| s->subdev_flags = SDF_WRITABLE; |
| s->n_chan = thisboard->ao_chans; |
| s->maxdata = (1 << thisboard->ao_bits) - 1; |
| s->range_table = thisboard->ranges; |
| s->insn_write = cb_pcidda_ao_winsn; |
| // s->subdev_flags |= SDF_CMD_READ; |
| // s->do_cmd = cb_pcidda_ai_cmd; |
| // s->do_cmdtest = cb_pcidda_ai_cmdtest; |
| |
| // two 8255 digital io subdevices |
| s = dev->subdevices + 1; |
| subdev_8255_init(dev, s, NULL, devpriv->digitalio); |
| s = dev->subdevices + 2; |
| subdev_8255_init(dev, s, NULL, devpriv->digitalio + PORT2A); |
| |
| printk(" eeprom:"); |
| for (index = 0; index < EEPROM_SIZE; index++) { |
| devpriv->eeprom_data[index] = cb_pcidda_read_eeprom(dev, index); |
| printk(" %i:0x%x ", index, devpriv->eeprom_data[index]); |
| } |
| printk("\n"); |
| |
| // set calibrations dacs |
| for (index = 0; index < thisboard->ao_chans; index++) |
| cb_pcidda_calibrate(dev, index, devpriv->ao_range[index]); |
| |
| return 1; |
| } |
| |
| /* |
| * _detach is called to deconfigure a device. It should deallocate |
| * resources. |
| * This function is also called when _attach() fails, so it should be |
| * careful not to release resources that were not necessarily |
| * allocated by _attach(). dev->private and dev->subdevices are |
| * deallocated automatically by the core. |
| */ |
| static int cb_pcidda_detach(struct comedi_device * dev) |
| { |
| /* |
| * Deallocate the I/O ports. |
| */ |
| if (devpriv) { |
| if (devpriv->pci_dev) { |
| if (devpriv->dac) { |
| comedi_pci_disable(devpriv->pci_dev); |
| } |
| pci_dev_put(devpriv->pci_dev); |
| } |
| } |
| // cleanup 8255 |
| if (dev->subdevices) { |
| subdev_8255_cleanup(dev, dev->subdevices + 1); |
| subdev_8255_cleanup(dev, dev->subdevices + 2); |
| } |
| |
| printk("comedi%d: cb_pcidda: remove\n", dev->minor); |
| |
| return 0; |
| } |
| |
| /* |
| * I will program this later... ;-) |
| */ |
| #if 0 |
| static int cb_pcidda_ai_cmd(struct comedi_device * dev, struct comedi_subdevice * s) |
| { |
| printk("cb_pcidda_ai_cmd\n"); |
| printk("subdev: %d\n", cmd->subdev); |
| printk("flags: %d\n", cmd->flags); |
| printk("start_src: %d\n", cmd->start_src); |
| printk("start_arg: %d\n", cmd->start_arg); |
| printk("scan_begin_src: %d\n", cmd->scan_begin_src); |
| printk("convert_src: %d\n", cmd->convert_src); |
| printk("convert_arg: %d\n", cmd->convert_arg); |
| printk("scan_end_src: %d\n", cmd->scan_end_src); |
| printk("scan_end_arg: %d\n", cmd->scan_end_arg); |
| printk("stop_src: %d\n", cmd->stop_src); |
| printk("stop_arg: %d\n", cmd->stop_arg); |
| printk("chanlist_len: %d\n", cmd->chanlist_len); |
| } |
| #endif |
| |
| #if 0 |
| static int cb_pcidda_ai_cmdtest(struct comedi_device * dev, struct comedi_subdevice * s, |
| struct comedi_cmd * cmd) |
| { |
| int err = 0; |
| int tmp; |
| |
| /* cmdtest tests a particular command to see if it is valid. |
| * Using the cmdtest ioctl, a user can create a valid cmd |
| * and then have it executes by the cmd ioctl. |
| * |
| * cmdtest returns 1,2,3,4 or 0, depending on which tests |
| * the command passes. */ |
| |
| /* step 1: make sure trigger sources are trivially valid */ |
| |
| tmp = cmd->start_src; |
| cmd->start_src &= TRIG_NOW; |
| if (!cmd->start_src || tmp != cmd->start_src) |
| err++; |
| |
| tmp = cmd->scan_begin_src; |
| cmd->scan_begin_src &= TRIG_TIMER | TRIG_EXT; |
| if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src) |
| err++; |
| |
| tmp = cmd->convert_src; |
| cmd->convert_src &= TRIG_TIMER | TRIG_EXT; |
| if (!cmd->convert_src || tmp != cmd->convert_src) |
| err++; |
| |
| tmp = cmd->scan_end_src; |
| cmd->scan_end_src &= TRIG_COUNT; |
| if (!cmd->scan_end_src || tmp != cmd->scan_end_src) |
| err++; |
| |
| tmp = cmd->stop_src; |
| cmd->stop_src &= TRIG_COUNT | TRIG_NONE; |
| if (!cmd->stop_src || tmp != cmd->stop_src) |
| err++; |
| |
| if (err) |
| return 1; |
| |
| /* step 2: make sure trigger sources are unique and mutually compatible */ |
| |
| /* note that mutual compatiblity is not an issue here */ |
| if (cmd->scan_begin_src != TRIG_TIMER |
| && cmd->scan_begin_src != TRIG_EXT) |
| err++; |
| if (cmd->convert_src != TRIG_TIMER && cmd->convert_src != TRIG_EXT) |
| err++; |
| if (cmd->stop_src != TRIG_TIMER && cmd->stop_src != TRIG_EXT) |
| err++; |
| |
| if (err) |
| return 2; |
| |
| /* step 3: make sure arguments are trivially compatible */ |
| |
| if (cmd->start_arg != 0) { |
| cmd->start_arg = 0; |
| err++; |
| } |
| #define MAX_SPEED 10000 /* in nanoseconds */ |
| #define MIN_SPEED 1000000000 /* in nanoseconds */ |
| |
| if (cmd->scan_begin_src == TRIG_TIMER) { |
| if (cmd->scan_begin_arg < MAX_SPEED) { |
| cmd->scan_begin_arg = MAX_SPEED; |
| err++; |
| } |
| if (cmd->scan_begin_arg > MIN_SPEED) { |
| cmd->scan_begin_arg = MIN_SPEED; |
| err++; |
| } |
| } else { |
| /* external trigger */ |
| /* should be level/edge, hi/lo specification here */ |
| /* should specify multiple external triggers */ |
| if (cmd->scan_begin_arg > 9) { |
| cmd->scan_begin_arg = 9; |
| err++; |
| } |
| } |
| if (cmd->convert_src == TRIG_TIMER) { |
| if (cmd->convert_arg < MAX_SPEED) { |
| cmd->convert_arg = MAX_SPEED; |
| err++; |
| } |
| if (cmd->convert_arg > MIN_SPEED) { |
| cmd->convert_arg = MIN_SPEED; |
| err++; |
| } |
| } else { |
| /* external trigger */ |
| /* see above */ |
| if (cmd->convert_arg > 9) { |
| cmd->convert_arg = 9; |
| err++; |
| } |
| } |
| |
| if (cmd->scan_end_arg != cmd->chanlist_len) { |
| cmd->scan_end_arg = cmd->chanlist_len; |
| err++; |
| } |
| if (cmd->stop_src == TRIG_COUNT) { |
| if (cmd->stop_arg > 0x00ffffff) { |
| cmd->stop_arg = 0x00ffffff; |
| err++; |
| } |
| } else { |
| /* TRIG_NONE */ |
| if (cmd->stop_arg != 0) { |
| cmd->stop_arg = 0; |
| err++; |
| } |
| } |
| |
| if (err) |
| return 3; |
| |
| /* step 4: fix up any arguments */ |
| |
| if (cmd->scan_begin_src == TRIG_TIMER) { |
| tmp = cmd->scan_begin_arg; |
| cb_pcidda_ns_to_timer(&cmd->scan_begin_arg, |
| cmd->flags & TRIG_ROUND_MASK); |
| if (tmp != cmd->scan_begin_arg) |
| err++; |
| } |
| if (cmd->convert_src == TRIG_TIMER) { |
| tmp = cmd->convert_arg; |
| cb_pcidda_ns_to_timer(&cmd->convert_arg, |
| cmd->flags & TRIG_ROUND_MASK); |
| if (tmp != cmd->convert_arg) |
| err++; |
| if (cmd->scan_begin_src == TRIG_TIMER && |
| cmd->scan_begin_arg < |
| cmd->convert_arg * cmd->scan_end_arg) { |
| cmd->scan_begin_arg = |
| cmd->convert_arg * cmd->scan_end_arg; |
| err++; |
| } |
| } |
| |
| if (err) |
| return 4; |
| |
| return 0; |
| } |
| #endif |
| |
| /* This function doesn't require a particular form, this is just |
| * what happens to be used in some of the drivers. It should |
| * convert ns nanoseconds to a counter value suitable for programming |
| * the device. Also, it should adjust ns so that it cooresponds to |
| * the actual time that the device will use. */ |
| #if 0 |
| static int cb_pcidda_ns_to_timer(unsigned int *ns, int round) |
| { |
| /* trivial timer */ |
| return *ns; |
| } |
| #endif |
| |
| static int cb_pcidda_ao_winsn(struct comedi_device * dev, struct comedi_subdevice * s, |
| struct comedi_insn * insn, unsigned int * data) |
| { |
| unsigned int command; |
| unsigned int channel, range; |
| |
| channel = CR_CHAN(insn->chanspec); |
| range = CR_RANGE(insn->chanspec); |
| |
| // adjust calibration dacs if range has changed |
| if (range != devpriv->ao_range[channel]) |
| cb_pcidda_calibrate(dev, channel, range); |
| |
| /* output channel configuration */ |
| command = NOSU | ENABLEDAC; |
| |
| /* output channel range */ |
| switch (range) { |
| case 0: |
| command |= BIP | RANGE10V; |
| break; |
| case 1: |
| command |= BIP | RANGE5V; |
| break; |
| case 2: |
| command |= BIP | RANGE2V5; |
| break; |
| case 3: |
| command |= UNIP | RANGE10V; |
| break; |
| case 4: |
| command |= UNIP | RANGE5V; |
| break; |
| case 5: |
| command |= UNIP | RANGE2V5; |
| break; |
| }; |
| |
| /* output channel specification */ |
| command |= channel << 2; |
| outw(command, devpriv->dac + DACONTROL); |
| |
| /* write data */ |
| outw(data[0], devpriv->dac + DADATA + channel * 2); |
| |
| /* return the number of samples read/written */ |
| return 1; |
| } |
| |
| // lowlevel read from eeprom |
| static unsigned int cb_pcidda_serial_in(struct comedi_device * dev) |
| { |
| unsigned int value = 0; |
| int i; |
| const int value_width = 16; // number of bits wide values are |
| |
| for (i = 1; i <= value_width; i++) { |
| // read bits most significant bit first |
| if (inw_p(devpriv->dac + DACALIBRATION1) & SERIAL_OUT_BIT) { |
| value |= 1 << (value_width - i); |
| } |
| } |
| |
| return value; |
| } |
| |
| // lowlevel write to eeprom/dac |
| static void cb_pcidda_serial_out(struct comedi_device * dev, unsigned int value, |
| unsigned int num_bits) |
| { |
| int i; |
| |
| for (i = 1; i <= num_bits; i++) { |
| // send bits most significant bit first |
| if (value & (1 << (num_bits - i))) |
| devpriv->dac_cal1_bits |= SERIAL_IN_BIT; |
| else |
| devpriv->dac_cal1_bits &= ~SERIAL_IN_BIT; |
| outw_p(devpriv->dac_cal1_bits, devpriv->dac + DACALIBRATION1); |
| } |
| } |
| |
| // reads a 16 bit value from board's eeprom |
| static unsigned int cb_pcidda_read_eeprom(struct comedi_device * dev, |
| unsigned int address) |
| { |
| unsigned int i; |
| unsigned int cal2_bits; |
| unsigned int value; |
| const int max_num_caldacs = 4; // one caldac for every two dac channels |
| const int read_instruction = 0x6; // bits to send to tell eeprom we want to read |
| const int instruction_length = 3; |
| const int address_length = 8; |
| |
| // send serial output stream to eeprom |
| cal2_bits = SELECT_EEPROM_BIT | DESELECT_REF_DAC_BIT | DUMMY_BIT; |
| // deactivate caldacs (one caldac for every two channels) |
| for (i = 0; i < max_num_caldacs; i++) { |
| cal2_bits |= DESELECT_CALDAC_BIT(i); |
| } |
| outw_p(cal2_bits, devpriv->dac + DACALIBRATION2); |
| |
| // tell eeprom we want to read |
| cb_pcidda_serial_out(dev, read_instruction, instruction_length); |
| // send address we want to read from |
| cb_pcidda_serial_out(dev, address, address_length); |
| |
| value = cb_pcidda_serial_in(dev); |
| |
| // deactivate eeprom |
| cal2_bits &= ~SELECT_EEPROM_BIT; |
| outw_p(cal2_bits, devpriv->dac + DACALIBRATION2); |
| |
| return value; |
| } |
| |
| // writes to 8 bit calibration dacs |
| static void cb_pcidda_write_caldac(struct comedi_device * dev, unsigned int caldac, |
| unsigned int channel, unsigned int value) |
| { |
| unsigned int cal2_bits; |
| unsigned int i; |
| const int num_channel_bits = 3; // caldacs use 3 bit channel specification |
| const int num_caldac_bits = 8; // 8 bit calibration dacs |
| const int max_num_caldacs = 4; // one caldac for every two dac channels |
| |
| /* write 3 bit channel */ |
| cb_pcidda_serial_out(dev, channel, num_channel_bits); |
| // write 8 bit caldac value |
| cb_pcidda_serial_out(dev, value, num_caldac_bits); |
| |
| // latch stream into appropriate caldac |
| // deselect reference dac |
| cal2_bits = DESELECT_REF_DAC_BIT | DUMMY_BIT; |
| // deactivate caldacs (one caldac for every two channels) |
| for (i = 0; i < max_num_caldacs; i++) { |
| cal2_bits |= DESELECT_CALDAC_BIT(i); |
| } |
| // activate the caldac we want |
| cal2_bits &= ~DESELECT_CALDAC_BIT(caldac); |
| outw_p(cal2_bits, devpriv->dac + DACALIBRATION2); |
| // deactivate caldac |
| cal2_bits |= DESELECT_CALDAC_BIT(caldac); |
| outw_p(cal2_bits, devpriv->dac + DACALIBRATION2); |
| } |
| |
| // returns caldac that calibrates given analog out channel |
| static unsigned int caldac_number(unsigned int channel) |
| { |
| return channel / 2; |
| } |
| |
| // returns caldac channel that provides fine gain for given ao channel |
| static unsigned int fine_gain_channel(unsigned int ao_channel) |
| { |
| return 4 * (ao_channel % 2); |
| } |
| |
| // returns caldac channel that provides coarse gain for given ao channel |
| static unsigned int coarse_gain_channel(unsigned int ao_channel) |
| { |
| return 1 + 4 * (ao_channel % 2); |
| } |
| |
| // returns caldac channel that provides coarse offset for given ao channel |
| static unsigned int coarse_offset_channel(unsigned int ao_channel) |
| { |
| return 2 + 4 * (ao_channel % 2); |
| } |
| |
| // returns caldac channel that provides fine offset for given ao channel |
| static unsigned int fine_offset_channel(unsigned int ao_channel) |
| { |
| return 3 + 4 * (ao_channel % 2); |
| } |
| |
| // returns eeprom address that provides offset for given ao channel and range |
| static unsigned int offset_eeprom_address(unsigned int ao_channel, |
| unsigned int range) |
| { |
| return 0x7 + 2 * range + 12 * ao_channel; |
| } |
| |
| // returns eeprom address that provides gain calibration for given ao channel and range |
| static unsigned int gain_eeprom_address(unsigned int ao_channel, |
| unsigned int range) |
| { |
| return 0x8 + 2 * range + 12 * ao_channel; |
| } |
| |
| // returns upper byte of eeprom entry, which gives the coarse adjustment values |
| static unsigned int eeprom_coarse_byte(unsigned int word) |
| { |
| return (word >> 8) & 0xff; |
| } |
| |
| // returns lower byte of eeprom entry, which gives the fine adjustment values |
| static unsigned int eeprom_fine_byte(unsigned int word) |
| { |
| return word & 0xff; |
| } |
| |
| // set caldacs to eeprom values for given channel and range |
| static void cb_pcidda_calibrate(struct comedi_device * dev, unsigned int channel, |
| unsigned int range) |
| { |
| unsigned int coarse_offset, fine_offset, coarse_gain, fine_gain; |
| |
| // remember range so we can tell when we need to readjust calibration |
| devpriv->ao_range[channel] = range; |
| |
| // get values from eeprom data |
| coarse_offset = |
| eeprom_coarse_byte(devpriv-> |
| eeprom_data[offset_eeprom_address(channel, range)]); |
| fine_offset = |
| eeprom_fine_byte(devpriv-> |
| eeprom_data[offset_eeprom_address(channel, range)]); |
| coarse_gain = |
| eeprom_coarse_byte(devpriv-> |
| eeprom_data[gain_eeprom_address(channel, range)]); |
| fine_gain = |
| eeprom_fine_byte(devpriv-> |
| eeprom_data[gain_eeprom_address(channel, range)]); |
| |
| // set caldacs |
| cb_pcidda_write_caldac(dev, caldac_number(channel), |
| coarse_offset_channel(channel), coarse_offset); |
| cb_pcidda_write_caldac(dev, caldac_number(channel), |
| fine_offset_channel(channel), fine_offset); |
| cb_pcidda_write_caldac(dev, caldac_number(channel), |
| coarse_gain_channel(channel), coarse_gain); |
| cb_pcidda_write_caldac(dev, caldac_number(channel), |
| fine_gain_channel(channel), fine_gain); |
| } |
| |
| /* |
| * A convenient macro that defines init_module() and cleanup_module(), |
| * as necessary. |
| */ |
| COMEDI_PCI_INITCLEANUP(driver_cb_pcidda, cb_pcidda_pci_table); |