Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
das800.c
Go to the documentation of this file.
1 /*
2  comedi/drivers/das800.c
3  Driver for Keitley das800 series boards and compatibles
4  Copyright (C) 2000 Frank Mori Hess <[email protected]>
5 
6  COMEDI - Linux Control and Measurement Device Interface
7  Copyright (C) 2000 David A. Schleef <[email protected]>
8 
9  This program is free software; you can redistribute it and/or modify
10  it under the terms of the GNU General Public License as published by
11  the Free Software Foundation; either version 2 of the License, or
12  (at your option) any later version.
13 
14  This program is distributed in the hope that it will be useful,
15  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  GNU General Public License for more details.
18 
19  You should have received a copy of the GNU General Public License
20  along with this program; if not, write to the Free Software
21  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 
23 ************************************************************************
24 */
25 /*
26 Driver: das800
27 Description: Keithley Metrabyte DAS800 (& compatibles)
28 Author: Frank Mori Hess <[email protected]>
29 Devices: [Keithley Metrabyte] DAS-800 (das-800), DAS-801 (das-801),
30  DAS-802 (das-802),
31  [Measurement Computing] CIO-DAS800 (cio-das800),
32  CIO-DAS801 (cio-das801), CIO-DAS802 (cio-das802),
33  CIO-DAS802/16 (cio-das802/16)
34 Status: works, cio-das802/16 untested - email me if you have tested it
35 
36 Configuration options:
37  [0] - I/O port base address
38  [1] - IRQ (optional, required for timed or externally triggered conversions)
39 
40 Notes:
41  IRQ can be omitted, although the cmd interface will not work without it.
42 
43  All entries in the channel/gain list must use the same gain and be
44  consecutive channels counting upwards in channel number (these are
45  hardware limitations.)
46 
47  I've never tested the gain setting stuff since I only have a
48  DAS-800 board with fixed gain.
49 
50  The cio-das802/16 does not have a fifo-empty status bit! Therefore
51  only fifo-half-full transfers are possible with this card.
52 */
53 /*
54 
55 cmd triggers supported:
56  start_src: TRIG_NOW | TRIG_EXT
57  scan_begin_src: TRIG_FOLLOW
58  scan_end_src: TRIG_COUNT
59  convert_src: TRIG_TIMER | TRIG_EXT
60  stop_src: TRIG_NONE | TRIG_COUNT
61 
62 
63 */
64 
65 #include <linux/interrupt.h>
66 #include "../comedidev.h"
67 
68 #include <linux/ioport.h>
69 #include <linux/delay.h>
70 
71 #include "8253.h"
72 #include "comedi_fc.h"
73 
74 #define DAS800_SIZE 8
75 #define TIMER_BASE 1000
76 #define N_CHAN_AI 8 /* number of analog input channels */
77 
78 /* Registers for the das800 */
79 
80 #define DAS800_LSB 0
81 #define FIFO_EMPTY 0x1
82 #define FIFO_OVF 0x2
83 #define DAS800_MSB 1
84 #define DAS800_CONTROL1 2
85 #define CONTROL1_INTE 0x8
86 #define DAS800_CONV_CONTROL 2
87 #define ITE 0x1
88 #define CASC 0x2
89 #define DTEN 0x4
90 #define IEOC 0x8
91 #define EACS 0x10
92 #define CONV_HCEN 0x80
93 #define DAS800_SCAN_LIMITS 2
94 #define DAS800_STATUS 2
95 #define IRQ 0x8
96 #define BUSY 0x80
97 #define DAS800_GAIN 3
98 #define CIO_FFOV 0x8 /* fifo overflow for cio-das802/16 */
99 #define CIO_ENHF 0x90 /* interrupt fifo half full for cio-das802/16 */
100 #define CONTROL1 0x80
101 #define CONV_CONTROL 0xa0
102 #define SCAN_LIMITS 0xc0
103 #define ID 0xe0
104 #define DAS800_8254 4
105 #define DAS800_STATUS2 7
106 #define STATUS2_HCEN 0x80
107 #define STATUS2_INTE 0X20
108 #define DAS800_ID 7
109 
110 struct das800_board {
111  const char *name;
112  int ai_speed;
113  const struct comedi_lrange *ai_range;
114  int resolution;
115 };
116 
117 /* analog input ranges */
118 static const struct comedi_lrange range_das800_ai = {
119  1,
120  {
121  RANGE(-5, 5),
122  }
123 };
124 
125 static const struct comedi_lrange range_das801_ai = {
126  9,
127  {
128  RANGE(-5, 5),
129  RANGE(-10, 10),
130  RANGE(0, 10),
131  RANGE(-0.5, 0.5),
132  RANGE(0, 1),
133  RANGE(-0.05, 0.05),
134  RANGE(0, 0.1),
135  RANGE(-0.01, 0.01),
136  RANGE(0, 0.02),
137  }
138 };
139 
140 static const struct comedi_lrange range_cio_das801_ai = {
141  9,
142  {
143  RANGE(-5, 5),
144  RANGE(-10, 10),
145  RANGE(0, 10),
146  RANGE(-0.5, 0.5),
147  RANGE(0, 1),
148  RANGE(-0.05, 0.05),
149  RANGE(0, 0.1),
150  RANGE(-0.005, 0.005),
151  RANGE(0, 0.01),
152  }
153 };
154 
155 static const struct comedi_lrange range_das802_ai = {
156  9,
157  {
158  RANGE(-5, 5),
159  RANGE(-10, 10),
160  RANGE(0, 10),
161  RANGE(-2.5, 2.5),
162  RANGE(0, 5),
163  RANGE(-1.25, 1.25),
164  RANGE(0, 2.5),
165  RANGE(-0.625, 0.625),
166  RANGE(0, 1.25),
167  }
168 };
169 
170 static const struct comedi_lrange range_das80216_ai = {
171  8,
172  {
173  RANGE(-10, 10),
174  RANGE(0, 10),
175  RANGE(-5, 5),
176  RANGE(0, 5),
177  RANGE(-2.5, 2.5),
178  RANGE(0, 2.5),
179  RANGE(-1.25, 1.25),
180  RANGE(0, 1.25),
181  }
182 };
183 
184 enum { das800, ciodas800, das801, ciodas801, das802, ciodas802, ciodas80216 };
185 
186 static const struct das800_board das800_boards[] = {
187  {
188  .name = "das-800",
189  .ai_speed = 25000,
190  .ai_range = &range_das800_ai,
191  .resolution = 12,
192  },
193  {
194  .name = "cio-das800",
195  .ai_speed = 20000,
196  .ai_range = &range_das800_ai,
197  .resolution = 12,
198  },
199  {
200  .name = "das-801",
201  .ai_speed = 25000,
202  .ai_range = &range_das801_ai,
203  .resolution = 12,
204  },
205  {
206  .name = "cio-das801",
207  .ai_speed = 20000,
208  .ai_range = &range_cio_das801_ai,
209  .resolution = 12,
210  },
211  {
212  .name = "das-802",
213  .ai_speed = 25000,
214  .ai_range = &range_das802_ai,
215  .resolution = 12,
216  },
217  {
218  .name = "cio-das802",
219  .ai_speed = 20000,
220  .ai_range = &range_das802_ai,
221  .resolution = 12,
222  },
223  {
224  .name = "cio-das802/16",
225  .ai_speed = 10000,
226  .ai_range = &range_das80216_ai,
227  .resolution = 16,
228  },
229 };
230 
231 /*
232  * Useful for shorthand access to the particular board structure
233  */
234 #define thisboard ((const struct das800_board *)dev->board_ptr)
235 
236 struct das800_private {
237  volatile unsigned int count; /* number of data points left to be taken */
238  volatile int forever; /* flag indicating whether we should take data forever */
239  unsigned int divisor1; /* value to load into board's counter 1 for timed conversions */
240  unsigned int divisor2; /* value to load into board's counter 2 for timed conversions */
241  volatile int do_bits; /* digital output bits */
242 };
243 
244 #define devpriv ((struct das800_private *)dev->private)
245 
246 static int das800_attach(struct comedi_device *dev,
247  struct comedi_devconfig *it);
248 static void das800_detach(struct comedi_device *dev);
249 static int das800_cancel(struct comedi_device *dev, struct comedi_subdevice *s);
250 
251 static struct comedi_driver driver_das800 = {
252  .driver_name = "das800",
253  .module = THIS_MODULE,
254  .attach = das800_attach,
255  .detach = das800_detach,
256  .num_names = ARRAY_SIZE(das800_boards),
257  .board_name = &das800_boards[0].name,
258  .offset = sizeof(struct das800_board),
259 };
260 
261 static irqreturn_t das800_interrupt(int irq, void *d);
262 static void enable_das800(struct comedi_device *dev);
263 static void disable_das800(struct comedi_device *dev);
264 static int das800_ai_do_cmdtest(struct comedi_device *dev,
265  struct comedi_subdevice *s,
266  struct comedi_cmd *cmd);
267 static int das800_ai_do_cmd(struct comedi_device *dev,
268  struct comedi_subdevice *s);
269 static int das800_ai_rinsn(struct comedi_device *dev,
270  struct comedi_subdevice *s, struct comedi_insn *insn,
271  unsigned int *data);
272 static int das800_di_rbits(struct comedi_device *dev,
273  struct comedi_subdevice *s, struct comedi_insn *insn,
274  unsigned int *data);
275 static int das800_do_wbits(struct comedi_device *dev,
276  struct comedi_subdevice *s, struct comedi_insn *insn,
277  unsigned int *data);
278 static int das800_probe(struct comedi_device *dev);
279 static int das800_set_frequency(struct comedi_device *dev);
280 
281 /* checks and probes das-800 series board type */
282 static int das800_probe(struct comedi_device *dev)
283 {
284  int id_bits;
285  unsigned long irq_flags;
286  int board;
287 
288  /* 'comedi spin lock irqsave' disables even rt interrupts, we use them to protect indirect addressing */
289  spin_lock_irqsave(&dev->spinlock, irq_flags);
290  outb(ID, dev->iobase + DAS800_GAIN); /* select base address + 7 to be ID register */
291  id_bits = inb(dev->iobase + DAS800_ID) & 0x3; /* get id bits */
292  spin_unlock_irqrestore(&dev->spinlock, irq_flags);
293 
294  board = thisboard - das800_boards;
295 
296  switch (id_bits) {
297  case 0x0:
298  if (board == das800) {
299  dev_dbg(dev->class_dev, "Board model: DAS-800\n");
300  return board;
301  }
302  if (board == ciodas800) {
303  dev_dbg(dev->class_dev, "Board model: CIO-DAS800\n");
304  return board;
305  }
306  dev_dbg(dev->class_dev, "Board model (probed): DAS-800\n");
307  return das800;
308  break;
309  case 0x2:
310  if (board == das801) {
311  dev_dbg(dev->class_dev, "Board model: DAS-801\n");
312  return board;
313  }
314  if (board == ciodas801) {
315  dev_dbg(dev->class_dev, "Board model: CIO-DAS801\n");
316  return board;
317  }
318  dev_dbg(dev->class_dev, "Board model (probed): DAS-801\n");
319  return das801;
320  break;
321  case 0x3:
322  if (board == das802) {
323  dev_dbg(dev->class_dev, "Board model: DAS-802\n");
324  return board;
325  }
326  if (board == ciodas802) {
327  dev_dbg(dev->class_dev, "Board model: CIO-DAS802\n");
328  return board;
329  }
330  if (board == ciodas80216) {
331  dev_dbg(dev->class_dev, "Board model: CIO-DAS802/16\n");
332  return board;
333  }
334  dev_dbg(dev->class_dev, "Board model (probed): DAS-802\n");
335  return das802;
336  break;
337  default:
338  dev_dbg(dev->class_dev,
339  "Board model: probe returned 0x%x (unknown)\n",
340  id_bits);
341  return board;
342  break;
343  }
344  return -1;
345 }
346 
347 /*
348  * A convenient macro that defines init_module() and cleanup_module(),
349  * as necessary.
350  */
351 static int __init driver_das800_init_module(void)
352 {
353  return comedi_driver_register(&driver_das800);
354 }
355 
356 static void __exit driver_das800_cleanup_module(void)
357 {
358  comedi_driver_unregister(&driver_das800);
359 }
360 
361 module_init(driver_das800_init_module);
362 module_exit(driver_das800_cleanup_module);
363 
364 /* interrupt service routine */
365 static irqreturn_t das800_interrupt(int irq, void *d)
366 {
367  short i; /* loop index */
368  short dataPoint = 0;
369  struct comedi_device *dev = d;
370  struct comedi_subdevice *s = dev->read_subdev; /* analog input subdevice */
371  struct comedi_async *async;
372  int status;
373  unsigned long irq_flags;
374  static const int max_loops = 128; /* half-fifo size for cio-das802/16 */
375  /* flags */
376  int fifo_empty = 0;
377  int fifo_overflow = 0;
378 
379  status = inb(dev->iobase + DAS800_STATUS);
380  /* if interrupt was not generated by board or driver not attached, quit */
381  if (!(status & IRQ))
382  return IRQ_NONE;
383  if (!(dev->attached))
384  return IRQ_HANDLED;
385 
386  /* wait until here to initialize async, since we will get null dereference
387  * if interrupt occurs before driver is fully attached!
388  */
389  async = s->async;
390 
391  /* if hardware conversions are not enabled, then quit */
392  spin_lock_irqsave(&dev->spinlock, irq_flags);
393  outb(CONTROL1, dev->iobase + DAS800_GAIN); /* select base address + 7 to be STATUS2 register */
394  status = inb(dev->iobase + DAS800_STATUS2) & STATUS2_HCEN;
395  /* don't release spinlock yet since we want to make sure no one else disables hardware conversions */
396  if (status == 0) {
397  spin_unlock_irqrestore(&dev->spinlock, irq_flags);
398  return IRQ_HANDLED;
399  }
400 
401  /* loop while card's fifo is not empty (and limit to half fifo for cio-das802/16) */
402  for (i = 0; i < max_loops; i++) {
403  /* read 16 bits from dev->iobase and dev->iobase + 1 */
404  dataPoint = inb(dev->iobase + DAS800_LSB);
405  dataPoint += inb(dev->iobase + DAS800_MSB) << 8;
406  if (thisboard->resolution == 12) {
407  fifo_empty = dataPoint & FIFO_EMPTY;
408  fifo_overflow = dataPoint & FIFO_OVF;
409  if (fifo_overflow)
410  break;
411  } else {
412  fifo_empty = 0; /* cio-das802/16 has no fifo empty status bit */
413  }
414  if (fifo_empty)
415  break;
416  /* strip off extraneous bits for 12 bit cards */
417  if (thisboard->resolution == 12)
418  dataPoint = (dataPoint >> 4) & 0xfff;
419  /* if there are more data points to collect */
420  if (devpriv->count > 0 || devpriv->forever == 1) {
421  /* write data point to buffer */
422  cfc_write_to_buffer(s, dataPoint);
423  if (devpriv->count > 0)
424  devpriv->count--;
425  }
426  }
427  async->events |= COMEDI_CB_BLOCK;
428  /* check for fifo overflow */
429  if (thisboard->resolution == 12) {
430  fifo_overflow = dataPoint & FIFO_OVF;
431  /* else cio-das802/16 */
432  } else {
433  fifo_overflow = inb(dev->iobase + DAS800_GAIN) & CIO_FFOV;
434  }
435  if (fifo_overflow) {
436  spin_unlock_irqrestore(&dev->spinlock, irq_flags);
437  comedi_error(dev, "DAS800 FIFO overflow");
438  das800_cancel(dev, s);
439  async->events |= COMEDI_CB_ERROR | COMEDI_CB_EOA;
440  comedi_event(dev, s);
441  async->events = 0;
442  return IRQ_HANDLED;
443  }
444  if (devpriv->count > 0 || devpriv->forever == 1) {
445  /* Re-enable card's interrupt.
446  * We already have spinlock, so indirect addressing is safe */
447  outb(CONTROL1, dev->iobase + DAS800_GAIN); /* select dev->iobase + 2 to be control register 1 */
448  outb(CONTROL1_INTE | devpriv->do_bits,
449  dev->iobase + DAS800_CONTROL1);
450  spin_unlock_irqrestore(&dev->spinlock, irq_flags);
451  /* otherwise, stop taking data */
452  } else {
453  spin_unlock_irqrestore(&dev->spinlock, irq_flags);
454  disable_das800(dev); /* disable hardware triggered conversions */
455  async->events |= COMEDI_CB_EOA;
456  }
457  comedi_event(dev, s);
458  async->events = 0;
459  return IRQ_HANDLED;
460 }
461 
462 static int das800_attach(struct comedi_device *dev, struct comedi_devconfig *it)
463 {
464  struct comedi_subdevice *s;
465  unsigned long iobase = it->options[0];
466  unsigned int irq = it->options[1];
467  unsigned long irq_flags;
468  int board;
469  int ret;
470 
471  dev_info(dev->class_dev, "das800: io 0x%lx\n", iobase);
472  if (irq)
473  dev_dbg(dev->class_dev, "irq %u\n", irq);
474 
475  /* allocate and initialize dev->private */
476  if (alloc_private(dev, sizeof(struct das800_private)) < 0)
477  return -ENOMEM;
478 
479  if (iobase == 0) {
480  dev_err(dev->class_dev,
481  "io base address required for das800\n");
482  return -EINVAL;
483  }
484 
485  /* check if io addresses are available */
486  if (!request_region(iobase, DAS800_SIZE, "das800")) {
487  dev_err(dev->class_dev, "I/O port conflict\n");
488  return -EIO;
489  }
490  dev->iobase = iobase;
491 
492  board = das800_probe(dev);
493  if (board < 0) {
494  dev_dbg(dev->class_dev, "unable to determine board type\n");
495  return -ENODEV;
496  }
497  dev->board_ptr = das800_boards + board;
498 
499  /* grab our IRQ */
500  if (irq == 1 || irq > 7) {
501  dev_err(dev->class_dev, "irq out of range\n");
502  return -EINVAL;
503  }
504  if (irq) {
505  if (request_irq(irq, das800_interrupt, 0, "das800", dev)) {
506  dev_err(dev->class_dev, "unable to allocate irq %u\n",
507  irq);
508  return -EINVAL;
509  }
510  }
511  dev->irq = irq;
512 
513  dev->board_name = thisboard->name;
514 
515  ret = comedi_alloc_subdevices(dev, 3);
516  if (ret)
517  return ret;
518 
519  /* analog input subdevice */
520  s = &dev->subdevices[0];
521  dev->read_subdev = s;
522  s->type = COMEDI_SUBD_AI;
523  s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_CMD_READ;
524  s->n_chan = 8;
525  s->len_chanlist = 8;
526  s->maxdata = (1 << thisboard->resolution) - 1;
527  s->range_table = thisboard->ai_range;
528  s->do_cmd = das800_ai_do_cmd;
529  s->do_cmdtest = das800_ai_do_cmdtest;
530  s->insn_read = das800_ai_rinsn;
531  s->cancel = das800_cancel;
532 
533  /* di */
534  s = &dev->subdevices[1];
535  s->type = COMEDI_SUBD_DI;
536  s->subdev_flags = SDF_READABLE;
537  s->n_chan = 3;
538  s->maxdata = 1;
539  s->range_table = &range_digital;
540  s->insn_bits = das800_di_rbits;
541 
542  /* do */
543  s = &dev->subdevices[2];
544  s->type = COMEDI_SUBD_DO;
545  s->subdev_flags = SDF_WRITABLE | SDF_READABLE;
546  s->n_chan = 4;
547  s->maxdata = 1;
548  s->range_table = &range_digital;
549  s->insn_bits = das800_do_wbits;
550 
551  disable_das800(dev);
552 
553  /* initialize digital out channels */
554  spin_lock_irqsave(&dev->spinlock, irq_flags);
555  outb(CONTROL1, dev->iobase + DAS800_GAIN); /* select dev->iobase + 2 to be control register 1 */
556  outb(CONTROL1_INTE | devpriv->do_bits, dev->iobase + DAS800_CONTROL1);
557  spin_unlock_irqrestore(&dev->spinlock, irq_flags);
558 
559  return 0;
560 };
561 
562 static void das800_detach(struct comedi_device *dev)
563 {
564  if (dev->iobase)
565  release_region(dev->iobase, DAS800_SIZE);
566  if (dev->irq)
567  free_irq(dev->irq, dev);
568 };
569 
570 static int das800_cancel(struct comedi_device *dev, struct comedi_subdevice *s)
571 {
572  devpriv->forever = 0;
573  devpriv->count = 0;
574  disable_das800(dev);
575  return 0;
576 }
577 
578 /* enable_das800 makes the card start taking hardware triggered conversions */
579 static void enable_das800(struct comedi_device *dev)
580 {
581  unsigned long irq_flags;
582  spin_lock_irqsave(&dev->spinlock, irq_flags);
583  /* enable fifo-half full interrupts for cio-das802/16 */
584  if (thisboard->resolution == 16)
585  outb(CIO_ENHF, dev->iobase + DAS800_GAIN);
586  outb(CONV_CONTROL, dev->iobase + DAS800_GAIN); /* select dev->iobase + 2 to be conversion control register */
587  outb(CONV_HCEN, dev->iobase + DAS800_CONV_CONTROL); /* enable hardware triggering */
588  outb(CONTROL1, dev->iobase + DAS800_GAIN); /* select dev->iobase + 2 to be control register 1 */
589  outb(CONTROL1_INTE | devpriv->do_bits, dev->iobase + DAS800_CONTROL1); /* enable card's interrupt */
590  spin_unlock_irqrestore(&dev->spinlock, irq_flags);
591 }
592 
593 /* disable_das800 stops hardware triggered conversions */
594 static void disable_das800(struct comedi_device *dev)
595 {
596  unsigned long irq_flags;
597  spin_lock_irqsave(&dev->spinlock, irq_flags);
598  outb(CONV_CONTROL, dev->iobase + DAS800_GAIN); /* select dev->iobase + 2 to be conversion control register */
599  outb(0x0, dev->iobase + DAS800_CONV_CONTROL); /* disable hardware triggering of conversions */
600  spin_unlock_irqrestore(&dev->spinlock, irq_flags);
601 }
602 
603 static int das800_ai_do_cmdtest(struct comedi_device *dev,
604  struct comedi_subdevice *s,
605  struct comedi_cmd *cmd)
606 {
607  int err = 0;
608  int tmp;
609  int gain, startChan;
610  int i;
611 
612  /* Step 1 : check if triggers are trivially valid */
613 
614  err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_EXT);
615  err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_FOLLOW);
616  err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_TIMER | TRIG_EXT);
617  err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
618  err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
619 
620  if (err)
621  return 1;
622 
623  /* Step 2a : make sure trigger sources are unique */
624 
625  err |= cfc_check_trigger_is_unique(cmd->start_src);
626  err |= cfc_check_trigger_is_unique(cmd->convert_src);
627  err |= cfc_check_trigger_is_unique(cmd->stop_src);
628 
629  /* Step 2b : and mutually compatible */
630 
631  if (err)
632  return 2;
633 
634  /* step 3: make sure arguments are trivially compatible */
635 
636  if (cmd->start_arg != 0) {
637  cmd->start_arg = 0;
638  err++;
639  }
640  if (cmd->convert_src == TRIG_TIMER) {
641  if (cmd->convert_arg < thisboard->ai_speed) {
642  cmd->convert_arg = thisboard->ai_speed;
643  err++;
644  }
645  }
646  if (!cmd->chanlist_len) {
647  cmd->chanlist_len = 1;
648  err++;
649  }
650  if (cmd->scan_end_arg != cmd->chanlist_len) {
651  cmd->scan_end_arg = cmd->chanlist_len;
652  err++;
653  }
654  if (cmd->stop_src == TRIG_COUNT) {
655  if (!cmd->stop_arg) {
656  cmd->stop_arg = 1;
657  err++;
658  }
659  } else { /* TRIG_NONE */
660  if (cmd->stop_arg != 0) {
661  cmd->stop_arg = 0;
662  err++;
663  }
664  }
665 
666  if (err)
667  return 3;
668 
669  /* step 4: fix up any arguments */
670 
671  if (cmd->convert_src == TRIG_TIMER) {
672  tmp = cmd->convert_arg;
673  /* calculate counter values that give desired timing */
674  i8253_cascade_ns_to_timer_2div(TIMER_BASE, &(devpriv->divisor1),
675  &(devpriv->divisor2),
676  &(cmd->convert_arg),
677  cmd->flags & TRIG_ROUND_MASK);
678  if (tmp != cmd->convert_arg)
679  err++;
680  }
681 
682  if (err)
683  return 4;
684 
685  /* check channel/gain list against card's limitations */
686  if (cmd->chanlist) {
687  gain = CR_RANGE(cmd->chanlist[0]);
688  startChan = CR_CHAN(cmd->chanlist[0]);
689  for (i = 1; i < cmd->chanlist_len; i++) {
690  if (CR_CHAN(cmd->chanlist[i]) !=
691  (startChan + i) % N_CHAN_AI) {
692  comedi_error(dev,
693  "entries in chanlist must be consecutive channels, counting upwards\n");
694  err++;
695  }
696  if (CR_RANGE(cmd->chanlist[i]) != gain) {
697  comedi_error(dev,
698  "entries in chanlist must all have the same gain\n");
699  err++;
700  }
701  }
702  }
703 
704  if (err)
705  return 5;
706 
707  return 0;
708 }
709 
710 static int das800_ai_do_cmd(struct comedi_device *dev,
711  struct comedi_subdevice *s)
712 {
713  int startChan, endChan, scan, gain;
714  int conv_bits;
715  unsigned long irq_flags;
716  struct comedi_async *async = s->async;
717 
718  if (!dev->irq) {
719  comedi_error(dev,
720  "no irq assigned for das-800, cannot do hardware conversions");
721  return -1;
722  }
723 
724  disable_das800(dev);
725 
726  /* set channel scan limits */
727  startChan = CR_CHAN(async->cmd.chanlist[0]);
728  endChan = (startChan + async->cmd.chanlist_len - 1) % 8;
729  scan = (endChan << 3) | startChan;
730 
731  spin_lock_irqsave(&dev->spinlock, irq_flags);
732  outb(SCAN_LIMITS, dev->iobase + DAS800_GAIN); /* select base address + 2 to be scan limits register */
733  outb(scan, dev->iobase + DAS800_SCAN_LIMITS); /* set scan limits */
734  spin_unlock_irqrestore(&dev->spinlock, irq_flags);
735 
736  /* set gain */
737  gain = CR_RANGE(async->cmd.chanlist[0]);
738  if (thisboard->resolution == 12 && gain > 0)
739  gain += 0x7;
740  gain &= 0xf;
741  outb(gain, dev->iobase + DAS800_GAIN);
742 
743  switch (async->cmd.stop_src) {
744  case TRIG_COUNT:
745  devpriv->count = async->cmd.stop_arg * async->cmd.chanlist_len;
746  devpriv->forever = 0;
747  break;
748  case TRIG_NONE:
749  devpriv->forever = 1;
750  devpriv->count = 0;
751  break;
752  default:
753  break;
754  }
755 
756  /* enable auto channel scan, send interrupts on end of conversion
757  * and set clock source to internal or external
758  */
759  conv_bits = 0;
760  conv_bits |= EACS | IEOC;
761  if (async->cmd.start_src == TRIG_EXT)
762  conv_bits |= DTEN;
763  switch (async->cmd.convert_src) {
764  case TRIG_TIMER:
765  conv_bits |= CASC | ITE;
766  /* set conversion frequency */
767  i8253_cascade_ns_to_timer_2div(TIMER_BASE, &(devpriv->divisor1),
768  &(devpriv->divisor2),
769  &(async->cmd.convert_arg),
770  async->cmd.
771  flags & TRIG_ROUND_MASK);
772  if (das800_set_frequency(dev) < 0) {
773  comedi_error(dev, "Error setting up counters");
774  return -1;
775  }
776  break;
777  case TRIG_EXT:
778  break;
779  default:
780  break;
781  }
782 
783  spin_lock_irqsave(&dev->spinlock, irq_flags);
784  outb(CONV_CONTROL, dev->iobase + DAS800_GAIN); /* select dev->iobase + 2 to be conversion control register */
785  outb(conv_bits, dev->iobase + DAS800_CONV_CONTROL);
786  spin_unlock_irqrestore(&dev->spinlock, irq_flags);
787  async->events = 0;
788  enable_das800(dev);
789  return 0;
790 }
791 
792 static int das800_ai_rinsn(struct comedi_device *dev,
793  struct comedi_subdevice *s, struct comedi_insn *insn,
794  unsigned int *data)
795 {
796  int i, n;
797  int chan;
798  int range;
799  int lsb, msb;
800  int timeout = 1000;
801  unsigned long irq_flags;
802 
803  disable_das800(dev); /* disable hardware conversions (enables software conversions) */
804 
805  /* set multiplexer */
806  chan = CR_CHAN(insn->chanspec);
807 
808  spin_lock_irqsave(&dev->spinlock, irq_flags);
809  outb(CONTROL1, dev->iobase + DAS800_GAIN); /* select dev->iobase + 2 to be control register 1 */
810  outb(chan | devpriv->do_bits, dev->iobase + DAS800_CONTROL1);
811  spin_unlock_irqrestore(&dev->spinlock, irq_flags);
812 
813  /* set gain / range */
814  range = CR_RANGE(insn->chanspec);
815  if (thisboard->resolution == 12 && range)
816  range += 0x7;
817  range &= 0xf;
818  outb(range, dev->iobase + DAS800_GAIN);
819 
820  udelay(5);
821 
822  for (n = 0; n < insn->n; n++) {
823  /* trigger conversion */
824  outb_p(0, dev->iobase + DAS800_MSB);
825 
826  for (i = 0; i < timeout; i++) {
827  if (!(inb(dev->iobase + DAS800_STATUS) & BUSY))
828  break;
829  }
830  if (i == timeout) {
831  comedi_error(dev, "timeout");
832  return -ETIME;
833  }
834  lsb = inb(dev->iobase + DAS800_LSB);
835  msb = inb(dev->iobase + DAS800_MSB);
836  if (thisboard->resolution == 12) {
837  data[n] = (lsb >> 4) & 0xff;
838  data[n] |= (msb << 4);
839  } else {
840  data[n] = (msb << 8) | lsb;
841  }
842  }
843 
844  return n;
845 }
846 
847 static int das800_di_rbits(struct comedi_device *dev,
848  struct comedi_subdevice *s, struct comedi_insn *insn,
849  unsigned int *data)
850 {
851  unsigned int bits;
852 
853  bits = inb(dev->iobase + DAS800_STATUS) >> 4;
854  bits &= 0x7;
855  data[1] = bits;
856  data[0] = 0;
857 
858  return insn->n;
859 }
860 
861 static int das800_do_wbits(struct comedi_device *dev,
862  struct comedi_subdevice *s, struct comedi_insn *insn,
863  unsigned int *data)
864 {
865  int wbits;
866  unsigned long irq_flags;
867 
868  /* only set bits that have been masked */
869  data[0] &= 0xf;
870  wbits = devpriv->do_bits >> 4;
871  wbits &= ~data[0];
872  wbits |= data[0] & data[1];
873  devpriv->do_bits = wbits << 4;
874 
875  spin_lock_irqsave(&dev->spinlock, irq_flags);
876  outb(CONTROL1, dev->iobase + DAS800_GAIN); /* select dev->iobase + 2 to be control register 1 */
877  outb(devpriv->do_bits | CONTROL1_INTE, dev->iobase + DAS800_CONTROL1);
878  spin_unlock_irqrestore(&dev->spinlock, irq_flags);
879 
880  data[1] = wbits;
881 
882  return insn->n;
883 }
884 
885 /* loads counters with divisor1, divisor2 from private structure */
886 static int das800_set_frequency(struct comedi_device *dev)
887 {
888  int err = 0;
889 
890  if (i8254_load(dev->iobase + DAS800_8254, 0, 1, devpriv->divisor1, 2))
891  err++;
892  if (i8254_load(dev->iobase + DAS800_8254, 0, 2, devpriv->divisor2, 2))
893  err++;
894  if (err)
895  return -1;
896 
897  return 0;
898 }
899 
900 MODULE_AUTHOR("Comedi http://www.comedi.org");
901 MODULE_DESCRIPTION("Comedi low-level driver");
902 MODULE_LICENSE("GPL");
Generated on Thu Jan 10 2013 14:26:55 for Linux Kernel by   doxygen 1.8.2