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