PageRenderTime 57ms CodeModel.GetById 17ms app.highlight 34ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/staging/comedi/drivers/pcl816.c

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