LXR linux/drivers/staging/comedi/drivers/ni_labpc

   1/*
   2 * comedi/drivers/ni_labpc_isadma.c
   3 * ISA DMA support for National Instruments Lab-PC series boards and
   4 * compatibles.
   5 *
   6 * Extracted from ni_labpc.c:
   7 * Copyright (C) 2001-2003 Frank Mori Hess <fmhess@users.sourceforge.net>
   8 *
   9 * This program is free software; you can redistribute it and/or modify
  10 * it under the terms of the GNU General Public License as published by
  11 * the Free Software Foundation; either version 2 of the License, or
  12 * (at your option) any later version.
  13 *
  14 * This program is distributed in the hope that it will be useful,
  15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 * GNU General Public License for more details.
  18 */
  19
  20#include <linux/module.h>
  21#include <linux/slab.h>
  22
  23#include "../comedidev.h"
  24
  25#include "comedi_isadma.h"
  26#include "ni_labpc.h"
  27#include "ni_labpc_regs.h"
  28#include "ni_labpc_isadma.h"
  29
  30/* size in bytes of dma buffer */
  31#define LABPC_ISADMA_BUFFER_SIZE        0xff00
  32
  33/* utility function that suggests a dma transfer size in bytes */
  34static unsigned int labpc_suggest_transfer_size(struct comedi_device *dev,
  35                                                struct comedi_subdevice *s,
  36                                                unsigned int maxbytes)
  37{
  38        struct comedi_cmd *cmd = &s->async->cmd;
  39        unsigned int sample_size = comedi_bytes_per_sample(s);
  40        unsigned int size;
  41        unsigned int freq;
  42
  43        if (cmd->convert_src == TRIG_TIMER)
  44                freq = 1000000000 / cmd->convert_arg;
  45        else
  46                /* return some default value */
  47                freq = 0xffffffff;
  48
  49        /* make buffer fill in no more than 1/3 second */
  50        size = (freq / 3) * sample_size;
  51
  52        /* set a minimum and maximum size allowed */
  53        if (size > maxbytes)
  54                size = maxbytes;
  55        else if (size < sample_size)
  56                size = sample_size;
  57
  58        return size;
  59}
  60
  61void labpc_setup_dma(struct comedi_device *dev, struct comedi_subdevice *s)
  62{
  63        struct labpc_private *devpriv = dev->private;
  64        struct comedi_isadma_desc *desc = &devpriv->dma->desc[0];
  65        struct comedi_cmd *cmd = &s->async->cmd;
  66        unsigned int sample_size = comedi_bytes_per_sample(s);
  67
  68        /* set appropriate size of transfer */
  69        desc->size = labpc_suggest_transfer_size(dev, s, desc->maxsize);
  70        if (cmd->stop_src == TRIG_COUNT &&
  71            devpriv->count * sample_size < desc->size)
  72                desc->size = devpriv->count * sample_size;
  73
  74        comedi_isadma_program(desc);
  75
  76        /* set CMD3 bits for caller to enable DMA and interrupt */
  77        devpriv->cmd3 |= (CMD3_DMAEN | CMD3_DMATCINTEN);
  78}
  79EXPORT_SYMBOL_GPL(labpc_setup_dma);
  80
  81void labpc_drain_dma(struct comedi_device *dev)
  82{
  83        struct labpc_private *devpriv = dev->private;
  84        struct comedi_isadma_desc *desc = &devpriv->dma->desc[0];
  85        struct comedi_subdevice *s = dev->read_subdev;
  86        struct comedi_async *async = s->async;
  87        struct comedi_cmd *cmd = &async->cmd;
  88        unsigned int max_samples = comedi_bytes_to_samples(s, desc->size);
  89        unsigned int residue;
  90        unsigned int nsamples;
  91        unsigned int leftover;
  92
  93        /*
  94         * residue is the number of bytes left to be done on the dma
  95         * transfer.  It should always be zero at this point unless
  96         * the stop_src is set to external triggering.
  97         */
  98        residue = comedi_isadma_disable(desc->chan);
  99
 100        /*
 101         * Figure out how many samples to read for this transfer and
 102         * how many will be stored for next time.
 103         */
 104        nsamples = max_samples - comedi_bytes_to_samples(s, residue);
 105        if (cmd->stop_src == TRIG_COUNT) {
 106                if (devpriv->count <= nsamples) {
 107                        nsamples = devpriv->count;
 108                        leftover = 0;
 109                } else {
 110                        leftover = devpriv->count - nsamples;
 111                        if (leftover > max_samples)
 112                                leftover = max_samples;
 113                }
 114                devpriv->count -= nsamples;
 115        } else {
 116                leftover = max_samples;
 117        }
 118        desc->size = comedi_samples_to_bytes(s, leftover);
 119
 120        comedi_buf_write_samples(s, desc->virt_addr, nsamples);
 121}
 122EXPORT_SYMBOL_GPL(labpc_drain_dma);
 123
 124static void handle_isa_dma(struct comedi_device *dev)
 125{
 126        struct labpc_private *devpriv = dev->private;
 127        struct comedi_isadma_desc *desc = &devpriv->dma->desc[0];
 128
 129        labpc_drain_dma(dev);
 130
 131        if (desc->size)
 132                comedi_isadma_program(desc);
 133
 134        /* clear dma tc interrupt */
 135        devpriv->write_byte(dev, 0x1, DMATC_CLEAR_REG);
 136}
 137
 138void labpc_handle_dma_status(struct comedi_device *dev)
 139{
 140        const struct labpc_boardinfo *board = dev->board_ptr;
 141        struct labpc_private *devpriv = dev->private;
 142
 143        /*
 144         * if a dma terminal count of external stop trigger
 145         * has occurred
 146         */
 147        if (devpriv->stat1 & STAT1_GATA0 ||
 148            (board->is_labpc1200 && devpriv->stat2 & STAT2_OUTA1))
 149                handle_isa_dma(dev);
 150}
 151EXPORT_SYMBOL_GPL(labpc_handle_dma_status);
 152
 153void labpc_init_dma_chan(struct comedi_device *dev, unsigned int dma_chan)
 154{
 155        struct labpc_private *devpriv = dev->private;
 156
 157        /* only DMA channels 3 and 1 are valid */
 158        if (dma_chan != 1 && dma_chan != 3)
 159                return;
 160
 161        /* DMA uses 1 buffer */
 162        devpriv->dma = comedi_isadma_alloc(dev, 1, dma_chan, dma_chan,
 163                                           LABPC_ISADMA_BUFFER_SIZE,
 164                                           COMEDI_ISADMA_READ);
 165}
 166EXPORT_SYMBOL_GPL(labpc_init_dma_chan);
 167
 168void labpc_free_dma_chan(struct comedi_device *dev)
 169{
 170        struct labpc_private *devpriv = dev->private;
 171
 172        if (devpriv)
 173                comedi_isadma_free(devpriv->dma);
 174}
 175EXPORT_SYMBOL_GPL(labpc_free_dma_chan);
 176
 177static int __init ni_labpc_isadma_init_module(void)
 178{
 179        return 0;
 180}
 181module_init(ni_labpc_isadma_init_module);
 182
 183static void __exit ni_labpc_isadma_cleanup_module(void)
 184{
 185}
 186module_exit(ni_labpc_isadma_cleanup_module);
 187
 188MODULE_AUTHOR("Comedi http://www.comedi.org");
 189MODULE_DESCRIPTION("Comedi NI Lab-PC ISA DMA support");
 190MODULE_LICENSE("GPL");
 191