aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorH Hartley Sweeten <hartleys@visionengravers.com>2012-09-26 17:11:10 -0400
committerGreg Kroah-Hartman <gregkh@linuxfoundation.org>2012-09-26 17:24:05 -0400
commit27020ffed9166d65ce1e5b523051d13bfa2329b0 (patch)
tree1b670291dec2d946a7be79c3d93f67b337237d88
parentee692cfad6520f7cc60b766a3c013f9e6eba6e38 (diff)
staging: comedi: drivers: use comedi_fc.h cmdtest helpers
Use the cfc_check_trigger_src() helper for Step 1 in all the driver cmdtest functions. Use the cfc_check_trigger_is_unique() helper for Step 2 in all the driver cmdtest functions. Note that single source triggers do not need to be checked, they are already unique if they pass Step 1. For aesthetic reasons, change the comments in the cmdtest functions for steps 1 and 2 so that they are all the same. Signed-off-by: H Hartley Sweeten <hsweeten@visionengravers.com> Cc: Ian Abbott <abbotti@mev.co.uk> Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Diffstat
-rw-r--r--drivers/staging/comedi/drivers/8255.c37
-rw-r--r--drivers/staging/comedi/drivers/addi-data/hwdrv_apci3120.c55
-rw-r--r--drivers/staging/comedi/drivers/addi-data/hwdrv_apci3200.c67
-rw-r--r--drivers/staging/comedi/drivers/adl_pci9111.c2
-rw-r--r--drivers/staging/comedi/drivers/adl_pci9118.c73
-rw-r--r--drivers/staging/comedi/drivers/adv_pci1710.c2
-rw-r--r--drivers/staging/comedi/drivers/amplc_dio200.c51
-rw-r--r--drivers/staging/comedi/drivers/amplc_pc236.c36
-rw-r--r--drivers/staging/comedi/drivers/amplc_pci224.c60
-rw-r--r--drivers/staging/comedi/drivers/amplc_pci230.c146
-rw-r--r--drivers/staging/comedi/drivers/cb_das16_cs.c50
-rw-r--r--drivers/staging/comedi/drivers/cb_pcidas.c102
-rw-r--r--drivers/staging/comedi/drivers/cb_pcidas64.c106
-rw-r--r--drivers/staging/comedi/drivers/cb_pcidda.c59
-rw-r--r--drivers/staging/comedi/drivers/comedi_parport.c37
-rw-r--r--drivers/staging/comedi/drivers/comedi_test.c43
-rw-r--r--drivers/staging/comedi/drivers/das16.c52
-rw-r--r--drivers/staging/comedi/drivers/das16m1.c44
-rw-r--r--drivers/staging/comedi/drivers/das1800.c58
-rw-r--r--drivers/staging/comedi/drivers/das800.c44
-rw-r--r--drivers/staging/comedi/drivers/dmm32at.c51
-rw-r--r--drivers/staging/comedi/drivers/dt2814.c42
-rw-r--r--drivers/staging/comedi/drivers/dt282x.c89
-rw-r--r--drivers/staging/comedi/drivers/dt3000.c36
-rw-r--r--drivers/staging/comedi/drivers/gsc_hpdi.c41
-rw-r--r--drivers/staging/comedi/drivers/me4000.c117
-rw-r--r--drivers/staging/comedi/drivers/ni_6527.c37
-rw-r--r--drivers/staging/comedi/drivers/ni_65xx.c37
-rw-r--r--drivers/staging/comedi/drivers/ni_at_a2150.c44
-rw-r--r--drivers/staging/comedi/drivers/ni_atmio16d.c48
-rw-r--r--drivers/staging/comedi/drivers/ni_labpc.c52
-rw-r--r--drivers/staging/comedi/drivers/ni_mio_common.c151
-rw-r--r--drivers/staging/comedi/drivers/ni_pcidio.c47
-rw-r--r--drivers/staging/comedi/drivers/ni_tiocmd.c61
-rw-r--r--drivers/staging/comedi/drivers/pcl711.c43
-rw-r--r--drivers/staging/comedi/drivers/pcl812.c45
-rw-r--r--drivers/staging/comedi/drivers/pcl816.c46
-rw-r--r--drivers/staging/comedi/drivers/pcl818.c41
-rw-r--r--drivers/staging/comedi/drivers/pcm_common.c56
-rw-r--r--drivers/staging/comedi/drivers/quatech_daqp_cs.c55
-rw-r--r--drivers/staging/comedi/drivers/rtd520.c55
-rw-r--r--drivers/staging/comedi/drivers/s626.c60
-rw-r--r--drivers/staging/comedi/drivers/skel.c68
-rw-r--r--drivers/staging/comedi/drivers/usbdux.c130
-rw-r--r--drivers/staging/comedi/drivers/usbduxfast.c62
-rw-r--r--drivers/staging/comedi/drivers/usbduxsigma.c125
46 files changed, 766 insertions, 1997 deletions
diff --git a/drivers/staging/comedi/drivers/8255.c b/drivers/staging/comedi/drivers/8255.c
index e2506dd25305..a256622e2dd7 100644
--- a/drivers/staging/comedi/drivers/8255.c
+++ b/drivers/staging/comedi/drivers/8255.c
@@ -82,6 +82,8 @@ I/O port base address can be found in the output of 'lspci -v'.
82 82
83#include <linux/ioport.h> 83#include <linux/ioport.h>
84#include <linux/slab.h> 84#include <linux/slab.h>
85
86#include "comedi_fc.h"
85#include "8255.h" 87#include "8255.h"
86 88
87#define _8255_SIZE 4 89#define _8255_SIZE 4
@@ -229,39 +231,20 @@ static int subdev_8255_cmdtest(struct comedi_device *dev,
229 struct comedi_cmd *cmd) 231 struct comedi_cmd *cmd)
230{ 232{
231 int err = 0; 233 int err = 0;
232 unsigned int tmp;
233
234 /* step 1 */
235
236 tmp = cmd->start_src;
237 cmd->start_src &= TRIG_NOW;
238 if (!cmd->start_src || tmp != cmd->start_src)
239 err++;
240
241 tmp = cmd->scan_begin_src;
242 cmd->scan_begin_src &= TRIG_EXT;
243 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
244 err++;
245 234
246 tmp = cmd->convert_src; 235 /* Step 1 : check if triggers are trivially valid */
247 cmd->convert_src &= TRIG_FOLLOW;
248 if (!cmd->convert_src || tmp != cmd->convert_src)
249 err++;
250 236
251 tmp = cmd->scan_end_src; 237 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
252 cmd->scan_end_src &= TRIG_COUNT; 238 err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_EXT);
253 if (!cmd->scan_end_src || tmp != cmd->scan_end_src) 239 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_FOLLOW);
254 err++; 240 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
255 241 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_NONE);
256 tmp = cmd->stop_src;
257 cmd->stop_src &= TRIG_NONE;
258 if (!cmd->stop_src || tmp != cmd->stop_src)
259 err++;
260 242
261 if (err) 243 if (err)
262 return 1; 244 return 1;
263 245
264 /* step 2 */ 246 /* Step 2a : make sure trigger sources are unique */
247 /* Step 2b : and mutually compatible */
265 248
266 if (err) 249 if (err)
267 return 2; 250 return 2;
diff --git a/drivers/staging/comedi/drivers/addi-data/hwdrv_apci3120.c b/drivers/staging/comedi/drivers/addi-data/hwdrv_apci3120.c
index d61fce081c14..f406dfb2a677 100644
--- a/drivers/staging/comedi/drivers/addi-data/hwdrv_apci3120.c
+++ b/drivers/staging/comedi/drivers/addi-data/hwdrv_apci3120.c
@@ -479,57 +479,26 @@ int i_APCI3120_CommandTestAnalogInput(struct comedi_device *dev, struct comedi_s
479 struct comedi_cmd *cmd) 479 struct comedi_cmd *cmd)
480{ 480{
481 int err = 0; 481 int err = 0;
482 int tmp; /* divisor1,divisor2; */
483 482
484 /* step 1: make sure trigger sources are trivially valid */ 483 /* Step 1 : check if triggers are trivially valid */
485 484
486 tmp = cmd->start_src; 485 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_EXT);
487 cmd->start_src &= TRIG_NOW | TRIG_EXT; 486 err |= cfc_check_trigger_src(&cmd->scan_begin_src,
488 if (!cmd->start_src || tmp != cmd->start_src) 487 TRIG_TIMER | TRIG_FOLLOW);
489 err++; 488 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_TIMER);
490 489 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
491 tmp = cmd->scan_begin_src; 490 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
492 cmd->scan_begin_src &= TRIG_TIMER | TRIG_FOLLOW;
493 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
494 err++;
495
496 tmp = cmd->convert_src;
497 cmd->convert_src &= TRIG_TIMER;
498 if (!cmd->convert_src || tmp != cmd->convert_src)
499 err++;
500
501 tmp = cmd->scan_end_src;
502 cmd->scan_end_src &= TRIG_COUNT;
503 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
504 err++;
505
506 tmp = cmd->stop_src;
507 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
508 if (!cmd->stop_src || tmp != cmd->stop_src)
509 err++;
510 491
511 if (err) 492 if (err)
512 return 1; 493 return 1;
513 494
514 /* step 2: make sure trigger sources are unique and mutually compatible */ 495 /* Step 2a : make sure trigger sources are unique */
515 496
516 if (cmd->start_src != TRIG_NOW && cmd->start_src != TRIG_EXT) 497 err |= cfc_check_trigger_is_unique(cmd->start_src);
517 err++; 498 err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
518 499 err |= cfc_check_trigger_is_unique(cmd->stop_src);
519 if (cmd->scan_begin_src != TRIG_TIMER &&
520 cmd->scan_begin_src != TRIG_FOLLOW)
521 err++;
522
523 if (cmd->convert_src != TRIG_TIMER)
524 err++;
525 500
526 if (cmd->scan_end_src != TRIG_COUNT) { 501 /* Step 2b : and mutually compatible */
527 cmd->scan_end_src = TRIG_COUNT;
528 err++;
529 }
530
531 if (cmd->stop_src != TRIG_NONE && cmd->stop_src != TRIG_COUNT)
532 err++;
533 502
534 if (err) 503 if (err)
535 return 2; 504 return 2;
diff --git a/drivers/staging/comedi/drivers/addi-data/hwdrv_apci3200.c b/drivers/staging/comedi/drivers/addi-data/hwdrv_apci3200.c
index f6f50923fa14..38ab49917d7e 100644
--- a/drivers/staging/comedi/drivers/addi-data/hwdrv_apci3200.c
+++ b/drivers/staging/comedi/drivers/addi-data/hwdrv_apci3200.c
@@ -2560,7 +2560,6 @@ int i_APCI3200_CommandTestAnalogInput(struct comedi_device *dev, struct comedi_s
2560{ 2560{
2561 2561
2562 int err = 0; 2562 int err = 0;
2563 int tmp; /* divisor1,divisor2; */
2564 unsigned int ui_ConvertTime = 0; 2563 unsigned int ui_ConvertTime = 0;
2565 unsigned int ui_ConvertTimeBase = 0; 2564 unsigned int ui_ConvertTimeBase = 0;
2566 unsigned int ui_DelayTime = 0; 2565 unsigned int ui_DelayTime = 0;
@@ -2571,41 +2570,32 @@ int i_APCI3200_CommandTestAnalogInput(struct comedi_device *dev, struct comedi_s
2571 int i_Cpt = 0; 2570 int i_Cpt = 0;
2572 double d_ConversionTimeForAllChannels = 0.0; 2571 double d_ConversionTimeForAllChannels = 0.0;
2573 double d_SCANTimeNewUnit = 0.0; 2572 double d_SCANTimeNewUnit = 0.0;
2574 /* step 1: make sure trigger sources are trivially valid */ 2573
2575 2574 /* Step 1 : check if triggers are trivially valid */
2576 tmp = cmd->start_src; 2575
2577 cmd->start_src &= TRIG_NOW | TRIG_EXT; 2576 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_EXT);
2578 if (!cmd->start_src || tmp != cmd->start_src) 2577 err |= cfc_check_trigger_src(&cmd->scan_begin_src,
2579 err++; 2578 TRIG_TIMER | TRIG_FOLLOW);
2580 tmp = cmd->scan_begin_src; 2579 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_TIMER);
2581 cmd->scan_begin_src &= TRIG_TIMER | TRIG_FOLLOW; 2580 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
2582 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src) 2581 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
2583 err++; 2582
2584 tmp = cmd->convert_src; 2583 if (s_BoardInfos[dev->minor].i_InterruptFlag == 0)
2585 cmd->convert_src &= TRIG_TIMER; 2584 err |= -EINVAL;
2586 if (!cmd->convert_src || tmp != cmd->convert_src) 2585
2587 err++;
2588 tmp = cmd->scan_end_src;
2589 cmd->scan_end_src &= TRIG_COUNT;
2590 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
2591 err++;
2592 tmp = cmd->stop_src;
2593 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
2594 if (!cmd->stop_src || tmp != cmd->stop_src)
2595 err++;
2596 /* if(i_InterruptFlag==0) */
2597 if (s_BoardInfos[dev->minor].i_InterruptFlag == 0) {
2598 err++;
2599 /* printk("\nThe interrupt should be enabled\n"); */
2600 }
2601 if (err) { 2586 if (err) {
2602 i_APCI3200_Reset(dev); 2587 i_APCI3200_Reset(dev);
2603 return 1; 2588 return 1;
2604 } 2589 }
2605 2590
2606 if (cmd->start_src != TRIG_NOW && cmd->start_src != TRIG_EXT) { 2591 /* Step 2a : make sure trigger sources are unique */
2607 err++; 2592
2608 } 2593 err |= cfc_check_trigger_is_unique(&cmd->start_src);
2594 err |= cfc_check_trigger_is_unique(&cmd->scan_begin_src);
2595 err |= cfc_check_trigger_is_unique(&cmd->stop_src);
2596
2597 /* Step 2b : and mutually compatible */
2598
2609 if (cmd->start_src == TRIG_EXT) { 2599 if (cmd->start_src == TRIG_EXT) {
2610 i_TriggerEdge = cmd->start_arg & 0xFFFF; 2600 i_TriggerEdge = cmd->start_arg & 0xFFFF;
2611 i_Triggermode = cmd->start_arg >> 16; 2601 i_Triggermode = cmd->start_arg >> 16;
@@ -2619,21 +2609,6 @@ int i_APCI3200_CommandTestAnalogInput(struct comedi_device *dev, struct comedi_s
2619 } 2609 }
2620 } 2610 }
2621 2611
2622 if (cmd->scan_begin_src != TRIG_TIMER &&
2623 cmd->scan_begin_src != TRIG_FOLLOW)
2624 err++;
2625
2626 if (cmd->convert_src != TRIG_TIMER)
2627 err++;
2628
2629 if (cmd->scan_end_src != TRIG_COUNT) {
2630 cmd->scan_end_src = TRIG_COUNT;
2631 err++;
2632 }
2633
2634 if (cmd->stop_src != TRIG_NONE && cmd->stop_src != TRIG_COUNT)
2635 err++;
2636
2637 if (err) { 2612 if (err) {
2638 i_APCI3200_Reset(dev); 2613 i_APCI3200_Reset(dev);
2639 return 2; 2614 return 2;
diff --git a/drivers/staging/comedi/drivers/adl_pci9111.c b/drivers/staging/comedi/drivers/adl_pci9111.c
index 91efaa4caadb..a87192ac2846 100644
--- a/drivers/staging/comedi/drivers/adl_pci9111.c
+++ b/drivers/staging/comedi/drivers/adl_pci9111.c
@@ -332,7 +332,7 @@ static int pci9111_ai_do_cmd_test(struct comedi_device *dev,
332 int range, reference; 332 int range, reference;
333 int i; 333 int i;
334 334
335 /* Step 1 : check if trigger are trivialy valid */ 335 /* Step 1 : check if triggers are trivially valid */
336 336
337 error |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW); 337 error |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
338 error |= cfc_check_trigger_src(&cmd->scan_begin_src, 338 error |= cfc_check_trigger_src(&cmd->scan_begin_src,
diff --git a/drivers/staging/comedi/drivers/adl_pci9118.c b/drivers/staging/comedi/drivers/adl_pci9118.c
index f7b254d004dc..06ff65c85c9f 100644
--- a/drivers/staging/comedi/drivers/adl_pci9118.c
+++ b/drivers/staging/comedi/drivers/adl_pci9118.c
@@ -1102,7 +1102,7 @@ static int pci9118_ai_cmdtest(struct comedi_device *dev,
1102 int tmp; 1102 int tmp;
1103 unsigned int divisor1 = 0, divisor2 = 0; 1103 unsigned int divisor1 = 0, divisor2 = 0;
1104 1104
1105 /* step 1: make sure trigger sources are trivially valid */ 1105 /* Step 1 : check if triggers are trivially valid */
1106 1106
1107 err |= cfc_check_trigger_src(&cmd->start_src, 1107 err |= cfc_check_trigger_src(&cmd->start_src,
1108 TRIG_NOW | TRIG_EXT | TRIG_INT); 1108 TRIG_NOW | TRIG_EXT | TRIG_INT);
@@ -1124,70 +1124,31 @@ static int pci9118_ai_cmdtest(struct comedi_device *dev,
1124 if (err) 1124 if (err)
1125 return 1; 1125 return 1;
1126 1126
1127 /* 1127 /* Step 2a : make sure trigger sources are unique */
1128 * step 2:
1129 * make sure trigger sources are
1130 * unique and mutually compatible
1131 */
1132 1128
1133 if (cmd->start_src != TRIG_NOW && 1129 err |= cfc_check_trigger_is_unique(cmd->start_src);
1134 cmd->start_src != TRIG_INT && cmd->start_src != TRIG_EXT) { 1130 err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
1135 cmd->start_src = TRIG_NOW; 1131 err |= cfc_check_trigger_is_unique(cmd->convert_src);
1136 err++; 1132 err |= cfc_check_trigger_is_unique(cmd->stop_src);
1137 }
1138
1139 if (cmd->scan_begin_src != TRIG_TIMER &&
1140 cmd->scan_begin_src != TRIG_EXT &&
1141 cmd->scan_begin_src != TRIG_INT &&
1142 cmd->scan_begin_src != TRIG_FOLLOW) {
1143 cmd->scan_begin_src = TRIG_FOLLOW;
1144 err++;
1145 }
1146
1147 if (cmd->convert_src != TRIG_TIMER &&
1148 cmd->convert_src != TRIG_EXT && cmd->convert_src != TRIG_NOW) {
1149 cmd->convert_src = TRIG_TIMER;
1150 err++;
1151 }
1152
1153 if (cmd->scan_end_src != TRIG_COUNT) {
1154 cmd->scan_end_src = TRIG_COUNT;
1155 err++;
1156 }
1157 1133
1158 if (cmd->stop_src != TRIG_NONE && 1134 /* Step 2b : and mutually compatible */
1159 cmd->stop_src != TRIG_COUNT &&
1160 cmd->stop_src != TRIG_INT && cmd->stop_src != TRIG_EXT) {
1161 cmd->stop_src = TRIG_COUNT;
1162 err++;
1163 }
1164 1135
1165 if (cmd->start_src == TRIG_EXT && cmd->scan_begin_src == TRIG_EXT) { 1136 if (cmd->start_src == TRIG_EXT && cmd->scan_begin_src == TRIG_EXT)
1166 cmd->start_src = TRIG_NOW; 1137 err |= -EINVAL;
1167 err++;
1168 }
1169 1138
1170 if (cmd->start_src == TRIG_INT && cmd->scan_begin_src == TRIG_INT) { 1139 if (cmd->start_src == TRIG_INT && cmd->scan_begin_src == TRIG_INT)
1171 cmd->start_src = TRIG_NOW; 1140 err |= -EINVAL;
1172 err++;
1173 }
1174 1141
1175 if ((cmd->scan_begin_src & (TRIG_TIMER | TRIG_EXT)) && 1142 if ((cmd->scan_begin_src & (TRIG_TIMER | TRIG_EXT)) &&
1176 (!(cmd->convert_src & (TRIG_TIMER | TRIG_NOW)))) { 1143 (!(cmd->convert_src & (TRIG_TIMER | TRIG_NOW))))
1177 cmd->convert_src = TRIG_TIMER; 1144 err |= -EINVAL;
1178 err++;
1179 }
1180 1145
1181 if ((cmd->scan_begin_src == TRIG_FOLLOW) && 1146 if ((cmd->scan_begin_src == TRIG_FOLLOW) &&
1182 (!(cmd->convert_src & (TRIG_TIMER | TRIG_EXT)))) { 1147 (!(cmd->convert_src & (TRIG_TIMER | TRIG_EXT))))
1183 cmd->convert_src = TRIG_TIMER; 1148 err |= -EINVAL;
1184 err++;
1185 }
1186 1149
1187 if (cmd->stop_src == TRIG_EXT && cmd->scan_begin_src == TRIG_EXT) { 1150 if (cmd->stop_src == TRIG_EXT && cmd->scan_begin_src == TRIG_EXT)
1188 cmd->stop_src = TRIG_COUNT; 1151 err |= -EINVAL;
1189 err++;
1190 }
1191 1152
1192 if (err) 1153 if (err)
1193 return 2; 1154 return 2;
diff --git a/drivers/staging/comedi/drivers/adv_pci1710.c b/drivers/staging/comedi/drivers/adv_pci1710.c
index 0fd0210625f6..def37bcc2a66 100644
--- a/drivers/staging/comedi/drivers/adv_pci1710.c
+++ b/drivers/staging/comedi/drivers/adv_pci1710.c
@@ -1046,7 +1046,7 @@ static int pci171x_ai_cmdtest(struct comedi_device *dev,
1046 int tmp; 1046 int tmp;
1047 unsigned int divisor1 = 0, divisor2 = 0; 1047 unsigned int divisor1 = 0, divisor2 = 0;
1048 1048
1049 /* step 1: make sure trigger sources are trivially valid */ 1049 /* Step 1 : check if triggers are trivially valid */
1050 1050
1051 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_EXT); 1051 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_EXT);
1052 err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_FOLLOW); 1052 err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_FOLLOW);
diff --git a/drivers/staging/comedi/drivers/amplc_dio200.c b/drivers/staging/comedi/drivers/amplc_dio200.c
index b7cfc13a951f..08f305210a69 100644
--- a/drivers/staging/comedi/drivers/amplc_dio200.c
+++ b/drivers/staging/comedi/drivers/amplc_dio200.c
@@ -210,6 +210,7 @@ order they appear in the channel list.
210 210
211#include "../comedidev.h" 211#include "../comedidev.h"
212 212
213#include "comedi_fc.h"
213#include "8255.h" 214#include "8255.h"
214#include "8253.h" 215#include "8253.h"
215 216
@@ -771,52 +772,24 @@ dio200_subdev_intr_cmdtest(struct comedi_device *dev,
771 struct comedi_subdevice *s, struct comedi_cmd *cmd) 772 struct comedi_subdevice *s, struct comedi_cmd *cmd)
772{ 773{
773 int err = 0; 774 int err = 0;
774 unsigned int tmp;
775 775
776 /* step 1: make sure trigger sources are trivially valid */ 776 /* Step 1 : check if triggers are trivially valid */
777 777
778 tmp = cmd->start_src; 778 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_INT);
779 cmd->start_src &= (TRIG_NOW | TRIG_INT); 779 err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_EXT);
780 if (!cmd->start_src || tmp != cmd->start_src) 780 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW);
781 err++; 781 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
782 782 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
783 tmp = cmd->scan_begin_src;
784 cmd->scan_begin_src &= TRIG_EXT;
785 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
786 err++;
787
788 tmp = cmd->convert_src;
789 cmd->convert_src &= TRIG_NOW;
790 if (!cmd->convert_src || tmp != cmd->convert_src)
791 err++;
792
793 tmp = cmd->scan_end_src;
794 cmd->scan_end_src &= TRIG_COUNT;
795 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
796 err++;
797
798 tmp = cmd->stop_src;
799 cmd->stop_src &= (TRIG_COUNT | TRIG_NONE);
800 if (!cmd->stop_src || tmp != cmd->stop_src)
801 err++;
802 783
803 if (err) 784 if (err)
804 return 1; 785 return 1;
805 786
806 /* step 2: make sure trigger sources are unique and mutually 787 /* Step 2a : make sure trigger sources are unique */
807 compatible */
808 788
809 /* these tests are true if more than one _src bit is set */ 789 err |= cfc_check_trigger_is_unique(cmd->start_src);
810 if ((cmd->start_src & (cmd->start_src - 1)) != 0) 790 err |= cfc_check_trigger_is_unique(cmd->stop_src);
811 err++; 791
812 if ((cmd->scan_begin_src & (cmd->scan_begin_src - 1)) != 0) 792 /* Step 2b : and mutually compatible */
813 err++;
814 if ((cmd->convert_src & (cmd->convert_src - 1)) != 0)
815 err++;
816 if ((cmd->scan_end_src & (cmd->scan_end_src - 1)) != 0)
817 err++;
818 if ((cmd->stop_src & (cmd->stop_src - 1)) != 0)
819 err++;
820 793
821 if (err) 794 if (err)
822 return 2; 795 return 2;
diff --git a/drivers/staging/comedi/drivers/amplc_pc236.c b/drivers/staging/comedi/drivers/amplc_pc236.c
index a957cd846088..eacb5e4735d7 100644
--- a/drivers/staging/comedi/drivers/amplc_pc236.c
+++ b/drivers/staging/comedi/drivers/amplc_pc236.c
@@ -56,6 +56,7 @@ unused.
56 56
57#include "../comedidev.h" 57#include "../comedidev.h"
58 58
59#include "comedi_fc.h"
59#include "8255.h" 60#include "8255.h"
60#include "plx9052.h" 61#include "plx9052.h"
61 62
@@ -313,39 +314,20 @@ static int pc236_intr_cmdtest(struct comedi_device *dev,
313 struct comedi_cmd *cmd) 314 struct comedi_cmd *cmd)
314{ 315{
315 int err = 0; 316 int err = 0;
316 int tmp;
317 317
318 /* step 1 */ 318 /* Step 1 : check if triggers are trivially valid */
319 319
320 tmp = cmd->start_src; 320 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
321 cmd->start_src &= TRIG_NOW; 321 err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_EXT);
322 if (!cmd->start_src || tmp != cmd->start_src) 322 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_FOLLOW);
323 err++; 323 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
324 324 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_NONE);
325 tmp = cmd->scan_begin_src;
326 cmd->scan_begin_src &= TRIG_EXT;
327 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
328 err++;
329
330 tmp = cmd->convert_src;
331 cmd->convert_src &= TRIG_FOLLOW;
332 if (!cmd->convert_src || tmp != cmd->convert_src)
333 err++;
334
335 tmp = cmd->scan_end_src;
336 cmd->scan_end_src &= TRIG_COUNT;
337 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
338 err++;
339
340 tmp = cmd->stop_src;
341 cmd->stop_src &= TRIG_NONE;
342 if (!cmd->stop_src || tmp != cmd->stop_src)
343 err++;
344 325
345 if (err) 326 if (err)
346 return 1; 327 return 1;
347 328
348 /* step 2: ignored */ 329 /* Step 2a : make sure trigger sources are unique */
330 /* Step 2b : and mutually compatible */
349 331
350 if (err) 332 if (err)
351 return 2; 333 return 2;
diff --git a/drivers/staging/comedi/drivers/amplc_pci224.c b/drivers/staging/comedi/drivers/amplc_pci224.c
index 365f911b9b0e..1f65ec4d261e 100644
--- a/drivers/staging/comedi/drivers/amplc_pci224.c
+++ b/drivers/staging/comedi/drivers/amplc_pci224.c
@@ -720,53 +720,31 @@ pci224_ao_cmdtest(struct comedi_device *dev, struct comedi_subdevice *s,
720 int err = 0; 720 int err = 0;
721 unsigned int tmp; 721 unsigned int tmp;
722 722
723 /* Step 1: make sure trigger sources are trivially valid. */ 723 /* Step 1 : check if triggers are trivially valid */
724 724
725 tmp = cmd->start_src; 725 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_INT | TRIG_EXT);
726 cmd->start_src &= TRIG_INT | TRIG_EXT; 726 err |= cfc_check_trigger_src(&cmd->scan_begin_src,
727 if (!cmd->start_src || tmp != cmd->start_src) 727 TRIG_EXT | TRIG_TIMER);
728 err++; 728 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW);
729 729 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
730 tmp = cmd->scan_begin_src; 730 err |= cfc_check_trigger_src(&cmd->stop_src,
731 cmd->scan_begin_src &= TRIG_EXT | TRIG_TIMER; 731 TRIG_COUNT | TRIG_EXT | TRIG_NONE);
732 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
733 err++;
734
735 tmp = cmd->convert_src;
736 cmd->convert_src &= TRIG_NOW;
737 if (!cmd->convert_src || tmp != cmd->convert_src)
738 err++;
739
740 tmp = cmd->scan_end_src;
741 cmd->scan_end_src &= TRIG_COUNT;
742 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
743 err++;
744
745 tmp = cmd->stop_src;
746 cmd->stop_src &= TRIG_COUNT | TRIG_EXT | TRIG_NONE;
747 if (!cmd->stop_src || tmp != cmd->stop_src)
748 err++;
749 732
750 if (err) 733 if (err)
751 return 1; 734 return 1;
752 735
753 /* Step 2: make sure trigger sources are unique and mutually 736 /* Step 2a : make sure trigger sources are unique */
754 * compatible. */
755 737
756 /* these tests are true if more than one _src bit is set */ 738 err |= cfc_check_trigger_is_unique(cmd->start_src);
757 if ((cmd->start_src & (cmd->start_src - 1)) != 0) 739 err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
758 err++; 740 err |= cfc_check_trigger_is_unique(cmd->stop_src);
759 if ((cmd->scan_begin_src & (cmd->scan_begin_src - 1)) != 0)
760 err++;
761 if ((cmd->convert_src & (cmd->convert_src - 1)) != 0)
762 err++;
763 if ((cmd->scan_end_src & (cmd->scan_end_src - 1)) != 0)
764 err++;
765 if ((cmd->stop_src & (cmd->stop_src - 1)) != 0)
766 err++;
767 741
768 /* There's only one external trigger signal (which makes these 742 /* Step 2b : and mutually compatible */
769 * tests easier). Only one thing can use it. */ 743
744 /*
745 * There's only one external trigger signal (which makes these
746 * tests easier). Only one thing can use it.
747 */
770 tmp = 0; 748 tmp = 0;
771 if (cmd->start_src & TRIG_EXT) 749 if (cmd->start_src & TRIG_EXT)
772 tmp++; 750 tmp++;
@@ -775,7 +753,7 @@ pci224_ao_cmdtest(struct comedi_device *dev, struct comedi_subdevice *s,
775 if (cmd->stop_src & TRIG_EXT) 753 if (cmd->stop_src & TRIG_EXT)
776 tmp++; 754 tmp++;
777 if (tmp > 1) 755 if (tmp > 1)
778 err++; 756 err |= -EINVAL;
779 757
780 if (err) 758 if (err)
781 return 2; 759 return 2;
diff --git a/drivers/staging/comedi/drivers/amplc_pci230.c b/drivers/staging/comedi/drivers/amplc_pci230.c
index 4c9f1314ea1d..bd8fb876ce2e 100644
--- a/drivers/staging/comedi/drivers/amplc_pci230.c
+++ b/drivers/staging/comedi/drivers/amplc_pci230.c
@@ -193,6 +193,7 @@ for (or detection of) various hardware problems added by Ian Abbott.
193#include <linux/delay.h> 193#include <linux/delay.h>
194#include <linux/interrupt.h> 194#include <linux/interrupt.h>
195 195
196#include "comedi_fc.h"
196#include "8253.h" 197#include "8253.h"
197#include "8255.h" 198#include "8255.h"
198 199
@@ -958,23 +959,11 @@ static int pci230_ao_cmdtest(struct comedi_device *dev,
958 int err = 0; 959 int err = 0;
959 unsigned int tmp; 960 unsigned int tmp;
960 961
961 /* cmdtest tests a particular command to see if it is valid. 962 /* Step 1 : check if triggers are trivially valid */
962 * Using the cmdtest ioctl, a user can create a valid cmd
963 * and then have it executes by the cmd ioctl.
964 *
965 * cmdtest returns 1,2,3,4 or 0, depending on which tests
966 * the command passes. */
967 963
968 /* Step 1: make sure trigger sources are trivially valid. 964 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_INT);
969 * "invalid source" returned by comedilib to user mode process
970 * if this fails. */
971
972 tmp = cmd->start_src;
973 cmd->start_src &= TRIG_INT;
974 if (!cmd->start_src || tmp != cmd->start_src)
975 err++;
976 965
977 tmp = cmd->scan_begin_src; 966 tmp = TRIG_TIMER | TRIG_INT;
978 if ((thisboard->min_hwver > 0) && (devpriv->hwver >= 2)) { 967 if ((thisboard->min_hwver > 0) && (devpriv->hwver >= 2)) {
979 /* 968 /*
980 * For PCI230+ hardware version 2 onwards, allow external 969 * For PCI230+ hardware version 2 onwards, allow external
@@ -990,46 +979,23 @@ static int pci230_ao_cmdtest(struct comedi_device *dev,
990 * scan_begin_src==TRIG_EXT support to be a bonus rather than a 979 * scan_begin_src==TRIG_EXT support to be a bonus rather than a
991 * guarantee! 980 * guarantee!
992 */ 981 */
993 cmd->scan_begin_src &= TRIG_TIMER | TRIG_INT | TRIG_EXT; 982 tmp |= TRIG_EXT;
994 } else {
995 cmd->scan_begin_src &= TRIG_TIMER | TRIG_INT;
996 } 983 }
997 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src) 984 err |= cfc_check_trigger_src(&cmd->scan_begin_src, tmp);
998 err++;
999 985
1000 tmp = cmd->convert_src; 986 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW);
1001 cmd->convert_src &= TRIG_NOW; 987 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
1002 if (!cmd->convert_src || tmp != cmd->convert_src) 988 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
1003 err++;
1004
1005 tmp = cmd->scan_end_src;
1006 cmd->scan_end_src &= TRIG_COUNT;
1007 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
1008 err++;
1009
1010 tmp = cmd->stop_src;
1011 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
1012 if (!cmd->stop_src || tmp != cmd->stop_src)
1013 err++;
1014 989
1015 if (err) 990 if (err)
1016 return 1; 991 return 1;
1017 992
1018 /* Step 2: make sure trigger sources are unique and mutually compatible 993 /* Step 2a : make sure trigger sources are unique */
1019 * "source conflict" returned by comedilib to user mode process
1020 * if this fails. */
1021 994
1022 /* these tests are true if more than one _src bit is set */ 995 err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
1023 if ((cmd->start_src & (cmd->start_src - 1)) != 0) 996 err |= cfc_check_trigger_is_unique(cmd->stop_src);
1024 err++; 997
1025 if ((cmd->scan_begin_src & (cmd->scan_begin_src - 1)) != 0) 998 /* Step 2b : and mutually compatible */
1026 err++;
1027 if ((cmd->convert_src & (cmd->convert_src - 1)) != 0)
1028 err++;
1029 if ((cmd->scan_end_src & (cmd->scan_end_src - 1)) != 0)
1030 err++;
1031 if ((cmd->stop_src & (cmd->stop_src - 1)) != 0)
1032 err++;
1033 999
1034 if (err) 1000 if (err)
1035 return 2; 1001 return 2;
@@ -1610,75 +1576,45 @@ static int pci230_ai_cmdtest(struct comedi_device *dev,
1610 int err = 0; 1576 int err = 0;
1611 unsigned int tmp; 1577 unsigned int tmp;
1612 1578
1613 /* cmdtest tests a particular command to see if it is valid. 1579 /* Step 1 : check if triggers are trivially valid */
1614 * Using the cmdtest ioctl, a user can create a valid cmd
1615 * and then have it executes by the cmd ioctl.
1616 *
1617 * cmdtest returns 1,2,3,4,5 or 0, depending on which tests
1618 * the command passes. */
1619 1580
1620 /* Step 1: make sure trigger sources are trivially valid. 1581 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_INT);
1621 * "invalid source" returned by comedilib to user mode process
1622 * if this fails. */
1623
1624 tmp = cmd->start_src;
1625 cmd->start_src &= TRIG_NOW | TRIG_INT;
1626 if (!cmd->start_src || tmp != cmd->start_src)
1627 err++;
1628 1582
1629 tmp = cmd->scan_begin_src; 1583 tmp = TRIG_FOLLOW | TRIG_TIMER | TRIG_INT;
1630 /* Unfortunately, we cannot trigger a scan off an external source
1631 * on the PCI260 board, since it uses the PPIC0 (DIO) input, which
1632 * isn't present on the PCI260. For PCI260+ we can use the
1633 * EXTTRIG/EXTCONVCLK input on pin 17 instead. */
1634 if ((thisboard->have_dio) || (thisboard->min_hwver > 0)) { 1584 if ((thisboard->have_dio) || (thisboard->min_hwver > 0)) {
1635 cmd->scan_begin_src &= TRIG_FOLLOW | TRIG_TIMER | TRIG_INT 1585 /*
1636 | TRIG_EXT; 1586 * Unfortunately, we cannot trigger a scan off an external
1637 } else { 1587 * source on the PCI260 board, since it uses the PPIC0 (DIO)
1638 cmd->scan_begin_src &= TRIG_FOLLOW | TRIG_TIMER | TRIG_INT; 1588 * input, which isn't present on the PCI260. For PCI260+
1589 * we can use the EXTTRIG/EXTCONVCLK input on pin 17 instead.
1590 */
1591 tmp |= TRIG_EXT;
1639 } 1592 }
1640 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src) 1593 err |= cfc_check_trigger_src(&cmd->scan_begin_src, tmp);
1641 err++; 1594 err |= cfc_check_trigger_src(&cmd->convert_src,
1642 1595 TRIG_TIMER | TRIG_INT | TRIG_EXT);
1643 tmp = cmd->convert_src; 1596 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
1644 cmd->convert_src &= TRIG_TIMER | TRIG_INT | TRIG_EXT; 1597 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
1645 if (!cmd->convert_src || tmp != cmd->convert_src)
1646 err++;
1647
1648 tmp = cmd->scan_end_src;
1649 cmd->scan_end_src &= TRIG_COUNT;
1650 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
1651 err++;
1652
1653 tmp = cmd->stop_src;
1654 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
1655 if (!cmd->stop_src || tmp != cmd->stop_src)
1656 err++;
1657 1598
1658 if (err) 1599 if (err)
1659 return 1; 1600 return 1;
1660 1601
1661 /* Step 2: make sure trigger sources are unique and mutually compatible 1602 /* Step 2a : make sure trigger sources are unique */
1662 * "source conflict" returned by comedilib to user mode process
1663 * if this fails. */
1664 1603
1665 /* these tests are true if more than one _src bit is set */ 1604 err |= cfc_check_trigger_is_unique(cmd->start_src);
1666 if ((cmd->start_src & (cmd->start_src - 1)) != 0) 1605 err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
1667 err++; 1606 err |= cfc_check_trigger_is_unique(cmd->convert_src);
1668 if ((cmd->scan_begin_src & (cmd->scan_begin_src - 1)) != 0) 1607 err |= cfc_check_trigger_is_unique(cmd->stop_src);
1669 err++; 1608
1670 if ((cmd->convert_src & (cmd->convert_src - 1)) != 0) 1609 /* Step 2b : and mutually compatible */
1671 err++;
1672 if ((cmd->scan_end_src & (cmd->scan_end_src - 1)) != 0)
1673 err++;
1674 if ((cmd->stop_src & (cmd->stop_src - 1)) != 0)
1675 err++;
1676 1610
1677 /* If scan_begin_src is not TRIG_FOLLOW, then a monostable will be 1611 /*
1678 * set up to generate a fixed number of timed conversion pulses. */ 1612 * If scan_begin_src is not TRIG_FOLLOW, then a monostable will be
1613 * set up to generate a fixed number of timed conversion pulses.
1614 */
1679 if ((cmd->scan_begin_src != TRIG_FOLLOW) 1615 if ((cmd->scan_begin_src != TRIG_FOLLOW)
1680 && (cmd->convert_src != TRIG_TIMER)) 1616 && (cmd->convert_src != TRIG_TIMER))
1681 err++; 1617 err |= -EINVAL;
1682 1618
1683 if (err) 1619 if (err)
1684 return 2; 1620 return 2;
diff --git a/drivers/staging/comedi/drivers/cb_das16_cs.c b/drivers/staging/comedi/drivers/cb_das16_cs.c
index a3d53babe137..6d81d8b40ccc 100644
--- a/drivers/staging/comedi/drivers/cb_das16_cs.c
+++ b/drivers/staging/comedi/drivers/cb_das16_cs.c
@@ -46,6 +46,7 @@ Status: experimental
46#include <pcmcia/cistpl.h> 46#include <pcmcia/cistpl.h>
47#include <pcmcia/ds.h> 47#include <pcmcia/ds.h>
48 48
49#include "comedi_fc.h"
49#include "8253.h" 50#include "8253.h"
50 51
51#define DAS16CS_SIZE 18 52#define DAS16CS_SIZE 18
@@ -169,47 +170,26 @@ static int das16cs_ai_cmdtest(struct comedi_device *dev,
169 int err = 0; 170 int err = 0;
170 int tmp; 171 int tmp;
171 172
172 /* step 1: make sure trigger sources are trivially valid */ 173 /* Step 1 : check if triggers are trivially valid */
173 174
174 tmp = cmd->start_src; 175 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
175 cmd->start_src &= TRIG_NOW; 176 err |= cfc_check_trigger_src(&cmd->scan_begin_src,
176 if (!cmd->start_src || tmp != cmd->start_src) 177 TRIG_TIMER | TRIG_EXT);
177 err++; 178 err |= cfc_check_trigger_src(&cmd->convert_src,
178 179 TRIG_TIMER | TRIG_EXT);
179 tmp = cmd->scan_begin_src; 180 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
180 cmd->scan_begin_src &= TRIG_TIMER | TRIG_EXT; 181 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
181 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
182 err++;
183
184 tmp = cmd->convert_src;
185 cmd->convert_src &= TRIG_TIMER | TRIG_EXT;
186 if (!cmd->convert_src || tmp != cmd->convert_src)
187 err++;
188
189 tmp = cmd->scan_end_src;
190 cmd->scan_end_src &= TRIG_COUNT;
191 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
192 err++;
193
194 tmp = cmd->stop_src;
195 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
196 if (!cmd->stop_src || tmp != cmd->stop_src)
197 err++;
198 182
199 if (err) 183 if (err)
200 return 1; 184 return 1;
201 185
202 /* step 2: make sure trigger sources are unique and 186 /* Step 2a : make sure trigger sources are unique */
203 * mutually compatible */
204 187
205 /* note that mutual compatibility is not an issue here */ 188 err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
206 if (cmd->scan_begin_src != TRIG_TIMER && 189 err |= cfc_check_trigger_is_unique(cmd->convert_src);
207 cmd->scan_begin_src != TRIG_EXT) 190 err |= cfc_check_trigger_is_unique(cmd->stop_src);
208 err++; 191
209 if (cmd->convert_src != TRIG_TIMER && cmd->convert_src != TRIG_EXT) 192 /* Step 2b : and mutually compatible */
210 err++;
211 if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE)
212 err++;
213 193
214 if (err) 194 if (err)
215 return 2; 195 return 2;
diff --git a/drivers/staging/comedi/drivers/cb_pcidas.c b/drivers/staging/comedi/drivers/cb_pcidas.c
index 4dd87c28ca20..de21a261ff45 100644
--- a/drivers/staging/comedi/drivers/cb_pcidas.c
+++ b/drivers/staging/comedi/drivers/cb_pcidas.c
@@ -803,58 +803,35 @@ static int cb_pcidas_ai_cmdtest(struct comedi_device *dev,
803 int tmp; 803 int tmp;
804 int i, gain, start_chan; 804 int i, gain, start_chan;
805 805
806 /* step 1: trigger sources are trivially valid */ 806 /* Step 1 : check if triggers are trivially valid */
807 807
808 tmp = cmd->start_src; 808 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_EXT);
809 cmd->start_src &= TRIG_NOW | TRIG_EXT; 809 err |= cfc_check_trigger_src(&cmd->scan_begin_src,
810 if (!cmd->start_src || tmp != cmd->start_src) 810 TRIG_FOLLOW | TRIG_TIMER | TRIG_EXT);
811 err++; 811 err |= cfc_check_trigger_src(&cmd->convert_src,
812 812 TRIG_TIMER | TRIG_NOW | TRIG_EXT);
813 tmp = cmd->scan_begin_src; 813 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
814 cmd->scan_begin_src &= TRIG_FOLLOW | TRIG_TIMER | TRIG_EXT; 814 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
815 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
816 err++;
817
818 tmp = cmd->convert_src;
819 cmd->convert_src &= TRIG_TIMER | TRIG_NOW | TRIG_EXT;
820 if (!cmd->convert_src || tmp != cmd->convert_src)
821 err++;
822
823 tmp = cmd->scan_end_src;
824 cmd->scan_end_src &= TRIG_COUNT;
825 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
826 err++;
827
828 tmp = cmd->stop_src;
829 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
830 if (!cmd->stop_src || tmp != cmd->stop_src)
831 err++;
832 815
833 if (err) 816 if (err)
834 return 1; 817 return 1;
835 818
836 /* step 2: trigger sources are unique and mutually compatible */ 819 /* Step 2a : make sure trigger sources are unique */
837 820
838 if (cmd->start_src != TRIG_NOW && cmd->start_src != TRIG_EXT) 821 err |= cfc_check_trigger_is_unique(cmd->start_src);
839 err++; 822 err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
840 if (cmd->scan_begin_src != TRIG_FOLLOW && 823 err |= cfc_check_trigger_is_unique(cmd->convert_src);
841 cmd->scan_begin_src != TRIG_TIMER && 824 err |= cfc_check_trigger_is_unique(cmd->stop_src);
842 cmd->scan_begin_src != TRIG_EXT) 825
843 err++; 826 /* Step 2b : and mutually compatible */
844 if (cmd->convert_src != TRIG_TIMER &&
845 cmd->convert_src != TRIG_EXT && cmd->convert_src != TRIG_NOW)
846 err++;
847 if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE)
848 err++;
849 827
850 /* make sure trigger sources are compatible with each other */
851 if (cmd->scan_begin_src == TRIG_FOLLOW && cmd->convert_src == TRIG_NOW) 828 if (cmd->scan_begin_src == TRIG_FOLLOW && cmd->convert_src == TRIG_NOW)
852 err++; 829 err |= -EINVAL;
853 if (cmd->scan_begin_src != TRIG_FOLLOW && cmd->convert_src != TRIG_NOW) 830 if (cmd->scan_begin_src != TRIG_FOLLOW && cmd->convert_src != TRIG_NOW)
854 err++; 831 err |= -EINVAL;
855 if (cmd->start_src == TRIG_EXT && 832 if (cmd->start_src == TRIG_EXT &&
856 (cmd->convert_src == TRIG_EXT || cmd->scan_begin_src == TRIG_EXT)) 833 (cmd->convert_src == TRIG_EXT || cmd->scan_begin_src == TRIG_EXT))
857 err++; 834 err |= -EINVAL;
858 835
859 if (err) 836 if (err)
860 return 2; 837 return 2;
@@ -1079,43 +1056,24 @@ static int cb_pcidas_ao_cmdtest(struct comedi_device *dev,
1079 int err = 0; 1056 int err = 0;
1080 int tmp; 1057 int tmp;
1081 1058
1082 /* step 1: trigger sources are trivially valid */ 1059 /* Step 1 : check if triggers are trivially valid */
1083
1084 tmp = cmd->start_src;
1085 cmd->start_src &= TRIG_INT;
1086 if (!cmd->start_src || tmp != cmd->start_src)
1087 err++;
1088
1089 tmp = cmd->scan_begin_src;
1090 cmd->scan_begin_src &= TRIG_TIMER | TRIG_EXT;
1091 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
1092 err++;
1093
1094 tmp = cmd->convert_src;
1095 cmd->convert_src &= TRIG_NOW;
1096 if (!cmd->convert_src || tmp != cmd->convert_src)
1097 err++;
1098
1099 tmp = cmd->scan_end_src;
1100 cmd->scan_end_src &= TRIG_COUNT;
1101 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
1102 err++;
1103 1060
1104 tmp = cmd->stop_src; 1061 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_INT);
1105 cmd->stop_src &= TRIG_COUNT | TRIG_NONE; 1062 err |= cfc_check_trigger_src(&cmd->scan_begin_src,
1106 if (!cmd->stop_src || tmp != cmd->stop_src) 1063 TRIG_TIMER | TRIG_EXT);
1107 err++; 1064 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW);
1065 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
1066 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
1108 1067
1109 if (err) 1068 if (err)
1110 return 1; 1069 return 1;
1111 1070
1112 /* step 2: trigger sources are unique and mutually compatible */ 1071 /* Step 2a : make sure trigger sources are unique */
1113 1072
1114 if (cmd->scan_begin_src != TRIG_TIMER && 1073 err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
1115 cmd->scan_begin_src != TRIG_EXT) 1074 err |= cfc_check_trigger_is_unique(cmd->stop_src);
1116 err++; 1075
1117 if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE) 1076 /* Step 2b : and mutually compatible */
1118 err++;
1119 1077
1120 if (err) 1078 if (err)
1121 return 2; 1079 return 2;
diff --git a/drivers/staging/comedi/drivers/cb_pcidas64.c b/drivers/staging/comedi/drivers/cb_pcidas64.c
index 7168883eed41..0472a9088abe 100644
--- a/drivers/staging/comedi/drivers/cb_pcidas64.c
+++ b/drivers/staging/comedi/drivers/cb_pcidas64.c
@@ -2108,74 +2108,50 @@ static int ai_cmdtest(struct comedi_device *dev, struct comedi_subdevice *s,
2108 struct comedi_cmd *cmd) 2108 struct comedi_cmd *cmd)
2109{ 2109{
2110 int err = 0; 2110 int err = 0;
2111 int tmp;
2112 unsigned int tmp_arg, tmp_arg2; 2111 unsigned int tmp_arg, tmp_arg2;
2113 int i; 2112 int i;
2114 int aref; 2113 int aref;
2115 unsigned int triggers; 2114 unsigned int triggers;
2116 2115
2117 /* step 1: make sure trigger sources are trivially valid */ 2116 /* Step 1 : check if triggers are trivially valid */
2118 2117
2119 tmp = cmd->start_src; 2118 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_EXT);
2120 cmd->start_src &= TRIG_NOW | TRIG_EXT;
2121 if (!cmd->start_src || tmp != cmd->start_src)
2122 err++;
2123 2119
2124 tmp = cmd->scan_begin_src;
2125 triggers = TRIG_TIMER; 2120 triggers = TRIG_TIMER;
2126 if (board(dev)->layout == LAYOUT_4020) 2121 if (board(dev)->layout == LAYOUT_4020)
2127 triggers |= TRIG_OTHER; 2122 triggers |= TRIG_OTHER;
2128 else 2123 else
2129 triggers |= TRIG_FOLLOW; 2124 triggers |= TRIG_FOLLOW;
2130 cmd->scan_begin_src &= triggers; 2125 err |= cfc_check_trigger_src(&cmd->scan_begin_src, triggers);
2131 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
2132 err++;
2133 2126
2134 tmp = cmd->convert_src;
2135 triggers = TRIG_TIMER; 2127 triggers = TRIG_TIMER;
2136 if (board(dev)->layout == LAYOUT_4020) 2128 if (board(dev)->layout == LAYOUT_4020)
2137 triggers |= TRIG_NOW; 2129 triggers |= TRIG_NOW;
2138 else 2130 else
2139 triggers |= TRIG_EXT; 2131 triggers |= TRIG_EXT;
2140 cmd->convert_src &= triggers; 2132 err |= cfc_check_trigger_src(&cmd->convert_src, triggers);
2141 if (!cmd->convert_src || tmp != cmd->convert_src)
2142 err++;
2143
2144 tmp = cmd->scan_end_src;
2145 cmd->scan_end_src &= TRIG_COUNT;
2146 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
2147 err++;
2148 2133
2149 tmp = cmd->stop_src; 2134 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
2150 cmd->stop_src &= TRIG_COUNT | TRIG_EXT | TRIG_NONE; 2135 err |= cfc_check_trigger_src(&cmd->stop_src,
2151 if (!cmd->stop_src || tmp != cmd->stop_src) 2136 TRIG_COUNT | TRIG_EXT | TRIG_NONE);
2152 err++;
2153 2137
2154 if (err) 2138 if (err)
2155 return 1; 2139 return 1;
2156 2140
2157 /* step 2: make sure trigger sources are unique and mutually compatible */ 2141 /* Step 2a : make sure trigger sources are unique */
2158 2142
2159 /* uniqueness check */ 2143 err |= cfc_check_trigger_is_unique(cmd->start_src);
2160 if (cmd->start_src != TRIG_NOW && cmd->start_src != TRIG_EXT) 2144 err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
2161 err++; 2145 err |= cfc_check_trigger_is_unique(cmd->convert_src);
2162 if (cmd->scan_begin_src != TRIG_TIMER && 2146 err |= cfc_check_trigger_is_unique(cmd->stop_src);
2163 cmd->scan_begin_src != TRIG_OTHER && 2147
2164 cmd->scan_begin_src != TRIG_FOLLOW) 2148 /* Step 2b : and mutually compatible */
2165 err++;
2166 if (cmd->convert_src != TRIG_TIMER &&
2167 cmd->convert_src != TRIG_EXT && cmd->convert_src != TRIG_NOW)
2168 err++;
2169 if (cmd->stop_src != TRIG_COUNT &&
2170 cmd->stop_src != TRIG_NONE && cmd->stop_src != TRIG_EXT)
2171 err++;
2172 2149
2173 /* compatibility check */
2174 if (cmd->convert_src == TRIG_EXT && cmd->scan_begin_src == TRIG_TIMER) 2150 if (cmd->convert_src == TRIG_EXT && cmd->scan_begin_src == TRIG_TIMER)
2175 err++; 2151 err |= -EINVAL;
2176 if (cmd->stop_src != TRIG_COUNT && 2152 if (cmd->stop_src != TRIG_COUNT &&
2177 cmd->stop_src != TRIG_NONE && cmd->stop_src != TRIG_EXT) 2153 cmd->stop_src != TRIG_NONE && cmd->stop_src != TRIG_EXT)
2178 err++; 2154 err |= -EINVAL;
2179 2155
2180 if (err) 2156 if (err)
2181 return 2; 2157 return 2;
@@ -3466,55 +3442,33 @@ static int ao_cmdtest(struct comedi_device *dev, struct comedi_subdevice *s,
3466 struct comedi_cmd *cmd) 3442 struct comedi_cmd *cmd)
3467{ 3443{
3468 int err = 0; 3444 int err = 0;
3469 int tmp;
3470 unsigned int tmp_arg; 3445 unsigned int tmp_arg;
3471 int i; 3446 int i;
3472 3447
3473 /* step 1: make sure trigger sources are trivially valid */ 3448 /* Step 1 : check if triggers are trivially valid */
3474 3449
3475 tmp = cmd->start_src; 3450 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_INT | TRIG_EXT);
3476 cmd->start_src &= TRIG_INT | TRIG_EXT; 3451 err |= cfc_check_trigger_src(&cmd->scan_begin_src,
3477 if (!cmd->start_src || tmp != cmd->start_src) 3452 TRIG_TIMER | TRIG_EXT);
3478 err++; 3453 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW);
3479 3454 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
3480 tmp = cmd->scan_begin_src; 3455 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_NONE);
3481 cmd->scan_begin_src &= TRIG_TIMER | TRIG_EXT;
3482 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
3483 err++;
3484
3485 tmp = cmd->convert_src;
3486 cmd->convert_src &= TRIG_NOW;
3487 if (!cmd->convert_src || tmp != cmd->convert_src)
3488 err++;
3489
3490 tmp = cmd->scan_end_src;
3491 cmd->scan_end_src &= TRIG_COUNT;
3492 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
3493 err++;
3494
3495 tmp = cmd->stop_src;
3496 cmd->stop_src &= TRIG_NONE;
3497 if (!cmd->stop_src || tmp != cmd->stop_src)
3498 err++;
3499 3456
3500 if (err) 3457 if (err)
3501 return 1; 3458 return 1;
3502 3459
3503 /* step 2: make sure trigger sources are unique and mutually compatible */ 3460 /* Step 2a : make sure trigger sources are unique */
3504 3461
3505 /* uniqueness check */ 3462 err |= cfc_check_trigger_is_unique(cmd->start_src);
3506 if (cmd->start_src != TRIG_INT && cmd->start_src != TRIG_EXT) 3463 err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
3507 err++; 3464
3508 if (cmd->scan_begin_src != TRIG_TIMER && 3465 /* Step 2b : and mutually compatible */
3509 cmd->scan_begin_src != TRIG_EXT)
3510 err++;
3511 3466
3512 /* compatibility check */
3513 if (cmd->convert_src == TRIG_EXT && cmd->scan_begin_src == TRIG_TIMER) 3467 if (cmd->convert_src == TRIG_EXT && cmd->scan_begin_src == TRIG_TIMER)
3514 err++; 3468 err |= -EINVAL;
3515 if (cmd->stop_src != TRIG_COUNT && 3469 if (cmd->stop_src != TRIG_COUNT &&
3516 cmd->stop_src != TRIG_NONE && cmd->stop_src != TRIG_EXT) 3470 cmd->stop_src != TRIG_NONE && cmd->stop_src != TRIG_EXT)
3517 err++; 3471 err |= -EINVAL;
3518 3472
3519 if (err) 3473 if (err)
3520 return 2; 3474 return 2;
diff --git a/drivers/staging/comedi/drivers/cb_pcidda.c b/drivers/staging/comedi/drivers/cb_pcidda.c
index ad9f3a3075a0..aef946df27e2 100644
--- a/drivers/staging/comedi/drivers/cb_pcidda.c
+++ b/drivers/staging/comedi/drivers/cb_pcidda.c
@@ -48,6 +48,7 @@ Please report success/failure with other different cards to
48 48
49#include "../comedidev.h" 49#include "../comedidev.h"
50 50
51#include "comedi_fc.h"
51#include "8255.h" 52#include "8255.h"
52 53
53/* PCI vendor number of ComputerBoards */ 54/* PCI vendor number of ComputerBoards */
@@ -247,56 +248,26 @@ static int cb_pcidda_ai_cmdtest(struct comedi_device *dev,
247 int err = 0; 248 int err = 0;
248 int tmp; 249 int tmp;
249 250
250 /* cmdtest tests a particular command to see if it is valid. 251 /* Step 1 : check if triggers are trivially valid */
251 * Using the cmdtest ioctl, a user can create a valid cmd
252 * and then have it executes by the cmd ioctl.
253 *
254 * cmdtest returns 1,2,3,4 or 0, depending on which tests
255 * the command passes. */
256 252
257 /* step 1: make sure trigger sources are trivially valid */ 253 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
258 254 err |= cfc_check_trigger_src(&cmd->scan_begin_src,
259 tmp = cmd->start_src; 255 TRIG_TIMER | TRIG_EXT);
260 cmd->start_src &= TRIG_NOW; 256 err |= cfc_check_trigger_src(&cmd->convert_src,
261 if (!cmd->start_src || tmp != cmd->start_src) 257 TRIG_TIMER | TRIG_EXT);
262 err++; 258 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
263 259 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
264 tmp = cmd->scan_begin_src;
265 cmd->scan_begin_src &= TRIG_TIMER | TRIG_EXT;
266 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
267 err++;
268
269 tmp = cmd->convert_src;
270 cmd->convert_src &= TRIG_TIMER | TRIG_EXT;
271 if (!cmd->convert_src || tmp != cmd->convert_src)
272 err++;
273
274 tmp = cmd->scan_end_src;
275 cmd->scan_end_src &= TRIG_COUNT;
276 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
277 err++;
278
279 tmp = cmd->stop_src;
280 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
281 if (!cmd->stop_src || tmp != cmd->stop_src)
282 err++;
283 260
284 if (err) 261 if (err)
285 return 1; 262 return 1;
286 263
287 /* 264 /* Step 2a : make sure trigger sources are unique */
288 * step 2: make sure trigger sources are unique and mutually
289 * compatible
290 */
291 265
292 /* note that mutual compatibility is not an issue here */ 266 err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
293 if (cmd->scan_begin_src != TRIG_TIMER 267 err |= cfc_check_trigger_is_unique(cmd->convert_src);
294 && cmd->scan_begin_src != TRIG_EXT) 268 err |= cfc_check_trigger_is_unique(cmd->stop_src);
295 err++; 269
296 if (cmd->convert_src != TRIG_TIMER && cmd->convert_src != TRIG_EXT) 270 /* Step 2b : and mutually compatible */
297 err++;
298 if (cmd->stop_src != TRIG_TIMER && cmd->stop_src != TRIG_EXT)
299 err++;
300 271
301 if (err) 272 if (err)
302 return 2; 273 return 2;
diff --git a/drivers/staging/comedi/drivers/comedi_parport.c b/drivers/staging/comedi/drivers/comedi_parport.c
index c9e40a9fea05..22ef94242590 100644
--- a/drivers/staging/comedi/drivers/comedi_parport.c
+++ b/drivers/staging/comedi/drivers/comedi_parport.c
@@ -85,6 +85,8 @@ pin, which can be used to wake up tasks.
85#include <linux/interrupt.h> 85#include <linux/interrupt.h>
86#include <linux/ioport.h> 86#include <linux/ioport.h>
87 87
88#include "comedi_fc.h"
89
88#define PARPORT_SIZE 3 90#define PARPORT_SIZE 3
89 91
90#define PARPORT_A 0 92#define PARPORT_A 0
@@ -176,39 +178,20 @@ static int parport_intr_cmdtest(struct comedi_device *dev,
176 struct comedi_cmd *cmd) 178 struct comedi_cmd *cmd)
177{ 179{
178 int err = 0; 180 int err = 0;
179 int tmp;
180
181 /* step 1 */
182
183 tmp = cmd->start_src;
184 cmd->start_src &= TRIG_NOW;
185 if (!cmd->start_src || tmp != cmd->start_src)
186 err++;
187
188 tmp = cmd->scan_begin_src;
189 cmd->scan_begin_src &= TRIG_EXT;
190 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
191 err++;
192 181
193 tmp = cmd->convert_src; 182 /* Step 1 : check if triggers are trivially valid */
194 cmd->convert_src &= TRIG_FOLLOW;
195 if (!cmd->convert_src || tmp != cmd->convert_src)
196 err++;
197 183
198 tmp = cmd->scan_end_src; 184 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
199 cmd->scan_end_src &= TRIG_COUNT; 185 err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_EXT);
200 if (!cmd->scan_end_src || tmp != cmd->scan_end_src) 186 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_FOLLOW);
201 err++; 187 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
202 188 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_NONE);
203 tmp = cmd->stop_src;
204 cmd->stop_src &= TRIG_NONE;
205 if (!cmd->stop_src || tmp != cmd->stop_src)
206 err++;
207 189
208 if (err) 190 if (err)
209 return 1; 191 return 1;
210 192
211 /* step 2: ignored */ 193 /* Step 2a : make sure trigger sources are unique */
194 /* Step 2b : and mutually compatible */
212 195
213 if (err) 196 if (err)
214 return 2; 197 return 2;
diff --git a/drivers/staging/comedi/drivers/comedi_test.c b/drivers/staging/comedi/drivers/comedi_test.c
index b0f0ec58dfed..7817def1556c 100644
--- a/drivers/staging/comedi/drivers/comedi_test.c
+++ b/drivers/staging/comedi/drivers/comedi_test.c
@@ -231,44 +231,23 @@ static int waveform_ai_cmdtest(struct comedi_device *dev,
231 int err = 0; 231 int err = 0;
232 int tmp; 232 int tmp;
233 233
234 /* step 1: make sure trigger sources are trivially valid */ 234 /* Step 1 : check if triggers are trivially valid */
235 235
236 tmp = cmd->start_src; 236 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
237 cmd->start_src &= TRIG_NOW; 237 err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_TIMER);
238 if (!cmd->start_src || tmp != cmd->start_src) 238 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW | TRIG_TIMER);
239 err++; 239 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
240 240 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
241 tmp = cmd->scan_begin_src;
242 cmd->scan_begin_src &= TRIG_TIMER;
243 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
244 err++;
245
246 tmp = cmd->convert_src;
247 cmd->convert_src &= TRIG_NOW | TRIG_TIMER;
248 if (!cmd->convert_src || tmp != cmd->convert_src)
249 err++;
250
251 tmp = cmd->scan_end_src;
252 cmd->scan_end_src &= TRIG_COUNT;
253 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
254 err++;
255
256 tmp = cmd->stop_src;
257 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
258 if (!cmd->stop_src || tmp != cmd->stop_src)
259 err++;
260 241
261 if (err) 242 if (err)
262 return 1; 243 return 1;
263 244
264 /* 245 /* Step 2a : make sure trigger sources are unique */
265 * step 2: make sure trigger sources are unique and mutually compatible
266 */
267 246
268 if (cmd->convert_src != TRIG_NOW && cmd->convert_src != TRIG_TIMER) 247 err |= cfc_check_trigger_is_unique(cmd->convert_src);
269 err++; 248 err |= cfc_check_trigger_is_unique(cmd->stop_src);
270 if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE) 249
271 err++; 250 /* Step 2b : and mutually compatible */
272 251
273 if (err) 252 if (err)
274 return 2; 253 return 2;
diff --git a/drivers/staging/comedi/drivers/das16.c b/drivers/staging/comedi/drivers/das16.c
index 744376a49d08..fcb8a32adb2f 100644
--- a/drivers/staging/comedi/drivers/das16.c
+++ b/drivers/staging/comedi/drivers/das16.c
@@ -402,62 +402,42 @@ static int das16_cmd_test(struct comedi_device *dev, struct comedi_subdevice *s,
402 int gain, start_chan, i; 402 int gain, start_chan, i;
403 int mask; 403 int mask;
404 404
405 /* make sure triggers are valid */ 405 /* Step 1 : check if triggers are trivially valid */
406 tmp = cmd->start_src; 406
407 cmd->start_src &= TRIG_NOW; 407 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
408 if (!cmd->start_src || tmp != cmd->start_src)
409 err++;
410 408
411 tmp = cmd->scan_begin_src;
412 mask = TRIG_FOLLOW; 409 mask = TRIG_FOLLOW;
413 /* if board supports burst mode */ 410 /* if board supports burst mode */
414 if (board->size > 0x400) 411 if (board->size > 0x400)
415 mask |= TRIG_TIMER | TRIG_EXT; 412 mask |= TRIG_TIMER | TRIG_EXT;
416 cmd->scan_begin_src &= mask; 413 err |= cfc_check_trigger_src(&cmd->scan_begin_src, mask);
417 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
418 err++;
419 414
420 tmp = cmd->convert_src; 415 tmp = cmd->convert_src;
421 mask = TRIG_TIMER | TRIG_EXT; 416 mask = TRIG_TIMER | TRIG_EXT;
422 /* if board supports burst mode */ 417 /* if board supports burst mode */
423 if (board->size > 0x400) 418 if (board->size > 0x400)
424 mask |= TRIG_NOW; 419 mask |= TRIG_NOW;
425 cmd->convert_src &= mask; 420 err |= cfc_check_trigger_src(&cmd->convert_src, mask);
426 if (!cmd->convert_src || tmp != cmd->convert_src)
427 err++;
428 421
429 tmp = cmd->scan_end_src; 422 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
430 cmd->scan_end_src &= TRIG_COUNT; 423 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
431 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
432 err++;
433
434 tmp = cmd->stop_src;
435 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
436 if (!cmd->stop_src || tmp != cmd->stop_src)
437 err++;
438 424
439 if (err) 425 if (err)
440 return 1; 426 return 1;
441 427
442 /** 428 /* Step 2a : make sure trigger sources are unique */
443 * step 2: make sure trigger sources are unique and 429
444 * mutually compatible 430 err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
445 */ 431 err |= cfc_check_trigger_is_unique(cmd->convert_src);
446 if (cmd->scan_begin_src != TRIG_TIMER && 432 err |= cfc_check_trigger_is_unique(cmd->stop_src);
447 cmd->scan_begin_src != TRIG_EXT && 433
448 cmd->scan_begin_src != TRIG_FOLLOW) 434 /* Step 2b : and mutually compatible */
449 err++;
450 if (cmd->convert_src != TRIG_TIMER &&
451 cmd->convert_src != TRIG_EXT && cmd->convert_src != TRIG_NOW)
452 err++;
453 if (cmd->stop_src != TRIG_NONE && cmd->stop_src != TRIG_COUNT)
454 err++;
455 435
456 /* make sure scan_begin_src and convert_src dont conflict */ 436 /* make sure scan_begin_src and convert_src dont conflict */
457 if (cmd->scan_begin_src == TRIG_FOLLOW && cmd->convert_src == TRIG_NOW) 437 if (cmd->scan_begin_src == TRIG_FOLLOW && cmd->convert_src == TRIG_NOW)
458 err++; 438 err |= -EINVAL;
459 if (cmd->scan_begin_src != TRIG_FOLLOW && cmd->convert_src != TRIG_NOW) 439 if (cmd->scan_begin_src != TRIG_FOLLOW && cmd->convert_src != TRIG_NOW)
460 err++; 440 err |= -EINVAL;
461 441
462 if (err) 442 if (err)
463 return 2; 443 return 2;
diff --git a/drivers/staging/comedi/drivers/das16m1.c b/drivers/staging/comedi/drivers/das16m1.c
index 7f0668f8ed83..3f87d7598e5b 100644
--- a/drivers/staging/comedi/drivers/das16m1.c
+++ b/drivers/staging/comedi/drivers/das16m1.c
@@ -170,42 +170,24 @@ static int das16m1_cmd_test(struct comedi_device *dev,
170 const struct das16m1_board *board = comedi_board(dev); 170 const struct das16m1_board *board = comedi_board(dev);
171 unsigned int err = 0, tmp, i; 171 unsigned int err = 0, tmp, i;
172 172
173 /* make sure triggers are valid */ 173 /* Step 1 : check if triggers are trivially valid */
174 tmp = cmd->start_src;
175 cmd->start_src &= TRIG_NOW | TRIG_EXT;
176 if (!cmd->start_src || tmp != cmd->start_src)
177 err++;
178
179 tmp = cmd->scan_begin_src;
180 cmd->scan_begin_src &= TRIG_FOLLOW;
181 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
182 err++;
183 174
184 tmp = cmd->convert_src; 175 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_EXT);
185 cmd->convert_src &= TRIG_TIMER | TRIG_EXT; 176 err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_FOLLOW);
186 if (!cmd->convert_src || tmp != cmd->convert_src) 177 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_TIMER | TRIG_EXT);
187 err++; 178 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
188 179 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
189 tmp = cmd->scan_end_src;
190 cmd->scan_end_src &= TRIG_COUNT;
191 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
192 err++;
193
194 tmp = cmd->stop_src;
195 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
196 if (!cmd->stop_src || tmp != cmd->stop_src)
197 err++;
198 180
199 if (err) 181 if (err)
200 return 1; 182 return 1;
201 183
202 /* step 2: make sure trigger sources are unique and mutually compatible */ 184 /* Step 2a : make sure trigger sources are unique */
203 if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE) 185
204 err++; 186 err |= cfc_check_trigger_is_unique(cmd->start_src);
205 if (cmd->start_src != TRIG_NOW && cmd->start_src != TRIG_EXT) 187 err |= cfc_check_trigger_is_unique(cmd->convert_src);
206 err++; 188 err |= cfc_check_trigger_is_unique(cmd->stop_src);
207 if (cmd->convert_src != TRIG_TIMER && cmd->convert_src != TRIG_EXT) 189
208 err++; 190 /* Step 2b : and mutually compatible */
209 191
210 if (err) 192 if (err)
211 return 2; 193 return 2;
diff --git a/drivers/staging/comedi/drivers/das1800.c b/drivers/staging/comedi/drivers/das1800.c
index 711d4e243b88..2555f3297d7b 100644
--- a/drivers/staging/comedi/drivers/das1800.c
+++ b/drivers/staging/comedi/drivers/das1800.c
@@ -784,59 +784,35 @@ static int das1800_ai_do_cmdtest(struct comedi_device *dev,
784 struct comedi_cmd *cmd) 784 struct comedi_cmd *cmd)
785{ 785{
786 int err = 0; 786 int err = 0;
787 int tmp;
788 unsigned int tmp_arg; 787 unsigned int tmp_arg;
789 int i; 788 int i;
790 int unipolar; 789 int unipolar;
791 790
792 /* step 1: make sure trigger sources are trivially valid */ 791 /* Step 1 : check if triggers are trivially valid */
793 792
794 tmp = cmd->start_src; 793 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_EXT);
795 cmd->start_src &= TRIG_NOW | TRIG_EXT; 794 err |= cfc_check_trigger_src(&cmd->scan_begin_src,
796 if (!cmd->start_src || tmp != cmd->start_src) 795 TRIG_FOLLOW | TRIG_TIMER | TRIG_EXT);
797 err++; 796 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_TIMER | TRIG_EXT);
798 797 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
799 tmp = cmd->scan_begin_src; 798 err |= cfc_check_trigger_src(&cmd->stop_src,
800 cmd->scan_begin_src &= TRIG_FOLLOW | TRIG_TIMER | TRIG_EXT; 799 TRIG_COUNT | TRIG_EXT | TRIG_NONE);
801 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
802 err++;
803
804 tmp = cmd->convert_src;
805 cmd->convert_src &= TRIG_TIMER | TRIG_EXT;
806 if (!cmd->convert_src || tmp != cmd->convert_src)
807 err++;
808
809 tmp = cmd->scan_end_src;
810 cmd->scan_end_src &= TRIG_COUNT;
811 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
812 err++;
813
814 tmp = cmd->stop_src;
815 cmd->stop_src &= TRIG_COUNT | TRIG_EXT | TRIG_NONE;
816 if (!cmd->stop_src || tmp != cmd->stop_src)
817 err++;
818 800
819 if (err) 801 if (err)
820 return 1; 802 return 1;
821 803
822 /* step 2: make sure trigger sources are unique and mutually compatible */ 804 /* Step 2a : make sure trigger sources are unique */
805
806 err |= cfc_check_trigger_is_unique(cmd->start_src);
807 err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
808 err |= cfc_check_trigger_is_unique(cmd->convert_src);
809 err |= cfc_check_trigger_is_unique(cmd->stop_src);
810
811 /* Step 2b : and mutually compatible */
823 812
824 /* uniqueness check */
825 if (cmd->start_src != TRIG_NOW && cmd->start_src != TRIG_EXT)
826 err++;
827 if (cmd->scan_begin_src != TRIG_FOLLOW &&
828 cmd->scan_begin_src != TRIG_TIMER &&
829 cmd->scan_begin_src != TRIG_EXT)
830 err++;
831 if (cmd->convert_src != TRIG_TIMER && cmd->convert_src != TRIG_EXT)
832 err++;
833 if (cmd->stop_src != TRIG_COUNT &&
834 cmd->stop_src != TRIG_NONE && cmd->stop_src != TRIG_EXT)
835 err++;
836 /* compatibility check */
837 if (cmd->scan_begin_src != TRIG_FOLLOW && 813 if (cmd->scan_begin_src != TRIG_FOLLOW &&
838 cmd->convert_src != TRIG_TIMER) 814 cmd->convert_src != TRIG_TIMER)
839 err++; 815 err |= -EINVAL;
840 816
841 if (err) 817 if (err)
842 return 2; 818 return 2;
diff --git a/drivers/staging/comedi/drivers/das800.c b/drivers/staging/comedi/drivers/das800.c
index 8e89101ad3a2..215deac0a396 100644
--- a/drivers/staging/comedi/drivers/das800.c
+++ b/drivers/staging/comedi/drivers/das800.c
@@ -609,44 +609,24 @@ static int das800_ai_do_cmdtest(struct comedi_device *dev,
609 int gain, startChan; 609 int gain, startChan;
610 int i; 610 int i;
611 611
612 /* step 1: make sure trigger sources are trivially valid */ 612 /* Step 1 : check if triggers are trivially valid */
613 613
614 tmp = cmd->start_src; 614 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_EXT);
615 cmd->start_src &= TRIG_NOW | TRIG_EXT; 615 err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_FOLLOW);
616 if (!cmd->start_src || tmp != cmd->start_src) 616 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_TIMER | TRIG_EXT);
617 err++; 617 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
618 618 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
619 tmp = cmd->scan_begin_src;
620 cmd->scan_begin_src &= TRIG_FOLLOW;
621 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
622 err++;
623
624 tmp = cmd->convert_src;
625 cmd->convert_src &= TRIG_TIMER | TRIG_EXT;
626 if (!cmd->convert_src || tmp != cmd->convert_src)
627 err++;
628
629 tmp = cmd->scan_end_src;
630 cmd->scan_end_src &= TRIG_COUNT;
631 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
632 err++;
633
634 tmp = cmd->stop_src;
635 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
636 if (!cmd->stop_src || tmp != cmd->stop_src)
637 err++;
638 619
639 if (err) 620 if (err)
640 return 1; 621 return 1;
641 622
642 /* step 2: make sure trigger sources are unique and mutually compatible */ 623 /* Step 2a : make sure trigger sources are unique */
643 624
644 if (cmd->start_src != TRIG_NOW && cmd->start_src != TRIG_EXT) 625 err |= cfc_check_trigger_is_unique(cmd->start_src);
645 err++; 626 err |= cfc_check_trigger_is_unique(cmd->convert_src);
646 if (cmd->convert_src != TRIG_TIMER && cmd->convert_src != TRIG_EXT) 627 err |= cfc_check_trigger_is_unique(cmd->stop_src);
647 err++; 628
648 if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE) 629 /* Step 2b : and mutually compatible */
649 err++;
650 630
651 if (err) 631 if (err)
652 return 2; 632 return 2;
diff --git a/drivers/staging/comedi/drivers/dmm32at.c b/drivers/staging/comedi/drivers/dmm32at.c
index 0703ca5d8cb7..4d5c33c4750f 100644
--- a/drivers/staging/comedi/drivers/dmm32at.c
+++ b/drivers/staging/comedi/drivers/dmm32at.c
@@ -41,6 +41,8 @@ Configuration Options:
41#include "../comedidev.h" 41#include "../comedidev.h"
42#include <linux/ioport.h> 42#include <linux/ioport.h>
43 43
44#include "comedi_fc.h"
45
44/* Board register addresses */ 46/* Board register addresses */
45 47
46#define DMM32AT_MEMSIZE 0x10 48#define DMM32AT_MEMSIZE 0x10
@@ -258,47 +260,26 @@ static int dmm32at_ai_cmdtest(struct comedi_device *dev,
258 int tmp; 260 int tmp;
259 int start_chan, gain, i; 261 int start_chan, gain, i;
260 262
261 /* step 1: make sure trigger sources are trivially valid */ 263 /* Step 1 : check if triggers are trivially valid */
262
263 tmp = cmd->start_src;
264 cmd->start_src &= TRIG_NOW;
265 if (!cmd->start_src || tmp != cmd->start_src)
266 err++;
267
268 tmp = cmd->scan_begin_src;
269 cmd->scan_begin_src &= TRIG_TIMER /*| TRIG_EXT */ ;
270 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
271 err++;
272
273 tmp = cmd->convert_src;
274 cmd->convert_src &= TRIG_TIMER /*| TRIG_EXT */ ;
275 if (!cmd->convert_src || tmp != cmd->convert_src)
276 err++;
277
278 tmp = cmd->scan_end_src;
279 cmd->scan_end_src &= TRIG_COUNT;
280 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
281 err++;
282 264
283 tmp = cmd->stop_src; 265 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
284 cmd->stop_src &= TRIG_COUNT | TRIG_NONE; 266 err |= cfc_check_trigger_src(&cmd->scan_begin_src,
285 if (!cmd->stop_src || tmp != cmd->stop_src) 267 TRIG_TIMER /*| TRIG_EXT */);
286 err++; 268 err |= cfc_check_trigger_src(&cmd->convert_src,
269 TRIG_TIMER /*| TRIG_EXT */);
270 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
271 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
287 272
288 if (err) 273 if (err)
289 return 1; 274 return 1;
290 275
291 /* step 2: make sure trigger sources are unique and mutually 276 /* Step 2a : make sure trigger sources are unique */
292 * compatible */
293 277
294 /* note that mutual compatibility is not an issue here */ 278 err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
295 if (cmd->scan_begin_src != TRIG_TIMER && 279 err |= cfc_check_trigger_is_unique(cmd->convert_src);
296 cmd->scan_begin_src != TRIG_EXT) 280 err |= cfc_check_trigger_is_unique(cmd->stop_src);
297 err++; 281
298 if (cmd->convert_src != TRIG_TIMER && cmd->convert_src != TRIG_EXT) 282 /* Step 2b : and mutually compatible */
299 err++;
300 if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE)
301 err++;
302 283
303 if (err) 284 if (err)
304 return 2; 285 return 2;
diff --git a/drivers/staging/comedi/drivers/dt2814.c b/drivers/staging/comedi/drivers/dt2814.c
index ce5d83768d4e..064a8f215e4d 100644
--- a/drivers/staging/comedi/drivers/dt2814.c
+++ b/drivers/staging/comedi/drivers/dt2814.c
@@ -45,6 +45,8 @@ addition, the clock does not seem to be very accurate.
45#include <linux/ioport.h> 45#include <linux/ioport.h>
46#include <linux/delay.h> 46#include <linux/delay.h>
47 47
48#include "comedi_fc.h"
49
48#define DT2814_SIZE 2 50#define DT2814_SIZE 2
49 51
50#define DT2814_CSR 0 52#define DT2814_CSR 0
@@ -129,42 +131,22 @@ static int dt2814_ai_cmdtest(struct comedi_device *dev,
129 int err = 0; 131 int err = 0;
130 int tmp; 132 int tmp;
131 133
132 /* step 1: make sure trigger sources are trivially valid */ 134 /* Step 1 : check if triggers are trivially valid */
133
134 tmp = cmd->start_src;
135 cmd->start_src &= TRIG_NOW;
136 if (!cmd->start_src || tmp != cmd->start_src)
137 err++;
138
139 tmp = cmd->scan_begin_src;
140 cmd->scan_begin_src &= TRIG_TIMER;
141 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
142 err++;
143
144 tmp = cmd->convert_src;
145 cmd->convert_src &= TRIG_NOW;
146 if (!cmd->convert_src || tmp != cmd->convert_src)
147 err++;
148
149 tmp = cmd->scan_end_src;
150 cmd->scan_end_src &= TRIG_COUNT;
151 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
152 err++;
153 135
154 tmp = cmd->stop_src; 136 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
155 cmd->stop_src &= TRIG_COUNT | TRIG_NONE; 137 err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_TIMER);
156 if (!cmd->stop_src || tmp != cmd->stop_src) 138 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW);
157 err++; 139 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
140 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
158 141
159 if (err) 142 if (err)
160 return 1; 143 return 1;
161 144
162 /* step 2: make sure trigger sources are 145 /* Step 2a : make sure trigger sources are unique */
163 * unique and mutually compatible */
164 146
165 /* note that mutual compatibility is not an issue here */ 147 err |= cfc_check_trigger_is_unique(cmd->stop_src);
166 if (cmd->stop_src != TRIG_TIMER && cmd->stop_src != TRIG_EXT) 148
167 err++; 149 /* Step 2b : and mutually compatible */
168 150
169 if (err) 151 if (err)
170 return 2; 152 return 2;
diff --git a/drivers/staging/comedi/drivers/dt282x.c b/drivers/staging/comedi/drivers/dt282x.c
index b7c43c84d949..78d340716d1e 100644
--- a/drivers/staging/comedi/drivers/dt282x.c
+++ b/drivers/staging/comedi/drivers/dt282x.c
@@ -582,47 +582,24 @@ static int dt282x_ai_cmdtest(struct comedi_device *dev,
582 int err = 0; 582 int err = 0;
583 int tmp; 583 int tmp;
584 584
585 /* step 1: make sure trigger sources are trivially valid */ 585 /* Step 1 : check if triggers are trivially valid */
586 586
587 tmp = cmd->start_src; 587 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
588 cmd->start_src &= TRIG_NOW; 588 err |= cfc_check_trigger_src(&cmd->scan_begin_src,
589 if (!cmd->start_src || tmp != cmd->start_src) 589 TRIG_FOLLOW | TRIG_EXT);
590 err++; 590 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_TIMER);
591 591 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
592 tmp = cmd->scan_begin_src; 592 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
593 cmd->scan_begin_src &= TRIG_FOLLOW | TRIG_EXT;
594 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
595 err++;
596
597 tmp = cmd->convert_src;
598 cmd->convert_src &= TRIG_TIMER;
599 if (!cmd->convert_src || tmp != cmd->convert_src)
600 err++;
601
602 tmp = cmd->scan_end_src;
603 cmd->scan_end_src &= TRIG_COUNT;
604 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
605 err++;
606
607 tmp = cmd->stop_src;
608 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
609 if (!cmd->stop_src || tmp != cmd->stop_src)
610 err++;
611 593
612 if (err) 594 if (err)
613 return 1; 595 return 1;
614 596
615 /* 597 /* Step 2a : make sure trigger sources are unique */
616 * step 2: make sure trigger sources are unique
617 * and mutually compatible
618 */
619 598
620 /* note that mutual compatibility is not an issue here */ 599 err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
621 if (cmd->scan_begin_src != TRIG_FOLLOW && 600 err |= cfc_check_trigger_is_unique(cmd->stop_src);
622 cmd->scan_begin_src != TRIG_EXT) 601
623 err++; 602 /* Step 2b : and mutually compatible */
624 if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE)
625 err++;
626 603
627 if (err) 604 if (err)
628 return 2; 605 return 2;
@@ -862,44 +839,22 @@ static int dt282x_ao_cmdtest(struct comedi_device *dev,
862 int err = 0; 839 int err = 0;
863 int tmp; 840 int tmp;
864 841
865 /* step 1: make sure trigger sources are trivially valid */ 842 /* Step 1 : check if triggers are trivially valid */
866 843
867 tmp = cmd->start_src; 844 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_INT);
868 cmd->start_src &= TRIG_INT; 845 err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_TIMER);
869 if (!cmd->start_src || tmp != cmd->start_src) 846 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW);
870 err++; 847 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
871 848 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
872 tmp = cmd->scan_begin_src;
873 cmd->scan_begin_src &= TRIG_TIMER;
874 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
875 err++;
876
877 tmp = cmd->convert_src;
878 cmd->convert_src &= TRIG_NOW;
879 if (!cmd->convert_src || tmp != cmd->convert_src)
880 err++;
881
882 tmp = cmd->scan_end_src;
883 cmd->scan_end_src &= TRIG_COUNT;
884 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
885 err++;
886
887 tmp = cmd->stop_src;
888 cmd->stop_src &= TRIG_NONE;
889 if (!cmd->stop_src || tmp != cmd->stop_src)
890 err++;
891 849
892 if (err) 850 if (err)
893 return 1; 851 return 1;
894 852
895 /* 853 /* Step 2a : make sure trigger sources are unique */
896 * step 2: make sure trigger sources are unique
897 * and mutually compatible
898 */
899 854
900 /* note that mutual compatibility is not an issue here */ 855 err |= cfc_check_trigger_is_unique(cmd->stop_src);
901 if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE) 856
902 err++; 857 /* Step 2b : and mutually compatible */
903 858
904 if (err) 859 if (err)
905 return 2; 860 return 2;
diff --git a/drivers/staging/comedi/drivers/dt3000.c b/drivers/staging/comedi/drivers/dt3000.c
index 3a940a2f000e..43d05ef97157 100644
--- a/drivers/staging/comedi/drivers/dt3000.c
+++ b/drivers/staging/comedi/drivers/dt3000.c
@@ -63,6 +63,8 @@ AO commands are not supported.
63#include "../comedidev.h" 63#include "../comedidev.h"
64#include <linux/delay.h> 64#include <linux/delay.h>
65 65
66#include "comedi_fc.h"
67
66#define PCI_VENDOR_ID_DT 0x1116 68#define PCI_VENDOR_ID_DT 0x1116
67 69
68static const struct comedi_lrange range_dt3000_ai = { 4, { 70static const struct comedi_lrange range_dt3000_ai = { 4, {
@@ -408,37 +410,19 @@ static int dt3k_ai_cmdtest(struct comedi_device *dev,
408 int err = 0; 410 int err = 0;
409 int tmp; 411 int tmp;
410 412
411 /* step 1: make sure trigger sources are trivially valid */ 413 /* Step 1 : check if triggers are trivially valid */
412
413 tmp = cmd->start_src;
414 cmd->start_src &= TRIG_NOW;
415 if (!cmd->start_src || tmp != cmd->start_src)
416 err++;
417
418 tmp = cmd->scan_begin_src;
419 cmd->scan_begin_src &= TRIG_TIMER;
420 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
421 err++;
422
423 tmp = cmd->convert_src;
424 cmd->convert_src &= TRIG_TIMER;
425 if (!cmd->convert_src || tmp != cmd->convert_src)
426 err++;
427 414
428 tmp = cmd->scan_end_src; 415 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
429 cmd->scan_end_src &= TRIG_COUNT; 416 err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_TIMER);
430 if (!cmd->scan_end_src || tmp != cmd->scan_end_src) 417 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_TIMER);
431 err++; 418 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
432 419 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT);
433 tmp = cmd->stop_src;
434 cmd->stop_src &= TRIG_COUNT;
435 if (!cmd->stop_src || tmp != cmd->stop_src)
436 err++;
437 420
438 if (err) 421 if (err)
439 return 1; 422 return 1;
440 423
441 /* step 2: make sure trigger sources are unique and mutually compatible */ 424 /* Step 2a : make sure trigger sources are unique */
425 /* Step 2b : and mutually compatible */
442 426
443 if (err) 427 if (err)
444 return 2; 428 return 2;
diff --git a/drivers/staging/comedi/drivers/gsc_hpdi.c b/drivers/staging/comedi/drivers/gsc_hpdi.c
index 5d3fa711a515..abff6603952a 100644
--- a/drivers/staging/comedi/drivers/gsc_hpdi.c
+++ b/drivers/staging/comedi/drivers/gsc_hpdi.c
@@ -723,45 +723,24 @@ static int di_cmd_test(struct comedi_device *dev, struct comedi_subdevice *s,
723 struct comedi_cmd *cmd) 723 struct comedi_cmd *cmd)
724{ 724{
725 int err = 0; 725 int err = 0;
726 int tmp;
727 int i; 726 int i;
728 727
729 /* step 1: make sure trigger sources are trivially valid */ 728 /* Step 1 : check if triggers are trivially valid */
730 729
731 tmp = cmd->start_src; 730 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
732 cmd->start_src &= TRIG_NOW; 731 err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_EXT);
733 if (!cmd->start_src || tmp != cmd->start_src) 732 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW);
734 err++; 733 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
735 734 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
736 tmp = cmd->scan_begin_src;
737 cmd->scan_begin_src &= TRIG_EXT;
738 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
739 err++;
740
741 tmp = cmd->convert_src;
742 cmd->convert_src &= TRIG_NOW;
743 if (!cmd->convert_src || tmp != cmd->convert_src)
744 err++;
745
746 tmp = cmd->scan_end_src;
747 cmd->scan_end_src &= TRIG_COUNT;
748 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
749 err++;
750
751 tmp = cmd->stop_src;
752 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
753 if (!cmd->stop_src || tmp != cmd->stop_src)
754 err++;
755 735
756 if (err) 736 if (err)
757 return 1; 737 return 1;
758 738
759 /* step 2: make sure trigger sources are unique and mutually 739 /* Step 2a : make sure trigger sources are unique */
760 * compatible */
761 740
762 /* uniqueness check */ 741 err |= cfc_check_trigger_is_unique(cmd->stop_src);
763 if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE) 742
764 err++; 743 /* Step 2b : and mutually compatible */
765 744
766 if (err) 745 if (err)
767 return 2; 746 return 2;
diff --git a/drivers/staging/comedi/drivers/me4000.c b/drivers/staging/comedi/drivers/me4000.c
index d7c5146b41e3..22db35d091f8 100644
--- a/drivers/staging/comedi/drivers/me4000.c
+++ b/drivers/staging/comedi/drivers/me4000.c
@@ -52,6 +52,7 @@ broken.
52#include <linux/list.h> 52#include <linux/list.h>
53#include <linux/spinlock.h> 53#include <linux/spinlock.h>
54 54
55#include "comedi_fc.h"
55#include "8253.h" 56#include "8253.h"
56 57
57#if 0 58#if 0
@@ -895,18 +896,6 @@ static int me4000_ai_do_cmd(struct comedi_device *dev,
895 return 0; 896 return 0;
896} 897}
897 898
898/*
899 * me4000_ai_do_cmd_test():
900 *
901 * The demo cmd.c in ./comedilib/demo specifies 6 return values:
902 * - success
903 * - invalid source
904 * - source conflict
905 * - invalid argument
906 * - argument conflict
907 * - invalid chanlist
908 * So I tried to adopt this scheme.
909 */
910static int me4000_ai_do_cmd_test(struct comedi_device *dev, 899static int me4000_ai_do_cmd_test(struct comedi_device *dev,
911 struct comedi_subdevice *s, 900 struct comedi_subdevice *s,
912 struct comedi_cmd *cmd) 901 struct comedi_cmd *cmd)
@@ -923,81 +912,29 @@ static int me4000_ai_do_cmd_test(struct comedi_device *dev,
923 /* Round the timer arguments */ 912 /* Round the timer arguments */
924 ai_round_cmd_args(dev, s, cmd, &init_ticks, &scan_ticks, &chan_ticks); 913 ai_round_cmd_args(dev, s, cmd, &init_ticks, &scan_ticks, &chan_ticks);
925 914
926 /* 915 /* Step 1 : check if triggers are trivially valid */
927 * Stage 1. Check if the trigger sources are generally valid. 916
928 */ 917 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_EXT);
929 switch (cmd->start_src) { 918 err |= cfc_check_trigger_src(&cmd->scan_begin_src,
930 case TRIG_NOW: 919 TRIG_FOLLOW | TRIG_TIMER | TRIG_EXT);
931 case TRIG_EXT: 920 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_TIMER | TRIG_EXT);
932 break; 921 err |= cfc_check_trigger_src(&cmd->scan_end_src,
933 case TRIG_ANY: 922 TRIG_NONE | TRIG_COUNT);
934 cmd->start_src &= TRIG_NOW | TRIG_EXT; 923 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_NONE | TRIG_COUNT);
935 err++; 924
936 break;
937 default:
938 dev_err(dev->class_dev, "Invalid start source\n");
939 cmd->start_src = TRIG_NOW;
940 err++;
941 }
942 switch (cmd->scan_begin_src) {
943 case TRIG_FOLLOW:
944 case TRIG_TIMER:
945 case TRIG_EXT:
946 break;
947 case TRIG_ANY:
948 cmd->scan_begin_src &= TRIG_FOLLOW | TRIG_TIMER | TRIG_EXT;
949 err++;
950 break;
951 default:
952 dev_err(dev->class_dev, "Invalid scan begin source\n");
953 cmd->scan_begin_src = TRIG_FOLLOW;
954 err++;
955 }
956 switch (cmd->convert_src) {
957 case TRIG_TIMER:
958 case TRIG_EXT:
959 break;
960 case TRIG_ANY:
961 cmd->convert_src &= TRIG_TIMER | TRIG_EXT;
962 err++;
963 break;
964 default:
965 dev_err(dev->class_dev, "Invalid convert source\n");
966 cmd->convert_src = TRIG_TIMER;
967 err++;
968 }
969 switch (cmd->scan_end_src) {
970 case TRIG_NONE:
971 case TRIG_COUNT:
972 break;
973 case TRIG_ANY:
974 cmd->scan_end_src &= TRIG_NONE | TRIG_COUNT;
975 err++;
976 break;
977 default:
978 dev_err(dev->class_dev, "Invalid scan end source\n");
979 cmd->scan_end_src = TRIG_NONE;
980 err++;
981 }
982 switch (cmd->stop_src) {
983 case TRIG_NONE:
984 case TRIG_COUNT:
985 break;
986 case TRIG_ANY:
987 cmd->stop_src &= TRIG_NONE | TRIG_COUNT;
988 err++;
989 break;
990 default:
991 dev_err(dev->class_dev, "Invalid stop source\n");
992 cmd->stop_src = TRIG_NONE;
993 err++;
994 }
995 if (err) 925 if (err)
996 return 1; 926 return 1;
997 927
998 /* 928 /* Step 2a : make sure trigger sources are unique */
999 * Stage 2. Check for trigger source conflicts. 929
1000 */ 930 err |= cfc_check_trigger_is_unique(cmd->start_src);
931 err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
932 err |= cfc_check_trigger_is_unique(cmd->convert_src);
933 err |= cfc_check_trigger_is_unique(cmd->scan_end_src);
934 err |= cfc_check_trigger_is_unique(cmd->stop_src);
935
936 /* Step 2b : and mutually compatible */
937
1001 if (cmd->start_src == TRIG_NOW && 938 if (cmd->start_src == TRIG_NOW &&
1002 cmd->scan_begin_src == TRIG_TIMER && 939 cmd->scan_begin_src == TRIG_TIMER &&
1003 cmd->convert_src == TRIG_TIMER) { 940 cmd->convert_src == TRIG_TIMER) {
@@ -1017,11 +954,7 @@ static int me4000_ai_do_cmd_test(struct comedi_device *dev,
1017 cmd->scan_begin_src == TRIG_EXT && 954 cmd->scan_begin_src == TRIG_EXT &&
1018 cmd->convert_src == TRIG_EXT) { 955 cmd->convert_src == TRIG_EXT) {
1019 } else { 956 } else {
1020 dev_err(dev->class_dev, "Invalid start trigger combination\n"); 957 err |= -EINVAL;
1021 cmd->start_src = TRIG_NOW;
1022 cmd->scan_begin_src = TRIG_FOLLOW;
1023 cmd->convert_src = TRIG_TIMER;
1024 err++;
1025 } 958 }
1026 959
1027 if (cmd->stop_src == TRIG_NONE && cmd->scan_end_src == TRIG_NONE) { 960 if (cmd->stop_src == TRIG_NONE && cmd->scan_end_src == TRIG_NONE) {
@@ -1032,11 +965,9 @@ static int me4000_ai_do_cmd_test(struct comedi_device *dev,
1032 } else if (cmd->stop_src == TRIG_COUNT && 965 } else if (cmd->stop_src == TRIG_COUNT &&
1033 cmd->scan_end_src == TRIG_COUNT) { 966 cmd->scan_end_src == TRIG_COUNT) {
1034 } else { 967 } else {
1035 dev_err(dev->class_dev, "Invalid stop trigger combination\n"); 968 err |= -EINVAL;
1036 cmd->stop_src = TRIG_NONE;
1037 cmd->scan_end_src = TRIG_NONE;
1038 err++;
1039 } 969 }
970
1040 if (err) 971 if (err)
1041 return 2; 972 return 2;
1042 973
diff --git a/drivers/staging/comedi/drivers/ni_6527.c b/drivers/staging/comedi/drivers/ni_6527.c
index 8125d5069899..51295f32ee89 100644
--- a/drivers/staging/comedi/drivers/ni_6527.c
+++ b/drivers/staging/comedi/drivers/ni_6527.c
@@ -44,6 +44,7 @@ Updated: Sat, 25 Jan 2003 13:24:40 -0800
44#include <linux/interrupt.h> 44#include <linux/interrupt.h>
45#include "../comedidev.h" 45#include "../comedidev.h"
46 46
47#include "comedi_fc.h"
47#include "mite.h" 48#include "mite.h"
48 49
49#define DRIVER_NAME "ni_6527" 50#define DRIVER_NAME "ni_6527"
@@ -224,40 +225,20 @@ static int ni6527_intr_cmdtest(struct comedi_device *dev,
224 struct comedi_cmd *cmd) 225 struct comedi_cmd *cmd)
225{ 226{
226 int err = 0; 227 int err = 0;
227 int tmp;
228 228
229 /* step 1: make sure trigger sources are trivially valid */ 229 /* Step 1 : check if triggers are trivially valid */
230 230
231 tmp = cmd->start_src; 231 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
232 cmd->start_src &= TRIG_NOW; 232 err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_OTHER);
233 if (!cmd->start_src || tmp != cmd->start_src) 233 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_FOLLOW);
234 err++; 234 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
235 235 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT);
236 tmp = cmd->scan_begin_src;
237 cmd->scan_begin_src &= TRIG_OTHER;
238 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
239 err++;
240
241 tmp = cmd->convert_src;
242 cmd->convert_src &= TRIG_FOLLOW;
243 if (!cmd->convert_src || tmp != cmd->convert_src)
244 err++;
245
246 tmp = cmd->scan_end_src;
247 cmd->scan_end_src &= TRIG_COUNT;
248 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
249 err++;
250
251 tmp = cmd->stop_src;
252 cmd->stop_src &= TRIG_COUNT;
253 if (!cmd->stop_src || tmp != cmd->stop_src)
254 err++;
255 236
256 if (err) 237 if (err)
257 return 1; 238 return 1;
258 239
259 /* step 2: make sure trigger sources are unique and */ 240 /* Step 2a : make sure trigger sources are unique */
260 /* are mutually compatible */ 241 /* Step 2b : and mutually compatible */
261 242
262 if (err) 243 if (err)
263 return 2; 244 return 2;
diff --git a/drivers/staging/comedi/drivers/ni_65xx.c b/drivers/staging/comedi/drivers/ni_65xx.c
index aab2b065cd54..2a73ff57a2fb 100644
--- a/drivers/staging/comedi/drivers/ni_65xx.c
+++ b/drivers/staging/comedi/drivers/ni_65xx.c
@@ -55,6 +55,7 @@ except maybe the 6514.
55#include <linux/slab.h> 55#include <linux/slab.h>
56#include "../comedidev.h" 56#include "../comedidev.h"
57 57
58#include "comedi_fc.h"
58#include "mite.h" 59#include "mite.h"
59 60
60#define NI6514_DIO_SIZE 4096 61#define NI6514_DIO_SIZE 4096
@@ -486,40 +487,20 @@ static int ni_65xx_intr_cmdtest(struct comedi_device *dev,
486 struct comedi_cmd *cmd) 487 struct comedi_cmd *cmd)
487{ 488{
488 int err = 0; 489 int err = 0;
489 int tmp;
490 490
491 /* step 1: make sure trigger sources are trivially valid */ 491 /* Step 1 : check if triggers are trivially valid */
492 492
493 tmp = cmd->start_src; 493 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
494 cmd->start_src &= TRIG_NOW; 494 err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_OTHER);
495 if (!cmd->start_src || tmp != cmd->start_src) 495 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_FOLLOW);
496 err++; 496 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
497 497 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT);
498 tmp = cmd->scan_begin_src;
499 cmd->scan_begin_src &= TRIG_OTHER;
500 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
501 err++;
502
503 tmp = cmd->convert_src;
504 cmd->convert_src &= TRIG_FOLLOW;
505 if (!cmd->convert_src || tmp != cmd->convert_src)
506 err++;
507
508 tmp = cmd->scan_end_src;
509 cmd->scan_end_src &= TRIG_COUNT;
510 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
511 err++;
512
513 tmp = cmd->stop_src;
514 cmd->stop_src &= TRIG_COUNT;
515 if (!cmd->stop_src || tmp != cmd->stop_src)
516 err++;
517 498
518 if (err) 499 if (err)
519 return 1; 500 return 1;
520 501
521 /* step 2: make sure trigger sources are unique and mutually 502 /* Step 2a : make sure trigger sources are unique */
522 compatible */ 503 /* Step 2b : and mutually compatible */
523 504
524 if (err) 505 if (err)
525 return 2; 506 return 2;
diff --git a/drivers/staging/comedi/drivers/ni_at_a2150.c b/drivers/staging/comedi/drivers/ni_at_a2150.c
index 5895d4dce30f..83950807b672 100644
--- a/drivers/staging/comedi/drivers/ni_at_a2150.c
+++ b/drivers/staging/comedi/drivers/ni_at_a2150.c
@@ -321,45 +321,23 @@ static int a2150_ai_cmdtest(struct comedi_device *dev,
321 int startChan; 321 int startChan;
322 int i; 322 int i;
323 323
324 /* step 1: make sure trigger sources are trivially valid */ 324 /* Step 1 : check if triggers are trivially valid */
325 325
326 tmp = cmd->start_src; 326 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_EXT);
327 cmd->start_src &= TRIG_NOW | TRIG_EXT; 327 err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_TIMER);
328 if (!cmd->start_src || tmp != cmd->start_src) 328 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW);
329 err++; 329 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
330 330 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
331 tmp = cmd->scan_begin_src;
332 cmd->scan_begin_src &= TRIG_TIMER;
333 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
334 err++;
335
336 tmp = cmd->convert_src;
337 cmd->convert_src &= TRIG_NOW;
338 if (!cmd->convert_src || tmp != cmd->convert_src)
339 err++;
340
341 tmp = cmd->scan_end_src;
342 cmd->scan_end_src &= TRIG_COUNT;
343 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
344 err++;
345
346 tmp = cmd->stop_src;
347 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
348 if (!cmd->stop_src || tmp != cmd->stop_src)
349 err++;
350 331
351 if (err) 332 if (err)
352 return 1; 333 return 1;
353 334
354 /* 335 /* Step 2a : make sure trigger sources are unique */
355 * step 2: make sure trigger sources are unique and mutually
356 * compatible
357 */
358 336
359 if (cmd->start_src != TRIG_NOW && cmd->start_src != TRIG_EXT) 337 err |= cfc_check_trigger_is_unique(cmd->start_src);
360 err++; 338 err |= cfc_check_trigger_is_unique(cmd->stop_src);
361 if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE) 339
362 err++; 340 /* Step 2b : and mutually compatible */
363 341
364 if (err) 342 if (err)
365 return 2; 343 return 2;
diff --git a/drivers/staging/comedi/drivers/ni_atmio16d.c b/drivers/staging/comedi/drivers/ni_atmio16d.c
index 4108cbfaf29b..e91a620f9db3 100644
--- a/drivers/staging/comedi/drivers/ni_atmio16d.c
+++ b/drivers/staging/comedi/drivers/ni_atmio16d.c
@@ -40,6 +40,7 @@ Devices: [National Instruments] AT-MIO-16 (atmio16), AT-MIO-16D (atmio16d)
40 40
41#include <linux/ioport.h> 41#include <linux/ioport.h>
42 42
43#include "comedi_fc.h"
43#include "8255.h" 44#include "8255.h"
44 45
45/* Configuration and Status Registers */ 46/* Configuration and Status Registers */
@@ -246,45 +247,26 @@ static int atmio16d_ai_cmdtest(struct comedi_device *dev,
246 struct comedi_subdevice *s, 247 struct comedi_subdevice *s,
247 struct comedi_cmd *cmd) 248 struct comedi_cmd *cmd)
248{ 249{
249 int err = 0, tmp; 250 int err = 0;
250 251
251 /* make sure triggers are valid */ 252 /* Step 1 : check if triggers are trivially valid */
252 tmp = cmd->start_src;
253 cmd->start_src &= TRIG_NOW;
254 if (!cmd->start_src || tmp != cmd->start_src)
255 err++;
256
257 tmp = cmd->scan_begin_src;
258 cmd->scan_begin_src &= TRIG_FOLLOW | TRIG_TIMER;
259 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
260 err++;
261
262 tmp = cmd->convert_src;
263 cmd->convert_src &= TRIG_TIMER;
264 if (!cmd->convert_src || tmp != cmd->convert_src)
265 err++;
266
267 tmp = cmd->scan_end_src;
268 cmd->scan_end_src &= TRIG_COUNT;
269 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
270 err++;
271 253
272 tmp = cmd->stop_src; 254 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
273 cmd->stop_src &= TRIG_COUNT | TRIG_NONE; 255 err |= cfc_check_trigger_src(&cmd->scan_begin_src,
274 if (!cmd->stop_src || tmp != cmd->stop_src) 256 TRIG_FOLLOW | TRIG_TIMER);
275 err++; 257 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_TIMER);
258 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
259 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
276 260
277 if (err) 261 if (err)
278 return 1; 262 return 1;
279 263
280 /* step 2: make sure trigger sources are unique & mutually compatible */ 264 /* Step 2a : make sure trigger sources are unique */
281 /* note that mutual compatibility is not an issue here */ 265
282 if (cmd->scan_begin_src != TRIG_FOLLOW && 266 err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
283 cmd->scan_begin_src != TRIG_EXT && 267 err |= cfc_check_trigger_is_unique(cmd->stop_src);
284 cmd->scan_begin_src != TRIG_TIMER) 268
285 err++; 269 /* Step 2b : and mutually compatible */
286 if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE)
287 err++;
288 270
289 if (err) 271 if (err)
290 return 2; 272 return 2;
diff --git a/drivers/staging/comedi/drivers/ni_labpc.c b/drivers/staging/comedi/drivers/ni_labpc.c
index d534e63d886e..28b91a6c3789 100644
--- a/drivers/staging/comedi/drivers/ni_labpc.c
+++ b/drivers/staging/comedi/drivers/ni_labpc.c
@@ -979,55 +979,33 @@ static int labpc_ai_cmdtest(struct comedi_device *dev,
979{ 979{
980 int err = 0; 980 int err = 0;
981 int tmp, tmp2; 981 int tmp, tmp2;
982 int stop_mask; 982 unsigned int stop_mask;
983 enum scan_mode mode; 983 enum scan_mode mode;
984 984
985 /* step 1: make sure trigger sources are trivially valid */ 985 /* Step 1 : check if triggers are trivially valid */
986 986
987 tmp = cmd->start_src; 987 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_EXT);
988 cmd->start_src &= TRIG_NOW | TRIG_EXT; 988 err |= cfc_check_trigger_src(&cmd->scan_begin_src,
989 if (!cmd->start_src || tmp != cmd->start_src) 989 TRIG_TIMER | TRIG_FOLLOW | TRIG_EXT);
990 err++; 990 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_TIMER | TRIG_EXT);
991 991 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
992 tmp = cmd->scan_begin_src;
993 cmd->scan_begin_src &= TRIG_TIMER | TRIG_FOLLOW | TRIG_EXT;
994 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
995 err++;
996
997 tmp = cmd->convert_src;
998 cmd->convert_src &= TRIG_TIMER | TRIG_EXT;
999 if (!cmd->convert_src || tmp != cmd->convert_src)
1000 err++;
1001
1002 tmp = cmd->scan_end_src;
1003 cmd->scan_end_src &= TRIG_COUNT;
1004 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
1005 err++;
1006 992
1007 tmp = cmd->stop_src;
1008 stop_mask = TRIG_COUNT | TRIG_NONE; 993 stop_mask = TRIG_COUNT | TRIG_NONE;
1009 if (thisboard->register_layout == labpc_1200_layout) 994 if (thisboard->register_layout == labpc_1200_layout)
1010 stop_mask |= TRIG_EXT; 995 stop_mask |= TRIG_EXT;
1011 cmd->stop_src &= stop_mask; 996 err |= cfc_check_trigger_src(&cmd->stop_src, stop_mask);
1012 if (!cmd->stop_src || tmp != cmd->stop_src)
1013 err++;
1014 997
1015 if (err) 998 if (err)
1016 return 1; 999 return 1;
1017 1000
1018 /* step 2: make sure trigger sources are unique and mutually compatible */ 1001 /* Step 2a : make sure trigger sources are unique */
1019 1002
1020 if (cmd->start_src != TRIG_NOW && cmd->start_src != TRIG_EXT) 1003 err |= cfc_check_trigger_is_unique(cmd->start_src);
1021 err++; 1004 err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
1022 if (cmd->scan_begin_src != TRIG_TIMER && 1005 err |= cfc_check_trigger_is_unique(cmd->convert_src);
1023 cmd->scan_begin_src != TRIG_FOLLOW && 1006 err |= cfc_check_trigger_is_unique(cmd->stop_src);
1024 cmd->scan_begin_src != TRIG_EXT) 1007
1025 err++; 1008 /* Step 2b : and mutually compatible */
1026 if (cmd->convert_src != TRIG_TIMER && cmd->convert_src != TRIG_EXT)
1027 err++;
1028 if (cmd->stop_src != TRIG_COUNT &&
1029 cmd->stop_src != TRIG_EXT && cmd->stop_src != TRIG_NONE)
1030 err++;
1031 1009
1032 /* can't have external stop and start triggers at once */ 1010 /* can't have external stop and start triggers at once */
1033 if (cmd->start_src == TRIG_EXT && cmd->stop_src == TRIG_EXT) 1011 if (cmd->start_src == TRIG_EXT && cmd->stop_src == TRIG_EXT)
diff --git a/drivers/staging/comedi/drivers/ni_mio_common.c b/drivers/staging/comedi/drivers/ni_mio_common.c
index 4bbb9798af7e..3e5fdae93163 100644
--- a/drivers/staging/comedi/drivers/ni_mio_common.c
+++ b/drivers/staging/comedi/drivers/ni_mio_common.c
@@ -2164,61 +2164,38 @@ static int ni_ai_cmdtest(struct comedi_device *dev, struct comedi_subdevice *s,
2164{ 2164{
2165 int err = 0; 2165 int err = 0;
2166 int tmp; 2166 int tmp;
2167 int sources; 2167 unsigned int sources;
2168 2168
2169 /* step 1: make sure trigger sources are trivially valid */ 2169 /* Step 1 : check if triggers are trivially valid */
2170 2170
2171 if ((cmd->flags & CMDF_WRITE)) { 2171 if ((cmd->flags & CMDF_WRITE))
2172 cmd->flags &= ~CMDF_WRITE; 2172 cmd->flags &= ~CMDF_WRITE;
2173 }
2174 2173
2175 tmp = cmd->start_src; 2174 err |= cfc_check_trigger_src(&cmd->start_src,
2176 cmd->start_src &= TRIG_NOW | TRIG_INT | TRIG_EXT; 2175 TRIG_NOW | TRIG_INT | TRIG_EXT);
2177 if (!cmd->start_src || tmp != cmd->start_src) 2176 err |= cfc_check_trigger_src(&cmd->scan_begin_src,
2178 err++; 2177 TRIG_TIMER | TRIG_EXT);
2179 2178
2180 tmp = cmd->scan_begin_src;
2181 cmd->scan_begin_src &= TRIG_TIMER | TRIG_EXT;
2182 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
2183 err++;
2184
2185 tmp = cmd->convert_src;
2186 sources = TRIG_TIMER | TRIG_EXT; 2179 sources = TRIG_TIMER | TRIG_EXT;
2187 if ((boardtype.reg_type == ni_reg_611x) 2180 if (boardtype.reg_type == ni_reg_611x ||
2188 || (boardtype.reg_type == ni_reg_6143)) 2181 boardtype.reg_type == ni_reg_6143)
2189 sources |= TRIG_NOW; 2182 sources |= TRIG_NOW;
2190 cmd->convert_src &= sources; 2183 err |= cfc_check_trigger_src(&cmd->convert_src, sources);
2191 if (!cmd->convert_src || tmp != cmd->convert_src)
2192 err++;
2193 2184
2194 tmp = cmd->scan_end_src; 2185 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
2195 cmd->scan_end_src &= TRIG_COUNT; 2186 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
2196 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
2197 err++;
2198
2199 tmp = cmd->stop_src;
2200 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
2201 if (!cmd->stop_src || tmp != cmd->stop_src)
2202 err++;
2203 2187
2204 if (err) 2188 if (err)
2205 return 1; 2189 return 1;
2206 2190
2207 /* step 2: make sure trigger sources are unique and mutually compatible */ 2191 /* Step 2a : make sure trigger sources are unique */
2208 2192
2209 /* note that mutual compatibility is not an issue here */ 2193 err |= cfc_check_trigger_is_unique(cmd->start_src);
2210 if (cmd->start_src != TRIG_NOW && 2194 err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
2211 cmd->start_src != TRIG_INT && cmd->start_src != TRIG_EXT) 2195 err |= cfc_check_trigger_is_unique(cmd->convert_src);
2212 err++; 2196 err |= cfc_check_trigger_is_unique(cmd->stop_src);
2213 if (cmd->scan_begin_src != TRIG_TIMER && 2197
2214 cmd->scan_begin_src != TRIG_EXT && 2198 /* Step 2b : and mutually compatible */
2215 cmd->scan_begin_src != TRIG_OTHER)
2216 err++;
2217 if (cmd->convert_src != TRIG_TIMER &&
2218 cmd->convert_src != TRIG_EXT && cmd->convert_src != TRIG_NOW)
2219 err++;
2220 if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE)
2221 err++;
2222 2199
2223 if (err) 2200 if (err)
2224 return 2; 2201 return 2;
@@ -3356,44 +3333,28 @@ static int ni_ao_cmdtest(struct comedi_device *dev, struct comedi_subdevice *s,
3356 int err = 0; 3333 int err = 0;
3357 int tmp; 3334 int tmp;
3358 3335
3359 /* step 1: make sure trigger sources are trivially valid */ 3336 /* Step 1 : check if triggers are trivially valid */
3360 3337
3361 if ((cmd->flags & CMDF_WRITE) == 0) { 3338 if ((cmd->flags & CMDF_WRITE) == 0)
3362 cmd->flags |= CMDF_WRITE; 3339 cmd->flags |= CMDF_WRITE;
3363 }
3364
3365 tmp = cmd->start_src;
3366 cmd->start_src &= TRIG_INT | TRIG_EXT;
3367 if (!cmd->start_src || tmp != cmd->start_src)
3368 err++;
3369 3340
3370 tmp = cmd->scan_begin_src; 3341 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_INT | TRIG_EXT);
3371 cmd->scan_begin_src &= TRIG_TIMER | TRIG_EXT; 3342 err |= cfc_check_trigger_src(&cmd->scan_begin_src,
3372 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src) 3343 TRIG_TIMER | TRIG_EXT);
3373 err++; 3344 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW);
3374 3345 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
3375 tmp = cmd->convert_src; 3346 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
3376 cmd->convert_src &= TRIG_NOW;
3377 if (!cmd->convert_src || tmp != cmd->convert_src)
3378 err++;
3379
3380 tmp = cmd->scan_end_src;
3381 cmd->scan_end_src &= TRIG_COUNT;
3382 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
3383 err++;
3384
3385 tmp = cmd->stop_src;
3386 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
3387 if (!cmd->stop_src || tmp != cmd->stop_src)
3388 err++;
3389 3347
3390 if (err) 3348 if (err)
3391 return 1; 3349 return 1;
3392 3350
3393 /* step 2: make sure trigger sources are unique and mutually compatible */ 3351 /* Step 2a : make sure trigger sources are unique */
3394 3352
3395 if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE) 3353 err |= cfc_check_trigger_is_unique(cmd->start_src);
3396 err++; 3354 err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
3355 err |= cfc_check_trigger_is_unique(cmd->stop_src);
3356
3357 /* Step 2b : and mutually compatible */
3397 3358
3398 if (err) 3359 if (err)
3399 return 2; 3360 return 2;
@@ -3643,51 +3604,21 @@ static int ni_cdio_cmdtest(struct comedi_device *dev,
3643{ 3604{
3644 int err = 0; 3605 int err = 0;
3645 int tmp; 3606 int tmp;
3646 int sources;
3647 unsigned i; 3607 unsigned i;
3648 3608
3649 /* step 1: make sure trigger sources are trivially valid */ 3609 /* Step 1 : check if triggers are trivially valid */
3650 3610
3651 tmp = cmd->start_src; 3611 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_INT);
3652 sources = TRIG_INT; 3612 err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_EXT);
3653 cmd->start_src &= sources; 3613 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW);
3654 if (!cmd->start_src || tmp != cmd->start_src) 3614 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
3655 err++; 3615 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_NONE);
3656
3657 tmp = cmd->scan_begin_src;
3658 cmd->scan_begin_src &= TRIG_EXT;
3659 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
3660 err++;
3661
3662 tmp = cmd->convert_src;
3663 cmd->convert_src &= TRIG_NOW;
3664 if (!cmd->convert_src || tmp != cmd->convert_src)
3665 err++;
3666
3667 tmp = cmd->scan_end_src;
3668 cmd->scan_end_src &= TRIG_COUNT;
3669 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
3670 err++;
3671
3672 tmp = cmd->stop_src;
3673 cmd->stop_src &= TRIG_NONE;
3674 if (!cmd->stop_src || tmp != cmd->stop_src)
3675 err++;
3676 3616
3677 if (err) 3617 if (err)
3678 return 1; 3618 return 1;
3679 3619
3680 /* step 2: make sure trigger sources are unique... */ 3620 /* Step 2a : make sure trigger sources are unique */
3681 3621 /* Step 2b : and mutually compatible */
3682 if (cmd->start_src != TRIG_INT)
3683 err++;
3684 if (cmd->scan_begin_src != TRIG_EXT)
3685 err++;
3686 if (cmd->convert_src != TRIG_NOW)
3687 err++;
3688 if (cmd->stop_src != TRIG_NONE)
3689 err++;
3690 /* ... and mutually compatible */
3691 3622
3692 if (err) 3623 if (err)
3693 return 2; 3624 return 2;
diff --git a/drivers/staging/comedi/drivers/ni_pcidio.c b/drivers/staging/comedi/drivers/ni_pcidio.c
index 6a70e266b1a3..bc9313ec985c 100644
--- a/drivers/staging/comedi/drivers/ni_pcidio.c
+++ b/drivers/staging/comedi/drivers/ni_pcidio.c
@@ -60,6 +60,7 @@ comedi_nonfree_firmware tarball available from http://www.comedi.org
60#include <linux/firmware.h> 60#include <linux/firmware.h>
61#include "../comedidev.h" 61#include "../comedidev.h"
62 62
63#include "comedi_fc.h"
63#include "mite.h" 64#include "mite.h"
64 65
65#undef DPRINTK 66#undef DPRINTK
@@ -683,45 +684,25 @@ static int ni_pcidio_cmdtest(struct comedi_device *dev,
683 int err = 0; 684 int err = 0;
684 int tmp; 685 int tmp;
685 686
686 /* step 1: make sure trigger sources are trivially valid */ 687 /* Step 1 : check if triggers are trivially valid */
687 688
688 tmp = cmd->start_src; 689 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_INT);
689 cmd->start_src &= TRIG_NOW | TRIG_INT; 690 err |= cfc_check_trigger_src(&cmd->scan_begin_src,
690 if (!cmd->start_src || tmp != cmd->start_src) 691 TRIG_TIMER | TRIG_EXT);
691 err++; 692 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW);
692 693 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
693 tmp = cmd->scan_begin_src; 694 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
694 cmd->scan_begin_src &= TRIG_TIMER | TRIG_EXT;
695 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
696 err++;
697
698 tmp = cmd->convert_src;
699 cmd->convert_src &= TRIG_NOW;
700 if (!cmd->convert_src || tmp != cmd->convert_src)
701 err++;
702
703 tmp = cmd->scan_end_src;
704 cmd->scan_end_src &= TRIG_COUNT;
705 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
706 err++;
707
708 tmp = cmd->stop_src;
709 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
710 if (!cmd->stop_src || tmp != cmd->stop_src)
711 err++;
712 695
713 if (err) 696 if (err)
714 return 1; 697 return 1;
715 698
716 /* step 2: make sure trigger sources are unique and mutually 699 /* Step 2a : make sure trigger sources are unique */
717 compatible */
718 700
719 /* note that mutual compatibility is not an issue here */ 701 err |= cfc_check_trigger_is_unique(cmd->start_src);
720 if (cmd->start_src != TRIG_NOW && cmd->start_src != TRIG_INT) 702 err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
721 err++; 703 err |= cfc_check_trigger_is_unique(cmd->stop_src);
722 if (cmd->scan_begin_src != TRIG_TIMER && 704
723 cmd->scan_begin_src != TRIG_EXT) 705 /* Step 2b : and mutually compatible */
724 err++;
725 706
726 if (err) 707 if (err)
727 return 2; 708 return 2;
diff --git a/drivers/staging/comedi/drivers/ni_tiocmd.c b/drivers/staging/comedi/drivers/ni_tiocmd.c
index a9611587460a..8ee93d359bed 100644
--- a/drivers/staging/comedi/drivers/ni_tiocmd.c
+++ b/drivers/staging/comedi/drivers/ni_tiocmd.c
@@ -48,6 +48,7 @@ TODO:
48 Support use of both banks X and Y 48 Support use of both banks X and Y
49*/ 49*/
50 50
51#include "comedi_fc.h"
51#include "ni_tio_internal.h" 52#include "ni_tio_internal.h"
52#include "mite.h" 53#include "mite.h"
53 54
@@ -237,61 +238,35 @@ EXPORT_SYMBOL_GPL(ni_tio_cmd);
237int ni_tio_cmdtest(struct ni_gpct *counter, struct comedi_cmd *cmd) 238int ni_tio_cmdtest(struct ni_gpct *counter, struct comedi_cmd *cmd)
238{ 239{
239 int err = 0; 240 int err = 0;
240 int tmp; 241 unsigned int sources;
241 int sources;
242 242
243 /* step 1: make sure trigger sources are trivially valid */ 243 /* Step 1 : check if triggers are trivially valid */
244 244
245 tmp = cmd->start_src;
246 sources = TRIG_NOW | TRIG_INT | TRIG_OTHER; 245 sources = TRIG_NOW | TRIG_INT | TRIG_OTHER;
247 if (ni_tio_counting_mode_registers_present(counter->counter_dev)) 246 if (ni_tio_counting_mode_registers_present(counter->counter_dev))
248 sources |= TRIG_EXT; 247 sources |= TRIG_EXT;
249 cmd->start_src &= sources; 248 err |= cfc_check_trigger_src(&cmd->start_src, sources);
250 if (!cmd->start_src || tmp != cmd->start_src)
251 err++;
252
253 tmp = cmd->scan_begin_src;
254 cmd->scan_begin_src &= TRIG_FOLLOW | TRIG_EXT | TRIG_OTHER;
255 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
256 err++;
257
258 tmp = cmd->convert_src;
259 sources = TRIG_NOW | TRIG_EXT | TRIG_OTHER;
260 cmd->convert_src &= sources;
261 if (!cmd->convert_src || tmp != cmd->convert_src)
262 err++;
263
264 tmp = cmd->scan_end_src;
265 cmd->scan_end_src &= TRIG_COUNT;
266 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
267 err++;
268 249
269 tmp = cmd->stop_src; 250 err |= cfc_check_trigger_src(&cmd->scan_begin_src,
270 cmd->stop_src &= TRIG_NONE; 251 TRIG_FOLLOW | TRIG_EXT | TRIG_OTHER);
271 if (!cmd->stop_src || tmp != cmd->stop_src) 252 err |= cfc_check_trigger_src(&cmd->convert_src,
272 err++; 253 TRIG_NOW | TRIG_EXT | TRIG_OTHER);
254 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
255 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_NONE);
273 256
274 if (err) 257 if (err)
275 return 1; 258 return 1;
276 259
277 /* step 2: make sure trigger sources are unique... */ 260 /* Step 2a : make sure trigger sources are unique */
261
262 err |= cfc_check_trigger_is_unique(cmd->start_src);
263 err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
264 err |= cfc_check_trigger_is_unique(cmd->convert_src);
265
266 /* Step 2b : and mutually compatible */
278 267
279 if (cmd->start_src != TRIG_NOW &&
280 cmd->start_src != TRIG_INT &&
281 cmd->start_src != TRIG_EXT && cmd->start_src != TRIG_OTHER)
282 err++;
283 if (cmd->scan_begin_src != TRIG_FOLLOW &&
284 cmd->scan_begin_src != TRIG_EXT &&
285 cmd->scan_begin_src != TRIG_OTHER)
286 err++;
287 if (cmd->convert_src != TRIG_OTHER &&
288 cmd->convert_src != TRIG_EXT && cmd->convert_src != TRIG_NOW)
289 err++;
290 if (cmd->stop_src != TRIG_NONE)
291 err++;
292 /* ... and mutually compatible */
293 if (cmd->convert_src != TRIG_NOW && cmd->scan_begin_src != TRIG_FOLLOW) 268 if (cmd->convert_src != TRIG_NOW && cmd->scan_begin_src != TRIG_FOLLOW)
294 err++; 269 err |= -EINVAL;
295 270
296 if (err) 271 if (err)
297 return 2; 272 return 2;
diff --git a/drivers/staging/comedi/drivers/pcl711.c b/drivers/staging/comedi/drivers/pcl711.c
index ef77b15f19f7..89305a14eb5c 100644
--- a/drivers/staging/comedi/drivers/pcl711.c
+++ b/drivers/staging/comedi/drivers/pcl711.c
@@ -64,6 +64,7 @@ supported.
64#include <linux/ioport.h> 64#include <linux/ioport.h>
65#include <linux/delay.h> 65#include <linux/delay.h>
66 66
67#include "comedi_fc.h"
67#include "8253.h" 68#include "8253.h"
68 69
69#define PCL711_SIZE 16 70#define PCL711_SIZE 16
@@ -266,42 +267,24 @@ static int pcl711_ai_cmdtest(struct comedi_device *dev,
266 int tmp; 267 int tmp;
267 int err = 0; 268 int err = 0;
268 269
269 /* step 1 */ 270 /* Step 1 : check if triggers are trivially valid */
270 tmp = cmd->start_src;
271 cmd->start_src &= TRIG_NOW;
272 if (!cmd->start_src || tmp != cmd->start_src)
273 err++;
274
275 tmp = cmd->scan_begin_src;
276 cmd->scan_begin_src &= TRIG_TIMER | TRIG_EXT;
277 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
278 err++;
279 271
280 tmp = cmd->convert_src; 272 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
281 cmd->convert_src &= TRIG_NOW; 273 err |= cfc_check_trigger_src(&cmd->scan_begin_src,
282 if (!cmd->convert_src || tmp != cmd->convert_src) 274 TRIG_TIMER | TRIG_EXT);
283 err++; 275 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW);
284 276 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
285 tmp = cmd->scan_end_src; 277 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
286 cmd->scan_end_src &= TRIG_COUNT;
287 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
288 err++;
289
290 tmp = cmd->stop_src;
291 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
292 if (!cmd->stop_src || tmp != cmd->stop_src)
293 err++;
294 278
295 if (err) 279 if (err)
296 return 1; 280 return 1;
297 281
298 /* step 2 */ 282 /* Step 2a : make sure trigger sources are unique */
299 283
300 if (cmd->scan_begin_src != TRIG_TIMER && 284 err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
301 cmd->scan_begin_src != TRIG_EXT) 285 err |= cfc_check_trigger_is_unique(cmd->stop_src);
302 err++; 286
303 if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE) 287 /* Step 2b : and mutually compatible */
304 err++;
305 288
306 if (err) 289 if (err)
307 return 2; 290 return 2;
diff --git a/drivers/staging/comedi/drivers/pcl812.c b/drivers/staging/comedi/drivers/pcl812.c
index d196343adb08..3cf55ff93083 100644
--- a/drivers/staging/comedi/drivers/pcl812.c
+++ b/drivers/staging/comedi/drivers/pcl812.c
@@ -117,6 +117,7 @@
117#include <linux/io.h> 117#include <linux/io.h>
118#include <asm/dma.h> 118#include <asm/dma.h>
119 119
120#include "comedi_fc.h"
120#include "8253.h" 121#include "8253.h"
121 122
122/* hardware types of the cards */ 123/* hardware types of the cards */
@@ -533,49 +534,31 @@ static int pcl812_ai_cmdtest(struct comedi_device *dev,
533{ 534{
534 const struct pcl812_board *board = comedi_board(dev); 535 const struct pcl812_board *board = comedi_board(dev);
535 int err = 0; 536 int err = 0;
537 unsigned int flags;
536 int tmp, divisor1, divisor2; 538 int tmp, divisor1, divisor2;
537 539
538 /* step 1: make sure trigger sources are trivially valid */ 540 /* Step 1 : check if triggers are trivially valid */
539 541
540 tmp = cmd->start_src; 542 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
541 cmd->start_src &= TRIG_NOW; 543 err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_FOLLOW);
542 if (!cmd->start_src || tmp != cmd->start_src)
543 err++;
544
545 tmp = cmd->scan_begin_src;
546 cmd->scan_begin_src &= TRIG_FOLLOW;
547 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
548 err++;
549 544
550 tmp = cmd->convert_src;
551 if (devpriv->use_ext_trg) 545 if (devpriv->use_ext_trg)
552 cmd->convert_src &= TRIG_EXT; 546 flags = TRIG_EXT;
553 else 547 else
554 cmd->convert_src &= TRIG_TIMER; 548 flags = TRIG_TIMER;
555 549 err |= cfc_check_trigger_src(&cmd->convert_src, flags);
556 if (!cmd->convert_src || tmp != cmd->convert_src)
557 err++;
558 550
559 tmp = cmd->scan_end_src; 551 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
560 cmd->scan_end_src &= TRIG_COUNT; 552 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
561 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
562 err++;
563
564 tmp = cmd->stop_src;
565 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
566 if (!cmd->stop_src || tmp != cmd->stop_src)
567 err++;
568 553
569 if (err) 554 if (err)
570 return 1; 555 return 1;
571 556
572 /* 557 /* Step 2a : make sure trigger sources are unique */
573 * step 2: make sure trigger sources are
574 * unique and mutually compatible
575 */
576 558
577 if (cmd->stop_src != TRIG_NONE && cmd->stop_src != TRIG_COUNT) 559 err |= cfc_check_trigger_is_unique(cmd->stop_src);
578 err++; 560
561 /* Step 2b : and mutually compatible */
579 562
580 if (err) 563 if (err)
581 return 2; 564 return 2;
diff --git a/drivers/staging/comedi/drivers/pcl816.c b/drivers/staging/comedi/drivers/pcl816.c
index f65fd66cc8a2..0822de058e4d 100644
--- a/drivers/staging/comedi/drivers/pcl816.c
+++ b/drivers/staging/comedi/drivers/pcl816.c
@@ -41,6 +41,7 @@ Configuration Options:
41#include <linux/io.h> 41#include <linux/io.h>
42#include <asm/dma.h> 42#include <asm/dma.h>
43 43
44#include "comedi_fc.h"
44#include "8253.h" 45#include "8253.h"
45 46
46#define DEBUG(x) x 47#define DEBUG(x) x
@@ -458,48 +459,23 @@ static int pcl816_ai_cmdtest(struct comedi_device *dev,
458 pcl816_cmdtest_out(-1, cmd); 459 pcl816_cmdtest_out(-1, cmd);
459 ); 460 );
460 461
461 /* step 1: make sure trigger sources are trivially valid */ 462 /* Step 1 : check if triggers are trivially valid */
462 tmp = cmd->start_src;
463 cmd->start_src &= TRIG_NOW;
464 if (!cmd->start_src || tmp != cmd->start_src)
465 err++;
466
467 tmp = cmd->scan_begin_src;
468 cmd->scan_begin_src &= TRIG_FOLLOW;
469 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
470 err++;
471
472 tmp = cmd->convert_src;
473 cmd->convert_src &= TRIG_EXT | TRIG_TIMER;
474 if (!cmd->convert_src || tmp != cmd->convert_src)
475 err++;
476
477 tmp = cmd->scan_end_src;
478 cmd->scan_end_src &= TRIG_COUNT;
479 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
480 err++;
481 463
482 tmp = cmd->stop_src; 464 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
483 cmd->stop_src &= TRIG_COUNT | TRIG_NONE; 465 err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_FOLLOW);
484 if (!cmd->stop_src || tmp != cmd->stop_src) 466 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_EXT | TRIG_TIMER);
485 err++; 467 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
468 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
486 469
487 if (err) 470 if (err)
488 return 1; 471 return 1;
489 472
473 /* Step 2a : make sure trigger sources are unique */
490 474
491 /* 475 err |= cfc_check_trigger_is_unique(cmd->convert_src);
492 * step 2: make sure trigger sources 476 err |= cfc_check_trigger_is_unique(cmd->stop_src);
493 * are unique and mutually compatible
494 */
495
496 if (cmd->convert_src != TRIG_EXT && cmd->convert_src != TRIG_TIMER) {
497 cmd->convert_src = TRIG_TIMER;
498 err++;
499 }
500 477
501 if (cmd->stop_src != TRIG_NONE && cmd->stop_src != TRIG_COUNT) 478 /* Step 2b : and mutually compatible */
502 err++;
503 479
504 if (err) 480 if (err)
505 return 2; 481 return 2;
diff --git a/drivers/staging/comedi/drivers/pcl818.c b/drivers/staging/comedi/drivers/pcl818.c
index 023a27df0d29..d4b0859d81f2 100644
--- a/drivers/staging/comedi/drivers/pcl818.c
+++ b/drivers/staging/comedi/drivers/pcl818.c
@@ -107,6 +107,7 @@ A word or two about DMA. Driver support DMA operations at two ways:
107#include <linux/io.h> 107#include <linux/io.h>
108#include <asm/dma.h> 108#include <asm/dma.h>
109 109
110#include "comedi_fc.h"
110#include "8253.h" 111#include "8253.h"
111 112
112/* #define PCL818_MODE13_AO 1 */ 113/* #define PCL818_MODE13_AO 1 */
@@ -1261,43 +1262,23 @@ static int ai_cmdtest(struct comedi_device *dev, struct comedi_subdevice *s,
1261 int err = 0; 1262 int err = 0;
1262 int tmp, divisor1 = 0, divisor2 = 0; 1263 int tmp, divisor1 = 0, divisor2 = 0;
1263 1264
1264 /* step 1: make sure trigger sources are trivially valid */ 1265 /* Step 1 : check if triggers are trivially valid */
1265 1266
1266 tmp = cmd->start_src; 1267 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
1267 cmd->start_src &= TRIG_NOW; 1268 err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_FOLLOW);
1268 if (!cmd->start_src || tmp != cmd->start_src) 1269 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_TIMER | TRIG_EXT);
1269 err++; 1270 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
1270 1271 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
1271 tmp = cmd->scan_begin_src;
1272 cmd->scan_begin_src &= TRIG_FOLLOW;
1273 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
1274 err++;
1275
1276 tmp = cmd->convert_src;
1277 cmd->convert_src &= TRIG_TIMER | TRIG_EXT;
1278 if (!cmd->convert_src || tmp != cmd->convert_src)
1279 err++;
1280
1281 tmp = cmd->scan_end_src;
1282 cmd->scan_end_src &= TRIG_COUNT;
1283 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
1284 err++;
1285
1286 tmp = cmd->stop_src;
1287 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
1288 if (!cmd->stop_src || tmp != cmd->stop_src)
1289 err++;
1290 1272
1291 if (err) 1273 if (err)
1292 return 1; 1274 return 1;
1293 1275
1294 /* step 2: make sure trigger sources are unique and mutually compatible */ 1276 /* Step 2a : make sure trigger sources are unique */
1295 1277
1296 if (cmd->convert_src != TRIG_TIMER && cmd->convert_src != TRIG_EXT) 1278 err |= cfc_check_trigger_is_unique(cmd->convert_src);
1297 err++; 1279 err |= cfc_check_trigger_is_unique(cmd->stop_src);
1298 1280
1299 if (cmd->stop_src != TRIG_NONE && cmd->stop_src != TRIG_COUNT) 1281 /* Step 2b : and mutually compatible */
1300 err++;
1301 1282
1302 if (err) 1283 if (err)
1303 return 2; 1284 return 2;
diff --git a/drivers/staging/comedi/drivers/pcm_common.c b/drivers/staging/comedi/drivers/pcm_common.c
index 474af7bc6c8b..85ee05ece9c8 100644
--- a/drivers/staging/comedi/drivers/pcm_common.c
+++ b/drivers/staging/comedi/drivers/pcm_common.c
@@ -1,60 +1,30 @@
1#include "../comedidev.h" 1#include "../comedidev.h"
2
3#include "comedi_fc.h"
2#include "pcm_common.h" 4#include "pcm_common.h"
3 5
4/*
5 * 'do_cmdtest' function for an 'INTERRUPT' subdevice. This is for
6 * the PCM drivers.
7 */
8int comedi_pcm_cmdtest(struct comedi_device *dev, 6int comedi_pcm_cmdtest(struct comedi_device *dev,
9 struct comedi_subdevice *s, struct comedi_cmd *cmd) 7 struct comedi_subdevice *s, struct comedi_cmd *cmd)
10{ 8{
11 int err = 0; 9 int err = 0;
12 unsigned int tmp;
13
14 /* step 1: make sure trigger sources are trivially valid */
15
16 tmp = cmd->start_src;
17 cmd->start_src &= (TRIG_NOW | TRIG_INT);
18 if (!cmd->start_src || tmp != cmd->start_src)
19 err++;
20
21 tmp = cmd->scan_begin_src;
22 cmd->scan_begin_src &= TRIG_EXT;
23 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
24 err++;
25
26 tmp = cmd->convert_src;
27 cmd->convert_src &= TRIG_NOW;
28 if (!cmd->convert_src || tmp != cmd->convert_src)
29 err++;
30 10
31 tmp = cmd->scan_end_src; 11 /* Step 1 : check if triggers are trivially valid */
32 cmd->scan_end_src &= TRIG_COUNT;
33 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
34 err++;
35 12
36 tmp = cmd->stop_src; 13 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_INT);
37 cmd->stop_src &= (TRIG_COUNT | TRIG_NONE); 14 err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_EXT);
38 if (!cmd->stop_src || tmp != cmd->stop_src) 15 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW);
39 err++; 16 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
17 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
40 18
41 if (err) 19 if (err)
42 return 1; 20 return 1;
43 21
44 /* step 2: make sure trigger sources are unique and 22 /* Step 2a : make sure trigger sources are unique */
45 * mutually compatible */
46 23
47 /* these tests are true if more than one _src bit is set */ 24 err |= cfc_check_trigger_is_unique(cmd->start_src);
48 if ((cmd->start_src & (cmd->start_src - 1)) != 0) 25 err |= cfc_check_trigger_is_unique(cmd->stop_src);
49 err++; 26
50 if ((cmd->scan_begin_src & (cmd->scan_begin_src - 1)) != 0) 27 /* Step 2b : and mutually compatible */
51 err++;
52 if ((cmd->convert_src & (cmd->convert_src - 1)) != 0)
53 err++;
54 if ((cmd->scan_end_src & (cmd->scan_end_src - 1)) != 0)
55 err++;
56 if ((cmd->stop_src & (cmd->stop_src - 1)) != 0)
57 err++;
58 28
59 if (err) 29 if (err)
60 return 2; 30 return 2;
diff --git a/drivers/staging/comedi/drivers/quatech_daqp_cs.c b/drivers/staging/comedi/drivers/quatech_daqp_cs.c
index e95a4eb0a67d..3e276f7a3380 100644
--- a/drivers/staging/comedi/drivers/quatech_daqp_cs.c
+++ b/drivers/staging/comedi/drivers/quatech_daqp_cs.c
@@ -56,6 +56,8 @@ Devices: [Quatech] DAQP-208 (daqp), DAQP-308
56 56
57#include <linux/completion.h> 57#include <linux/completion.h>
58 58
59#include "comedi_fc.h"
60
59/* Maximum number of separate DAQP devices we'll allow */ 61/* Maximum number of separate DAQP devices we'll allow */
60#define MAX_DEV 4 62#define MAX_DEV 4
61 63
@@ -456,51 +458,26 @@ static int daqp_ai_cmdtest(struct comedi_device *dev,
456 int err = 0; 458 int err = 0;
457 int tmp; 459 int tmp;
458 460
459 /* step 1: make sure trigger sources are trivially valid */ 461 /* Step 1 : check if triggers are trivially valid */
460
461 tmp = cmd->start_src;
462 cmd->start_src &= TRIG_NOW;
463 if (!cmd->start_src || tmp != cmd->start_src)
464 err++;
465
466 tmp = cmd->scan_begin_src;
467 cmd->scan_begin_src &= TRIG_TIMER | TRIG_FOLLOW;
468 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
469 err++;
470
471 tmp = cmd->convert_src;
472 cmd->convert_src &= TRIG_TIMER | TRIG_NOW;
473 if (!cmd->convert_src || tmp != cmd->convert_src)
474 err++;
475
476 tmp = cmd->scan_end_src;
477 cmd->scan_end_src &= TRIG_COUNT;
478 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
479 err++;
480 462
481 tmp = cmd->stop_src; 463 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
482 cmd->stop_src &= TRIG_COUNT | TRIG_NONE; 464 err |= cfc_check_trigger_src(&cmd->scan_begin_src,
483 if (!cmd->stop_src || tmp != cmd->stop_src) 465 TRIG_TIMER | TRIG_FOLLOW);
484 err++; 466 err |= cfc_check_trigger_src(&cmd->convert_src,
467 TRIG_TIMER | TRIG_NOW);
468 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
469 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
485 470
486 if (err) 471 if (err)
487 return 1; 472 return 1;
488 473
489 /* 474 /* Step 2a : make sure trigger sources are unique */
490 * step 2: make sure trigger sources
491 * are unique and mutually compatible
492 */
493 475
494 /* note that mutual compatibility is not an issue here */ 476 err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
495 if (cmd->scan_begin_src != TRIG_TIMER && 477 err |= cfc_check_trigger_is_unique(cmd->convert_src);
496 cmd->scan_begin_src != TRIG_FOLLOW) 478 err |= cfc_check_trigger_is_unique(cmd->stop_src);
497 err++; 479
498 if (cmd->convert_src != TRIG_NOW && cmd->convert_src != TRIG_TIMER) 480 /* Step 2b : and mutually compatible */
499 err++;
500 if (cmd->scan_begin_src == TRIG_FOLLOW && cmd->convert_src == TRIG_NOW)
501 err++;
502 if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE)
503 err++;
504 481
505 if (err) 482 if (err)
506 return 2; 483 return 2;
diff --git a/drivers/staging/comedi/drivers/rtd520.c b/drivers/staging/comedi/drivers/rtd520.c
index d0e4844e5248..41d24b08913b 100644
--- a/drivers/staging/comedi/drivers/rtd520.c
+++ b/drivers/staging/comedi/drivers/rtd520.c
@@ -106,6 +106,8 @@ Configuration options:
106 106
107#include "../comedidev.h" 107#include "../comedidev.h"
108 108
109#include "comedi_fc.h"
110
109#define DRV_NAME "rtd520" 111#define DRV_NAME "rtd520"
110 112
111/*====================================================================== 113/*======================================================================
@@ -976,52 +978,25 @@ static int rtd_ai_cmdtest(struct comedi_device *dev,
976 int err = 0; 978 int err = 0;
977 int tmp; 979 int tmp;
978 980
979 /* step 1: make sure trigger sources are trivially valid */ 981 /* Step 1 : check if triggers are trivially valid */
980
981 tmp = cmd->start_src;
982 cmd->start_src &= TRIG_NOW;
983 if (!cmd->start_src || tmp != cmd->start_src)
984 err++;
985
986 tmp = cmd->scan_begin_src;
987 cmd->scan_begin_src &= TRIG_TIMER | TRIG_EXT;
988 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
989 err++;
990
991
992 tmp = cmd->convert_src;
993 cmd->convert_src &= TRIG_TIMER | TRIG_EXT;
994 if (!cmd->convert_src || tmp != cmd->convert_src)
995 err++;
996
997
998 tmp = cmd->scan_end_src;
999 cmd->scan_end_src &= TRIG_COUNT;
1000 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
1001 err++;
1002
1003
1004 tmp = cmd->stop_src;
1005 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
1006 if (!cmd->stop_src || tmp != cmd->stop_src)
1007 err++;
1008 982
983 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
984 err |= cfc_check_trigger_src(&cmd->scan_begin_src,
985 TRIG_TIMER | TRIG_EXT);
986 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_TIMER | TRIG_EXT);
987 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
988 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
1009 989
1010 if (err) 990 if (err)
1011 return 1; 991 return 1;
1012 992
1013 /* step 2: make sure trigger sources are unique 993 /* Step 2a : make sure trigger sources are unique */
1014 and mutually compatible */
1015 /* note that mutual compatibility is not an issue here */
1016 if (cmd->scan_begin_src != TRIG_TIMER &&
1017 cmd->scan_begin_src != TRIG_EXT) {
1018 err++;
1019 }
1020 if (cmd->convert_src != TRIG_TIMER && cmd->convert_src != TRIG_EXT)
1021 err++;
1022 994
1023 if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE) 995 err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
1024 err++; 996 err |= cfc_check_trigger_is_unique(cmd->convert_src);
997 err |= cfc_check_trigger_is_unique(cmd->stop_src);
998
999 /* Step 2b : and mutually compatible */
1025 1000
1026 if (err) 1001 if (err)
1027 return 2; 1002 return 2;
diff --git a/drivers/staging/comedi/drivers/s626.c b/drivers/staging/comedi/drivers/s626.c
index 24878c815fd7..551d68b7837c 100644
--- a/drivers/staging/comedi/drivers/s626.c
+++ b/drivers/staging/comedi/drivers/s626.c
@@ -1505,56 +1505,28 @@ static int s626_ai_cmdtest(struct comedi_device *dev,
1505 int err = 0; 1505 int err = 0;
1506 int tmp; 1506 int tmp;
1507 1507
1508 /* cmdtest tests a particular command to see if it is valid. Using 1508 /* Step 1 : check if triggers are trivially valid */
1509 * the cmdtest ioctl, a user can create a valid cmd and then have it
1510 * executes by the cmd ioctl.
1511 *
1512 * cmdtest returns 1,2,3,4 or 0, depending on which tests the
1513 * command passes. */
1514
1515 /* step 1: make sure trigger sources are trivially valid */
1516
1517 tmp = cmd->start_src;
1518 cmd->start_src &= TRIG_NOW | TRIG_INT | TRIG_EXT;
1519 if (!cmd->start_src || tmp != cmd->start_src)
1520 err++;
1521 1509
1522 tmp = cmd->scan_begin_src; 1510 err |= cfc_check_trigger_src(&cmd->start_src,
1523 cmd->scan_begin_src &= TRIG_TIMER | TRIG_EXT | TRIG_FOLLOW; 1511 TRIG_NOW | TRIG_INT | TRIG_EXT);
1524 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src) 1512 err |= cfc_check_trigger_src(&cmd->scan_begin_src,
1525 err++; 1513 TRIG_TIMER | TRIG_EXT | TRIG_FOLLOW);
1526 1514 err |= cfc_check_trigger_src(&cmd->convert_src,
1527 tmp = cmd->convert_src; 1515 TRIG_TIMER | TRIG_EXT | TRIG_NOW);
1528 cmd->convert_src &= TRIG_TIMER | TRIG_EXT | TRIG_NOW; 1516 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
1529 if (!cmd->convert_src || tmp != cmd->convert_src) 1517 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
1530 err++;
1531
1532 tmp = cmd->scan_end_src;
1533 cmd->scan_end_src &= TRIG_COUNT;
1534 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
1535 err++;
1536
1537 tmp = cmd->stop_src;
1538 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
1539 if (!cmd->stop_src || tmp != cmd->stop_src)
1540 err++;
1541 1518
1542 if (err) 1519 if (err)
1543 return 1; 1520 return 1;
1544 1521
1545 /* step 2: make sure trigger sources are unique and mutually 1522 /* Step 2a : make sure trigger sources are unique */
1546 compatible */
1547 1523
1548 /* note that mutual compatibility is not an issue here */ 1524 err |= cfc_check_trigger_is_unique(cmd->start_src);
1549 if (cmd->scan_begin_src != TRIG_TIMER && 1525 err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
1550 cmd->scan_begin_src != TRIG_EXT 1526 err |= cfc_check_trigger_is_unique(cmd->convert_src);
1551 && cmd->scan_begin_src != TRIG_FOLLOW) 1527 err |= cfc_check_trigger_is_unique(cmd->stop_src);
1552 err++; 1528
1553 if (cmd->convert_src != TRIG_TIMER && 1529 /* Step 2b : and mutually compatible */
1554 cmd->convert_src != TRIG_EXT && cmd->convert_src != TRIG_NOW)
1555 err++;
1556 if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE)
1557 err++;
1558 1530
1559 if (err) 1531 if (err)
1560 return 2; 1532 return 2;
diff --git a/drivers/staging/comedi/drivers/skel.c b/drivers/staging/comedi/drivers/skel.c
index eb70baca49d8..b70cdf300bbd 100644
--- a/drivers/staging/comedi/drivers/skel.c
+++ b/drivers/staging/comedi/drivers/skel.c
@@ -76,6 +76,8 @@ Configuration Options:
76 76
77#include <linux/pci.h> /* for PCI devices */ 77#include <linux/pci.h> /* for PCI devices */
78 78
79#include "comedi_fc.h"
80
79/* Imaginary registers for the imaginary board */ 81/* Imaginary registers for the imaginary board */
80 82
81#define SKEL_SIZE 0 83#define SKEL_SIZE 0
@@ -349,60 +351,40 @@ static int skel_ai_rinsn(struct comedi_device *dev, struct comedi_subdevice *s,
349 return n; 351 return n;
350} 352}
351 353
354/*
355 * cmdtest tests a particular command to see if it is valid.
356 * Using the cmdtest ioctl, a user can create a valid cmd
357 * and then have it executes by the cmd ioctl.
358 *
359 * cmdtest returns 1,2,3,4 or 0, depending on which tests
360 * the command passes.
361 */
352static int skel_ai_cmdtest(struct comedi_device *dev, 362static int skel_ai_cmdtest(struct comedi_device *dev,
353 struct comedi_subdevice *s, struct comedi_cmd *cmd) 363 struct comedi_subdevice *s,
364 struct comedi_cmd *cmd)
354{ 365{
355 int err = 0; 366 int err = 0;
356 int tmp; 367 int tmp;
357 368
358 /* cmdtest tests a particular command to see if it is valid. 369 /* Step 1 : check if triggers are trivially valid */
359 * Using the cmdtest ioctl, a user can create a valid cmd
360 * and then have it executes by the cmd ioctl.
361 *
362 * cmdtest returns 1,2,3,4 or 0, depending on which tests
363 * the command passes. */
364
365 /* step 1: make sure trigger sources are trivially valid */
366 370
367 tmp = cmd->start_src; 371 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
368 cmd->start_src &= TRIG_NOW; 372 err |= cfc_check_trigger_src(&cmd->scan_begin_src,
369 if (!cmd->start_src || tmp != cmd->start_src) 373 TRIG_TIMER | TRIG_EXT);
370 err++; 374 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_TIMER | TRIG_EXT);
371 375 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
372 tmp = cmd->scan_begin_src; 376 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
373 cmd->scan_begin_src &= TRIG_TIMER | TRIG_EXT;
374 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
375 err++;
376
377 tmp = cmd->convert_src;
378 cmd->convert_src &= TRIG_TIMER | TRIG_EXT;
379 if (!cmd->convert_src || tmp != cmd->convert_src)
380 err++;
381
382 tmp = cmd->scan_end_src;
383 cmd->scan_end_src &= TRIG_COUNT;
384 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
385 err++;
386
387 tmp = cmd->stop_src;
388 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
389 if (!cmd->stop_src || tmp != cmd->stop_src)
390 err++;
391 377
392 if (err) 378 if (err)
393 return 1; 379 return 1;
394 380
395 /* step 2: make sure trigger sources are unique and mutually compatible 381 /* Step 2a : make sure trigger sources are unique */
396 */
397 382
398 /* note that mutual compatibility is not an issue here */ 383 err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
399 if (cmd->scan_begin_src != TRIG_TIMER && 384 err |= cfc_check_trigger_is_unique(cmd->convert_src);
400 cmd->scan_begin_src != TRIG_EXT) 385 err |= cfc_check_trigger_is_unique(cmd->stop_src);
401 err++; 386
402 if (cmd->convert_src != TRIG_TIMER && cmd->convert_src != TRIG_EXT) 387 /* Step 2b : and mutually compatible */
403 err++;
404 if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE)
405 err++;
406 388
407 if (err) 389 if (err)
408 return 2; 390 return 2;
diff --git a/drivers/staging/comedi/drivers/usbdux.c b/drivers/staging/comedi/drivers/usbdux.c
index bc5fc5cc4641..b536bba74351 100644
--- a/drivers/staging/comedi/drivers/usbdux.c
+++ b/drivers/staging/comedi/drivers/usbdux.c
@@ -98,6 +98,8 @@ sampling rate. If you sample two channels you get 4kHz and so on.
98 98
99#include "../comedidev.h" 99#include "../comedidev.h"
100 100
101#include "comedi_fc.h"
102
101/* timeout for the USB-transfer in ms*/ 103/* timeout for the USB-transfer in ms*/
102#define BULK_TIMEOUT 1000 104#define BULK_TIMEOUT 1000
103 105
@@ -929,9 +931,9 @@ static int usbduxsub_submit_OutURBs(struct usbduxsub *usbduxsub)
929static int usbdux_ai_cmdtest(struct comedi_device *dev, 931static int usbdux_ai_cmdtest(struct comedi_device *dev,
930 struct comedi_subdevice *s, struct comedi_cmd *cmd) 932 struct comedi_subdevice *s, struct comedi_cmd *cmd)
931{ 933{
932 int err = 0, tmp, i;
933 unsigned int tmpTimer;
934 struct usbduxsub *this_usbduxsub = dev->private; 934 struct usbduxsub *this_usbduxsub = dev->private;
935 int err = 0, i;
936 unsigned int tmpTimer;
935 937
936 if (!(this_usbduxsub->probed)) 938 if (!(this_usbduxsub->probed))
937 return -ENODEV; 939 return -ENODEV;
@@ -939,51 +941,23 @@ static int usbdux_ai_cmdtest(struct comedi_device *dev,
939 dev_dbg(&this_usbduxsub->interface->dev, 941 dev_dbg(&this_usbduxsub->interface->dev,
940 "comedi%d: usbdux_ai_cmdtest\n", dev->minor); 942 "comedi%d: usbdux_ai_cmdtest\n", dev->minor);
941 943
942 /* make sure triggers are valid */ 944 /* Step 1 : check if triggers are trivially valid */
943 /* Only immediate triggers are allowed */
944 tmp = cmd->start_src;
945 cmd->start_src &= TRIG_NOW | TRIG_INT;
946 if (!cmd->start_src || tmp != cmd->start_src)
947 err++;
948 945
949 /* trigger should happen timed */ 946 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_INT);
950 tmp = cmd->scan_begin_src; 947 err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_TIMER);
951 /* start a new _scan_ with a timer */ 948 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW);
952 cmd->scan_begin_src &= TRIG_TIMER; 949 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
953 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src) 950 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
954 err++;
955
956 /* scanning is continuous */
957 tmp = cmd->convert_src;
958 cmd->convert_src &= TRIG_NOW;
959 if (!cmd->convert_src || tmp != cmd->convert_src)
960 err++;
961
962 /* issue a trigger when scan is finished and start a new scan */
963 tmp = cmd->scan_end_src;
964 cmd->scan_end_src &= TRIG_COUNT;
965 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
966 err++;
967
968 /* trigger at the end of count events or not, stop condition or not */
969 tmp = cmd->stop_src;
970 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
971 if (!cmd->stop_src || tmp != cmd->stop_src)
972 err++;
973 951
974 if (err) 952 if (err)
975 return 1; 953 return 1;
976 954
977 /* 955 /* Step 2a : make sure trigger sources are unique */
978 * step 2: make sure trigger sources are unique and mutually compatible 956
979 * note that mutual compatibility is not an issue here 957 err |= cfc_check_trigger_is_unique(cmd->start_src);
980 */ 958 err |= cfc_check_trigger_is_unique(cmd->stop_src);
981 if (cmd->scan_begin_src != TRIG_FOLLOW && 959
982 cmd->scan_begin_src != TRIG_EXT && 960 /* Step 2b : and mutually compatible */
983 cmd->scan_begin_src != TRIG_TIMER)
984 err++;
985 if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE)
986 err++;
987 961
988 if (err) 962 if (err)
989 return 2; 963 return 2;
@@ -1488,8 +1462,9 @@ static int usbdux_ao_inttrig(struct comedi_device *dev,
1488static int usbdux_ao_cmdtest(struct comedi_device *dev, 1462static int usbdux_ao_cmdtest(struct comedi_device *dev,
1489 struct comedi_subdevice *s, struct comedi_cmd *cmd) 1463 struct comedi_subdevice *s, struct comedi_cmd *cmd)
1490{ 1464{
1491 int err = 0, tmp;
1492 struct usbduxsub *this_usbduxsub = dev->private; 1465 struct usbduxsub *this_usbduxsub = dev->private;
1466 int err = 0;
1467 unsigned int flags;
1493 1468
1494 if (!this_usbduxsub) 1469 if (!this_usbduxsub)
1495 return -EFAULT; 1470 return -EFAULT;
@@ -1500,69 +1475,46 @@ static int usbdux_ao_cmdtest(struct comedi_device *dev,
1500 dev_dbg(&this_usbduxsub->interface->dev, 1475 dev_dbg(&this_usbduxsub->interface->dev,
1501 "comedi%d: usbdux_ao_cmdtest\n", dev->minor); 1476 "comedi%d: usbdux_ao_cmdtest\n", dev->minor);
1502 1477
1503 /* make sure triggers are valid */ 1478 /* Step 1 : check if triggers are trivially valid */
1504 /* Only immediate triggers are allowed */ 1479
1505 tmp = cmd->start_src; 1480 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_INT);
1506 cmd->start_src &= TRIG_NOW | TRIG_INT;
1507 if (!cmd->start_src || tmp != cmd->start_src)
1508 err++;
1509 1481
1510 /* trigger should happen timed */
1511 tmp = cmd->scan_begin_src;
1512 /* just now we scan also in the high speed mode every frame */
1513 /* this is due to ehci driver limitations */
1514 if (0) { /* (this_usbduxsub->high_speed) */ 1482 if (0) { /* (this_usbduxsub->high_speed) */
1515 /* start immediately a new scan */
1516 /* the sampling rate is set by the coversion rate */ 1483 /* the sampling rate is set by the coversion rate */
1517 cmd->scan_begin_src &= TRIG_FOLLOW; 1484 flags = TRIG_FOLLOW;
1518 } else { 1485 } else {
1519 /* start a new scan (output at once) with a timer */ 1486 /* start a new scan (output at once) with a timer */
1520 cmd->scan_begin_src &= TRIG_TIMER; 1487 flags = TRIG_TIMER;
1521 } 1488 }
1522 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src) 1489 err |= cfc_check_trigger_src(&cmd->scan_begin_src, flags);
1523 err++;
1524 1490
1525 /* scanning is continuous */
1526 tmp = cmd->convert_src;
1527 /* we always output at 1kHz just now all channels at once */
1528 if (0) { /* (this_usbduxsub->high_speed) */ 1491 if (0) { /* (this_usbduxsub->high_speed) */
1529 /* 1492 /*
1530 * in usb-2.0 only one conversion it transmitted but with 8kHz/n 1493 * in usb-2.0 only one conversion it transmitted
1494 * but with 8kHz/n
1531 */ 1495 */
1532 cmd->convert_src &= TRIG_TIMER; 1496 flags = TRIG_TIMER;
1533 } else { 1497 } else {
1534 /* all conversion events happen simultaneously with a rate of 1498 /*
1535 * 1kHz/n */ 1499 * all conversion events happen simultaneously with
1536 cmd->convert_src &= TRIG_NOW; 1500 * a rate of 1kHz/n
1501 */
1502 flags = TRIG_NOW;
1537 } 1503 }
1538 if (!cmd->convert_src || tmp != cmd->convert_src) 1504 err |= cfc_check_trigger_src(&cmd->convert_src, flags);
1539 err++;
1540
1541 /* issue a trigger when scan is finished and start a new scan */
1542 tmp = cmd->scan_end_src;
1543 cmd->scan_end_src &= TRIG_COUNT;
1544 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
1545 err++;
1546 1505
1547 /* trigger at the end of count events or not, stop condition or not */ 1506 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
1548 tmp = cmd->stop_src; 1507 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
1549 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
1550 if (!cmd->stop_src || tmp != cmd->stop_src)
1551 err++;
1552 1508
1553 if (err) 1509 if (err)
1554 return 1; 1510 return 1;
1555 1511
1556 /* 1512 /* Step 2a : make sure trigger sources are unique */
1557 * step 2: make sure trigger sources are unique and mutually compatible 1513
1558 * note that mutual compatibility is not an issue here 1514 err |= cfc_check_trigger_is_unique(cmd->start_src);
1559 */ 1515 err |= cfc_check_trigger_is_unique(cmd->stop_src);
1560 if (cmd->scan_begin_src != TRIG_FOLLOW && 1516
1561 cmd->scan_begin_src != TRIG_EXT && 1517 /* Step 2b : and mutually compatible */
1562 cmd->scan_begin_src != TRIG_TIMER)
1563 err++;
1564 if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE)
1565 err++;
1566 1518
1567 if (err) 1519 if (err)
1568 return 2; 1520 return 2;
diff --git a/drivers/staging/comedi/drivers/usbduxfast.c b/drivers/staging/comedi/drivers/usbduxfast.c
index 0f6c1392f6ce..1154a7e2895d 100644
--- a/drivers/staging/comedi/drivers/usbduxfast.c
+++ b/drivers/staging/comedi/drivers/usbduxfast.c
@@ -549,10 +549,10 @@ static int usbduxfast_ai_cmdtest(struct comedi_device *dev,
549 struct comedi_subdevice *s, 549 struct comedi_subdevice *s,
550 struct comedi_cmd *cmd) 550 struct comedi_cmd *cmd)
551{ 551{
552 int err = 0, stop_mask = 0; 552 struct usbduxfastsub_s *udfs = dev->private;
553 int err = 0;
553 long int steps, tmp; 554 long int steps, tmp;
554 int minSamplPer; 555 int minSamplPer;
555 struct usbduxfastsub_s *udfs = dev->private;
556 556
557 if (!udfs->probed) 557 if (!udfs->probed)
558 return -ENODEV; 558 return -ENODEV;
@@ -563,57 +563,31 @@ static int usbduxfast_ai_cmdtest(struct comedi_device *dev,
563 "scan_begin_arg=%u\n", 563 "scan_begin_arg=%u\n",
564 dev->minor, cmd->convert_arg, cmd->scan_begin_arg); 564 dev->minor, cmd->convert_arg, cmd->scan_begin_arg);
565#endif 565#endif
566 /* step 1: make sure trigger sources are trivially valid */ 566 /* Step 1 : check if triggers are trivially valid */
567
568 tmp = cmd->start_src;
569 cmd->start_src &= TRIG_NOW | TRIG_EXT | TRIG_INT;
570 if (!cmd->start_src || tmp != cmd->start_src)
571 err++;
572
573 tmp = cmd->scan_begin_src;
574 cmd->scan_begin_src &= TRIG_TIMER | TRIG_FOLLOW | TRIG_EXT;
575 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
576 err++;
577
578 tmp = cmd->convert_src;
579 cmd->convert_src &= TRIG_TIMER | TRIG_EXT;
580 if (!cmd->convert_src || tmp != cmd->convert_src)
581 err++;
582
583 tmp = cmd->scan_end_src;
584 cmd->scan_end_src &= TRIG_COUNT;
585 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
586 err++;
587 567
588 tmp = cmd->stop_src; 568 err |= cfc_check_trigger_src(&cmd->start_src,
589 stop_mask = TRIG_COUNT | TRIG_NONE; 569 TRIG_NOW | TRIG_EXT | TRIG_INT);
590 cmd->stop_src &= stop_mask; 570 err |= cfc_check_trigger_src(&cmd->scan_begin_src,
591 if (!cmd->stop_src || tmp != cmd->stop_src) 571 TRIG_TIMER | TRIG_FOLLOW | TRIG_EXT);
592 err++; 572 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_TIMER | TRIG_EXT);
573 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
574 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
593 575
594 if (err) 576 if (err)
595 return 1; 577 return 1;
596 578
597 /* 579 /* Step 2a : make sure trigger sources are unique */
598 * step 2: make sure trigger sources are unique and mutually compatible
599 */
600 580
601 if (cmd->start_src != TRIG_NOW && 581 err |= cfc_check_trigger_is_unique(cmd->start_src);
602 cmd->start_src != TRIG_EXT && cmd->start_src != TRIG_INT) 582 err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
603 err++; 583 err |= cfc_check_trigger_is_unique(cmd->convert_src);
604 if (cmd->scan_begin_src != TRIG_TIMER && 584 err |= cfc_check_trigger_is_unique(cmd->stop_src);
605 cmd->scan_begin_src != TRIG_FOLLOW && 585
606 cmd->scan_begin_src != TRIG_EXT) 586 /* Step 2b : and mutually compatible */
607 err++;
608 if (cmd->convert_src != TRIG_TIMER && cmd->convert_src != TRIG_EXT)
609 err++;
610 if (cmd->stop_src != TRIG_COUNT &&
611 cmd->stop_src != TRIG_EXT && cmd->stop_src != TRIG_NONE)
612 err++;
613 587
614 /* can't have external stop and start triggers at once */ 588 /* can't have external stop and start triggers at once */
615 if (cmd->start_src == TRIG_EXT && cmd->stop_src == TRIG_EXT) 589 if (cmd->start_src == TRIG_EXT && cmd->stop_src == TRIG_EXT)
616 err++; 590 err |= -EINVAL;
617 591
618 if (err) 592 if (err)
619 return 2; 593 return 2;
diff --git a/drivers/staging/comedi/drivers/usbduxsigma.c b/drivers/staging/comedi/drivers/usbduxsigma.c
index b4ab83f1215f..b1694121f845 100644
--- a/drivers/staging/comedi/drivers/usbduxsigma.c
+++ b/drivers/staging/comedi/drivers/usbduxsigma.c
@@ -897,9 +897,9 @@ static int usbdux_ai_cmdtest(struct comedi_device *dev,
897 struct comedi_subdevice *s, 897 struct comedi_subdevice *s,
898 struct comedi_cmd *cmd) 898 struct comedi_cmd *cmd)
899{ 899{
900 int err = 0, tmp, i;
901 unsigned int tmpTimer;
902 struct usbduxsub *this_usbduxsub = dev->private; 900 struct usbduxsub *this_usbduxsub = dev->private;
901 int err = 0, i;
902 unsigned int tmpTimer;
903 903
904 if (!(this_usbduxsub->probed)) 904 if (!(this_usbduxsub->probed))
905 return -ENODEV; 905 return -ENODEV;
@@ -907,51 +907,23 @@ static int usbdux_ai_cmdtest(struct comedi_device *dev,
907 dev_dbg(&this_usbduxsub->interface->dev, 907 dev_dbg(&this_usbduxsub->interface->dev,
908 "comedi%d: usbdux_ai_cmdtest\n", dev->minor); 908 "comedi%d: usbdux_ai_cmdtest\n", dev->minor);
909 909
910 /* make sure triggers are valid */ 910 /* Step 1 : check if triggers are trivially valid */
911 /* Only immediate triggers are allowed */
912 tmp = cmd->start_src;
913 cmd->start_src &= TRIG_NOW | TRIG_INT;
914 if (!cmd->start_src || tmp != cmd->start_src)
915 err++;
916
917 /* trigger should happen timed */
918 tmp = cmd->scan_begin_src;
919 /* start a new _scan_ with a timer */
920 cmd->scan_begin_src &= TRIG_TIMER;
921 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
922 err++;
923
924 /* scanning is continuous */
925 tmp = cmd->convert_src;
926 cmd->convert_src &= TRIG_NOW;
927 if (!cmd->convert_src || tmp != cmd->convert_src)
928 err++;
929
930 /* issue a trigger when scan is finished and start a new scan */
931 tmp = cmd->scan_end_src;
932 cmd->scan_end_src &= TRIG_COUNT;
933 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
934 err++;
935 911
936 /* trigger at the end of count events or not, stop condition or not */ 912 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_INT);
937 tmp = cmd->stop_src; 913 err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_TIMER);
938 cmd->stop_src &= TRIG_COUNT | TRIG_NONE; 914 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW);
939 if (!cmd->stop_src || tmp != cmd->stop_src) 915 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
940 err++; 916 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
941 917
942 if (err) 918 if (err)
943 return 1; 919 return 1;
944 920
945 /* 921 /* Step 2a : make sure trigger sources are unique */
946 * step 2: make sure trigger sources are unique and mutually compatible 922
947 * note that mutual compatibility is not an issue here 923 err |= cfc_check_trigger_is_unique(cmd->start_src);
948 */ 924 err |= cfc_check_trigger_is_unique(cmd->stop_src);
949 if (cmd->scan_begin_src != TRIG_FOLLOW && 925
950 cmd->scan_begin_src != TRIG_EXT && 926 /* Step 2b : and mutually compatible */
951 cmd->scan_begin_src != TRIG_TIMER)
952 err++;
953 if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE)
954 err++;
955 927
956 if (err) 928 if (err)
957 return 2; 929 return 2;
@@ -1558,8 +1530,9 @@ static int usbdux_ao_cmdtest(struct comedi_device *dev,
1558 struct comedi_subdevice *s, 1530 struct comedi_subdevice *s,
1559 struct comedi_cmd *cmd) 1531 struct comedi_cmd *cmd)
1560{ 1532{
1561 int err = 0, tmp;
1562 struct usbduxsub *this_usbduxsub = dev->private; 1533 struct usbduxsub *this_usbduxsub = dev->private;
1534 int err = 0;
1535 unsigned int flags;
1563 1536
1564 if (!this_usbduxsub) 1537 if (!this_usbduxsub)
1565 return -EFAULT; 1538 return -EFAULT;
@@ -1570,63 +1543,35 @@ static int usbdux_ao_cmdtest(struct comedi_device *dev,
1570 dev_dbg(&this_usbduxsub->interface->dev, 1543 dev_dbg(&this_usbduxsub->interface->dev,
1571 "comedi%d: usbdux_ao_cmdtest\n", dev->minor); 1544 "comedi%d: usbdux_ao_cmdtest\n", dev->minor);
1572 1545
1573 /* make sure triggers are valid */ 1546 /* Step 1 : check if triggers are trivially valid */
1574 /* Only immediate triggers are allowed */ 1547
1575 tmp = cmd->start_src; 1548 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_INT);
1576 cmd->start_src &= TRIG_NOW | TRIG_INT;
1577 if (!cmd->start_src || tmp != cmd->start_src)
1578 err++;
1579 1549
1580 /* trigger should happen timed */
1581 tmp = cmd->scan_begin_src;
1582 /* just now we scan also in the high speed mode every frame */
1583 /* this is due to ehci driver limitations */
1584 if (0) { /* (this_usbduxsub->high_speed) */ 1550 if (0) { /* (this_usbduxsub->high_speed) */
1585 /* start immediately a new scan */ 1551 /*
1586 /* the sampling rate is set by the coversion rate */ 1552 * start immediately a new scan
1587 cmd->scan_begin_src &= TRIG_FOLLOW; 1553 * the sampling rate is set by the coversion rate
1554 */
1555 flags = TRIG_FOLLOW;
1588 } else { 1556 } else {
1589 /* start a new scan (output at once) with a timer */ 1557 /* start a new scan (output at once) with a timer */
1590 cmd->scan_begin_src &= TRIG_TIMER; 1558 flags = TRIG_TIMER;
1591 } 1559 }
1592 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src) 1560 err |= cfc_check_trigger_src(&cmd->scan_begin_src, flags);
1593 err++;
1594
1595 /* scanning is continuous */
1596 tmp = cmd->convert_src;
1597 1561
1598 /* all conversion events happen simultaneously */ 1562 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW);
1599 cmd->convert_src &= TRIG_NOW; 1563 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
1600 1564 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
1601 if (!cmd->convert_src || tmp != cmd->convert_src)
1602 err++;
1603
1604 /* issue a trigger when scan is finished and start a new scan */
1605 tmp = cmd->scan_end_src;
1606 cmd->scan_end_src &= TRIG_COUNT;
1607 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
1608 err++;
1609
1610 /* trigger at the end of count events or not, stop condition or not */
1611 tmp = cmd->stop_src;
1612 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
1613 if (!cmd->stop_src || tmp != cmd->stop_src)
1614 err++;
1615 1565
1616 if (err) 1566 if (err)
1617 return 1; 1567 return 1;
1618 1568
1619 /* 1569 /* Step 2a : make sure trigger sources are unique */
1620 * step 2: make sure trigger sources 1570
1621 * are unique and mutually compatible 1571 err |= cfc_check_trigger_is_unique(cmd->start_src);
1622 * note that mutual compatibility is not an issue here 1572 err |= cfc_check_trigger_is_unique(cmd->stop_src);
1623 */ 1573
1624 if (cmd->scan_begin_src != TRIG_FOLLOW && 1574 /* Step 2b : and mutually compatible */
1625 cmd->scan_begin_src != TRIG_EXT &&
1626 cmd->scan_begin_src != TRIG_TIMER)
1627 err++;
1628 if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE)
1629 err++;
1630 1575
1631 if (err) 1576 if (err)
1632 return 2; 1577 return 2;
generated by cgit v1.2.2 (git 2.25.0) at 2025-08-23 15:46:17 -0400