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 "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 */
  34 static 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
  61 void 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 }
  79 EXPORT_SYMBOL_GPL(labpc_setup_dma);
  80
  81 void 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 }
 122 EXPORT_SYMBOL_GPL(labpc_drain_dma);
 123
 124 static 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
 138 void 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 }
 151 EXPORT_SYMBOL_GPL(labpc_handle_dma_status);
 152
 153 void 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 }
 166 EXPORT_SYMBOL_GPL(labpc_init_dma_chan);
 167
 168 void 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 }
 175 EXPORT_SYMBOL_GPL(labpc_free_dma_chan);
 176
 177 static int __init ni_labpc_isadma_init_module(void)
 178 {
 179         return 0;
 180 }
 181 module_init(ni_labpc_isadma_init_module);
 182
 183 static void __exit ni_labpc_isadma_cleanup_module(void)
 184 {
 185 }
 186 module_exit(ni_labpc_isadma_cleanup_module);
 187
 188 MODULE_AUTHOR("Comedi http://www.comedi.org");
 189 MODULE_DESCRIPTION("Comedi NI Lab-PC ISA DMA support");
 190 MODULE_LICENSE("GPL");