projects / deliverable / linux.git / blob
? search:


06de25bb2f56fc3e7fa821945a39bfaf0def21ff
[deliverable/linux.git] / drivers / staging / comedi / drivers / ni_at_a2150.c
1 /*
2 comedi/drivers/ni_at_a2150.c
3 Driver for National Instruments AT-A2150 boards
4 Copyright (C) 2001, 2002 Frank Mori Hess <fmhess@users.sourceforge.net>
5
6 COMEDI - Linux Control and Measurement Device Interface
7 Copyright (C) 2000 David A. Schleef <ds@schleef.org>
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: ni_at_a2150
27 Description: National Instruments AT-A2150
28 Author: Frank Mori Hess
29 Status: works
30 Devices: [National Instruments] AT-A2150C (at_a2150c), AT-2150S (at_a2150s)
31
32 If you want to ac couple the board's inputs, use AREF_OTHER.
33
34 Configuration options:
35 [0] - I/O port base address
36 [1] - IRQ (optional, required for timed conversions)
37 [2] - DMA (optional, required for timed conversions)
38
39 */
40 /*
41 Yet another driver for obsolete hardware brought to you by Frank Hess.
42 Testing and debugging help provided by Dave Andruczyk.
43
44 This driver supports the boards:
45
46 AT-A2150C
47 AT-A2150S
48
49 The only difference is their master clock frequencies.
50
51 Options:
52 [0] - base io address
53 [1] - irq
54 [2] - dma channel
55
56 References (from ftp://ftp.natinst.com/support/manuals):
57
58 320360.pdf AT-A2150 User Manual
59
60 TODO:
61
62 analog level triggering
63 TRIG_WAKE_EOS
64
65 */
66
67 #include <linux/interrupt.h>
68 #include <linux/slab.h>
69 #include "../comedidev.h"
70
71 #include <linux/ioport.h>
72 #include <linux/io.h>
73 #include <asm/dma.h>
74
75 #include "8253.h"
76 #include "comedi_fc.h"
77
78 #define A2150_SIZE 28
79 #define A2150_DMA_BUFFER_SIZE 0xff00 /* size in bytes of dma buffer */
80
81 /* #define A2150_DEBUG enable debugging code */
82 #undef A2150_DEBUG /* disable debugging code */
83
84 /* Registers and bits */
85 #define CONFIG_REG 0x0
86 #define CHANNEL_BITS(x) ((x) & 0x7)
87 #define CHANNEL_MASK 0x7
88 #define CLOCK_SELECT_BITS(x) (((x) & 0x3) << 3)
89 #define CLOCK_DIVISOR_BITS(x) (((x) & 0x3) << 5)
90 #define CLOCK_MASK (0xf << 3)
91 #define ENABLE0_BIT 0x80 /* enable (don't internally ground) channels 0 and 1 */
92 #define ENABLE1_BIT 0x100 /* enable (don't internally ground) channels 2 and 3 */
93 #define AC0_BIT 0x200 /* ac couple channels 0,1 */
94 #define AC1_BIT 0x400 /* ac couple channels 2,3 */
95 #define APD_BIT 0x800 /* analog power down */
96 #define DPD_BIT 0x1000 /* digital power down */
97 #define TRIGGER_REG 0x2 /* trigger config register */
98 #define POST_TRIGGER_BITS 0x2
99 #define DELAY_TRIGGER_BITS 0x3
100 #define HW_TRIG_EN 0x10 /* enable hardware trigger */
101 #define FIFO_START_REG 0x6 /* software start aquistion trigger */
102 #define FIFO_RESET_REG 0x8 /* clears fifo + fifo flags */
103 #define FIFO_DATA_REG 0xa /* read data */
104 #define DMA_TC_CLEAR_REG 0xe /* clear dma terminal count interrupt */
105 #define STATUS_REG 0x12 /* read only */
106 #define FNE_BIT 0x1 /* fifo not empty */
107 #define OVFL_BIT 0x8 /* fifo overflow */
108 #define EDAQ_BIT 0x10 /* end of acquisition interrupt */
109 #define DCAL_BIT 0x20 /* offset calibration in progress */
110 #define INTR_BIT 0x40 /* interrupt has occurred */
111 #define DMA_TC_BIT 0x80 /* dma terminal count interrupt has occurred */
112 #define ID_BITS(x) (((x) >> 8) & 0x3)
113 #define IRQ_DMA_CNTRL_REG 0x12 /* write only */
114 #define DMA_CHAN_BITS(x) ((x) & 0x7) /* sets dma channel */
115 #define DMA_EN_BIT 0x8 /* enables dma */
116 #define IRQ_LVL_BITS(x) (((x) & 0xf) << 4) /* sets irq level */
117 #define FIFO_INTR_EN_BIT 0x100 /* enable fifo interrupts */
118 #define FIFO_INTR_FHF_BIT 0x200 /* interrupt fifo half full */
119 #define DMA_INTR_EN_BIT 0x800 /* enable interrupt on dma terminal count */
120 #define DMA_DEM_EN_BIT 0x1000 /* enables demand mode dma */
121 #define I8253_BASE_REG 0x14
122 #define I8253_MODE_REG 0x17
123 #define HW_COUNT_DISABLE 0x30 /* disable hardware counting of conversions */
124
125 struct a2150_board {
126 const char *name;
127 int clock[4]; /* master clock periods, in nanoseconds */
128 int num_clocks; /* number of available master clock speeds */
129 int ai_speed; /* maximum conversion rate in nanoseconds */
130 };
131
132 /* analog input range */
133 static const struct comedi_lrange range_a2150 = {
134 1,
135 {
136 RANGE(-2.828, 2.828),
137 }
138 };
139
140 /* enum must match board indices */
141 enum { a2150_c, a2150_s };
142 static const struct a2150_board a2150_boards[] = {
143 {
144 .name = "at-a2150c",
145 .clock = {31250, 22676, 20833, 19531},
146 .num_clocks = 4,
147 .ai_speed = 19531,
148 },
149 {
150 .name = "at-a2150s",
151 .clock = {62500, 50000, 41667, 0},
152 .num_clocks = 3,
153 .ai_speed = 41667,
154 },
155 };
156
157 /*
158 * Useful for shorthand access to the particular board structure
159 */
160 #define thisboard ((const struct a2150_board *)dev->board_ptr)
161
162 struct a2150_private {
163
164 volatile unsigned int count; /* number of data points left to be taken */
165 unsigned int dma; /* dma channel */
166 s16 *dma_buffer; /* dma buffer */
167 unsigned int dma_transfer_size; /* size in bytes of dma transfers */
168 int irq_dma_bits; /* irq/dma register bits */
169 int config_bits; /* config register bits */
170 };
171
172 static int a2150_cancel(struct comedi_device *dev, struct comedi_subdevice *s);
173
174 static int a2150_get_timing(struct comedi_device *dev, unsigned int *period,
175 int flags);
176 static int a2150_set_chanlist(struct comedi_device *dev,
177 unsigned int start_channel,
178 unsigned int num_channels);
179 #ifdef A2150_DEBUG
180
181 static void ni_dump_regs(struct comedi_device *dev)
182 {
183 struct a2150_private *devpriv = dev->private;
184
185 printk("config bits 0x%x\n", devpriv->config_bits);
186 printk("irq dma bits 0x%x\n", devpriv->irq_dma_bits);
187 printk("status bits 0x%x\n", inw(dev->iobase + STATUS_REG));
188 }
189
190 #endif
191
192 /* interrupt service routine */
193 static irqreturn_t a2150_interrupt(int irq, void *d)
194 {
195 int i;
196 int status;
197 unsigned long flags;
198 struct comedi_device *dev = d;
199 struct a2150_private *devpriv = dev->private;
200 struct comedi_subdevice *s = dev->read_subdev;
201 struct comedi_async *async;
202 struct comedi_cmd *cmd;
203 unsigned int max_points, num_points, residue, leftover;
204 short dpnt;
205 static const int sample_size = sizeof(devpriv->dma_buffer[0]);
206
207 if (dev->attached == 0) {
208 comedi_error(dev, "premature interrupt");
209 return IRQ_HANDLED;
210 }
211 /* initialize async here to make sure s is not NULL */
212 async = s->async;
213 async->events = 0;
214 cmd = &async->cmd;
215
216 status = inw(dev->iobase + STATUS_REG);
217
218 if ((status & INTR_BIT) == 0) {
219 comedi_error(dev, "spurious interrupt");
220 return IRQ_NONE;
221 }
222
223 if (status & OVFL_BIT) {
224 comedi_error(dev, "fifo overflow");
225 a2150_cancel(dev, s);
226 async->events |= COMEDI_CB_ERROR | COMEDI_CB_EOA;
227 }
228
229 if ((status & DMA_TC_BIT) == 0) {
230 comedi_error(dev, "caught non-dma interrupt? Aborting.");
231 a2150_cancel(dev, s);
232 async->events |= COMEDI_CB_ERROR | COMEDI_CB_EOA;
233 comedi_event(dev, s);
234 return IRQ_HANDLED;
235 }
236
237 flags = claim_dma_lock();
238 disable_dma(devpriv->dma);
239 /* clear flip-flop to make sure 2-byte registers for
240 * count and address get set correctly */
241 clear_dma_ff(devpriv->dma);
242
243 /* figure out how many points to read */
244 max_points = devpriv->dma_transfer_size / sample_size;
245 /* residue is the number of points left to be done on the dma
246 * transfer. It should always be zero at this point unless
247 * the stop_src is set to external triggering.
248 */
249 residue = get_dma_residue(devpriv->dma) / sample_size;
250 num_points = max_points - residue;
251 if (devpriv->count < num_points && cmd->stop_src == TRIG_COUNT)
252 num_points = devpriv->count;
253
254 /* figure out how many points will be stored next time */
255 leftover = 0;
256 if (cmd->stop_src == TRIG_NONE) {
257 leftover = devpriv->dma_transfer_size / sample_size;
258 } else if (devpriv->count > max_points) {
259 leftover = devpriv->count - max_points;
260 if (leftover > max_points)
261 leftover = max_points;
262 }
263 /* there should only be a residue if collection was stopped by having
264 * the stop_src set to an external trigger, in which case there
265 * will be no more data
266 */
267 if (residue)
268 leftover = 0;
269
270 for (i = 0; i < num_points; i++) {
271 /* write data point to comedi buffer */
272 dpnt = devpriv->dma_buffer[i];
273 /* convert from 2's complement to unsigned coding */
274 dpnt ^= 0x8000;
275 cfc_write_to_buffer(s, dpnt);
276 if (cmd->stop_src == TRIG_COUNT) {
277 if (--devpriv->count == 0) { /* end of acquisition */
278 a2150_cancel(dev, s);
279 async->events |= COMEDI_CB_EOA;
280 break;
281 }
282 }
283 }
284 /* re-enable dma */
285 if (leftover) {
286 set_dma_addr(devpriv->dma, virt_to_bus(devpriv->dma_buffer));
287 set_dma_count(devpriv->dma, leftover * sample_size);
288 enable_dma(devpriv->dma);
289 }
290 release_dma_lock(flags);
291
292 async->events |= COMEDI_CB_BLOCK;
293
294 comedi_event(dev, s);
295
296 /* clear interrupt */
297 outw(0x00, dev->iobase + DMA_TC_CLEAR_REG);
298
299 return IRQ_HANDLED;
300 }
301
302 static int a2150_cancel(struct comedi_device *dev, struct comedi_subdevice *s)
303 {
304 struct a2150_private *devpriv = dev->private;
305
306 /* disable dma on card */
307 devpriv->irq_dma_bits &= ~DMA_INTR_EN_BIT & ~DMA_EN_BIT;
308 outw(devpriv->irq_dma_bits, dev->iobase + IRQ_DMA_CNTRL_REG);
309
310 /* disable computer's dma */
311 disable_dma(devpriv->dma);
312
313 /* clear fifo and reset triggering circuitry */
314 outw(0, dev->iobase + FIFO_RESET_REG);
315
316 return 0;
317 }
318
319 static int a2150_ai_cmdtest(struct comedi_device *dev,
320 struct comedi_subdevice *s, struct comedi_cmd *cmd)
321 {
322 int err = 0;
323 int tmp;
324 int startChan;
325 int i;
326
327 /* Step 1 : check if triggers are trivially valid */
328
329 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_EXT);
330 err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_TIMER);
331 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW);
332 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
333 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
334
335 if (err)
336 return 1;
337
338 /* Step 2a : make sure trigger sources are unique */
339
340 err |= cfc_check_trigger_is_unique(cmd->start_src);
341 err |= cfc_check_trigger_is_unique(cmd->stop_src);
342
343 /* Step 2b : and mutually compatible */
344
345 if (err)
346 return 2;
347
348 /* Step 3: check if arguments are trivially valid */
349
350 err |= cfc_check_trigger_arg_is(&cmd->start_arg, 0);
351
352 if (cmd->convert_src == TRIG_TIMER)
353 err |= cfc_check_trigger_arg_min(&cmd->convert_arg,
354 thisboard->ai_speed);
355
356 err |= cfc_check_trigger_arg_min(&cmd->chanlist_len, 1);
357 err |= cfc_check_trigger_arg_is(&cmd->scan_end_arg, cmd->chanlist_len);
358
359 if (cmd->stop_src == TRIG_COUNT)
360 err |= cfc_check_trigger_arg_min(&cmd->stop_arg, 1);
361 else /* TRIG_NONE */
362 err |= cfc_check_trigger_arg_is(&cmd->stop_arg, 0);
363
364 if (err)
365 return 3;
366
367 /* step 4: fix up any arguments */
368
369 if (cmd->scan_begin_src == TRIG_TIMER) {
370 tmp = cmd->scan_begin_arg;
371 a2150_get_timing(dev, &cmd->scan_begin_arg, cmd->flags);
372 if (tmp != cmd->scan_begin_arg)
373 err++;
374 }
375
376 if (err)
377 return 4;
378
379 /* check channel/gain list against card's limitations */
380 if (cmd->chanlist) {
381 startChan = CR_CHAN(cmd->chanlist[0]);
382 for (i = 1; i < cmd->chanlist_len; i++) {
383 if (CR_CHAN(cmd->chanlist[i]) != (startChan + i)) {
384 comedi_error(dev,
385 "entries in chanlist must be consecutive channels, counting upwards\n");
386 err++;
387 }
388 }
389 if (cmd->chanlist_len == 2 && CR_CHAN(cmd->chanlist[0]) == 1) {
390 comedi_error(dev,
391 "length 2 chanlist must be channels 0,1 or channels 2,3");
392 err++;
393 }
394 if (cmd->chanlist_len == 3) {
395 comedi_error(dev,
396 "chanlist must have 1,2 or 4 channels");
397 err++;
398 }
399 if (CR_AREF(cmd->chanlist[0]) != CR_AREF(cmd->chanlist[1]) ||
400 CR_AREF(cmd->chanlist[2]) != CR_AREF(cmd->chanlist[3])) {
401 comedi_error(dev,
402 "channels 0/1 and 2/3 must have the same analog reference");
403 err++;
404 }
405 }
406
407 if (err)
408 return 5;
409
410 return 0;
411 }
412
413 static int a2150_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
414 {
415 struct a2150_private *devpriv = dev->private;
416 struct comedi_async *async = s->async;
417 struct comedi_cmd *cmd = &async->cmd;
418 unsigned long lock_flags;
419 unsigned int old_config_bits = devpriv->config_bits;
420 unsigned int trigger_bits;
421
422 if (!dev->irq || !devpriv->dma) {
423 comedi_error(dev,
424 " irq and dma required, cannot do hardware conversions");
425 return -1;
426 }
427 if (cmd->flags & TRIG_RT) {
428 comedi_error(dev,
429 " dma incompatible with hard real-time interrupt (TRIG_RT), aborting");
430 return -1;
431 }
432 /* clear fifo and reset triggering circuitry */
433 outw(0, dev->iobase + FIFO_RESET_REG);
434
435 /* setup chanlist */
436 if (a2150_set_chanlist(dev, CR_CHAN(cmd->chanlist[0]),
437 cmd->chanlist_len) < 0)
438 return -1;
439
440 /* setup ac/dc coupling */
441 if (CR_AREF(cmd->chanlist[0]) == AREF_OTHER)
442 devpriv->config_bits |= AC0_BIT;
443 else
444 devpriv->config_bits &= ~AC0_BIT;
445 if (CR_AREF(cmd->chanlist[2]) == AREF_OTHER)
446 devpriv->config_bits |= AC1_BIT;
447 else
448 devpriv->config_bits &= ~AC1_BIT;
449
450 /* setup timing */
451 a2150_get_timing(dev, &cmd->scan_begin_arg, cmd->flags);
452
453 /* send timing, channel, config bits */
454 outw(devpriv->config_bits, dev->iobase + CONFIG_REG);
455
456 /* initialize number of samples remaining */
457 devpriv->count = cmd->stop_arg * cmd->chanlist_len;
458
459 /* enable computer's dma */
460 lock_flags = claim_dma_lock();
461 disable_dma(devpriv->dma);
462 /* clear flip-flop to make sure 2-byte registers for
463 * count and address get set correctly */
464 clear_dma_ff(devpriv->dma);
465 set_dma_addr(devpriv->dma, virt_to_bus(devpriv->dma_buffer));
466 /* set size of transfer to fill in 1/3 second */
467 #define ONE_THIRD_SECOND 333333333
468 devpriv->dma_transfer_size =
469 sizeof(devpriv->dma_buffer[0]) * cmd->chanlist_len *
470 ONE_THIRD_SECOND / cmd->scan_begin_arg;
471 if (devpriv->dma_transfer_size > A2150_DMA_BUFFER_SIZE)
472 devpriv->dma_transfer_size = A2150_DMA_BUFFER_SIZE;
473 if (devpriv->dma_transfer_size < sizeof(devpriv->dma_buffer[0]))
474 devpriv->dma_transfer_size = sizeof(devpriv->dma_buffer[0]);
475 devpriv->dma_transfer_size -=
476 devpriv->dma_transfer_size % sizeof(devpriv->dma_buffer[0]);
477 set_dma_count(devpriv->dma, devpriv->dma_transfer_size);
478 enable_dma(devpriv->dma);
479 release_dma_lock(lock_flags);
480
481 /* clear dma interrupt before enabling it, to try and get rid of that
482 * one spurious interrupt that has been happening */
483 outw(0x00, dev->iobase + DMA_TC_CLEAR_REG);
484
485 /* enable dma on card */
486 devpriv->irq_dma_bits |= DMA_INTR_EN_BIT | DMA_EN_BIT;
487 outw(devpriv->irq_dma_bits, dev->iobase + IRQ_DMA_CNTRL_REG);
488
489 /* may need to wait 72 sampling periods if timing was changed */
490 i8254_load(dev->iobase + I8253_BASE_REG, 0, 2, 72, 0);
491
492 /* setup start triggering */
493 trigger_bits = 0;
494 /* decide if we need to wait 72 periods for valid data */
495 if (cmd->start_src == TRIG_NOW &&
496 (old_config_bits & CLOCK_MASK) !=
497 (devpriv->config_bits & CLOCK_MASK)) {
498 /* set trigger source to delay trigger */
499 trigger_bits |= DELAY_TRIGGER_BITS;
500 } else {
501 /* otherwise no delay */
502 trigger_bits |= POST_TRIGGER_BITS;
503 }
504 /* enable external hardware trigger */
505 if (cmd->start_src == TRIG_EXT) {
506 trigger_bits |= HW_TRIG_EN;
507 } else if (cmd->start_src == TRIG_OTHER) {
508 /* XXX add support for level/slope start trigger using TRIG_OTHER */
509 comedi_error(dev, "you shouldn't see this?");
510 }
511 /* send trigger config bits */
512 outw(trigger_bits, dev->iobase + TRIGGER_REG);
513
514 /* start acquisition for soft trigger */
515 if (cmd->start_src == TRIG_NOW)
516 outw(0, dev->iobase + FIFO_START_REG);
517 #ifdef A2150_DEBUG
518 ni_dump_regs(dev);
519 #endif
520
521 return 0;
522 }
523
524 static int a2150_ai_rinsn(struct comedi_device *dev, struct comedi_subdevice *s,
525 struct comedi_insn *insn, unsigned int *data)
526 {
527 struct a2150_private *devpriv = dev->private;
528 unsigned int i, n;
529 static const int timeout = 100000;
530 static const int filter_delay = 36;
531
532 /* clear fifo and reset triggering circuitry */
533 outw(0, dev->iobase + FIFO_RESET_REG);
534
535 /* setup chanlist */
536 if (a2150_set_chanlist(dev, CR_CHAN(insn->chanspec), 1) < 0)
537 return -1;
538
539 /* set dc coupling */
540 devpriv->config_bits &= ~AC0_BIT;
541 devpriv->config_bits &= ~AC1_BIT;
542
543 /* send timing, channel, config bits */
544 outw(devpriv->config_bits, dev->iobase + CONFIG_REG);
545
546 /* disable dma on card */
547 devpriv->irq_dma_bits &= ~DMA_INTR_EN_BIT & ~DMA_EN_BIT;
548 outw(devpriv->irq_dma_bits, dev->iobase + IRQ_DMA_CNTRL_REG);
549
550 /* setup start triggering */
551 outw(0, dev->iobase + TRIGGER_REG);
552
553 /* start acquisition for soft trigger */
554 outw(0, dev->iobase + FIFO_START_REG);
555
556 /*
557 * there is a 35.6 sample delay for data to get through the
558 * antialias filter
559 */
560 for (n = 0; n < filter_delay; n++) {
561 for (i = 0; i < timeout; i++) {
562 if (inw(dev->iobase + STATUS_REG) & FNE_BIT)
563 break;
564 udelay(1);
565 }
566 if (i == timeout) {
567 comedi_error(dev, "timeout");
568 return -ETIME;
569 }
570 inw(dev->iobase + FIFO_DATA_REG);
571 }
572
573 /* read data */
574 for (n = 0; n < insn->n; n++) {
575 for (i = 0; i < timeout; i++) {
576 if (inw(dev->iobase + STATUS_REG) & FNE_BIT)
577 break;
578 udelay(1);
579 }
580 if (i == timeout) {
581 comedi_error(dev, "timeout");
582 return -ETIME;
583 }
584 #ifdef A2150_DEBUG
585 ni_dump_regs(dev);
586 #endif
587 data[n] = inw(dev->iobase + FIFO_DATA_REG);
588 #ifdef A2150_DEBUG
589 printk(" data is %i\n", data[n]);
590 #endif
591 data[n] ^= 0x8000;
592 }
593
594 /* clear fifo and reset triggering circuitry */
595 outw(0, dev->iobase + FIFO_RESET_REG);
596
597 return n;
598 }
599
600 /*
601 * sets bits in devpriv->clock_bits to nearest approximation of requested
602 * period, adjusts requested period to actual timing.
603 */
604 static int a2150_get_timing(struct comedi_device *dev, unsigned int *period,
605 int flags)
606 {
607 struct a2150_private *devpriv = dev->private;
608 int lub, glb, temp;
609 int lub_divisor_shift, lub_index, glb_divisor_shift, glb_index;
610 int i, j;
611
612 /* initialize greatest lower and least upper bounds */
613 lub_divisor_shift = 3;
614 lub_index = 0;
615 lub = thisboard->clock[lub_index] * (1 << lub_divisor_shift);
616 glb_divisor_shift = 0;
617 glb_index = thisboard->num_clocks - 1;
618 glb = thisboard->clock[glb_index] * (1 << glb_divisor_shift);
619
620 /* make sure period is in available range */
621 if (*period < glb)
622 *period = glb;
623 if (*period > lub)
624 *period = lub;
625
626 /* we can multiply period by 1, 2, 4, or 8, using (1 << i) */
627 for (i = 0; i < 4; i++) {
628 /* there are a maximum of 4 master clocks */
629 for (j = 0; j < thisboard->num_clocks; j++) {
630 /* temp is the period in nanosec we are evaluating */
631 temp = thisboard->clock[j] * (1 << i);
632 /* if it is the best match yet */
633 if (temp < lub && temp >= *period) {
634 lub_divisor_shift = i;
635 lub_index = j;
636 lub = temp;
637 }
638 if (temp > glb && temp <= *period) {
639 glb_divisor_shift = i;
640 glb_index = j;
641 glb = temp;
642 }
643 }
644 }
645 flags &= TRIG_ROUND_MASK;
646 switch (flags) {
647 case TRIG_ROUND_NEAREST:
648 default:
649 /* if least upper bound is better approximation */
650 if (lub - *period < *period - glb)
651 *period = lub;
652 else
653 *period = glb;
654 break;
655 case TRIG_ROUND_UP:
656 *period = lub;
657 break;
658 case TRIG_ROUND_DOWN:
659 *period = glb;
660 break;
661 }
662
663 /* set clock bits for config register appropriately */
664 devpriv->config_bits &= ~CLOCK_MASK;
665 if (*period == lub) {
666 devpriv->config_bits |=
667 CLOCK_SELECT_BITS(lub_index) |
668 CLOCK_DIVISOR_BITS(lub_divisor_shift);
669 } else {
670 devpriv->config_bits |=
671 CLOCK_SELECT_BITS(glb_index) |
672 CLOCK_DIVISOR_BITS(glb_divisor_shift);
673 }
674
675 return 0;
676 }
677
678 static int a2150_set_chanlist(struct comedi_device *dev,
679 unsigned int start_channel,
680 unsigned int num_channels)
681 {
682 struct a2150_private *devpriv = dev->private;
683
684 if (start_channel + num_channels > 4)
685 return -1;
686
687 devpriv->config_bits &= ~CHANNEL_MASK;
688
689 switch (num_channels) {
690 case 1:
691 devpriv->config_bits |= CHANNEL_BITS(0x4 | start_channel);
692 break;
693 case 2:
694 if (start_channel == 0) {
695 devpriv->config_bits |= CHANNEL_BITS(0x2);
696 } else if (start_channel == 2) {
697 devpriv->config_bits |= CHANNEL_BITS(0x3);
698 } else {
699 return -1;
700 }
701 break;
702 case 4:
703 devpriv->config_bits |= CHANNEL_BITS(0x1);
704 break;
705 default:
706 return -1;
707 break;
708 }
709
710 return 0;
711 }
712
713 /* probes board type, returns offset */
714 static int a2150_probe(struct comedi_device *dev)
715 {
716 int status = inw(dev->iobase + STATUS_REG);
717 return ID_BITS(status);
718 }
719
720 static int a2150_attach(struct comedi_device *dev, struct comedi_devconfig *it)
721 {
722 struct a2150_private *devpriv;
723 struct comedi_subdevice *s;
724 unsigned long iobase = it->options[0];
725 unsigned int irq = it->options[1];
726 unsigned int dma = it->options[2];
727 static const int timeout = 2000;
728 int i;
729 int ret;
730
731 printk("comedi%d: %s: io 0x%lx", dev->minor, dev->driver->driver_name,
732 iobase);
733 if (irq) {
734 printk(", irq %u", irq);
735 } else {
736 printk(", no irq");
737 }
738 if (dma) {
739 printk(", dma %u", dma);
740 } else {
741 printk(", no dma");
742 }
743 printk("\n");
744
745 devpriv = kzalloc(sizeof(*devpriv), GFP_KERNEL);
746 if (!devpriv)
747 return -ENOMEM;
748 dev->private = devpriv;
749
750 if (iobase == 0) {
751 printk(" io base address required\n");
752 return -EINVAL;
753 }
754
755 /* check if io addresses are available */
756 if (!request_region(iobase, A2150_SIZE, dev->driver->driver_name)) {
757 printk(" I/O port conflict\n");
758 return -EIO;
759 }
760 dev->iobase = iobase;
761
762 /* grab our IRQ */
763 if (irq) {
764 /* check that irq is supported */
765 if (irq < 3 || irq == 8 || irq == 13 || irq > 15) {
766 printk(" invalid irq line %u\n", irq);
767 return -EINVAL;
768 }
769 if (request_irq(irq, a2150_interrupt, 0,
770 dev->driver->driver_name, dev)) {
771 printk("unable to allocate irq %u\n", irq);
772 return -EINVAL;
773 }
774 devpriv->irq_dma_bits |= IRQ_LVL_BITS(irq);
775 dev->irq = irq;
776 }
777 /* initialize dma */
778 if (dma) {
779 if (dma == 4 || dma > 7) {
780 printk(" invalid dma channel %u\n", dma);
781 return -EINVAL;
782 }
783 if (request_dma(dma, dev->driver->driver_name)) {
784 printk(" failed to allocate dma channel %u\n", dma);
785 return -EINVAL;
786 }
787 devpriv->dma = dma;
788 devpriv->dma_buffer =
789 kmalloc(A2150_DMA_BUFFER_SIZE, GFP_KERNEL | GFP_DMA);
790 if (devpriv->dma_buffer == NULL)
791 return -ENOMEM;
792
793 disable_dma(dma);
794 set_dma_mode(dma, DMA_MODE_READ);
795
796 devpriv->irq_dma_bits |= DMA_CHAN_BITS(dma);
797 }
798
799 dev->board_ptr = a2150_boards + a2150_probe(dev);
800 dev->board_name = thisboard->name;
801
802 ret = comedi_alloc_subdevices(dev, 1);
803 if (ret)
804 return ret;
805
806 /* analog input subdevice */
807 s = &dev->subdevices[0];
808 dev->read_subdev = s;
809 s->type = COMEDI_SUBD_AI;
810 s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_OTHER | SDF_CMD_READ;
811 s->n_chan = 4;
812 s->len_chanlist = 4;
813 s->maxdata = 0xffff;
814 s->range_table = &range_a2150;
815 s->do_cmd = a2150_ai_cmd;
816 s->do_cmdtest = a2150_ai_cmdtest;
817 s->insn_read = a2150_ai_rinsn;
818 s->cancel = a2150_cancel;
819
820 /* need to do this for software counting of completed conversions, to
821 * prevent hardware count from stopping acquisition */
822 outw(HW_COUNT_DISABLE, dev->iobase + I8253_MODE_REG);
823
824 /* set card's irq and dma levels */
825 outw(devpriv->irq_dma_bits, dev->iobase + IRQ_DMA_CNTRL_REG);
826
827 /* reset and sync adc clock circuitry */
828 outw_p(DPD_BIT | APD_BIT, dev->iobase + CONFIG_REG);
829 outw_p(DPD_BIT, dev->iobase + CONFIG_REG);
830 /* initialize configuration register */
831 devpriv->config_bits = 0;
832 outw(devpriv->config_bits, dev->iobase + CONFIG_REG);
833 /* wait until offset calibration is done, then enable analog inputs */
834 for (i = 0; i < timeout; i++) {
835 if ((DCAL_BIT & inw(dev->iobase + STATUS_REG)) == 0)
836 break;
837 udelay(1000);
838 }
839 if (i == timeout) {
840 printk
841 (" timed out waiting for offset calibration to complete\n");
842 return -ETIME;
843 }
844 devpriv->config_bits |= ENABLE0_BIT | ENABLE1_BIT;
845 outw(devpriv->config_bits, dev->iobase + CONFIG_REG);
846
847 return 0;
848 };
849
850 static void a2150_detach(struct comedi_device *dev)
851 {
852 struct a2150_private *devpriv = dev->private;
853
854 if (dev->iobase) {
855 outw(APD_BIT | DPD_BIT, dev->iobase + CONFIG_REG);
856 release_region(dev->iobase, A2150_SIZE);
857 }
858 if (dev->irq)
859 free_irq(dev->irq, dev);
860 if (devpriv) {
861 if (devpriv->dma)
862 free_dma(devpriv->dma);
863 kfree(devpriv->dma_buffer);
864 }
865 };
866
867 static struct comedi_driver ni_at_a2150_driver = {
868 .driver_name = "ni_at_a2150",
869 .module = THIS_MODULE,
870 .attach = a2150_attach,
871 .detach = a2150_detach,
872 };
873 module_comedi_driver(ni_at_a2150_driver);
874
875 MODULE_AUTHOR("Comedi http://www.comedi.org");
876 MODULE_DESCRIPTION("Comedi low-level driver");
877 MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.063622 seconds and 4 git commands to generate.