Staging: comedi: usbdux: code style cleanups

Fix a lot of checkpatch.pl warnings and errors in the usbdux driver.

Cc: Bernd Porr <BerndPorr@f2s.com>
Cc: David Schleef <ds@schleef.org>
Cc: Frank Mori Hess <fmhess@users.sourceforge.net>
Cc: Ian Abbott <abbotti@mev.co.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

1 files changed, 221 insertions, 237 deletions

diff --git a/drivers/staging/comedi/drivers/usbdux.c b/drivers/staging/comedi/drivers/usbdux.c
index 331dc59..3c51607a 100644
--- a/drivers/staging/comedi/drivers/usbdux.c
+++ b/drivers/staging/comedi/drivers/usbdux.c
@@ -296,7 +296,7 @@ static DECLARE_MUTEX(start_stop_sem);
 
 // Stops the data acquision
 // It should be safe to call this function from any context
-static int usbduxsub_unlink_InURBs(usbduxsub_t * usbduxsub_tmp)
+static int usbduxsub_unlink_InURBs(usbduxsub_t *usbduxsub_tmp)
 {
 	int i = 0;
 	int err = 0;
@@ -317,10 +317,12 @@ static int usbduxsub_unlink_InURBs(usbduxsub_t * usbduxsub_tmp)
 	return err;
 }
 
-/* This will stop a running acquisition operation */
-// Is called from within this driver from both the
-// interrupt context and from comedi
-static int usbdux_ai_stop(usbduxsub_t * this_usbduxsub, int do_unlink)
+/*
+ * This will stop a running acquisition operation
+ * Is called from within this driver from both the
+ * interrupt context and from comedi
+ */
+static int usbdux_ai_stop(usbduxsub_t *this_usbduxsub, int do_unlink)
 {
 	int ret = 0;
 
@@ -460,27 +462,26 @@ static void usbduxsub_ai_IsocIrq(struct urb *urb)
 
 	urb->dev = this_usbduxsub->usbdev;
 
-	// resubmit the urb
+	/* resubmit the urb */
 	err = USB_SUBMIT_URB(urb);
 	if (unlikely(err < 0)) {
 		printk("comedi_: usbdux_: urb resubmit failed in int-context! err=%d ", err);
-		if (err == -EL2NSYNC) {
+		if (err == -EL2NSYNC)
 			printk("--> buggy USB host controller or bug in IRQ handler!\n");
-		} else {
+		else
 			printk("\n");
-		}
 		s->async->events |= COMEDI_CB_EOA;
 		s->async->events |= COMEDI_CB_ERROR;
 		comedi_event(this_usbduxsub->comedidev, s);
-		// don't do an unlink here
+		/* don't do an unlink here */
 		usbdux_ai_stop(this_usbduxsub, 0);
 		return;
 	}
 
 	this_usbduxsub->ai_counter--;
-	if (likely(this_usbduxsub->ai_counter > 0)) {
+	if (likely(this_usbduxsub->ai_counter > 0))
 		return;
-	}
+
 	// timer zero, transfer measurements to comedi
 	this_usbduxsub->ai_counter = this_usbduxsub->ai_timer;
 
@@ -518,17 +519,16 @@ static void usbduxsub_ai_IsocIrq(struct urb *urb)
 	comedi_event(this_usbduxsub->comedidev, s);
 }
 
