// 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;
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;
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;
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);
/* 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;
#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;
/* 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);
}
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;
}
// 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) {
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
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);
}
}
-static int usbduxsub_start(usbduxsub_t * usbduxsub)
+static int usbduxsub_start(usbduxsub_t *usbduxsub)
{
int errcode = 0;
uint8_t local_transfer_buffer[16];
return 0;
}
-static int usbduxsub_stop(usbduxsub_t * usbduxsub)
+static int usbduxsub_stop(usbduxsub_t *usbduxsub)
{
int errcode = 0;
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;
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;
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;
return 0;
}
-int usbduxsub_submit_OutURBs(usbduxsub_t * usbduxsub)
+static int usbduxsub_submit_OutURBs(usbduxsub_t *usbduxsub)
{
int i, errFlag;
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;
#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;
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;
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;
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;
#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)) {
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;
}
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;
}
}
/* 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;
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);
//////////////////
// 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);
#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);
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);
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
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);
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);
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;
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);
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);
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;
/////////////////////////////
// PWM
-static int usbduxsub_unlink_PwmURBs(usbduxsub_t * usbduxsub_tmp)
+static int usbduxsub_unlink_PwmURBs(usbduxsub_t *usbduxsub_tmp)
{
int err = 0;
/* 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;
#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;
}
/* 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);
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;
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
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 {
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;
}
// 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
#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:
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);
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;
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;
/* 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.");
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",
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);
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);
#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;
return 0;
}
-static int usbdux_detach(comedi_device * dev)
+static int usbdux_detach(comedi_device *dev)
{
usbduxsub_t *usbduxsub_tmp;
/* 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)
}
}
-// 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
projects / linux-beck.git / commitdiff