Merge branch 'kmemtrace-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git...
[linux-2.6] / drivers / staging / comedi / drivers / das16m1.c
1 /*
2     comedi/drivers/das16m1.c
3     CIO-DAS16/M1 driver
4     Author: Frank Mori Hess, based on code from the das16
5       driver.
6     Copyright (C) 2001 Frank Mori Hess <fmhess@users.sourceforge.net>
7
8     COMEDI - Linux Control and Measurement Device Interface
9     Copyright (C) 2000 David A. Schleef <ds@schleef.org>
10
11     This program is free software; you can redistribute it and/or modify
12     it under the terms of the GNU General Public License as published by
13     the Free Software Foundation; either version 2 of the License, or
14     (at your option) any later version.
15
16     This program is distributed in the hope that it will be useful,
17     but WITHOUT ANY WARRANTY; without even the implied warranty of
18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19     GNU General Public License for more details.
20
21     You should have received a copy of the GNU General Public License
22     along with this program; if not, write to the Free Software
23     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24
25 ************************************************************************
26 */
27 /*
28 Driver: das16m1
29 Description: CIO-DAS16/M1
30 Author: Frank Mori Hess <fmhess@users.sourceforge.net>
31 Devices: [Measurement Computing] CIO-DAS16/M1 (cio-das16/m1)
32 Status: works
33
34 This driver supports a single board - the CIO-DAS16/M1.
35 As far as I know, there are no other boards that have
36 the same register layout.  Even the CIO-DAS16/M1/16 is
37 significantly different.
38
39 I was _barely_ able to reach the full 1 MHz capability
40 of this board, using a hard real-time interrupt
41 (set the TRIG_RT flag in your struct comedi_cmd and use
42 rtlinux or RTAI).  The board can't do dma, so the bottleneck is
43 pulling the data across the ISA bus.  I timed the interrupt
44 handler, and it took my computer ~470 microseconds to pull 512
45 samples from the board.  So at 1 Mhz sampling rate,
46 expect your CPU to be spending almost all of its
47 time in the interrupt handler.
48
49 This board has some unusual restrictions for its channel/gain list.  If the
50 list has 2 or more channels in it, then two conditions must be satisfied:
51 (1) - even/odd channels must appear at even/odd indices in the list
52 (2) - the list must have an even number of entries.
53
54 Options:
55         [0] - base io address
56         [1] - irq (optional, but you probably want it)
57
58 irq can be omitted, although the cmd interface will not work without it.
59 */
60
61 #include <linux/ioport.h>
62 #include "../comedidev.h"
63
64 #include "8255.h"
65 #include "8253.h"
66 #include "comedi_fc.h"
67
68 #define DAS16M1_SIZE 16
69 #define DAS16M1_SIZE2 8
70
71 #define DAS16M1_XTAL 100        //10 MHz master clock
72
73 #define FIFO_SIZE 1024          // 1024 sample fifo
74
75 /*
76     CIO-DAS16_M1.pdf
77
78     "cio-das16/m1"
79
80   0     a/d bits 0-3, mux               start 12 bit
81   1     a/d bits 4-11           unused
82   2     status          control
83   3     di 4 bit                do 4 bit
84   4     unused                  clear interrupt
85   5     interrupt, pacer
86   6     channel/gain queue address
87   7     channel/gain queue data
88   89ab  8254
89   cdef  8254
90   400   8255
91   404-407       8254
92
93 */
94
95 #define DAS16M1_AI             0        // 16-bit wide register
96 #define   AI_CHAN(x)             ((x) & 0xf)
97 #define DAS16M1_CS             2
98 #define   EXT_TRIG_BIT           0x1
99 #define   OVRUN                  0x20
100 #define   IRQDATA                0x80
101 #define DAS16M1_DIO            3
102 #define DAS16M1_CLEAR_INTR     4
103 #define DAS16M1_INTR_CONTROL   5
104 #define   EXT_PACER              0x2
105 #define   INT_PACER              0x3
106 #define   PACER_MASK             0x3
107 #define   INTE                   0x80
108 #define DAS16M1_QUEUE_ADDR     6
109 #define DAS16M1_QUEUE_DATA     7
110 #define   Q_CHAN(x)              ((x) & 0x7)
111 #define   Q_RANGE(x)             (((x) & 0xf) << 4)
112 #define   UNIPOLAR               0x40
113 #define DAS16M1_8254_FIRST             0x8
114 #define DAS16M1_8254_FIRST_CNTRL       0xb
115 #define   TOTAL_CLEAR                    0x30
116 #define DAS16M1_8254_SECOND            0xc
117 #define DAS16M1_82C55                  0x400
118 #define DAS16M1_8254_THIRD             0x404
119
120 static const struct comedi_lrange range_das16m1 = { 9,
121         {
122                         BIP_RANGE(5),
123                         BIP_RANGE(2.5),
124                         BIP_RANGE(1.25),
125                         BIP_RANGE(0.625),
126                         UNI_RANGE(10),
127                         UNI_RANGE(5),
128                         UNI_RANGE(2.5),
129                         UNI_RANGE(1.25),
130                         BIP_RANGE(10),
131                 }
132 };
133
134 static int das16m1_do_wbits(struct comedi_device * dev, struct comedi_subdevice * s,
135         struct comedi_insn * insn, unsigned int * data);
136 static int das16m1_di_rbits(struct comedi_device * dev, struct comedi_subdevice * s,
137         struct comedi_insn * insn, unsigned int * data);
138 static int das16m1_ai_rinsn(struct comedi_device * dev, struct comedi_subdevice * s,
139         struct comedi_insn * insn, unsigned int * data);
140
141 static int das16m1_cmd_test(struct comedi_device * dev, struct comedi_subdevice * s,
142         struct comedi_cmd * cmd);
143 static int das16m1_cmd_exec(struct comedi_device * dev, struct comedi_subdevice * s);
144 static int das16m1_cancel(struct comedi_device * dev, struct comedi_subdevice * s);
145
146 static int das16m1_poll(struct comedi_device * dev, struct comedi_subdevice * s);
147 static irqreturn_t das16m1_interrupt(int irq, void *d PT_REGS_ARG);
148 static void das16m1_handler(struct comedi_device * dev, unsigned int status);
149
150 static unsigned int das16m1_set_pacer(struct comedi_device * dev, unsigned int ns,
151         int round_flag);
152
153 static int das16m1_irq_bits(unsigned int irq);
154
155 struct das16m1_board {
156         const char *name;
157         unsigned int ai_speed;
158 };
159
160 static const struct das16m1_board das16m1_boards[] = {
161         {
162               name:     "cio-das16/m1", // CIO-DAS16_M1.pdf
163               ai_speed:1000,    // 1MHz max speed
164                 },
165 };
166
167 #define das16m1_num_boards ((sizeof(das16m1_boards)) / (sizeof(das16m1_boards[0])))
168
169 static int das16m1_attach(struct comedi_device * dev, struct comedi_devconfig * it);
170 static int das16m1_detach(struct comedi_device * dev);
171 static struct comedi_driver driver_das16m1 = {
172       driver_name:"das16m1",
173       module:THIS_MODULE,
174       attach:das16m1_attach,
175       detach:das16m1_detach,
176       board_name:&das16m1_boards[0].name,
177       num_names:das16m1_num_boards,
178       offset:sizeof(das16m1_boards[0]),
179 };
180
181 struct das16m1_private_struct {
182         unsigned int control_state;
183         volatile unsigned int adc_count;        // number of samples completed
184         /* initial value in lower half of hardware conversion counter,
185          * needed to keep track of whether new count has been loaded into
186          * counter yet (loaded by first sample conversion) */
187         u16 initial_hw_count;
188         short ai_buffer[FIFO_SIZE];
189         unsigned int do_bits;   // saves status of digital output bits
190         unsigned int divisor1;  // divides master clock to obtain conversion speed
191         unsigned int divisor2;  // divides master clock to obtain conversion speed
192 };
193 #define devpriv ((struct das16m1_private_struct *)(dev->private))
194 #define thisboard ((const struct das16m1_board *)(dev->board_ptr))
195
196 COMEDI_INITCLEANUP(driver_das16m1);
197
198 static inline short munge_sample(short data)
199 {
200         return (data >> 4) & 0xfff;
201 }
202
203 static int das16m1_cmd_test(struct comedi_device * dev, struct comedi_subdevice * s,
204         struct comedi_cmd * cmd)
205 {
206         unsigned int err = 0, tmp, i;
207
208         /* make sure triggers are valid */
209         tmp = cmd->start_src;
210         cmd->start_src &= TRIG_NOW | TRIG_EXT;
211         if (!cmd->start_src || tmp != cmd->start_src)
212                 err++;
213
214         tmp = cmd->scan_begin_src;
215         cmd->scan_begin_src &= TRIG_FOLLOW;
216         if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
217                 err++;
218
219         tmp = cmd->convert_src;
220         cmd->convert_src &= TRIG_TIMER | TRIG_EXT;
221         if (!cmd->convert_src || tmp != cmd->convert_src)
222                 err++;
223
224         tmp = cmd->scan_end_src;
225         cmd->scan_end_src &= TRIG_COUNT;
226         if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
227                 err++;
228
229         tmp = cmd->stop_src;
230         cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
231         if (!cmd->stop_src || tmp != cmd->stop_src)
232                 err++;
233
234         if (err)
235                 return 1;
236
237         /* step 2: make sure trigger sources are unique and mutually compatible */
238         if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE)
239                 err++;
240         if (cmd->start_src != TRIG_NOW && cmd->start_src != TRIG_EXT)
241                 err++;
242         if (cmd->convert_src != TRIG_TIMER && cmd->convert_src != TRIG_EXT)
243                 err++;
244
245         if (err)
246                 return 2;
247
248         /* step 3: make sure arguments are trivially compatible */
249         if (cmd->start_arg != 0) {
250                 cmd->start_arg = 0;
251                 err++;
252         }
253
254         if (cmd->scan_begin_src == TRIG_FOLLOW) {
255                 /* internal trigger */
256                 if (cmd->scan_begin_arg != 0) {
257                         cmd->scan_begin_arg = 0;
258                         err++;
259                 }
260         }
261
262         if (cmd->convert_src == TRIG_TIMER) {
263                 if (cmd->convert_arg < thisboard->ai_speed) {
264                         cmd->convert_arg = thisboard->ai_speed;
265                         err++;
266                 }
267         }
268
269         if (cmd->scan_end_arg != cmd->chanlist_len) {
270                 cmd->scan_end_arg = cmd->chanlist_len;
271                 err++;
272         }
273
274         if (cmd->stop_src == TRIG_COUNT) {
275                 /* any count is allowed */
276         } else {
277                 /* TRIG_NONE */
278                 if (cmd->stop_arg != 0) {
279                         cmd->stop_arg = 0;
280                         err++;
281                 }
282         }
283
284         if (err)
285                 return 3;
286
287         /* step 4: fix up arguments */
288
289         if (cmd->convert_src == TRIG_TIMER) {
290                 tmp = cmd->convert_arg;
291                 /* calculate counter values that give desired timing */
292                 i8253_cascade_ns_to_timer_2div(DAS16M1_XTAL,
293                         &(devpriv->divisor1), &(devpriv->divisor2),
294                         &(cmd->convert_arg), cmd->flags & TRIG_ROUND_MASK);
295                 if (tmp != cmd->convert_arg)
296                         err++;
297         }
298
299         if (err)
300                 return 4;
301
302         // check chanlist against board's peculiarities
303         if (cmd->chanlist && cmd->chanlist_len > 1) {
304                 for (i = 0; i < cmd->chanlist_len; i++) {
305                         // even/odd channels must go into even/odd queue addresses
306                         if ((i % 2) != (CR_CHAN(cmd->chanlist[i]) % 2)) {
307                                 comedi_error(dev, "bad chanlist:\n"
308                                         " even/odd channels must go have even/odd chanlist indices");
309                                 err++;
310                         }
311                 }
312                 if ((cmd->chanlist_len % 2) != 0) {
313                         comedi_error(dev,
314                                 "chanlist must be of even length or length 1");
315                         err++;
316                 }
317         }
318
319         if (err)
320                 return 5;
321
322         return 0;
323 }
324
325 static int das16m1_cmd_exec(struct comedi_device * dev, struct comedi_subdevice * s)
326 {
327         struct comedi_async *async = s->async;
328         struct comedi_cmd *cmd = &async->cmd;
329         unsigned int byte, i;
330
331         if (dev->irq == 0) {
332                 comedi_error(dev, "irq required to execute comedi_cmd");
333                 return -1;
334         }
335
336         /* disable interrupts and internal pacer */
337         devpriv->control_state &= ~INTE & ~PACER_MASK;
338         outb(devpriv->control_state, dev->iobase + DAS16M1_INTR_CONTROL);
339
340         // set software count
341         devpriv->adc_count = 0;
342         /* Initialize lower half of hardware counter, used to determine how
343          * many samples are in fifo.  Value doesn't actually load into counter
344          * until counter's next clock (the next a/d conversion) */
345         i8254_load(dev->iobase + DAS16M1_8254_FIRST, 0, 1, 0, 2);
346         /* remember current reading of counter so we know when counter has
347          * actually been loaded */
348         devpriv->initial_hw_count =
349                 i8254_read(dev->iobase + DAS16M1_8254_FIRST, 0, 1);
350         /* setup channel/gain queue */
351         for (i = 0; i < cmd->chanlist_len; i++) {
352                 outb(i, dev->iobase + DAS16M1_QUEUE_ADDR);
353                 byte = Q_CHAN(CR_CHAN(cmd->
354                                 chanlist[i])) | Q_RANGE(CR_RANGE(cmd->
355                                 chanlist[i]));
356                 outb(byte, dev->iobase + DAS16M1_QUEUE_DATA);
357         }
358
359         /* set counter mode and counts */
360         cmd->convert_arg =
361                 das16m1_set_pacer(dev, cmd->convert_arg,
362                 cmd->flags & TRIG_ROUND_MASK);
363
364         // set control & status register
365         byte = 0;
366         /* if we are using external start trigger (also board dislikes having
367          * both start and conversion triggers external simultaneously) */
368         if (cmd->start_src == TRIG_EXT && cmd->convert_src != TRIG_EXT) {
369                 byte |= EXT_TRIG_BIT;
370         }
371         outb(byte, dev->iobase + DAS16M1_CS);
372         /* clear interrupt bit */
373         outb(0, dev->iobase + DAS16M1_CLEAR_INTR);
374
375         /* enable interrupts and internal pacer */
376         devpriv->control_state &= ~PACER_MASK;
377         if (cmd->convert_src == TRIG_TIMER) {
378                 devpriv->control_state |= INT_PACER;
379         } else {
380                 devpriv->control_state |= EXT_PACER;
381         }
382         devpriv->control_state |= INTE;
383         outb(devpriv->control_state, dev->iobase + DAS16M1_INTR_CONTROL);
384
385         return 0;
386 }
387
388 static int das16m1_cancel(struct comedi_device * dev, struct comedi_subdevice * s)
389 {
390         devpriv->control_state &= ~INTE & ~PACER_MASK;
391         outb(devpriv->control_state, dev->iobase + DAS16M1_INTR_CONTROL);
392
393         return 0;
394 }
395
396 static int das16m1_ai_rinsn(struct comedi_device * dev, struct comedi_subdevice * s,
397         struct comedi_insn * insn, unsigned int * data)
398 {
399         int i, n;
400         int byte;
401         const int timeout = 1000;
402
403         /* disable interrupts and internal pacer */
404         devpriv->control_state &= ~INTE & ~PACER_MASK;
405         outb(devpriv->control_state, dev->iobase + DAS16M1_INTR_CONTROL);
406
407         /* setup channel/gain queue */
408         outb(0, dev->iobase + DAS16M1_QUEUE_ADDR);
409         byte = Q_CHAN(CR_CHAN(insn->chanspec)) | Q_RANGE(CR_RANGE(insn->
410                         chanspec));
411         outb(byte, dev->iobase + DAS16M1_QUEUE_DATA);
412
413         for (n = 0; n < insn->n; n++) {
414                 /* clear IRQDATA bit */
415                 outb(0, dev->iobase + DAS16M1_CLEAR_INTR);
416                 /* trigger conversion */
417                 outb(0, dev->iobase);
418
419                 for (i = 0; i < timeout; i++) {
420                         if (inb(dev->iobase + DAS16M1_CS) & IRQDATA)
421                                 break;
422                 }
423                 if (i == timeout) {
424                         comedi_error(dev, "timeout");
425                         return -ETIME;
426                 }
427                 data[n] = munge_sample(inw(dev->iobase));
428         }
429
430         return n;
431 }
432
433 static int das16m1_di_rbits(struct comedi_device * dev, struct comedi_subdevice * s,
434         struct comedi_insn * insn, unsigned int * data)
435 {
436         unsigned int bits;
437
438         bits = inb(dev->iobase + DAS16M1_DIO) & 0xf;
439         data[1] = bits;
440         data[0] = 0;
441
442         return 2;
443 }
444
445 static int das16m1_do_wbits(struct comedi_device * dev, struct comedi_subdevice * s,
446         struct comedi_insn * insn, unsigned int * data)
447 {
448         unsigned int wbits;
449
450         // only set bits that have been masked
451         data[0] &= 0xf;
452         wbits = devpriv->do_bits;
453         // zero bits that have been masked
454         wbits &= ~data[0];
455         // set masked bits
456         wbits |= data[0] & data[1];
457         devpriv->do_bits = wbits;
458         data[1] = wbits;
459
460         outb(devpriv->do_bits, dev->iobase + DAS16M1_DIO);
461
462         return 2;
463 }
464
465 static int das16m1_poll(struct comedi_device * dev, struct comedi_subdevice * s)
466 {
467         unsigned long flags;
468         unsigned int status;
469
470         // prevent race with interrupt handler
471         comedi_spin_lock_irqsave(&dev->spinlock, flags);
472         status = inb(dev->iobase + DAS16M1_CS);
473         das16m1_handler(dev, status);
474         comedi_spin_unlock_irqrestore(&dev->spinlock, flags);
475
476         return s->async->buf_write_count - s->async->buf_read_count;
477 }
478
479 static irqreturn_t das16m1_interrupt(int irq, void *d PT_REGS_ARG)
480 {
481         int status;
482         struct comedi_device *dev = d;
483
484         if (dev->attached == 0) {
485                 comedi_error(dev, "premature interrupt");
486                 return IRQ_HANDLED;
487         }
488         // prevent race with comedi_poll()
489         spin_lock(&dev->spinlock);
490
491         status = inb(dev->iobase + DAS16M1_CS);
492
493         if ((status & (IRQDATA | OVRUN)) == 0) {
494                 comedi_error(dev, "spurious interrupt");
495                 spin_unlock(&dev->spinlock);
496                 return IRQ_NONE;
497         }
498
499         das16m1_handler(dev, status);
500
501         /* clear interrupt */
502         outb(0, dev->iobase + DAS16M1_CLEAR_INTR);
503
504         spin_unlock(&dev->spinlock);
505         return IRQ_HANDLED;
506 }
507
508 static void munge_sample_array(short * array, unsigned int num_elements)
509 {
510         unsigned int i;
511
512         for (i = 0; i < num_elements; i++) {
513                 array[i] = munge_sample(array[i]);
514         }
515 }
516
517 static void das16m1_handler(struct comedi_device * dev, unsigned int status)
518 {
519         struct comedi_subdevice *s;
520         struct comedi_async *async;
521         struct comedi_cmd *cmd;
522         u16 num_samples;
523         u16 hw_counter;
524
525         s = dev->read_subdev;
526         async = s->async;
527         async->events = 0;
528         cmd = &async->cmd;
529
530         // figure out how many samples are in fifo
531         hw_counter = i8254_read(dev->iobase + DAS16M1_8254_FIRST, 0, 1);
532         /* make sure hardware counter reading is not bogus due to initial value
533          * not having been loaded yet */
534         if (devpriv->adc_count == 0 && hw_counter == devpriv->initial_hw_count) {
535                 num_samples = 0;
536         } else {
537                 /* The calculation of num_samples looks odd, but it uses the following facts.
538                  * 16 bit hardware counter is initialized with value of zero (which really
539                  * means 0x1000).  The counter decrements by one on each conversion
540                  * (when the counter decrements from zero it goes to 0xffff).  num_samples
541                  * is a 16 bit variable, so it will roll over in a similar fashion to the
542                  * hardware counter.  Work it out, and this is what you get. */
543                 num_samples = -hw_counter - devpriv->adc_count;
544         }
545         // check if we only need some of the points
546         if (cmd->stop_src == TRIG_COUNT) {
547                 if (num_samples > cmd->stop_arg * cmd->chanlist_len)
548                         num_samples = cmd->stop_arg * cmd->chanlist_len;
549         }
550         // make sure we dont try to get too many points if fifo has overrun
551         if (num_samples > FIFO_SIZE)
552                 num_samples = FIFO_SIZE;
553         insw(dev->iobase, devpriv->ai_buffer, num_samples);
554         munge_sample_array(devpriv->ai_buffer, num_samples);
555         cfc_write_array_to_buffer(s, devpriv->ai_buffer,
556                 num_samples * sizeof(short));
557         devpriv->adc_count += num_samples;
558
559         if (cmd->stop_src == TRIG_COUNT) {
560                 if (devpriv->adc_count >= cmd->stop_arg * cmd->chanlist_len) {  /* end of acquisition */
561                         das16m1_cancel(dev, s);
562                         async->events |= COMEDI_CB_EOA;
563                 }
564         }
565
566         /* this probably won't catch overruns since the card doesn't generate
567          * overrun interrupts, but we might as well try */
568         if (status & OVRUN) {
569                 das16m1_cancel(dev, s);
570                 async->events |= COMEDI_CB_EOA | COMEDI_CB_ERROR;
571                 comedi_error(dev, "fifo overflow");
572         }
573
574         comedi_event(dev, s);
575
576 }
577
578 /* This function takes a time in nanoseconds and sets the     *
579  * 2 pacer clocks to the closest frequency possible. It also  *
580  * returns the actual sampling period.                        */
581 static unsigned int das16m1_set_pacer(struct comedi_device * dev, unsigned int ns,
582         int rounding_flags)
583 {
584         i8253_cascade_ns_to_timer_2div(DAS16M1_XTAL, &(devpriv->divisor1),
585                 &(devpriv->divisor2), &ns, rounding_flags & TRIG_ROUND_MASK);
586
587         /* Write the values of ctr1 and ctr2 into counters 1 and 2 */
588         i8254_load(dev->iobase + DAS16M1_8254_SECOND, 0, 1, devpriv->divisor1,
589                 2);
590         i8254_load(dev->iobase + DAS16M1_8254_SECOND, 0, 2, devpriv->divisor2,
591                 2);
592
593         return ns;
594 }
595
596 static int das16m1_irq_bits(unsigned int irq)
597 {
598         int ret;
599
600         switch (irq) {
601         case 10:
602                 ret = 0x0;
603                 break;
604         case 11:
605                 ret = 0x1;
606                 break;
607         case 12:
608                 ret = 0x2;
609                 break;
610         case 15:
611                 ret = 0x3;
612                 break;
613         case 2:
614                 ret = 0x4;
615                 break;
616         case 3:
617                 ret = 0x5;
618                 break;
619         case 5:
620                 ret = 0x6;
621                 break;
622         case 7:
623                 ret = 0x7;
624                 break;
625         default:
626                 return -1;
627                 break;
628         }
629         return (ret << 4);
630 }
631
632 /*
633  * Options list:
634  *   0  I/O base
635  *   1  IRQ
636  */
637
638 static int das16m1_attach(struct comedi_device * dev, struct comedi_devconfig * it)
639 {
640         struct comedi_subdevice *s;
641         int ret;
642         unsigned int irq;
643         unsigned long iobase;
644
645         iobase = it->options[0];
646
647         printk("comedi%d: das16m1:", dev->minor);
648
649         if ((ret = alloc_private(dev,
650                                 sizeof(struct das16m1_private_struct))) < 0)
651                 return ret;
652
653         dev->board_name = thisboard->name;
654
655         printk(" io 0x%lx-0x%lx 0x%lx-0x%lx",
656                 iobase, iobase + DAS16M1_SIZE,
657                 iobase + DAS16M1_82C55, iobase + DAS16M1_82C55 + DAS16M1_SIZE2);
658         if (!request_region(iobase, DAS16M1_SIZE, driver_das16m1.driver_name)) {
659                 printk(" I/O port conflict\n");
660                 return -EIO;
661         }
662         if (!request_region(iobase + DAS16M1_82C55, DAS16M1_SIZE2,
663                         driver_das16m1.driver_name)) {
664                 release_region(iobase, DAS16M1_SIZE);
665                 printk(" I/O port conflict\n");
666                 return -EIO;
667         }
668         dev->iobase = iobase;
669
670         /* now for the irq */
671         irq = it->options[1];
672         // make sure it is valid
673         if (das16m1_irq_bits(irq) >= 0) {
674                 ret = comedi_request_irq(irq, das16m1_interrupt, 0,
675                         driver_das16m1.driver_name, dev);
676                 if (ret < 0) {
677                         printk(", irq unavailable\n");
678                         return ret;
679                 }
680                 dev->irq = irq;
681                 printk(", irq %u\n", irq);
682         } else if (irq == 0) {
683                 printk(", no irq\n");
684         } else {
685                 printk(", invalid irq\n"
686                         " valid irqs are 2, 3, 5, 7, 10, 11, 12, or 15\n");
687                 return -EINVAL;
688         }
689
690         if ((ret = alloc_subdevices(dev, 4)) < 0)
691                 return ret;
692
693         s = dev->subdevices + 0;
694         dev->read_subdev = s;
695         /* ai */
696         s->type = COMEDI_SUBD_AI;
697         s->subdev_flags = SDF_READABLE | SDF_CMD_READ;
698         s->n_chan = 8;
699         s->subdev_flags = SDF_DIFF;
700         s->len_chanlist = 256;
701         s->maxdata = (1 << 12) - 1;
702         s->range_table = &range_das16m1;
703         s->insn_read = das16m1_ai_rinsn;
704         s->do_cmdtest = das16m1_cmd_test;
705         s->do_cmd = das16m1_cmd_exec;
706         s->cancel = das16m1_cancel;
707         s->poll = das16m1_poll;
708
709         s = dev->subdevices + 1;
710         /* di */
711         s->type = COMEDI_SUBD_DI;
712         s->subdev_flags = SDF_READABLE;
713         s->n_chan = 4;
714         s->maxdata = 1;
715         s->range_table = &range_digital;
716         s->insn_bits = das16m1_di_rbits;
717
718         s = dev->subdevices + 2;
719         /* do */
720         s->type = COMEDI_SUBD_DO;
721         s->subdev_flags = SDF_WRITABLE | SDF_READABLE;
722         s->n_chan = 4;
723         s->maxdata = 1;
724         s->range_table = &range_digital;
725         s->insn_bits = das16m1_do_wbits;
726
727         s = dev->subdevices + 3;
728         /* 8255 */
729         subdev_8255_init(dev, s, NULL, dev->iobase + DAS16M1_82C55);
730
731         // disable upper half of hardware conversion counter so it doesn't mess with us
732         outb(TOTAL_CLEAR, dev->iobase + DAS16M1_8254_FIRST_CNTRL);
733
734         // initialize digital output lines
735         outb(devpriv->do_bits, dev->iobase + DAS16M1_DIO);
736
737         /* set the interrupt level */
738         if (dev->irq)
739                 devpriv->control_state = das16m1_irq_bits(dev->irq);
740         else
741                 devpriv->control_state = 0;
742         outb(devpriv->control_state, dev->iobase + DAS16M1_INTR_CONTROL);
743
744         return 0;
745 }
746
747 static int das16m1_detach(struct comedi_device * dev)
748 {
749         printk("comedi%d: das16m1: remove\n", dev->minor);
750
751 //      das16m1_reset(dev);
752
753         if (dev->subdevices)
754                 subdev_8255_cleanup(dev, dev->subdevices + 3);
755
756         if (dev->irq)
757                 comedi_free_irq(dev->irq, dev);
758
759         if (dev->iobase) {
760                 release_region(dev->iobase, DAS16M1_SIZE);
761                 release_region(dev->iobase + DAS16M1_82C55, DAS16M1_SIZE2);
762         }
763
764         return 0;
765 }