-static int usbduxsub_unlink_OutURBs(usbduxsub_t * usbduxsub_tmp)
+static int usbduxsub_unlink_OutURBs(usbduxsub_t *usbduxsub_tmp)
 {
 	int i = 0;
-
 	int err = 0;
 
 	if (usbduxsub_tmp && usbduxsub_tmp->urbOut) {
 		for (i = 0; i < usbduxsub_tmp->numOfOutBuffers; i++) {
-			if (usbduxsub_tmp->urbOut[i]) {
+			if (usbduxsub_tmp->urbOut[i])
 				usb_kill_urb(usbduxsub_tmp->urbOut[i]);
-			}
+
 #ifdef NOISY_DUX_DEBUGBUG
 			printk("comedi: usbdux: unlinked OutURB %d: res=%d\n",
 				i, err);
@@ -541,7 +541,7 @@ static int usbduxsub_unlink_OutURBs(usbduxsub_t * usbduxsub_tmp)
 /* This will cancel a running acquisition operation
  * in any context.
  */
-static int usbdux_ao_stop(usbduxsub_t * this_usbduxsub, int do_unlink)
+static int usbdux_ao_stop(usbduxsub_t *this_usbduxsub, int do_unlink)
 {
 	int ret = 0;
 
@@ -554,18 +554,16 @@ static int usbdux_ao_stop(usbduxsub_t * this_usbduxsub, int do_unlink)
 #ifdef NOISY_DUX_DEBUGBUG
 	printk("comedi: usbdux_ao_cancel\n");
 #endif
-	if (do_unlink) {
+	if (do_unlink)
 		ret = usbduxsub_unlink_OutURBs(this_usbduxsub);
-	}
 
 	this_usbduxsub->ao_cmd_running = 0;
 
 	return ret;
 }
 
-// force unlink
-// is called by comedi
-static int usbdux_ao_cancel(comedi_device * dev, comedi_subdevice * s)
+/* force unlink, is called by comedi */
+static int usbdux_ao_cancel(comedi_device *dev, comedi_subdevice *s)
 {
 	usbduxsub_t *this_usbduxsub = dev->private;
 	int res = 0;
@@ -618,12 +616,12 @@ static void usbduxsub_ao_IsocIrq(struct urb *urb)
 		/* success */
 		break;
 
-		// after an unlink command, unplug, ... etc
-		// no unlink needed here. Already shutting down.
 	case -ECONNRESET:
 	case -ENOENT:
 	case -ESHUTDOWN:
 	case -ECONNABORTED:
+		// after an unlink command, unplug, ... etc
+		// no unlink needed here. Already shutting down.
 		if (this_usbduxsub->ao_cmd_running) {
 			s->async->events |= COMEDI_CB_EOA;
 			comedi_event(this_usbduxsub->comedidev, s);
@@ -631,8 +629,8 @@ static void usbduxsub_ao_IsocIrq(struct urb *urb)
 		}
 		return;
 
-		// a real error
 	default:
+		// a real error
 		if (this_usbduxsub->ao_cmd_running) {
 			printk("comedi_: usbdux_: Non-zero urb status received in ao intr context: %d\n", urb->status);
 			s->async->events |= COMEDI_CB_ERROR;
@@ -645,9 +643,9 @@ static void usbduxsub_ao_IsocIrq(struct urb *urb)
 	}
 
 	// are we actually running?
-	if (!(this_usbduxsub->ao_cmd_running)) {
+	if (!(this_usbduxsub->ao_cmd_running))
 		return;
-	}
+
 	// normal operation: executing a command in this subdevice
 	this_usbduxsub->ao_counter--;
 	if (this_usbduxsub->ao_counter <= 0) {
@@ -672,9 +670,9 @@ static void usbduxsub_ao_IsocIrq(struct urb *urb)
 			s->async->cmd.chanlist_len;
 		for (i = 0; i < s->async->cmd.chanlist_len; i++) {
 			sampl_t temp;
-			if (i >= NUMOUTCHANNELS) {
+			if (i >= NUMOUTCHANNELS)
 				break;
-			}
+
 			// pointer to the DA
 			datap = (&(((int8_t *) urb->transfer_buffer)[i * 3 + 1]));
 			// get the data from comedi
@@ -712,11 +710,11 @@ static void usbduxsub_ao_IsocIrq(struct urb *urb)
 		if ((ret = USB_SUBMIT_URB(urb)) < 0) {
 			printk("comedi_: usbdux_: ao urb resubm failed in int-cont.");
 			printk("ret=%d", ret);
-			if (ret == EL2NSYNC) {
+			if (ret == EL2NSYNC)
 				printk("--> buggy USB host controller or bug in IRQ handling!\n");
-			} else {
+			else
 				printk("\n");
-			}
+
 			s->async->events |= COMEDI_CB_EOA;
 			s->async->events |= COMEDI_CB_ERROR;
 			comedi_event(this_usbduxsub->comedidev, s);
@@ -726,7 +724,7 @@ static void usbduxsub_ao_IsocIrq(struct urb *urb)
 	}
 }
 
-static int usbduxsub_start(usbduxsub_t * usbduxsub)
+static int usbduxsub_start(usbduxsub_t *usbduxsub)
 {
 	int errcode = 0;
 	uint8_t local_transfer_buffer[16];
@@ -759,7 +757,7 @@ static int usbduxsub_start(usbduxsub_t * usbduxsub)
 	return 0;
 }
 
-static int usbduxsub_stop(usbduxsub_t * usbduxsub)
+static int usbduxsub_stop(usbduxsub_t *usbduxsub)
 {
 	int errcode = 0;
 
@@ -790,9 +788,9 @@ static int usbduxsub_stop(usbduxsub_t * usbduxsub)
 	return 0;
 }
 
-static int usbduxsub_upload(usbduxsub_t * usbduxsub,
-	uint8_t * local_transfer_buffer,
-	unsigned int startAddr, unsigned int len)
+static int usbduxsub_upload(usbduxsub_t *usbduxsub,
+			    uint8_t *local_transfer_buffer,
+			    unsigned int startAddr, unsigned int len)
 {
 	int errcode;
 
@@ -834,8 +832,8 @@ static int usbduxsub_upload(usbduxsub_t * usbduxsub,
 	return 0;
 }
 
-int firmwareUpload(usbduxsub_t * usbduxsub,
-	uint8_t * firmwareBinary, int sizeFirmware)
+static int firmwareUpload(usbduxsub_t *usbduxsub, uint8_t *firmwareBinary,
+			  int sizeFirmware)
 {
 	int ret;
 
@@ -860,16 +858,16 @@ int firmwareUpload(usbduxsub_t * usbduxsub,
 	return 0;
 }
 
-int usbduxsub_submit_InURBs(usbduxsub_t * usbduxsub)
+static int usbduxsub_submit_InURBs(usbduxsub_t *usbduxsub)
 {
 	int i, errFlag;
 
-	if (!usbduxsub) {
+	if (!usbduxsub)
 		return -EFAULT;
-	}
+
 	/* Submit all URBs and start the transfer on the bus */
 	for (i = 0; i < usbduxsub->numOfInBuffers; i++) {
-		// in case of a resubmission after an unlink...
+		/* in case of a resubmission after an unlink... */
 		usbduxsub->urbIn[i]->interval = usbduxsub->ai_interval;
 		usbduxsub->urbIn[i]->context = usbduxsub->comedidev;
 		usbduxsub->urbIn[i]->dev = usbduxsub->usbdev;
@@ -889,7 +887,7 @@ int usbduxsub_submit_InURBs(usbduxsub_t * usbduxsub)
 	return 0;
 }
 
-int usbduxsub_submit_OutURBs(usbduxsub_t * usbduxsub)
+static int usbduxsub_submit_OutURBs(usbduxsub_t *usbduxsub)
 {
 	int i, errFlag;
 
@@ -916,8 +914,8 @@ int usbduxsub_submit_OutURBs(usbduxsub_t * usbduxsub)
 	return 0;
 }
 
-static int usbdux_ai_cmdtest(comedi_device * dev,
-	comedi_subdevice * s, comedi_cmd * cmd)
+static int usbdux_ai_cmdtest(comedi_device *dev, comedi_subdevice *s,
+			     comedi_cmd *cmd)
 {
 	int err = 0, tmp, i;
 	unsigned int tmpTimer;
@@ -1072,7 +1070,7 @@ static int8_t create_adc_command(unsigned int chan, int range)
 #define SENDPWMON                 7
 #define SENDPWMOFF                8
 
-static int send_dux_commands(usbduxsub_t * this_usbduxsub, int cmd_type)
+static int send_dux_commands(usbduxsub_t *this_usbduxsub, int cmd_type)
 {
 	int result, nsent;
 
@@ -1089,13 +1087,13 @@ static int send_dux_commands(usbduxsub_t * this_usbduxsub, int cmd_type)
 		usb_sndbulkpipe(this_usbduxsub->usbdev,
 			COMMAND_OUT_EP),
 		this_usbduxsub->dux_commands, SIZEOFDUXBUFFER, &nsent, 10 * HZ);
-	if (result < 0) {
+	if (result < 0)
 		printk("comedi%d: could not transmit dux_command to the usb-device, err=%d\n", this_usbduxsub->comedidev->minor, result);
-	}
+
 	return result;
 }
 
-static int receive_dux_commands(usbduxsub_t * this_usbduxsub, int command)
+static int receive_dux_commands(usbduxsub_t *this_usbduxsub, int command)
 {
 	int result = (-EFAULT);
 	int nrec;
@@ -1119,8 +1117,8 @@ static int receive_dux_commands(usbduxsub_t * this_usbduxsub, int command)
 	return -EFAULT;
 }
 
-static int usbdux_ai_inttrig(comedi_device * dev,
-	comedi_subdevice * s, unsigned int trignum)
+static int usbdux_ai_inttrig(comedi_device *dev, comedi_subdevice *s,
+			     unsigned int trignum)
 {
 	int ret;
 	usbduxsub_t *this_usbduxsub = dev->private;
@@ -1160,7 +1158,7 @@ static int usbdux_ai_inttrig(comedi_device * dev,
 	return 1;
 }
 
-static int usbdux_ai_cmd(comedi_device * dev, comedi_subdevice * s)
+static int usbdux_ai_cmd(comedi_device *dev, comedi_subdevice *s)
 {
 	comedi_cmd *cmd = &s->async->cmd;
 	unsigned int chan, range;
@@ -1171,10 +1169,10 @@ static int usbdux_ai_cmd(comedi_device * dev, comedi_subdevice * s)
 #ifdef NOISY_DUX_DEBUGBUG
 	printk("comedi%d: usbdux_ai_cmd\n", dev->minor);
 #endif
-	if (!this_usbduxsub) {
+	if (!this_usbduxsub)
 		return -EFAULT;
-	}
-	// block other CPUs from starting an ai_cmd
+
+	/* block other CPUs from starting an ai_cmd */
 	down(&this_usbduxsub->sem);
 
 	if (!(this_usbduxsub->probed)) {
@@ -1186,7 +1184,7 @@ static int usbdux_ai_cmd(comedi_device * dev, comedi_subdevice * s)
 		up(&this_usbduxsub->sem);
 		return -EBUSY;
 	}
-	// set current channel of the running aquisition to zero
+	/* set current channel of the running aquisition to zero */
 	s->async->cur_chan = 0;
 
 	this_usbduxsub->dux_commands[1] = cmd->chanlist_len;
@@ -1211,20 +1209,21 @@ static int usbdux_ai_cmd(comedi_device * dev, comedi_subdevice * s)
 	}
 
 	if (this_usbduxsub->high_speed) {
-		// every channel gets a time window of 125us. Thus, if we
-		// sample all 8 channels we need 1ms. If we sample only
-		// one channel we need only 125us
+		/*
+		 * every channel gets a time window of 125us. Thus, if we
+		 * sample all 8 channels we need 1ms. If we sample only one
+		 * channel we need only 125us
+		 */
 		this_usbduxsub->ai_interval = 1;
-		// find a power of 2 for the interval
+		/* find a power of 2 for the interval */
 		while ((this_usbduxsub->ai_interval) < (cmd->chanlist_len)) {
 			this_usbduxsub->ai_interval =
 				(this_usbduxsub->ai_interval) * 2;
 		}
-		this_usbduxsub->ai_timer =
-			cmd->scan_begin_arg / (125000 *
+		this_usbduxsub->ai_timer = cmd->scan_begin_arg / (125000 *
 			(this_usbduxsub->ai_interval));
 	} else {
-		// interval always 1ms
+		/* interval always 1ms */
 		this_usbduxsub->ai_interval = 1;
 		this_usbduxsub->ai_timer = cmd->scan_begin_arg / 1000000;
 	}
@@ -1267,8 +1266,8 @@ static int usbdux_ai_cmd(comedi_device * dev, comedi_subdevice * s)
 }
 
 /* Mode 0 is used to get a single conversion on demand */
-static int usbdux_ai_insn_read(comedi_device * dev,
-	comedi_subdevice * s, comedi_insn * insn, lsampl_t * data)
+static int usbdux_ai_insn_read(comedi_device *dev, comedi_subdevice *s,
+			       comedi_insn *insn, lsampl_t *data)
 {
 	int i;
 	lsampl_t one = 0;
@@ -1314,9 +1313,9 @@ static int usbdux_ai_insn_read(comedi_device * dev,
 			return 0;
 		}
 		one = le16_to_cpu(this_usbduxsub->insnBuffer[1]);
-		if (CR_RANGE(insn->chanspec) <= 1) {
+		if (CR_RANGE(insn->chanspec) <= 1)
 			one = one ^ 0x800;
-		}
+
 		data[i] = one;
 	}
 	up(&this_usbduxsub->sem);
@@ -1326,30 +1325,30 @@ static int usbdux_ai_insn_read(comedi_device * dev,
 //////////////////
 // analog out
 
-static int usbdux_ao_insn_read(comedi_device * dev, comedi_subdevice * s,
-	comedi_insn * insn, lsampl_t * data)
+static int usbdux_ao_insn_read(comedi_device *dev, comedi_subdevice *s,
+			       comedi_insn *insn, lsampl_t *data)
 {
 	int i;
 	int chan = CR_CHAN(insn->chanspec);
 	usbduxsub_t *this_usbduxsub = dev->private;
 
-	if (!this_usbduxsub) {
+	if (!this_usbduxsub)
 		return -EFAULT;
-	}
+
 	down(&this_usbduxsub->sem);
 	if (!(this_usbduxsub->probed)) {
 		up(&this_usbduxsub->sem);
 		return -ENODEV;
 	}
-	for (i = 0; i < insn->n; i++) {
+	for (i = 0; i < insn->n; i++)
 		data[i] = this_usbduxsub->outBuffer[chan];
-	}
+
 	up(&this_usbduxsub->sem);
 	return i;
 }
 
-static int usbdux_ao_insn_write(comedi_device * dev, comedi_subdevice * s,
-	comedi_insn * insn, lsampl_t * data)
+static int usbdux_ao_insn_write(comedi_device *dev, comedi_subdevice *s,
+				comedi_insn *insn, lsampl_t *data)
 {
 	int i, err;
 	int chan = CR_CHAN(insn->chanspec);
@@ -1358,9 +1357,9 @@ static int usbdux_ao_insn_write(comedi_device * dev, comedi_subdevice * s,
 #ifdef NOISY_DUX_DEBUGBUG
 	printk("comedi%d: ao_insn_write\n", dev->minor);
 #endif
-	if (!this_usbduxsub) {
+	if (!this_usbduxsub)
 		return -EFAULT;
-	}
+
 	down(&this_usbduxsub->sem);
 	if (!(this_usbduxsub->probed)) {
 		up(&this_usbduxsub->sem);
@@ -1396,15 +1395,15 @@ static int usbdux_ao_insn_write(comedi_device * dev, comedi_subdevice * s,
 	return i;
 }
 
-static int usbdux_ao_inttrig(comedi_device * dev, comedi_subdevice * s,
-	unsigned int trignum)
+static int usbdux_ao_inttrig(comedi_device *dev, comedi_subdevice *s,
+			     unsigned int trignum)
 {
 	int ret;
 	usbduxsub_t *this_usbduxsub = dev->private;
 
-	if (!this_usbduxsub) {
+	if (!this_usbduxsub)
 		return -EFAULT;
-	}
+
 	down(&this_usbduxsub->sem);
 	if (!(this_usbduxsub->probed)) {
 		up(&this_usbduxsub->sem);
@@ -1433,18 +1432,18 @@ static int usbdux_ao_inttrig(comedi_device * dev, comedi_subdevice * s,
 	return 1;
 }
 
-static int usbdux_ao_cmdtest(comedi_device * dev,
-	comedi_subdevice * s, comedi_cmd * cmd)
+static int usbdux_ao_cmdtest(comedi_device *dev, comedi_subdevice *s,
+			     comedi_cmd *cmd)
 {
 	int err = 0, tmp;
 	usbduxsub_t *this_usbduxsub = dev->private;
 
-	if (!this_usbduxsub) {
+	if (!this_usbduxsub)
 		return -EFAULT;
-	}
-	if (!(this_usbduxsub->probed)) {
+
+	if (!(this_usbduxsub->probed))
 		return -ENODEV;
-	}
+
 #ifdef NOISY_DUX_DEBUGBUG
 	printk("comedi%d: usbdux_ao_cmdtest\n", dev->minor);
 #endif
@@ -1566,16 +1565,16 @@ static int usbdux_ao_cmdtest(comedi_device * dev,
 	return 0;
 }
 
-static int usbdux_ao_cmd(comedi_device * dev, comedi_subdevice * s)
+static int usbdux_ao_cmd(comedi_device *dev, comedi_subdevice *s)
 {
 	comedi_cmd *cmd = &s->async->cmd;
 	unsigned int chan, gain;
 	int i, ret;
 	usbduxsub_t *this_usbduxsub = dev->private;
 
-	if (!this_usbduxsub) {
+	if (!this_usbduxsub)
 		return -EFAULT;
-	}
+
 	down(&this_usbduxsub->sem);
 	if (!(this_usbduxsub->probed)) {
 		up(&this_usbduxsub->sem);
@@ -1666,8 +1665,8 @@ static int usbdux_ao_cmd(comedi_device * dev, comedi_subdevice * s)
 	return 0;
 }
 
-static int usbdux_dio_insn_config(comedi_device * dev,
-	comedi_subdevice * s, comedi_insn * insn, lsampl_t * data)
+static int usbdux_dio_insn_config(comedi_device *dev, comedi_subdevice *s,
+				  comedi_insn *insn, lsampl_t *data)
 {
 	int chan = CR_CHAN(insn->chanspec);
 
@@ -1697,16 +1696,16 @@ static int usbdux_dio_insn_config(comedi_device * dev,
 	return insn->n;
 }
 
-static int usbdux_dio_insn_bits(comedi_device * dev,
-	comedi_subdevice * s, comedi_insn * insn, lsampl_t * data)
+static int usbdux_dio_insn_bits(comedi_device *dev, comedi_subdevice *s,
+				comedi_insn *insn, lsampl_t *data)
 {
 
 	usbduxsub_t *this_usbduxsub = dev->private;
 	int err;
 
-	if (!this_usbduxsub) {
+	if (!this_usbduxsub)
 		return -EFAULT;
-	}
+
 
 	if (insn->n != 2)
 		return -EINVAL;
@@ -1742,18 +1741,16 @@ static int usbdux_dio_insn_bits(comedi_device * dev,
 	return 2;
 }
 
-// reads the 4 counters
-// only two are used just now
-static int usbdux_counter_read(comedi_device * dev, comedi_subdevice * s,
-	comedi_insn * insn, lsampl_t * data)
+/* reads the 4 counters, only two are used just now */
+static int usbdux_counter_read(comedi_device *dev, comedi_subdevice *s,
+			       comedi_insn *insn, lsampl_t *data)
 {
 	usbduxsub_t *this_usbduxsub = dev->private;
 	int chan = insn->chanspec;
 	int err;
 
-	if (!this_usbduxsub) {
+	if (!this_usbduxsub)
 		return -EFAULT;
-	}
 
 	down(&this_usbduxsub->sem);
 
@@ -1778,15 +1775,14 @@ static int usbdux_counter_read(comedi_device * dev, comedi_subdevice * s,
 	return 1;
 }
 
-static int usbdux_counter_write(comedi_device * dev, comedi_subdevice * s,
-	comedi_insn * insn, lsampl_t * data)
+static int usbdux_counter_write(comedi_device *dev, comedi_subdevice *s,
+				comedi_insn *insn, lsampl_t *data)
 {
 	usbduxsub_t *this_usbduxsub = dev->private;
 	int err;
 
-	if (!this_usbduxsub) {
+	if (!this_usbduxsub)
 		return -EFAULT;
-	}
 
 	down(&this_usbduxsub->sem);
 
@@ -1808,8 +1804,8 @@ static int usbdux_counter_write(comedi_device * dev, comedi_subdevice * s,
 	return 1;
 }
 
-static int usbdux_counter_config(comedi_device * dev, comedi_subdevice * s,
-	comedi_insn * insn, lsampl_t * data)
+static int usbdux_counter_config(comedi_device *dev, comedi_subdevice *s,
+				 comedi_insn *insn, lsampl_t *data)
 {
 	// nothing to do so far
 	return 2;
@@ -1818,7 +1814,7 @@ static int usbdux_counter_config(comedi_device * dev, comedi_subdevice * s,
 /////////////////////////////
 // PWM
 
-static int usbduxsub_unlink_PwmURBs(usbduxsub_t * usbduxsub_tmp)
+static int usbduxsub_unlink_PwmURBs(usbduxsub_t *usbduxsub_tmp)
 {
 	int err = 0;
 
@@ -1835,7 +1831,7 @@ static int usbduxsub_unlink_PwmURBs(usbduxsub_t * usbduxsub_tmp)
 /* This cancels a running acquisition operation
  * in any context.
  */
-static int usbdux_pwm_stop(usbduxsub_t * this_usbduxsub, int do_unlink)
+static int usbdux_pwm_stop(usbduxsub_t *this_usbduxsub, int do_unlink)
 {
 	int ret = 0;
 
@@ -1848,32 +1844,30 @@ static int usbdux_pwm_stop(usbduxsub_t * this_usbduxsub, int do_unlink)
 #ifdef NOISY_DUX_DEBUGBUG
 	printk("comedi: usbdux_pwm_cancel\n");
 #endif
-	if (do_unlink) {
+	if (do_unlink)
 		ret = usbduxsub_unlink_PwmURBs(this_usbduxsub);
-	}
+
 
 	this_usbduxsub->pwm_cmd_running = 0;
 
 	return ret;
 }
 
-// force unlink
-// is called by comedi
-static int usbdux_pwm_cancel(comedi_device * dev, comedi_subdevice * s)
+/* force unlink - is called by comedi */
+static int usbdux_pwm_cancel(comedi_device *dev, comedi_subdevice *s)
 {
 	usbduxsub_t *this_usbduxsub = dev->private;
 	int res = 0;
 
-	// unlink only if it is really running
+	/* unlink only if it is really running */
 	res = usbdux_pwm_stop(this_usbduxsub, this_usbduxsub->pwm_cmd_running);
 
 #ifdef NOISY_DUX_DEBUGBUG
 	printk("comedi %d: sending pwm off command to the usb device.\n",
 		dev->minor);
 #endif
-	if ((res = send_dux_commands(this_usbduxsub, SENDPWMOFF)) < 0) {
+	if ((res = send_dux_commands(this_usbduxsub, SENDPWMOFF)) < 0)
 		return res;
-	}
 
 	return res;
 }
@@ -1911,19 +1905,21 @@ static void usbduxsub_pwm_irq(struct urb *urb)
 		/* success */
 		break;
 
-		// after an unlink command, unplug, ... etc
-		// no unlink needed here. Already shutting down.
 	case -ECONNRESET:
 	case -ENOENT:
 	case -ESHUTDOWN:
 	case -ECONNABORTED:
-		if (this_usbduxsub->pwm_cmd_running) {
+		/*
+		 * after an unlink command, unplug, ... etc
+		 * no unlink needed here. Already shutting down.
+		 */
+		if (this_usbduxsub->pwm_cmd_running)
 			usbdux_pwm_stop(this_usbduxsub, 0);
-		}
+
 		return;
 
-		// a real error
 	default:
+		/* a real error */
 		if (this_usbduxsub->pwm_cmd_running) {
 			printk("comedi_: usbdux_: Non-zero urb status received in pwm intr context: %d\n", urb->status);
 			usbdux_pwm_stop(this_usbduxsub, 0);
@@ -1931,10 +1927,9 @@ static void usbduxsub_pwm_irq(struct urb *urb)
 		return;
 	}
 
-	// are we actually running?
-	if (!(this_usbduxsub->pwm_cmd_running)) {
+	/* are we actually running? */
+	if (!(this_usbduxsub->pwm_cmd_running))
 		return;
-	}
 
 	urb->transfer_buffer_length = this_usbduxsub->sizePwmBuf;
 	urb->dev = this_usbduxsub->usbdev;
@@ -1943,24 +1938,24 @@ static void usbduxsub_pwm_irq(struct urb *urb)
 		if ((ret = USB_SUBMIT_URB(urb)) < 0) {
 			printk("comedi_: usbdux_: pwm urb resubm failed in int-cont.");
 			printk("ret=%d", ret);
-			if (ret == EL2NSYNC) {
+			if (ret == EL2NSYNC)
 				printk("--> buggy USB host controller or bug in IRQ handling!\n");
-			} else {
+			else
 				printk("\n");
-			}
-			// don't do an unlink here
+
+			/* don't do an unlink here */
 			usbdux_pwm_stop(this_usbduxsub, 0);
 		}
 	}
 }
 
-int usbduxsub_submit_PwmURBs(usbduxsub_t * usbduxsub)
+static int usbduxsub_submit_PwmURBs(usbduxsub_t *usbduxsub)
 {
 	int errFlag;
 
-	if (!usbduxsub) {
+	if (!usbduxsub)
 		return -EFAULT;
-	}
+
 #ifdef NOISY_DUX_DEBUGBUG
 	printk("comedi_: usbdux: submitting pwm-urb\n");
 #endif
@@ -1982,13 +1977,13 @@ int usbduxsub_submit_PwmURBs(usbduxsub_t * usbduxsub)
 	return 0;
 }
 
-static int usbdux_pwm_period(comedi_device * dev, comedi_subdevice * s,
+static int usbdux_pwm_period(comedi_device *dev, comedi_subdevice *s,
 			     lsampl_t period)
 {
 	usbduxsub_t *this_usbduxsub = dev->private;
-	int fx2delay=255;
-	if (period < MIN_PWM_PERIOD)
-	{
+	int fx2delay = 255;
+
+	if (period < MIN_PWM_PERIOD) {
 		printk("comedi%d: illegal period setting for pwm.\n", dev->minor);
 		return -EAGAIN;
 	} else {
@@ -1999,10 +1994,10 @@ static int usbdux_pwm_period(comedi_device * dev, comedi_subdevice * s,
 			return -EAGAIN;
 		}
 	}
-	this_usbduxsub->pwmDelay=fx2delay;
-	this_usbduxsub->pwmPeriod=period;
+	this_usbduxsub->pwmDelay = fx2delay;
+	this_usbduxsub->pwmPeriod = period;
 #ifdef NOISY_DUX_DEBUGBUG
-	printk("usbdux_pwm_period: frequ=%d, period=%d\n",period,fx2delay);
+	printk("usbdux_pwm_period: frequ=%d, period=%d\n", period, fx2delay);
 #endif
 	return 0;
 }
@@ -2098,37 +2093,36 @@ static int usbdux_pwm_write(comedi_device * dev, comedi_subdevice * s,
 
 	// the sign is set via a special INSN only, this gives us 8 bits for
 	// normal operation
-	return usbdux_pwm_pattern(dev,s,
-				  CR_CHAN(insn->chanspec),
-				  data[0],
-				  0); // relay sign 0 by default
+	// relay sign 0 by default
+	return usbdux_pwm_pattern(dev, s, CR_CHAN(insn->chanspec),
+				  data[0], 0);
 }
 
-
-static int usbdux_pwm_read(comedi_device * x1, comedi_subdevice * x2,
-	comedi_insn * x3, lsampl_t * x4)
+static int usbdux_pwm_read(comedi_device *x1, comedi_subdevice *x2,
+			   comedi_insn *x3, lsampl_t *x4)
 {
-	// not needed
+	/* not needed */
 	return -EINVAL;
 };
 
-// switches on/off PWM
-static int usbdux_pwm_config(comedi_device * dev, comedi_subdevice * s,
-	comedi_insn * insn, lsampl_t * data)
+/* switches on/off PWM */
+static int usbdux_pwm_config(comedi_device *dev, comedi_subdevice *s,
+			     comedi_insn *insn, lsampl_t *data)
 {
 	usbduxsub_t *this_usbduxsub = dev->private;
 	switch (data[0]) {
 	case INSN_CONFIG_ARM:
 #ifdef NOISY_DUX_DEBUGBUG
-		// switch it on
+		/* switch it on */
 		printk("comedi%d: pwm_insn_config: pwm on\n",
 		       dev->minor);
 #endif
-		// if not zero the PWM is limited to a certain time which is
-		// not supported here
-		if (data[1]!=0) {
+		/*
+		 * if not zero the PWM is limited to a certain time which is
+		 * not supported here
+		 */
+		if (data[1] != 0)
 			return -EINVAL;
-		}
 		return usbdux_pwm_start(dev, s);
 	case INSN_CONFIG_DISARM:
 #ifdef NOISY_DUX_DEBUGBUG
@@ -2137,8 +2131,10 @@ static int usbdux_pwm_config(comedi_device * dev, comedi_subdevice * s,
 #endif
 		return usbdux_pwm_cancel(dev, s);
 	case INSN_CONFIG_GET_PWM_STATUS:
-		// to check if the USB transmission has failed or in case
-		// PWM was limited to n cycles to check if it has terminated
+		/*
+		 * to check if the USB transmission has failed or in case PWM
+		 * was limited to n cycles to check if it has terminated
+		 */
 		data[1] = this_usbduxsub->pwm_cmd_running;
 		return 0;
 	case INSN_CONFIG_PWM_SET_PERIOD:
@@ -2146,37 +2142,41 @@ static int usbdux_pwm_config(comedi_device * dev, comedi_subdevice * s,
 		printk("comedi%d: pwm_insn_config: setting period\n",
 		       dev->minor);
 #endif
-		return usbdux_pwm_period(dev,s,data[1]);
+		return usbdux_pwm_period(dev, s, data[1]);
 	case INSN_CONFIG_PWM_GET_PERIOD:
 		data[1] = this_usbduxsub->pwmPeriod;
 		return 0;
 	case INSN_CONFIG_PWM_SET_H_BRIDGE:
-		// value in the first byte and the sign in the second for a relay
+		/* value in the first byte and the sign in the second for a
+		   relay */
 		return usbdux_pwm_pattern(dev, s,
-					  CR_CHAN(insn->chanspec), // the channel number
-					  data[1], // actual PWM data
-					  (data[2]!=0)); // just a sign
+					  /* the channel number */
+					  CR_CHAN(insn->chanspec),
+					  /* actual PWM data */
+					  data[1],
+					  /* just a sign */
+					  (data[2] != 0));
 	case INSN_CONFIG_PWM_GET_H_BRIDGE:
-		// values are not kept in this driver, nothing to return here
+		/* values are not kept in this driver, nothing to return here */
 		return -EINVAL;
 	}
 	return -EINVAL;
 }
 
-// end of PWM
-///////////////////////////////////////////////////////////////////
+/* end of PWM */
+/*****************************************************************/
 
-static void tidy_up(usbduxsub_t * usbduxsub_tmp)
+static void tidy_up(usbduxsub_t *usbduxsub_tmp)
 {
 	int i;
 
 #ifdef CONFIG_COMEDI_DEBUG
 	printk("comedi_: usbdux: tiding up\n");
 #endif
-	if (!usbduxsub_tmp) {
+	if (!usbduxsub_tmp)
 		return;
-	}
-	// shows the usb subsystem that the driver is down
+
+	/* shows the usb subsystem that the driver is down */
 	if (usbduxsub_tmp->interface)
 		usb_set_intfdata(usbduxsub_tmp->interface, NULL);
 
@@ -2227,34 +2227,22 @@ static void tidy_up(usbduxsub_t * usbduxsub_tmp)
 			usbduxsub_tmp->pwm_cmd_running = 0;
 			usbduxsub_unlink_PwmURBs(usbduxsub_tmp);
 		}
-		if (usbduxsub_tmp->urbPwm->transfer_buffer) {
-			kfree(usbduxsub_tmp->urbPwm->transfer_buffer);
-			usbduxsub_tmp->urbPwm->transfer_buffer = NULL;
-		}
+		kfree(usbduxsub_tmp->urbPwm->transfer_buffer);
+		usbduxsub_tmp->urbPwm->transfer_buffer = NULL;
 		usb_kill_urb(usbduxsub_tmp->urbPwm);
 		usb_free_urb(usbduxsub_tmp->urbPwm);
 		usbduxsub_tmp->urbPwm = NULL;
 	}
-	if (usbduxsub_tmp->inBuffer) {
-		kfree(usbduxsub_tmp->inBuffer);
-		usbduxsub_tmp->inBuffer = NULL;
-	}
-	if (usbduxsub_tmp->insnBuffer) {
-		kfree(usbduxsub_tmp->insnBuffer);
-		usbduxsub_tmp->insnBuffer = NULL;
-	}
-	if (usbduxsub_tmp->inBuffer) {
-		kfree(usbduxsub_tmp->inBuffer);
-		usbduxsub_tmp->inBuffer = NULL;
-	}
-	if (usbduxsub_tmp->dac_commands) {
-		kfree(usbduxsub_tmp->dac_commands);
-		usbduxsub_tmp->dac_commands = NULL;
-	}
-	if (usbduxsub_tmp->dux_commands) {
-		kfree(usbduxsub_tmp->dux_commands);
-		usbduxsub_tmp->dux_commands = NULL;
-	}
+	kfree(usbduxsub_tmp->inBuffer);
+	usbduxsub_tmp->inBuffer = NULL;
+	kfree(usbduxsub_tmp->insnBuffer);
+	usbduxsub_tmp->insnBuffer = NULL;
+	kfree(usbduxsub_tmp->inBuffer);
+	usbduxsub_tmp->inBuffer = NULL;
+	kfree(usbduxsub_tmp->dac_commands);
+	usbduxsub_tmp->dac_commands = NULL;
+	kfree(usbduxsub_tmp->dux_commands);
+	usbduxsub_tmp->dux_commands = NULL;
 	usbduxsub_tmp->ai_cmd_running = 0;
 	usbduxsub_tmp->ao_cmd_running = 0;
 	usbduxsub_tmp->pwm_cmd_running = 0;
@@ -2263,24 +2251,25 @@ static void tidy_up(usbduxsub_t * usbduxsub_tmp)
 static unsigned hex2unsigned(char *h)
 {
 	unsigned hi, lo;
-	if (h[0] > '9') {
+
+	if (h[0] > '9')
 		hi = h[0] - 'A' + 0x0a;
-	} else {
+	else
 		hi = h[0] - '0';
-	}
-	if (h[1] > '9') {
+
+	if (h[1] > '9')
 		lo = h[1] - 'A' + 0x0a;
-	} else {
+	else
 		lo = h[1] - '0';
-	}
+
 	return hi * 0x10 + lo;
 }
 
-// for FX2
+/* for FX2 */
 #define FIRMWARE_MAX_LEN 0x2000
 
-// taken from David Brownell's fxload and adjusted for this driver
-static int read_firmware(usbduxsub_t * usbduxsub, void *firmwarePtr, long size)
+/* taken from David Brownell's fxload and adjusted for this driver */
+static int read_firmware(usbduxsub_t *usbduxsub, void *firmwarePtr, long size)
 {
 	int i = 0;
 	unsigned char *fp = (char *)firmwarePtr;
@@ -2335,9 +2324,9 @@ static int read_firmware(usbduxsub_t * usbduxsub, void *firmwarePtr, long size)
 		/* Read the target offset */
 		off = (hex2unsigned(buf + 3) * 0x0100) + hex2unsigned(buf + 5);
 
-		if ((off + len) > maxAddr) {
+		if ((off + len) > maxAddr)
 			maxAddr = off + len;
-		}
+
 
 		if (maxAddr >= FIRMWARE_MAX_LEN) {
 			printk("comedi_: usbdux: firmware upload goes beyond FX2 RAM boundaries.");
@@ -2349,9 +2338,9 @@ static int read_firmware(usbduxsub_t * usbduxsub, void *firmwarePtr, long size)
 		type = hex2unsigned(buf + 7);
 
 		/* If this is an EOF record, then make it so. */
-		if (type == 1) {
+		if (type == 1)
 			break;
-		}
+
 
 		if (type != 0) {
 			printk("comedi_: usbdux: unsupported record type: %u\n",
@@ -2466,20 +2455,20 @@ static int usbduxsub_probe(struct usb_interface *uinterf,
 		up(&start_stop_sem);
 		return PROBE_ERR_RETURN(-ENOMEM);
 	}
-	// setting to alternate setting 3: enabling iso ep and bulk ep.
+	/* setting to alternate setting 3: enabling iso ep and bulk ep. */
 	i = usb_set_interface(usbduxsub[index].usbdev,
-		usbduxsub[index].ifnum, 3);
+			      usbduxsub[index].ifnum, 3);
 	if (i < 0) {
 		printk("comedi_: usbdux%d: could not set alternate setting 3 in high speed.\n", index);
 		tidy_up(&(usbduxsub[index]));
 		up(&start_stop_sem);
 		return PROBE_ERR_RETURN(-ENODEV);
 	}
-	if (usbduxsub[index].high_speed) {
+	if (usbduxsub[index].high_speed)
 		usbduxsub[index].numOfInBuffers = NUMOFINBUFFERSHIGH;
-	} else {
+	else
 		usbduxsub[index].numOfInBuffers = NUMOFINBUFFERSFULL;
-	}
+
 	usbduxsub[index].urbIn =
 		kzalloc(sizeof(struct urb *) * usbduxsub[index].numOfInBuffers,
 		GFP_KERNEL);
@@ -2522,12 +2511,12 @@ static int usbduxsub_probe(struct usb_interface *uinterf,
 		usbduxsub[index].urbIn[i]->iso_frame_desc[0].length = SIZEINBUF;
 	}
 
-	// out
-	if (usbduxsub[index].high_speed) {
+	/* out */
+	if (usbduxsub[index].high_speed)
 		usbduxsub[index].numOfOutBuffers = NUMOFOUTBUFFERSHIGH;
-	} else {
+	else
 		usbduxsub[index].numOfOutBuffers = NUMOFOUTBUFFERSFULL;
-	}
+
 	usbduxsub[index].urbOut =
 		kzalloc(sizeof(struct urb *) * usbduxsub[index].numOfOutBuffers,
 		GFP_KERNEL);
@@ -2637,8 +2626,8 @@ static void usbduxsub_disconnect(struct usb_interface *intf)
 #endif
 }
 
-// is called when comedi-config is called
-static int usbdux_attach(comedi_device * dev, comedi_devconfig * it)
+/* is called when comedi-config is called */
+static int usbdux_attach(comedi_device *dev, comedi_devconfig *it)
 {
 	int ret;
 	int index;
@@ -2799,7 +2788,7 @@ static int usbdux_attach(comedi_device * dev, comedi_devconfig * it)
 	return 0;
 }
 
-static int usbdux_detach(comedi_device * dev)
+static int usbdux_detach(comedi_device *dev)
 {
 	usbduxsub_t *usbduxsub_tmp;
 
@@ -2833,10 +2822,10 @@ static int usbdux_detach(comedi_device * dev)
 
 /* main driver struct */
 static comedi_driver driver_usbdux = {
-      driver_name:"usbdux",
-      module:THIS_MODULE,
-      attach:usbdux_attach,
-      detach:usbdux_detach,
+      .driver_name =	"usbdux",
+      .module =		THIS_MODULE,
+      .attach =		usbdux_attach,
+      .detach =		usbdux_detach,
 };
 
 static void init_usb_devices(void)
@@ -2854,26 +2843,21 @@ static void init_usb_devices(void)
 	}
 }
 
-// Table with the USB-devices: just now only testing IDs
+/* Table with the USB-devices: just now only testing IDs */
 static struct usb_device_id usbduxsub_table[] = {
-	{USB_DEVICE(0x13d8, 0x0001),
-		},
-	{USB_DEVICE(0x13d8, 0x0002)
-		},
+	{USB_DEVICE(0x13d8, 0x0001) },
+	{USB_DEVICE(0x13d8, 0x0002) },
 	{}			/* Terminating entry */
 };
 
 MODULE_DEVICE_TABLE(usb, usbduxsub_table);
 
-// The usbduxsub-driver
+/* The usbduxsub-driver */
 static struct usb_driver usbduxsub_driver = {
-#ifdef COMEDI_HAVE_USB_DRIVER_OWNER
-      owner:THIS_MODULE,
-#endif
-      name:BOARDNAME,
-      probe:usbduxsub_probe,
-      disconnect:usbduxsub_disconnect,
-      id_table:usbduxsub_table,
+      .name =		BOARDNAME,
+      .probe =		usbduxsub_probe,
+      .disconnect =	usbduxsub_disconnect,
+      .id_table =	usbduxsub_table,
 };
 
 // Can't use the nice macro as I have also to initialise the USB