?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Staging: comedi: add #include <linux/io.h> to a bunch of drivers
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / staging / comedi / drivers / adl_pci9118.c
blobf17654e44aefd390fd9b7bea9f1fa79f3ed0c7b1
1 /*
2 * comedi/drivers/adl_pci9118.c
3 *
4 * hardware driver for ADLink cards:
5 * card: PCI-9118DG, PCI-9118HG, PCI-9118HR
6 * driver: pci9118dg, pci9118hg, pci9118hr
7 *
8 * Author: Michal Dobes <dobes@tesnet.cz>
9 *
10 */
11 /*
12 Driver: adl_pci9118
13 Description: Adlink PCI-9118DG, PCI-9118HG, PCI-9118HR
14 Author: Michal Dobes <dobes@tesnet.cz>
15 Devices: [ADLink] PCI-9118DG (pci9118dg), PCI-9118HG (pci9118hg),
16 PCI-9118HR (pci9118hr)
17 Status: works
18
19 This driver supports AI, AO, DI and DO subdevices.
20 AI subdevice supports cmd and insn interface,
21 other subdevices support only insn interface.
22 For AI:
23 - If cmd->scan_begin_src=TRIG_EXT then trigger input is TGIN (pin 46).
24 - If cmd->convert_src=TRIG_EXT then trigger input is EXTTRG (pin 44).
25 - If cmd->start_src/stop_src=TRIG_EXT then trigger input is TGIN (pin 46).
26 - It is not necessary to have cmd.scan_end_arg=cmd.chanlist_len but
27 cmd.scan_end_arg modulo cmd.chanlist_len must by 0.
28 - If return value of cmdtest is 5 then you've bad channel list
29 (it isn't possible mixture S.E. and DIFF inputs or bipolar and unipolar
30 ranges).
31
32 There are some hardware limitations:
33 a) You cann't use mixture of unipolar/bipoar ranges or differencial/single
34 ended inputs.
35 b) DMA transfers must have the length aligned to two samples (32 bit),
36 so there is some problems if cmd->chanlist_len is odd. This driver tries
37 bypass this with adding one sample to the end of the every scan and discard
38 it on output but this cann't be used if cmd->scan_begin_src=TRIG_FOLLOW
39 and is used flag TRIG_WAKE_EOS, then driver switch to interrupt driven mode
40 with interrupt after every sample.
41 c) If isn't used DMA then you can use only mode where
42 cmd->scan_begin_src=TRIG_FOLLOW.
43
44 Configuration options:
45 [0] - PCI bus of device (optional)
46 [1] - PCI slot of device (optional)
47 If bus/slot is not specified, then first available PCI
48 card will be used.
49 [2] - 0= standard 8 DIFF/16 SE channels configuration
50 n = external multiplexer connected, 1 <= n <= 256
51 [3] - 0=autoselect DMA or EOC interrupts operation
52 1 = disable DMA mode
53 3 = disable DMA and INT, only insn interface will work
54 [4] - sample&hold signal - card can generate signal for external S&H board
55 0 = use SSHO(pin 45) signal is generated in onboard hardware S&H logic
56 0 != use ADCHN7(pin 23) signal is generated from driver, number say how
57 long delay is requested in ns and sign polarity of the hold
58 (in this case external multiplexor can serve only 128 channels)
59 [5] - 0=stop measure on all hardware errors
60 2 | = ignore ADOR - A/D Overrun status
61 8|=ignore Bover - A/D Burst Mode Overrun status
62 256|=ignore nFull - A/D FIFO Full status
63
64 */
65 #include "../comedidev.h"
66
67 #include <linux/delay.h>
68 #include <linux/gfp.h>
69 #include <linux/interrupt.h>
70 #include <linux/io.h>
71
72 #include "amcc_s5933.h"
73 #include "8253.h"
74 #include "comedi_pci.h"
75 #include "comedi_fc.h"
76
77 #define PCI_VENDOR_ID_AMCC 0x10e8
78
79 /* paranoid checks are broken */
80 #undef PCI9118_PARANOIDCHECK /*
81 * if defined, then is used code which control
82 * correct channel number on every 12 bit sample
83 */
84
85 #undef PCI9118_EXTDEBUG /*
86 * if defined then driver prints
87 * a lot of messages
88 */
89
90 #undef DPRINTK
91 #ifdef PCI9118_EXTDEBUG
92 #define DPRINTK(fmt, args...) printk(fmt, ## args)
93 #else
94 #define DPRINTK(fmt, args...)
95 #endif
96
97 #define IORANGE_9118 64 /* I hope */
98 #define PCI9118_CHANLEN 255 /*
99 * len of chanlist, some source say 256,
100 * but reality looks like 255 :-(
101 */
102
103 #define PCI9118_CNT0 0x00 /* R/W: 8254 counter 0 */
104 #define PCI9118_CNT1 0x04 /* R/W: 8254 counter 0 */
105 #define PCI9118_CNT2 0x08 /* R/W: 8254 counter 0 */
106 #define PCI9118_CNTCTRL 0x0c /* W: 8254 counter control */
107 #define PCI9118_AD_DATA 0x10 /* R: A/D data */
108 #define PCI9118_DA1 0x10 /* W: D/A registers */
109 #define PCI9118_DA2 0x14
110 #define PCI9118_ADSTAT 0x18 /* R: A/D status register */
111 #define PCI9118_ADCNTRL 0x18 /* W: A/D control register */
112 #define PCI9118_DI 0x1c /* R: digi input register */
113 #define PCI9118_DO 0x1c /* W: digi output register */
114 #define PCI9118_SOFTTRG 0x20 /* W: soft trigger for A/D */
115 #define PCI9118_GAIN 0x24 /* W: A/D gain/channel register */
116 #define PCI9118_BURST 0x28 /* W: A/D burst number register */
117 #define PCI9118_SCANMOD 0x2c /* W: A/D auto scan mode */
118 #define PCI9118_ADFUNC 0x30 /* W: A/D function register */
119 #define PCI9118_DELFIFO 0x34 /* W: A/D data FIFO reset */
120 #define PCI9118_INTSRC 0x38 /* R: interrupt reason register */
121 #define PCI9118_INTCTRL 0x38 /* W: interrupt control register */
122
123 /* bits from A/D control register (PCI9118_ADCNTRL) */
124 #define AdControl_UniP 0x80 /* 1=bipolar, 0=unipolar */
125 #define AdControl_Diff 0x40 /* 1=differential, 0= single end inputs */
126 #define AdControl_SoftG 0x20 /* 1=8254 counter works, 0=counter stops */
127 #define AdControl_ExtG 0x10 /*
128 * 1=8254 countrol controlled by TGIN(pin 46),
129 * 0=controlled by SoftG
130 */
131 #define AdControl_ExtM 0x08 /*
132 * 1=external hardware trigger (pin 44),
133 * 0=internal trigger
134 */
135 #define AdControl_TmrTr 0x04 /*
136 * 1=8254 is iternal trigger source,
137 * 0=software trigger is source
138 * (register PCI9118_SOFTTRG)
139 */
140 #define AdControl_Int 0x02 /* 1=enable INT, 0=disable */
141 #define AdControl_Dma 0x01 /* 1=enable DMA, 0=disable */
142
143 /* bits from A/D function register (PCI9118_ADFUNC) */
144 #define AdFunction_PDTrg 0x80 /*
145 * 1=positive,
146 * 0=negative digital trigger
147 * (only positive is correct)
148 */
149 #define AdFunction_PETrg 0x40 /*
150 * 1=positive,
151 * 0=negative external trigger
152 * (only positive is correct)
153 */
154 #define AdFunction_BSSH 0x20 /* 1=with sample&hold, 0=without */
155 #define AdFunction_BM 0x10 /* 1=burst mode, 0=normal mode */
156 #define AdFunction_BS 0x08 /*
157 * 1=burst mode start,
158 * 0=burst mode stop
159 */
160 #define AdFunction_PM 0x04 /*
161 * 1=post trigger mode,
162 * 0=not post trigger
163 */
164 #define AdFunction_AM 0x02 /*
165 * 1=about trigger mode,
166 * 0=not about trigger
167 */
168 #define AdFunction_Start 0x01 /* 1=trigger start, 0=trigger stop */
169
170 /* bits from A/D status register (PCI9118_ADSTAT) */
171 #define AdStatus_nFull 0x100 /* 0=FIFO full (fatal), 1=not full */
172 #define AdStatus_nHfull 0x080 /* 0=FIFO half full, 1=FIFO not half full */
173 #define AdStatus_nEpty 0x040 /* 0=FIFO empty, 1=FIFO not empty */
174 #define AdStatus_Acmp 0x020 /* */
175 #define AdStatus_DTH 0x010 /* 1=external digital trigger */
176 #define AdStatus_Bover 0x008 /* 1=burst mode overrun (fatal) */
177 #define AdStatus_ADOS 0x004 /* 1=A/D over speed (warning) */
178 #define AdStatus_ADOR 0x002 /* 1=A/D overrun (fatal) */
179 #define AdStatus_ADrdy 0x001 /* 1=A/D already ready, 0=not ready */
180
181 /* bits for interrupt reason and control (PCI9118_INTSRC, PCI9118_INTCTRL) */
182 /* 1=interrupt occur, enable source, 0=interrupt not occur, disable source */
183 #define Int_Timer 0x08 /* timer interrupt */
184 #define Int_About 0x04 /* about trigger complete */
185 #define Int_Hfull 0x02 /* A/D FIFO hlaf full */
186 #define Int_DTrg 0x01 /* external digital trigger */
187
188 #define START_AI_EXT 0x01 /* start measure on external trigger */
189 #define STOP_AI_EXT 0x02 /* stop measure on external trigger */
190 #define START_AI_INT 0x04 /* start measure on internal trigger */
191 #define STOP_AI_INT 0x08 /* stop measure on internal trigger */
192
193 #define EXTTRG_AI 0 /* ext trg is used by AI */
194
195 static const struct comedi_lrange range_pci9118dg_hr = { 8, {
196 BIP_RANGE(5),
197 BIP_RANGE(2.5),
198 BIP_RANGE(1.25),
199 BIP_RANGE(0.625),
200 UNI_RANGE(10),
201 UNI_RANGE(5),
202 UNI_RANGE(2.5),
203 UNI_RANGE(1.25)
204 }
205 };
206
207 static const struct comedi_lrange range_pci9118hg = { 8, {
208 BIP_RANGE(5),
209 BIP_RANGE(0.5),
210 BIP_RANGE(0.05),
211 BIP_RANGE(0.005),
212 UNI_RANGE(10),
213 UNI_RANGE(1),
214 UNI_RANGE(0.1),
215 UNI_RANGE(0.01)
216 }
217 };
218
219 #define PCI9118_BIPOLAR_RANGES 4 /*
220 * used for test on mixture
221 * of BIP/UNI ranges
222 */
223
224 static int pci9118_attach(struct comedi_device *dev,
225 struct comedi_devconfig *it);
226 static int pci9118_detach(struct comedi_device *dev);
227
228 struct boardtype {
229 const char *name; /* board name */
230 int vendor_id; /* PCI vendor a device ID of card */
231 int device_id;
232 int iorange_amcc; /* iorange for own S5933 region */
233 int iorange_9118; /* pass thru card region size */
234 int n_aichan; /* num of A/D chans */
235 int n_aichand; /* num of A/D chans in diff mode */
236 int mux_aichan; /*
237 * num of A/D chans with
238 * external multiplexor
239 */
240 int n_aichanlist; /* len of chanlist */
241 int n_aochan; /* num of D/A chans */
242 int ai_maxdata; /* resolution of A/D */
243 int ao_maxdata; /* resolution of D/A */
244 const struct comedi_lrange *rangelist_ai; /* rangelist for A/D */
245 const struct comedi_lrange *rangelist_ao; /* rangelist for D/A */
246 unsigned int ai_ns_min; /* max sample speed of card v ns */
247 unsigned int ai_pacer_min; /*
248 * minimal pacer value
249 * (c1*c2 or c1 in burst)
250 */
251 int half_fifo_size; /* size of FIFO/2 */
252
253 };
254
255 static DEFINE_PCI_DEVICE_TABLE(pci9118_pci_table) = {
256 { PCI_DEVICE(PCI_VENDOR_ID_AMCC, 0x80d9) },
257 { 0 }
258 };
259
260 MODULE_DEVICE_TABLE(pci, pci9118_pci_table);
261
262 static const struct boardtype boardtypes[] = {
263 {"pci9118dg", PCI_VENDOR_ID_AMCC, 0x80d9,
264 AMCC_OP_REG_SIZE, IORANGE_9118,
265 16, 8, 256, PCI9118_CHANLEN, 2, 0x0fff, 0x0fff,
266 &range_pci9118dg_hr, &range_bipolar10,
267 3000, 12, 512},
268 {"pci9118hg", PCI_VENDOR_ID_AMCC, 0x80d9,
269 AMCC_OP_REG_SIZE, IORANGE_9118,
270 16, 8, 256, PCI9118_CHANLEN, 2, 0x0fff, 0x0fff,
271 &range_pci9118hg, &range_bipolar10,
272 3000, 12, 512},
273 {"pci9118hr", PCI_VENDOR_ID_AMCC, 0x80d9,
274 AMCC_OP_REG_SIZE, IORANGE_9118,
275 16, 8, 256, PCI9118_CHANLEN, 2, 0xffff, 0x0fff,
276 &range_pci9118dg_hr, &range_bipolar10,
277 10000, 40, 512},
278 };
279
280 #define n_boardtypes (sizeof(boardtypes)/sizeof(struct boardtype))
281
282 static struct comedi_driver driver_pci9118 = {
283 .driver_name = "adl_pci9118",
284 .module = THIS_MODULE,
285 .attach = pci9118_attach,
286 .detach = pci9118_detach,
287 .num_names = n_boardtypes,
288 .board_name = &boardtypes[0].name,
289 .offset = sizeof(struct boardtype),
290 };
291
292 static int __devinit driver_pci9118_pci_probe(struct pci_dev *dev,
293 const struct pci_device_id *ent)
294 {
295 return comedi_pci_auto_config(dev, driver_pci9118.driver_name);
296 }
297
298 static void __devexit driver_pci9118_pci_remove(struct pci_dev *dev)
299 {
300 comedi_pci_auto_unconfig(dev);
301 }
302
303 static struct pci_driver driver_pci9118_pci_driver = {
304 .id_table = pci9118_pci_table,
305 .probe = &driver_pci9118_pci_probe,
306 .remove = __devexit_p(&driver_pci9118_pci_remove)
307 };
308
309 static int __init driver_pci9118_init_module(void)
310 {
311 int retval;
312
313 retval = comedi_driver_register(&driver_pci9118);
314 if (retval < 0)
315 return retval;
316
317 driver_pci9118_pci_driver.name = (char *)driver_pci9118.driver_name;
318 return pci_register_driver(&driver_pci9118_pci_driver);
319 }
320
321 static void __exit driver_pci9118_cleanup_module(void)
322 {
323 pci_unregister_driver(&driver_pci9118_pci_driver);
324 comedi_driver_unregister(&driver_pci9118);
325 }
326
327 module_init(driver_pci9118_init_module);
328 module_exit(driver_pci9118_cleanup_module);
329
330 struct pci9118_private {
331 unsigned long iobase_a; /* base+size for AMCC chip */
332 unsigned int master; /* master capable */
333 struct pci_dev *pcidev; /* ptr to actual pcidev */
334 unsigned int usemux; /* we want to use external multiplexor! */
335 #ifdef PCI9118_PARANOIDCHECK
336 unsigned short chanlist[PCI9118_CHANLEN + 1]; /*
337 * list of
338 * scanned channel
339 */
340 unsigned char chanlistlen; /* number of scanlist */
341 #endif
342 unsigned char AdControlReg; /* A/D control register */
343 unsigned char IntControlReg; /* Interrupt control register */
344 unsigned char AdFunctionReg; /* A/D function register */
345 char valid; /* driver is ok */
346 char ai_neverending; /* we do unlimited AI */
347 unsigned int i8254_osc_base; /* frequence of onboard oscilator */
348 unsigned int ai_do; /* what do AI? 0=nothing, 1 to 4 mode */
349 unsigned int ai_act_scan; /* how many scans we finished */
350 unsigned int ai_buf_ptr; /* data buffer ptr in samples */
351 unsigned int ai_n_chan; /* how many channels is measured */
352 unsigned int ai_n_scanlen; /* len of actual scanlist */
353 unsigned int ai_n_realscanlen; /*
354 * what we must transfer for one
355 * outgoing scan include front/back adds
356 */
357 unsigned int ai_act_dmapos; /* position in actual real stream */
358 unsigned int ai_add_front; /*
359 * how many channels we must add
360 * before scan to satisfy S&H?
361 */
362 unsigned int ai_add_back; /*
363 * how many channels we must add
364 * before scan to satisfy DMA?
365 */
366 unsigned int *ai_chanlist; /* actual chanlist */
367 unsigned int ai_timer1;
368 unsigned int ai_timer2;
369 unsigned int ai_flags;
370 char ai12_startstop; /*
371 * measure can start/stop
372 * on external trigger
373 */
374 unsigned int ai_divisor1, ai_divisor2; /*
375 * divisors for start of measure
376 * on external start
377 */
378 unsigned int ai_data_len;
379 short *ai_data;
380 short ao_data[2]; /* data output buffer */
381 unsigned int ai_scans; /* number of scans to do */
382 char dma_doublebuf; /* we can use double buffring */
383 unsigned int dma_actbuf; /* which buffer is used now */
384 short *dmabuf_virt[2]; /*
385 * pointers to begin of
386 * DMA buffer
387 */
388 unsigned long dmabuf_hw[2]; /* hw address of DMA buff */
389 unsigned int dmabuf_size[2]; /*
390 * size of dma buffer in bytes
391 */
392 unsigned int dmabuf_use_size[2]; /*
393 * which size we may now use
394 * for transfer
395 */
396 unsigned int dmabuf_used_size[2]; /* which size was truly used */
397 unsigned int dmabuf_panic_size[2];
398 unsigned int dmabuf_samples[2]; /* size in samples */
399 int dmabuf_pages[2]; /* number of pages in buffer */
400 unsigned char cnt0_users; /*
401 * bit field of 8254 CNT0 users
402 * (0-unused, 1-AO, 2-DI, 3-DO)
403 */
404 unsigned char exttrg_users; /*
405 * bit field of external trigger
406 * users(0-AI, 1-AO, 2-DI, 3-DO)
407 */
408 unsigned int cnt0_divisor; /* actual CNT0 divisor */
409 void (*int_ai_func) (struct comedi_device *, struct comedi_subdevice *,
410 unsigned short,
411 unsigned int,
412 unsigned short); /*
413 * ptr to actual interrupt
414 * AI function
415 */
416 unsigned char ai16bits; /* =1 16 bit card */
417 unsigned char usedma; /* =1 use DMA transfer and not INT */
418 unsigned char useeoshandle; /*
419 * =1 change WAKE_EOS DMA transfer
420 * to fit on every second
421 */
422 unsigned char usessh; /* =1 turn on S&H support */
423 int softsshdelay; /*
424 * >0 use software S&H,
425 * numer is requested delay in ns
426 */
427 unsigned char softsshsample; /*
428 * polarity of S&H signal
429 * in sample state
430 */
431 unsigned char softsshhold; /*
432 * polarity of S&H signal
433 * in hold state
434 */
435 unsigned int ai_maskerr; /* which warning was printed */
436 unsigned int ai_maskharderr; /* on which error bits stops */
437 unsigned int ai_inttrig_start; /* TRIG_INT for start */
438 };
439
440 #define devpriv ((struct pci9118_private *)dev->private)
441 #define this_board ((struct boardtype *)dev->board_ptr)
442
443 /*
444 ==============================================================================
445 */
446
447 static int check_channel_list(struct comedi_device *dev,
448 struct comedi_subdevice *s, int n_chan,
449 unsigned int *chanlist, int frontadd,
450 int backadd);
451 static int setup_channel_list(struct comedi_device *dev,
452 struct comedi_subdevice *s, int n_chan,
453 unsigned int *chanlist, int rot, int frontadd,
454 int backadd, int usedma, char eoshandle);
455 static void start_pacer(struct comedi_device *dev, int mode,
456 unsigned int divisor1, unsigned int divisor2);
457 static int pci9118_reset(struct comedi_device *dev);
458 static int pci9118_exttrg_add(struct comedi_device *dev, unsigned char source);
459 static int pci9118_exttrg_del(struct comedi_device *dev, unsigned char source);
460 static int pci9118_ai_cancel(struct comedi_device *dev,
461 struct comedi_subdevice *s);
462 static void pci9118_calc_divisors(char mode, struct comedi_device *dev,
463 struct comedi_subdevice *s,
464 unsigned int *tim1, unsigned int *tim2,
465 unsigned int flags, int chans,
466 unsigned int *div1, unsigned int *div2,
467 char usessh, unsigned int chnsshfront);
468
469 /*
470 ==============================================================================
471 */
472 static int pci9118_insn_read_ai(struct comedi_device *dev,
473 struct comedi_subdevice *s,
474 struct comedi_insn *insn, unsigned int *data)
475 {
476
477 int n, timeout;
478
479 devpriv->AdControlReg = AdControl_Int & 0xff;
480 devpriv->AdFunctionReg = AdFunction_PDTrg | AdFunction_PETrg;
481 outl(devpriv->AdFunctionReg, dev->iobase + PCI9118_ADFUNC);
482 /*
483 * positive triggers, no S&H,
484 * no burst, burst stop,
485 * no post trigger,
486 * no about trigger,
487 * trigger stop
488 */
489
490 if (!setup_channel_list(dev, s, 1, &insn->chanspec, 0, 0, 0, 0, 0))
491 return -EINVAL;
492
493 outl(0, dev->iobase + PCI9118_DELFIFO); /* flush FIFO */
494
495 for (n = 0; n < insn->n; n++) {
496 outw(0, dev->iobase + PCI9118_SOFTTRG); /* start conversion */
497 udelay(2);
498 timeout = 100;
499 while (timeout--) {
500 if (inl(dev->iobase + PCI9118_ADSTAT) & AdStatus_ADrdy)
501 goto conv_finish;
502 udelay(1);
503 }
504
505 comedi_error(dev, "A/D insn timeout");
506 data[n] = 0;
507 outl(0, dev->iobase + PCI9118_DELFIFO); /* flush FIFO */
508 return -ETIME;
509
510 conv_finish:
511 if (devpriv->ai16bits) {
512 data[n] =
513 (inl(dev->iobase +
514 PCI9118_AD_DATA) & 0xffff) ^ 0x8000;
515 } else {
516 data[n] =
517 (inw(dev->iobase + PCI9118_AD_DATA) >> 4) & 0xfff;
518 }
519 }
520
521 outl(0, dev->iobase + PCI9118_DELFIFO); /* flush FIFO */
522 return n;
523
524 }
525
526 /*
527 ==============================================================================
528 */
529 static int pci9118_insn_write_ao(struct comedi_device *dev,
530 struct comedi_subdevice *s,
531 struct comedi_insn *insn, unsigned int *data)
532 {
533 int n, chanreg, ch;
534
535 ch = CR_CHAN(insn->chanspec);
536 if (ch)
537 chanreg = PCI9118_DA2;
538 else
539 chanreg = PCI9118_DA1;
540
541
542 for (n = 0; n < insn->n; n++) {
543 outl(data[n], dev->iobase + chanreg);
544 devpriv->ao_data[ch] = data[n];
545 }
546
547 return n;
548 }
549
550 /*
551 ==============================================================================
552 */
553 static int pci9118_insn_read_ao(struct comedi_device *dev,
554 struct comedi_subdevice *s,
555 struct comedi_insn *insn, unsigned int *data)
556 {
557 int n, chan;
558
559 chan = CR_CHAN(insn->chanspec);
560 for (n = 0; n < insn->n; n++)
561 data[n] = devpriv->ao_data[chan];
562
563 return n;
564 }
565
566 /*
567 ==============================================================================
568 */
569 static int pci9118_insn_bits_di(struct comedi_device *dev,
570 struct comedi_subdevice *s,
571 struct comedi_insn *insn, unsigned int *data)
572 {
573 data[1] = inl(dev->iobase + PCI9118_DI) & 0xf;
574
575 return 2;
576 }
577
578 /*
579 ==============================================================================
580 */
581 static int pci9118_insn_bits_do(struct comedi_device *dev,
582 struct comedi_subdevice *s,
583 struct comedi_insn *insn, unsigned int *data)
584 {
585 if (data[0]) {
586 s->state &= ~data[0];
587 s->state |= (data[0] & data[1]);
588 outl(s->state & 0x0f, dev->iobase + PCI9118_DO);
589 }
590 data[1] = s->state;
591
592 return 2;
593 }
594
595 /*
596 ==============================================================================
597 */
598 static void interrupt_pci9118_ai_mode4_switch(struct comedi_device *dev)
599 {
600 devpriv->AdFunctionReg =
601 AdFunction_PDTrg | AdFunction_PETrg | AdFunction_AM;
602 outl(devpriv->AdFunctionReg, dev->iobase + PCI9118_ADFUNC);
603 outl(0x30, dev->iobase + PCI9118_CNTCTRL);
604 outl((devpriv->dmabuf_hw[1 - devpriv->dma_actbuf] >> 1) & 0xff,
605 dev->iobase + PCI9118_CNT0);
606 outl((devpriv->dmabuf_hw[1 - devpriv->dma_actbuf] >> 9) & 0xff,
607 dev->iobase + PCI9118_CNT0);
608 devpriv->AdFunctionReg |= AdFunction_Start;
609 outl(devpriv->AdFunctionReg, dev->iobase + PCI9118_ADFUNC);
610 }
611
612 static unsigned int defragment_dma_buffer(struct comedi_device *dev,
613 struct comedi_subdevice *s,
614 short *dma_buffer,
615 unsigned int num_samples)
616 {
617 unsigned int i = 0, j = 0;
618 unsigned int start_pos = devpriv->ai_add_front,
619 stop_pos = devpriv->ai_add_front + devpriv->ai_n_chan;
620 unsigned int raw_scanlen = devpriv->ai_add_front + devpriv->ai_n_chan +
621 devpriv->ai_add_back;
622
623 for (i = 0; i < num_samples; i++) {
624 if (devpriv->ai_act_dmapos >= start_pos &&
625 devpriv->ai_act_dmapos < stop_pos) {
626 dma_buffer[j++] = dma_buffer[i];
627 }
628 devpriv->ai_act_dmapos++;
629 devpriv->ai_act_dmapos %= raw_scanlen;
630 }
631
632 return j;
633 }
634
635 /*
636 ==============================================================================
637 */
638 static int move_block_from_dma(struct comedi_device *dev,
639 struct comedi_subdevice *s,
640 short *dma_buffer,
641 unsigned int num_samples)
642 {
643 unsigned int num_bytes;
644
645 num_samples = defragment_dma_buffer(dev, s, dma_buffer, num_samples);
646 devpriv->ai_act_scan +=
647 (s->async->cur_chan + num_samples) / devpriv->ai_n_scanlen;
648 s->async->cur_chan += num_samples;
649 s->async->cur_chan %= devpriv->ai_n_scanlen;
650 num_bytes =
651 cfc_write_array_to_buffer(s, dma_buffer,
652 num_samples * sizeof(short));
653 if (num_bytes < num_samples * sizeof(short))
654 return -1;
655 return 0;
656 }
657
658 /*
659 ==============================================================================
660 */
661 static char pci9118_decode_error_status(struct comedi_device *dev,
662 struct comedi_subdevice *s,
663 unsigned char m)
664 {
665 if (m & 0x100) {
666 comedi_error(dev, "A/D FIFO Full status (Fatal Error!)");
667 devpriv->ai_maskerr &= ~0x100L;
668 }
669 if (m & 0x008) {
670 comedi_error(dev,
671 "A/D Burst Mode Overrun Status (Fatal Error!)");
672 devpriv->ai_maskerr &= ~0x008L;
673 }
674 if (m & 0x004) {
675 comedi_error(dev, "A/D Over Speed Status (Warning!)");
676 devpriv->ai_maskerr &= ~0x004L;
677 }
678 if (m & 0x002) {
679 comedi_error(dev, "A/D Overrun Status (Fatal Error!)");
680 devpriv->ai_maskerr &= ~0x002L;
681 }
682 if (m & devpriv->ai_maskharderr) {
683 s->async->events |= COMEDI_CB_ERROR | COMEDI_CB_EOA;
684 pci9118_ai_cancel(dev, s);
685 comedi_event(dev, s);
686 return 1;
687 }
688
689 return 0;
690 }
691
692 static void pci9118_ai_munge(struct comedi_device *dev,
693 struct comedi_subdevice *s, void *data,
694 unsigned int num_bytes,
695 unsigned int start_chan_index)
696 {
697 unsigned int i, num_samples = num_bytes / sizeof(short);
698 short *array = data;
699
700 for (i = 0; i < num_samples; i++) {
701 if (devpriv->usedma)
702 array[i] = be16_to_cpu(array[i]);
703 if (devpriv->ai16bits)
704 array[i] ^= 0x8000;
705 else
706 array[i] = (array[i] >> 4) & 0x0fff;
707
708 }
709 }
710
711 /*
712 ==============================================================================
713 */
714 static void interrupt_pci9118_ai_onesample(struct comedi_device *dev,
715 struct comedi_subdevice *s,
716 unsigned short int_adstat,
717 unsigned int int_amcc,
718 unsigned short int_daq)
719 {
720 register short sampl;
721
722 s->async->events = 0;
723
724 if (int_adstat & devpriv->ai_maskerr)
725 if (pci9118_decode_error_status(dev, s, int_adstat))
726 return;
727
728 sampl = inw(dev->iobase + PCI9118_AD_DATA);
729
730 #ifdef PCI9118_PARANOIDCHECK
731 if (devpriv->ai16bits == 0) {
732 if ((sampl & 0x000f) != devpriv->chanlist[s->async->cur_chan]) {
733 /* data dropout! */
734 printk
735 ("comedi: A/D SAMPL - data dropout: "
736 "received channel %d, expected %d!\n",
737 sampl & 0x000f,
738 devpriv->chanlist[s->async->cur_chan]);
739 s->async->events |= COMEDI_CB_ERROR | COMEDI_CB_EOA;
740 pci9118_ai_cancel(dev, s);
741 comedi_event(dev, s);
742 return;
743 }
744 }
745 #endif
746 cfc_write_to_buffer(s, sampl);
747 s->async->cur_chan++;
748 if (s->async->cur_chan >= devpriv->ai_n_scanlen) {
749 /* one scan done */
750 s->async->cur_chan %= devpriv->ai_n_scanlen;
751 devpriv->ai_act_scan++;
752 if (!(devpriv->ai_neverending))
753 if (devpriv->ai_act_scan >= devpriv->ai_scans) {
754 /* all data sampled */
755 pci9118_ai_cancel(dev, s);
756 s->async->events |= COMEDI_CB_EOA;
757 }
758 }
759
760 if (s->async->events)
761 comedi_event(dev, s);
762 }
763
764 /*
765 ==============================================================================
766 */
767 static void interrupt_pci9118_ai_dma(struct comedi_device *dev,
768 struct comedi_subdevice *s,
769 unsigned short int_adstat,
770 unsigned int int_amcc,
771 unsigned short int_daq)
772 {
773 unsigned int next_dma_buf, samplesinbuf, sampls, m;
774
775 if (int_amcc & MASTER_ABORT_INT) {
776 comedi_error(dev, "AMCC IRQ - MASTER DMA ABORT!");
777 s->async->events |= COMEDI_CB_ERROR | COMEDI_CB_EOA;
778 pci9118_ai_cancel(dev, s);
779 comedi_event(dev, s);
780 return;
781 }
782
783 if (int_amcc & TARGET_ABORT_INT) {
784 comedi_error(dev, "AMCC IRQ - TARGET DMA ABORT!");
785 s->async->events |= COMEDI_CB_ERROR | COMEDI_CB_EOA;
786 pci9118_ai_cancel(dev, s);
787 comedi_event(dev, s);
788 return;
789 }
790 if (int_adstat & devpriv->ai_maskerr)
791 /* if (int_adstat & 0x106) */
792 if (pci9118_decode_error_status(dev, s, int_adstat))
793 return;
794
795 samplesinbuf = devpriv->dmabuf_use_size[devpriv->dma_actbuf] >> 1;
796 /* number of received real samples */
797 /* DPRINTK("dma_actbuf=%d\n",devpriv->dma_actbuf); */
798
799 if (devpriv->dma_doublebuf) { /*
800 * switch DMA buffers if is used
801 * double buffering
802 */
803 next_dma_buf = 1 - devpriv->dma_actbuf;
804 outl(devpriv->dmabuf_hw[next_dma_buf],
805 devpriv->iobase_a + AMCC_OP_REG_MWAR);
806 outl(devpriv->dmabuf_use_size[next_dma_buf],
807 devpriv->iobase_a + AMCC_OP_REG_MWTC);
808 devpriv->dmabuf_used_size[next_dma_buf] =
809 devpriv->dmabuf_use_size[next_dma_buf];
810 if (devpriv->ai_do == 4)
811 interrupt_pci9118_ai_mode4_switch(dev);
812 }
813
814 if (samplesinbuf) {
815 m = devpriv->ai_data_len >> 1; /*
816 * how many samples is to
817 * end of buffer
818 */
819 /*
820 * DPRINTK("samps=%d m=%d %d %d\n",
821 * samplesinbuf,m,s->async->buf_int_count,s->async->buf_int_ptr);
822 */
823 sampls = m;
824 move_block_from_dma(dev, s,
825 devpriv->dmabuf_virt[devpriv->dma_actbuf],
826 samplesinbuf);
827 m = m - sampls; /* m= how many samples was transferred */
828 }
829 /* DPRINTK("YYY\n"); */
830
831 if (!devpriv->ai_neverending)
832 if (devpriv->ai_act_scan >= devpriv->ai_scans) {
833 /* all data sampled */
834 pci9118_ai_cancel(dev, s);
835 s->async->events |= COMEDI_CB_EOA;
836 }
837
838 if (devpriv->dma_doublebuf) { /* switch dma buffers */
839 devpriv->dma_actbuf = 1 - devpriv->dma_actbuf;
840 } else { /* restart DMA if is not used double buffering */
841 outl(devpriv->dmabuf_hw[0],
842 devpriv->iobase_a + AMCC_OP_REG_MWAR);
843 outl(devpriv->dmabuf_use_size[0],
844 devpriv->iobase_a + AMCC_OP_REG_MWTC);
845 if (devpriv->ai_do == 4)
846 interrupt_pci9118_ai_mode4_switch(dev);
847 }
848
849 comedi_event(dev, s);
850 }
851
852 /*
853 ==============================================================================
854 */
855 static irqreturn_t interrupt_pci9118(int irq, void *d)
856 {
857 struct comedi_device *dev = d;
858 unsigned int int_daq = 0, int_amcc, int_adstat;
859
860 if (!dev->attached)
861 return IRQ_NONE; /* not fully initialized */
862
863 int_daq = inl(dev->iobase + PCI9118_INTSRC) & 0xf;
864 /* get IRQ reasons from card */
865 int_amcc = inl(devpriv->iobase_a + AMCC_OP_REG_INTCSR);
866 /* get INT register from AMCC chip */
867
868 /*
869 * DPRINTK("INT daq=0x%01x amcc=0x%08x MWAR=0x%08x
870 * MWTC=0x%08x ADSTAT=0x%02x ai_do=%d\n",
871 * int_daq, int_amcc, inl(devpriv->iobase_a+AMCC_OP_REG_MWAR),
872 * inl(devpriv->iobase_a+AMCC_OP_REG_MWTC),
873 * inw(dev->iobase+PCI9118_ADSTAT)&0x1ff,devpriv->ai_do);
874 */
875
876 if ((!int_daq) && (!(int_amcc & ANY_S593X_INT)))
877 return IRQ_NONE; /* interrupt from other source */
878
879 outl(int_amcc | 0x00ff0000, devpriv->iobase_a + AMCC_OP_REG_INTCSR);
880 /* shutdown IRQ reasons in AMCC */
881
882 int_adstat = inw(dev->iobase + PCI9118_ADSTAT) & 0x1ff;
883 /* get STATUS register */
884
885 if (devpriv->ai_do) {
886 if (devpriv->ai12_startstop)
887 if ((int_adstat & AdStatus_DTH) &&
888 (int_daq & Int_DTrg)) {
889 /* start stop of measure */
890 if (devpriv->ai12_startstop & START_AI_EXT) {
891 devpriv->ai12_startstop &=
892 ~START_AI_EXT;
893 if (!(devpriv->ai12_startstop &
894 STOP_AI_EXT))
895 pci9118_exttrg_del
896 (dev, EXTTRG_AI);
897 /* deactivate EXT trigger */
898 start_pacer(dev, devpriv->ai_do,
899 devpriv->ai_divisor1,
900 devpriv->ai_divisor2);
901 /* start pacer */
902 outl(devpriv->AdControlReg,
903 dev->iobase + PCI9118_ADCNTRL);
904 } else {
905 if (devpriv->ai12_startstop &
906 STOP_AI_EXT) {
907 devpriv->ai12_startstop &=
908 ~STOP_AI_EXT;
909 pci9118_exttrg_del
910 (dev, EXTTRG_AI);
911 /* deactivate EXT trigger */
912 devpriv->ai_neverending = 0;
913 /*
914 * well, on next interrupt from
915 * DMA/EOC measure will stop
916 */
917 }
918 }
919 }
920
921 (devpriv->int_ai_func) (dev, dev->subdevices + 0, int_adstat,
922 int_amcc, int_daq);
923
924 }
925 return IRQ_HANDLED;
926 }
927
928 /*
929 ==============================================================================
930 */
931 static int pci9118_ai_inttrig(struct comedi_device *dev,
932 struct comedi_subdevice *s, unsigned int trignum)
933 {
934 if (trignum != devpriv->ai_inttrig_start)
935 return -EINVAL;
936
937 devpriv->ai12_startstop &= ~START_AI_INT;
938 s->async->inttrig = NULL;
939
940 outl(devpriv->IntControlReg, dev->iobase + PCI9118_INTCTRL);
941 outl(devpriv->AdFunctionReg, dev->iobase + PCI9118_ADFUNC);
942 if (devpriv->ai_do != 3) {
943 start_pacer(dev, devpriv->ai_do, devpriv->ai_divisor1,
944 devpriv->ai_divisor2);
945 devpriv->AdControlReg |= AdControl_SoftG;
946 }
947 outl(devpriv->AdControlReg, dev->iobase + PCI9118_ADCNTRL);
948
949 return 1;
950 }
951
952 /*
953 ==============================================================================
954 */
955 static int pci9118_ai_cmdtest(struct comedi_device *dev,
956 struct comedi_subdevice *s,
957 struct comedi_cmd *cmd)
958 {
959 int err = 0;
960 int tmp;
961 unsigned int divisor1 = 0, divisor2 = 0;
962
963 /* step 1: make sure trigger sources are trivially valid */
964
965 tmp = cmd->start_src;
966 cmd->start_src &= TRIG_NOW | TRIG_EXT | TRIG_INT;
967 if (!cmd->start_src || tmp != cmd->start_src)
968 err++;
969
970 tmp = cmd->scan_begin_src;
971 if (devpriv->master)
972 cmd->scan_begin_src &= TRIG_TIMER | TRIG_EXT | TRIG_FOLLOW;
973 else
974 cmd->scan_begin_src &= TRIG_FOLLOW;
975
976 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
977 err++;
978
979 tmp = cmd->convert_src;
980 if (devpriv->master)
981 cmd->convert_src &= TRIG_TIMER | TRIG_EXT | TRIG_NOW;
982 else
983 cmd->convert_src &= TRIG_TIMER | TRIG_EXT;
984
985 if (!cmd->convert_src || tmp != cmd->convert_src)
986 err++;
987
988 tmp = cmd->scan_end_src;
989 cmd->scan_end_src &= TRIG_COUNT;
990 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
991 err++;
992
993 tmp = cmd->stop_src;
994 cmd->stop_src &= TRIG_COUNT | TRIG_NONE | TRIG_EXT;
995 if (!cmd->stop_src || tmp != cmd->stop_src)
996 err++;
997
998 if (err)
999 return 1;
1000
1001 /*
1002 * step 2:
1003 * make sure trigger sources are
1004 * unique and mutually compatible
1005 */
1006
1007 if (cmd->start_src != TRIG_NOW &&
1008 cmd->start_src != TRIG_INT && cmd->start_src != TRIG_EXT) {
1009 cmd->start_src = TRIG_NOW;
1010 err++;
1011 }
1012
1013 if (cmd->scan_begin_src != TRIG_TIMER &&
1014 cmd->scan_begin_src != TRIG_EXT &&
1015 cmd->scan_begin_src != TRIG_INT &&
1016 cmd->scan_begin_src != TRIG_FOLLOW) {
1017 cmd->scan_begin_src = TRIG_FOLLOW;
1018 err++;
1019 }
1020
1021 if (cmd->convert_src != TRIG_TIMER &&
1022 cmd->convert_src != TRIG_EXT && cmd->convert_src != TRIG_NOW) {
1023 cmd->convert_src = TRIG_TIMER;
1024 err++;
1025 }
1026
1027 if (cmd->scan_end_src != TRIG_COUNT) {
1028 cmd->scan_end_src = TRIG_COUNT;
1029 err++;
1030 }
1031
1032 if (cmd->stop_src != TRIG_NONE &&
1033 cmd->stop_src != TRIG_COUNT &&
1034 cmd->stop_src != TRIG_INT && cmd->stop_src != TRIG_EXT) {
1035 cmd->stop_src = TRIG_COUNT;
1036 err++;
1037 }
1038
1039 if (cmd->start_src == TRIG_EXT && cmd->scan_begin_src == TRIG_EXT) {
1040 cmd->start_src = TRIG_NOW;
1041 err++;
1042 }
1043
1044 if (cmd->start_src == TRIG_INT && cmd->scan_begin_src == TRIG_INT) {
1045 cmd->start_src = TRIG_NOW;
1046 err++;
1047 }
1048
1049 if ((cmd->scan_begin_src & (TRIG_TIMER | TRIG_EXT)) &&
1050 (!(cmd->convert_src & (TRIG_TIMER | TRIG_NOW)))) {
1051 cmd->convert_src = TRIG_TIMER;
1052 err++;
1053 }
1054
1055 if ((cmd->scan_begin_src == TRIG_FOLLOW) &&
1056 (!(cmd->convert_src & (TRIG_TIMER | TRIG_EXT)))) {
1057 cmd->convert_src = TRIG_TIMER;
1058 err++;
1059 }
1060
1061 if (cmd->stop_src == TRIG_EXT && cmd->scan_begin_src == TRIG_EXT) {
1062 cmd->stop_src = TRIG_COUNT;
1063 err++;
1064 }
1065
1066 if (err)
1067 return 2;
1068
1069 /* step 3: make sure arguments are trivially compatible */
1070
1071 if (cmd->start_src & (TRIG_NOW | TRIG_EXT))
1072 if (cmd->start_arg != 0) {
1073 cmd->start_arg = 0;
1074 err++;
1075 }
1076
1077 if (cmd->scan_begin_src & (TRIG_FOLLOW | TRIG_EXT))
1078 if (cmd->scan_begin_arg != 0) {
1079 cmd->scan_begin_arg = 0;
1080 err++;
1081 }
1082
1083 if ((cmd->scan_begin_src == TRIG_TIMER) &&
1084 (cmd->convert_src == TRIG_TIMER) && (cmd->scan_end_arg == 1)) {
1085 cmd->scan_begin_src = TRIG_FOLLOW;
1086 cmd->convert_arg = cmd->scan_begin_arg;
1087 cmd->scan_begin_arg = 0;
1088 }
1089
1090 if (cmd->scan_begin_src == TRIG_TIMER)
1091 if (cmd->scan_begin_arg < this_board->ai_ns_min) {
1092 cmd->scan_begin_arg = this_board->ai_ns_min;
1093 err++;
1094 }
1095
1096 if (cmd->scan_begin_src == TRIG_EXT)
1097 if (cmd->scan_begin_arg) {
1098 cmd->scan_begin_arg = 0;
1099 err++;
1100 if (cmd->scan_end_arg > 65535) {
1101 cmd->scan_end_arg = 65535;
1102 err++;
1103 }
1104 }
1105
1106 if (cmd->convert_src & (TRIG_TIMER | TRIG_NOW))
1107 if (cmd->convert_arg < this_board->ai_ns_min) {
1108 cmd->convert_arg = this_board->ai_ns_min;
1109 err++;
1110 }
1111
1112 if (cmd->convert_src == TRIG_EXT)
1113 if (cmd->convert_arg) {
1114 cmd->convert_arg = 0;
1115 err++;
1116 }
1117
1118 if (cmd->stop_src == TRIG_COUNT) {
1119 if (!cmd->stop_arg) {
1120 cmd->stop_arg = 1;
1121 err++;
1122 }
1123 } else { /* TRIG_NONE */
1124 if (cmd->stop_arg != 0) {
1125 cmd->stop_arg = 0;
1126 err++;
1127 }
1128 }
1129
1130 if (!cmd->chanlist_len) {
1131 cmd->chanlist_len = 1;
1132 err++;
1133 }
1134
1135 if (cmd->chanlist_len > this_board->n_aichanlist) {
1136 cmd->chanlist_len = this_board->n_aichanlist;
1137 err++;
1138 }
1139
1140 if (cmd->scan_end_arg < cmd->chanlist_len) {
1141 cmd->scan_end_arg = cmd->chanlist_len;
1142 err++;
1143 }
1144
1145 if ((cmd->scan_end_arg % cmd->chanlist_len)) {
1146 cmd->scan_end_arg =
1147 cmd->chanlist_len * (cmd->scan_end_arg / cmd->chanlist_len);
1148 err++;
1149 }
1150
1151 if (err)
1152 return 3;
1153
1154 /* step 4: fix up any arguments */
1155
1156 if (cmd->scan_begin_src == TRIG_TIMER) {
1157 tmp = cmd->scan_begin_arg;
1158 /* printk("S1 timer1=%u timer2=%u\n",cmd->scan_begin_arg,cmd->convert_arg); */
1159 i8253_cascade_ns_to_timer(devpriv->i8254_osc_base, &divisor1,
1160 &divisor2, &cmd->scan_begin_arg,
1161 cmd->flags & TRIG_ROUND_MASK);
1162 /* printk("S2 timer1=%u timer2=%u\n",cmd->scan_begin_arg,cmd->convert_arg); */
1163 if (cmd->scan_begin_arg < this_board->ai_ns_min)
1164 cmd->scan_begin_arg = this_board->ai_ns_min;
1165 if (tmp != cmd->scan_begin_arg)
1166 err++;
1167 }
1168
1169 if (cmd->convert_src & (TRIG_TIMER | TRIG_NOW)) {
1170 tmp = cmd->convert_arg;
1171 i8253_cascade_ns_to_timer(devpriv->i8254_osc_base, &divisor1,
1172 &divisor2, &cmd->convert_arg,
1173 cmd->flags & TRIG_ROUND_MASK);
1174 /* printk("s1 timer1=%u timer2=%u\n",cmd->scan_begin_arg,cmd->convert_arg); */
1175 if (cmd->convert_arg < this_board->ai_ns_min)
1176 cmd->convert_arg = this_board->ai_ns_min;
1177 if (tmp != cmd->convert_arg)
1178 err++;
1179 if (cmd->scan_begin_src == TRIG_TIMER
1180 && cmd->convert_src == TRIG_NOW) {
1181 if (cmd->convert_arg == 0) {
1182 if (cmd->scan_begin_arg <
1183 this_board->ai_ns_min *
1184 (cmd->scan_end_arg + 2)) {
1185 cmd->scan_begin_arg =
1186 this_board->ai_ns_min *
1187 (cmd->scan_end_arg + 2);
1188 /* printk("s2 timer1=%u timer2=%u\n",cmd->scan_begin_arg,cmd->convert_arg); */
1189 err++;
1190 }
1191 } else {
1192 if (cmd->scan_begin_arg <
1193 cmd->convert_arg * cmd->chanlist_len) {
1194 cmd->scan_begin_arg =
1195 cmd->convert_arg *
1196 cmd->chanlist_len;
1197 /* printk("s3 timer1=%u timer2=%u\n",cmd->scan_begin_arg,cmd->convert_arg); */
1198 err++;
1199 }
1200 }
1201 }
1202 }
1203
1204 if (err)
1205 return 4;
1206
1207 if (cmd->chanlist)
1208 if (!check_channel_list(dev, s, cmd->chanlist_len,
1209 cmd->chanlist, 0, 0))
1210 return 5; /* incorrect channels list */
1211
1212 return 0;
1213 }
1214
1215 /*
1216 ==============================================================================
1217 */
1218 static int Compute_and_setup_dma(struct comedi_device *dev)
1219 {
1220 unsigned int dmalen0, dmalen1, i;
1221
1222 DPRINTK("adl_pci9118 EDBG: BGN: Compute_and_setup_dma()\n");
1223 dmalen0 = devpriv->dmabuf_size[0];
1224 dmalen1 = devpriv->dmabuf_size[1];
1225 DPRINTK("1 dmalen0=%d dmalen1=%d ai_data_len=%d\n", dmalen0, dmalen1,
1226 devpriv->ai_data_len);
1227 /* isn't output buff smaller that our DMA buff? */
1228 if (dmalen0 > (devpriv->ai_data_len)) {
1229 dmalen0 = devpriv->ai_data_len & ~3L; /*
1230 * align to 32bit down
1231 */
1232 }
1233 if (dmalen1 > (devpriv->ai_data_len)) {
1234 dmalen1 = devpriv->ai_data_len & ~3L; /*
1235 * align to 32bit down
1236 */
1237 }
1238 DPRINTK("2 dmalen0=%d dmalen1=%d\n", dmalen0, dmalen1);
1239
1240 /* we want wake up every scan? */
1241 if (devpriv->ai_flags & TRIG_WAKE_EOS) {
1242 if (dmalen0 < (devpriv->ai_n_realscanlen << 1)) {
1243 /* uff, too short DMA buffer, disable EOS support! */
1244 devpriv->ai_flags &= (~TRIG_WAKE_EOS);
1245 printk
1246 ("comedi%d: WAR: DMA0 buf too short, can't "
1247 "support TRIG_WAKE_EOS (%d<%d)\n",
1248 dev->minor, dmalen0,
1249 devpriv->ai_n_realscanlen << 1);
1250 } else {
1251 /* short first DMA buffer to one scan */
1252 dmalen0 = devpriv->ai_n_realscanlen << 1;
1253 DPRINTK
1254 ("21 dmalen0=%d ai_n_realscanlen=%d "
1255 "useeoshandle=%d\n",
1256 dmalen0, devpriv->ai_n_realscanlen,
1257 devpriv->useeoshandle);
1258 if (devpriv->useeoshandle)
1259 dmalen0 += 2;
1260 if (dmalen0 < 4) {
1261 printk
1262 ("comedi%d: ERR: DMA0 buf len bug? "
1263 "(%d<4)\n",
1264 dev->minor, dmalen0);
1265 dmalen0 = 4;
1266 }
1267 }
1268 }
1269 if (devpriv->ai_flags & TRIG_WAKE_EOS) {
1270 if (dmalen1 < (devpriv->ai_n_realscanlen << 1)) {
1271 /* uff, too short DMA buffer, disable EOS support! */
1272 devpriv->ai_flags &= (~TRIG_WAKE_EOS);
1273 printk
1274 ("comedi%d: WAR: DMA1 buf too short, "
1275 "can't support TRIG_WAKE_EOS (%d<%d)\n",
1276 dev->minor, dmalen1,
1277 devpriv->ai_n_realscanlen << 1);
1278 } else {
1279 /* short second DMA buffer to one scan */
1280 dmalen1 = devpriv->ai_n_realscanlen << 1;
1281 DPRINTK
1282 ("22 dmalen1=%d ai_n_realscanlen=%d "
1283 "useeoshandle=%d\n",
1284 dmalen1, devpriv->ai_n_realscanlen,
1285 devpriv->useeoshandle);
1286 if (devpriv->useeoshandle)
1287 dmalen1 -= 2;
1288 if (dmalen1 < 4) {
1289 printk
1290 ("comedi%d: ERR: DMA1 buf len bug? "
1291 "(%d<4)\n",
1292 dev->minor, dmalen1);
1293 dmalen1 = 4;
1294 }
1295 }
1296 }
1297
1298 DPRINTK("3 dmalen0=%d dmalen1=%d\n", dmalen0, dmalen1);
1299 /* transfer without TRIG_WAKE_EOS */
1300 if (!(devpriv->ai_flags & TRIG_WAKE_EOS)) {
1301 /* if it's possible then align DMA buffers to length of scan */
1302 i = dmalen0;
1303 dmalen0 =
1304 (dmalen0 / (devpriv->ai_n_realscanlen << 1)) *
1305 (devpriv->ai_n_realscanlen << 1);
1306 dmalen0 &= ~3L;
1307 if (!dmalen0)
1308 dmalen0 = i; /* uff. very long scan? */
1309 i = dmalen1;
1310 dmalen1 =
1311 (dmalen1 / (devpriv->ai_n_realscanlen << 1)) *
1312 (devpriv->ai_n_realscanlen << 1);
1313 dmalen1 &= ~3L;
1314 if (!dmalen1)
1315 dmalen1 = i; /* uff. very long scan? */
1316 /*
1317 * if measure isn't neverending then test, if it fits whole
1318 * into one or two DMA buffers
1319 */
1320 if (!devpriv->ai_neverending) {
1321 /* fits whole measure into one DMA buffer? */
1322 if (dmalen0 >
1323 ((devpriv->ai_n_realscanlen << 1) *
1324 devpriv->ai_scans)) {
1325 DPRINTK
1326 ("3.0 ai_n_realscanlen=%d ai_scans=%d\n",
1327 devpriv->ai_n_realscanlen,
1328 devpriv->ai_scans);
1329 dmalen0 =
1330 (devpriv->ai_n_realscanlen << 1) *
1331 devpriv->ai_scans;
1332 DPRINTK("3.1 dmalen0=%d dmalen1=%d\n", dmalen0,
1333 dmalen1);
1334 dmalen0 &= ~3L;
1335 } else { /*
1336 * fits whole measure into
1337 * two DMA buffer?
1338 */
1339 if (dmalen1 >
1340 ((devpriv->ai_n_realscanlen << 1) *
1341 devpriv->ai_scans - dmalen0))
1342 dmalen1 =
1343 (devpriv->ai_n_realscanlen << 1) *
1344 devpriv->ai_scans - dmalen0;
1345 DPRINTK("3.2 dmalen0=%d dmalen1=%d\n", dmalen0,
1346 dmalen1);
1347 dmalen1 &= ~3L;
1348 }
1349 }
1350 }
1351
1352 DPRINTK("4 dmalen0=%d dmalen1=%d\n", dmalen0, dmalen1);
1353
1354 /* these DMA buffer size will be used */
1355 devpriv->dma_actbuf = 0;
1356 devpriv->dmabuf_use_size[0] = dmalen0;
1357 devpriv->dmabuf_use_size[1] = dmalen1;
1358
1359 DPRINTK("5 dmalen0=%d dmalen1=%d\n", dmalen0, dmalen1);
1360 #if 0
1361 if (devpriv->ai_n_scanlen < this_board->half_fifo_size) {
1362 devpriv->dmabuf_panic_size[0] =
1363 (this_board->half_fifo_size / devpriv->ai_n_scanlen +
1364 1) * devpriv->ai_n_scanlen * sizeof(short);
1365 devpriv->dmabuf_panic_size[1] =
1366 (this_board->half_fifo_size / devpriv->ai_n_scanlen +
1367 1) * devpriv->ai_n_scanlen * sizeof(short);
1368 } else {
1369 devpriv->dmabuf_panic_size[0] =
1370 (devpriv->ai_n_scanlen << 1) % devpriv->dmabuf_size[0];
1371 devpriv->dmabuf_panic_size[1] =
1372 (devpriv->ai_n_scanlen << 1) % devpriv->dmabuf_size[1];
1373 }
1374 #endif
1375
1376 outl(inl(devpriv->iobase_a + AMCC_OP_REG_MCSR) & (~EN_A2P_TRANSFERS),
1377 devpriv->iobase_a + AMCC_OP_REG_MCSR); /* stop DMA */
1378 outl(devpriv->dmabuf_hw[0], devpriv->iobase_a + AMCC_OP_REG_MWAR);
1379 outl(devpriv->dmabuf_use_size[0], devpriv->iobase_a + AMCC_OP_REG_MWTC);
1380 /* init DMA transfer */
1381 outl(0x00000000 | AINT_WRITE_COMPL,
1382 devpriv->iobase_a + AMCC_OP_REG_INTCSR);
1383 /* outl(0x02000000|AINT_WRITE_COMPL, devpriv->iobase_a+AMCC_OP_REG_INTCSR); */
1384
1385 outl(inl(devpriv->iobase_a +
1386 AMCC_OP_REG_MCSR) | RESET_A2P_FLAGS | A2P_HI_PRIORITY |
1387 EN_A2P_TRANSFERS, devpriv->iobase_a + AMCC_OP_REG_MCSR);
1388 outl(inl(devpriv->iobase_a + AMCC_OP_REG_INTCSR) | EN_A2P_TRANSFERS,
1389 devpriv->iobase_a + AMCC_OP_REG_INTCSR);
1390 /* allow bus mastering */
1391
1392 DPRINTK("adl_pci9118 EDBG: END: Compute_and_setup_dma()\n");
1393 return 0;
1394 }
1395
1396 /*
1397 ==============================================================================
1398 */
1399 static int pci9118_ai_docmd_sampl(struct comedi_device *dev,
1400 struct comedi_subdevice *s)
1401 {
1402 DPRINTK("adl_pci9118 EDBG: BGN: pci9118_ai_docmd_sampl(%d,) [%d]\n",
1403 dev->minor, devpriv->ai_do);
1404 switch (devpriv->ai_do) {
1405 case 1:
1406 devpriv->AdControlReg |= AdControl_TmrTr;
1407 break;
1408 case 2:
1409 comedi_error(dev, "pci9118_ai_docmd_sampl() mode 2 bug!\n");
1410 return -EIO;
1411 case 3:
1412 devpriv->AdControlReg |= AdControl_ExtM;
1413 break;
1414 case 4:
1415 comedi_error(dev, "pci9118_ai_docmd_sampl() mode 4 bug!\n");
1416 return -EIO;
1417 default:
1418 comedi_error(dev,
1419 "pci9118_ai_docmd_sampl() mode number bug!\n");
1420 return -EIO;
1421 }
1422
1423 devpriv->int_ai_func = interrupt_pci9118_ai_onesample;
1424 /* transfer function */
1425
1426 if (devpriv->ai12_startstop)
1427 pci9118_exttrg_add(dev, EXTTRG_AI);
1428 /* activate EXT trigger */
1429
1430 if ((devpriv->ai_do == 1) || (devpriv->ai_do == 2))
1431 devpriv->IntControlReg |= Int_Timer;
1432
1433 devpriv->AdControlReg |= AdControl_Int;
1434
1435 outl(inl(devpriv->iobase_a + AMCC_OP_REG_INTCSR) | 0x1f00,
1436 devpriv->iobase_a + AMCC_OP_REG_INTCSR);
1437 /* allow INT in AMCC */
1438
1439 if (!(devpriv->ai12_startstop & (START_AI_EXT | START_AI_INT))) {
1440 outl(devpriv->IntControlReg, dev->iobase + PCI9118_INTCTRL);
1441 outl(devpriv->AdFunctionReg, dev->iobase + PCI9118_ADFUNC);
1442 if (devpriv->ai_do != 3) {
1443 start_pacer(dev, devpriv->ai_do, devpriv->ai_divisor1,
1444 devpriv->ai_divisor2);
1445 devpriv->AdControlReg |= AdControl_SoftG;
1446 }
1447 outl(devpriv->IntControlReg, dev->iobase + PCI9118_INTCTRL);
1448 }
1449
1450 DPRINTK("adl_pci9118 EDBG: END: pci9118_ai_docmd_sampl()\n");
1451 return 0;
1452 }
1453
1454 /*
1455 ==============================================================================
1456 */
1457 static int pci9118_ai_docmd_dma(struct comedi_device *dev,
1458 struct comedi_subdevice *s)
1459 {
1460 DPRINTK("adl_pci9118 EDBG: BGN: pci9118_ai_docmd_dma(%d,) [%d,%d]\n",
1461 dev->minor, devpriv->ai_do, devpriv->usedma);
1462 Compute_and_setup_dma(dev);
1463
1464 switch (devpriv->ai_do) {
1465 case 1:
1466 devpriv->AdControlReg |=
1467 ((AdControl_TmrTr | AdControl_Dma) & 0xff);
1468 break;
1469 case 2:
1470 devpriv->AdControlReg |=
1471 ((AdControl_TmrTr | AdControl_Dma) & 0xff);
1472 devpriv->AdFunctionReg =
1473 AdFunction_PDTrg | AdFunction_PETrg | AdFunction_BM |
1474 AdFunction_BS;
1475 if (devpriv->usessh && (!devpriv->softsshdelay))
1476 devpriv->AdFunctionReg |= AdFunction_BSSH;
1477 outl(devpriv->ai_n_realscanlen, dev->iobase + PCI9118_BURST);
1478 break;
1479 case 3:
1480 devpriv->AdControlReg |=
1481 ((AdControl_ExtM | AdControl_Dma) & 0xff);
1482 devpriv->AdFunctionReg = AdFunction_PDTrg | AdFunction_PETrg;
1483 break;
1484 case 4:
1485 devpriv->AdControlReg |=
1486 ((AdControl_TmrTr | AdControl_Dma) & 0xff);
1487 devpriv->AdFunctionReg =
1488 AdFunction_PDTrg | AdFunction_PETrg | AdFunction_AM;
1489 outl(devpriv->AdFunctionReg, dev->iobase + PCI9118_ADFUNC);
1490 outl(0x30, dev->iobase + PCI9118_CNTCTRL);
1491 outl((devpriv->dmabuf_hw[0] >> 1) & 0xff,
1492 dev->iobase + PCI9118_CNT0);
1493 outl((devpriv->dmabuf_hw[0] >> 9) & 0xff,
1494 dev->iobase + PCI9118_CNT0);
1495 devpriv->AdFunctionReg |= AdFunction_Start;
1496 break;
1497 default:
1498 comedi_error(dev, "pci9118_ai_docmd_dma() mode number bug!\n");
1499 return -EIO;
1500 }
1501
1502 if (devpriv->ai12_startstop) {
1503 pci9118_exttrg_add(dev, EXTTRG_AI);
1504 /* activate EXT trigger */
1505 }
1506
1507 devpriv->int_ai_func = interrupt_pci9118_ai_dma;
1508 /* transfer function */
1509
1510 outl(0x02000000 | AINT_WRITE_COMPL,
1511 devpriv->iobase_a + AMCC_OP_REG_INTCSR);
1512
1513 if (!(devpriv->ai12_startstop & (START_AI_EXT | START_AI_INT))) {
1514 outl(devpriv->AdFunctionReg, dev->iobase + PCI9118_ADFUNC);
1515 outl(devpriv->IntControlReg, dev->iobase + PCI9118_INTCTRL);
1516 if (devpriv->ai_do != 3) {
1517 start_pacer(dev, devpriv->ai_do, devpriv->ai_divisor1,
1518 devpriv->ai_divisor2);
1519 devpriv->AdControlReg |= AdControl_SoftG;
1520 }
1521 outl(devpriv->AdControlReg, dev->iobase + PCI9118_ADCNTRL);
1522 }
1523
1524 DPRINTK("adl_pci9118 EDBG: BGN: pci9118_ai_docmd_dma()\n");
1525 return 0;
1526 }
1527
1528 /*
1529 ==============================================================================
1530 */
1531 static int pci9118_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
1532 {
1533 struct comedi_cmd *cmd = &s->async->cmd;
1534 unsigned int addchans = 0;
1535 int ret = 0;
1536
1537 DPRINTK("adl_pci9118 EDBG: BGN: pci9118_ai_cmd(%d,)\n", dev->minor);
1538 devpriv->ai12_startstop = 0;
1539 devpriv->ai_flags = cmd->flags;
1540 devpriv->ai_n_chan = cmd->chanlist_len;
1541 devpriv->ai_n_scanlen = cmd->scan_end_arg;
1542 devpriv->ai_chanlist = cmd->chanlist;
1543 devpriv->ai_data = s->async->prealloc_buf;
1544 devpriv->ai_data_len = s->async->prealloc_bufsz;
1545 devpriv->ai_timer1 = 0;
1546 devpriv->ai_timer2 = 0;
1547 devpriv->ai_add_front = 0;
1548 devpriv->ai_add_back = 0;
1549 devpriv->ai_maskerr = 0x10e;
1550
1551 /* prepare for start/stop conditions */
1552 if (cmd->start_src == TRIG_EXT)
1553 devpriv->ai12_startstop |= START_AI_EXT;
1554 if (cmd->stop_src == TRIG_EXT) {
1555 devpriv->ai_neverending = 1;
1556 devpriv->ai12_startstop |= STOP_AI_EXT;
1557 }
1558 if (cmd->start_src == TRIG_INT) {
1559 devpriv->ai12_startstop |= START_AI_INT;
1560 devpriv->ai_inttrig_start = cmd->start_arg;
1561 s->async->inttrig = pci9118_ai_inttrig;
1562 }
1563 #if 0
1564 if (cmd->stop_src == TRIG_INT) {
1565 devpriv->ai_neverending = 1;
1566 devpriv->ai12_startstop |= STOP_AI_INT;
1567 }
1568 #endif
1569 if (cmd->stop_src == TRIG_NONE)
1570 devpriv->ai_neverending = 1;
1571 if (cmd->stop_src == TRIG_COUNT) {
1572 devpriv->ai_scans = cmd->stop_arg;
1573 devpriv->ai_neverending = 0;
1574 } else {
1575 devpriv->ai_scans = 0;
1576 }
1577
1578 /* use sample&hold signal? */
1579 if (cmd->convert_src == TRIG_NOW)
1580 devpriv->usessh = 1;
1581 /* yes */
1582 else
1583 devpriv->usessh = 0;
1584 /* no */
1585
1586 DPRINTK("1 neverending=%d scans=%u usessh=%d ai_startstop=0x%2x\n",
1587 devpriv->ai_neverending, devpriv->ai_scans, devpriv->usessh,
1588 devpriv->ai12_startstop);
1589
1590 /*
1591 * use additional sample at end of every scan
1592 * to satisty DMA 32 bit transfer?
1593 */
1594 devpriv->ai_add_front = 0;
1595 devpriv->ai_add_back = 0;
1596 devpriv->useeoshandle = 0;
1597 if (devpriv->master) {
1598 devpriv->usedma = 1;
1599 if ((cmd->flags & TRIG_WAKE_EOS) &&
1600 (devpriv->ai_n_scanlen == 1)) {
1601 if (cmd->convert_src == TRIG_NOW)
1602 devpriv->ai_add_back = 1;
1603 if (cmd->convert_src == TRIG_TIMER) {
1604 devpriv->usedma = 0;
1605 /*
1606 * use INT transfer if scanlist
1607 * have only one channel
1608 */
1609 }
1610 }
1611 if ((cmd->flags & TRIG_WAKE_EOS) &&
1612 (devpriv->ai_n_scanlen & 1) &&
1613 (devpriv->ai_n_scanlen > 1)) {
1614 if (cmd->scan_begin_src == TRIG_FOLLOW) {
1615 /*
1616 * vpriv->useeoshandle=1; // change DMA transfer
1617 * block to fit EOS on every second call
1618 */
1619 devpriv->usedma = 0;
1620 /*
1621 * XXX maybe can be corrected to use 16 bit DMA
1622 */
1623 } else { /*
1624 * well, we must insert one sample
1625 * to end of EOS to meet 32 bit transfer
1626 */
1627 devpriv->ai_add_back = 1;
1628 }
1629 }
1630 } else { /* interrupt transfer don't need any correction */
1631 devpriv->usedma = 0;
1632 }
1633
1634 /*
1635 * we need software S&H signal?
1636 * It adds two samples before every scan as minimum
1637 */
1638 if (devpriv->usessh && devpriv->softsshdelay) {
1639 devpriv->ai_add_front = 2;
1640 if ((devpriv->usedma == 1) && (devpriv->ai_add_back == 1)) {
1641 /* move it to front */
1642 devpriv->ai_add_front++;
1643 devpriv->ai_add_back = 0;
1644 }
1645 if (cmd->convert_arg < this_board->ai_ns_min)
1646 cmd->convert_arg = this_board->ai_ns_min;
1647 addchans = devpriv->softsshdelay / cmd->convert_arg;
1648 if (devpriv->softsshdelay % cmd->convert_arg)
1649 addchans++;
1650 if (addchans > (devpriv->ai_add_front - 1)) {
1651 /* uff, still short */
1652 devpriv->ai_add_front = addchans + 1;
1653 if (devpriv->usedma == 1)
1654 if ((devpriv->ai_add_front +
1655 devpriv->ai_n_chan +
1656 devpriv->ai_add_back) & 1)
1657 devpriv->ai_add_front++;
1658 /* round up to 32 bit */
1659 }
1660 }
1661 /* well, we now know what must be all added */
1662 devpriv->ai_n_realscanlen = /*
1663 * what we must take from card in real
1664 * to have ai_n_scanlen on output?
1665 */
1666 (devpriv->ai_add_front + devpriv->ai_n_chan +
1667 devpriv->ai_add_back) * (devpriv->ai_n_scanlen /
1668 devpriv->ai_n_chan);
1669
1670 DPRINTK("2 usedma=%d realscan=%d af=%u n_chan=%d ab=%d n_scanlen=%d\n",
1671 devpriv->usedma,
1672 devpriv->ai_n_realscanlen, devpriv->ai_add_front,
1673 devpriv->ai_n_chan, devpriv->ai_add_back,
1674 devpriv->ai_n_scanlen);
1675
1676 /* check and setup channel list */
1677 if (!check_channel_list(dev, s, devpriv->ai_n_chan,
1678 devpriv->ai_chanlist, devpriv->ai_add_front,
1679 devpriv->ai_add_back))
1680 return -EINVAL;
1681 if (!setup_channel_list(dev, s, devpriv->ai_n_chan,
1682 devpriv->ai_chanlist, 0, devpriv->ai_add_front,
1683 devpriv->ai_add_back, devpriv->usedma,
1684 devpriv->useeoshandle))
1685 return -EINVAL;
1686
1687 /* compute timers settings */
1688 /*
1689 * simplest way, fr=4Mhz/(tim1*tim2),
1690 * channel manipulation without timers effect
1691 */
1692 if (((cmd->scan_begin_src == TRIG_FOLLOW) ||
1693 (cmd->scan_begin_src == TRIG_EXT) ||
1694 (cmd->scan_begin_src == TRIG_INT)) &&
1695 (cmd->convert_src == TRIG_TIMER)) {
1696 /* both timer is used for one time */
1697 if (cmd->scan_begin_src == TRIG_EXT)
1698 devpriv->ai_do = 4;
1699 else
1700 devpriv->ai_do = 1;
1701 pci9118_calc_divisors(devpriv->ai_do, dev, s,
1702 &cmd->scan_begin_arg, &cmd->convert_arg,
1703 devpriv->ai_flags,
1704 devpriv->ai_n_realscanlen,
1705 &devpriv->ai_divisor1,
1706 &devpriv->ai_divisor2, devpriv->usessh,
1707 devpriv->ai_add_front);
1708 devpriv->ai_timer2 = cmd->convert_arg;
1709 }
1710
1711 if ((cmd->scan_begin_src == TRIG_TIMER) &&
1712 ((cmd->convert_src == TRIG_TIMER) ||
1713 (cmd->convert_src == TRIG_NOW))) {
1714 /* double timed action */
1715 if (!devpriv->usedma) {
1716 comedi_error(dev,
1717 "cmd->scan_begin_src=TRIG_TIMER works "
1718 "only with bus mastering!");
1719 return -EIO;
1720 }
1721
1722 devpriv->ai_do = 2;
1723 pci9118_calc_divisors(devpriv->ai_do, dev, s,
1724 &cmd->scan_begin_arg, &cmd->convert_arg,
1725 devpriv->ai_flags,
1726 devpriv->ai_n_realscanlen,
1727 &devpriv->ai_divisor1,
1728 &devpriv->ai_divisor2, devpriv->usessh,
1729 devpriv->ai_add_front);
1730 devpriv->ai_timer1 = cmd->scan_begin_arg;
1731 devpriv->ai_timer2 = cmd->convert_arg;
1732 }
1733
1734 if ((cmd->scan_begin_src == TRIG_FOLLOW)
1735 && (cmd->convert_src == TRIG_EXT)) {
1736 devpriv->ai_do = 3;
1737 }
1738
1739 start_pacer(dev, -1, 0, 0); /* stop pacer */
1740
1741 devpriv->AdControlReg = 0; /*
1742 * bipolar, S.E., use 8254, stop 8354,
1743 * internal trigger, soft trigger,
1744 * disable DMA
1745 */
1746 outl(devpriv->AdControlReg, dev->iobase + PCI9118_ADCNTRL);
1747 devpriv->AdFunctionReg = AdFunction_PDTrg | AdFunction_PETrg;
1748 /*
1749 * positive triggers, no S&H, no burst,
1750 * burst stop, no post trigger,
1751 * no about trigger, trigger stop
1752 */
1753 outl(devpriv->AdFunctionReg, dev->iobase + PCI9118_ADFUNC);
1754 udelay(1);
1755 outl(0, dev->iobase + PCI9118_DELFIFO); /* flush FIFO */
1756 inl(dev->iobase + PCI9118_ADSTAT); /*
1757 * flush A/D and INT
1758 * status register
1759 */
1760 inl(dev->iobase + PCI9118_INTSRC);
1761
1762 devpriv->ai_act_scan = 0;
1763 devpriv->ai_act_dmapos = 0;
1764 s->async->cur_chan = 0;
1765 devpriv->ai_buf_ptr = 0;
1766
1767 if (devpriv->usedma)
1768 ret = pci9118_ai_docmd_dma(dev, s);
1769 else
1770 ret = pci9118_ai_docmd_sampl(dev, s);
1771
1772 DPRINTK("adl_pci9118 EDBG: END: pci9118_ai_cmd()\n");
1773 return ret;
1774 }
1775
1776 /*
1777 ==============================================================================
1778 */
1779 static int check_channel_list(struct comedi_device *dev,
1780 struct comedi_subdevice *s, int n_chan,
1781 unsigned int *chanlist, int frontadd, int backadd)
1782 {
1783 unsigned int i, differencial = 0, bipolar = 0;
1784
1785 /* correct channel and range number check itself comedi/range.c */
1786 if (n_chan < 1) {
1787 comedi_error(dev, "range/channel list is empty!");
1788 return 0;
1789 }
1790 if ((frontadd + n_chan + backadd) > s->len_chanlist) {
1791 printk
1792 ("comedi%d: range/channel list is too long for "
1793 "actual configuration (%d>%d)!",
1794 dev->minor, n_chan, s->len_chanlist - frontadd - backadd);
1795 return 0;
1796 }
1797
1798 if (CR_AREF(chanlist[0]) == AREF_DIFF)
1799 differencial = 1; /* all input must be diff */
1800 if (CR_RANGE(chanlist[0]) < PCI9118_BIPOLAR_RANGES)
1801 bipolar = 1; /* all input must be bipolar */
1802 if (n_chan > 1)
1803 for (i = 1; i < n_chan; i++) { /* check S.E/diff */
1804 if ((CR_AREF(chanlist[i]) == AREF_DIFF) !=
1805 (differencial)) {
1806 comedi_error(dev,
1807 "Differencial and single ended "
1808 "inputs can't be mixtured!");
1809 return 0;
1810 }
1811 if ((CR_RANGE(chanlist[i]) < PCI9118_BIPOLAR_RANGES) !=
1812 (bipolar)) {
1813 comedi_error(dev,
1814 "Bipolar and unipolar ranges "
1815 "can't be mixtured!");
1816 return 0;
1817 }
1818 if ((!devpriv->usemux) & (differencial) &
1819 (CR_CHAN(chanlist[i]) >= this_board->n_aichand)) {
1820 comedi_error(dev,
1821 "If AREF_DIFF is used then is "
1822 "available only first 8 channels!");
1823 return 0;
1824 }
1825 }
1826
1827 return 1;
1828 }
1829
1830 /*
1831 ==============================================================================
1832 */
1833 static int setup_channel_list(struct comedi_device *dev,
1834 struct comedi_subdevice *s, int n_chan,
1835 unsigned int *chanlist, int rot, int frontadd,
1836 int backadd, int usedma, char useeos)
1837 {
1838 unsigned int i, differencial = 0, bipolar = 0;
1839 unsigned int scanquad, gain, ssh = 0x00;
1840
1841 DPRINTK
1842 ("adl_pci9118 EDBG: BGN: setup_channel_list"
1843 "(%d,.,%d,.,%d,%d,%d,%d)\n",
1844 dev->minor, n_chan, rot, frontadd, backadd, usedma);
1845
1846 if (usedma == 1) {
1847 rot = 8;
1848 usedma = 0;
1849 }
1850
1851 if (CR_AREF(chanlist[0]) == AREF_DIFF)
1852 differencial = 1; /* all input must be diff */
1853 if (CR_RANGE(chanlist[0]) < PCI9118_BIPOLAR_RANGES)
1854 bipolar = 1; /* all input must be bipolar */
1855
1856 /* All is ok, so we can setup channel/range list */
1857
1858 if (!bipolar) {
1859 devpriv->AdControlReg |= AdControl_UniP;
1860 /* set unibipolar */
1861 } else {
1862 devpriv->AdControlReg &= ((~AdControl_UniP) & 0xff);
1863 /* enable bipolar */
1864 }
1865
1866 if (differencial) {
1867 devpriv->AdControlReg |= AdControl_Diff;
1868 /* enable diff inputs */
1869 } else {
1870 devpriv->AdControlReg &= ((~AdControl_Diff) & 0xff);
1871 /* set single ended inputs */
1872 }
1873
1874 outl(devpriv->AdControlReg, dev->iobase + PCI9118_ADCNTRL);
1875 /* setup mode */
1876
1877 outl(2, dev->iobase + PCI9118_SCANMOD);
1878 /* gods know why this sequence! */
1879 outl(0, dev->iobase + PCI9118_SCANMOD);
1880 outl(1, dev->iobase + PCI9118_SCANMOD);
1881
1882 #ifdef PCI9118_PARANOIDCHECK
1883 devpriv->chanlistlen = n_chan;
1884 for (i = 0; i < (PCI9118_CHANLEN + 1); i++)
1885 devpriv->chanlist[i] = 0x55aa;
1886 #endif
1887
1888 if (frontadd) { /* insert channels for S&H */
1889 ssh = devpriv->softsshsample;
1890 DPRINTK("FA: %04x: ", ssh);
1891 for (i = 0; i < frontadd; i++) {
1892 /* store range list to card */
1893 scanquad = CR_CHAN(chanlist[0]);
1894 /* get channel number; */
1895 gain = CR_RANGE(chanlist[0]);
1896 /* get gain number */
1897 scanquad |= ((gain & 0x03) << 8);
1898 outl(scanquad | ssh, dev->iobase + PCI9118_GAIN);
1899 DPRINTK("%02x ", scanquad | ssh);
1900 ssh = devpriv->softsshhold;
1901 }
1902 DPRINTK("\n ");
1903 }
1904
1905 DPRINTK("SL: ", ssh);
1906 for (i = 0; i < n_chan; i++) { /* store range list to card */
1907 scanquad = CR_CHAN(chanlist[i]); /* get channel number */
1908 #ifdef PCI9118_PARANOIDCHECK
1909 devpriv->chanlist[i ^ usedma] = (scanquad & 0xf) << rot;
1910 #endif
1911 gain = CR_RANGE(chanlist[i]); /* get gain number */
1912 scanquad |= ((gain & 0x03) << 8);
1913 outl(scanquad | ssh, dev->iobase + PCI9118_GAIN);
1914 DPRINTK("%02x ", scanquad | ssh);
1915 }
1916 DPRINTK("\n ");
1917
1918 if (backadd) { /* insert channels for fit onto 32bit DMA */
1919 DPRINTK("BA: %04x: ", ssh);
1920 for (i = 0; i < backadd; i++) { /* store range list to card */
1921 scanquad = CR_CHAN(chanlist[0]);
1922 /* get channel number */
1923 gain = CR_RANGE(chanlist[0]); /* get gain number */
1924 scanquad |= ((gain & 0x03) << 8);
1925 outl(scanquad | ssh, dev->iobase + PCI9118_GAIN);
1926 DPRINTK("%02x ", scanquad | ssh);
1927 }
1928 DPRINTK("\n ");
1929 }
1930 #ifdef PCI9118_PARANOIDCHECK
1931 devpriv->chanlist[n_chan ^ usedma] = devpriv->chanlist[0 ^ usedma];
1932 /* for 32bit operations */
1933 if (useeos) {
1934 for (i = 1; i < n_chan; i++) { /* store range list to card */
1935 devpriv->chanlist[(n_chan + i) ^ usedma] =
1936 (CR_CHAN(chanlist[i]) & 0xf) << rot;
1937 }
1938 devpriv->chanlist[(2 * n_chan) ^ usedma] =
1939 devpriv->chanlist[0 ^ usedma];
1940 /* for 32bit operations */
1941 useeos = 2;
1942 } else {
1943 useeos = 1;
1944 }
1945 #ifdef PCI9118_EXTDEBUG
1946 DPRINTK("CHL: ");
1947 for (i = 0; i <= (useeos * n_chan); i++)
1948 DPRINTK("%04x ", devpriv->chanlist[i]);
1949
1950 DPRINTK("\n ");
1951 #endif
1952 #endif
1953 outl(0, dev->iobase + PCI9118_SCANMOD); /* close scan queue */
1954 /* udelay(100); important delay, or first sample will be crippled */
1955
1956 DPRINTK("adl_pci9118 EDBG: END: setup_channel_list()\n");
1957 return 1; /* we can serve this with scan logic */
1958 }
1959
1960 /*
1961 ==============================================================================
1962 calculate 8254 divisors if they are used for dual timing
1963 */
1964 static void pci9118_calc_divisors(char mode, struct comedi_device *dev,
1965 struct comedi_subdevice *s,
1966 unsigned int *tim1, unsigned int *tim2,
1967 unsigned int flags, int chans,
1968 unsigned int *div1, unsigned int *div2,
1969 char usessh, unsigned int chnsshfront)
1970 {
1971 DPRINTK
1972 ("adl_pci9118 EDBG: BGN: pci9118_calc_divisors"
1973 "(%d,%d,.,%u,%u,%u,%d,.,.,,%u,%u)\n",
1974 mode, dev->minor, *tim1, *tim2, flags, chans, usessh, chnsshfront);
1975 switch (mode) {
1976 case 1:
1977 case 4:
1978 if (*tim2 < this_board->ai_ns_min)
1979 *tim2 = this_board->ai_ns_min;
1980 i8253_cascade_ns_to_timer(devpriv->i8254_osc_base, div1, div2,
1981 tim2, flags & TRIG_ROUND_NEAREST);
1982 DPRINTK("OSC base=%u div1=%u div2=%u timer1=%u\n",
1983 devpriv->i8254_osc_base, *div1, *div2, *tim1);
1984 break;
1985 case 2:
1986 if (*tim2 < this_board->ai_ns_min)
1987 *tim2 = this_board->ai_ns_min;
1988 DPRINTK("1 div1=%u div2=%u timer1=%u timer2=%u\n", *div1, *div2,
1989 *tim1, *tim2);
1990 *div1 = *tim2 / devpriv->i8254_osc_base;
1991 /* convert timer (burst) */
1992 DPRINTK("2 div1=%u div2=%u timer1=%u timer2=%u\n", *div1, *div2,
1993 *tim1, *tim2);
1994 if (*div1 < this_board->ai_pacer_min)
1995 *div1 = this_board->ai_pacer_min;
1996 DPRINTK("3 div1=%u div2=%u timer1=%u timer2=%u\n", *div1, *div2,
1997 *tim1, *tim2);
1998 *div2 = *tim1 / devpriv->i8254_osc_base; /* scan timer */
1999 DPRINTK("4 div1=%u div2=%u timer1=%u timer2=%u\n", *div1, *div2,
2000 *tim1, *tim2);
2001 *div2 = *div2 / *div1; /* major timer is c1*c2 */
2002 DPRINTK("5 div1=%u div2=%u timer1=%u timer2=%u\n", *div1, *div2,
2003 *tim1, *tim2);
2004 if (*div2 < chans)
2005 *div2 = chans;
2006 DPRINTK("6 div1=%u div2=%u timer1=%u timer2=%u\n", *div1, *div2,
2007 *tim1, *tim2);
2008
2009 *tim2 = *div1 * devpriv->i8254_osc_base;
2010 /* real convert timer */
2011
2012 if (usessh & (chnsshfront == 0)) /* use BSSH signal */
2013 if (*div2 < (chans + 2))
2014 *div2 = chans + 2;
2015
2016 DPRINTK("7 div1=%u div2=%u timer1=%u timer2=%u\n", *div1, *div2,
2017 *tim1, *tim2);
2018 *tim1 = *div1 * *div2 * devpriv->i8254_osc_base;
2019 DPRINTK("OSC base=%u div1=%u div2=%u timer1=%u timer2=%u\n",
2020 devpriv->i8254_osc_base, *div1, *div2, *tim1, *tim2);
2021 break;
2022 }
2023 DPRINTK("adl_pci9118 EDBG: END: pci9118_calc_divisors(%u,%u)\n",
2024 *div1, *div2);
2025 }
2026
2027 /*
2028 ==============================================================================
2029 */
2030 static void start_pacer(struct comedi_device *dev, int mode,
2031 unsigned int divisor1, unsigned int divisor2)
2032 {
2033 outl(0x74, dev->iobase + PCI9118_CNTCTRL);
2034 outl(0xb4, dev->iobase + PCI9118_CNTCTRL);
2035 /* outl(0x30, dev->iobase + PCI9118_CNTCTRL); */
2036 udelay(1);
2037
2038 if ((mode == 1) || (mode == 2) || (mode == 4)) {
2039 outl(divisor2 & 0xff, dev->iobase + PCI9118_CNT2);
2040 outl((divisor2 >> 8) & 0xff, dev->iobase + PCI9118_CNT2);
2041 outl(divisor1 & 0xff, dev->iobase + PCI9118_CNT1);
2042 outl((divisor1 >> 8) & 0xff, dev->iobase + PCI9118_CNT1);
2043 }
2044 }
2045
2046 /*
2047 ==============================================================================
2048 */
2049 static int pci9118_exttrg_add(struct comedi_device *dev, unsigned char source)
2050 {
2051 if (source > 3)
2052 return -1; /* incorrect source */
2053 devpriv->exttrg_users |= (1 << source);
2054 devpriv->IntControlReg |= Int_DTrg;
2055 outl(devpriv->IntControlReg, dev->iobase + PCI9118_INTCTRL);
2056 outl(inl(devpriv->iobase_a + AMCC_OP_REG_INTCSR) | 0x1f00,
2057 devpriv->iobase_a + AMCC_OP_REG_INTCSR);
2058 /* allow INT in AMCC */
2059 return 0;
2060 }
2061
2062 /*
2063 ==============================================================================
2064 */
2065 static int pci9118_exttrg_del(struct comedi_device *dev, unsigned char source)
2066 {
2067 if (source > 3)
2068 return -1; /* incorrect source */
2069 devpriv->exttrg_users &= ~(1 << source);
2070 if (!devpriv->exttrg_users) { /* shutdown ext trg intterrupts */
2071 devpriv->IntControlReg &= ~Int_DTrg;
2072 if (!devpriv->IntControlReg) /* all IRQ disabled */
2073 outl(inl(devpriv->iobase_a + AMCC_OP_REG_INTCSR) &
2074 (~0x00001f00),
2075 devpriv->iobase_a + AMCC_OP_REG_INTCSR);
2076 /* disable int in AMCC */
2077 outl(devpriv->IntControlReg, dev->iobase + PCI9118_INTCTRL);
2078 }
2079 return 0;
2080 }
2081
2082 /*
2083 ==============================================================================
2084 */
2085 static int pci9118_ai_cancel(struct comedi_device *dev,
2086 struct comedi_subdevice *s)
2087 {
2088 if (devpriv->usedma)
2089 outl(inl(devpriv->iobase_a + AMCC_OP_REG_MCSR) &
2090 (~EN_A2P_TRANSFERS),
2091 devpriv->iobase_a + AMCC_OP_REG_MCSR); /* stop DMA */
2092 pci9118_exttrg_del(dev, EXTTRG_AI);
2093 start_pacer(dev, 0, 0, 0); /* stop 8254 counters */
2094 devpriv->AdFunctionReg = AdFunction_PDTrg | AdFunction_PETrg;
2095 outl(devpriv->AdFunctionReg, dev->iobase + PCI9118_ADFUNC);
2096 /*
2097 * positive triggers, no S&H, no burst,
2098 * burst stop, no post trigger,
2099 * no about trigger, trigger stop
2100 */
2101 devpriv->AdControlReg = 0x00;
2102 outl(devpriv->AdControlReg, dev->iobase + PCI9118_ADCNTRL);
2103 /*
2104 * bipolar, S.E., use 8254, stop 8354,
2105 * internal trigger, soft trigger,
2106 * disable INT and DMA
2107 */
2108 outl(0, dev->iobase + PCI9118_BURST);
2109 outl(1, dev->iobase + PCI9118_SCANMOD);
2110 outl(2, dev->iobase + PCI9118_SCANMOD); /* reset scan queue */
2111 outl(0, dev->iobase + PCI9118_DELFIFO); /* flush FIFO */
2112
2113 devpriv->ai_do = 0;
2114 devpriv->usedma = 0;
2115
2116 devpriv->ai_act_scan = 0;
2117 devpriv->ai_act_dmapos = 0;
2118 s->async->cur_chan = 0;
2119 s->async->inttrig = NULL;
2120 devpriv->ai_buf_ptr = 0;
2121 devpriv->ai_neverending = 0;
2122 devpriv->dma_actbuf = 0;
2123
2124 if (!devpriv->IntControlReg)
2125 outl(inl(devpriv->iobase_a + AMCC_OP_REG_INTCSR) | 0x1f00,
2126 devpriv->iobase_a + AMCC_OP_REG_INTCSR);
2127 /* allow INT in AMCC */
2128
2129 return 0;
2130 }
2131
2132 /*
2133 ==============================================================================
2134 */
2135 static int pci9118_reset(struct comedi_device *dev)
2136 {
2137 devpriv->IntControlReg = 0;
2138 devpriv->exttrg_users = 0;
2139 inl(dev->iobase + PCI9118_INTCTRL);
2140 outl(devpriv->IntControlReg, dev->iobase + PCI9118_INTCTRL);
2141 /* disable interrupts source */
2142 outl(0x30, dev->iobase + PCI9118_CNTCTRL);
2143 /* outl(0xb4, dev->iobase + PCI9118_CNTCTRL); */
2144 start_pacer(dev, 0, 0, 0); /* stop 8254 counters */
2145 devpriv->AdControlReg = 0;
2146 outl(devpriv->AdControlReg, dev->iobase + PCI9118_ADCNTRL);
2147 /*
2148 * bipolar, S.E., use 8254,
2149 * stop 8354, internal trigger,
2150 * soft trigger,
2151 * disable INT and DMA
2152 */
2153 outl(0, dev->iobase + PCI9118_BURST);
2154 outl(1, dev->iobase + PCI9118_SCANMOD);
2155 outl(2, dev->iobase + PCI9118_SCANMOD); /* reset scan queue */
2156 devpriv->AdFunctionReg = AdFunction_PDTrg | AdFunction_PETrg;
2157 outl(devpriv->AdFunctionReg, dev->iobase + PCI9118_ADFUNC);
2158 /*
2159 * positive triggers, no S&H,
2160 * no burst, burst stop,
2161 * no post trigger,
2162 * no about trigger,
2163 * trigger stop
2164 */
2165
2166 devpriv->ao_data[0] = 2047;
2167 devpriv->ao_data[1] = 2047;
2168 outl(devpriv->ao_data[0], dev->iobase + PCI9118_DA1);
2169 /* reset A/D outs to 0V */
2170 outl(devpriv->ao_data[1], dev->iobase + PCI9118_DA2);
2171 outl(0, dev->iobase + PCI9118_DO); /* reset digi outs to L */
2172 udelay(10);
2173 inl(dev->iobase + PCI9118_AD_DATA);
2174 outl(0, dev->iobase + PCI9118_DELFIFO); /* flush FIFO */
2175 outl(0, dev->iobase + PCI9118_INTSRC); /* remove INT requests */
2176 inl(dev->iobase + PCI9118_ADSTAT); /* flush A/D status register */
2177 inl(dev->iobase + PCI9118_INTSRC); /* flush INT requests */
2178 devpriv->AdControlReg = 0;
2179 outl(devpriv->AdControlReg, dev->iobase + PCI9118_ADCNTRL);
2180 /*
2181 * bipolar, S.E., use 8254,
2182 * stop 8354, internal trigger,
2183 * soft trigger,
2184 * disable INT and DMA
2185 */
2186
2187 devpriv->cnt0_users = 0;
2188 devpriv->exttrg_users = 0;
2189
2190 return 0;
2191 }
2192
2193 /*
2194 ==============================================================================
2195 */
2196 static int pci9118_attach(struct comedi_device *dev,
2197 struct comedi_devconfig *it)
2198 {
2199 struct comedi_subdevice *s;
2200 int ret, pages, i;
2201 unsigned short master;
2202 unsigned int irq;
2203 unsigned long iobase_a, iobase_9;
2204 struct pci_dev *pcidev;
2205 int opt_bus, opt_slot;
2206 const char *errstr;
2207 unsigned char pci_bus, pci_slot, pci_func;
2208 u16 u16w;
2209
2210 printk("comedi%d: adl_pci9118: board=%s", dev->minor, this_board->name);
2211
2212 opt_bus = it->options[0];
2213 opt_slot = it->options[1];
2214 if (it->options[3] & 1)
2215 master = 0; /* user don't want use bus master */
2216 else
2217 master = 1;
2218
2219 ret = alloc_private(dev, sizeof(struct pci9118_private));
2220 if (ret < 0) {
2221 printk(" - Allocation failed!\n");
2222 return -ENOMEM;
2223 }
2224
2225 /* Look for matching PCI device */
2226 errstr = "not found!";
2227 pcidev = NULL;
2228 while (NULL != (pcidev = pci_get_device(PCI_VENDOR_ID_AMCC,
2229 this_board->device_id,
2230 pcidev))) {
2231 /* Found matching vendor/device. */
2232 if (opt_bus || opt_slot) {
2233 /* Check bus/slot. */
2234 if (opt_bus != pcidev->bus->number
2235 || opt_slot != PCI_SLOT(pcidev->devfn))
2236 continue; /* no match */
2237 }
2238 /*
2239 * Look for device that isn't in use.
2240 * Enable PCI device and request regions.
2241 */
2242 if (comedi_pci_enable(pcidev, "adl_pci9118")) {
2243 errstr =
2244 "failed to enable PCI device and request regions!";
2245 continue;
2246 }
2247 break;
2248 }
2249
2250 if (!pcidev) {
2251 if (opt_bus || opt_slot) {
2252 printk(KERN_ERR " - Card at b:s %d:%d %s\n",
2253 opt_bus, opt_slot, errstr);
2254 } else {
2255 printk(KERN_ERR " - Card %s\n", errstr);
2256 }
2257 return -EIO;
2258 }
2259
2260 if (master)
2261 pci_set_master(pcidev);
2262
2263
2264 pci_bus = pcidev->bus->number;
2265 pci_slot = PCI_SLOT(pcidev->devfn);
2266 pci_func = PCI_FUNC(pcidev->devfn);
2267 irq = pcidev->irq;
2268 iobase_a = pci_resource_start(pcidev, 0);
2269 iobase_9 = pci_resource_start(pcidev, 2);
2270
2271 printk(KERN_ERR ", b:s:f=%d:%d:%d, io=0x%4lx, 0x%4lx", pci_bus,
2272 pci_slot, pci_func, iobase_9, iobase_a);
2273
2274 dev->iobase = iobase_9;
2275 dev->board_name = this_board->name;
2276
2277 devpriv->pcidev = pcidev;
2278 devpriv->iobase_a = iobase_a;
2279
2280 pci9118_reset(dev);
2281
2282 if (it->options[3] & 2)
2283 irq = 0; /* user don't want use IRQ */
2284 if (irq > 0) {
2285 if (request_irq(irq, interrupt_pci9118, IRQF_SHARED,
2286 "ADLink PCI-9118", dev)) {
2287 printk(", unable to allocate IRQ %d, DISABLING IT",
2288 irq);
2289 irq = 0; /* Can't use IRQ */
2290 } else {
2291 printk(", irq=%u", irq);
2292 }
2293 } else {
2294 printk(", IRQ disabled");
2295 }
2296
2297 dev->irq = irq;
2298
2299 if (master) { /* alloc DMA buffers */
2300 devpriv->dma_doublebuf = 0;
2301 for (i = 0; i < 2; i++) {
2302 for (pages = 4; pages >= 0; pages--) {
2303 devpriv->dmabuf_virt[i] =
2304 (short *)__get_free_pages(GFP_KERNEL,
2305 pages);
2306 if (devpriv->dmabuf_virt[i])
2307 break;
2308 }
2309 if (devpriv->dmabuf_virt[i]) {
2310 devpriv->dmabuf_pages[i] = pages;
2311 devpriv->dmabuf_size[i] = PAGE_SIZE * pages;
2312 devpriv->dmabuf_samples[i] =
2313 devpriv->dmabuf_size[i] >> 1;
2314 devpriv->dmabuf_hw[i] =
2315 virt_to_bus((void *)
2316 devpriv->dmabuf_virt[i]);
2317 }
2318 }
2319 if (!devpriv->dmabuf_virt[0]) {
2320 printk(", Can't allocate DMA buffer, DMA disabled!");
2321 master = 0;
2322 }
2323
2324 if (devpriv->dmabuf_virt[1])
2325 devpriv->dma_doublebuf = 1;
2326
2327 }
2328
2329 devpriv->master = master;
2330 if (devpriv->master)
2331 printk(", bus master");
2332 else
2333 printk(", no bus master");
2334
2335 devpriv->usemux = 0;
2336 if (it->options[2] > 0) {
2337 devpriv->usemux = it->options[2];
2338 if (devpriv->usemux > 256)
2339 devpriv->usemux = 256; /* max 256 channels! */
2340 if (it->options[4] > 0)
2341 if (devpriv->usemux > 128) {
2342 devpriv->usemux = 128;
2343 /* max 128 channels with softare S&H! */
2344 }
2345 printk(", ext. mux %d channels", devpriv->usemux);
2346 }
2347
2348 devpriv->softsshdelay = it->options[4];
2349 if (devpriv->softsshdelay < 0) {
2350 /* select sample&hold signal polarity */
2351 devpriv->softsshdelay = -devpriv->softsshdelay;
2352 devpriv->softsshsample = 0x80;
2353 devpriv->softsshhold = 0x00;
2354 } else {
2355 devpriv->softsshsample = 0x00;
2356 devpriv->softsshhold = 0x80;
2357 }
2358
2359 printk(".\n");
2360
2361 pci_read_config_word(devpriv->pcidev, PCI_COMMAND, &u16w);
2362 pci_write_config_word(devpriv->pcidev, PCI_COMMAND, u16w | 64);
2363 /* Enable parity check for parity error */
2364
2365 ret = alloc_subdevices(dev, 4);
2366 if (ret < 0)
2367 return ret;
2368
2369 s = dev->subdevices + 0;
2370 dev->read_subdev = s;
2371 s->type = COMEDI_SUBD_AI;
2372 s->subdev_flags = SDF_READABLE | SDF_COMMON | SDF_GROUND | SDF_DIFF;
2373 if (devpriv->usemux)
2374 s->n_chan = devpriv->usemux;
2375 else
2376 s->n_chan = this_board->n_aichan;
2377
2378 s->maxdata = this_board->ai_maxdata;
2379 s->len_chanlist = this_board->n_aichanlist;
2380 s->range_table = this_board->rangelist_ai;
2381 s->cancel = pci9118_ai_cancel;
2382 s->insn_read = pci9118_insn_read_ai;
2383 if (dev->irq) {
2384 s->subdev_flags |= SDF_CMD_READ;
2385 s->do_cmdtest = pci9118_ai_cmdtest;
2386 s->do_cmd = pci9118_ai_cmd;
2387 s->munge = pci9118_ai_munge;
2388 }
2389
2390 s = dev->subdevices + 1;
2391 s->type = COMEDI_SUBD_AO;
2392 s->subdev_flags = SDF_WRITABLE | SDF_GROUND | SDF_COMMON;
2393 s->n_chan = this_board->n_aochan;
2394 s->maxdata = this_board->ao_maxdata;
2395 s->len_chanlist = this_board->n_aochan;
2396 s->range_table = this_board->rangelist_ao;
2397 s->insn_write = pci9118_insn_write_ao;
2398 s->insn_read = pci9118_insn_read_ao;
2399
2400 s = dev->subdevices + 2;
2401 s->type = COMEDI_SUBD_DI;
2402 s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_COMMON;
2403 s->n_chan = 4;
2404 s->maxdata = 1;
2405 s->len_chanlist = 4;
2406 s->range_table = &range_digital;
2407 s->io_bits = 0; /* all bits input */
2408 s->insn_bits = pci9118_insn_bits_di;
2409
2410 s = dev->subdevices + 3;
2411 s->type = COMEDI_SUBD_DO;
2412 s->subdev_flags = SDF_WRITABLE | SDF_GROUND | SDF_COMMON;
2413 s->n_chan = 4;
2414 s->maxdata = 1;
2415 s->len_chanlist = 4;
2416 s->range_table = &range_digital;
2417 s->io_bits = 0xf; /* all bits output */
2418 s->insn_bits = pci9118_insn_bits_do;
2419
2420 devpriv->valid = 1;
2421 devpriv->i8254_osc_base = 250; /* 250ns=4MHz */
2422 devpriv->ai_maskharderr = 0x10a;
2423 /* default measure crash condition */
2424 if (it->options[5]) /* disable some requested */
2425 devpriv->ai_maskharderr &= ~it->options[5];
2426
2427 switch (this_board->ai_maxdata) {
2428 case 0xffff:
2429 devpriv->ai16bits = 1;
2430 break;
2431 default:
2432 devpriv->ai16bits = 0;
2433 break;
2434 }
2435 return 0;
2436 }
2437
2438 /*
2439 ==============================================================================
2440 */
2441 static int pci9118_detach(struct comedi_device *dev)
2442 {
2443 if (dev->private) {
2444 if (devpriv->valid)
2445 pci9118_reset(dev);
2446 if (dev->irq)
2447 free_irq(dev->irq, dev);
2448 if (devpriv->pcidev) {
2449 if (dev->iobase)
2450 comedi_pci_disable(devpriv->pcidev);
2451
2452 pci_dev_put(devpriv->pcidev);
2453 }
2454 if (devpriv->dmabuf_virt[0])
2455 free_pages((unsigned long)devpriv->dmabuf_virt[0],
2456 devpriv->dmabuf_pages[0]);
2457 if (devpriv->dmabuf_virt[1])
2458 free_pages((unsigned long)devpriv->dmabuf_virt[1],
2459 devpriv->dmabuf_pages[1]);
2460 }
2461
2462 return 0;
2463 }
2464
2465 /*
2466 ==============================================================================
2467 */
2468
2469 MODULE_AUTHOR("Comedi http://www.comedi.org");
2470 MODULE_DESCRIPTION("Comedi low-level driver");
2471 MODULE_LICENSE("GPL");
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree