From: H Hartley Sweeten Date: Wed, 14 Jan 2015 17:05:02 +0000 (-0700) Subject: staging: comedi: comedi_isadma: introduce helper module for ISA DMA X-Git-Url: https://git.karo-electronics.de/?a=commitdiff_plain;h=20a1ea7d6ba184a1f6e25e85786738003387cada;p=linux-beck.git staging: comedi: comedi_isadma: introduce helper module for ISA DMA Introduce a new helper module to consolidate all the ISA DMA code. This will allow removing the "depends on ISA_DMA_API" from the legacy drivers that can use DMA for async command support. This module is complete based on the various uses of ISA DMA in the comedi drivers. Signed-off-by: H Hartley Sweeten Reviewed-by: Ian Abbott Signed-off-by: Greg Kroah-Hartman --- diff --git a/drivers/staging/comedi/Kconfig b/drivers/staging/comedi/Kconfig index 37f33c461701..1e296b7aa7cb 100644 --- a/drivers/staging/comedi/Kconfig +++ b/drivers/staging/comedi/Kconfig @@ -1262,6 +1262,9 @@ config COMEDI_DAS08 tristate select COMEDI_8255 +config COMEDI_ISADMA + tristate + config COMEDI_NI_LABPC tristate select COMEDI_8255 diff --git a/drivers/staging/comedi/drivers/Makefile b/drivers/staging/comedi/drivers/Makefile index 84fdf20ca986..7d1fbd53a8ab 100644 --- a/drivers/staging/comedi/drivers/Makefile +++ b/drivers/staging/comedi/drivers/Makefile @@ -3,6 +3,7 @@ ccflags-$(CONFIG_COMEDI_DEBUG) := -DDEBUG # Comedi "helper" modules +obj-$(CONFIG_COMEDI_ISADMA) += comedi_isadma.o # Comedi misc drivers obj-$(CONFIG_COMEDI_BOND) += comedi_bond.o diff --git a/drivers/staging/comedi/drivers/comedi_isadma.c b/drivers/staging/comedi/drivers/comedi_isadma.c new file mode 100644 index 000000000000..dbdea71d6b95 --- /dev/null +++ b/drivers/staging/comedi/drivers/comedi_isadma.c @@ -0,0 +1,262 @@ +/* + * COMEDI ISA DMA support functions + * Copyright (c) 2014 H Hartley Sweeten + * + * 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. + */ + +#include +#include +#include +#include +#include + +#include "../comedidev.h" + +#include "comedi_isadma.h" + +/** + * comedi_isadma_program - program and enable an ISA DMA transfer + * @desc: the ISA DMA cookie to program and enable + */ +void comedi_isadma_program(struct comedi_isadma_desc *desc) +{ + unsigned long flags; + + flags = claim_dma_lock(); + clear_dma_ff(desc->chan); + set_dma_mode(desc->chan, desc->mode); + set_dma_addr(desc->chan, desc->hw_addr); + set_dma_count(desc->chan, desc->size); + enable_dma(desc->chan); + release_dma_lock(flags); +} +EXPORT_SYMBOL_GPL(comedi_isadma_program); + +/** + * comedi_isadma_disable - disable the ISA DMA channel + * @dma_chan: the DMA channel to disable + * + * Returns the residue (remaining bytes) left in the DMA transfer. + */ +unsigned int comedi_isadma_disable(unsigned int dma_chan) +{ + unsigned long flags; + unsigned int residue; + + flags = claim_dma_lock(); + disable_dma(dma_chan); + residue = get_dma_residue(dma_chan); + release_dma_lock(flags); + + return residue; +} +EXPORT_SYMBOL_GPL(comedi_isadma_disable); + +/** + * comedi_isadma_disable_on_sample - disable the ISA DMA channel + * @dma_chan: the DMA channel to disable + * @size: the sample size (in bytes) + * + * Returns the residue (remaining bytes) left in the DMA transfer. + */ +unsigned int comedi_isadma_disable_on_sample(unsigned int dma_chan, + unsigned int size) +{ + int stalled = 0; + unsigned long flags; + unsigned int residue; + unsigned int new_residue; + + residue = comedi_isadma_disable(dma_chan); + while (residue % size) { + /* residue is a partial sample, enable DMA to allow more data */ + flags = claim_dma_lock(); + enable_dma(dma_chan); + release_dma_lock(flags); + + udelay(2); + new_residue = comedi_isadma_disable(dma_chan); + + /* is DMA stalled? */ + if (new_residue == residue) { + stalled++; + if (stalled > 10) + break; + } + residue = new_residue; + stalled = 0; + } + return residue; +} +EXPORT_SYMBOL_GPL(comedi_isadma_disable_on_sample); + +/** + * comedi_isadma_poll - poll the current DMA transfer + * @dma: the ISA DMA to poll + * + * Returns the position (in bytes) of the current DMA transfer. + */ +unsigned int comedi_isadma_poll(struct comedi_isadma *dma) +{ + struct comedi_isadma_desc *desc = &dma->desc[dma->cur_dma]; + unsigned long flags; + unsigned int result; + unsigned int result1; + + flags = claim_dma_lock(); + clear_dma_ff(desc->chan); + if (!isa_dma_bridge_buggy) + disable_dma(desc->chan); + result = get_dma_residue(desc->chan); + /* + * Read the counter again and choose higher value in order to + * avoid reading during counter lower byte roll over if the + * isa_dma_bridge_buggy is set. + */ + result1 = get_dma_residue(desc->chan); + if (!isa_dma_bridge_buggy) + enable_dma(desc->chan); + release_dma_lock(flags); + + if (result < result1) + result = result1; + if (result >= desc->size || result == 0) + return 0; + else + return desc->size - result; +} +EXPORT_SYMBOL_GPL(comedi_isadma_poll); + +/** + * comedi_isadma_set_mode - set the ISA DMA transfer direction + * @desc: the ISA DMA cookie to set + * @dma_dir: the DMA direction + */ +void comedi_isadma_set_mode(struct comedi_isadma_desc *desc, char dma_dir) +{ + desc->mode = (dma_dir == COMEDI_ISADMA_READ) ? DMA_MODE_READ + : DMA_MODE_WRITE; +} +EXPORT_SYMBOL_GPL(comedi_isadma_set_mode); + +/** + * comedi_isadma_alloc - allocate and initialize the ISA DMA + * @dev: comedi_device struct + * @n_desc: the number of cookies to allocate + * @dma_chan: DMA channel for the first cookie + * @dma_chan2: DMA channel for the second cookie + * @maxsize: the size of the buffer to allocate for each cookie + * @dma_dir: the DMA direction + * + * Returns the allocated and initialized ISA DMA or NULL if anything fails. + */ +struct comedi_isadma *comedi_isadma_alloc(struct comedi_device *dev, + int n_desc, unsigned int dma_chan1, + unsigned int dma_chan2, + unsigned int maxsize, char dma_dir) +{ + struct comedi_isadma *dma = NULL; + struct comedi_isadma_desc *desc; + unsigned int dma_chans[2]; + int i; + + if (n_desc < 1 || n_desc > 2) + goto no_dma; + + dma = kzalloc(sizeof(*dma), GFP_KERNEL); + if (!dma) + goto no_dma; + + desc = kcalloc(n_desc, sizeof(*desc), GFP_KERNEL); + if (!desc) + goto no_dma; + dma->desc = desc; + dma->n_desc = n_desc; + + dma_chans[0] = dma_chan1; + if (dma_chan2 == 0 || dma_chan2 == dma_chan1) + dma_chans[1] = dma_chan1; + else + dma_chans[1] = dma_chan2; + + if (request_dma(dma_chans[0], dev->board_name)) + goto no_dma; + dma->chan = dma_chans[0]; + if (dma_chans[1] != dma_chans[0]) { + if (request_dma(dma_chans[1], dev->board_name)) + goto no_dma; + } + dma->chan2 = dma_chans[1]; + + for (i = 0; i < n_desc; i++) { + desc = &dma->desc[i]; + desc->chan = dma_chans[i]; + desc->maxsize = maxsize; + desc->virt_addr = dma_alloc_coherent(NULL, desc->maxsize, + &desc->hw_addr, + GFP_KERNEL); + if (!desc->virt_addr) + goto no_dma; + comedi_isadma_set_mode(desc, dma_dir); + } + + return dma; + +no_dma: + comedi_isadma_free(dma); + return NULL; +} +EXPORT_SYMBOL_GPL(comedi_isadma_alloc); + +/** + * comedi_isadma_free - free the ISA DMA + * @dma: the ISA DMA to free + */ +void comedi_isadma_free(struct comedi_isadma *dma) +{ + struct comedi_isadma_desc *desc; + int i; + + if (!dma) + return; + + if (dma->desc) { + for (i = 0; i < dma->n_desc; i++) { + desc = &dma->desc[i]; + if (desc->virt_addr) + dma_free_coherent(NULL, desc->maxsize, + desc->virt_addr, desc->hw_addr); + } + kfree(dma->desc); + } + if (dma->chan2 && dma->chan2 != dma->chan) + free_dma(dma->chan2); + if (dma->chan) + free_dma(dma->chan); + kfree(dma); +} +EXPORT_SYMBOL_GPL(comedi_isadma_free); + +static int __init comedi_isadma_init(void) +{ + return 0; +} +module_init(comedi_isadma_init); + +static void __exit comedi_isadma_exit(void) +{ +} +module_exit(comedi_isadma_exit); + +MODULE_AUTHOR("H Hartley Sweeten "); +MODULE_DESCRIPTION("Comedi ISA DMA support"); +MODULE_LICENSE("GPL"); diff --git a/drivers/staging/comedi/drivers/comedi_isadma.h b/drivers/staging/comedi/drivers/comedi_isadma.h new file mode 100644 index 000000000000..c7c524faf595 --- /dev/null +++ b/drivers/staging/comedi/drivers/comedi_isadma.h @@ -0,0 +1,116 @@ +/* + * COMEDI ISA DMA support functions + * Copyright (c) 2014 H Hartley Sweeten + * + * 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. + */ + +#ifndef _COMEDI_ISADMA_H +#define _COMEDI_ISADMA_H + +/* + * These are used to avoid issues when and the DMA_MODE_ + * defines are not available. + */ +#define COMEDI_ISADMA_READ 0 +#define COMEDI_ISADMA_WRITE 1 + +/** + * struct comedi_isadma_desc - cookie for ISA DMA + * @virt_addr: virtual address of buffer + * @hw_addr: hardware (bus) address of buffer + * @chan: DMA channel + * @maxsize: allocated size of buffer (in bytes) + * @size: transfer size (in bytes) + * @mode: DMA_MODE_READ or DMA_MODE_WRITE + */ +struct comedi_isadma_desc { + void *virt_addr; + dma_addr_t hw_addr; + unsigned int chan; + unsigned int maxsize; + unsigned int size; + char mode; +}; + +/** + * struct comedi_isadma - ISA DMA data + * @desc: cookie for each DMA buffer + * @n_desc: the number of cookies + * @cur_dma: the current cookie in use + * @chan: the first DMA channel requested + * @chan2: the second DMA channel requested + */ +struct comedi_isadma { + struct comedi_isadma_desc *desc; + int n_desc; + int cur_dma; + unsigned int chan; + unsigned int chan2; +}; + +#if IS_ENABLED(CONFIG_ISA_DMA_API) + +void comedi_isadma_program(struct comedi_isadma_desc *); +unsigned int comedi_isadma_disable(unsigned int dma_chan); +unsigned int comedi_isadma_disable_on_sample(unsigned int dma_chan, + unsigned int size); +unsigned int comedi_isadma_poll(struct comedi_isadma *); +void comedi_isadma_set_mode(struct comedi_isadma_desc *, char dma_dir); + +struct comedi_isadma *comedi_isadma_alloc(struct comedi_device *, + int n_desc, unsigned int dma_chan1, + unsigned int dma_chan2, + unsigned int maxsize, char dma_dir); +void comedi_isadma_free(struct comedi_isadma *); + +#else /* !IS_ENABLED(CONFIG_ISA_DMA_API) */ + +static inline void comedi_isadma_program(struct comedi_isadma_desc *desc) +{ +} + +static inline unsigned int comedi_isadma_disable(unsigned int dma_chan) +{ + return 0; +} + +static inline unsigned int +comedi_isadma_disable_on_sample(unsigned int dma_chan, unsigned int size) +{ + return 0; +} + +static inline unsigned int comedi_isadma_poll(struct comedi_isadma *dma) +{ + return 0; +} + +static inline void comedi_isadma_set_mode(struct comedi_isadma_desc *desc, + char dma_dir) +{ +} + +static inline struct comedi_isadma * +comedi_isadma_alloc(struct comedi_device *dev, int n_desc, + unsigned int dma_chan1, unsigned int dma_chan2, + unsigned int maxsize, char dma_dir) +{ + return NULL; +} + +static inline void comedi_isadma_free(struct comedi_isadma *dma) +{ +} + +#endif /* !IS_ENABLED(CONFIG_ISA_DMA_API) */ + +#endif /* #ifndef _COMEDI_ISADMA_H */