/* * das16.c * DAS16 driver * * COMEDI - Linux Control and Measurement Device Interface * Copyright (C) 2000 David A. Schleef * Copyright (C) 2000 Chris R. Baugher * Copyright (C) 2001,2002 Frank Mori Hess * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. */ /* * Driver: das16 * Description: DAS16 compatible boards * Author: Sam Moore, Warren Jasper, ds, Chris Baugher, Frank Hess, Roman Fietze * Devices: (Keithley Metrabyte) DAS-16 [das-16] * (Keithley Metrabyte) DAS-16G [das-16g] * (Keithley Metrabyte) DAS-16F [das-16f] * (Keithley Metrabyte) DAS-1201 [das-1201] * (Keithley Metrabyte) DAS-1202 [das-1202] * (Keithley Metrabyte) DAS-1401 [das-1401] * (Keithley Metrabyte) DAS-1402 [das-1402] * (Keithley Metrabyte) DAS-1601 [das-1601] * (Keithley Metrabyte) DAS-1602 [das-1602] * (ComputerBoards) PC104-DAS16/JR [pc104-das16jr] * (ComputerBoards) PC104-DAS16JR/16 [pc104-das16jr/16] * (ComputerBoards) CIO-DAS16 [cio-das16] * (ComputerBoards) CIO-DAS16F [cio-das16/f] * (ComputerBoards) CIO-DAS16/JR [cio-das16/jr] * (ComputerBoards) CIO-DAS16JR/16 [cio-das16jr/16] * (ComputerBoards) CIO-DAS1401/12 [cio-das1401/12] * (ComputerBoards) CIO-DAS1402/12 [cio-das1402/12] * (ComputerBoards) CIO-DAS1402/16 [cio-das1402/16] * (ComputerBoards) CIO-DAS1601/12 [cio-das1601/12] * (ComputerBoards) CIO-DAS1602/12 [cio-das1602/12] * (ComputerBoards) CIO-DAS1602/16 [cio-das1602/16] * (ComputerBoards) CIO-DAS16/330 [cio-das16/330] * Status: works * Updated: 2003-10-12 * * A rewrite of the das16 and das1600 drivers. * * Options: * [0] - base io address * [1] - irq (does nothing, irq is not used anymore) * [2] - dma channel (optional, required for comedi_command support) * [3] - master clock speed in MHz (optional, 1 or 10, ignored if * board can probe clock, defaults to 1) * [4] - analog input range lowest voltage in microvolts (optional, * only useful if your board does not have software * programmable gain) * [5] - analog input range highest voltage in microvolts (optional, * only useful if board does not have software programmable * gain) * [6] - analog output range lowest voltage in microvolts (optional) * [7] - analog output range highest voltage in microvolts (optional) * * Passing a zero for an option is the same as leaving it unspecified. */ /* * Testing and debugging help provided by Daniel Koch. * * Keithley Manuals: * 2309.PDF (das16) * 4919.PDF (das1400, 1600) * 4922.PDF (das-1400) * 4923.PDF (das1200, 1400, 1600) * * Computer boards manuals also available from their website * www.measurementcomputing.com */ #include #include #include #include #include #include #include "../comedidev.h" #include "8253.h" #include "8255.h" #include "comedi_fc.h" #define DAS16_DMA_SIZE 0xff00 /* size in bytes of allocated dma buffer */ /* * Register I/O map */ #define DAS16_TRIG_REG 0x00 #define DAS16_AI_LSB_REG 0x00 #define DAS16_AI_MSB_REG 0x01 #define DAS16_MUX_REG 0x02 #define DAS16_DIO_REG 0x03 #define DAS16_AO_LSB_REG(x) ((x) ? 0x06 : 0x04) #define DAS16_AO_MSB_REG(x) ((x) ? 0x07 : 0x05) #define DAS16_STATUS_REG 0x08 #define DAS16_STATUS_BUSY (1 << 7) #define DAS16_STATUS_UNIPOLAR (1 << 6) #define DAS16_STATUS_MUXBIT (1 << 5) #define DAS16_STATUS_INT (1 << 4) #define DAS16_CTRL_REG 0x09 #define DAS16_CTRL_INTE (1 << 7) #define DAS16_CTRL_IRQ(x) (((x) & 0x7) << 4) #define DAS16_CTRL_DMAE (1 << 2) #define DAS16_CTRL_PACING_MASK (3 << 0) #define DAS16_CTRL_INT_PACER (3 << 0) #define DAS16_CTRL_EXT_PACER (2 << 0) #define DAS16_CTRL_SOFT_PACER (0 << 0) #define DAS16_PACER_REG 0x0a #define DAS16_PACER_BURST_LEN(x) (((x) & 0xf) << 4) #define DAS16_PACER_CTR0 (1 << 1) #define DAS16_PACER_TRIG0 (1 << 0) #define DAS16_GAIN_REG 0x0b #define DAS16_TIMER_BASE_REG 0x0c /* to 0x0f */ #define DAS1600_CONV_REG 0x404 #define DAS1600_CONV_DISABLE (1 << 6) #define DAS1600_BURST_REG 0x405 #define DAS1600_BURST_VAL (1 << 6) #define DAS1600_ENABLE_REG 0x406 #define DAS1600_ENABLE_VAL (1 << 6) #define DAS1600_STATUS_REG 0x407 #define DAS1600_STATUS_BME (1 << 6) #define DAS1600_STATUS_ME (1 << 5) #define DAS1600_STATUS_CD (1 << 4) #define DAS1600_STATUS_WS (1 << 1) #define DAS1600_STATUS_CLK_10MHZ (1 << 0) static const struct comedi_lrange range_das1x01_bip = { 4, { BIP_RANGE(10), BIP_RANGE(1), BIP_RANGE(0.1), BIP_RANGE(0.01) } }; static const struct comedi_lrange range_das1x01_unip = { 4, { UNI_RANGE(10), UNI_RANGE(1), UNI_RANGE(0.1), UNI_RANGE(0.01) } }; static const struct comedi_lrange range_das1x02_bip = { 4, { BIP_RANGE(10), BIP_RANGE(5), BIP_RANGE(2.5), BIP_RANGE(1.25) } }; static const struct comedi_lrange range_das1x02_unip = { 4, { UNI_RANGE(10), UNI_RANGE(5), UNI_RANGE(2.5), UNI_RANGE(1.25) } }; static const struct comedi_lrange range_das16jr = { 9, { BIP_RANGE(10), BIP_RANGE(5), BIP_RANGE(2.5), BIP_RANGE(1.25), BIP_RANGE(0.625), UNI_RANGE(10), UNI_RANGE(5), UNI_RANGE(2.5), UNI_RANGE(1.25) } }; static const struct comedi_lrange range_das16jr_16 = { 8, { BIP_RANGE(10), BIP_RANGE(5), BIP_RANGE(2.5), BIP_RANGE(1.25), UNI_RANGE(10), UNI_RANGE(5), UNI_RANGE(2.5), UNI_RANGE(1.25) } }; static const int das16jr_gainlist[] = { 8, 0, 1, 2, 3, 4, 5, 6, 7 }; static const int das16jr_16_gainlist[] = { 0, 1, 2, 3, 4, 5, 6, 7 }; static const int das1600_gainlist[] = { 0, 1, 2, 3 }; enum { das16_pg_none = 0, das16_pg_16jr, das16_pg_16jr_16, das16_pg_1601, das16_pg_1602, }; static const int *const das16_gainlists[] = { NULL, das16jr_gainlist, das16jr_16_gainlist, das1600_gainlist, das1600_gainlist, }; static const struct comedi_lrange *const das16_ai_uni_lranges[] = { &range_unknown, &range_das16jr, &range_das16jr_16, &range_das1x01_unip, &range_das1x02_unip, }; static const struct comedi_lrange *const das16_ai_bip_lranges[] = { &range_unknown, &range_das16jr, &range_das16jr_16, &range_das1x01_bip, &range_das1x02_bip, }; struct das16_board { const char *name; unsigned int ai_maxdata; unsigned int ai_speed; /* max conversion speed in nanosec */ unsigned int ai_pg; unsigned int has_ao:1; unsigned int has_8255:1; unsigned int i8255_offset; unsigned int size; unsigned int id; }; static const struct das16_board das16_boards[] = { { .name = "das-16", .ai_maxdata = 0x0fff, .ai_speed = 15000, .ai_pg = das16_pg_none, .has_ao = 1, .has_8255 = 1, .i8255_offset = 0x10, .size = 0x14, .id = 0x00, }, { .name = "das-16g", .ai_maxdata = 0x0fff, .ai_speed = 15000, .ai_pg = das16_pg_none, .has_ao = 1, .has_8255 = 1, .i8255_offset = 0x10, .size = 0x14, .id = 0x00, }, { .name = "das-16f", .ai_maxdata = 0x0fff, .ai_speed = 8500, .ai_pg = das16_pg_none, .has_ao = 1, .has_8255 = 1, .i8255_offset = 0x10, .size = 0x14, .id = 0x00, }, { .name = "cio-das16", .ai_maxdata = 0x0fff, .ai_speed = 20000, .ai_pg = das16_pg_none, .has_ao = 1, .has_8255 = 1, .i8255_offset = 0x10, .size = 0x14, .id = 0x80, }, { .name = "cio-das16/f", .ai_maxdata = 0x0fff, .ai_speed = 10000, .ai_pg = das16_pg_none, .has_ao = 1, .has_8255 = 1, .i8255_offset = 0x10, .size = 0x14, .id = 0x80, }, { .name = "cio-das16/jr", .ai_maxdata = 0x0fff, .ai_speed = 7692, .ai_pg = das16_pg_16jr, .size = 0x10, .id = 0x00, }, { .name = "pc104-das16jr", .ai_maxdata = 0x0fff, .ai_speed = 3300, .ai_pg = das16_pg_16jr, .size = 0x10, .id = 0x00, }, { .name = "cio-das16jr/16", .ai_maxdata = 0xffff, .ai_speed = 10000, .ai_pg = das16_pg_16jr_16, .size = 0x10, .id = 0x00, }, { .name = "pc104-das16jr/16", .ai_maxdata = 0xffff, .ai_speed = 10000, .ai_pg = das16_pg_16jr_16, .size = 0x10, .id = 0x00, }, { .name = "das-1201", .ai_maxdata = 0x0fff, .ai_speed = 20000, .ai_pg = das16_pg_none, .has_8255 = 1, .i8255_offset = 0x400, .size = 0x408, .id = 0x20, }, { .name = "das-1202", .ai_maxdata = 0x0fff, .ai_speed = 10000, .ai_pg = das16_pg_none, .has_8255 = 1, .i8255_offset = 0x400, .size = 0x408, .id = 0x20, }, { .name = "das-1401", .ai_maxdata = 0x0fff, .ai_speed = 10000, .ai_pg = das16_pg_1601, .size = 0x408, .id = 0xc0, }, { .name = "das-1402", .ai_maxdata = 0x0fff, .ai_speed = 10000, .ai_pg = das16_pg_1602, .size = 0x408, .id = 0xc0, }, { .name = "das-1601", .ai_maxdata = 0x0fff, .ai_speed = 10000, .ai_pg = das16_pg_1601, .has_ao = 1, .has_8255 = 1, .i8255_offset = 0x400, .size = 0x408, .id = 0xc0, }, { .name = "das-1602", .ai_maxdata = 0x0fff, .ai_speed = 10000, .ai_pg = das16_pg_1602, .has_ao = 1, .has_8255 = 1, .i8255_offset = 0x400, .size = 0x408, .id = 0xc0, }, { .name = "cio-das1401/12", .ai_maxdata = 0x0fff, .ai_speed = 6250, .ai_pg = das16_pg_1601, .size = 0x408, .id = 0xc0, }, { .name = "cio-das1402/12", .ai_maxdata = 0x0fff, .ai_speed = 6250, .ai_pg = das16_pg_1602, .size = 0x408, .id = 0xc0, }, { .name = "cio-das1402/16", .ai_maxdata = 0xffff, .ai_speed = 10000, .ai_pg = das16_pg_1602, .size = 0x408, .id = 0xc0, }, { .name = "cio-das1601/12", .ai_maxdata = 0x0fff, .ai_speed = 6250, .ai_pg = das16_pg_1601, .has_ao = 1, .has_8255 = 1, .i8255_offset = 0x400, .size = 0x408, .id = 0xc0, }, { .name = "cio-das1602/12", .ai_maxdata = 0x0fff, .ai_speed = 10000, .ai_pg = das16_pg_1602, .has_ao = 1, .has_8255 = 1, .i8255_offset = 0x400, .size = 0x408, .id = 0xc0, }, { .name = "cio-das1602/16", .ai_maxdata = 0xffff, .ai_speed = 10000, .ai_pg = das16_pg_1602, .has_ao = 1, .has_8255 = 1, .i8255_offset = 0x400, .size = 0x408, .id = 0xc0, }, { .name = "cio-das16/330", .ai_maxdata = 0x0fff, .ai_speed = 3030, .ai_pg = das16_pg_16jr, .size = 0x14, .id = 0xf0, }, }; /* Period for timer interrupt in jiffies. It's a function * to deal with possibility of dynamic HZ patches */ static inline int timer_period(void) { return HZ / 20; } struct das16_private_struct { unsigned int clockbase; unsigned int ctrl_reg; unsigned long adc_byte_count; unsigned int divisor1; unsigned int divisor2; unsigned int dma_chan; uint16_t *dma_buffer[2]; dma_addr_t dma_buffer_addr[2]; unsigned int current_buffer; unsigned int dma_transfer_size; struct comedi_lrange *user_ai_range_table; struct comedi_lrange *user_ao_range_table; struct timer_list timer; short timer_running; unsigned long extra_iobase; unsigned int can_burst:1; }; static void das16_ai_enable(struct comedi_device *dev, unsigned int mode, unsigned int src) { struct das16_private_struct *devpriv = dev->private; devpriv->ctrl_reg &= ~(DAS16_CTRL_INTE | DAS16_CTRL_DMAE | DAS16_CTRL_PACING_MASK); devpriv->ctrl_reg |= mode; if (src == TRIG_EXT) devpriv->ctrl_reg |= DAS16_CTRL_EXT_PACER; else devpriv->ctrl_reg |= DAS16_CTRL_INT_PACER; outb(devpriv->ctrl_reg, dev->iobase + DAS16_CTRL_REG); } static void das16_ai_disable(struct comedi_device *dev) { struct das16_private_struct *devpriv = dev->private; /* disable interrupts, dma and pacer clocked conversions */ devpriv->ctrl_reg &= ~(DAS16_CTRL_INTE | DAS16_CTRL_DMAE | DAS16_CTRL_PACING_MASK); outb(devpriv->ctrl_reg, dev->iobase + DAS16_CTRL_REG); } /* the pc104-das16jr (at least) has problems if the dma transfer is interrupted in the middle of transferring a 16 bit sample, so this function takes care to get an even transfer count after disabling dma channel. */ static int disable_dma_on_even(struct comedi_device *dev) { struct das16_private_struct *devpriv = dev->private; int residue; int i; static const int disable_limit = 100; static const int enable_timeout = 100; disable_dma(devpriv->dma_chan); residue = get_dma_residue(devpriv->dma_chan); for (i = 0; i < disable_limit && (residue % 2); ++i) { int j; enable_dma(devpriv->dma_chan); for (j = 0; j < enable_timeout; ++j) { int new_residue; udelay(2); new_residue = get_dma_residue(devpriv->dma_chan); if (new_residue != residue) break; } disable_dma(devpriv->dma_chan); residue = get_dma_residue(devpriv->dma_chan); } if (i == disable_limit) { dev_err(dev->class_dev, "failed to get an even dma transfer, could be trouble\n"); } return residue; } static void das16_interrupt(struct comedi_device *dev) { struct das16_private_struct *devpriv = dev->private; struct comedi_subdevice *s = dev->read_subdev; struct comedi_async *async = s->async; struct comedi_cmd *cmd = &async->cmd; unsigned long spin_flags; unsigned long dma_flags; int num_bytes, residue; int buffer_index; spin_lock_irqsave(&dev->spinlock, spin_flags); if (!(devpriv->ctrl_reg & DAS16_CTRL_DMAE)) { spin_unlock_irqrestore(&dev->spinlock, spin_flags); return; } dma_flags = claim_dma_lock(); clear_dma_ff(devpriv->dma_chan); residue = disable_dma_on_even(dev); /* figure out how many points to read */ if (residue > devpriv->dma_transfer_size) { dev_err(dev->class_dev, "residue > transfer size!\n"); async->events |= COMEDI_CB_ERROR | COMEDI_CB_EOA; num_bytes = 0; } else num_bytes = devpriv->dma_transfer_size - residue; if (cmd->stop_src == TRIG_COUNT && num_bytes >= devpriv->adc_byte_count) { num_bytes = devpriv->adc_byte_count; async->events |= COMEDI_CB_EOA; } buffer_index = devpriv->current_buffer; devpriv->current_buffer = (devpriv->current_buffer + 1) % 2; devpriv->adc_byte_count -= num_bytes; /* re-enable dma */ if ((async->events & COMEDI_CB_EOA) == 0) { set_dma_addr(devpriv->dma_chan, devpriv->dma_buffer_addr[devpriv->current_buffer]); set_dma_count(devpriv->dma_chan, devpriv->dma_transfer_size); enable_dma(devpriv->dma_chan); } release_dma_lock(dma_flags); spin_unlock_irqrestore(&dev->spinlock, spin_flags); cfc_write_array_to_buffer(s, devpriv->dma_buffer[buffer_index], num_bytes); cfc_handle_events(dev, s); } static void das16_timer_interrupt(unsigned long arg) { struct comedi_device *dev = (struct comedi_device *)arg; struct das16_private_struct *devpriv = dev->private; das16_interrupt(dev); if (devpriv->timer_running) mod_timer(&devpriv->timer, jiffies + timer_period()); } static int das16_cmd_test(struct comedi_device *dev, struct comedi_subdevice *s, struct comedi_cmd *cmd) { const struct das16_board *board = comedi_board(dev); struct das16_private_struct *devpriv = dev->private; int err = 0, tmp; int gain, start_chan, i; int mask; /* Step 1 : check if triggers are trivially valid */ err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW); mask = TRIG_FOLLOW; if (devpriv->can_burst) mask |= TRIG_TIMER | TRIG_EXT; err |= cfc_check_trigger_src(&cmd->scan_begin_src, mask); tmp = cmd->convert_src; mask = TRIG_TIMER | TRIG_EXT; if (devpriv->can_burst) mask |= TRIG_NOW; err |= cfc_check_trigger_src(&cmd->convert_src, mask); err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT); err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE); if (err) return 1; /* Step 2a : make sure trigger sources are unique */ err |= cfc_check_trigger_is_unique(cmd->scan_begin_src); err |= cfc_check_trigger_is_unique(cmd->convert_src); err |= cfc_check_trigger_is_unique(cmd->stop_src); /* Step 2b : and mutually compatible */ /* make sure scan_begin_src and convert_src dont conflict */ if (cmd->scan_begin_src == TRIG_FOLLOW && cmd->convert_src == TRIG_NOW) err |= -EINVAL; if (cmd->scan_begin_src != TRIG_FOLLOW && cmd->convert_src != TRIG_NOW) err |= -EINVAL; if (err) return 2; /* Step 3: check if arguments are trivially valid */ err |= cfc_check_trigger_arg_is(&cmd->start_arg, 0); if (cmd->scan_begin_src == TRIG_FOLLOW) /* internal trigger */ err |= cfc_check_trigger_arg_is(&cmd->scan_begin_arg, 0); err |= cfc_check_trigger_arg_is(&cmd->scan_end_arg, cmd->chanlist_len); /* check against maximum frequency */ if (cmd->scan_begin_src == TRIG_TIMER) err |= cfc_check_trigger_arg_min(&cmd->scan_begin_arg, board->ai_speed * cmd->chanlist_len); if (cmd->convert_src == TRIG_TIMER) err |= cfc_check_trigger_arg_min(&cmd->convert_arg, board->ai_speed); if (cmd->stop_src == TRIG_NONE) err |= cfc_check_trigger_arg_is(&cmd->stop_arg, 0); if (err) return 3; /* step 4: fix up arguments */ if (cmd->scan_begin_src == TRIG_TIMER) { unsigned int tmp = cmd->scan_begin_arg; /* set divisors, correct timing arguments */ i8253_cascade_ns_to_timer_2div(devpriv->clockbase, &devpriv->divisor1, &devpriv->divisor2, &cmd->scan_begin_arg, cmd->flags & TRIG_ROUND_MASK); err += (tmp != cmd->scan_begin_arg); } if (cmd->convert_src == TRIG_TIMER) { unsigned int tmp = cmd->convert_arg; /* set divisors, correct timing arguments */ i8253_cascade_ns_to_timer_2div(devpriv->clockbase, &devpriv->divisor1, &devpriv->divisor2, &cmd->convert_arg, cmd->flags & TRIG_ROUND_MASK); err += (tmp != cmd->convert_arg); } if (err) return 4; /* check channel/gain list against card's limitations */ if (cmd->chanlist) { gain = CR_RANGE(cmd->chanlist[0]); start_chan = CR_CHAN(cmd->chanlist[0]); for (i = 1; i < cmd->chanlist_len; i++) { if (CR_CHAN(cmd->chanlist[i]) != (start_chan + i) % s->n_chan) { dev_err(dev->class_dev, "entries in chanlist must be consecutive channels, counting upwards\n"); err++; } if (CR_RANGE(cmd->chanlist[i]) != gain) { dev_err(dev->class_dev, "entries in chanlist must all have the same gain\n"); err++; } } } if (err) return 5; return 0; } static unsigned int das16_set_pacer(struct comedi_device *dev, unsigned int ns, int rounding_flags) { struct das16_private_struct *devpriv = dev->private; unsigned long timer_base = dev->iobase + DAS16_TIMER_BASE_REG; i8253_cascade_ns_to_timer_2div(devpriv->clockbase, &devpriv->divisor1, &devpriv->divisor2, &ns, rounding_flags & TRIG_ROUND_MASK); /* Write the values of ctr1 and ctr2 into counters 1 and 2 */ i8254_load(timer_base, 0, 1, devpriv->divisor1, 2); i8254_load(timer_base, 0, 2, devpriv->divisor2, 2); return ns; } static int das16_cmd_exec(struct comedi_device *dev, struct comedi_subdevice *s) { const struct das16_board *board = comedi_board(dev); struct das16_private_struct *devpriv = dev->private; struct comedi_async *async = s->async; struct comedi_cmd *cmd = &async->cmd; unsigned int byte; unsigned long flags; int range; if (cmd->flags & TRIG_RT) { dev_err(dev->class_dev, "isa dma transfers cannot be performed with TRIG_RT, aborting\n"); return -1; } devpriv->adc_byte_count = cmd->stop_arg * cmd->chanlist_len * sizeof(uint16_t); if (devpriv->can_burst) outb(DAS1600_CONV_DISABLE, dev->iobase + DAS1600_CONV_REG); /* set scan limits */ byte = CR_CHAN(cmd->chanlist[0]); byte |= CR_CHAN(cmd->chanlist[cmd->chanlist_len - 1]) << 4; outb(byte, dev->iobase + DAS16_MUX_REG); /* set gain (this is also burst rate register but according to * computer boards manual, burst rate does nothing, even on * keithley cards) */ if (board->ai_pg != das16_pg_none) { range = CR_RANGE(cmd->chanlist[0]); outb((das16_gainlists[board->ai_pg])[range], dev->iobase + DAS16_GAIN_REG); } /* set counter mode and counts */ cmd->convert_arg = das16_set_pacer(dev, cmd->convert_arg, cmd->flags & TRIG_ROUND_MASK); /* enable counters */ byte = 0; if (devpriv->can_burst) { if (cmd->convert_src == TRIG_NOW) { outb(DAS1600_BURST_VAL, dev->iobase + DAS1600_BURST_REG); /* set burst length */ byte |= DAS16_PACER_BURST_LEN(cmd->chanlist_len - 1); } else { outb(0, dev->iobase + DAS1600_BURST_REG); } } outb(byte, dev->iobase + DAS16_PACER_REG); /* set up dma transfer */ flags = claim_dma_lock(); disable_dma(devpriv->dma_chan); /* clear flip-flop to make sure 2-byte registers for * count and address get set correctly */ clear_dma_ff(devpriv->dma_chan); devpriv->current_buffer = 0; set_dma_addr(devpriv->dma_chan, devpriv->dma_buffer_addr[devpriv->current_buffer]); devpriv->dma_transfer_size = DAS16_DMA_SIZE; set_dma_count(devpriv->dma_chan, devpriv->dma_transfer_size); enable_dma(devpriv->dma_chan); release_dma_lock(flags); /* set up interrupt */ devpriv->timer_running = 1; devpriv->timer.expires = jiffies + timer_period(); add_timer(&devpriv->timer); das16_ai_enable(dev, DAS16_CTRL_DMAE, cmd->convert_src); if (devpriv->can_burst) outb(0, dev->iobase + DAS1600_CONV_REG); return 0; } static int das16_cancel(struct comedi_device *dev, struct comedi_subdevice *s) { struct das16_private_struct *devpriv = dev->private; unsigned long flags; spin_lock_irqsave(&dev->spinlock, flags); das16_ai_disable(dev); disable_dma(devpriv->dma_chan); /* disable SW timer */ if (devpriv->timer_running) { devpriv->timer_running = 0; del_timer(&devpriv->timer); } if (devpriv->can_burst) outb(0, dev->iobase + DAS1600_BURST_REG); spin_unlock_irqrestore(&dev->spinlock, flags); return 0; } static void das16_ai_munge(struct comedi_device *dev, struct comedi_subdevice *s, void *array, unsigned int num_bytes, unsigned int start_chan_index) { unsigned int i, num_samples = num_bytes / sizeof(short); short *data = array; for (i = 0; i < num_samples; i++) { data[i] = le16_to_cpu(data[i]); if (s->maxdata == 0x0fff) data[i] >>= 4; data[i] &= s->maxdata; } } static int das16_ai_wait_for_conv(struct comedi_device *dev, unsigned int timeout) { unsigned int status; int i; for (i = 0; i < timeout; i++) { status = inb(dev->iobase + DAS16_STATUS_REG); if (!(status & DAS16_STATUS_BUSY)) return 0; } return -ETIME; } static int das16_ai_insn_read(struct comedi_device *dev, struct comedi_subdevice *s, struct comedi_insn *insn, unsigned int *data) { const struct das16_board *board = comedi_board(dev); unsigned int chan = CR_CHAN(insn->chanspec); unsigned int range = CR_RANGE(insn->chanspec); unsigned int val; int ret; int i; das16_ai_disable(dev); /* set multiplexer */ outb(chan | (chan << 4), dev->iobase + DAS16_MUX_REG); /* set gain */ if (board->ai_pg != das16_pg_none) { outb((das16_gainlists[board->ai_pg])[range], dev->iobase + DAS16_GAIN_REG); } for (i = 0; i < insn->n; i++) { /* trigger conversion */ outb_p(0, dev->iobase + DAS16_TRIG_REG); ret = das16_ai_wait_for_conv(dev, 1000); if (ret) return ret; val = inb(dev->iobase + DAS16_AI_MSB_REG) << 8; val |= inb(dev->iobase + DAS16_AI_LSB_REG); if (s->maxdata == 0x0fff) val >>= 4; val &= s->maxdata; data[i] = val; } return insn->n; } static int das16_ao_insn_write(struct comedi_device *dev, struct comedi_subdevice *s, struct comedi_insn *insn, unsigned int *data) { unsigned int chan = CR_CHAN(insn->chanspec); unsigned int val; int i; for (i = 0; i < insn->n; i++) { val = data[i]; val <<= 4; outb(val & 0xff, dev->iobase + DAS16_AO_LSB_REG(chan)); outb((val >> 8) & 0xff, dev->iobase + DAS16_AO_MSB_REG(chan)); } return insn->n; } static int das16_di_insn_bits(struct comedi_device *dev, struct comedi_subdevice *s, struct comedi_insn *insn, unsigned int *data) { data[1] = inb(dev->iobase + DAS16_DIO_REG) & 0xf; return insn->n; } static int das16_do_insn_bits(struct comedi_device *dev, struct comedi_subdevice *s, struct comedi_insn *insn, unsigned int *data) { unsigned int mask = data[0]; unsigned int bits = data[1]; if (mask) { s->state &= ~mask; s->state |= (bits & mask); outb(s->state, dev->iobase + DAS16_DIO_REG); } data[1] = s->state; return insn->n; } static int das16_probe(struct comedi_device *dev, struct comedi_devconfig *it) { const struct das16_board *board = comedi_board(dev); int diobits; /* diobits indicates boards */ diobits = inb(dev->iobase + DAS16_DIO_REG) & 0xf0; if (board->id != diobits) { dev_err(dev->class_dev, "requested board's id bits are incorrect (0x%x != 0x%x)\n", board->id, diobits); return -EINVAL; } return 0; } static void das16_reset(struct comedi_device *dev) { outb(0, dev->iobase + DAS16_STATUS_REG); outb(0, dev->iobase + DAS16_CTRL_REG); outb(0, dev->iobase + DAS16_PACER_REG); outb(0, dev->iobase + DAS16_TIMER_BASE_REG + i8254_control_reg); } static int das16_attach(struct comedi_device *dev, struct comedi_devconfig *it) { const struct das16_board *board = comedi_board(dev); struct das16_private_struct *devpriv; struct comedi_subdevice *s; struct comedi_lrange *lrange; struct comedi_krange *krange; unsigned int dma_chan = it->options[2]; unsigned int status; int ret; /* check that clock setting is valid */ if (it->options[3]) { if (it->options[3] != 0 && it->options[3] != 1 && it->options[3] != 10) { dev_err(dev->class_dev, "Invalid option. Master clock must be set to 1 or 10 (MHz)\n"); return -EINVAL; } } devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv)); if (!devpriv) return -ENOMEM; if (board->size < 0x400) { ret = comedi_request_region(dev, it->options[0], board->size); if (ret) return ret; } else { ret = comedi_request_region(dev, it->options[0], 0x10); if (ret) return ret; /* Request an additional region for the 8255 */ ret = __comedi_request_region(dev, dev->iobase + 0x400, board->size & 0x3ff); if (ret) return ret; devpriv->extra_iobase = dev->iobase + 0x400; devpriv->can_burst = 1; } /* probe id bits to make sure they are consistent */ if (das16_probe(dev, it)) return -EINVAL; /* get master clock speed */ if (devpriv->can_burst) { status = inb(dev->iobase + DAS1600_STATUS_REG); if (status & DAS1600_STATUS_CLK_10MHZ) devpriv->clockbase = 100; else devpriv->clockbase = 1000; } else { if (it->options[3]) devpriv->clockbase = 1000 / it->options[3]; else devpriv->clockbase = 1000; /* 1 MHz default */ } /* initialize dma */ if (dma_chan == 1 || dma_chan == 3) { unsigned long flags; int i; if (request_dma(dma_chan, dev->board_name)) { dev_err(dev->class_dev, "failed to request dma channel %i\n", dma_chan); return -EINVAL; } devpriv->dma_chan = dma_chan; /* allocate dma buffers */ for (i = 0; i < 2; i++) { void *p; p = pci_alloc_consistent(NULL, DAS16_DMA_SIZE, &devpriv->dma_buffer_addr[i]); if (!p) return -ENOMEM; devpriv->dma_buffer[i] = p; } flags = claim_dma_lock(); disable_dma(devpriv->dma_chan); set_dma_mode(devpriv->dma_chan, DMA_MODE_READ); release_dma_lock(flags); init_timer(&devpriv->timer); devpriv->timer.function = das16_timer_interrupt; devpriv->timer.data = (unsigned long)dev; } /* get any user-defined input range */ if (board->ai_pg == das16_pg_none && (it->options[4] || it->options[5])) { /* allocate single-range range table */ lrange = kzalloc(sizeof(*lrange) + sizeof(*krange), GFP_KERNEL); if (!lrange) return -ENOMEM; /* initialize ai range */ devpriv->user_ai_range_table = lrange; lrange->length = 1; krange = devpriv->user_ai_range_table->range; krange->min = it->options[4]; krange->max = it->options[5]; krange->flags = UNIT_volt; } /* get any user-defined output range */ if (it->options[6] || it->options[7]) { /* allocate single-range range table */ lrange = kzalloc(sizeof(*lrange) + sizeof(*krange), GFP_KERNEL); if (!lrange) return -ENOMEM; /* initialize ao range */ devpriv->user_ao_range_table = lrange; lrange->length = 1; krange = devpriv->user_ao_range_table->range; krange->min = it->options[6]; krange->max = it->options[7]; krange->flags = UNIT_volt; } ret = comedi_alloc_subdevices(dev, 4 + board->has_8255); if (ret) return ret; status = inb(dev->iobase + DAS16_STATUS_REG); /* Analog Input subdevice */ s = &dev->subdevices[0]; s->type = COMEDI_SUBD_AI; s->subdev_flags = SDF_READABLE; if (status & DAS16_STATUS_MUXBIT) { s->subdev_flags |= SDF_GROUND; s->n_chan = 16; } else { s->subdev_flags |= SDF_DIFF; s->n_chan = 8; } s->len_chanlist = s->n_chan; s->maxdata = board->ai_maxdata; if (devpriv->user_ai_range_table) { /* user defined ai range */ s->range_table = devpriv->user_ai_range_table; } else if (status & DAS16_STATUS_UNIPOLAR) { s->range_table = das16_ai_uni_lranges[board->ai_pg]; } else { s->range_table = das16_ai_bip_lranges[board->ai_pg]; } s->insn_read = das16_ai_insn_read; if (devpriv->dma_chan) { dev->read_subdev = s; s->subdev_flags |= SDF_CMD_READ; s->do_cmdtest = das16_cmd_test; s->do_cmd = das16_cmd_exec; s->cancel = das16_cancel; s->munge = das16_ai_munge; } /* Analog Output subdevice */ s = &dev->subdevices[1]; if (board->has_ao) { s->type = COMEDI_SUBD_AO; s->subdev_flags = SDF_WRITABLE; s->n_chan = 2; s->maxdata = 0x0fff; s->range_table = devpriv->user_ao_range_table; s->insn_write = das16_ao_insn_write; } else { s->type = COMEDI_SUBD_UNUSED; } /* Digital Input subdevice */ s = &dev->subdevices[2]; s->type = COMEDI_SUBD_DI; s->subdev_flags = SDF_READABLE; s->n_chan = 4; s->maxdata = 1; s->range_table = &range_digital; s->insn_bits = das16_di_insn_bits; /* Digital Output subdevice */ s = &dev->subdevices[3]; s->type = COMEDI_SUBD_DO; s->subdev_flags = SDF_WRITABLE; s->n_chan = 4; s->maxdata = 1; s->range_table = &range_digital; s->insn_bits = das16_do_insn_bits; /* initialize digital output lines */ outb(s->state, dev->iobase + DAS16_DIO_REG); /* 8255 Digital I/O subdevice */ if (board->has_8255) { s = &dev->subdevices[4]; ret = subdev_8255_init(dev, s, NULL, dev->iobase + board->i8255_offset); if (ret) return ret; } das16_reset(dev); /* set the interrupt level */ devpriv->ctrl_reg = DAS16_CTRL_IRQ(dev->irq); outb(devpriv->ctrl_reg, dev->iobase + DAS16_CTRL_REG); if (devpriv->can_burst) { outb(DAS1600_ENABLE_VAL, dev->iobase + DAS1600_ENABLE_REG); outb(0, dev->iobase + DAS1600_CONV_REG); outb(0, dev->iobase + DAS1600_BURST_REG); } return 0; } static void das16_detach(struct comedi_device *dev) { const struct das16_board *board = comedi_board(dev); struct das16_private_struct *devpriv = dev->private; int i; if (devpriv) { if (dev->iobase) das16_reset(dev); for (i = 0; i < 2; i++) { if (devpriv->dma_buffer[i]) pci_free_consistent(NULL, DAS16_DMA_SIZE, devpriv->dma_buffer[i], devpriv-> dma_buffer_addr[i]); } if (devpriv->dma_chan) free_dma(devpriv->dma_chan); kfree(devpriv->user_ai_range_table); kfree(devpriv->user_ao_range_table); if (devpriv->extra_iobase) release_region(devpriv->extra_iobase, board->size & 0x3ff); } comedi_legacy_detach(dev); } static struct comedi_driver das16_driver = { .driver_name = "das16", .module = THIS_MODULE, .attach = das16_attach, .detach = das16_detach, .board_name = &das16_boards[0].name, .num_names = ARRAY_SIZE(das16_boards), .offset = sizeof(das16_boards[0]), }; module_comedi_driver(das16_driver); MODULE_AUTHOR("Comedi http://www.comedi.org"); MODULE_DESCRIPTION("Comedi driver for DAS16 compatible boards"); MODULE_LICENSE("GPL");