staging: comedi: das1800: introduce struct das1800_dma_desc

For aesthetics, introduce a struct to hold the DMA descriptor data.

Signed-off-by: H Hartley Sweeten <hsweeten@visionengravers.com>
Reviewed-by: Ian Abbott <abbotti@mev.co.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

drivers/staging/comedi/drivers/das1800.c

@@ -420,6 +420,11 @@ static const struct das1800_board das1800_boards[] = {
 	 },
 };
 
+struct das1800_dma_desc {
+	unsigned int chan;	/* DMA channel */
+	uint16_t *virt_addr;	/* virtual address of DMA buffer */
+};
+
 struct das1800_private {
 	unsigned int divisor1;	/* value to load into board's counter 1 for timed conversions */
 	unsigned int divisor2;	/* value to load into board's counter 2 for timed conversions */
@@ -427,12 +432,8 @@ struct das1800_private {
 	/* dma bits for control register b, stored so that dma can be
 	 * turned on and off */
 	int dma_bits;
-	unsigned int dma0;	/* dma channels used */
+	struct das1800_dma_desc dma_desc[2];
-	unsigned int dma1;
+	int cur_dma;
-	unsigned int dma_current;	/* dma channel currently in use */
-	uint16_t *ai_buf0;	/* pointers to dma buffers */
-	uint16_t *ai_buf1;
-	uint16_t *dma_current_buf;	/* pointer to dma buffer currently being used */
 	uint16_t *fifo_buf;	/* bounce buffer for analog input FIFO */
 	unsigned int dma_transfer_size;	/* size of transfer currently used, in bytes */
 	unsigned long iobase2;	/* secondary io address used for analog out on 'ao' boards */
@@ -540,24 +541,18 @@ static void das1800_flush_dma(struct comedi_device *dev,
 			      struct comedi_subdevice *s)
 {
 	struct das1800_private *devpriv = dev->private;
+	struct das1800_dma_desc *dma = &devpriv->dma_desc[devpriv->cur_dma];
 	unsigned long flags;
 	const int dual_dma = devpriv->irq_dma_bits & DMA_DUAL;
 
 	flags = claim_dma_lock();
-	das1800_flush_dma_channel(dev, s, devpriv->dma_current,
+	das1800_flush_dma_channel(dev, s, dma->chan, dma->virt_addr);
-				  devpriv->dma_current_buf);
 
 	if (dual_dma) {
 		/*  switch to other channel and flush it */
-		if (devpriv->dma_current == devpriv->dma0) {
+		devpriv->cur_dma = 1 - devpriv->cur_dma;
-			devpriv->dma_current = devpriv->dma1;
+		dma = &devpriv->dma_desc[devpriv->cur_dma];
-			devpriv->dma_current_buf = devpriv->ai_buf1;
+		das1800_flush_dma_channel(dev, s, dma->chan, dma->virt_addr);
-		} else {
-			devpriv->dma_current = devpriv->dma0;
-			devpriv->dma_current_buf = devpriv->ai_buf0;
-		}
-		das1800_flush_dma_channel(dev, s, devpriv->dma_current,
-					  devpriv->dma_current_buf);
 	}
 
 	release_dma_lock(flags);
@@ -570,47 +565,43 @@ static void das1800_handle_dma(struct comedi_device *dev,
 			       struct comedi_subdevice *s, unsigned int status)
 {
 	struct das1800_private *devpriv = dev->private;
+	struct das1800_dma_desc *dma = &devpriv->dma_desc[devpriv->cur_dma];
 	unsigned long flags;
 	const int dual_dma = devpriv->irq_dma_bits & DMA_DUAL;
 
 	flags = claim_dma_lock();
-	das1800_flush_dma_channel(dev, s, devpriv->dma_current,
+	das1800_flush_dma_channel(dev, s, dma->chan, dma->virt_addr);
-				  devpriv->dma_current_buf);
 	/*  re-enable  dma channel */
-	set_dma_addr(devpriv->dma_current,
+	set_dma_addr(dma->chan, virt_to_bus(dma->virt_addr));
-		     virt_to_bus(devpriv->dma_current_buf));
+	set_dma_count(dma->chan, devpriv->dma_transfer_size);
-	set_dma_count(devpriv->dma_current, devpriv->dma_transfer_size);
+	enable_dma(dma->chan);
-	enable_dma(devpriv->dma_current);
 	release_dma_lock(flags);
 
 	if (status & DMATC) {
 		/*  clear DMATC interrupt bit */
 		outb(CLEAR_INTR_MASK & ~DMATC, dev->iobase + DAS1800_STATUS);
 		/*  switch dma channels for next time, if appropriate */
-		if (dual_dma) {
+		if (dual_dma)
-			/*  read data from the other channel next time */
+			devpriv->cur_dma = 1 - devpriv->cur_dma;
-			if (devpriv->dma_current == devpriv->dma0) {
-				devpriv->dma_current = devpriv->dma1;
-				devpriv->dma_current_buf = devpriv->ai_buf1;
-			} else {
-				devpriv->dma_current = devpriv->dma0;
-				devpriv->dma_current_buf = devpriv->ai_buf0;
-			}
-		}
 	}
 }
 
 static int das1800_cancel(struct comedi_device *dev, struct comedi_subdevice *s)
 {
 	struct das1800_private *devpriv = dev->private;
+	struct das1800_dma_desc *dma;
+	int i;
 
 	outb(0x0, dev->iobase + DAS1800_STATUS);	/* disable conversions */
 	outb(0x0, dev->iobase + DAS1800_CONTROL_B);	/* disable interrupts and dma */
 	outb(0x0, dev->iobase + DAS1800_CONTROL_A);	/* disable and clear fifo and stop triggering */
-	if (devpriv->dma0)
+
-		disable_dma(devpriv->dma0);
+	for (i = 0; i < 2; i++) {
-	if (devpriv->dma1)
+		dma = &devpriv->dma_desc[i];
-		disable_dma(devpriv->dma1);
+		if (dma->chan)
+			disable_dma(dma->chan);
+	}
+
 	return 0;
 }
 
@@ -1006,35 +997,37 @@ static unsigned int suggest_transfer_size(const struct comedi_cmd *cmd)
 static void setup_dma(struct comedi_device *dev, const struct comedi_cmd *cmd)
 {
 	struct das1800_private *devpriv = dev->private;
+	struct das1800_dma_desc *dma = &devpriv->dma_desc[0];
 	unsigned long lock_flags;
 	const int dual_dma = devpriv->irq_dma_bits & DMA_DUAL;
 
 	if ((devpriv->irq_dma_bits & DMA_ENABLED) == 0)
 		return;
 
+	devpriv->cur_dma = 0;
+
 	/* determine a reasonable dma transfer size */
 	devpriv->dma_transfer_size = suggest_transfer_size(cmd);
 	lock_flags = claim_dma_lock();
-	disable_dma(devpriv->dma0);
+	disable_dma(dma->chan);
 	/* clear flip-flop to make sure 2-byte registers for
 	 * count and address get set correctly */
-	clear_dma_ff(devpriv->dma0);
+	clear_dma_ff(dma->chan);
-	set_dma_addr(devpriv->dma0, virt_to_bus(devpriv->ai_buf0));
+	set_dma_addr(dma->chan, virt_to_bus(dma->virt_addr));
 	/*  set appropriate size of transfer */
-	set_dma_count(devpriv->dma0, devpriv->dma_transfer_size);
+	set_dma_count(dma->chan, devpriv->dma_transfer_size);
-	devpriv->dma_current = devpriv->dma0;
+	enable_dma(dma->chan);
-	devpriv->dma_current_buf = devpriv->ai_buf0;
-	enable_dma(devpriv->dma0);
 	/*  set up dual dma if appropriate */
 	if (dual_dma) {
-		disable_dma(devpriv->dma1);
+		dma = &devpriv->dma_desc[1];
+		disable_dma(dma->chan);
 		/* clear flip-flop to make sure 2-byte registers for
 		 * count and address get set correctly */
-		clear_dma_ff(devpriv->dma1);
+		clear_dma_ff(dma->chan);
-		set_dma_addr(devpriv->dma1, virt_to_bus(devpriv->ai_buf1));
+		set_dma_addr(dma->chan, virt_to_bus(dma->virt_addr));
 		/*  set appropriate size of transfer */
-		set_dma_count(devpriv->dma1, devpriv->dma_transfer_size);
+		set_dma_count(dma->chan, devpriv->dma_transfer_size);
-		enable_dma(devpriv->dma1);
+		enable_dma(dma->chan);
 	}
 	release_dma_lock(lock_flags);
 }
@@ -1239,6 +1232,7 @@ static int das1800_init_dma(struct comedi_device *dev, unsigned int dma0,
 			    unsigned int dma1)
 {
 	struct das1800_private *devpriv = dev->private;
+	struct das1800_dma_desc *dma;
 	unsigned long flags;
 
 	/* encode dma0 and dma1 into 2 digit hexadecimal for switch */
@@ -1270,40 +1264,39 @@ static int das1800_init_dma(struct comedi_device *dev, unsigned int dma0,
 			"dma 5,6 / 6,7 / or 7,5\n");
 		return -EINVAL;
 	}
+
+	dma = &devpriv->dma_desc[0];
 	if (request_dma(dma0, dev->driver->driver_name)) {
 		dev_err(dev->class_dev,
 			"failed to allocate dma channel %i\n", dma0);
 		return -EINVAL;
 	}
-	devpriv->dma0 = dma0;
+	dma->chan = dma0;
-	devpriv->dma_current = dma0;
+	dma->virt_addr = kmalloc(DMA_BUF_SIZE, GFP_KERNEL | GFP_DMA);
+	if (!dma->virt_addr)
+		return -ENOMEM;
+	flags = claim_dma_lock();
+	disable_dma(dma->chan);
+	set_dma_mode(dma->chan, DMA_MODE_READ);
+	release_dma_lock(flags);
+
 	if (dma1) {
+		dma = &devpriv->dma_desc[1];
 		if (request_dma(dma1, dev->driver->driver_name)) {
 			dev_err(dev->class_dev,
 				"failed to allocate dma channel %i\n",
 				dma1);
 			return -EINVAL;
 		}
-		devpriv->dma1 = dma1;
+		dma->chan = dma1;
-	}
+		dma->virt_addr = kmalloc(DMA_BUF_SIZE, GFP_KERNEL | GFP_DMA);
-	devpriv->ai_buf0 = kmalloc(DMA_BUF_SIZE, GFP_KERNEL | GFP_DMA);
+		if (!dma->virt_addr)
-	if (devpriv->ai_buf0 == NULL)
-		return -ENOMEM;
-	devpriv->dma_current_buf = devpriv->ai_buf0;
-	if (dma1) {
-		devpriv->ai_buf1 =
-			kmalloc(DMA_BUF_SIZE, GFP_KERNEL | GFP_DMA);
-		if (devpriv->ai_buf1 == NULL)
 			return -ENOMEM;
+		flags = claim_dma_lock();
+		disable_dma(dma->chan);
+		set_dma_mode(dma->chan, DMA_MODE_READ);
+		release_dma_lock(flags);
 	}
-	flags = claim_dma_lock();
-	disable_dma(devpriv->dma0);
-	set_dma_mode(devpriv->dma0, DMA_MODE_READ);
-	if (dma1) {
-		disable_dma(devpriv->dma1);
-		set_dma_mode(devpriv->dma1, DMA_MODE_READ);
-	}
-	release_dma_lock(flags);
 
 	return 0;
 }
@@ -1521,14 +1514,16 @@ static int das1800_attach(struct comedi_device *dev,
 static void das1800_detach(struct comedi_device *dev)
 {
 	struct das1800_private *devpriv = dev->private;
+	struct das1800_dma_desc *dma;
+	int i;
 
 	if (devpriv) {
-		if (devpriv->dma0)
+		for (i = 0; i < 2; i++) {
-			free_dma(devpriv->dma0);
+			dma = &devpriv->dma_desc[i];
-		if (devpriv->dma1)
+			if (dma->chan)
-			free_dma(devpriv->dma1);
+				free_dma(dma->chan);
-		kfree(devpriv->ai_buf0);
+			kfree(dma->virt_addr);
-		kfree(devpriv->ai_buf1);
+		}
 		kfree(devpriv->fifo_buf);
 		if (devpriv->iobase2)
 			release_region(devpriv->iobase2, DAS1800_SIZE);