drivers/staging/comedi/drivers/ni_labpc_isadma.c

   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 "comedi_fc.h"
  27 #include "ni_labpc.h"
  28 #include "ni_labpc_regs.h"
  29 #include "ni_labpc_isadma.h"
  30
  31 /* size in bytes of dma buffer */
  32 #define LABPC_ISADMA_BUFFER_SIZE        0xff00
  33
  34 /* utility function that suggests a dma transfer size in bytes */
  35 static unsigned int labpc_suggest_transfer_size(struct comedi_device *dev,
  36                                                 struct comedi_subdevice *s,
  37                                                 unsigned int maxbytes)
  38 {
  39         struct comedi_cmd *cmd = &s->async->cmd;
  40         unsigned int sample_size = comedi_bytes_per_sample(s);
  41         unsigned int size;
  42         unsigned int freq;
  43
  44         if (cmd->convert_src == TRIG_TIMER)
  45                 freq = 1000000000 / cmd->convert_arg;
  46         else
  47                 /* return some default value */
  48                 freq = 0xffffffff;
  49
  50         /* make buffer fill in no more than 1/3 second */
  51         size = (freq / 3) * sample_size;
  52
  53         /* set a minimum and maximum size allowed */
  54         if (size > maxbytes)
  55                 size = maxbytes;
  56         else if (size < sample_size)
  57                 size = sample_size;
  58
  59         return size;
  60 }
  61
  62 void labpc_setup_dma(struct comedi_device *dev, struct comedi_subdevice *s)
  63 {
  64         struct labpc_private *devpriv = dev->private;
  65         struct comedi_isadma_desc *desc = &devpriv->dma->desc[0];
  66         struct comedi_cmd *cmd = &s->async->cmd;
  67         unsigned int sample_size = comedi_bytes_per_sample(s);
  68
  69         /* set appropriate size of transfer */
  70         desc->size = labpc_suggest_transfer_size(dev, s, desc->maxsize);
  71         if (cmd->stop_src == TRIG_COUNT &&
  72             devpriv->count * sample_size < desc->size)
  73                 desc->size = devpriv->count * sample_size;
  74
  75         comedi_isadma_program(desc);
  76
  77         /* set CMD3 bits for caller to enable DMA and interrupt */
  78         devpriv->cmd3 |= (CMD3_DMAEN | CMD3_DMATCINTEN);
  79 }
  80 EXPORT_SYMBOL_GPL(labpc_setup_dma);
  81
  82 void labpc_drain_dma(struct comedi_device *dev)
  83 {
  84         struct labpc_private *devpriv = dev->private;
  85         struct comedi_isadma_desc *desc = &devpriv->dma->desc[0];
  86         struct comedi_subdevice *s = dev->read_subdev;
  87         struct comedi_async *async = s->async;
  88         struct comedi_cmd *cmd = &async->cmd;
  89         unsigned int max_samples = comedi_bytes_to_samples(s, desc->size);
  90         unsigned int residue;
  91         unsigned int nsamples;
  92         unsigned int leftover;
  93
  94         /*
  95          * residue is the number of bytes left to be done on the dma
  96          * transfer.  It should always be zero at this point unless
  97          * the stop_src is set to external triggering.
  98          */
  99         residue = comedi_isadma_disable(desc->chan);
 100
 101         /*
 102          * Figure out how many samples to read for this transfer and
 103          * how many will be stored for next time.
 104          */
 105         nsamples = max_samples - comedi_bytes_to_samples(s, residue);
 106         if (cmd->stop_src == TRIG_COUNT) {
 107                 if (devpriv->count <= nsamples) {
 108                         nsamples = devpriv->count;
 109                         leftover = 0;
 110                 } else {
 111                         leftover = devpriv->count - nsamples;
 112                         if (leftover > max_samples)
 113                                 leftover = max_samples;
 114                 }
 115                 devpriv->count -= nsamples;
 116         } else {
 117                 leftover = max_samples;
 118         }
 119         desc->size = comedi_samples_to_bytes(s, leftover);
 120
 121         comedi_buf_write_samples(s, desc->virt_addr, nsamples);
 122 }
 123 EXPORT_SYMBOL_GPL(labpc_drain_dma);
 124
 125 static void handle_isa_dma(struct comedi_device *dev)
 126 {
 127         struct labpc_private *devpriv = dev->private;
 128         struct comedi_isadma_desc *desc = &devpriv->dma->desc[0];
 129
 130         labpc_drain_dma(dev);
 131
 132         if (desc->size)
 133                 comedi_isadma_program(desc);
 134
 135         /* clear dma tc interrupt */
 136         devpriv->write_byte(dev, 0x1, DMATC_CLEAR_REG);
 137 }
 138
 139 void labpc_handle_dma_status(struct comedi_device *dev)
 140 {
 141         const struct labpc_boardinfo *board = dev->board_ptr;
 142         struct labpc_private *devpriv = dev->private;
 143
 144         /*
 145          * if a dma terminal count of external stop trigger
 146          * has occurred
 147          */
 148         if (devpriv->stat1 & STAT1_GATA0 ||
 149             (board->is_labpc1200 && devpriv->stat2 & STAT2_OUTA1))
 150                 handle_isa_dma(dev);
 151 }
 152 EXPORT_SYMBOL_GPL(labpc_handle_dma_status);
 153
 154 void labpc_init_dma_chan(struct comedi_device *dev, unsigned int dma_chan)
 155 {
 156         struct labpc_private *devpriv = dev->private;
 157
 158         /* only DMA channels 3 and 1 are valid */
 159         if (dma_chan != 1 && dma_chan != 3)
 160                 return;
 161
 162         /* DMA uses 1 buffer */
 163         devpriv->dma = comedi_isadma_alloc(dev, 1, dma_chan, dma_chan,
 164                                            LABPC_ISADMA_BUFFER_SIZE,
 165                                            COMEDI_ISADMA_READ);
 166 }
 167 EXPORT_SYMBOL_GPL(labpc_init_dma_chan);
 168
 169 void labpc_free_dma_chan(struct comedi_device *dev)
 170 {
 171         struct labpc_private *devpriv = dev->private;
 172
 173         if (devpriv)
 174                 comedi_isadma_free(devpriv->dma);
 175 }
 176 EXPORT_SYMBOL_GPL(labpc_free_dma_chan);
 177
 178 static int __init ni_labpc_isadma_init_module(void)
 179 {
 180         return 0;
 181 }
 182 module_init(ni_labpc_isadma_init_module);
 183
 184 static void __exit ni_labpc_isadma_cleanup_module(void)
 185 {
 186 }
 187 module_exit(ni_labpc_isadma_cleanup_module);
 188
 189 MODULE_AUTHOR("Comedi http://www.comedi.org");
 190 MODULE_DESCRIPTION("Comedi NI Lab-PC ISA DMA support");
 191 MODULE_LICENSE("GPL");