staging: comedi: adl_pci9111: fix incorrect irq passed to request_irq()
[firefly-linux-kernel-4.4.55.git] / drivers / staging / comedi / drivers / addi-data / APCI1710_Pwm.c
1 /**
2 @verbatim
3
4 Copyright (C) 2004,2005  ADDI-DATA GmbH for the source code of this module.
5
6         ADDI-DATA GmbH
7         Dieselstrasse 3
8         D-77833 Ottersweier
9         Tel: +19(0)7223/9493-0
10         Fax: +49(0)7223/9493-92
11         http://www.addi-data.com
12         info@addi-data.com
13
14 This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.
15
16 This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19
20 You should also find the complete GPL in the COPYING file accompanying this source code.
21
22 @endverbatim
23 */
24 /*
25
26   +-----------------------------------------------------------------------+
27   | (C) ADDI-DATA GmbH          Dieselstraße 3       D-77833 Ottersweier  |
28   +-----------------------------------------------------------------------+
29   | Tel : +49 (0) 7223/9493-0     | email    : info@addi-data.com         |
30   | Fax : +49 (0) 7223/9493-92    | Internet : http://www.addi-data.com   |
31   +-----------------------------------------------------------------------+
32   | Project     : API APCI1710    | Compiler : gcc                        |
33   | Module name : PWM.C           | Version  : 2.96                       |
34   +-------------------------------+---------------------------------------+
35   | Project manager: Eric Stolz   | Date     :  02/12/2002                |
36   +-----------------------------------------------------------------------+
37   | Description :   APCI-1710 Wulse wide modulation module                |
38   |                                                                       |
39   |                                                                       |
40   +-----------------------------------------------------------------------+
41   |                             UPDATES                                   |
42   +-----------------------------------------------------------------------+
43   |   Date   |   Author  |          Description of updates                |
44   +-----------------------------------------------------------------------+
45   | 08/05/00 | Guinot C  | - 0400/0228 All Function in RING 0             |
46   |          |           |   available                                    |
47   +-----------------------------------------------------------------------+
48 */
49
50 #define APCI1710_30MHZ                  30
51 #define APCI1710_33MHZ                  33
52 #define APCI1710_40MHZ                  40
53
54 #define APCI1710_PWM_INIT               0
55 #define APCI1710_PWM_GETINITDATA        1
56
57 #define APCI1710_PWM_DISABLE            0
58 #define APCI1710_PWM_ENABLE             1
59 #define APCI1710_PWM_NEWTIMING          2
60
61 /*
62 +----------------------------------------------------------------------------+
63 | Function Name     : _INT_ i_APCI1710_InitPWM                               |
64 |                                       (unsigned char_     b_BoardHandle,            |
65 |                                        unsigned char_     b_ModulNbr,               |
66 |                                        unsigned char_     b_PWM,                    |
67 |                                        unsigned char_     b_ClockSelection,         |
68 |                                        unsigned char_     b_TimingUnit,             |
69 |                                        ULONG_   ul_LowTiming,              |
70 |                                        ULONG_   ul_HighTiming,             |
71 |                                        PULONG_ pul_RealLowTiming,          |
72 |                                        PULONG_ pul_RealHighTiming)         |
73 +----------------------------------------------------------------------------+
74 | Task              : Configure the selected PWM (b_PWM) from selected module|
75 |                     (b_ModulNbr). The ul_LowTiming, ul_HighTiming and      |
76 |                     ul_TimingUnit determine the low/high timing base for   |
77 |                     the period. pul_RealLowTiming, pul_RealHighTiming      |
78 |                     return the real timing value.                          |
79 |                     You must calling this function be for you call any     |
80 |                     other function witch access of the PWM.                |
81 +----------------------------------------------------------------------------+
82 | Input Parameters  : unsigned char_     b_BoardHandle    : Handle of board APCI-1710 |
83 |                     unsigned char_     b_ModulNbr       : Module number to configure|
84 |                                                  (0 to 3)                  |
85 |                     unsigned char_     b_PWM            : Selected PWM (0 or 1).    |
86 |                     unsigned char_     b_ClockSelection : Selection from PCI bus    |
87 |                                                  clock                     |
88 |                                                   - APCI1710_30MHZ :       |
89 |                                                     The PC have a 30 MHz   |
90 |                                                     PCI bus clock          |
91 |                                                   - APCI1710_33MHZ :       |
92 |                                                     The PC have a 33 MHz   |
93 |                                                     PCI bus clock          |
94 |                                                   - APCI1710_40MHZ         |
95 |                                                     The APCI-1710 have a   |
96 |                                                     integrated 40Mhz       |
97 |                                                     quartz.                |
98 |                     unsigned char_     b_TimingUnit     : Base timing Unit (0 to 4) |
99 |                                                       0 : ns               |
100 |                                                       1 : æs               |
101 |                                                       2 : ms               |
102 |                                                       3 : s                |
103 |                                                       4 : mn               |
104 |                     ULONG_    ul_LowTiming     : Low base timing value.    |
105 |                     ULONG_    ul_HighTiming    : High base timing value.   |
106 +----------------------------------------------------------------------------+
107 | Output Parameters : PULONG_  pul_RealLowTiming  : Real low base timing     |
108 |                                                   value.                   |
109 |                     PULONG_  pul_RealHighTiming : Real high base timing    |
110 |                                                   value.                   |
111 +----------------------------------------------------------------------------+
112 | Return Value      : 0: No error                                            |
113 |                    -1: The handle parameter of the board is wrong          |
114 |                    -2: Module selection wrong                              |
115 |                    -3: The module is not a PWM module                      |
116 |                    -4: PWM selection is wrong                              |
117 |                    -5: The selected input clock is wrong                   |
118 |                    -6: Timing Unit selection is wrong                      |
119 |                    -7: Low base timing selection is wrong                  |
120 |                    -8: High base timing selection is wrong                 |
121 |                    -9: You can not used the 40MHz clock selection with     |
122 |                        this board                                          |
123 +----------------------------------------------------------------------------+
124 */
125 static int i_APCI1710_InitPWM(struct comedi_device *dev,
126                               unsigned char b_ModulNbr,
127                               unsigned char b_PWM,
128                               unsigned char b_ClockSelection,
129                               unsigned char b_TimingUnit,
130                               unsigned int ul_LowTiming,
131                               unsigned int ul_HighTiming,
132                               unsigned int *pul_RealLowTiming,
133                               unsigned int *pul_RealHighTiming)
134 {
135         struct addi_private *devpriv = dev->private;
136         int i_ReturnValue = 0;
137         unsigned int ul_LowTimerValue = 0;
138         unsigned int ul_HighTimerValue = 0;
139         unsigned int dw_Command;
140         double d_RealLowTiming = 0;
141         double d_RealHighTiming = 0;
142
143         /**************************/
144         /* Test the module number */
145         /**************************/
146
147         if (b_ModulNbr < 4) {
148                 /***************/
149                 /* Test if PWM */
150                 /***************/
151
152                 if ((devpriv->s_BoardInfos.
153                                 dw_MolduleConfiguration[b_ModulNbr] &
154                                 0xFFFF0000UL) == APCI1710_PWM) {
155                         /**************************/
156                         /* Test the PWM selection */
157                         /**************************/
158
159                         if (b_PWM <= 1) {
160                                 /******************/
161                                 /* Test the clock */
162                                 /******************/
163
164                                 if ((b_ClockSelection == APCI1710_30MHZ) ||
165                                         (b_ClockSelection == APCI1710_33MHZ) ||
166                                         (b_ClockSelection == APCI1710_40MHZ)) {
167                                         /************************/
168                                         /* Test the timing unit */
169                                         /************************/
170
171                                         if (b_TimingUnit <= 4) {
172                                                 /*********************************/
173                                                 /* Test the low timing selection */
174                                                 /*********************************/
175
176                                                 if (((b_ClockSelection ==
177                                                                         APCI1710_30MHZ)
178                                                                 && (b_TimingUnit
179                                                                         == 0)
180                                                                 && (ul_LowTiming
181                                                                         >= 266)
182                                                                 && (ul_LowTiming
183                                                                         <=
184                                                                         0xFFFFFFFFUL))
185                                                         || ((b_ClockSelection ==
186                                                                         APCI1710_30MHZ)
187                                                                 && (b_TimingUnit
188                                                                         == 1)
189                                                                 && (ul_LowTiming
190                                                                         >= 1)
191                                                                 && (ul_LowTiming
192                                                                         <=
193                                                                         571230650UL))
194                                                         || ((b_ClockSelection ==
195                                                                         APCI1710_30MHZ)
196                                                                 && (b_TimingUnit
197                                                                         == 2)
198                                                                 && (ul_LowTiming
199                                                                         >= 1)
200                                                                 && (ul_LowTiming
201                                                                         <=
202                                                                         571230UL))
203                                                         || ((b_ClockSelection ==
204                                                                         APCI1710_30MHZ)
205                                                                 && (b_TimingUnit
206                                                                         == 3)
207                                                                 && (ul_LowTiming
208                                                                         >= 1)
209                                                                 && (ul_LowTiming
210                                                                         <=
211                                                                         571UL))
212                                                         || ((b_ClockSelection ==
213                                                                         APCI1710_30MHZ)
214                                                                 && (b_TimingUnit
215                                                                         == 4)
216                                                                 && (ul_LowTiming
217                                                                         >= 1)
218                                                                 && (ul_LowTiming
219                                                                         <= 9UL))
220                                                         || ((b_ClockSelection ==
221                                                                         APCI1710_33MHZ)
222                                                                 && (b_TimingUnit
223                                                                         == 0)
224                                                                 && (ul_LowTiming
225                                                                         >= 242)
226                                                                 && (ul_LowTiming
227                                                                         <=
228                                                                         0xFFFFFFFFUL))
229                                                         || ((b_ClockSelection ==
230                                                                         APCI1710_33MHZ)
231                                                                 && (b_TimingUnit
232                                                                         == 1)
233                                                                 && (ul_LowTiming
234                                                                         >= 1)
235                                                                 && (ul_LowTiming
236                                                                         <=
237                                                                         519691043UL))
238                                                         || ((b_ClockSelection ==
239                                                                         APCI1710_33MHZ)
240                                                                 && (b_TimingUnit
241                                                                         == 2)
242                                                                 && (ul_LowTiming
243                                                                         >= 1)
244                                                                 && (ul_LowTiming
245                                                                         <=
246                                                                         519691UL))
247                                                         || ((b_ClockSelection ==
248                                                                         APCI1710_33MHZ)
249                                                                 && (b_TimingUnit
250                                                                         == 3)
251                                                                 && (ul_LowTiming
252                                                                         >= 1)
253                                                                 && (ul_LowTiming
254                                                                         <=
255                                                                         520UL))
256                                                         || ((b_ClockSelection ==
257                                                                         APCI1710_33MHZ)
258                                                                 && (b_TimingUnit
259                                                                         == 4)
260                                                                 && (ul_LowTiming
261                                                                         >= 1)
262                                                                 && (ul_LowTiming
263                                                                         <= 8UL))
264                                                         || ((b_ClockSelection ==
265                                                                         APCI1710_40MHZ)
266                                                                 && (b_TimingUnit
267                                                                         == 0)
268                                                                 && (ul_LowTiming
269                                                                         >= 200)
270                                                                 && (ul_LowTiming
271                                                                         <=
272                                                                         0xFFFFFFFFUL))
273                                                         || ((b_ClockSelection ==
274                                                                         APCI1710_40MHZ)
275                                                                 && (b_TimingUnit
276                                                                         == 1)
277                                                                 && (ul_LowTiming
278                                                                         >= 1)
279                                                                 && (ul_LowTiming
280                                                                         <=
281                                                                         429496729UL))
282                                                         || ((b_ClockSelection ==
283                                                                         APCI1710_40MHZ)
284                                                                 && (b_TimingUnit
285                                                                         == 2)
286                                                                 && (ul_LowTiming
287                                                                         >= 1)
288                                                                 && (ul_LowTiming
289                                                                         <=
290                                                                         429496UL))
291                                                         || ((b_ClockSelection ==
292                                                                         APCI1710_40MHZ)
293                                                                 && (b_TimingUnit
294                                                                         == 3)
295                                                                 && (ul_LowTiming
296                                                                         >= 1)
297                                                                 && (ul_LowTiming
298                                                                         <=
299                                                                         429UL))
300                                                         || ((b_ClockSelection ==
301                                                                         APCI1710_40MHZ)
302                                                                 && (b_TimingUnit
303                                                                         == 4)
304                                                                 && (ul_LowTiming
305                                                                         >= 1)
306                                                                 && (ul_LowTiming
307                                                                         <=
308                                                                         7UL))) {
309                                                         /**********************************/
310                                                         /* Test the High timing selection */
311                                                         /**********************************/
312
313                                                         if (((b_ClockSelection == APCI1710_30MHZ) && (b_TimingUnit == 0) && (ul_HighTiming >= 266) && (ul_HighTiming <= 0xFFFFFFFFUL)) || ((b_ClockSelection == APCI1710_30MHZ) && (b_TimingUnit == 1) && (ul_HighTiming >= 1) && (ul_HighTiming <= 571230650UL)) || ((b_ClockSelection == APCI1710_30MHZ) && (b_TimingUnit == 2) && (ul_HighTiming >= 1) && (ul_HighTiming <= 571230UL)) || ((b_ClockSelection == APCI1710_30MHZ) && (b_TimingUnit == 3) && (ul_HighTiming >= 1) && (ul_HighTiming <= 571UL)) || ((b_ClockSelection == APCI1710_30MHZ) && (b_TimingUnit == 4) && (ul_HighTiming >= 1) && (ul_HighTiming <= 9UL)) || ((b_ClockSelection == APCI1710_33MHZ) && (b_TimingUnit == 0) && (ul_HighTiming >= 242) && (ul_HighTiming <= 0xFFFFFFFFUL)) || ((b_ClockSelection == APCI1710_33MHZ) && (b_TimingUnit == 1) && (ul_HighTiming >= 1) && (ul_HighTiming <= 519691043UL)) || ((b_ClockSelection == APCI1710_33MHZ) && (b_TimingUnit == 2) && (ul_HighTiming >= 1) && (ul_HighTiming <= 519691UL)) || ((b_ClockSelection == APCI1710_33MHZ) && (b_TimingUnit == 3) && (ul_HighTiming >= 1) && (ul_HighTiming <= 520UL)) || ((b_ClockSelection == APCI1710_33MHZ) && (b_TimingUnit == 4) && (ul_HighTiming >= 1) && (ul_HighTiming <= 8UL)) || ((b_ClockSelection == APCI1710_40MHZ) && (b_TimingUnit == 0) && (ul_HighTiming >= 200) && (ul_HighTiming <= 0xFFFFFFFFUL)) || ((b_ClockSelection == APCI1710_40MHZ) && (b_TimingUnit == 1) && (ul_HighTiming >= 1) && (ul_HighTiming <= 429496729UL)) || ((b_ClockSelection == APCI1710_40MHZ) && (b_TimingUnit == 2) && (ul_HighTiming >= 1) && (ul_HighTiming <= 429496UL)) || ((b_ClockSelection == APCI1710_40MHZ) && (b_TimingUnit == 3) && (ul_HighTiming >= 1) && (ul_HighTiming <= 429UL)) || ((b_ClockSelection == APCI1710_40MHZ) && (b_TimingUnit == 4) && (ul_HighTiming >= 1) && (ul_HighTiming <= 7UL))) {
314                                                                 /**************************/
315                                                                 /* Test the board version */
316                                                                 /**************************/
317
318                                                                 if (((b_ClockSelection == APCI1710_40MHZ) && (devpriv->s_BoardInfos.b_BoardVersion > 0)) || (b_ClockSelection != APCI1710_40MHZ)) {
319
320                                                                         /************************************/
321                                                                         /* Calculate the low division fator */
322                                                                         /************************************/
323
324                                                                         fpu_begin
325                                                                                 ();
326
327                                                                         switch (b_TimingUnit) {
328                                                                                 /******/
329                                                                                 /* ns */
330                                                                                 /******/
331
332                                                                         case 0:
333
334                                                                                 /******************/
335                                                                                 /* Timer 0 factor */
336                                                                                 /******************/
337
338                                                                                 ul_LowTimerValue
339                                                                                         =
340                                                                                         (unsigned int)
341                                                                                         (ul_LowTiming
342                                                                                         *
343                                                                                         (0.00025 * b_ClockSelection));
344
345                                                                                 /*******************/
346                                                                                 /* Round the value */
347                                                                                 /*******************/
348
349                                                                                 if ((double)((double)ul_LowTiming * (0.00025 * (double)b_ClockSelection)) >= ((double)((double)ul_LowTimerValue + 0.5))) {
350                                                                                         ul_LowTimerValue
351                                                                                                 =
352                                                                                                 ul_LowTimerValue
353                                                                                                 +
354                                                                                                 1;
355                                                                                 }
356
357                                                                                 /*****************************/
358                                                                                 /* Calculate the real timing */
359                                                                                 /*****************************/
360
361                                                                                 *pul_RealLowTiming
362                                                                                         =
363                                                                                         (unsigned int)
364                                                                                         (ul_LowTimerValue
365                                                                                         /
366                                                                                         (0.00025 * (double)b_ClockSelection));
367                                                                                 d_RealLowTiming
368                                                                                         =
369                                                                                         (double)
370                                                                                         ul_LowTimerValue
371                                                                                         /
372                                                                                         (0.00025
373                                                                                         *
374                                                                                         (double)
375                                                                                         b_ClockSelection);
376
377                                                                                 if ((double)((double)ul_LowTimerValue / (0.00025 * (double)b_ClockSelection)) >= (double)((double)*pul_RealLowTiming + 0.5)) {
378                                                                                         *pul_RealLowTiming
379                                                                                                 =
380                                                                                                 *pul_RealLowTiming
381                                                                                                 +
382                                                                                                 1;
383                                                                                 }
384
385                                                                                 ul_LowTiming
386                                                                                         =
387                                                                                         ul_LowTiming
388                                                                                         -
389                                                                                         1;
390                                                                                 ul_LowTimerValue
391                                                                                         =
392                                                                                         ul_LowTimerValue
393                                                                                         -
394                                                                                         2;
395
396                                                                                 if (b_ClockSelection != APCI1710_40MHZ) {
397                                                                                         ul_LowTimerValue
398                                                                                                 =
399                                                                                                 (unsigned int)
400                                                                                                 (
401                                                                                                 (double)
402                                                                                                 (ul_LowTimerValue)
403                                                                                                 *
404                                                                                                 1.007752288);
405                                                                                 }
406
407                                                                                 break;
408
409                                                                                 /******/
410                                                                                 /* æs */
411                                                                                 /******/
412
413                                                                         case 1:
414
415                                                                                 /******************/
416                                                                                 /* Timer 0 factor */
417                                                                                 /******************/
418
419                                                                                 ul_LowTimerValue
420                                                                                         =
421                                                                                         (unsigned int)
422                                                                                         (ul_LowTiming
423                                                                                         *
424                                                                                         (0.25 * b_ClockSelection));
425
426                                                                                 /*******************/
427                                                                                 /* Round the value */
428                                                                                 /*******************/
429
430                                                                                 if ((double)((double)ul_LowTiming * (0.25 * (double)b_ClockSelection)) >= ((double)((double)ul_LowTimerValue + 0.5))) {
431                                                                                         ul_LowTimerValue
432                                                                                                 =
433                                                                                                 ul_LowTimerValue
434                                                                                                 +
435                                                                                                 1;
436                                                                                 }
437
438                                                                                 /*****************************/
439                                                                                 /* Calculate the real timing */
440                                                                                 /*****************************/
441
442                                                                                 *pul_RealLowTiming
443                                                                                         =
444                                                                                         (unsigned int)
445                                                                                         (ul_LowTimerValue
446                                                                                         /
447                                                                                         (0.25 * (double)b_ClockSelection));
448                                                                                 d_RealLowTiming
449                                                                                         =
450                                                                                         (double)
451                                                                                         ul_LowTimerValue
452                                                                                         /
453                                                                                         (
454                                                                                         (double)
455                                                                                         0.25
456                                                                                         *
457                                                                                         (double)
458                                                                                         b_ClockSelection);
459
460                                                                                 if ((double)((double)ul_LowTimerValue / (0.25 * (double)b_ClockSelection)) >= (double)((double)*pul_RealLowTiming + 0.5)) {
461                                                                                         *pul_RealLowTiming
462                                                                                                 =
463                                                                                                 *pul_RealLowTiming
464                                                                                                 +
465                                                                                                 1;
466                                                                                 }
467
468                                                                                 ul_LowTiming
469                                                                                         =
470                                                                                         ul_LowTiming
471                                                                                         -
472                                                                                         1;
473                                                                                 ul_LowTimerValue
474                                                                                         =
475                                                                                         ul_LowTimerValue
476                                                                                         -
477                                                                                         2;
478
479                                                                                 if (b_ClockSelection != APCI1710_40MHZ) {
480                                                                                         ul_LowTimerValue
481                                                                                                 =
482                                                                                                 (unsigned int)
483                                                                                                 (
484                                                                                                 (double)
485                                                                                                 (ul_LowTimerValue)
486                                                                                                 *
487                                                                                                 1.007752288);
488                                                                                 }
489
490                                                                                 break;
491
492                                                                                 /******/
493                                                                                 /* ms */
494                                                                                 /******/
495
496                                                                         case 2:
497
498                                                                                 /******************/
499                                                                                 /* Timer 0 factor */
500                                                                                 /******************/
501
502                                                                                 ul_LowTimerValue
503                                                                                         =
504                                                                                         ul_LowTiming
505                                                                                         *
506                                                                                         (250.0
507                                                                                         *
508                                                                                         b_ClockSelection);
509
510                                                                                 /*******************/
511                                                                                 /* Round the value */
512                                                                                 /*******************/
513
514                                                                                 if ((double)((double)ul_LowTiming * (250.0 * (double)b_ClockSelection)) >= ((double)((double)ul_LowTimerValue + 0.5))) {
515                                                                                         ul_LowTimerValue
516                                                                                                 =
517                                                                                                 ul_LowTimerValue
518                                                                                                 +
519                                                                                                 1;
520                                                                                 }
521
522                                                                                 /*****************************/
523                                                                                 /* Calculate the real timing */
524                                                                                 /*****************************/
525
526                                                                                 *pul_RealLowTiming
527                                                                                         =
528                                                                                         (unsigned int)
529                                                                                         (ul_LowTimerValue
530                                                                                         /
531                                                                                         (250.0 * (double)b_ClockSelection));
532                                                                                 d_RealLowTiming
533                                                                                         =
534                                                                                         (double)
535                                                                                         ul_LowTimerValue
536                                                                                         /
537                                                                                         (250.0
538                                                                                         *
539                                                                                         (double)
540                                                                                         b_ClockSelection);
541
542                                                                                 if ((double)((double)ul_LowTimerValue / (250.0 * (double)b_ClockSelection)) >= (double)((double)*pul_RealLowTiming + 0.5)) {
543                                                                                         *pul_RealLowTiming
544                                                                                                 =
545                                                                                                 *pul_RealLowTiming
546                                                                                                 +
547                                                                                                 1;
548                                                                                 }
549
550                                                                                 ul_LowTiming
551                                                                                         =
552                                                                                         ul_LowTiming
553                                                                                         -
554                                                                                         1;
555                                                                                 ul_LowTimerValue
556                                                                                         =
557                                                                                         ul_LowTimerValue
558                                                                                         -
559                                                                                         2;
560
561                                                                                 if (b_ClockSelection != APCI1710_40MHZ) {
562                                                                                         ul_LowTimerValue
563                                                                                                 =
564                                                                                                 (unsigned int)
565                                                                                                 (
566                                                                                                 (double)
567                                                                                                 (ul_LowTimerValue)
568                                                                                                 *
569                                                                                                 1.007752288);
570                                                                                 }
571
572                                                                                 break;
573
574                                                                                 /*****/
575                                                                                 /* s */
576                                                                                 /*****/
577
578                                                                         case 3:
579                                                                                 /******************/
580                                                                                 /* Timer 0 factor */
581                                                                                 /******************/
582
583                                                                                 ul_LowTimerValue
584                                                                                         =
585                                                                                         (unsigned int)
586                                                                                         (ul_LowTiming
587                                                                                         *
588                                                                                         (250000.0
589                                                                                                 *
590                                                                                                 b_ClockSelection));
591
592                                                                                 /*******************/
593                                                                                 /* Round the value */
594                                                                                 /*******************/
595
596                                                                                 if ((double)((double)ul_LowTiming * (250000.0 * (double)b_ClockSelection)) >= ((double)((double)ul_LowTimerValue + 0.5))) {
597                                                                                         ul_LowTimerValue
598                                                                                                 =
599                                                                                                 ul_LowTimerValue
600                                                                                                 +
601                                                                                                 1;
602                                                                                 }
603
604                                                                                 /*****************************/
605                                                                                 /* Calculate the real timing */
606                                                                                 /*****************************/
607
608                                                                                 *pul_RealLowTiming
609                                                                                         =
610                                                                                         (unsigned int)
611                                                                                         (ul_LowTimerValue
612                                                                                         /
613                                                                                         (250000.0
614                                                                                                 *
615                                                                                                 (double)
616                                                                                                 b_ClockSelection));
617                                                                                 d_RealLowTiming
618                                                                                         =
619                                                                                         (double)
620                                                                                         ul_LowTimerValue
621                                                                                         /
622                                                                                         (250000.0
623                                                                                         *
624                                                                                         (double)
625                                                                                         b_ClockSelection);
626
627                                                                                 if ((double)((double)ul_LowTimerValue / (250000.0 * (double)b_ClockSelection)) >= (double)((double)*pul_RealLowTiming + 0.5)) {
628                                                                                         *pul_RealLowTiming
629                                                                                                 =
630                                                                                                 *pul_RealLowTiming
631                                                                                                 +
632                                                                                                 1;
633                                                                                 }
634
635                                                                                 ul_LowTiming
636                                                                                         =
637                                                                                         ul_LowTiming
638                                                                                         -
639                                                                                         1;
640                                                                                 ul_LowTimerValue
641                                                                                         =
642                                                                                         ul_LowTimerValue
643                                                                                         -
644                                                                                         2;
645
646                                                                                 if (b_ClockSelection != APCI1710_40MHZ) {
647                                                                                         ul_LowTimerValue
648                                                                                                 =
649                                                                                                 (unsigned int)
650                                                                                                 (
651                                                                                                 (double)
652                                                                                                 (ul_LowTimerValue)
653                                                                                                 *
654                                                                                                 1.007752288);
655                                                                                 }
656
657                                                                                 break;
658
659                                                                                 /******/
660                                                                                 /* mn */
661                                                                                 /******/
662
663                                                                         case 4:
664
665                                                                                 /******************/
666                                                                                 /* Timer 0 factor */
667                                                                                 /******************/
668
669                                                                                 ul_LowTimerValue
670                                                                                         =
671                                                                                         (unsigned int)
672                                                                                         (
673                                                                                         (ul_LowTiming
674                                                                                                 *
675                                                                                                 60)
676                                                                                         *
677                                                                                         (250000.0
678                                                                                                 *
679                                                                                                 b_ClockSelection));
680
681                                                                                 /*******************/
682                                                                                 /* Round the value */
683                                                                                 /*******************/
684
685                                                                                 if ((double)((double)(ul_LowTiming * 60.0) * (250000.0 * (double)b_ClockSelection)) >= ((double)((double)ul_LowTimerValue + 0.5))) {
686                                                                                         ul_LowTimerValue
687                                                                                                 =
688                                                                                                 ul_LowTimerValue
689                                                                                                 +
690                                                                                                 1;
691                                                                                 }
692
693                                                                                 /*****************************/
694                                                                                 /* Calculate the real timing */
695                                                                                 /*****************************/
696
697                                                                                 *pul_RealLowTiming
698                                                                                         =
699                                                                                         (unsigned int)
700                                                                                         (ul_LowTimerValue
701                                                                                         /
702                                                                                         (250000.0
703                                                                                                 *
704                                                                                                 (double)
705                                                                                                 b_ClockSelection))
706                                                                                         /
707                                                                                         60;
708                                                                                 d_RealLowTiming
709                                                                                         =
710                                                                                         (
711                                                                                         (double)
712                                                                                         ul_LowTimerValue
713                                                                                         /
714                                                                                         (250000.0
715                                                                                                 *
716                                                                                                 (double)
717                                                                                                 b_ClockSelection))
718                                                                                         /
719                                                                                         60.0;
720
721                                                                                 if ((double)(((double)ul_LowTimerValue / (250000.0 * (double)b_ClockSelection)) / 60.0) >= (double)((double)*pul_RealLowTiming + 0.5)) {
722                                                                                         *pul_RealLowTiming
723                                                                                                 =
724                                                                                                 *pul_RealLowTiming
725                                                                                                 +
726                                                                                                 1;
727                                                                                 }
728
729                                                                                 ul_LowTiming
730                                                                                         =
731                                                                                         ul_LowTiming
732                                                                                         -
733                                                                                         1;
734                                                                                 ul_LowTimerValue
735                                                                                         =
736                                                                                         ul_LowTimerValue
737                                                                                         -
738                                                                                         2;
739
740                                                                                 if (b_ClockSelection != APCI1710_40MHZ) {
741                                                                                         ul_LowTimerValue
742                                                                                                 =
743                                                                                                 (unsigned int)
744                                                                                                 (
745                                                                                                 (double)
746                                                                                                 (ul_LowTimerValue)
747                                                                                                 *
748                                                                                                 1.007752288);
749                                                                                 }
750
751                                                                                 break;
752                                                                         }
753
754                                                                         /*************************************/
755                                                                         /* Calculate the high division fator */
756                                                                         /*************************************/
757
758                                                                         switch (b_TimingUnit) {
759                                                                                 /******/
760                                                                                 /* ns */
761                                                                                 /******/
762
763                                                                         case 0:
764
765                                                                                 /******************/
766                                                                                 /* Timer 0 factor */
767                                                                                 /******************/
768
769                                                                                 ul_HighTimerValue
770                                                                                         =
771                                                                                         (unsigned int)
772                                                                                         (ul_HighTiming
773                                                                                         *
774                                                                                         (0.00025 * b_ClockSelection));
775
776                                                                                 /*******************/
777                                                                                 /* Round the value */
778                                                                                 /*******************/
779
780                                                                                 if ((double)((double)ul_HighTiming * (0.00025 * (double)b_ClockSelection)) >= ((double)((double)ul_HighTimerValue + 0.5))) {
781                                                                                         ul_HighTimerValue
782                                                                                                 =
783                                                                                                 ul_HighTimerValue
784                                                                                                 +
785                                                                                                 1;
786                                                                                 }
787
788                                                                                 /*****************************/
789                                                                                 /* Calculate the real timing */
790                                                                                 /*****************************/
791
792                                                                                 *pul_RealHighTiming
793                                                                                         =
794                                                                                         (unsigned int)
795                                                                                         (ul_HighTimerValue
796                                                                                         /
797                                                                                         (0.00025 * (double)b_ClockSelection));
798                                                                                 d_RealHighTiming
799                                                                                         =
800                                                                                         (double)
801                                                                                         ul_HighTimerValue
802                                                                                         /
803                                                                                         (0.00025
804                                                                                         *
805                                                                                         (double)
806                                                                                         b_ClockSelection);
807
808                                                                                 if ((double)((double)ul_HighTimerValue / (0.00025 * (double)b_ClockSelection)) >= (double)((double)*pul_RealHighTiming + 0.5)) {
809                                                                                         *pul_RealHighTiming
810                                                                                                 =
811                                                                                                 *pul_RealHighTiming
812                                                                                                 +
813                                                                                                 1;
814                                                                                 }
815
816                                                                                 ul_HighTiming
817                                                                                         =
818                                                                                         ul_HighTiming
819                                                                                         -
820                                                                                         1;
821                                                                                 ul_HighTimerValue
822                                                                                         =
823                                                                                         ul_HighTimerValue
824                                                                                         -
825                                                                                         2;
826
827                                                                                 if (b_ClockSelection != APCI1710_40MHZ) {
828                                                                                         ul_HighTimerValue
829                                                                                                 =
830                                                                                                 (unsigned int)
831                                                                                                 (
832                                                                                                 (double)
833                                                                                                 (ul_HighTimerValue)
834                                                                                                 *
835                                                                                                 1.007752288);
836                                                                                 }
837
838                                                                                 break;
839
840                                                                                 /******/
841                                                                                 /* æs */
842                                                                                 /******/
843
844                                                                         case 1:
845
846                                                                                 /******************/
847                                                                                 /* Timer 0 factor */
848                                                                                 /******************/
849
850                                                                                 ul_HighTimerValue
851                                                                                         =
852                                                                                         (unsigned int)
853                                                                                         (ul_HighTiming
854                                                                                         *
855                                                                                         (0.25 * b_ClockSelection));
856
857                                                                                 /*******************/
858                                                                                 /* Round the value */
859                                                                                 /*******************/
860
861                                                                                 if ((double)((double)ul_HighTiming * (0.25 * (double)b_ClockSelection)) >= ((double)((double)ul_HighTimerValue + 0.5))) {
862                                                                                         ul_HighTimerValue
863                                                                                                 =
864                                                                                                 ul_HighTimerValue
865                                                                                                 +
866                                                                                                 1;
867                                                                                 }
868
869                                                                                 /*****************************/
870                                                                                 /* Calculate the real timing */
871                                                                                 /*****************************/
872
873                                                                                 *pul_RealHighTiming
874                                                                                         =
875                                                                                         (unsigned int)
876                                                                                         (ul_HighTimerValue
877                                                                                         /
878                                                                                         (0.25 * (double)b_ClockSelection));
879                                                                                 d_RealHighTiming
880                                                                                         =
881                                                                                         (double)
882                                                                                         ul_HighTimerValue
883                                                                                         /
884                                                                                         (
885                                                                                         (double)
886                                                                                         0.25
887                                                                                         *
888                                                                                         (double)
889                                                                                         b_ClockSelection);
890
891                                                                                 if ((double)((double)ul_HighTimerValue / (0.25 * (double)b_ClockSelection)) >= (double)((double)*pul_RealHighTiming + 0.5)) {
892                                                                                         *pul_RealHighTiming
893                                                                                                 =
894                                                                                                 *pul_RealHighTiming
895                                                                                                 +
896                                                                                                 1;
897                                                                                 }
898
899                                                                                 ul_HighTiming
900                                                                                         =
901                                                                                         ul_HighTiming
902                                                                                         -
903                                                                                         1;
904                                                                                 ul_HighTimerValue
905                                                                                         =
906                                                                                         ul_HighTimerValue
907                                                                                         -
908                                                                                         2;
909
910                                                                                 if (b_ClockSelection != APCI1710_40MHZ) {
911                                                                                         ul_HighTimerValue
912                                                                                                 =
913                                                                                                 (unsigned int)
914                                                                                                 (
915                                                                                                 (double)
916                                                                                                 (ul_HighTimerValue)
917                                                                                                 *
918                                                                                                 1.007752288);
919                                                                                 }
920
921                                                                                 break;
922
923                                                                                 /******/
924                                                                                 /* ms */
925                                                                                 /******/
926
927                                                                         case 2:
928
929                                                                                 /******************/
930                                                                                 /* Timer 0 factor */
931                                                                                 /******************/
932
933                                                                                 ul_HighTimerValue
934                                                                                         =
935                                                                                         ul_HighTiming
936                                                                                         *
937                                                                                         (250.0
938                                                                                         *
939                                                                                         b_ClockSelection);
940
941                                                                                 /*******************/
942                                                                                 /* Round the value */
943                                                                                 /*******************/
944
945                                                                                 if ((double)((double)ul_HighTiming * (250.0 * (double)b_ClockSelection)) >= ((double)((double)ul_HighTimerValue + 0.5))) {
946                                                                                         ul_HighTimerValue
947                                                                                                 =
948                                                                                                 ul_HighTimerValue
949                                                                                                 +
950                                                                                                 1;
951                                                                                 }
952
953                                                                                 /*****************************/
954                                                                                 /* Calculate the real timing */
955                                                                                 /*****************************/
956
957                                                                                 *pul_RealHighTiming
958                                                                                         =
959                                                                                         (unsigned int)
960                                                                                         (ul_HighTimerValue
961                                                                                         /
962                                                                                         (250.0 * (double)b_ClockSelection));
963                                                                                 d_RealHighTiming
964                                                                                         =
965                                                                                         (double)
966                                                                                         ul_HighTimerValue
967                                                                                         /
968                                                                                         (250.0
969                                                                                         *
970                                                                                         (double)
971                                                                                         b_ClockSelection);
972
973                                                                                 if ((double)((double)ul_HighTimerValue / (250.0 * (double)b_ClockSelection)) >= (double)((double)*pul_RealHighTiming + 0.5)) {
974                                                                                         *pul_RealHighTiming
975                                                                                                 =
976                                                                                                 *pul_RealHighTiming
977                                                                                                 +
978                                                                                                 1;
979                                                                                 }
980
981                                                                                 ul_HighTiming
982                                                                                         =
983                                                                                         ul_HighTiming
984                                                                                         -
985                                                                                         1;
986                                                                                 ul_HighTimerValue
987                                                                                         =
988                                                                                         ul_HighTimerValue
989                                                                                         -
990                                                                                         2;
991
992                                                                                 if (b_ClockSelection != APCI1710_40MHZ) {
993                                                                                         ul_HighTimerValue
994                                                                                                 =
995                                                                                                 (unsigned int)
996                                                                                                 (
997                                                                                                 (double)
998                                                                                                 (ul_HighTimerValue)
999                                                                                                 *
1000                                                                                                 1.007752288);
1001                                                                                 }
1002
1003                                                                                 break;
1004
1005                                                                                 /*****/
1006                                                                                 /* s */
1007                                                                                 /*****/
1008
1009                                                                         case 3:
1010
1011                                                                                 /******************/
1012                                                                                 /* Timer 0 factor */
1013                                                                                 /******************/
1014
1015                                                                                 ul_HighTimerValue
1016                                                                                         =
1017                                                                                         (unsigned int)
1018                                                                                         (ul_HighTiming
1019                                                                                         *
1020                                                                                         (250000.0
1021                                                                                                 *
1022                                                                                                 b_ClockSelection));
1023
1024                                                                                 /*******************/
1025                                                                                 /* Round the value */
1026                                                                                 /*******************/
1027
1028                                                                                 if ((double)((double)ul_HighTiming * (250000.0 * (double)b_ClockSelection)) >= ((double)((double)ul_HighTimerValue + 0.5))) {
1029                                                                                         ul_HighTimerValue
1030                                                                                                 =
1031                                                                                                 ul_HighTimerValue
1032                                                                                                 +
1033                                                                                                 1;
1034                                                                                 }
1035
1036                                                                                 /*****************************/
1037                                                                                 /* Calculate the real timing */
1038                                                                                 /*****************************/
1039
1040                                                                                 *pul_RealHighTiming
1041                                                                                         =
1042                                                                                         (unsigned int)
1043                                                                                         (ul_HighTimerValue
1044                                                                                         /
1045                                                                                         (250000.0
1046                                                                                                 *
1047                                                                                                 (double)
1048                                                                                                 b_ClockSelection));
1049                                                                                 d_RealHighTiming
1050                                                                                         =
1051                                                                                         (double)
1052                                                                                         ul_HighTimerValue
1053                                                                                         /
1054                                                                                         (250000.0
1055                                                                                         *
1056                                                                                         (double)
1057                                                                                         b_ClockSelection);
1058
1059                                                                                 if ((double)((double)ul_HighTimerValue / (250000.0 * (double)b_ClockSelection)) >= (double)((double)*pul_RealHighTiming + 0.5)) {
1060                                                                                         *pul_RealHighTiming
1061                                                                                                 =
1062                                                                                                 *pul_RealHighTiming
1063                                                                                                 +
1064                                                                                                 1;
1065                                                                                 }
1066
1067                                                                                 ul_HighTiming
1068                                                                                         =
1069                                                                                         ul_HighTiming
1070                                                                                         -
1071                                                                                         1;
1072                                                                                 ul_HighTimerValue
1073                                                                                         =
1074                                                                                         ul_HighTimerValue
1075                                                                                         -
1076                                                                                         2;
1077
1078                                                                                 if (b_ClockSelection != APCI1710_40MHZ) {
1079                                                                                         ul_HighTimerValue
1080                                                                                                 =
1081                                                                                                 (unsigned int)
1082                                                                                                 (
1083                                                                                                 (double)
1084                                                                                                 (ul_HighTimerValue)
1085                                                                                                 *
1086                                                                                                 1.007752288);
1087                                                                                 }
1088
1089                                                                                 break;
1090
1091                                                                                 /******/
1092                                                                                 /* mn */
1093                                                                                 /******/
1094
1095                                                                         case 4:
1096
1097                                                                                 /******************/
1098                                                                                 /* Timer 0 factor */
1099                                                                                 /******************/
1100
1101                                                                                 ul_HighTimerValue
1102                                                                                         =
1103                                                                                         (unsigned int)
1104                                                                                         (
1105                                                                                         (ul_HighTiming
1106                                                                                                 *
1107                                                                                                 60)
1108                                                                                         *
1109                                                                                         (250000.0
1110                                                                                                 *
1111                                                                                                 b_ClockSelection));
1112
1113                                                                                 /*******************/
1114                                                                                 /* Round the value */
1115                                                                                 /*******************/
1116
1117                                                                                 if ((double)((double)(ul_HighTiming * 60.0) * (250000.0 * (double)b_ClockSelection)) >= ((double)((double)ul_HighTimerValue + 0.5))) {
1118                                                                                         ul_HighTimerValue
1119                                                                                                 =
1120                                                                                                 ul_HighTimerValue
1121                                                                                                 +
1122                                                                                                 1;
1123                                                                                 }
1124
1125                                                                                 /*****************************/
1126                                                                                 /* Calculate the real timing */
1127                                                                                 /*****************************/
1128
1129                                                                                 *pul_RealHighTiming
1130                                                                                         =
1131                                                                                         (unsigned int)
1132                                                                                         (ul_HighTimerValue
1133                                                                                         /
1134                                                                                         (250000.0
1135                                                                                                 *
1136                                                                                                 (double)
1137                                                                                                 b_ClockSelection))
1138                                                                                         /
1139                                                                                         60;
1140                                                                                 d_RealHighTiming
1141                                                                                         =
1142                                                                                         (
1143                                                                                         (double)
1144                                                                                         ul_HighTimerValue
1145                                                                                         /
1146                                                                                         (250000.0
1147                                                                                                 *
1148                                                                                                 (double)
1149                                                                                                 b_ClockSelection))
1150                                                                                         /
1151                                                                                         60.0;
1152
1153                                                                                 if ((double)(((double)ul_HighTimerValue / (250000.0 * (double)b_ClockSelection)) / 60.0) >= (double)((double)*pul_RealHighTiming + 0.5)) {
1154                                                                                         *pul_RealHighTiming
1155                                                                                                 =
1156                                                                                                 *pul_RealHighTiming
1157                                                                                                 +
1158                                                                                                 1;
1159                                                                                 }
1160
1161                                                                                 ul_HighTiming
1162                                                                                         =
1163                                                                                         ul_HighTiming
1164                                                                                         -
1165                                                                                         1;
1166                                                                                 ul_HighTimerValue
1167                                                                                         =
1168                                                                                         ul_HighTimerValue
1169                                                                                         -
1170                                                                                         2;
1171
1172                                                                                 if (b_ClockSelection != APCI1710_40MHZ) {
1173                                                                                         ul_HighTimerValue
1174                                                                                                 =
1175                                                                                                 (unsigned int)
1176                                                                                                 (
1177                                                                                                 (double)
1178                                                                                                 (ul_HighTimerValue)
1179                                                                                                 *
1180                                                                                                 1.007752288);
1181                                                                                 }
1182
1183                                                                                 break;
1184                                                                         }
1185
1186                                                                         fpu_end();
1187                                                                         /****************************/
1188                                                                         /* Save the clock selection */
1189                                                                         /****************************/
1190
1191                                                                         devpriv->
1192                                                                                 s_ModuleInfo
1193                                                                                 [b_ModulNbr].
1194                                                                                 s_PWMModuleInfo.
1195                                                                                 b_ClockSelection
1196                                                                                 =
1197                                                                                 b_ClockSelection;
1198
1199                                                                         /************************/
1200                                                                         /* Save the timing unit */
1201                                                                         /************************/
1202
1203                                                                         devpriv->
1204                                                                                 s_ModuleInfo
1205                                                                                 [b_ModulNbr].
1206                                                                                 s_PWMModuleInfo.
1207                                                                                 s_PWMInfo
1208                                                                                 [b_PWM].
1209                                                                                 b_TimingUnit
1210                                                                                 =
1211                                                                                 b_TimingUnit;
1212
1213                                                                         /****************************/
1214                                                                         /* Save the low base timing */
1215                                                                         /****************************/
1216
1217                                                                         devpriv->
1218                                                                                 s_ModuleInfo
1219                                                                                 [b_ModulNbr].
1220                                                                                 s_PWMModuleInfo.
1221                                                                                 s_PWMInfo
1222                                                                                 [b_PWM].
1223                                                                                 d_LowTiming
1224                                                                                 =
1225                                                                                 d_RealLowTiming;
1226
1227                                                                         devpriv->
1228                                                                                 s_ModuleInfo
1229                                                                                 [b_ModulNbr].
1230                                                                                 s_PWMModuleInfo.
1231                                                                                 s_PWMInfo
1232                                                                                 [b_PWM].
1233                                                                                 ul_RealLowTiming
1234                                                                                 =
1235                                                                                 *pul_RealLowTiming;
1236
1237                                                                         /****************************/
1238                                                                         /* Save the high base timing */
1239                                                                         /****************************/
1240
1241                                                                         devpriv->
1242                                                                                 s_ModuleInfo
1243                                                                                 [b_ModulNbr].
1244                                                                                 s_PWMModuleInfo.
1245                                                                                 s_PWMInfo
1246                                                                                 [b_PWM].
1247                                                                                 d_HighTiming
1248                                                                                 =
1249                                                                                 d_RealHighTiming;
1250
1251                                                                         devpriv->
1252                                                                                 s_ModuleInfo
1253                                                                                 [b_ModulNbr].
1254                                                                                 s_PWMModuleInfo.
1255                                                                                 s_PWMInfo
1256                                                                                 [b_PWM].
1257                                                                                 ul_RealHighTiming
1258                                                                                 =
1259                                                                                 *pul_RealHighTiming;
1260
1261                                                                         /************************/
1262                                                                         /* Write the low timing */
1263                                                                         /************************/
1264
1265                                                                         outl(ul_LowTimerValue, devpriv->s_BoardInfos.ui_Address + 0 + (20 * b_PWM) + (64 * b_ModulNbr));
1266
1267                                                                         /*************************/
1268                                                                         /* Write the high timing */
1269                                                                         /*************************/
1270
1271                                                                         outl(ul_HighTimerValue, devpriv->s_BoardInfos.ui_Address + 4 + (20 * b_PWM) + (64 * b_ModulNbr));
1272
1273                                                                         /***************************/
1274                                                                         /* Set the clock selection */
1275                                                                         /***************************/
1276
1277                                                                         dw_Command
1278                                                                                 =
1279                                                                                 inl
1280                                                                                 (devpriv->
1281                                                                                 s_BoardInfos.
1282                                                                                 ui_Address
1283                                                                                 +
1284                                                                                 8
1285                                                                                 +
1286                                                                                 (20 * b_PWM) + (64 * b_ModulNbr));
1287
1288                                                                         dw_Command
1289                                                                                 =
1290                                                                                 dw_Command
1291                                                                                 &
1292                                                                                 0x7F;
1293
1294                                                                         if (b_ClockSelection == APCI1710_40MHZ) {
1295                                                                                 dw_Command
1296                                                                                         =
1297                                                                                         dw_Command
1298                                                                                         |
1299                                                                                         0x80;
1300                                                                         }
1301
1302                                                                         /***************************/
1303                                                                         /* Set the clock selection */
1304                                                                         /***************************/
1305
1306                                                                         outl(dw_Command, devpriv->s_BoardInfos.ui_Address + 8 + (20 * b_PWM) + (64 * b_ModulNbr));
1307
1308                                                                         /*************/
1309                                                                         /* PWM init. */
1310                                                                         /*************/
1311                                                                         devpriv->
1312                                                                                 s_ModuleInfo
1313                                                                                 [b_ModulNbr].
1314                                                                                 s_PWMModuleInfo.
1315                                                                                 s_PWMInfo
1316                                                                                 [b_PWM].
1317                                                                                 b_PWMInit
1318                                                                                 =
1319                                                                                 1;
1320                                                                 } else {
1321                                                                         /***************************************************/
1322                                                                         /* You can not used the 40MHz clock selection with */
1323                                                                         /* this board                                      */
1324                                                                         /***************************************************/
1325                                                                         DPRINTK("You can not used the 40MHz clock selection with this board\n");
1326                                                                         i_ReturnValue
1327                                                                                 =
1328                                                                                 -9;
1329                                                                 }
1330                                                         } else {
1331                                                                 /***************************************/
1332                                                                 /* High base timing selection is wrong */
1333                                                                 /***************************************/
1334                                                                 DPRINTK("High base timing selection is wrong\n");
1335                                                                 i_ReturnValue =
1336                                                                         -8;
1337                                                         }
1338                                                 } else {
1339                                                         /**************************************/
1340                                                         /* Low base timing selection is wrong */
1341                                                         /**************************************/
1342                                                         DPRINTK("Low base timing selection is wrong\n");
1343                                                         i_ReturnValue = -7;
1344                                                 }
1345                                         }       /*  if ((b_TimingUnit >= 0) && (b_TimingUnit <= 4)) */
1346                                         else {
1347                                                 /**********************************/
1348                                                 /* Timing unit selection is wrong */
1349                                                 /**********************************/
1350                                                 DPRINTK("Timing unit selection is wrong\n");
1351                                                 i_ReturnValue = -6;
1352                                         }       /*  if ((b_TimingUnit >= 0) && (b_TimingUnit <= 4)) */
1353                                 }       /*  if ((b_ClockSelection == APCI1710_30MHZ) || (b_ClockSelection == APCI1710_33MHZ) || (b_ClockSelection == APCI1710_40MHZ)) */
1354                                 else {
1355                                         /*******************************/
1356                                         /* The selected clock is wrong */
1357                                         /*******************************/
1358                                         DPRINTK("The selected clock is wrong\n");
1359                                         i_ReturnValue = -5;
1360                                 }       /*  if ((b_ClockSelection == APCI1710_30MHZ) || (b_ClockSelection == APCI1710_33MHZ) || (b_ClockSelection == APCI1710_40MHZ)) */
1361                         }       /*  if (b_PWM >= 0 && b_PWM <= 1) */
1362                         else {
1363                                 /******************************/
1364                                 /* Tor PWM selection is wrong */
1365                                 /******************************/
1366                                 DPRINTK("Tor PWM selection is wrong\n");
1367                                 i_ReturnValue = -4;
1368                         }       /*  if (b_PWM >= 0 && b_PWM <= 1) */
1369                 } else {
1370                         /**********************************/
1371                         /* The module is not a PWM module */
1372                         /**********************************/
1373                         DPRINTK("The module is not a PWM module\n");
1374                         i_ReturnValue = -3;
1375                 }
1376         } else {
1377                 /***********************/
1378                 /* Module number error */
1379                 /***********************/
1380                 DPRINTK("Module number error\n");
1381                 i_ReturnValue = -2;
1382         }
1383
1384         return i_ReturnValue;
1385 }
1386
1387 /*
1388 +----------------------------------------------------------------------------+
1389 | Function Name     : _INT_ i_APCI1710_GetPWMInitialisation                  |
1390 |                                       (unsigned char_     b_BoardHandle,            |
1391 |                                        unsigned char_     b_ModulNbr,               |
1392 |                                        unsigned char_     b_PWM,                    |
1393 |                                        unsigned char *_   pb_TimingUnit,             |
1394 |                                        PULONG_ pul_LowTiming,              |
1395 |                                        PULONG_ pul_HighTiming,             |
1396 |                                        unsigned char *_   pb_StartLevel,             |
1397 |                                        unsigned char *_   pb_StopMode,               |
1398 |                                        unsigned char *_   pb_StopLevel,              |
1399 |                                        unsigned char *_   pb_ExternGate,             |
1400 |                                        unsigned char *_   pb_InterruptEnable,        |
1401 |                                        unsigned char *_   pb_Enable)                 |
1402 +----------------------------------------------------------------------------+
1403 | Task              : Return the PWM (b_PWM) initialisation from selected    |
1404 |                     module (b_ModulNbr). You must calling the              |
1405 |                     "i_APCI1710_InitPWM" function be for you call this     |
1406 |                     function.                                              |
1407 +----------------------------------------------------------------------------+
1408 | Input Parameters  : unsigned char_ b_BoardHandle : Handle of board APCI-1710        |
1409 |                     unsigned char_ b_ModulNbr    : Selected module number (0 to 3)  |
1410 |                     unsigned char_ b_PWM         : Selected PWM (0 or 1)            |
1411 +----------------------------------------------------------------------------+
1412 | Output Parameters : unsigned char *_  pb_TimingUnit      : Base timing Unit (0 to 4) |
1413 |                                                       0 : ns               |
1414 |                                                       1 : æs               |
1415 |                                                       2 : ms               |
1416 |                                                       3 : s                |
1417 |                                                       4 : mn               |
1418 |                     PULONG_ pul_LowTiming      : Low base timing value.    |
1419 |                     PULONG_ pul_HighTiming     : High base timing value.   |
1420 |                     unsigned char *_  pb_StartLevel      : Start period level        |
1421 |                                                  selection                 |
1422 |                                                       0 : The period start |
1423 |                                                           with a low level |
1424 |                                                       1 : The period start |
1425 |                                                           with a high level|
1426 |                     unsigned char *_  pb_StopMode        : Stop mode selection       |
1427 |                                                  0 : The PWM is stopped    |
1428 |                                                      directly after the    |
1429 |                                                     "i_APCI1710_DisablePWM"|
1430 |                                                      function and break the|
1431 |                                                      last period           |
1432 |                                                  1 : After the             |
1433 |                                                     "i_APCI1710_DisablePWM"|
1434 |                                                      function the PWM is   |
1435 |                                                      stopped at the end    |
1436 |                                                      from last period cycle|
1437 |                     unsigned char *_  pb_StopLevel        : Stop PWM level selection |
1438 |                                                    0 : The output signal   |
1439 |                                                        keep the level after|
1440 |                                                        the                 |
1441 |                                                     "i_APCI1710_DisablePWM"|
1442 |                                                        function            |
1443 |                                                    1 : The output signal is|
1444 |                                                        set to low after the|
1445 |                                                     "i_APCI1710_DisablePWM"|
1446 |                                                        function            |
1447 |                                                    2 : The output signal is|
1448 |                                                        set to high after   |
1449 |                                                        the                 |
1450 |                                                     "i_APCI1710_DisablePWM"|
1451 |                                                        function            |
1452 |                     unsigned char *_  pb_ExternGate      : Extern gate action        |
1453 |                                                  selection                 |
1454 |                                                   0 : Extern gate signal   |
1455 |                                                       not used.            |
1456 |                                                   1 : Extern gate signal   |
1457 |                                                       used.                |
1458 |                     unsigned char *_  pb_InterruptEnable : Enable or disable the PWM |
1459 |                                                  interrupt.                |
1460 |                                                  - APCI1710_ENABLE :       |
1461 |                                                    Enable the PWM interrupt|
1462 |                                                    A interrupt occur after |
1463 |                                                    each period             |
1464 |                                                  - APCI1710_DISABLE :      |
1465 |                                                    Disable the PWM         |
1466 |                                                    interrupt               |
1467 |                     unsigned char *_  pb_Enable          : Indicate if the PWM is    |
1468 |                                                  enabled or no             |
1469 |                                                       0 : PWM not enabled  |
1470 |                                                       1 : PWM enabled      |
1471 +----------------------------------------------------------------------------+
1472 | Return Value      :  0: No error                                           |
1473 |                     -1: The handle parameter of the board is wrong         |
1474 |                     -2: Module selection wrong                             |
1475 |                     -3: The module is not a PWM module                     |
1476 |                     -4: PWM selection is wrong                             |
1477 |                     -5: PWM not initialised see function                   |
1478 |                         "i_APCI1710_InitPWM"                               |
1479 +----------------------------------------------------------------------------+
1480 */
1481 static int i_APCI1710_GetPWMInitialisation(struct comedi_device *dev,
1482                                            unsigned char b_ModulNbr,
1483                                            unsigned char b_PWM,
1484                                            unsigned char *pb_TimingUnit,
1485                                            unsigned int *pul_LowTiming,
1486                                            unsigned int *pul_HighTiming,
1487                                            unsigned char *pb_StartLevel,
1488                                            unsigned char *pb_StopMode,
1489                                            unsigned char *pb_StopLevel,
1490                                            unsigned char *pb_ExternGate,
1491                                            unsigned char *pb_InterruptEnable,
1492                                            unsigned char *pb_Enable)
1493 {
1494         struct addi_private *devpriv = dev->private;
1495         int i_ReturnValue = 0;
1496         unsigned int dw_Status;
1497         unsigned int dw_Command;
1498
1499         /**************************/
1500         /* Test the module number */
1501         /**************************/
1502
1503         if (b_ModulNbr < 4) {
1504                 /***************/
1505                 /* Test if PWM */
1506                 /***************/
1507
1508                 if ((devpriv->s_BoardInfos.
1509                                 dw_MolduleConfiguration[b_ModulNbr] &
1510                                 0xFFFF0000UL) == APCI1710_PWM) {
1511                         /**************************/
1512                         /* Test the PWM selection */
1513                         /**************************/
1514
1515                         if (b_PWM <= 1) {
1516                                 /***************************/
1517                                 /* Test if PWM initialised */
1518                                 /***************************/
1519
1520                                 dw_Status = inl(devpriv->s_BoardInfos.
1521                                         ui_Address + 12 + (20 * b_PWM) +
1522                                         (64 * b_ModulNbr));
1523
1524                                 if (dw_Status & 0x10) {
1525                                         /***********************/
1526                                         /* Read the low timing */
1527                                         /***********************/
1528
1529                                         *pul_LowTiming =
1530                                                 inl(devpriv->s_BoardInfos.
1531                                                 ui_Address + 0 + (20 * b_PWM) +
1532                                                 (64 * b_ModulNbr));
1533
1534                                         /************************/
1535                                         /* Read the high timing */
1536                                         /************************/
1537
1538                                         *pul_HighTiming =
1539                                                 inl(devpriv->s_BoardInfos.
1540                                                 ui_Address + 4 + (20 * b_PWM) +
1541                                                 (64 * b_ModulNbr));
1542
1543                                         /********************/
1544                                         /* Read the command */
1545                                         /********************/
1546
1547                                         dw_Command = inl(devpriv->s_BoardInfos.
1548                                                 ui_Address + 8 + (20 * b_PWM) +
1549                                                 (64 * b_ModulNbr));
1550
1551                                         *pb_StartLevel =
1552                                                 (unsigned char) ((dw_Command >> 5) & 1);
1553                                         *pb_StopMode =
1554                                                 (unsigned char) ((dw_Command >> 0) & 1);
1555                                         *pb_StopLevel =
1556                                                 (unsigned char) ((dw_Command >> 1) & 1);
1557                                         *pb_ExternGate =
1558                                                 (unsigned char) ((dw_Command >> 4) & 1);
1559                                         *pb_InterruptEnable =
1560                                                 (unsigned char) ((dw_Command >> 3) & 1);
1561
1562                                         if (*pb_StopLevel) {
1563                                                 *pb_StopLevel =
1564                                                         *pb_StopLevel +
1565                                                         (unsigned char) ((dw_Command >>
1566                                                                 2) & 1);
1567                                         }
1568
1569                                         /********************/
1570                                         /* Read the command */
1571                                         /********************/
1572
1573                                         dw_Command = inl(devpriv->s_BoardInfos.
1574                                                 ui_Address + 8 + (20 * b_PWM) +
1575                                                 (64 * b_ModulNbr));
1576
1577                                         *pb_Enable =
1578                                                 (unsigned char) ((dw_Command >> 0) & 1);
1579
1580                                         *pb_TimingUnit = devpriv->
1581                                                 s_ModuleInfo[b_ModulNbr].
1582                                                 s_PWMModuleInfo.
1583                                                 s_PWMInfo[b_PWM].b_TimingUnit;
1584                                 }       /*  if (dw_Status & 0x10) */
1585                                 else {
1586                                         /***********************/
1587                                         /* PWM not initialised */
1588                                         /***********************/
1589                                         DPRINTK("PWM not initialised\n");
1590                                         i_ReturnValue = -5;
1591                                 }       /*  if (dw_Status & 0x10) */
1592                         }       /*  if (b_PWM >= 0 && b_PWM <= 1) */
1593                         else {
1594                                 /******************************/
1595                                 /* Tor PWM selection is wrong */
1596                                 /******************************/
1597                                 DPRINTK("Tor PWM selection is wrong\n");
1598                                 i_ReturnValue = -4;
1599                         }       /*  if (b_PWM >= 0 && b_PWM <= 1) */
1600                 } else {
1601                         /**********************************/
1602                         /* The module is not a PWM module */
1603                         /**********************************/
1604                         DPRINTK("The module is not a PWM module\n");
1605                         i_ReturnValue = -3;
1606                 }
1607         } else {
1608                 /***********************/
1609                 /* Module number error */
1610                 /***********************/
1611                 DPRINTK("Module number error\n");
1612                 i_ReturnValue = -2;
1613         }
1614
1615         return i_ReturnValue;
1616 }
1617
1618 /*
1619  * Pwm Init and Get Pwm Initialisation
1620  */
1621 static int i_APCI1710_InsnConfigPWM(struct comedi_device *dev,
1622                                     struct comedi_subdevice *s,
1623                                     struct comedi_insn *insn,
1624                                     unsigned int *data)
1625 {
1626         unsigned char b_ConfigType;
1627         int i_ReturnValue = 0;
1628         b_ConfigType = CR_CHAN(insn->chanspec);
1629
1630         switch (b_ConfigType) {
1631         case APCI1710_PWM_INIT:
1632                 i_ReturnValue = i_APCI1710_InitPWM(dev, (unsigned char) CR_AREF(insn->chanspec),        /*   b_ModulNbr */
1633                         (unsigned char) data[0],        /* b_PWM */
1634                         (unsigned char) data[1],        /*  b_ClockSelection */
1635                         (unsigned char) data[2],        /*  b_TimingUnit */
1636                         (unsigned int) data[3], /* ul_LowTiming */
1637                         (unsigned int) data[4], /* ul_HighTiming */
1638                         (unsigned int *) &data[0],      /* pul_RealLowTiming */
1639                         (unsigned int *) &data[1]       /* pul_RealHighTiming */
1640                         );
1641                 break;
1642
1643         case APCI1710_PWM_GETINITDATA:
1644                 i_ReturnValue = i_APCI1710_GetPWMInitialisation(dev, (unsigned char) CR_AREF(insn->chanspec),   /*  b_ModulNbr */
1645                         (unsigned char) data[0],        /* b_PWM */
1646                         (unsigned char *) &data[0],     /* pb_TimingUnit */
1647                         (unsigned int *) &data[1],      /* pul_LowTiming */
1648                         (unsigned int *) &data[2],      /* pul_HighTiming */
1649                         (unsigned char *) &data[3],     /*  pb_StartLevel */
1650                         (unsigned char *) &data[4],     /*  pb_StopMode */
1651                         (unsigned char *) &data[5],     /*  pb_StopLevel */
1652                         (unsigned char *) &data[6],     /*  pb_ExternGate */
1653                         (unsigned char *) &data[7],     /*  pb_InterruptEnable */
1654                         (unsigned char *) &data[8]      /*  pb_Enable */
1655                         );
1656                 break;
1657
1658         default:
1659                 printk(" Config Parameter Wrong\n");
1660         }
1661
1662         if (i_ReturnValue >= 0)
1663                 i_ReturnValue = insn->n;
1664         return i_ReturnValue;
1665 }
1666
1667 /*
1668 +----------------------------------------------------------------------------+
1669 | Function Name     : _INT_     i_APCI1710_EnablePWM                         |
1670 |                                       (unsigned char_  b_BoardHandle,               |
1671 |                                        unsigned char_  b_ModulNbr,                  |
1672 |                                        unsigned char_  b_PWM,                       |
1673 |                                        unsigned char_  b_StartLevel,                |
1674 |                                        unsigned char_  b_StopMode,                  |
1675 |                                        unsigned char_  b_StopLevel,                 |
1676 |                                        unsigned char_  b_ExternGate,                |
1677 |                                        unsigned char_  b_InterruptEnable)           |
1678 +----------------------------------------------------------------------------+
1679 | Task              : Enable the selected PWM (b_PWM) from selected module   |
1680 |                     (b_ModulNbr). You must calling the "i_APCI1710_InitPWM"|
1681 |                     function be for you call this function.                |
1682 |                     If you enable the PWM interrupt, the PWM generate a    |
1683 |                     interrupt after each period.                           |
1684 |                     See function "i_APCI1710_SetBoardIntRoutineX" and the  |
1685 |                     Interrupt mask description chapter.                    |
1686 +----------------------------------------------------------------------------+
1687 | Input Parameters  : unsigned char_ b_BoardHandle     : Handle of board APCI-1710    |
1688 |                     unsigned char_ b_ModulNbr        : Selected module number       |
1689 |                                               (0 to 3)                     |
1690 |                     unsigned char_ b_PWM             : Selected PWM (0 or 1)        |
1691 |                     unsigned char_ b_StartLevel      : Start period level selection |
1692 |                                                0 : The period start with a |
1693 |                                                    low level               |
1694 |                                                1 : The period start with a |
1695 |                                                    high level              |
1696 |                     unsigned char_ b_StopMode        : Stop mode selection          |
1697 |                                                0 : The PWM is stopped      |
1698 |                                                    directly after the      |
1699 |                                                    "i_APCI1710_DisablePWM" |
1700 |                                                    function and break the  |
1701 |                                                    last period             |
1702 |                                                1 : After the               |
1703 |                                                    "i_APCI1710_DisablePWM" |
1704 |                                                     function the PWM is    |
1705 |                                                     stopped at the end from|
1706 |                                                     last period cycle.     |
1707 |                     unsigned char_ b_StopLevel       : Stop PWM level selection     |
1708 |                                                0 : The output signal keep  |
1709 |                                                    the level after the     |
1710 |                                                    "i_APCI1710_DisablePWM" |
1711 |                                                    function                |
1712 |                                                1 : The output signal is set|
1713 |                                                    to low after the        |
1714 |                                                    "i_APCI1710_DisablePWM" |
1715 |                                                    function                |
1716 |                                                2 : The output signal is set|
1717 |                                                    to high after the       |
1718 |                                                    "i_APCI1710_DisablePWM" |
1719 |                                                    function                |
1720 |                     unsigned char_ b_ExternGate      : Extern gate action selection |
1721 |                                                0 : Extern gate signal not  |
1722 |                                                    used.                   |
1723 |                                                1 : Extern gate signal used.|
1724 |                     unsigned char_ b_InterruptEnable : Enable or disable the PWM    |
1725 |                                               interrupt.                   |
1726 |                                               - APCI1710_ENABLE :          |
1727 |                                                 Enable the PWM interrupt   |
1728 |                                                 A interrupt occur after    |
1729 |                                                 each period                |
1730 |                                               - APCI1710_DISABLE :         |
1731 |                                                 Disable the PWM interrupt  |
1732 +----------------------------------------------------------------------------+
1733 | Output Parameters : -                                                      |
1734 +----------------------------------------------------------------------------+
1735 | Return Value      : 0:  No error                                           |
1736 |                    -1:  The handle parameter of the board is wrong         |
1737 |                    -2:  Module selection wrong                             |
1738 |                    -3:  The module is not a PWM module                     |
1739 |                    -4:  PWM selection is wrong                             |
1740 |                    -5:  PWM not initialised see function                   |
1741 |                         "i_APCI1710_InitPWM"                               |
1742 |                    -6:  PWM start level selection is wrong                 |
1743 |                    -7:  PWM stop mode selection is wrong                   |
1744 |                    -8:  PWM stop level selection is wrong                  |
1745 |                    -9:  Extern gate signal selection is wrong              |
1746 |                    -10: Interrupt parameter is wrong                       |
1747 |                    -11: Interrupt function not initialised.                |
1748 |                         See function "i_APCI1710_SetBoardIntRoutineX"      |
1749 +----------------------------------------------------------------------------+
1750 */
1751 static int i_APCI1710_EnablePWM(struct comedi_device *dev,
1752                                 unsigned char b_ModulNbr,
1753                                 unsigned char b_PWM,
1754                                 unsigned char b_StartLevel,
1755                                 unsigned char b_StopMode,
1756                                 unsigned char b_StopLevel,
1757                                 unsigned char b_ExternGate,
1758                                 unsigned char b_InterruptEnable)
1759 {
1760         struct addi_private *devpriv = dev->private;
1761         int i_ReturnValue = 0;
1762         unsigned int dw_Status;
1763         unsigned int dw_Command;
1764
1765         devpriv->tsk_Current = current; /*  Save the current process task structure */
1766         /**************************/
1767         /* Test the module number */
1768         /**************************/
1769
1770         if (b_ModulNbr < 4) {
1771                 /***************/
1772                 /* Test if PWM */
1773                 /***************/
1774
1775                 if ((devpriv->s_BoardInfos.
1776                                 dw_MolduleConfiguration[b_ModulNbr] &
1777                                 0xFFFF0000UL) == APCI1710_PWM) {
1778                         /**************************/
1779                         /* Test the PWM selection */
1780                         /**************************/
1781
1782                         if (b_PWM <= 1) {
1783                                 /***************************/
1784                                 /* Test if PWM initialised */
1785                                 /***************************/
1786
1787                                 dw_Status = inl(devpriv->s_BoardInfos.
1788                                         ui_Address + 12 + (20 * b_PWM) +
1789                                         (64 * b_ModulNbr));
1790
1791                                 if (dw_Status & 0x10) {
1792                                         /**********************************/
1793                                         /* Test the start level selection */
1794                                         /**********************************/
1795
1796                                         if (b_StartLevel <= 1) {
1797                                                 /**********************/
1798                                                 /* Test the stop mode */
1799                                                 /**********************/
1800
1801                                                 if (b_StopMode <= 1) {
1802                                                         /***********************/
1803                                                         /* Test the stop level */
1804                                                         /***********************/
1805
1806                                                         if (b_StopLevel <= 2) {
1807                                                                 /*****************************/
1808                                                                 /* Test the extern gate mode */
1809                                                                 /*****************************/
1810
1811                                                                 if (b_ExternGate
1812                                                                         <= 1) {
1813                                                                         /*****************************/
1814                                                                         /* Test the interrupt action */
1815                                                                         /*****************************/
1816
1817                                                                         if (b_InterruptEnable == APCI1710_ENABLE || b_InterruptEnable == APCI1710_DISABLE) {
1818                                                                                 /******************************************/
1819                                                                                 /* Test if interrupt function initialised */
1820                                                                                 /******************************************/
1821
1822                                                                                 /********************/
1823                                                                                 /* Read the command */
1824                                                                                 /********************/
1825
1826                                                                                 dw_Command
1827                                                                                         =
1828                                                                                         inl
1829                                                                                         (devpriv->
1830                                                                                         s_BoardInfos.
1831                                                                                         ui_Address
1832                                                                                         +
1833                                                                                         8
1834                                                                                         +
1835                                                                                         (20 * b_PWM) + (64 * b_ModulNbr));
1836
1837                                                                                 dw_Command
1838                                                                                         =
1839                                                                                         dw_Command
1840                                                                                         &
1841                                                                                         0x80;
1842
1843                                                                                 /********************/
1844                                                                                 /* Make the command */
1845                                                                                 /********************/
1846
1847                                                                                 dw_Command
1848                                                                                         =
1849                                                                                         dw_Command
1850                                                                                         |
1851                                                                                         b_StopMode
1852                                                                                         |
1853                                                                                         (b_InterruptEnable
1854                                                                                         <<
1855                                                                                         3)
1856                                                                                         |
1857                                                                                         (b_ExternGate
1858                                                                                         <<
1859                                                                                         4)
1860                                                                                         |
1861                                                                                         (b_StartLevel
1862                                                                                         <<
1863                                                                                         5);
1864
1865                                                                                 if (b_StopLevel & 3) {
1866                                                                                         dw_Command
1867                                                                                                 =
1868                                                                                                 dw_Command
1869                                                                                                 |
1870                                                                                                 2;
1871
1872                                                                                         if (b_StopLevel & 2) {
1873                                                                                                 dw_Command
1874                                                                                                         =
1875                                                                                                         dw_Command
1876                                                                                                         |
1877                                                                                                         4;
1878                                                                                         }
1879                                                                                 }
1880
1881                                                                                 devpriv->
1882                                                                                         s_ModuleInfo
1883                                                                                         [b_ModulNbr].
1884                                                                                         s_PWMModuleInfo.
1885                                                                                         s_PWMInfo
1886                                                                                         [b_PWM].
1887                                                                                         b_InterruptEnable
1888                                                                                         =
1889                                                                                         b_InterruptEnable;
1890
1891                                                                                 /*******************/
1892                                                                                 /* Set the command */
1893                                                                                 /*******************/
1894
1895                                                                                 outl(dw_Command, devpriv->s_BoardInfos.ui_Address + 8 + (20 * b_PWM) + (64 * b_ModulNbr));
1896
1897                                                                                 /******************/
1898                                                                                 /* Enable the PWM */
1899                                                                                 /******************/
1900                                                                                 outl(1, devpriv->s_BoardInfos.ui_Address + 12 + (20 * b_PWM) + (64 * b_ModulNbr));
1901                                                                         }       /*  if (b_InterruptEnable == APCI1710_ENABLE || b_InterruptEnable == APCI1710_DISABLE) */
1902                                                                         else {
1903                                                                                 /********************************/
1904                                                                                 /* Interrupt parameter is wrong */
1905                                                                                 /********************************/
1906                                                                                 DPRINTK("Interrupt parameter is wrong\n");
1907                                                                                 i_ReturnValue
1908                                                                                         =
1909                                                                                         -10;
1910                                                                         }       /*  if (b_InterruptEnable == APCI1710_ENABLE || b_InterruptEnable == APCI1710_DISABLE) */
1911                                                                 }       /*  if (b_ExternGate >= 0 && b_ExternGate <= 1) */
1912                                                                 else {
1913                                                                         /*****************************************/
1914                                                                         /* Extern gate signal selection is wrong */
1915                                                                         /*****************************************/
1916                                                                         DPRINTK("Extern gate signal selection is wrong\n");
1917                                                                         i_ReturnValue
1918                                                                                 =
1919                                                                                 -9;
1920                                                                 }       /*  if (b_ExternGate >= 0 && b_ExternGate <= 1) */
1921                                                         }       /*  if (b_StopLevel >= 0 && b_StopLevel <= 2) */
1922                                                         else {
1923                                                                 /*************************************/
1924                                                                 /* PWM stop level selection is wrong */
1925                                                                 /*************************************/
1926                                                                 DPRINTK("PWM stop level selection is wrong\n");
1927                                                                 i_ReturnValue =
1928                                                                         -8;
1929                                                         }       /*  if (b_StopLevel >= 0 && b_StopLevel <= 2) */
1930                                                 }       /*  if (b_StopMode >= 0 && b_StopMode <= 1) */
1931                                                 else {
1932                                                         /************************************/
1933                                                         /* PWM stop mode selection is wrong */
1934                                                         /************************************/
1935                                                         DPRINTK("PWM stop mode selection is wrong\n");
1936                                                         i_ReturnValue = -7;
1937                                                 }       /*  if (b_StopMode >= 0 && b_StopMode <= 1) */
1938                                         }       /*  if (b_StartLevel >= 0 && b_StartLevel <= 1) */
1939                                         else {
1940                                                 /**************************************/
1941                                                 /* PWM start level selection is wrong */
1942                                                 /**************************************/
1943                                                 DPRINTK("PWM start level selection is wrong\n");
1944                                                 i_ReturnValue = -6;
1945                                         }       /*  if (b_StartLevel >= 0 && b_StartLevel <= 1) */
1946                                 }       /*  if (dw_Status & 0x10) */
1947                                 else {
1948                                         /***********************/
1949                                         /* PWM not initialised */
1950                                         /***********************/
1951                                         DPRINTK("PWM not initialised\n");
1952                                         i_ReturnValue = -5;
1953                                 }       /*  if (dw_Status & 0x10) */
1954                         }       /*  if (b_PWM >= 0 && b_PWM <= 1) */
1955                         else {
1956                                 /******************************/
1957                                 /* Tor PWM selection is wrong */
1958                                 /******************************/
1959                                 DPRINTK("Tor PWM selection is wrong\n");
1960                                 i_ReturnValue = -4;
1961                         }       /*  if (b_PWM >= 0 && b_PWM <= 1) */
1962                 } else {
1963                         /**********************************/
1964                         /* The module is not a PWM module */
1965                         /**********************************/
1966                         DPRINTK("The module is not a PWM module\n");
1967                         i_ReturnValue = -3;
1968                 }
1969         } else {
1970                 /***********************/
1971                 /* Module number error */
1972                 /***********************/
1973                 DPRINTK("Module number error\n");
1974                 i_ReturnValue = -2;
1975         }
1976
1977         return i_ReturnValue;
1978 }
1979
1980 /*
1981 +----------------------------------------------------------------------------+
1982 | Function Name     : _INT_ i_APCI1710_DisablePWM (unsigned char_  b_BoardHandle,     |
1983 |                                                  unsigned char_  b_ModulNbr,        |
1984 |                                                  unsigned char_  b_PWM)             |
1985 +----------------------------------------------------------------------------+
1986 | Task              : Disable the selected PWM (b_PWM) from selected module  |
1987 |                     (b_ModulNbr). The output signal level depend of the    |
1988 |                     initialisation by the "i_APCI1710_EnablePWM".          |
1989 |                     See the b_StartLevel, b_StopMode and b_StopLevel       |
1990 |                     parameters from this function.                         |
1991 +----------------------------------------------------------------------------+
1992 | Input Parameters  :BYTE_ b_BoardHandle : Handle of board APCI-1710         |
1993 |                    unsigned char_ b_ModulNbr    : Selected module number (0 to 3)   |
1994 |                    unsigned char_ b_PWM         : Selected PWM (0 or 1)             |
1995 +----------------------------------------------------------------------------+
1996 | Output Parameters : -                                                      |
1997 +----------------------------------------------------------------------------+
1998 | Return Value      :  0: No error                                           |
1999 |                     -1: The handle parameter of the board is wrong         |
2000 |                     -2: Module selection wrong                             |
2001 |                     -3: The module is not a PWM module                     |
2002 |                     -4: PWM selection is wrong                             |
2003 |                     -5: PWM not initialised see function                   |
2004 |                         "i_APCI1710_InitPWM"                               |
2005 |                     -6: PWM not enabled see function                       |
2006 |                         "i_APCI1710_EnablePWM"                             |
2007 +----------------------------------------------------------------------------+
2008 */
2009 static int i_APCI1710_DisablePWM(struct comedi_device *dev,
2010                                  unsigned char b_ModulNbr,
2011                                  unsigned char b_PWM)
2012 {
2013         struct addi_private *devpriv = dev->private;
2014         int i_ReturnValue = 0;
2015         unsigned int dw_Status;
2016
2017         /**************************/
2018         /* Test the module number */
2019         /**************************/
2020
2021         if (b_ModulNbr < 4) {
2022                 /***************/
2023                 /* Test if PWM */
2024                 /***************/
2025
2026                 if ((devpriv->s_BoardInfos.
2027                                 dw_MolduleConfiguration[b_ModulNbr] &
2028                                 0xFFFF0000UL) == APCI1710_PWM) {
2029                         /**************************/
2030                         /* Test the PWM selection */
2031                         /**************************/
2032
2033                         if (b_PWM <= 1) {
2034                                 /***************************/
2035                                 /* Test if PWM initialised */
2036                                 /***************************/
2037
2038                                 dw_Status = inl(devpriv->s_BoardInfos.
2039                                         ui_Address + 12 + (20 * b_PWM) +
2040                                         (64 * b_ModulNbr));
2041
2042                                 if (dw_Status & 0x10) {
2043                                         /***********************/
2044                                         /* Test if PWM enabled */
2045                                         /***********************/
2046
2047                                         if (dw_Status & 0x1) {
2048                                                 /*******************/
2049                                                 /* Disable the PWM */
2050                                                 /*******************/
2051                                                 outl(0, devpriv->s_BoardInfos.
2052                                                         ui_Address + 12 +
2053                                                         (20 * b_PWM) +
2054                                                         (64 * b_ModulNbr));
2055                                         }       /*  if (dw_Status & 0x1) */
2056                                         else {
2057                                                 /*******************/
2058                                                 /* PWM not enabled */
2059                                                 /*******************/
2060                                                 DPRINTK("PWM not enabled\n");
2061                                                 i_ReturnValue = -6;
2062                                         }       /*  if (dw_Status & 0x1) */
2063                                 }       /*  if (dw_Status & 0x10) */
2064                                 else {
2065                                         /***********************/
2066                                         /* PWM not initialised */
2067                                         /***********************/
2068                                         DPRINTK(" PWM not initialised\n");
2069                                         i_ReturnValue = -5;
2070                                 }       /*  if (dw_Status & 0x10) */
2071                         }       /*  if (b_PWM >= 0 && b_PWM <= 1) */
2072                         else {
2073                                 /******************************/
2074                                 /* Tor PWM selection is wrong */
2075                                 /******************************/
2076                                 DPRINTK("Tor PWM selection is wrong\n");
2077                                 i_ReturnValue = -4;
2078                         }       /*  if (b_PWM >= 0 && b_PWM <= 1) */
2079                 } else {
2080                         /**********************************/
2081                         /* The module is not a PWM module */
2082                         /**********************************/
2083                         DPRINTK("The module is not a PWM module\n");
2084                         i_ReturnValue = -3;
2085                 }
2086         } else {
2087                 /***********************/
2088                 /* Module number error */
2089                 /***********************/
2090                 DPRINTK("Module number error\n");
2091                 i_ReturnValue = -2;
2092         }
2093
2094         return i_ReturnValue;
2095 }
2096
2097 /*
2098 +----------------------------------------------------------------------------+
2099 | Function Name     : _INT_ i_APCI1710_SetNewPWMTiming                       |
2100 |                                       (unsigned char_     b_BoardHandle,            |
2101 |                                        unsigned char_     b_ModulNbr,               |
2102 |                                        unsigned char_     b_PWM,                    |
2103 |                                        unsigned char_     b_ClockSelection,         |
2104 |                                        unsigned char_     b_TimingUnit,             |
2105 |                                        ULONG_   ul_LowTiming,              |
2106 |                                        ULONG_   ul_HighTiming)             |
2107 +----------------------------------------------------------------------------+
2108 | Task              : Set a new timing. The ul_LowTiming, ul_HighTiming and  |
2109 |                     ul_TimingUnit determine the low/high timing base for   |
2110 |                     the period.                                            |
2111 +----------------------------------------------------------------------------+
2112 | Input Parameters  : unsigned char_     b_BoardHandle    : Handle of board APCI-1710 |
2113 |                     unsigned char_     b_ModulNbr       : Module number to configure|
2114 |                                                  (0 to 3)                  |
2115 |                     unsigned char_     b_PWM            : Selected PWM (0 or 1).    |
2116 |                     unsigned char_     b_TimingUnit     : Base timing Unit (0 to 4) |
2117 |                                                       0 : ns               |
2118 |                                                       1 : æs               |
2119 |                                                       2 : ms               |
2120 |                                                       3 : s                |
2121 |                                                       4 : mn               |
2122 |                     ULONG_    ul_LowTiming     : Low base timing value.    |
2123 |                     ULONG_    ul_HighTiming    : High base timing value.   |
2124 +----------------------------------------------------------------------------+
2125 | Output Parameters : -                                                      |
2126 +----------------------------------------------------------------------------+
2127 | Return Value      : 0: No error                                            |
2128 |                    -1: The handle parameter of the board is wrong          |
2129 |                    -2: Module selection wrong                              |
2130 |                    -3: The module is not a PWM module                      |
2131 |                    -4: PWM selection is wrong                              |
2132 |                    -5: PWM not initialised                                 |
2133 |                    -6: Timing Unit selection is wrong                      |
2134 |                    -7: Low base timing selection is wrong                  |
2135 |                    -8: High base timing selection is wrong                 |
2136 +----------------------------------------------------------------------------+
2137 */
2138 static int i_APCI1710_SetNewPWMTiming(struct comedi_device *dev,
2139                                       unsigned char b_ModulNbr,
2140                                       unsigned char b_PWM,
2141                                       unsigned char b_TimingUnit,
2142                                       unsigned int ul_LowTiming,
2143                                       unsigned int ul_HighTiming)
2144 {
2145         struct addi_private *devpriv = dev->private;
2146         unsigned char b_ClockSelection;
2147         int i_ReturnValue = 0;
2148         unsigned int ul_LowTimerValue = 0;
2149         unsigned int ul_HighTimerValue = 0;
2150         unsigned int ul_RealLowTiming = 0;
2151         unsigned int ul_RealHighTiming = 0;
2152         unsigned int dw_Status;
2153         unsigned int dw_Command;
2154         double d_RealLowTiming = 0;
2155         double d_RealHighTiming = 0;
2156
2157         /**************************/
2158         /* Test the module number */
2159         /**************************/
2160
2161         if (b_ModulNbr < 4) {
2162                 /***************/
2163                 /* Test if PWM */
2164                 /***************/
2165
2166                 if ((devpriv->s_BoardInfos.
2167                                 dw_MolduleConfiguration[b_ModulNbr] &
2168                                 0xFFFF0000UL) == APCI1710_PWM) {
2169                         /**************************/
2170                         /* Test the PWM selection */
2171                         /**************************/
2172
2173                         if (b_PWM <= 1) {
2174                                 /***************************/
2175                                 /* Test if PWM initialised */
2176                                 /***************************/
2177
2178                                 dw_Status = inl(devpriv->s_BoardInfos.
2179                                         ui_Address + 12 + (20 * b_PWM) +
2180                                         (64 * b_ModulNbr));
2181
2182                                 if (dw_Status & 0x10) {
2183                                         b_ClockSelection = devpriv->
2184                                                 s_ModuleInfo[b_ModulNbr].
2185                                                 s_PWMModuleInfo.
2186                                                 b_ClockSelection;
2187
2188                                         /************************/
2189                                         /* Test the timing unit */
2190                                         /************************/
2191
2192                                         if (b_TimingUnit <= 4) {
2193                                                 /*********************************/
2194                                                 /* Test the low timing selection */
2195                                                 /*********************************/
2196
2197                                                 if (((b_ClockSelection ==
2198                                                                         APCI1710_30MHZ)
2199                                                                 && (b_TimingUnit
2200                                                                         == 0)
2201                                                                 && (ul_LowTiming
2202                                                                         >= 266)
2203                                                                 && (ul_LowTiming
2204                                                                         <=
2205                                                                         0xFFFFFFFFUL))
2206                                                         || ((b_ClockSelection ==
2207                                                                         APCI1710_30MHZ)
2208                                                                 && (b_TimingUnit
2209                                                                         == 1)
2210                                                                 && (ul_LowTiming
2211                                                                         >= 1)
2212                                                                 && (ul_LowTiming
2213                                                                         <=
2214                                                                         571230650UL))
2215                                                         || ((b_ClockSelection ==
2216                                                                         APCI1710_30MHZ)
2217                                                                 && (b_TimingUnit
2218                                                                         == 2)
2219                                                                 && (ul_LowTiming
2220                                                                         >= 1)
2221                                                                 && (ul_LowTiming
2222                                                                         <=
2223                                                                         571230UL))
2224                                                         || ((b_ClockSelection ==
2225                                                                         APCI1710_30MHZ)
2226                                                                 && (b_TimingUnit
2227                                                                         == 3)
2228                                                                 && (ul_LowTiming
2229                                                                         >= 1)
2230                                                                 && (ul_LowTiming
2231                                                                         <=
2232                                                                         571UL))
2233                                                         || ((b_ClockSelection ==
2234                                                                         APCI1710_30MHZ)
2235                                                                 && (b_TimingUnit
2236                                                                         == 4)
2237                                                                 && (ul_LowTiming
2238                                                                         >= 1)
2239                                                                 && (ul_LowTiming
2240                                                                         <= 9UL))
2241                                                         || ((b_ClockSelection ==
2242                                                                         APCI1710_33MHZ)
2243                                                                 && (b_TimingUnit
2244                                                                         == 0)
2245                                                                 && (ul_LowTiming
2246                                                                         >= 242)
2247                                                                 && (ul_LowTiming
2248                                                                         <=
2249                                                                         0xFFFFFFFFUL))
2250                                                         || ((b_ClockSelection ==
2251                                                                         APCI1710_33MHZ)
2252                                                                 && (b_TimingUnit
2253                                                                         == 1)
2254                                                                 && (ul_LowTiming
2255                                                                         >= 1)
2256                                                                 && (ul_LowTiming
2257                                                                         <=
2258                                                                         519691043UL))
2259                                                         || ((b_ClockSelection ==
2260                                                                         APCI1710_33MHZ)
2261                                                                 && (b_TimingUnit
2262                                                                         == 2)
2263                                                                 && (ul_LowTiming
2264                                                                         >= 1)
2265                                                                 && (ul_LowTiming
2266                                                                         <=
2267                                                                         519691UL))
2268                                                         || ((b_ClockSelection ==
2269                                                                         APCI1710_33MHZ)
2270                                                                 && (b_TimingUnit
2271                                                                         == 3)
2272                                                                 && (ul_LowTiming
2273                                                                         >= 1)
2274                                                                 && (ul_LowTiming
2275                                                                         <=
2276                                                                         520UL))
2277                                                         || ((b_ClockSelection ==
2278                                                                         APCI1710_33MHZ)
2279                                                                 && (b_TimingUnit
2280                                                                         == 4)
2281                                                                 && (ul_LowTiming
2282                                                                         >= 1)
2283                                                                 && (ul_LowTiming
2284                                                                         <= 8UL))
2285                                                         || ((b_ClockSelection ==
2286                                                                         APCI1710_40MHZ)
2287                                                                 && (b_TimingUnit
2288                                                                         == 0)
2289                                                                 && (ul_LowTiming
2290                                                                         >= 200)
2291                                                                 && (ul_LowTiming
2292                                                                         <=
2293                                                                         0xFFFFFFFFUL))
2294                                                         || ((b_ClockSelection ==
2295                                                                         APCI1710_40MHZ)
2296                                                                 && (b_TimingUnit
2297                                                                         == 1)
2298                                                                 && (ul_LowTiming
2299                                                                         >= 1)
2300                                                                 && (ul_LowTiming
2301                                                                         <=
2302                                                                         429496729UL))
2303                                                         || ((b_ClockSelection ==
2304                                                                         APCI1710_40MHZ)
2305                                                                 && (b_TimingUnit
2306                                                                         == 2)
2307                                                                 && (ul_LowTiming
2308                                                                         >= 1)
2309                                                                 && (ul_LowTiming
2310                                                                         <=
2311                                                                         429496UL))
2312                                                         || ((b_ClockSelection ==
2313                                                                         APCI1710_40MHZ)
2314                                                                 && (b_TimingUnit
2315                                                                         == 3)
2316                                                                 && (ul_LowTiming
2317                                                                         >= 1)
2318                                                                 && (ul_LowTiming
2319                                                                         <=
2320                                                                         429UL))
2321                                                         || ((b_ClockSelection ==
2322                                                                         APCI1710_40MHZ)
2323                                                                 && (b_TimingUnit
2324                                                                         == 4)
2325                                                                 && (ul_LowTiming
2326                                                                         >= 1)
2327                                                                 && (ul_LowTiming
2328                                                                         <=
2329                                                                         7UL))) {
2330                                                         /**********************************/
2331                                                         /* Test the High timing selection */
2332                                                         /**********************************/
2333
2334                                                         if (((b_ClockSelection == APCI1710_30MHZ) && (b_TimingUnit == 0) && (ul_HighTiming >= 266) && (ul_HighTiming <= 0xFFFFFFFFUL)) || ((b_ClockSelection == APCI1710_30MHZ) && (b_TimingUnit == 1) && (ul_HighTiming >= 1) && (ul_HighTiming <= 571230650UL)) || ((b_ClockSelection == APCI1710_30MHZ) && (b_TimingUnit == 2) && (ul_HighTiming >= 1) && (ul_HighTiming <= 571230UL)) || ((b_ClockSelection == APCI1710_30MHZ) && (b_TimingUnit == 3) && (ul_HighTiming >= 1) && (ul_HighTiming <= 571UL)) || ((b_ClockSelection == APCI1710_30MHZ) && (b_TimingUnit == 4) && (ul_HighTiming >= 1) && (ul_HighTiming <= 9UL)) || ((b_ClockSelection == APCI1710_33MHZ) && (b_TimingUnit == 0) && (ul_HighTiming >= 242) && (ul_HighTiming <= 0xFFFFFFFFUL)) || ((b_ClockSelection == APCI1710_33MHZ) && (b_TimingUnit == 1) && (ul_HighTiming >= 1) && (ul_HighTiming <= 519691043UL)) || ((b_ClockSelection == APCI1710_33MHZ) && (b_TimingUnit == 2) && (ul_HighTiming >= 1) && (ul_HighTiming <= 519691UL)) || ((b_ClockSelection == APCI1710_33MHZ) && (b_TimingUnit == 3) && (ul_HighTiming >= 1) && (ul_HighTiming <= 520UL)) || ((b_ClockSelection == APCI1710_33MHZ) && (b_TimingUnit == 4) && (ul_HighTiming >= 1) && (ul_HighTiming <= 8UL)) || ((b_ClockSelection == APCI1710_40MHZ) && (b_TimingUnit == 0) && (ul_HighTiming >= 200) && (ul_HighTiming <= 0xFFFFFFFFUL)) || ((b_ClockSelection == APCI1710_40MHZ) && (b_TimingUnit == 1) && (ul_HighTiming >= 1) && (ul_HighTiming <= 429496729UL)) || ((b_ClockSelection == APCI1710_40MHZ) && (b_TimingUnit == 2) && (ul_HighTiming >= 1) && (ul_HighTiming <= 429496UL)) || ((b_ClockSelection == APCI1710_40MHZ) && (b_TimingUnit == 3) && (ul_HighTiming >= 1) && (ul_HighTiming <= 429UL)) || ((b_ClockSelection == APCI1710_40MHZ) && (b_TimingUnit == 4) && (ul_HighTiming >= 1) && (ul_HighTiming <= 7UL))) {
2335                                                                 /************************************/
2336                                                                 /* Calculate the low division fator */
2337                                                                 /************************************/
2338
2339                                                                 fpu_begin();
2340                                                                 switch (b_TimingUnit) {
2341                                                                         /******/
2342                                                                         /* ns */
2343                                                                         /******/
2344
2345                                                                 case 0:
2346
2347                                                                         /******************/
2348                                                                         /* Timer 0 factor */
2349                                                                         /******************/
2350
2351                                                                         ul_LowTimerValue
2352                                                                                 =
2353                                                                                 (unsigned int)
2354                                                                                 (ul_LowTiming
2355                                                                                 *
2356                                                                                 (0.00025 * b_ClockSelection));
2357
2358                                                                         /*******************/
2359                                                                         /* Round the value */
2360                                                                         /*******************/
2361
2362                                                                         if ((double)((double)ul_LowTiming * (0.00025 * (double)b_ClockSelection)) >= ((double)((double)ul_LowTimerValue + 0.5))) {
2363                                                                                 ul_LowTimerValue
2364                                                                                         =
2365                                                                                         ul_LowTimerValue
2366                                                                                         +
2367                                                                                         1;
2368                                                                         }
2369
2370                                                                         /*****************************/
2371                                                                         /* Calculate the real timing */
2372                                                                         /*****************************/
2373
2374                                                                         ul_RealLowTiming
2375                                                                                 =
2376                                                                                 (unsigned int)
2377                                                                                 (ul_LowTimerValue
2378                                                                                 /
2379                                                                                 (0.00025 * (double)b_ClockSelection));
2380                                                                         d_RealLowTiming
2381                                                                                 =
2382                                                                                 (double)
2383                                                                                 ul_LowTimerValue
2384                                                                                 /
2385                                                                                 (0.00025
2386                                                                                 *
2387                                                                                 (double)
2388                                                                                 b_ClockSelection);
2389
2390                                                                         if ((double)((double)ul_LowTimerValue / (0.00025 * (double)b_ClockSelection)) >= (double)((double)ul_RealLowTiming + 0.5)) {
2391                                                                                 ul_RealLowTiming
2392                                                                                         =
2393                                                                                         ul_RealLowTiming
2394                                                                                         +
2395                                                                                         1;
2396                                                                         }
2397
2398                                                                         ul_LowTiming
2399                                                                                 =
2400                                                                                 ul_LowTiming
2401                                                                                 -
2402                                                                                 1;
2403                                                                         ul_LowTimerValue
2404                                                                                 =
2405                                                                                 ul_LowTimerValue
2406                                                                                 -
2407                                                                                 2;
2408
2409                                                                         if (b_ClockSelection != APCI1710_40MHZ) {
2410                                                                                 ul_LowTimerValue
2411                                                                                         =
2412                                                                                         (unsigned int)
2413                                                                                         (
2414                                                                                         (double)
2415                                                                                         (ul_LowTimerValue)
2416                                                                                         *
2417                                                                                         1.007752288);
2418                                                                         }
2419
2420                                                                         break;
2421
2422                                                                         /******/
2423                                                                         /* æs */
2424                                                                         /******/
2425
2426                                                                 case 1:
2427
2428                                                                         /******************/
2429                                                                         /* Timer 0 factor */
2430                                                                         /******************/
2431
2432                                                                         ul_LowTimerValue
2433                                                                                 =
2434                                                                                 (unsigned int)
2435                                                                                 (ul_LowTiming
2436                                                                                 *
2437                                                                                 (0.25 * b_ClockSelection));
2438
2439                                                                         /*******************/
2440                                                                         /* Round the value */
2441                                                                         /*******************/
2442
2443                                                                         if ((double)((double)ul_LowTiming * (0.25 * (double)b_ClockSelection)) >= ((double)((double)ul_LowTimerValue + 0.5))) {
2444                                                                                 ul_LowTimerValue
2445                                                                                         =
2446                                                                                         ul_LowTimerValue
2447                                                                                         +
2448                                                                                         1;
2449                                                                         }
2450
2451                                                                         /*****************************/
2452                                                                         /* Calculate the real timing */
2453                                                                         /*****************************/
2454
2455                                                                         ul_RealLowTiming
2456                                                                                 =
2457                                                                                 (unsigned int)
2458                                                                                 (ul_LowTimerValue
2459                                                                                 /
2460                                                                                 (0.25 * (double)b_ClockSelection));
2461                                                                         d_RealLowTiming
2462                                                                                 =
2463                                                                                 (double)
2464                                                                                 ul_LowTimerValue
2465                                                                                 /
2466                                                                                 (
2467                                                                                 (double)
2468                                                                                 0.25
2469                                                                                 *
2470                                                                                 (double)
2471                                                                                 b_ClockSelection);
2472
2473                                                                         if ((double)((double)ul_LowTimerValue / (0.25 * (double)b_ClockSelection)) >= (double)((double)ul_RealLowTiming + 0.5)) {
2474                                                                                 ul_RealLowTiming
2475                                                                                         =
2476                                                                                         ul_RealLowTiming
2477                                                                                         +
2478                                                                                         1;
2479                                                                         }
2480
2481                                                                         ul_LowTiming
2482                                                                                 =
2483                                                                                 ul_LowTiming
2484                                                                                 -
2485                                                                                 1;
2486                                                                         ul_LowTimerValue
2487                                                                                 =
2488                                                                                 ul_LowTimerValue
2489                                                                                 -
2490                                                                                 2;
2491
2492                                                                         if (b_ClockSelection != APCI1710_40MHZ) {
2493                                                                                 ul_LowTimerValue
2494                                                                                         =
2495                                                                                         (unsigned int)
2496                                                                                         (
2497                                                                                         (double)
2498                                                                                         (ul_LowTimerValue)
2499                                                                                         *
2500                                                                                         1.007752288);
2501                                                                         }
2502
2503                                                                         break;
2504
2505                                                                         /******/
2506                                                                         /* ms */
2507                                                                         /******/
2508
2509                                                                 case 2:
2510
2511                                                                         /******************/
2512                                                                         /* Timer 0 factor */
2513                                                                         /******************/
2514
2515                                                                         ul_LowTimerValue
2516                                                                                 =
2517                                                                                 ul_LowTiming
2518                                                                                 *
2519                                                                                 (250.0
2520                                                                                 *
2521                                                                                 b_ClockSelection);
2522
2523                                                                         /*******************/
2524                                                                         /* Round the value */
2525                                                                         /*******************/
2526
2527                                                                         if ((double)((double)ul_LowTiming * (250.0 * (double)b_ClockSelection)) >= ((double)((double)ul_LowTimerValue + 0.5))) {
2528                                                                                 ul_LowTimerValue
2529                                                                                         =
2530                                                                                         ul_LowTimerValue
2531                                                                                         +
2532                                                                                         1;
2533                                                                         }
2534
2535                                                                         /*****************************/
2536                                                                         /* Calculate the real timing */
2537                                                                         /*****************************/
2538
2539                                                                         ul_RealLowTiming
2540                                                                                 =
2541                                                                                 (unsigned int)
2542                                                                                 (ul_LowTimerValue
2543                                                                                 /
2544                                                                                 (250.0 * (double)b_ClockSelection));
2545                                                                         d_RealLowTiming
2546                                                                                 =
2547                                                                                 (double)
2548                                                                                 ul_LowTimerValue
2549                                                                                 /
2550                                                                                 (250.0
2551                                                                                 *
2552                                                                                 (double)
2553                                                                                 b_ClockSelection);
2554
2555                                                                         if ((double)((double)ul_LowTimerValue / (250.0 * (double)b_ClockSelection)) >= (double)((double)ul_RealLowTiming + 0.5)) {
2556                                                                                 ul_RealLowTiming
2557                                                                                         =
2558                                                                                         ul_RealLowTiming
2559                                                                                         +
2560                                                                                         1;
2561                                                                         }
2562
2563                                                                         ul_LowTiming
2564                                                                                 =
2565                                                                                 ul_LowTiming
2566                                                                                 -
2567                                                                                 1;
2568                                                                         ul_LowTimerValue
2569                                                                                 =
2570                                                                                 ul_LowTimerValue
2571                                                                                 -
2572                                                                                 2;
2573
2574                                                                         if (b_ClockSelection != APCI1710_40MHZ) {
2575                                                                                 ul_LowTimerValue
2576                                                                                         =
2577                                                                                         (unsigned int)
2578                                                                                         (
2579                                                                                         (double)
2580                                                                                         (ul_LowTimerValue)
2581                                                                                         *
2582                                                                                         1.007752288);
2583                                                                         }
2584
2585                                                                         break;
2586
2587                                                                         /*****/
2588                                                                         /* s */
2589                                                                         /*****/
2590
2591                                                                 case 3:
2592
2593                                                                         /******************/
2594                                                                         /* Timer 0 factor */
2595                                                                         /******************/
2596
2597                                                                         ul_LowTimerValue
2598                                                                                 =
2599                                                                                 (unsigned int)
2600                                                                                 (ul_LowTiming
2601                                                                                 *
2602                                                                                 (250000.0
2603                                                                                         *
2604                                                                                         b_ClockSelection));
2605
2606                                                                         /*******************/
2607                                                                         /* Round the value */
2608                                                                         /*******************/
2609
2610                                                                         if ((double)((double)ul_LowTiming * (250000.0 * (double)b_ClockSelection)) >= ((double)((double)ul_LowTimerValue + 0.5))) {
2611                                                                                 ul_LowTimerValue
2612                                                                                         =
2613                                                                                         ul_LowTimerValue
2614                                                                                         +
2615                                                                                         1;
2616                                                                         }
2617
2618                                                                         /*****************************/
2619                                                                         /* Calculate the real timing */
2620                                                                         /*****************************/
2621
2622                                                                         ul_RealLowTiming
2623                                                                                 =
2624                                                                                 (unsigned int)
2625                                                                                 (ul_LowTimerValue
2626                                                                                 /
2627                                                                                 (250000.0
2628                                                                                         *
2629                                                                                         (double)
2630                                                                                         b_ClockSelection));
2631                                                                         d_RealLowTiming
2632                                                                                 =
2633                                                                                 (double)
2634                                                                                 ul_LowTimerValue
2635                                                                                 /
2636                                                                                 (250000.0
2637                                                                                 *
2638                                                                                 (double)
2639                                                                                 b_ClockSelection);
2640
2641                                                                         if ((double)((double)ul_LowTimerValue / (250000.0 * (double)b_ClockSelection)) >= (double)((double)ul_RealLowTiming + 0.5)) {
2642                                                                                 ul_RealLowTiming
2643                                                                                         =
2644                                                                                         ul_RealLowTiming
2645                                                                                         +
2646                                                                                         1;
2647                                                                         }
2648
2649                                                                         ul_LowTiming
2650                                                                                 =
2651                                                                                 ul_LowTiming
2652                                                                                 -
2653                                                                                 1;
2654                                                                         ul_LowTimerValue
2655                                                                                 =
2656                                                                                 ul_LowTimerValue
2657                                                                                 -
2658                                                                                 2;
2659
2660                                                                         if (b_ClockSelection != APCI1710_40MHZ) {
2661                                                                                 ul_LowTimerValue
2662                                                                                         =
2663                                                                                         (unsigned int)
2664                                                                                         (
2665                                                                                         (double)
2666                                                                                         (ul_LowTimerValue)
2667                                                                                         *
2668                                                                                         1.007752288);
2669                                                                         }
2670
2671                                                                         break;
2672
2673                                                                         /******/
2674                                                                         /* mn */
2675                                                                         /******/
2676
2677                                                                 case 4:
2678
2679                                                                         /******************/
2680                                                                         /* Timer 0 factor */
2681                                                                         /******************/
2682
2683                                                                         ul_LowTimerValue
2684                                                                                 =
2685                                                                                 (unsigned int)
2686                                                                                 (
2687                                                                                 (ul_LowTiming
2688                                                                                         *
2689                                                                                         60)
2690                                                                                 *
2691                                                                                 (250000.0
2692                                                                                         *
2693                                                                                         b_ClockSelection));
2694
2695                                                                         /*******************/
2696                                                                         /* Round the value */
2697                                                                         /*******************/
2698
2699                                                                         if ((double)((double)(ul_LowTiming * 60.0) * (250000.0 * (double)b_ClockSelection)) >= ((double)((double)ul_LowTimerValue + 0.5))) {
2700                                                                                 ul_LowTimerValue
2701                                                                                         =
2702                                                                                         ul_LowTimerValue
2703                                                                                         +
2704                                                                                         1;
2705                                                                         }
2706
2707                                                                         /*****************************/
2708                                                                         /* Calculate the real timing */
2709                                                                         /*****************************/
2710
2711                                                                         ul_RealLowTiming
2712                                                                                 =
2713                                                                                 (unsigned int)
2714                                                                                 (ul_LowTimerValue
2715                                                                                 /
2716                                                                                 (250000.0
2717                                                                                         *
2718                                                                                         (double)
2719                                                                                         b_ClockSelection))
2720                                                                                 /
2721                                                                                 60;
2722                                                                         d_RealLowTiming
2723                                                                                 =
2724                                                                                 (
2725                                                                                 (double)
2726                                                                                 ul_LowTimerValue
2727                                                                                 /
2728                                                                                 (250000.0
2729                                                                                         *
2730                                                                                         (double)
2731                                                                                         b_ClockSelection))
2732                                                                                 /
2733                                                                                 60.0;
2734
2735                                                                         if ((double)(((double)ul_LowTimerValue / (250000.0 * (double)b_ClockSelection)) / 60.0) >= (double)((double)ul_RealLowTiming + 0.5)) {
2736                                                                                 ul_RealLowTiming
2737                                                                                         =
2738                                                                                         ul_RealLowTiming
2739                                                                                         +
2740                                                                                         1;
2741                                                                         }
2742
2743                                                                         ul_LowTiming
2744                                                                                 =
2745                                                                                 ul_LowTiming
2746                                                                                 -
2747                                                                                 1;
2748                                                                         ul_LowTimerValue
2749                                                                                 =
2750                                                                                 ul_LowTimerValue
2751                                                                                 -
2752                                                                                 2;
2753
2754                                                                         if (b_ClockSelection != APCI1710_40MHZ) {
2755                                                                                 ul_LowTimerValue
2756                                                                                         =
2757                                                                                         (unsigned int)
2758                                                                                         (
2759                                                                                         (double)
2760                                                                                         (ul_LowTimerValue)
2761                                                                                         *
2762                                                                                         1.007752288);
2763                                                                         }
2764
2765                                                                         break;
2766                                                                 }
2767
2768                                                                 /*************************************/
2769                                                                 /* Calculate the high division fator */
2770                                                                 /*************************************/
2771
2772                                                                 switch (b_TimingUnit) {
2773                                                                         /******/
2774                                                                         /* ns */
2775                                                                         /******/
2776
2777                                                                 case 0:
2778
2779                                                                         /******************/
2780                                                                         /* Timer 0 factor */
2781                                                                         /******************/
2782
2783                                                                         ul_HighTimerValue
2784                                                                                 =
2785                                                                                 (unsigned int)
2786                                                                                 (ul_HighTiming
2787                                                                                 *
2788                                                                                 (0.00025 * b_ClockSelection));
2789
2790                                                                         /*******************/
2791                                                                         /* Round the value */
2792                                                                         /*******************/
2793
2794                                                                         if ((double)((double)ul_HighTiming * (0.00025 * (double)b_ClockSelection)) >= ((double)((double)ul_HighTimerValue + 0.5))) {
2795                                                                                 ul_HighTimerValue
2796                                                                                         =
2797                                                                                         ul_HighTimerValue
2798                                                                                         +
2799                                                                                         1;
2800                                                                         }
2801
2802                                                                         /*****************************/
2803                                                                         /* Calculate the real timing */
2804                                                                         /*****************************/
2805
2806                                                                         ul_RealHighTiming
2807                                                                                 =
2808                                                                                 (unsigned int)
2809                                                                                 (ul_HighTimerValue
2810                                                                                 /
2811                                                                                 (0.00025 * (double)b_ClockSelection));
2812                                                                         d_RealHighTiming
2813                                                                                 =
2814                                                                                 (double)
2815                                                                                 ul_HighTimerValue
2816                                                                                 /
2817                                                                                 (0.00025
2818                                                                                 *
2819                                                                                 (double)
2820                                                                                 b_ClockSelection);
2821
2822                                                                         if ((double)((double)ul_HighTimerValue / (0.00025 * (double)b_ClockSelection)) >= (double)((double)ul_RealHighTiming + 0.5)) {
2823                                                                                 ul_RealHighTiming
2824                                                                                         =
2825                                                                                         ul_RealHighTiming
2826                                                                                         +
2827                                                                                         1;
2828                                                                         }
2829
2830                                                                         ul_HighTiming
2831                                                                                 =
2832                                                                                 ul_HighTiming
2833                                                                                 -
2834                                                                                 1;
2835                                                                         ul_HighTimerValue
2836                                                                                 =
2837                                                                                 ul_HighTimerValue
2838                                                                                 -
2839                                                                                 2;
2840
2841                                                                         if (b_ClockSelection != APCI1710_40MHZ) {
2842                                                                                 ul_HighTimerValue
2843                                                                                         =
2844                                                                                         (unsigned int)
2845                                                                                         (
2846                                                                                         (double)
2847                                                                                         (ul_HighTimerValue)
2848                                                                                         *
2849                                                                                         1.007752288);
2850                                                                         }
2851
2852                                                                         break;
2853
2854                                                                         /******/
2855                                                                         /* æs */
2856                                                                         /******/
2857
2858                                                                 case 1:
2859
2860                                                                         /******************/
2861                                                                         /* Timer 0 factor */
2862                                                                         /******************/
2863
2864                                                                         ul_HighTimerValue
2865                                                                                 =
2866                                                                                 (unsigned int)
2867                                                                                 (ul_HighTiming
2868                                                                                 *
2869                                                                                 (0.25 * b_ClockSelection));
2870
2871                                                                         /*******************/
2872                                                                         /* Round the value */
2873                                                                         /*******************/
2874
2875                                                                         if ((double)((double)ul_HighTiming * (0.25 * (double)b_ClockSelection)) >= ((double)((double)ul_HighTimerValue + 0.5))) {
2876                                                                                 ul_HighTimerValue
2877                                                                                         =
2878                                                                                         ul_HighTimerValue
2879                                                                                         +
2880                                                                                         1;
2881                                                                         }
2882
2883                                                                         /*****************************/
2884                                                                         /* Calculate the real timing */
2885                                                                         /*****************************/
2886
2887                                                                         ul_RealHighTiming
2888                                                                                 =
2889                                                                                 (unsigned int)
2890                                                                                 (ul_HighTimerValue
2891                                                                                 /
2892                                                                                 (0.25 * (double)b_ClockSelection));
2893                                                                         d_RealHighTiming
2894                                                                                 =
2895                                                                                 (double)
2896                                                                                 ul_HighTimerValue
2897                                                                                 /
2898                                                                                 (
2899                                                                                 (double)
2900                                                                                 0.25
2901                                                                                 *
2902                                                                                 (double)
2903                                                                                 b_ClockSelection);
2904
2905                                                                         if ((double)((double)ul_HighTimerValue / (0.25 * (double)b_ClockSelection)) >= (double)((double)ul_RealHighTiming + 0.5)) {
2906                                                                                 ul_RealHighTiming
2907                                                                                         =
2908                                                                                         ul_RealHighTiming
2909                                                                                         +
2910                                                                                         1;
2911                                                                         }
2912
2913                                                                         ul_HighTiming
2914                                                                                 =
2915                                                                                 ul_HighTiming
2916                                                                                 -
2917                                                                                 1;
2918                                                                         ul_HighTimerValue
2919                                                                                 =
2920                                                                                 ul_HighTimerValue
2921                                                                                 -
2922                                                                                 2;
2923
2924                                                                         if (b_ClockSelection != APCI1710_40MHZ) {
2925                                                                                 ul_HighTimerValue
2926                                                                                         =
2927                                                                                         (unsigned int)
2928                                                                                         (
2929                                                                                         (double)
2930                                                                                         (ul_HighTimerValue)
2931                                                                                         *
2932                                                                                         1.007752288);
2933                                                                         }
2934
2935                                                                         break;
2936
2937                                                                         /******/
2938                                                                         /* ms */
2939                                                                         /******/
2940
2941                                                                 case 2:
2942
2943                                                                         /******************/
2944                                                                         /* Timer 0 factor */
2945                                                                         /******************/
2946
2947                                                                         ul_HighTimerValue
2948                                                                                 =
2949                                                                                 ul_HighTiming
2950                                                                                 *
2951                                                                                 (250.0
2952                                                                                 *
2953                                                                                 b_ClockSelection);
2954
2955                                                                         /*******************/
2956                                                                         /* Round the value */
2957                                                                         /*******************/
2958
2959                                                                         if ((double)((double)ul_HighTiming * (250.0 * (double)b_ClockSelection)) >= ((double)((double)ul_HighTimerValue + 0.5))) {
2960                                                                                 ul_HighTimerValue
2961                                                                                         =
2962                                                                                         ul_HighTimerValue
2963                                                                                         +
2964                                                                                         1;
2965                                                                         }
2966
2967                                                                         /*****************************/
2968                                                                         /* Calculate the real timing */
2969                                                                         /*****************************/
2970
2971                                                                         ul_RealHighTiming
2972                                                                                 =
2973                                                                                 (unsigned int)
2974                                                                                 (ul_HighTimerValue
2975                                                                                 /
2976                                                                                 (250.0 * (double)b_ClockSelection));
2977                                                                         d_RealHighTiming
2978                                                                                 =
2979                                                                                 (double)
2980                                                                                 ul_HighTimerValue
2981                                                                                 /
2982                                                                                 (250.0
2983                                                                                 *
2984                                                                                 (double)
2985                                                                                 b_ClockSelection);
2986
2987                                                                         if ((double)((double)ul_HighTimerValue / (250.0 * (double)b_ClockSelection)) >= (double)((double)ul_RealHighTiming + 0.5)) {
2988                                                                                 ul_RealHighTiming
2989                                                                                         =
2990                                                                                         ul_RealHighTiming
2991                                                                                         +
2992                                                                                         1;
2993                                                                         }
2994
2995                                                                         ul_HighTiming
2996                                                                                 =
2997                                                                                 ul_HighTiming
2998                                                                                 -
2999                                                                                 1;
3000                                                                         ul_HighTimerValue
3001                                                                                 =
3002                                                                                 ul_HighTimerValue
3003                                                                                 -
3004                                                                                 2;
3005
3006                                                                         if (b_ClockSelection != APCI1710_40MHZ) {
3007                                                                                 ul_HighTimerValue
3008                                                                                         =
3009                                                                                         (unsigned int)
3010                                                                                         (
3011                                                                                         (double)
3012                                                                                         (ul_HighTimerValue)
3013                                                                                         *
3014                                                                                         1.007752288);
3015                                                                         }
3016
3017                                                                         break;
3018
3019                                                                         /*****/
3020                                                                         /* s */
3021                                                                         /*****/
3022
3023                                                                 case 3:
3024
3025                                                                         /******************/
3026                                                                         /* Timer 0 factor */
3027                                                                         /******************/
3028
3029                                                                         ul_HighTimerValue
3030                                                                                 =
3031                                                                                 (unsigned int)
3032                                                                                 (ul_HighTiming
3033                                                                                 *
3034                                                                                 (250000.0
3035                                                                                         *
3036                                                                                         b_ClockSelection));
3037
3038                                                                         /*******************/
3039                                                                         /* Round the value */
3040                                                                         /*******************/
3041
3042                                                                         if ((double)((double)ul_HighTiming * (250000.0 * (double)b_ClockSelection)) >= ((double)((double)ul_HighTimerValue + 0.5))) {
3043                                                                                 ul_HighTimerValue
3044                                                                                         =
3045                                                                                         ul_HighTimerValue
3046                                                                                         +
3047                                                                                         1;
3048                                                                         }
3049
3050                                                                         /*****************************/
3051                                                                         /* Calculate the real timing */
3052                                                                         /*****************************/
3053
3054                                                                         ul_RealHighTiming
3055                                                                                 =
3056                                                                                 (unsigned int)
3057                                                                                 (ul_HighTimerValue
3058                                                                                 /
3059                                                                                 (250000.0
3060                                                                                         *
3061                                                                                         (double)
3062                                                                                         b_ClockSelection));
3063                                                                         d_RealHighTiming
3064                                                                                 =
3065                                                                                 (double)
3066                                                                                 ul_HighTimerValue
3067                                                                                 /
3068                                                                                 (250000.0
3069                                                                                 *
3070                                                                                 (double)
3071                                                                                 b_ClockSelection);
3072
3073                                                                         if ((double)((double)ul_HighTimerValue / (250000.0 * (double)b_ClockSelection)) >= (double)((double)ul_RealHighTiming + 0.5)) {
3074                                                                                 ul_RealHighTiming
3075                                                                                         =
3076                                                                                         ul_RealHighTiming
3077                                                                                         +
3078                                                                                         1;
3079                                                                         }
3080
3081                                                                         ul_HighTiming
3082                                                                                 =
3083                                                                                 ul_HighTiming
3084                                                                                 -
3085                                                                                 1;
3086                                                                         ul_HighTimerValue
3087                                                                                 =
3088                                                                                 ul_HighTimerValue
3089                                                                                 -
3090                                                                                 2;
3091
3092                                                                         if (b_ClockSelection != APCI1710_40MHZ) {
3093                                                                                 ul_HighTimerValue
3094                                                                                         =
3095                                                                                         (unsigned int)
3096                                                                                         (
3097                                                                                         (double)
3098                                                                                         (ul_HighTimerValue)
3099                                                                                         *
3100                                                                                         1.007752288);
3101                                                                         }
3102
3103                                                                         break;
3104
3105                                                                         /******/
3106                                                                         /* mn */
3107                                                                         /******/
3108
3109                                                                 case 4:
3110
3111                                                                         /******************/
3112                                                                         /* Timer 0 factor */
3113                                                                         /******************/
3114
3115                                                                         ul_HighTimerValue
3116                                                                                 =
3117                                                                                 (unsigned int)
3118                                                                                 (
3119                                                                                 (ul_HighTiming
3120                                                                                         *
3121                                                                                         60)
3122                                                                                 *
3123                                                                                 (250000.0
3124                                                                                         *
3125                                                                                         b_ClockSelection));
3126
3127                                                                         /*******************/
3128                                                                         /* Round the value */
3129                                                                         /*******************/
3130
3131                                                                         if ((double)((double)(ul_HighTiming * 60.0) * (250000.0 * (double)b_ClockSelection)) >= ((double)((double)ul_HighTimerValue + 0.5))) {
3132                                                                                 ul_HighTimerValue
3133                                                                                         =
3134                                                                                         ul_HighTimerValue
3135                                                                                         +
3136                                                                                         1;
3137                                                                         }
3138
3139                                                                         /*****************************/
3140                                                                         /* Calculate the real timing */
3141                                                                         /*****************************/
3142
3143                                                                         ul_RealHighTiming
3144                                                                                 =
3145                                                                                 (unsigned int)
3146                                                                                 (ul_HighTimerValue
3147                                                                                 /
3148                                                                                 (250000.0
3149                                                                                         *
3150                                                                                         (double)
3151                                                                                         b_ClockSelection))
3152                                                                                 /
3153                                                                                 60;
3154                                                                         d_RealHighTiming
3155                                                                                 =
3156                                                                                 (
3157                                                                                 (double)
3158                                                                                 ul_HighTimerValue
3159                                                                                 /
3160                                                                                 (250000.0
3161                                                                                         *
3162                                                                                         (double)
3163                                                                                         b_ClockSelection))
3164                                                                                 /
3165                                                                                 60.0;
3166
3167                                                                         if ((double)(((double)ul_HighTimerValue / (250000.0 * (double)b_ClockSelection)) / 60.0) >= (double)((double)ul_RealHighTiming + 0.5)) {
3168                                                                                 ul_RealHighTiming
3169                                                                                         =
3170                                                                                         ul_RealHighTiming
3171                                                                                         +
3172                                                                                         1;
3173                                                                         }
3174
3175                                                                         ul_HighTiming
3176                                                                                 =
3177                                                                                 ul_HighTiming
3178                                                                                 -
3179                                                                                 1;
3180                                                                         ul_HighTimerValue
3181                                                                                 =
3182                                                                                 ul_HighTimerValue
3183                                                                                 -
3184                                                                                 2;
3185
3186                                                                         if (b_ClockSelection != APCI1710_40MHZ) {
3187                                                                                 ul_HighTimerValue
3188                                                                                         =
3189                                                                                         (unsigned int)
3190                                                                                         (
3191                                                                                         (double)
3192                                                                                         (ul_HighTimerValue)
3193                                                                                         *
3194                                                                                         1.007752288);
3195                                                                         }
3196
3197                                                                         break;
3198                                                                 }
3199
3200                                                                 fpu_end();
3201
3202                                                                 /************************/
3203                                                                 /* Save the timing unit */
3204                                                                 /************************/
3205
3206                                                                 devpriv->
3207                                                                         s_ModuleInfo
3208                                                                         [b_ModulNbr].
3209                                                                         s_PWMModuleInfo.
3210                                                                         s_PWMInfo
3211                                                                         [b_PWM].
3212                                                                         b_TimingUnit
3213                                                                         =
3214                                                                         b_TimingUnit;
3215
3216                                                                 /****************************/
3217                                                                 /* Save the low base timing */
3218                                                                 /****************************/
3219
3220                                                                 devpriv->
3221                                                                         s_ModuleInfo
3222                                                                         [b_ModulNbr].
3223                                                                         s_PWMModuleInfo.
3224                                                                         s_PWMInfo
3225                                                                         [b_PWM].
3226                                                                         d_LowTiming
3227                                                                         =
3228                                                                         d_RealLowTiming;
3229
3230                                                                 devpriv->
3231                                                                         s_ModuleInfo
3232                                                                         [b_ModulNbr].
3233                                                                         s_PWMModuleInfo.
3234                                                                         s_PWMInfo
3235                                                                         [b_PWM].
3236                                                                         ul_RealLowTiming
3237                                                                         =
3238                                                                         ul_RealLowTiming;
3239
3240                                                                 /****************************/
3241                                                                 /* Save the high base timing */
3242                                                                 /****************************/
3243
3244                                                                 devpriv->
3245                                                                         s_ModuleInfo
3246                                                                         [b_ModulNbr].
3247                                                                         s_PWMModuleInfo.
3248                                                                         s_PWMInfo
3249                                                                         [b_PWM].
3250                                                                         d_HighTiming
3251                                                                         =
3252                                                                         d_RealHighTiming;
3253
3254                                                                 devpriv->
3255                                                                         s_ModuleInfo
3256                                                                         [b_ModulNbr].
3257                                                                         s_PWMModuleInfo.
3258                                                                         s_PWMInfo
3259                                                                         [b_PWM].
3260                                                                         ul_RealHighTiming
3261                                                                         =
3262                                                                         ul_RealHighTiming;
3263
3264                                                                 /************************/
3265                                                                 /* Write the low timing */
3266                                                                 /************************/
3267
3268                                                                 outl(ul_LowTimerValue, devpriv->s_BoardInfos.ui_Address + 0 + (20 * b_PWM) + (64 * b_ModulNbr));
3269
3270                                                                 /*************************/
3271                                                                 /* Write the high timing */
3272                                                                 /*************************/
3273
3274                                                                 outl(ul_HighTimerValue, devpriv->s_BoardInfos.ui_Address + 4 + (20 * b_PWM) + (64 * b_ModulNbr));
3275
3276                                                                 /***************************/
3277                                                                 /* Set the clock selection */
3278                                                                 /***************************/
3279
3280                                                                 dw_Command =
3281                                                                         inl
3282                                                                         (devpriv->
3283                                                                         s_BoardInfos.
3284                                                                         ui_Address
3285                                                                         + 8 +
3286                                                                         (20 * b_PWM) + (64 * b_ModulNbr));
3287
3288                                                                 dw_Command =
3289                                                                         dw_Command
3290                                                                         & 0x7F;
3291
3292                                                                 if (b_ClockSelection == APCI1710_40MHZ) {
3293                                                                         dw_Command
3294                                                                                 =
3295                                                                                 dw_Command
3296                                                                                 |
3297                                                                                 0x80;
3298                                                                 }
3299
3300                                                                 /***************************/
3301                                                                 /* Set the clock selection */
3302                                                                 /***************************/
3303
3304                                                                 outl(dw_Command,
3305                                                                         devpriv->
3306                                                                         s_BoardInfos.
3307                                                                         ui_Address
3308                                                                         + 8 +
3309                                                                         (20 * b_PWM) + (64 * b_ModulNbr));
3310                                                         } else {
3311                                                                 /***************************************/
3312                                                                 /* High base timing selection is wrong */
3313                                                                 /***************************************/
3314                                                                 DPRINTK("High base timing selection is wrong\n");
3315                                                                 i_ReturnValue =
3316                                                                         -8;
3317                                                         }
3318                                                 } else {
3319                                                         /**************************************/
3320                                                         /* Low base timing selection is wrong */
3321                                                         /**************************************/
3322                                                         DPRINTK("Low base timing selection is wrong\n");
3323                                                         i_ReturnValue = -7;
3324                                                 }
3325                                         }       /*  if ((b_TimingUnit >= 0) && (b_TimingUnit <= 4)) */
3326                                         else {
3327                                                 /**********************************/
3328                                                 /* Timing unit selection is wrong */
3329                                                 /**********************************/
3330                                                 DPRINTK("Timing unit selection is wrong\n");
3331                                                 i_ReturnValue = -6;
3332                                         }       /*  if ((b_TimingUnit >= 0) && (b_TimingUnit <= 4)) */
3333                                 }       /*  if (dw_Status & 0x10) */
3334                                 else {
3335                                         /***********************/
3336                                         /* PWM not initialised */
3337                                         /***********************/
3338                                         DPRINTK("PWM not initialised\n");
3339                                         i_ReturnValue = -5;
3340                                 }       /*  if (dw_Status & 0x10) */
3341                         }       /*  if (b_PWM >= 0 && b_PWM <= 1) */
3342                         else {
3343                                 /******************************/
3344                                 /* Tor PWM selection is wrong */
3345                                 /******************************/
3346                                 DPRINTK("Tor PWM selection is wrong\n");
3347                                 i_ReturnValue = -4;
3348                         }       /*  if (b_PWM >= 0 && b_PWM <= 1) */
3349                 } else {
3350                         /**********************************/
3351                         /* The module is not a PWM module */
3352                         /**********************************/
3353                         DPRINTK("The module is not a PWM module\n");
3354                         i_ReturnValue = -3;
3355                 }
3356         } else {
3357                 /***********************/
3358                 /* Module number error */
3359                 /***********************/
3360                 DPRINTK("Module number error\n");
3361                 i_ReturnValue = -2;
3362         }
3363
3364         return i_ReturnValue;
3365 }
3366
3367 /*
3368  * Pwm Enable Disable and Set New Timing
3369  */
3370 static int i_APCI1710_InsnWritePWM(struct comedi_device *dev,
3371                                    struct comedi_subdevice *s,
3372                                    struct comedi_insn *insn,
3373                                    unsigned int *data)
3374 {
3375         unsigned char b_WriteType;
3376         int i_ReturnValue = 0;
3377         b_WriteType = CR_CHAN(insn->chanspec);
3378
3379         switch (b_WriteType) {
3380         case APCI1710_PWM_ENABLE:
3381                 i_ReturnValue = i_APCI1710_EnablePWM(dev,
3382                         (unsigned char) CR_AREF(insn->chanspec),
3383                         (unsigned char) data[0],
3384                         (unsigned char) data[1],
3385                         (unsigned char) data[2],
3386                         (unsigned char) data[3], (unsigned char) data[4], (unsigned char) data[5]);
3387                 break;
3388
3389         case APCI1710_PWM_DISABLE:
3390                 i_ReturnValue = i_APCI1710_DisablePWM(dev,
3391                         (unsigned char) CR_AREF(insn->chanspec), (unsigned char) data[0]);
3392                 break;
3393
3394         case APCI1710_PWM_NEWTIMING:
3395                 i_ReturnValue = i_APCI1710_SetNewPWMTiming(dev,
3396                         (unsigned char) CR_AREF(insn->chanspec),
3397                         (unsigned char) data[0],
3398                         (unsigned char) data[1], (unsigned int) data[2], (unsigned int) data[3]);
3399                 break;
3400
3401         default:
3402                 printk("Write Config Parameter Wrong\n");
3403         }
3404
3405         if (i_ReturnValue >= 0)
3406                 i_ReturnValue = insn->n;
3407         return i_ReturnValue;
3408 }
3409
3410 /*
3411 +----------------------------------------------------------------------------+
3412 | Function Name     : _INT_ i_APCI1710_GetPWMStatus                          |
3413 |                               (unsigned char_    b_BoardHandle,                     |
3414 |                                unsigned char_    b_ModulNbr,                        |
3415 |                                unsigned char_    b_PWM,                             |
3416 |                                unsigned char *_  pb_PWMOutputStatus,                 |
3417 |                                unsigned char *_  pb_ExternGateStatus)                |
3418 +----------------------------------------------------------------------------+
3419 | Task              : Return the status from selected PWM (b_PWM) from       |
3420 |                     selected module (b_ModulNbr).                          |
3421 +----------------------------------------------------------------------------+
3422 | Input Parameters  : unsigned char_  b_BoardHandle : Handle of board APCI-1710       |
3423 |                     unsigned char_  b_PWM         : Selected PWM (0 or 1)           |
3424 |                     unsigned char_  b_ModulNbr    : Selected module number (0 to 3)
3425         b_ModulNbr                      =(unsigned char)  CR_AREF(insn->chanspec);
3426         b_PWM                           =(unsigned char)  data[0];
3427
3428  |
3429 +----------------------------------------------------------------------------+
3430 | Output Parameters : unsigned char *_  pb_PWMOutputStatus  : Return the PWM output    |
3431 |                                                   level status.            |
3432 |                                                    0 : The PWM output level|
3433 |                                                        is low.             |
3434 |                                                    1 : The PWM output level|
3435 |                                                        is high.            |
3436 |                     unsigned char *_  pb_ExternGateStatus : Return the extern gate   |
3437 |                                                   level status.            |
3438 |                                                    0 : The extern gate is  |
3439 |                                                        low.                |
3440 |                                                    1 : The extern gate is  |
3441 |                                                        high.
3442     pb_PWMOutputStatus  =(unsigned char *) data[0];
3443         pb_ExternGateStatus =(unsigned char *) data[1];             |
3444 +----------------------------------------------------------------------------+
3445 | Return Value      :  0: No error                                           |
3446 |                     -1: The handle parameter of the board is wrong         |
3447 |                     -2: Module selection wrong                             |
3448 |                     -3: The module is not a PWM module                     |
3449 |                     -4: PWM selection is wrong                             |
3450 |                     -5: PWM not initialised see function                   |
3451 |                         "i_APCI1710_InitPWM"                               |
3452 |                     -6: PWM not enabled see function "i_APCI1710_EnablePWM"|
3453 +----------------------------------------------------------------------------+
3454 */
3455 static int i_APCI1710_InsnReadGetPWMStatus(struct comedi_device *dev,
3456                                            struct comedi_subdevice *s,
3457                                            struct comedi_insn *insn,
3458                                            unsigned int *data)
3459 {
3460         struct addi_private *devpriv = dev->private;
3461         int i_ReturnValue = 0;
3462         unsigned int dw_Status;
3463         unsigned char b_ModulNbr;
3464         unsigned char b_PWM;
3465         unsigned char *pb_PWMOutputStatus;
3466         unsigned char *pb_ExternGateStatus;
3467
3468         i_ReturnValue = insn->n;
3469         b_ModulNbr = (unsigned char) CR_AREF(insn->chanspec);
3470         b_PWM = (unsigned char) CR_CHAN(insn->chanspec);
3471         pb_PWMOutputStatus = (unsigned char *) &data[0];
3472         pb_ExternGateStatus = (unsigned char *) &data[1];
3473
3474         /**************************/
3475         /* Test the module number */
3476         /**************************/
3477
3478         if (b_ModulNbr < 4) {
3479                 /***************/
3480                 /* Test if PWM */
3481                 /***************/
3482
3483                 if ((devpriv->s_BoardInfos.
3484                                 dw_MolduleConfiguration[b_ModulNbr] &
3485                                 0xFFFF0000UL) == APCI1710_PWM) {
3486                         /**************************/
3487                         /* Test the PWM selection */
3488                         /**************************/
3489
3490                         if (b_PWM <= 1) {
3491                                 /***************************/
3492                                 /* Test if PWM initialised */
3493                                 /***************************/
3494
3495                                 dw_Status = inl(devpriv->s_BoardInfos.
3496                                         ui_Address + 12 + (20 * b_PWM) +
3497                                         (64 * b_ModulNbr));
3498
3499                                 if (dw_Status & 0x10) {
3500                                         /***********************/
3501                                         /* Test if PWM enabled */
3502                                         /***********************/
3503
3504                                         if (dw_Status & 0x1) {
3505                                                 *pb_PWMOutputStatus =
3506                                                         (unsigned char) ((dw_Status >> 7)
3507                                                         & 1);
3508                                                 *pb_ExternGateStatus =
3509                                                         (unsigned char) ((dw_Status >> 6)
3510                                                         & 1);
3511                                         }       /*  if (dw_Status & 0x1) */
3512                                         else {
3513                                                 /*******************/
3514                                                 /* PWM not enabled */
3515                                                 /*******************/
3516
3517                                                 DPRINTK("PWM not enabled \n");
3518                                                 i_ReturnValue = -6;
3519                                         }       /*  if (dw_Status & 0x1) */
3520                                 }       /*  if (dw_Status & 0x10) */
3521                                 else {
3522                                         /***********************/
3523                                         /* PWM not initialised */
3524                                         /***********************/
3525
3526                                         DPRINTK("PWM not initialised\n");
3527                                         i_ReturnValue = -5;
3528                                 }       /*  if (dw_Status & 0x10) */
3529                         }       /*  if (b_PWM >= 0 && b_PWM <= 1) */
3530                         else {
3531                                 /******************************/
3532                                 /* Tor PWM selection is wrong */
3533                                 /******************************/
3534
3535                                 DPRINTK("Tor PWM selection is wrong\n");
3536                                 i_ReturnValue = -4;
3537                         }       /*  if (b_PWM >= 0 && b_PWM <= 1) */
3538                 } else {
3539                         /**********************************/
3540                         /* The module is not a PWM module */
3541                         /**********************************/
3542
3543                         DPRINTK("The module is not a PWM module\n");
3544                         i_ReturnValue = -3;
3545                 }
3546         } else {
3547                 /***********************/
3548                 /* Module number error */
3549                 /***********************/
3550
3551                 DPRINTK("Module number error\n");
3552                 i_ReturnValue = -2;
3553         }
3554
3555         return i_ReturnValue;
3556 }
3557
3558 static int i_APCI1710_InsnBitsReadPWMInterrupt(struct comedi_device *dev,
3559                                                struct comedi_subdevice *s,
3560                                                struct comedi_insn *insn,
3561                                                unsigned int *data)
3562 {
3563         struct addi_private *devpriv = dev->private;
3564
3565         data[0] = devpriv->s_InterruptParameters.
3566                 s_FIFOInterruptParameters[devpriv->
3567                 s_InterruptParameters.ui_Read].b_OldModuleMask;
3568         data[1] = devpriv->s_InterruptParameters.
3569                 s_FIFOInterruptParameters[devpriv->
3570                 s_InterruptParameters.ui_Read].ul_OldInterruptMask;
3571         data[2] = devpriv->s_InterruptParameters.
3572                 s_FIFOInterruptParameters[devpriv->
3573                 s_InterruptParameters.ui_Read].ul_OldCounterLatchValue;
3574
3575         /**************************/
3576         /* Increment the read FIFO */
3577         /***************************/
3578
3579         devpriv->
3580                 s_InterruptParameters.
3581                 ui_Read = (devpriv->
3582                 s_InterruptParameters.ui_Read + 1) % APCI1710_SAVE_INTERRUPT;
3583
3584         return insn->n;
3585
3586 }