aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
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 2026-01-03 01:40:47 -0500