git.oblomov.eu Git - linux-2.6/blob - drivers/staging/comedi/drivers/pcl816.c

   1 /*
   2    comedi/drivers/pcl816.c
   3
   4    Author:  Juan Grigera <juan@grigera.com.ar>
   5             based on pcl818 by Michal Dobes <dobes@tesnet.cz> and bits of pcl812
   6
   7    hardware driver for Advantech cards:
   8     card:   PCL-816, PCL814B
   9     driver: pcl816
  10 */
  11 /*
  12 Driver: pcl816
  13 Description: Advantech PCL-816 cards, PCL-814
  14 Author: Juan Grigera <juan@grigera.com.ar>
  15 Devices: [Advantech] PCL-816 (pcl816), PCL-814B (pcl814b)
  16 Status: works
  17 Updated: Tue,  2 Apr 2002 23:15:21 -0800
  18
  19 PCL 816 and 814B have 16 SE/DIFF ADCs, 16 DACs, 16 DI and 16 DO.
  20 Differences are at resolution (16 vs 12 bits).
  21
  22 The driver support AI command mode, other subdevices not written.
  23
  24 Analog output and digital input and output are not supported.
  25
  26 Configuration Options:
  27   [0] - IO Base
  28   [1] - IRQ     (0=disable, 2, 3, 4, 5, 6, 7)
  29   [2] - DMA     (0=disable, 1, 3)
  30   [3] - 0, 10=10MHz clock for 8254
  31             1= 1MHz clock for 8254
  32
  33 */
  34
  35 #include "../comedidev.h"
  36
  37 #include <linux/ioport.h>
  38 #include <linux/mc146818rtc.h>
  39 #include <linux/delay.h>
  40 #include <asm/dma.h>
  41
  42 #include "8253.h"
  43
  44 #define DEBUG(x) x
  45
  46 // boards constants
  47 // IO space len
  48 #define PCLx1x_RANGE 16
  49
  50 //#define outb(x,y)  printk("OUTB(%x, 200+%d)\n", x,y-0x200); outb(x,y)
  51
  52 // INTEL 8254 counters
  53 #define PCL816_CTR0 4
  54 #define PCL816_CTR1 5
  55 #define PCL816_CTR2 6
  56 // R: counter read-back register W: counter control
  57 #define PCL816_CTRCTL 7
  58
  59 // R: A/D high byte W: A/D range control
  60 #define PCL816_RANGE 9
  61 // W: clear INT request
  62 #define PCL816_CLRINT 10
  63 // R: next mux scan channel W: mux scan channel & range control pointer
  64 #define PCL816_MUX 11
  65 // R/W: operation control register
  66 #define PCL816_CONTROL 12
  67
  68 // R: return status byte  W: set DMA/IRQ
  69 #define PCL816_STATUS 13
  70 #define PCL816_STATUS_DRDY_MASK 0x80
  71
  72 // R: low byte of A/D W: soft A/D trigger
  73 #define PCL816_AD_LO 8
  74 // R: high byte of A/D W: A/D range control
  75 #define PCL816_AD_HI 9
  76
  77 // type of interrupt handler
  78 #define INT_TYPE_AI1_INT 1
  79 #define INT_TYPE_AI1_DMA 2
  80 #define INT_TYPE_AI3_INT 4
  81 #define INT_TYPE_AI3_DMA 5
  82 #ifdef unused
  83 #define INT_TYPE_AI1_DMA_RTC 9
  84 #define INT_TYPE_AI3_DMA_RTC 10
  85
  86 // RTC stuff...
  87 #define RTC_IRQ         8
  88 #define RTC_IO_EXTENT   0x10
  89 #endif
  90
  91 #define MAGIC_DMA_WORD 0x5a5a
  92
  93 static const struct comedi_lrange range_pcl816 = { 8, {
  94                         BIP_RANGE(10),
  95                         BIP_RANGE(5),
  96                         BIP_RANGE(2.5),
  97                         BIP_RANGE(1.25),
  98                         UNI_RANGE(10),
  99                         UNI_RANGE(5),
 100                         UNI_RANGE(2.5),
 101                         UNI_RANGE(1.25),
 102         }
 103 };
 104 struct pcl816_board {
 105
 106         const char *name;       // board name
 107         int n_ranges;           // len of range list
 108         int n_aichan;           // num of A/D chans in diferencial mode
 109         unsigned int ai_ns_min; // minimal alllowed delay between samples (in ns)
 110         int n_aochan;           // num of D/A chans
 111         int n_dichan;           // num of DI chans
 112         int n_dochan;           // num of DO chans
 113         const struct comedi_lrange *ai_range_type;      // default A/D rangelist
 114         const struct comedi_lrange *ao_range_type;      // dafault D/A rangelist
 115         unsigned int io_range;  // len of IO space
 116         unsigned int IRQbits;   // allowed interrupts
 117         unsigned int DMAbits;   // allowed DMA chans
 118         int ai_maxdata;         // maxdata for A/D
 119         int ao_maxdata;         // maxdata for D/A
 120         int ai_chanlist;        // allowed len of channel list A/D
 121         int ao_chanlist;        // allowed len of channel list D/A
 122         int i8254_osc_base;     // 1/frequency of on board oscilator in ns
 123 };
 124
 125
 126 static const struct pcl816_board boardtypes[] = {
 127         {"pcl816", 8, 16, 10000, 1, 16, 16, &range_pcl816,
 128                         &range_pcl816, PCLx1x_RANGE,
 129                         0x00fc, // IRQ mask
 130                         0x0a,   // DMA mask
 131                         0xffff, // 16-bit card
 132                         0xffff, // D/A maxdata
 133                         1024,
 134                         1,      // ao chan list
 135                 100},
 136         {"pcl814b", 8, 16, 10000, 1, 16, 16, &range_pcl816,
 137                         &range_pcl816, PCLx1x_RANGE,
 138                         0x00fc,
 139                         0x0a,
 140                         0x3fff, /* 14 bit card */
 141                         0x3fff,
 142                         1024,
 143                         1,
 144                 100},
 145 };
 146
 147 #define n_boardtypes (sizeof(boardtypes)/sizeof(struct pcl816_board))
 148 #define devpriv ((struct pcl816_private *)dev->private)
 149 #define this_board ((const struct pcl816_board *)dev->board_ptr)
 150
 151 static int pcl816_attach(struct comedi_device * dev, struct comedi_devconfig * it);
 152 static int pcl816_detach(struct comedi_device * dev);
 153
 154 #ifdef unused
 155 static int RTC_lock = 0;        /* RTC lock */
 156 static int RTC_timer_lock = 0;  /* RTC int lock */
 157 #endif
 158
 159 static struct comedi_driver driver_pcl816 = {
 160       driver_name:"pcl816",
 161       module:THIS_MODULE,
 162       attach:pcl816_attach,
 163       detach:pcl816_detach,
 164       board_name:&boardtypes[0].name,
 165       num_names:n_boardtypes,
 166       offset:sizeof(struct pcl816_board),
 167 };
 168
 169 COMEDI_INITCLEANUP(driver_pcl816);
 170
 171 struct pcl816_private {
 172
 173         unsigned int dma;       // used DMA, 0=don't use DMA
 174         int dma_rtc;            // 1=RTC used with DMA, 0=no RTC alloc
 175 #ifdef unused
 176         unsigned long rtc_iobase;       // RTC port region
 177         unsigned int rtc_iosize;
 178         unsigned int rtc_irq;
 179 #endif
 180         unsigned long dmabuf[2];        // pointers to begin of DMA buffers
 181         unsigned int dmapages[2];       // len of DMA buffers in PAGE_SIZEs
 182         unsigned int hwdmaptr[2];       // hardware address of DMA buffers
 183         unsigned int hwdmasize[2];      // len of DMA buffers in Bytes
 184         unsigned int dmasamplsize;      // size in samples hwdmasize[0]/2
 185         unsigned int last_top_dma;      // DMA pointer in last RTC int
 186         int next_dma_buf;       // which DMA buffer will be used next round
 187         long dma_runs_to_end;   // how many we must permorm DMA transfer to end of record
 188         unsigned long last_dma_run;     // how many bytes we must transfer on last DMA page
 189
 190         unsigned int ai_scans;  // len of scanlist
 191         unsigned char ai_neverending;   // if=1, then we do neverending record (you must use cancel())
 192         int irq_free;           // 1=have allocated IRQ
 193         int irq_blocked;        // 1=IRQ now uses any subdev
 194 #ifdef unused
 195         int rtc_irq_blocked;    // 1=we now do AI with DMA&RTC
 196 #endif
 197         int irq_was_now_closed; // when IRQ finish, there's stored int816_mode for last interrupt
 198         int int816_mode;        // who now uses IRQ - 1=AI1 int, 2=AI1 dma, 3=AI3 int, 4AI3 dma
 199         struct comedi_subdevice *last_int_sub;  // ptr to subdevice which now finish
 200         int ai_act_scan;        // how many scans we finished
 201         unsigned int ai_act_chanlist[16];       // MUX setting for actual AI operations
 202         unsigned int ai_act_chanlist_len;       // how long is actual MUX list
 203         unsigned int ai_act_chanlist_pos;       // actual position in MUX list
 204         unsigned int ai_poll_ptr;       // how many sampes transfer poll
 205         struct comedi_subdevice *sub_ai;        // ptr to AI subdevice
 206 #ifdef unused
 207         struct timer_list rtc_irq_timer;        // timer for RTC sanity check
 208         unsigned long rtc_freq; // RTC int freq
 209 #endif
 210 };
 211
 212
 213 /*
 214 ==============================================================================
 215 */
 216 static int check_and_setup_channel_list(struct comedi_device * dev,
 217         struct comedi_subdevice * s, unsigned int *chanlist, int chanlen);
 218 static int pcl816_ai_cancel(struct comedi_device * dev, struct comedi_subdevice * s);
 219 static void start_pacer(struct comedi_device * dev, int mode, unsigned int divisor1,
 220         unsigned int divisor2);
 221 #ifdef unused
 222 static int set_rtc_irq_bit(unsigned char bit);
 223 #endif
 224
 225 static int pcl816_ai_cmdtest(struct comedi_device * dev, struct comedi_subdevice * s,
 226         struct comedi_cmd * cmd);
 227 static int pcl816_ai_cmd(struct comedi_device * dev, struct comedi_subdevice * s);
 228
 229 /*
 230 ==============================================================================
 231    ANALOG INPUT MODE0, 816 cards, slow version
 232 */
 233 static int pcl816_ai_insn_read(struct comedi_device * dev, struct comedi_subdevice * s,
 234         struct comedi_insn * insn, unsigned int * data)
 235 {
 236         int n;
 237         int timeout;
 238
 239         DPRINTK("mode 0 analog input\n");
 240         // software trigger, DMA and INT off
 241         outb(0, dev->iobase + PCL816_CONTROL);
 242         // clear INT (conversion end) flag
 243         outb(0, dev->iobase + PCL816_CLRINT);
 244
 245         // Set the input channel
 246         outb(CR_CHAN(insn->chanspec) & 0xf, dev->iobase + PCL816_MUX);
 247         outb(CR_RANGE(insn->chanspec), dev->iobase + PCL816_RANGE);     /* select gain */
 248
 249         for (n = 0; n < insn->n; n++) {
 250
 251                 outb(0, dev->iobase + PCL816_AD_LO);    /* start conversion */
 252
 253                 timeout = 100;
 254                 while (timeout--) {
 255                         if (!(inb(dev->iobase + PCL816_STATUS) &
 256                                         PCL816_STATUS_DRDY_MASK)) {
 257                                 // return read value
 258                                 data[n] =
 259                                         ((inb(dev->iobase +
 260                                                         PCL816_AD_HI) << 8) |
 261                                         (inb(dev->iobase + PCL816_AD_LO)));
 262
 263                                 outb(0, dev->iobase + PCL816_CLRINT);   /* clear INT (conversion end) flag */
 264                                 break;
 265                         }
 266                         comedi_udelay(1);
 267                 }
 268                 // Return timeout error
 269                 if (!timeout) {
 270                         comedi_error(dev, "A/D insn timeout\n");
 271                         data[0] = 0;
 272                         outb(0, dev->iobase + PCL816_CLRINT);   /* clear INT (conversion end) flag */
 273                         return -EIO;
 274                 }
 275
 276         }
 277         return n;
 278 }
 279
 280 /*
 281 ==============================================================================
 282    analog input interrupt mode 1 & 3, 818 cards
 283    one sample per interrupt version
 284 */
 285 static irqreturn_t interrupt_pcl816_ai_mode13_int(int irq, void *d)
 286 {
 287         struct comedi_device *dev = d;
 288         struct comedi_subdevice *s = dev->subdevices + 0;
 289         int low, hi;
 290         int timeout = 50;       /* wait max 50us */
 291
 292         while (timeout--) {
 293                 if (!(inb(dev->iobase + PCL816_STATUS) &
 294                                 PCL816_STATUS_DRDY_MASK))
 295                         break;
 296                 comedi_udelay(1);
 297         }
 298         if (!timeout) {         // timeout, bail error
 299                 outb(0, dev->iobase + PCL816_CLRINT);   /* clear INT request */
 300                 comedi_error(dev, "A/D mode1/3 IRQ without DRDY!");
 301                 pcl816_ai_cancel(dev, s);
 302                 s->async->events |= COMEDI_CB_EOA | COMEDI_CB_ERROR;
 303                 comedi_event(dev, s);
 304                 return IRQ_HANDLED;
 305
 306         }
 307
 308         // get the sample
 309         low = inb(dev->iobase + PCL816_AD_LO);
 310         hi = inb(dev->iobase + PCL816_AD_HI);
 311
 312         comedi_buf_put(s->async, (hi << 8) | low);
 313
 314         outb(0, dev->iobase + PCL816_CLRINT);   /* clear INT request */
 315
 316         if (++devpriv->ai_act_chanlist_pos >= devpriv->ai_act_chanlist_len)
 317                 devpriv->ai_act_chanlist_pos = 0;
 318
 319         if (s->async->cur_chan == 0) {
 320                 devpriv->ai_act_scan++;
 321         }
 322
 323         if (!devpriv->ai_neverending)
 324                 if (devpriv->ai_act_scan >= devpriv->ai_scans) {        /* all data sampled */
 325                         /* all data sampled */
 326                         pcl816_ai_cancel(dev, s);
 327                         s->async->events |= COMEDI_CB_EOA;
 328                 }
 329         comedi_event(dev, s);
 330         return IRQ_HANDLED;
 331 }
 332
 333 /*
 334 ==============================================================================
 335    analog input dma mode 1 & 3, 816 cards
 336 */
 337 static void transfer_from_dma_buf(struct comedi_device * dev, struct comedi_subdevice * s,
 338         short * ptr, unsigned int bufptr, unsigned int len)
 339 {
 340         int i;
 341
 342         s->async->events = 0;
 343
 344         for (i = 0; i < len; i++) {
 345
 346                 comedi_buf_put(s->async, ptr[bufptr++]);
 347
 348                 if (++devpriv->ai_act_chanlist_pos >=
 349                         devpriv->ai_act_chanlist_len) {
 350                         devpriv->ai_act_chanlist_pos = 0;
 351                         devpriv->ai_act_scan++;
 352                 }
 353
 354                 if (!devpriv->ai_neverending)
 355                         if (devpriv->ai_act_scan >= devpriv->ai_scans) {        // all data sampled
 356                                 pcl816_ai_cancel(dev, s);
 357                                 s->async->events |= COMEDI_CB_EOA;
 358                                 s->async->events |= COMEDI_CB_BLOCK;
 359                                 break;
 360                         }
 361         }
 362
 363         comedi_event(dev, s);
 364 }
 365
 366 static irqreturn_t interrupt_pcl816_ai_mode13_dma(int irq, void *d)
 367 {
 368         struct comedi_device *dev = d;
 369         struct comedi_subdevice *s = dev->subdevices + 0;
 370         int len, bufptr, this_dma_buf;
 371         unsigned long dma_flags;
 372         short *ptr;
 373
 374         disable_dma(devpriv->dma);
 375         this_dma_buf = devpriv->next_dma_buf;
 376
 377         if ((devpriv->dma_runs_to_end > -1) || devpriv->ai_neverending) {       // switch dma bufs
 378
 379                 devpriv->next_dma_buf = 1 - devpriv->next_dma_buf;
 380                 set_dma_mode(devpriv->dma, DMA_MODE_READ);
 381                 dma_flags = claim_dma_lock();
 382 //  clear_dma_ff (devpriv->dma);
 383                 set_dma_addr(devpriv->dma,
 384                         devpriv->hwdmaptr[devpriv->next_dma_buf]);
 385                 if (devpriv->dma_runs_to_end) {
 386                         set_dma_count(devpriv->dma,
 387                                 devpriv->hwdmasize[devpriv->next_dma_buf]);
 388                 } else {
 389                         set_dma_count(devpriv->dma, devpriv->last_dma_run);
 390                 }
 391                 release_dma_lock(dma_flags);
 392                 enable_dma(devpriv->dma);
 393         }
 394
 395         devpriv->dma_runs_to_end--;
 396         outb(0, dev->iobase + PCL816_CLRINT);   /* clear INT request */
 397
 398         ptr = (short *) devpriv->dmabuf[this_dma_buf];
 399
 400         len = (devpriv->hwdmasize[0] >> 1) - devpriv->ai_poll_ptr;
 401         bufptr = devpriv->ai_poll_ptr;
 402         devpriv->ai_poll_ptr = 0;
 403
 404         transfer_from_dma_buf(dev, s, ptr, bufptr, len);
 405         return IRQ_HANDLED;
 406 }
 407
 408 /*
 409 ==============================================================================
 410     INT procedure
 411 */
 412 static irqreturn_t interrupt_pcl816(int irq, void *d PT_REGS_ARG)
 413 {
 414         struct comedi_device *dev = d;
 415         DPRINTK("<I>");
 416
 417         if (!dev->attached) {
 418                 comedi_error(dev, "premature interrupt");
 419                 return IRQ_HANDLED;
 420         }
 421
 422         switch (devpriv->int816_mode) {
 423         case INT_TYPE_AI1_DMA:
 424         case INT_TYPE_AI3_DMA:
 425                 return interrupt_pcl816_ai_mode13_dma(irq, d);
 426         case INT_TYPE_AI1_INT:
 427         case INT_TYPE_AI3_INT:
 428                 return interrupt_pcl816_ai_mode13_int(irq, d);
 429         }
 430
 431         outb(0, dev->iobase + PCL816_CLRINT);   /* clear INT request */
 432         if ((!dev->irq) | (!devpriv->irq_free) | (!devpriv->irq_blocked) |
 433                 (!devpriv->int816_mode)) {
 434                 if (devpriv->irq_was_now_closed) {
 435                         devpriv->irq_was_now_closed = 0;
 436                         // comedi_error(dev,"last IRQ..");
 437                         return IRQ_HANDLED;
 438                 }
 439                 comedi_error(dev, "bad IRQ!");
 440                 return IRQ_NONE;
 441         }
 442         comedi_error(dev, "IRQ from unknow source!");
 443         return IRQ_NONE;
 444 }
 445
 446 /*
 447 ==============================================================================
 448    COMMAND MODE
 449 */
 450 static void pcl816_cmdtest_out(int e, struct comedi_cmd * cmd)
 451 {
 452         rt_printk("pcl816 e=%d startsrc=%x scansrc=%x convsrc=%x\n", e,
 453                 cmd->start_src, cmd->scan_begin_src, cmd->convert_src);
 454         rt_printk("pcl816 e=%d startarg=%d scanarg=%d convarg=%d\n", e,
 455                 cmd->start_arg, cmd->scan_begin_arg, cmd->convert_arg);
 456         rt_printk("pcl816 e=%d stopsrc=%x scanend=%x\n", e, cmd->stop_src,
 457                 cmd->scan_end_src);
 458         rt_printk("pcl816 e=%d stoparg=%d scanendarg=%d chanlistlen=%d\n", e,
 459                 cmd->stop_arg, cmd->scan_end_arg, cmd->chanlist_len);
 460 }
 461
 462 /*
 463 ==============================================================================
 464 */
 465 static int pcl816_ai_cmdtest(struct comedi_device * dev, struct comedi_subdevice * s,
 466         struct comedi_cmd * cmd)
 467 {
 468         int err = 0;
 469         int tmp, divisor1, divisor2;
 470
 471         DEBUG(rt_printk("pcl816 pcl812_ai_cmdtest\n");
 472                 pcl816_cmdtest_out(-1, cmd););
 473
 474         /* step 1: make sure trigger sources are trivially valid */
 475         tmp = cmd->start_src;
 476         cmd->start_src &= TRIG_NOW;
 477         if (!cmd->start_src || tmp != cmd->start_src)
 478                 err++;
 479
 480         tmp = cmd->scan_begin_src;
 481         cmd->scan_begin_src &= TRIG_FOLLOW;
 482         if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
 483                 err++;
 484
 485         if (!cmd->convert_src & (TRIG_EXT | TRIG_TIMER))
 486                 err++;
 487
 488         tmp = cmd->scan_end_src;
 489         cmd->scan_end_src &= TRIG_COUNT;
 490         if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
 491                 err++;
 492
 493         tmp = cmd->stop_src;
 494         cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
 495         if (!cmd->stop_src || tmp != cmd->stop_src)
 496                 err++;
 497
 498         if (err) {
 499                 return 1;
 500         }
 501
 502         /* step 2: make sure trigger sources are unique and mutually compatible */
 503
 504         if (cmd->start_src != TRIG_NOW) {
 505                 cmd->start_src = TRIG_NOW;
 506                 err++;
 507         }
 508
 509         if (cmd->scan_begin_src != TRIG_FOLLOW) {
 510                 cmd->scan_begin_src = TRIG_FOLLOW;
 511                 err++;
 512         }
 513
 514         if (cmd->convert_src != TRIG_EXT && cmd->convert_src != TRIG_TIMER) {
 515                 cmd->convert_src = TRIG_TIMER;
 516                 err++;
 517         }
 518
 519         if (cmd->scan_end_src != TRIG_COUNT) {
 520                 cmd->scan_end_src = TRIG_COUNT;
 521                 err++;
 522         }
 523
 524         if (cmd->stop_src != TRIG_NONE && cmd->stop_src != TRIG_COUNT)
 525                 err++;
 526
 527         if (err) {
 528                 return 2;
 529         }
 530
 531         /* step 3: make sure arguments are trivially compatible */
 532         if (cmd->start_arg != 0) {
 533                 cmd->start_arg = 0;
 534                 err++;
 535         }
 536
 537         if (cmd->scan_begin_arg != 0) {
 538                 cmd->scan_begin_arg = 0;
 539                 err++;
 540         }
 541         if (cmd->convert_src == TRIG_TIMER) {
 542                 if (cmd->convert_arg < this_board->ai_ns_min) {
 543                         cmd->convert_arg = this_board->ai_ns_min;
 544                         err++;
 545                 }
 546         } else {                /* TRIG_EXT */
 547                 if (cmd->convert_arg != 0) {
 548                         cmd->convert_arg = 0;
 549                         err++;
 550                 }
 551         }
 552
 553         if (!cmd->chanlist_len) {
 554                 cmd->chanlist_len = 1;
 555                 err++;
 556         }
 557         if (cmd->chanlist_len > this_board->n_aichan) {
 558                 cmd->chanlist_len = this_board->n_aichan;
 559                 err++;
 560         }
 561         if (cmd->scan_end_arg != cmd->chanlist_len) {
 562                 cmd->scan_end_arg = cmd->chanlist_len;
 563                 err++;
 564         }
 565         if (cmd->stop_src == TRIG_COUNT) {
 566                 if (!cmd->stop_arg) {
 567                         cmd->stop_arg = 1;
 568                         err++;
 569                 }
 570         } else {                /* TRIG_NONE */
 571                 if (cmd->stop_arg != 0) {
 572                         cmd->stop_arg = 0;
 573                         err++;
 574                 }
 575         }
 576
 577         if (err) {
 578                 return 3;
 579         }
 580
 581         /* step 4: fix up any arguments */
 582         if (cmd->convert_src == TRIG_TIMER) {
 583                 tmp = cmd->convert_arg;
 584                 i8253_cascade_ns_to_timer(this_board->i8254_osc_base,
 585                         &divisor1, &divisor2, &cmd->convert_arg,
 586                         cmd->flags & TRIG_ROUND_MASK);
 587                 if (cmd->convert_arg < this_board->ai_ns_min)
 588                         cmd->convert_arg = this_board->ai_ns_min;
 589                 if (tmp != cmd->convert_arg)
 590                         err++;
 591         }
 592
 593         if (err) {
 594                 return 4;
 595         }
 596
 597         return 0;
 598 }
 599
 600 static int pcl816_ai_cmd(struct comedi_device * dev, struct comedi_subdevice * s)
 601 {
 602         unsigned int divisor1 = 0, divisor2 = 0, dma_flags, bytes, dmairq;
 603         struct comedi_cmd *cmd = &s->async->cmd;
 604
 605         if (cmd->start_src != TRIG_NOW)
 606                 return -EINVAL;
 607         if (cmd->scan_begin_src != TRIG_FOLLOW)
 608                 return -EINVAL;
 609         if (cmd->scan_end_src != TRIG_COUNT)
 610                 return -EINVAL;
 611         if (cmd->scan_end_arg != cmd->chanlist_len)
 612                 return -EINVAL;
 613 //      if(cmd->chanlist_len>MAX_CHANLIST_LEN) return -EINVAL;
 614         if (devpriv->irq_blocked)
 615                 return -EBUSY;
 616
 617         if (cmd->convert_src == TRIG_TIMER) {
 618                 if (cmd->convert_arg < this_board->ai_ns_min)
 619                         cmd->convert_arg = this_board->ai_ns_min;
 620
 621                 i8253_cascade_ns_to_timer(this_board->i8254_osc_base, &divisor1,
 622                         &divisor2, &cmd->convert_arg,
 623                         cmd->flags & TRIG_ROUND_MASK);
 624                 if (divisor1 == 1) {    // PCL816 crash if any divisor is set to 1
 625                         divisor1 = 2;
 626                         divisor2 /= 2;
 627                 }
 628                 if (divisor2 == 1) {
 629                         divisor2 = 2;
 630                         divisor1 /= 2;
 631                 }
 632         }
 633
 634         start_pacer(dev, -1, 0, 0);     // stop pacer
 635
 636         if (!check_and_setup_channel_list(dev, s, cmd->chanlist,
 637                         cmd->chanlist_len))
 638                 return -EINVAL;
 639         comedi_udelay(1);
 640
 641         devpriv->ai_act_scan = 0;
 642         s->async->cur_chan = 0;
 643         devpriv->irq_blocked = 1;
 644         devpriv->ai_poll_ptr = 0;
 645         devpriv->irq_was_now_closed = 0;
 646
 647         if (cmd->stop_src == TRIG_COUNT) {
 648                 devpriv->ai_scans = cmd->stop_arg;
 649                 devpriv->ai_neverending = 0;
 650         } else {
 651                 devpriv->ai_scans = 0;
 652                 devpriv->ai_neverending = 1;
 653         }
 654
 655         if ((cmd->flags & TRIG_WAKE_EOS)) {     // don't we want wake up every scan?
 656                 printk("pl816: You wankt WAKE_EOS but I dont want handle it");
 657                 //              devpriv->ai_eos=1;
 658                 //if (devpriv->ai_n_chan==1)
 659                 //      devpriv->dma=0; // DMA is useless for this situation
 660         }
 661
 662         if (devpriv->dma) {
 663                 bytes = devpriv->hwdmasize[0];
 664                 if (!devpriv->ai_neverending) {
 665                         bytes = s->async->cmd.chanlist_len * s->async->cmd.chanlist_len * sizeof(short);        // how many
 666                         devpriv->dma_runs_to_end = bytes / devpriv->hwdmasize[0];       // how many DMA pages we must fill
 667                         devpriv->last_dma_run = bytes % devpriv->hwdmasize[0];  //on last dma transfer must be moved
 668                         devpriv->dma_runs_to_end--;
 669                         if (devpriv->dma_runs_to_end >= 0)
 670                                 bytes = devpriv->hwdmasize[0];
 671                 } else
 672                         devpriv->dma_runs_to_end = -1;
 673
 674                 devpriv->next_dma_buf = 0;
 675                 set_dma_mode(devpriv->dma, DMA_MODE_READ);
 676                 dma_flags = claim_dma_lock();
 677                 clear_dma_ff(devpriv->dma);
 678                 set_dma_addr(devpriv->dma, devpriv->hwdmaptr[0]);
 679                 set_dma_count(devpriv->dma, bytes);
 680                 release_dma_lock(dma_flags);
 681                 enable_dma(devpriv->dma);
 682         }
 683
 684         start_pacer(dev, 1, divisor1, divisor2);
 685         dmairq = ((devpriv->dma & 0x3) << 4) | (dev->irq & 0x7);
 686
 687         switch (cmd->convert_src) {
 688         case TRIG_TIMER:
 689                 devpriv->int816_mode = INT_TYPE_AI1_DMA;
 690                 outb(0x32, dev->iobase + PCL816_CONTROL);       // Pacer+IRQ+DMA
 691                 outb(dmairq, dev->iobase + PCL816_STATUS);      // write irq and DMA to card
 692                 break;
 693
 694         default:
 695                 devpriv->int816_mode = INT_TYPE_AI3_DMA;
 696                 outb(0x34, dev->iobase + PCL816_CONTROL);       // Ext trig+IRQ+DMA
 697                 outb(dmairq, dev->iobase + PCL816_STATUS);      // write irq to card
 698                 break;
 699         }
 700
 701         DPRINTK("pcl816 END: pcl812_ai_cmd()\n");
 702         return 0;
 703 }
 704
 705 static int pcl816_ai_poll(struct comedi_device * dev, struct comedi_subdevice * s)
 706 {
 707         unsigned long flags;
 708         unsigned int top1, top2, i;
 709
 710         if (!devpriv->dma)
 711                 return 0;       // poll is valid only for DMA transfer
 712
 713         comedi_spin_lock_irqsave(&dev->spinlock, flags);
 714
 715         for (i = 0; i < 20; i++) {
 716                 top1 = get_dma_residue(devpriv->dma);   // where is now DMA
 717                 top2 = get_dma_residue(devpriv->dma);
 718                 if (top1 == top2)
 719                         break;
 720         }
 721         if (top1 != top2) {
 722                 comedi_spin_unlock_irqrestore(&dev->spinlock, flags);
 723                 return 0;
 724         }
 725
 726         top1 = devpriv->hwdmasize[0] - top1;    // where is now DMA in buffer
 727         top1 >>= 1;             // sample position
 728         top2 = top1 - devpriv->ai_poll_ptr;
 729         if (top2 < 1) {         // no new samples
 730                 comedi_spin_unlock_irqrestore(&dev->spinlock, flags);
 731                 return 0;
 732         }
 733
 734         transfer_from_dma_buf(dev, s,
 735                 (short *) devpriv->dmabuf[devpriv->next_dma_buf],
 736                 devpriv->ai_poll_ptr, top2);
 737
 738         devpriv->ai_poll_ptr = top1;    // new buffer position
 739         comedi_spin_unlock_irqrestore(&dev->spinlock, flags);
 740
 741         return s->async->buf_write_count - s->async->buf_read_count;
 742 }
 743
 744 /*
 745 ==============================================================================
 746  cancel any mode 1-4 AI
 747 */
 748 static int pcl816_ai_cancel(struct comedi_device * dev, struct comedi_subdevice * s)
 749 {
 750 //  DEBUG(rt_printk("pcl816_ai_cancel()\n");)
 751
 752         if (devpriv->irq_blocked > 0) {
 753                 switch (devpriv->int816_mode) {
 754 #ifdef unused
 755                 case INT_TYPE_AI1_DMA_RTC:
 756                 case INT_TYPE_AI3_DMA_RTC:
 757                         set_rtc_irq_bit(0);     // stop RTC
 758                         del_timer(&devpriv->rtc_irq_timer);
 759 #endif
 760                 case INT_TYPE_AI1_DMA:
 761                 case INT_TYPE_AI3_DMA:
 762                         disable_dma(devpriv->dma);
 763                 case INT_TYPE_AI1_INT:
 764                 case INT_TYPE_AI3_INT:
 765                         outb(inb(dev->iobase + PCL816_CONTROL) & 0x73, dev->iobase + PCL816_CONTROL);   /* Stop A/D */
 766                         comedi_udelay(1);
 767                         outb(0, dev->iobase + PCL816_CONTROL);  /* Stop A/D */
 768                         outb(0xb0, dev->iobase + PCL816_CTRCTL);        /* Stop pacer */
 769                         outb(0x70, dev->iobase + PCL816_CTRCTL);
 770                         outb(0, dev->iobase + PCL816_AD_LO);
 771                         inb(dev->iobase + PCL816_AD_LO);
 772                         inb(dev->iobase + PCL816_AD_HI);
 773                         outb(0, dev->iobase + PCL816_CLRINT);   /* clear INT request */
 774                         outb(0, dev->iobase + PCL816_CONTROL);  /* Stop A/D */
 775                         devpriv->irq_blocked = 0;
 776                         devpriv->irq_was_now_closed = devpriv->int816_mode;
 777                         devpriv->int816_mode = 0;
 778                         devpriv->last_int_sub = s;
 779 //        s->busy = 0;
 780                         break;
 781                 }
 782         }
 783
 784         DEBUG(rt_printk("comedi: pcl816_ai_cancel() successful\n");
 785                 )
 786                 return 0;
 787 }
 788
 789 /*
 790 ==============================================================================
 791  chech for PCL816
 792 */
 793 static int pcl816_check(unsigned long iobase)
 794 {
 795         outb(0x00, iobase + PCL816_MUX);
 796         comedi_udelay(1);
 797         if (inb(iobase + PCL816_MUX) != 0x00)
 798                 return 1;       //there isn't card
 799         outb(0x55, iobase + PCL816_MUX);
 800         comedi_udelay(1);
 801         if (inb(iobase + PCL816_MUX) != 0x55)
 802                 return 1;       //there isn't card
 803         outb(0x00, iobase + PCL816_MUX);
 804         comedi_udelay(1);
 805         outb(0x18, iobase + PCL816_CONTROL);
 806         comedi_udelay(1);
 807         if (inb(iobase + PCL816_CONTROL) != 0x18)
 808                 return 1;       //there isn't card
 809         return 0;               // ok, card exist
 810 }
 811
 812 /*
 813 ==============================================================================
 814  reset whole PCL-816 cards
 815 */
 816 static void pcl816_reset(struct comedi_device * dev)
 817 {
 818 //  outb (0, dev->iobase + PCL818_DA_LO);       // DAC=0V
 819 //  outb (0, dev->iobase + PCL818_DA_HI);
 820 //  comedi_udelay (1);
 821 //  outb (0, dev->iobase + PCL818_DO_HI);       // DO=$0000
 822 //  outb (0, dev->iobase + PCL818_DO_LO);
 823 //  comedi_udelay (1);
 824         outb(0, dev->iobase + PCL816_CONTROL);
 825         outb(0, dev->iobase + PCL816_MUX);
 826         outb(0, dev->iobase + PCL816_CLRINT);
 827         outb(0xb0, dev->iobase + PCL816_CTRCTL);        /* Stop pacer */
 828         outb(0x70, dev->iobase + PCL816_CTRCTL);
 829         outb(0x30, dev->iobase + PCL816_CTRCTL);
 830         outb(0, dev->iobase + PCL816_RANGE);
 831 }
 832
 833 /*
 834 ==============================================================================
 835  Start/stop pacer onboard pacer
 836 */
 837 static void
 838 start_pacer(struct comedi_device * dev, int mode, unsigned int divisor1,
 839         unsigned int divisor2)
 840 {
 841         outb(0x32, dev->iobase + PCL816_CTRCTL);
 842         outb(0xff, dev->iobase + PCL816_CTR0);
 843         outb(0x00, dev->iobase + PCL816_CTR0);
 844         comedi_udelay(1);
 845         outb(0xb4, dev->iobase + PCL816_CTRCTL);        // set counter 2 as mode 3
 846         outb(0x74, dev->iobase + PCL816_CTRCTL);        // set counter 1 as mode 3
 847         comedi_udelay(1);
 848
 849         if (mode == 1) {
 850                 DPRINTK("mode %d, divisor1 %d, divisor2 %d\n", mode, divisor1,
 851                         divisor2);
 852                 outb(divisor2 & 0xff, dev->iobase + PCL816_CTR2);
 853                 outb((divisor2 >> 8) & 0xff, dev->iobase + PCL816_CTR2);
 854                 outb(divisor1 & 0xff, dev->iobase + PCL816_CTR1);
 855                 outb((divisor1 >> 8) & 0xff, dev->iobase + PCL816_CTR1);
 856         }
 857
 858         /* clear pending interrupts (just in case) */
 859 //      outb(0, dev->iobase + PCL816_CLRINT);
 860 }
 861
 862 /*
 863 ==============================================================================
 864  Check if channel list from user is builded correctly
 865  If it's ok, then program scan/gain logic
 866 */
 867 static int
 868 check_and_setup_channel_list(struct comedi_device * dev, struct comedi_subdevice * s,
 869         unsigned int *chanlist, int chanlen)
 870 {
 871         unsigned int chansegment[16];
 872         unsigned int i, nowmustbechan, seglen, segpos;
 873
 874         // correct channel and range number check itself comedi/range.c
 875         if (chanlen < 1) {
 876                 comedi_error(dev, "range/channel list is empty!");
 877                 return 0;
 878         }
 879
 880         if (chanlen > 1) {
 881                 chansegment[0] = chanlist[0];   // first channel is everytime ok
 882                 for (i = 1, seglen = 1; i < chanlen; i++, seglen++) {
 883                         // build part of chanlist
 884                         DEBUG(rt_printk("%d. %d %d\n", i, CR_CHAN(chanlist[i]),
 885                                         CR_RANGE(chanlist[i]));
 886                                 )
 887                                 if (chanlist[0] == chanlist[i])
 888                                 break;  // we detect loop, this must by finish
 889                         nowmustbechan =
 890                                 (CR_CHAN(chansegment[i - 1]) + 1) % chanlen;
 891                         if (nowmustbechan != CR_CHAN(chanlist[i])) {
 892                                 // channel list isn't continous :-(
 893                                 rt_printk
 894                                         ("comedi%d: pcl816: channel list must be continous! chanlist[%i]=%d but must be %d or %d!\n",
 895                                         dev->minor, i, CR_CHAN(chanlist[i]),
 896                                         nowmustbechan, CR_CHAN(chanlist[0]));
 897                                 return 0;
 898                         }
 899                         chansegment[i] = chanlist[i];   // well, this is next correct channel in list
 900                 }
 901
 902                 for (i = 0, segpos = 0; i < chanlen; i++) {     // check whole chanlist
 903                         DEBUG(rt_printk("%d %d=%d %d\n",
 904                                         CR_CHAN(chansegment[i % seglen]),
 905                                         CR_RANGE(chansegment[i % seglen]),
 906                                         CR_CHAN(chanlist[i]),
 907                                         CR_RANGE(chanlist[i]));
 908                                 )
 909                                 if (chanlist[i] != chansegment[i % seglen]) {
 910                                 rt_printk
 911                                         ("comedi%d: pcl816: bad channel or range number! chanlist[%i]=%d,%d,%d and not %d,%d,%d!\n",
 912                                         dev->minor, i, CR_CHAN(chansegment[i]),
 913                                         CR_RANGE(chansegment[i]),
 914                                         CR_AREF(chansegment[i]),
 915                                         CR_CHAN(chanlist[i % seglen]),
 916                                         CR_RANGE(chanlist[i % seglen]),
 917                                         CR_AREF(chansegment[i % seglen]));
 918                                 return 0;       // chan/gain list is strange
 919                         }
 920                 }
 921         } else {
 922                 seglen = 1;
 923         }
 924
 925         devpriv->ai_act_chanlist_len = seglen;
 926         devpriv->ai_act_chanlist_pos = 0;
 927
 928         for (i = 0; i < seglen; i++) {  // store range list to card
 929                 devpriv->ai_act_chanlist[i] = CR_CHAN(chanlist[i]);
 930                 outb(CR_CHAN(chanlist[0]) & 0xf, dev->iobase + PCL816_MUX);
 931                 outb(CR_RANGE(chanlist[0]), dev->iobase + PCL816_RANGE);        /* select gain */
 932         }
 933
 934         comedi_udelay(1);
 935
 936         outb(devpriv->ai_act_chanlist[0] | (devpriv->ai_act_chanlist[seglen - 1] << 4), dev->iobase + PCL816_MUX);      /* select channel interval to scan */
 937
 938         return 1;               // we can serve this with MUX logic
 939 }
 940
 941 #ifdef unused
 942 /*
 943 ==============================================================================
 944   Enable(1)/disable(0) periodic interrupts from RTC
 945 */
 946 static int set_rtc_irq_bit(unsigned char bit)
 947 {
 948         unsigned char val;
 949         unsigned long flags;
 950
 951         if (bit == 1) {
 952                 RTC_timer_lock++;
 953                 if (RTC_timer_lock > 1)
 954                         return 0;
 955         } else {
 956                 RTC_timer_lock--;
 957                 if (RTC_timer_lock < 0)
 958                         RTC_timer_lock = 0;
 959                 if (RTC_timer_lock > 0)
 960                         return 0;
 961         }
 962
 963         save_flags(flags);
 964         cli();
 965         val = CMOS_READ(RTC_CONTROL);
 966         if (bit) {
 967                 val |= RTC_PIE;
 968         } else {
 969                 val &= ~RTC_PIE;
 970         }
 971         CMOS_WRITE(val, RTC_CONTROL);
 972         CMOS_READ(RTC_INTR_FLAGS);
 973         restore_flags(flags);
 974         return 0;
 975 }
 976 #endif
 977
 978 /*
 979 ==============================================================================
 980   Free any resources that we have claimed
 981 */
 982 static void free_resources(struct comedi_device * dev)
 983 {
 984         //rt_printk("free_resource()\n");
 985         if (dev->private) {
 986                 pcl816_ai_cancel(dev, devpriv->sub_ai);
 987                 pcl816_reset(dev);
 988                 if (devpriv->dma)
 989                         free_dma(devpriv->dma);
 990                 if (devpriv->dmabuf[0])
 991                         free_pages(devpriv->dmabuf[0], devpriv->dmapages[0]);
 992                 if (devpriv->dmabuf[1])
 993                         free_pages(devpriv->dmabuf[1], devpriv->dmapages[1]);
 994 #ifdef unused
 995                 if (devpriv->rtc_irq)
 996                         comedi_free_irq(devpriv->rtc_irq, dev);
 997                 if ((devpriv->dma_rtc) && (RTC_lock == 1)) {
 998                         if (devpriv->rtc_iobase)
 999                                 release_region(devpriv->rtc_iobase,
1000                                         devpriv->rtc_iosize);
1001                 }
1002 #endif
1003         }
1004
1005         if (dev->irq)
1006                 free_irq(dev->irq, dev);
1007         if (dev->iobase)
1008                 release_region(dev->iobase, this_board->io_range);
1009         //rt_printk("free_resource() end\n");
1010 }
1011
1012 /*
1013 ==============================================================================
1014
1015    Initialization
1016
1017 */
1018 static int pcl816_attach(struct comedi_device * dev, struct comedi_devconfig * it)
1019 {
1020         int ret;
1021         unsigned long iobase;
1022         unsigned int irq, dma;
1023         unsigned long pages;
1024         //int i;
1025         struct comedi_subdevice *s;
1026
1027         /* claim our I/O space */
1028         iobase = it->options[0];
1029         printk("comedi%d: pcl816:  board=%s, ioport=0x%03lx", dev->minor,
1030                 this_board->name, iobase);
1031
1032         if (!request_region(iobase, this_board->io_range, "pcl816")) {
1033                 rt_printk("I/O port conflict\n");
1034                 return -EIO;
1035         }
1036
1037         dev->iobase = iobase;
1038
1039         if (pcl816_check(iobase)) {
1040                 rt_printk(", I cann't detect board. FAIL!\n");
1041                 return -EIO;
1042         }
1043
1044         if ((ret = alloc_private(dev, sizeof(struct pcl816_private))) < 0)
1045                 return ret;     /* Can't alloc mem */
1046
1047         /* set up some name stuff */
1048         dev->board_name = this_board->name;
1049
1050         /* grab our IRQ */
1051         irq = 0;
1052         if (this_board->IRQbits != 0) { /* board support IRQ */
1053                 irq = it->options[1];
1054                 if (irq) {      /* we want to use IRQ */
1055                         if (((1 << irq) & this_board->IRQbits) == 0) {
1056                                 rt_printk
1057                                         (", IRQ %u is out of allowed range, DISABLING IT",
1058                                         irq);
1059                                 irq = 0;        /* Bad IRQ */
1060                         } else {
1061                                 if (comedi_request_irq(irq, interrupt_pcl816, 0,
1062                                                 "pcl816", dev)) {
1063                                         rt_printk
1064                                                 (", unable to allocate IRQ %u, DISABLING IT",
1065                                                 irq);
1066                                         irq = 0;        /* Can't use IRQ */
1067                                 } else {
1068                                         rt_printk(", irq=%u", irq);
1069                                 }
1070                         }
1071                 }
1072         }
1073
1074         dev->irq = irq;
1075         if (irq) {
1076                 devpriv->irq_free = 1;
1077         } /* 1=we have allocated irq */
1078         else {
1079                 devpriv->irq_free = 0;
1080         }
1081         devpriv->irq_blocked = 0;       /* number of subdevice which use IRQ */
1082         devpriv->int816_mode = 0;       /* mode of irq */
1083
1084 #ifdef unused
1085         /* grab RTC for DMA operations */
1086         devpriv->dma_rtc = 0;
1087         if (it->options[2] > 0) {       // we want to use DMA
1088                 if (RTC_lock == 0) {
1089                         if (!request_region(RTC_PORT(0), RTC_IO_EXTENT,
1090                                         "pcl816 (RTC)"))
1091                                 goto no_rtc;
1092                 }
1093                 devpriv->rtc_iobase = RTC_PORT(0);
1094                 devpriv->rtc_iosize = RTC_IO_EXTENT;
1095                 RTC_lock++;
1096 #ifdef UNTESTED_CODE
1097                 if (!comedi_request_irq(RTC_IRQ,
1098                                 interrupt_pcl816_ai_mode13_dma_rtc, 0,
1099                                 "pcl816 DMA (RTC)", dev)) {
1100                         devpriv->dma_rtc = 1;
1101                         devpriv->rtc_irq = RTC_IRQ;
1102                         rt_printk(", dma_irq=%u", devpriv->rtc_irq);
1103                 } else {
1104                         RTC_lock--;
1105                         if (RTC_lock == 0) {
1106                                 if (devpriv->rtc_iobase)
1107                                         release_region(devpriv->rtc_iobase,
1108                                                 devpriv->rtc_iosize);
1109                         }
1110                         devpriv->rtc_iobase = 0;
1111                         devpriv->rtc_iosize = 0;
1112                 }
1113 #else
1114                 printk("pcl816: RTC code missing");
1115 #endif
1116
1117         }
1118
1119       no_rtc:
1120 #endif
1121         /* grab our DMA */
1122         dma = 0;
1123         devpriv->dma = dma;
1124         if ((devpriv->irq_free == 0) && (devpriv->dma_rtc == 0))
1125                 goto no_dma;    /* if we haven't IRQ, we can't use DMA */
1126
1127         if (this_board->DMAbits != 0) { /* board support DMA */
1128                 dma = it->options[2];
1129                 if (dma < 1)
1130                         goto no_dma;    /* DMA disabled */
1131
1132                 if (((1 << dma) & this_board->DMAbits) == 0) {
1133                         rt_printk(", DMA is out of allowed range, FAIL!\n");
1134                         return -EINVAL; /* Bad DMA */
1135                 }
1136                 ret = request_dma(dma, "pcl816");
1137                 if (ret) {
1138                         rt_printk(", unable to allocate DMA %u, FAIL!\n", dma);
1139                         return -EBUSY;  /* DMA isn't free */
1140                 }
1141
1142                 devpriv->dma = dma;
1143                 rt_printk(", dma=%u", dma);
1144                 pages = 2;      /* we need 16KB */
1145                 devpriv->dmabuf[0] = __get_dma_pages(GFP_KERNEL, pages);
1146
1147                 if (!devpriv->dmabuf[0]) {
1148                         rt_printk(", unable to allocate DMA buffer, FAIL!\n");
1149                         /* maybe experiment with try_to_free_pages() will help .... */
1150                         return -EBUSY;  /* no buffer :-( */
1151                 }
1152                 devpriv->dmapages[0] = pages;
1153                 devpriv->hwdmaptr[0] = virt_to_bus((void *)devpriv->dmabuf[0]);
1154                 devpriv->hwdmasize[0] = (1 << pages) * PAGE_SIZE;
1155                 //rt_printk("%d %d %ld, ",devpriv->dmapages[0],devpriv->hwdmasize[0],PAGE_SIZE);
1156
1157                 if (devpriv->dma_rtc == 0) {    // we must do duble buff :-(
1158                         devpriv->dmabuf[1] = __get_dma_pages(GFP_KERNEL, pages);
1159                         if (!devpriv->dmabuf[1]) {
1160                                 rt_printk
1161                                         (", unable to allocate DMA buffer, FAIL!\n");
1162                                 return -EBUSY;
1163                         }
1164                         devpriv->dmapages[1] = pages;
1165                         devpriv->hwdmaptr[1] =
1166                                 virt_to_bus((void *)devpriv->dmabuf[1]);
1167                         devpriv->hwdmasize[1] = (1 << pages) * PAGE_SIZE;
1168                 }
1169         }
1170
1171       no_dma:
1172
1173 /*  if (this_board->n_aochan > 0)
1174     subdevs[1] = COMEDI_SUBD_AO;
1175   if (this_board->n_dichan > 0)
1176     subdevs[2] = COMEDI_SUBD_DI;
1177   if (this_board->n_dochan > 0)
1178     subdevs[3] = COMEDI_SUBD_DO;
1179 */
1180         if ((ret = alloc_subdevices(dev, 1)) < 0)
1181                 return ret;
1182
1183         s = dev->subdevices + 0;
1184         if (this_board->n_aichan > 0) {
1185                 s->type = COMEDI_SUBD_AI;
1186                 devpriv->sub_ai = s;
1187                 dev->read_subdev = s;
1188                 s->subdev_flags = SDF_READABLE | SDF_CMD_READ;
1189                 s->n_chan = this_board->n_aichan;
1190                 s->subdev_flags |= SDF_DIFF;
1191                 //printk (", %dchans DIFF DAC - %d", s->n_chan, i);
1192                 s->maxdata = this_board->ai_maxdata;
1193                 s->len_chanlist = this_board->ai_chanlist;
1194                 s->range_table = this_board->ai_range_type;
1195                 s->cancel = pcl816_ai_cancel;
1196                 s->do_cmdtest = pcl816_ai_cmdtest;
1197                 s->do_cmd = pcl816_ai_cmd;
1198                 s->poll = pcl816_ai_poll;
1199                 s->insn_read = pcl816_ai_insn_read;
1200         } else {
1201                 s->type = COMEDI_SUBD_UNUSED;
1202         }
1203
1204 #if 0
1205 case COMEDI_SUBD_AO:
1206         s->subdev_flags = SDF_WRITABLE | SDF_GROUND;
1207         s->n_chan = this_board->n_aochan;
1208         s->maxdata = this_board->ao_maxdata;
1209         s->len_chanlist = this_board->ao_chanlist;
1210         s->range_table = this_board->ao_range_type;
1211         break;
1212
1213 case COMEDI_SUBD_DI:
1214         s->subdev_flags = SDF_READABLE;
1215         s->n_chan = this_board->n_dichan;
1216         s->maxdata = 1;
1217         s->len_chanlist = this_board->n_dichan;
1218         s->range_table = &range_digital;
1219         break;
1220
1221 case COMEDI_SUBD_DO:
1222         s->subdev_flags = SDF_WRITABLE;
1223         s->n_chan = this_board->n_dochan;
1224         s->maxdata = 1;
1225         s->len_chanlist = this_board->n_dochan;
1226         s->range_table = &range_digital;
1227         break;
1228 #endif
1229
1230         pcl816_reset(dev);
1231
1232         rt_printk("\n");
1233
1234         return 0;
1235 }
1236
1237 /*
1238 ==============================================================================
1239   Removes device
1240  */
1241 static int pcl816_detach(struct comedi_device * dev)
1242 {
1243         DEBUG(rt_printk("comedi%d: pcl816: remove\n", dev->minor);
1244                 )
1245                 free_resources(dev);
1246 #ifdef unused
1247         if (devpriv->dma_rtc)
1248                 RTC_lock--;
1249 #endif
1250         return 0;
1251 }