1 /**
2 * @file me1600_ao.c
3 *
4 * @brief ME-1600 analog output subdevice instance.
5 * @note Copyright (C) 2007 Meilhaus Electronic GmbH (support@meilhaus.de)
6 * @author Guenter Gebhardt
7 * @author Krzysztof Gantzke (k.gantzke@meilhaus.de)
8 */
9
10 /*
11 * Copyright (C) 2007 Meilhaus Electronic GmbH (support@meilhaus.de)
12 *
13 * This file is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or
16 * (at your option) any later version.
17 *
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the Free Software
25 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 */
27
28 #ifndef __KERNEL__
29 # define __KERNEL__
30 #endif
31
32 /* Includes
33 */
34
35 #include <linux/module.h>
36
37 #include <linux/slab.h>
38 #include <linux/spinlock.h>
39 #include <asm/io.h>
40 #include <linux/types.h>
41 #include <linux/sched.h>
42
43 #include <linux/workqueue.h>
44
45 #include "medefines.h"
46 #include "meinternal.h"
47 #include "meerror.h"
48 #include "medebug.h"
49
50 #include "me1600_ao_reg.h"
51 #include "me1600_ao.h"
52
53 /* Defines
54 */
55
56 static void me1600_ao_destructor(struct me_subdevice *subdevice);
57
58 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
59 static void me1600_ao_work_control_task(void *subdevice);
60 #else
61 static void me1600_ao_work_control_task(struct work_struct *work);
62 #endif
63
64 static int me1600_ao_io_reset_subdevice(me_subdevice_t * subdevice,
65 struct file *filep, int flags);
66 static int me1600_ao_io_single_config(me_subdevice_t * subdevice,
67 struct file *filep, int channel,
68 int single_config, int ref, int trig_chan,
69 int trig_type, int trig_edge, int flags);
70 static int me1600_ao_io_single_read(me_subdevice_t * subdevice,
71 struct file *filep, int channel, int *value,
72 int time_out, int flags);
73 static int me1600_ao_io_single_write(me_subdevice_t * subdevice,
74 struct file *filep, int channel, int value,
75 int time_out, int flags);
76 static int me1600_ao_query_number_channels(me_subdevice_t * subdevice,
77 int *number);
78 static int me1600_ao_query_subdevice_type(me_subdevice_t * subdevice, int *type,
79 int *subtype);
80 static int me1600_ao_query_subdevice_caps(me_subdevice_t * subdevice,
81 int *caps);
82 static int me1600_ao_query_range_by_min_max(me_subdevice_t * subdevice,
83 int unit, int *min, int *max,
84 int *maxdata, int *range);
85 static int me1600_ao_query_number_ranges(me_subdevice_t * subdevice, int unit,
86 int *count);
87 static int me1600_ao_query_range_info(me_subdevice_t * subdevice, int range,
88 int *unit, int *min, int *max,
89 int *maxdata);
90
91 /* Functions
92 */
93
me1600_ao_constructor(uint32_t reg_base,unsigned int ao_idx,int curr,spinlock_t * config_regs_lock,spinlock_t * ao_shadows_lock,me1600_ao_shadow_t * ao_regs_shadows,struct workqueue_struct * me1600_wq)94 me1600_ao_subdevice_t *me1600_ao_constructor(uint32_t reg_base,
95 unsigned int ao_idx,
96 int curr,
97 spinlock_t * config_regs_lock,
98 spinlock_t * ao_shadows_lock,
99 me1600_ao_shadow_t *
100 ao_regs_shadows,
101 struct workqueue_struct *me1600_wq)
102 {
103 me1600_ao_subdevice_t *subdevice;
104 int err;
105
106 PDEBUG("executed. idx=%d\n", ao_idx);
107
108 // Allocate memory for subdevice instance.
109 subdevice = kmalloc(sizeof(me1600_ao_subdevice_t), GFP_KERNEL);
110
111 if (!subdevice) {
112 PERROR
113 ("Cannot get memory for analog output subdevice instance.\n");
114 return NULL;
115 }
116
117 memset(subdevice, 0, sizeof(me1600_ao_subdevice_t));
118
119 // Initialize subdevice base class.
120 err = me_subdevice_init(&subdevice->base);
121
122 if (err) {
123 PERROR("Cannot initialize subdevice base class instance.\n");
124 kfree(subdevice);
125 return NULL;
126 }
127 // Initialize spin locks.
128 spin_lock_init(&subdevice->subdevice_lock);
129 subdevice->config_regs_lock = config_regs_lock;
130 subdevice->ao_shadows_lock = ao_shadows_lock;
131
132 // Save the subdevice index.
133 subdevice->ao_idx = ao_idx;
134
135 // Initialize range lists.
136 subdevice->u_ranges_count = 2;
137
138 subdevice->u_ranges[0].min = 0; //0V
139 subdevice->u_ranges[0].max = 9997558; //10V
140
141 subdevice->u_ranges[1].min = -10E6; //-10V
142 subdevice->u_ranges[1].max = 9995117; //10V
143
144 if (curr) { // This is version with current outputs.
145 subdevice->i_ranges_count = 2;
146
147 subdevice->i_ranges[0].min = 0; //0mA
148 subdevice->i_ranges[0].max = 19995117; //20mA
149
150 subdevice->i_ranges[1].min = 4E3; //4mA
151 subdevice->i_ranges[1].max = 19995118; //20mA
152 } else { // This is version without current outputs.
153 subdevice->i_ranges_count = 0;
154
155 subdevice->i_ranges[0].min = 0; //0mA
156 subdevice->i_ranges[0].max = 0; //0mA
157
158 subdevice->i_ranges[1].min = 0; //0mA
159 subdevice->i_ranges[1].max = 0; //0mA
160 }
161
162 // Initialize registers.
163 subdevice->uni_bi_reg = reg_base + ME1600_UNI_BI_REG;
164 subdevice->i_range_reg = reg_base + ME1600_020_420_REG;
165 subdevice->sim_output_reg = reg_base + ME1600_SIM_OUTPUT_REG;
166 subdevice->current_on_reg = reg_base + ME1600_CURRENT_ON_REG;
167 #ifdef MEDEBUG_DEBUG_REG
168 subdevice->reg_base = reg_base;
169 #endif
170
171 // Initialize shadow structure.
172 subdevice->ao_regs_shadows = ao_regs_shadows;
173
174 // Override base class methods.
175 subdevice->base.me_subdevice_destructor = me1600_ao_destructor;
176 subdevice->base.me_subdevice_io_reset_subdevice =
177 me1600_ao_io_reset_subdevice;
178 subdevice->base.me_subdevice_io_single_config =
179 me1600_ao_io_single_config;
180 subdevice->base.me_subdevice_io_single_read = me1600_ao_io_single_read;
181 subdevice->base.me_subdevice_io_single_write =
182 me1600_ao_io_single_write;
183 subdevice->base.me_subdevice_query_number_channels =
184 me1600_ao_query_number_channels;
185 subdevice->base.me_subdevice_query_subdevice_type =
186 me1600_ao_query_subdevice_type;
187 subdevice->base.me_subdevice_query_subdevice_caps =
188 me1600_ao_query_subdevice_caps;
189 subdevice->base.me_subdevice_query_range_by_min_max =
190 me1600_ao_query_range_by_min_max;
191 subdevice->base.me_subdevice_query_number_ranges =
192 me1600_ao_query_number_ranges;
193 subdevice->base.me_subdevice_query_range_info =
194 me1600_ao_query_range_info;
195
196 // Initialize wait queue.
197 init_waitqueue_head(&subdevice->wait_queue);
198
199 // Prepare work queue.
200 subdevice->me1600_workqueue = me1600_wq;
201
202 /* workqueue API changed in kernel 2.6.20 */
203 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20) )
204 INIT_WORK(&subdevice->ao_control_task, me1600_ao_work_control_task,
205 (void *)subdevice);
206 #else
207 INIT_DELAYED_WORK(&subdevice->ao_control_task,
208 me1600_ao_work_control_task);
209 #endif
210 return subdevice;
211 }
212
me1600_ao_destructor(struct me_subdevice * subdevice)213 static void me1600_ao_destructor(struct me_subdevice *subdevice)
214 {
215 me1600_ao_subdevice_t *instance;
216
217 instance = (me1600_ao_subdevice_t *) subdevice;
218
219 PDEBUG("executed. idx=%d\n", instance->ao_idx);
220
221 instance->ao_control_task_flag = 0;
222
223 // Reset subdevice to asure clean exit.
224 me1600_ao_io_reset_subdevice(subdevice, NULL,
225 ME_IO_RESET_SUBDEVICE_NO_FLAGS);
226
227 // Remove any tasks from work queue. This is paranoic because it was done allready in reset().
228 if (!cancel_delayed_work(&instance->ao_control_task)) { //Wait 2 ticks to be sure that control task is removed from queue.
229 set_current_state(TASK_INTERRUPTIBLE);
230 schedule_timeout(2);
231 }
232 }
233
me1600_ao_io_reset_subdevice(me_subdevice_t * subdevice,struct file * filep,int flags)234 static int me1600_ao_io_reset_subdevice(me_subdevice_t * subdevice,
235 struct file *filep, int flags)
236 {
237 me1600_ao_subdevice_t *instance;
238 uint16_t tmp;
239
240 instance = (me1600_ao_subdevice_t *) subdevice;
241
242 PDEBUG("executed. idx=%d\n", instance->ao_idx);
243
244 if (flags) {
245 PERROR("Invalid flag specified.\n");
246 return ME_ERRNO_INVALID_FLAGS;
247 }
248
249 ME_SUBDEVICE_ENTER;
250
251 //Cancel control task
252 PDEBUG("Cancel control task. idx=%d\n", instance->ao_idx);
253 instance->ao_control_task_flag = 0;
254 cancel_delayed_work(&instance->ao_control_task);
255 (instance->ao_regs_shadows)->trigger &= ~(0x1 << instance->ao_idx); //Cancell waiting for trigger.
256
257 // Reset all settings.
258 spin_lock(&instance->subdevice_lock);
259 spin_lock(instance->ao_shadows_lock);
260 (instance->ao_regs_shadows)->shadow[instance->ao_idx] = 0;
261 (instance->ao_regs_shadows)->mirror[instance->ao_idx] = 0;
262 (instance->ao_regs_shadows)->trigger &= ~(0x1 << instance->ao_idx); //Not waiting for triggering.
263 (instance->ao_regs_shadows)->synchronous &= ~(0x1 << instance->ao_idx); //Individual triggering.
264
265 // Set output to default (safe) state.
266 spin_lock(instance->config_regs_lock);
267 tmp = inw(instance->uni_bi_reg); // unipolar
268 tmp |= (0x1 << instance->ao_idx);
269 outw(tmp, instance->uni_bi_reg);
270 PDEBUG_REG("uni_bi_reg outw(0x%lX+0x%lX)=0x%x\n", instance->reg_base,
271 instance->uni_bi_reg - instance->reg_base, tmp);
272
273 tmp = inw(instance->current_on_reg); // Volts only!
274 tmp &= ~(0x1 << instance->ao_idx);
275 tmp &= 0x00FF;
276 outw(tmp, instance->current_on_reg);
277 PDEBUG_REG("current_on_reg outl(0x%lX+0x%lX)=0x%x\n",
278 instance->reg_base,
279 instance->current_on_reg - instance->reg_base, tmp);
280
281 tmp = inw(instance->i_range_reg); // 0..20mA <= If exists.
282 tmp &= ~(0x1 << instance->ao_idx);
283 outw(tmp, instance->i_range_reg);
284 PDEBUG_REG("i_range_reg outl(0x%lX+0x%lX)=0x%x\n", instance->reg_base,
285 instance->i_range_reg - instance->reg_base, tmp);
286
287 outw(0, (instance->ao_regs_shadows)->registry[instance->ao_idx]);
288 PDEBUG_REG("channel_reg outw(0x%lX+0x%lX)=0x%x\n", instance->reg_base,
289 (instance->ao_regs_shadows)->registry[instance->ao_idx] -
290 instance->reg_base, 0);
291
292 // Trigger output.
293 outw(0x0000, instance->sim_output_reg);
294 PDEBUG_REG("sim_output_reg outl(0x%lX+0x%lX)=0x%x\n",
295 instance->reg_base,
296 instance->sim_output_reg - instance->reg_base, 0x0000);
297 outw(0xFFFF, instance->sim_output_reg);
298 PDEBUG_REG("sim_output_reg outl(0x%lX+0x%lX)=0x%x\n",
299 instance->reg_base,
300 instance->sim_output_reg - instance->reg_base, 0xFFFF);
301 spin_unlock(instance->config_regs_lock);
302 spin_unlock(instance->ao_shadows_lock);
303
304 // Set status to 'none'
305 instance->status = ao_status_none;
306 spin_unlock(&instance->subdevice_lock);
307
308 //Signal reset if user is on wait.
309 wake_up_interruptible_all(&instance->wait_queue);
310
311 ME_SUBDEVICE_EXIT;
312
313 return ME_ERRNO_SUCCESS;
314 }
315
me1600_ao_io_single_config(me_subdevice_t * subdevice,struct file * filep,int channel,int single_config,int ref,int trig_chan,int trig_type,int trig_edge,int flags)316 static int me1600_ao_io_single_config(me_subdevice_t * subdevice,
317 struct file *filep,
318 int channel,
319 int single_config,
320 int ref,
321 int trig_chan,
322 int trig_type, int trig_edge, int flags)
323 {
324 me1600_ao_subdevice_t *instance;
325 uint16_t tmp;
326
327 instance = (me1600_ao_subdevice_t *) subdevice;
328
329 PDEBUG("executed. idx=%d\n", instance->ao_idx);
330
331 // Checking parameters.
332 if (flags) {
333 PERROR
334 ("Invalid flag specified. Must be ME_IO_SINGLE_CONFIG_NO_FLAGS.\n");
335 return ME_ERRNO_INVALID_FLAGS;
336 }
337
338 if (trig_edge != ME_TRIG_EDGE_NONE) {
339 PERROR
340 ("Invalid trigger edge. Software trigger has not edge. Must be ME_TRIG_EDGE_NONE\n");
341 return ME_ERRNO_INVALID_TRIG_EDGE;
342 }
343
344 if (trig_type != ME_TRIG_TYPE_SW) {
345 PERROR("Invalid trigger edge. Must be ME_TRIG_TYPE_SW.\n");
346 return ME_ERRNO_INVALID_TRIG_TYPE;
347 }
348
349 if ((trig_chan != ME_TRIG_CHAN_DEFAULT)
350 && (trig_chan != ME_TRIG_CHAN_SYNCHRONOUS)) {
351 PERROR("Invalid trigger channel specified.\n");
352 return ME_ERRNO_INVALID_TRIG_CHAN;
353 }
354
355 if (ref != ME_REF_AO_GROUND) {
356 PERROR
357 ("Invalid reference. Analog outputs have to have got REF_AO_GROUND.\n");
358 return ME_ERRNO_INVALID_REF;
359 }
360
361 if (((single_config + 1) >
362 (instance->u_ranges_count + instance->i_ranges_count))
363 || (single_config < 0)) {
364 PERROR("Invalid range specified.\n");
365 return ME_ERRNO_INVALID_SINGLE_CONFIG;
366 }
367
368 if (channel) {
369 PERROR("Invalid channel specified.\n");
370 return ME_ERRNO_INVALID_CHANNEL;
371 }
372 // Checking parameters - done. All is fine. Do config.
373
374 ME_SUBDEVICE_ENTER;
375
376 //Cancel control task
377 PDEBUG("Cancel control task. idx=%d\n", instance->ao_idx);
378 instance->ao_control_task_flag = 0;
379 cancel_delayed_work(&instance->ao_control_task);
380
381 spin_lock(&instance->subdevice_lock);
382 spin_lock(instance->ao_shadows_lock);
383 (instance->ao_regs_shadows)->trigger &= ~(0x1 << instance->ao_idx); //Cancell waiting for trigger.
384 (instance->ao_regs_shadows)->shadow[instance->ao_idx] = 0;
385 (instance->ao_regs_shadows)->mirror[instance->ao_idx] = 0;
386
387 spin_lock(instance->config_regs_lock);
388 switch (single_config) {
389 case 0: // 0V 10V
390 tmp = inw(instance->current_on_reg); // Volts
391 tmp &= ~(0x1 << instance->ao_idx);
392 outw(tmp, instance->current_on_reg);
393 PDEBUG_REG("current_on_reg outw(0x%lX+0x%lX)=0x%x\n",
394 instance->reg_base,
395 instance->current_on_reg - instance->reg_base, tmp);
396
397 // 0V
398 outw(0,
399 (instance->ao_regs_shadows)->registry[instance->ao_idx]);
400 PDEBUG_REG("channel_reg outw(0x%lX+0x%lX)=0x%x\n",
401 instance->reg_base,
402 (instance->ao_regs_shadows)->registry[instance->
403 ao_idx] -
404 instance->reg_base, 0);
405
406 tmp = inw(instance->uni_bi_reg); // unipolar
407 tmp |= (0x1 << instance->ao_idx);
408 outw(tmp, instance->uni_bi_reg);
409 PDEBUG_REG("uni_bi_reg outw(0x%lX+0x%lX)=0x%x\n",
410 instance->reg_base,
411 instance->uni_bi_reg - instance->reg_base, tmp);
412
413 tmp = inw(instance->i_range_reg); // 0..20mA <= If exists.
414 tmp &= ~(0x1 << instance->ao_idx);
415 outw(tmp, instance->i_range_reg);
416 PDEBUG_REG("i_range_reg outl(0x%lX+0x%lX)=0x%x\n",
417 instance->reg_base,
418 instance->i_range_reg - instance->reg_base, tmp);
419 break;
420
421 case 1: // -10V 10V
422 tmp = inw(instance->current_on_reg); // Volts
423 tmp &= ~(0x1 << instance->ao_idx);
424 outw(tmp, instance->current_on_reg);
425 PDEBUG_REG("current_on_reg outw(0x%lX+0x%lX)=0x%x\n",
426 instance->reg_base,
427 instance->current_on_reg - instance->reg_base, tmp);
428
429 // 0V
430 outw(0x0800,
431 (instance->ao_regs_shadows)->registry[instance->ao_idx]);
432 PDEBUG_REG("channel_reg outw(0x%lX+0x%lX)=0x%x\n",
433 instance->reg_base,
434 (instance->ao_regs_shadows)->registry[instance->
435 ao_idx] -
436 instance->reg_base, 0x0800);
437
438 tmp = inw(instance->uni_bi_reg); // bipolar
439 tmp &= ~(0x1 << instance->ao_idx);
440 outw(tmp, instance->uni_bi_reg);
441 PDEBUG_REG("uni_bi_reg outw(0x%lX+0x%lX)=0x%x\n",
442 instance->reg_base,
443 instance->uni_bi_reg - instance->reg_base, tmp);
444
445 tmp = inw(instance->i_range_reg); // 0..20mA <= If exists.
446 tmp &= ~(0x1 << instance->ao_idx);
447 outw(tmp, instance->i_range_reg);
448 PDEBUG_REG("i_range_reg outl(0x%lX+0x%lX)=0x%x\n",
449 instance->reg_base,
450 instance->i_range_reg - instance->reg_base, tmp);
451 break;
452
453 case 2: // 0mA 20mA
454 tmp = inw(instance->current_on_reg); // mAmpers
455 tmp |= (0x1 << instance->ao_idx);
456 outw(tmp, instance->current_on_reg);
457 PDEBUG_REG("current_on_reg outw(0x%lX+0x%lX)=0x%x\n",
458 instance->reg_base,
459 instance->current_on_reg - instance->reg_base, tmp);
460
461 tmp = inw(instance->i_range_reg); // 0..20mA
462 tmp &= ~(0x1 << instance->ao_idx);
463 outw(tmp, instance->i_range_reg);
464 PDEBUG_REG("i_range_reg outl(0x%lX+0x%lX)=0x%x\n",
465 instance->reg_base,
466 instance->i_range_reg - instance->reg_base, tmp);
467
468 // 0mA
469 outw(0,
470 (instance->ao_regs_shadows)->registry[instance->ao_idx]);
471 PDEBUG_REG("channel_reg outw(0x%lX+0x%lX)=0x%x\n",
472 instance->reg_base,
473 (instance->ao_regs_shadows)->registry[instance->
474 ao_idx] -
475 instance->reg_base, 0);
476
477 tmp = inw(instance->uni_bi_reg); // unipolar
478 tmp |= (0x1 << instance->ao_idx);
479 outw(tmp, instance->uni_bi_reg);
480 PDEBUG_REG("uni_bi_reg outw(0x%lX+0x%lX)=0x%x\n",
481 instance->reg_base,
482 instance->uni_bi_reg - instance->reg_base, tmp);
483 break;
484
485 case 3: // 4mA 20mA
486 tmp = inw(instance->current_on_reg); // mAmpers
487 tmp |= (0x1 << instance->ao_idx);
488 outw(tmp, instance->current_on_reg);
489 PDEBUG_REG("current_on_reg outw(0x%lX+0x%lX)=0x%x\n",
490 instance->reg_base,
491 instance->current_on_reg - instance->reg_base, tmp);
492
493 tmp = inw(instance->i_range_reg); // 4..20mA
494 tmp |= (0x1 << instance->ao_idx);
495 outw(tmp, instance->i_range_reg);
496 PDEBUG_REG("i_range_reg outl(0x%lX+0x%lX)=0x%x\n",
497 instance->reg_base,
498 instance->i_range_reg - instance->reg_base, tmp);
499
500 // 4mA
501 outw(0,
502 (instance->ao_regs_shadows)->registry[instance->ao_idx]);
503 PDEBUG_REG("channel_reg outw(0x%lX+0x%lX)=0x%x\n",
504 instance->reg_base,
505 (instance->ao_regs_shadows)->registry[instance->
506 ao_idx] -
507 instance->reg_base, 0);
508
509 tmp = inw(instance->uni_bi_reg); // unipolar
510 tmp |= (0x1 << instance->ao_idx);
511 outw(tmp, instance->uni_bi_reg);
512 PDEBUG_REG("uni_bi_reg outw(0x%lX+0x%lX)=0x%x\n",
513 instance->reg_base,
514 instance->uni_bi_reg - instance->reg_base, tmp);
515 break;
516 }
517
518 // Trigger output.
519 outw(0x0000, instance->sim_output_reg);
520 PDEBUG_REG("sim_output_reg outl(0x%lX+0x%lX)=0x%x\n",
521 instance->reg_base,
522 instance->sim_output_reg - instance->reg_base, 0x0000);
523 outw(0xFFFF, instance->sim_output_reg);
524 PDEBUG_REG("sim_output_reg outl(0x%lX+0x%lX)=0x%x\n",
525 instance->reg_base,
526 instance->sim_output_reg - instance->reg_base, 0xFFFF);
527
528 if (trig_chan == ME_TRIG_CHAN_DEFAULT) { // Individual triggering.
529 (instance->ao_regs_shadows)->synchronous &=
530 ~(0x1 << instance->ao_idx);
531 PDEBUG("Individual triggering.\n");
532 } else if (trig_chan == ME_TRIG_CHAN_SYNCHRONOUS) { // Synchronous triggering.
533 (instance->ao_regs_shadows)->synchronous |=
534 (0x1 << instance->ao_idx);
535 PDEBUG("Synchronous triggering.\n");
536 }
537 spin_unlock(instance->config_regs_lock);
538 spin_unlock(instance->ao_shadows_lock);
539
540 instance->status = ao_status_single_configured;
541 spin_unlock(&instance->subdevice_lock);
542
543 ME_SUBDEVICE_EXIT;
544
545 return ME_ERRNO_SUCCESS;
546 }
547
me1600_ao_io_single_read(me_subdevice_t * subdevice,struct file * filep,int channel,int * value,int time_out,int flags)548 static int me1600_ao_io_single_read(me_subdevice_t * subdevice,
549 struct file *filep,
550 int channel,
551 int *value, int time_out, int flags)
552 {
553 me1600_ao_subdevice_t *instance;
554 unsigned long delay = 0;
555 unsigned long j = 0;
556 int err = ME_ERRNO_SUCCESS;
557
558 instance = (me1600_ao_subdevice_t *) subdevice;
559
560 PDEBUG("executed. idx=%d\n", instance->ao_idx);
561
562 if (flags & ~ME_IO_SINGLE_NONBLOCKING) {
563 PERROR("Invalid flag specified. %d\n", flags);
564 return ME_ERRNO_INVALID_FLAGS;
565 }
566
567 if (time_out < 0) {
568 PERROR("Invalid timeout specified.\n");
569 return ME_ERRNO_INVALID_TIMEOUT;
570 }
571
572 if (channel) {
573 PERROR("Invalid channel specified.\n");
574 return ME_ERRNO_INVALID_CHANNEL;
575 }
576
577 if ((!flags) && ((instance->ao_regs_shadows)->trigger & instance->ao_idx)) { //Blocking mode. Wait for software trigger.
578 if (time_out) {
579 delay = (time_out * HZ) / 1000;
580 if (delay == 0)
581 delay = 1;
582 }
583
584 j = jiffies;
585
586 //Only runing process will interrupt this call. Events are signaled when status change. This procedure has own timeout.
587 wait_event_interruptible_timeout(instance->wait_queue,
588 (!((instance->
589 ao_regs_shadows)->
590 trigger & instance->
591 ao_idx)),
592 (delay) ? delay : LONG_MAX);
593
594 if (instance == ao_status_none) { // Reset was called.
595 PDEBUG("Single canceled.\n");
596 err = ME_ERRNO_CANCELLED;
597 }
598
599 if (signal_pending(current)) {
600 PERROR("Wait on start of state machine interrupted.\n");
601 err = ME_ERRNO_SIGNAL;
602 }
603
604 if ((delay) && ((jiffies - j) >= delay)) {
605 PDEBUG("Timeout reached.\n");
606 err = ME_ERRNO_TIMEOUT;
607 }
608 }
609
610 *value = (instance->ao_regs_shadows)->mirror[instance->ao_idx];
611
612 return err;
613 }
614
me1600_ao_io_single_write(me_subdevice_t * subdevice,struct file * filep,int channel,int value,int time_out,int flags)615 static int me1600_ao_io_single_write(me_subdevice_t * subdevice,
616 struct file *filep,
617 int channel,
618 int value, int time_out, int flags)
619 {
620 me1600_ao_subdevice_t *instance;
621 int err = ME_ERRNO_SUCCESS;
622 unsigned long delay = 0;
623 int i;
624 unsigned long j = 0;
625
626 instance = (me1600_ao_subdevice_t *) subdevice;
627
628 PDEBUG("executed. idx=%d\n", instance->ao_idx);
629
630 if (flags &
631 ~(ME_IO_SINGLE_TYPE_TRIG_SYNCHRONOUS |
632 ME_IO_SINGLE_TYPE_WRITE_NONBLOCKING)) {
633 PERROR("Invalid flag specified.\n");
634 return ME_ERRNO_INVALID_FLAGS;
635 }
636
637 if (time_out < 0) {
638 PERROR("Invalid timeout specified.\n");
639 return ME_ERRNO_INVALID_TIMEOUT;
640 }
641
642 if (value & ~ME1600_AO_MAX_DATA) {
643 PERROR("Invalid value provided.\n");
644 return ME_ERRNO_VALUE_OUT_OF_RANGE;
645 }
646
647 if (channel) {
648 PERROR("Invalid channel specified.\n");
649 return ME_ERRNO_INVALID_CHANNEL;
650 }
651
652 ME_SUBDEVICE_ENTER;
653
654 //Cancel control task
655 PDEBUG("Cancel control task. idx=%d\n", instance->ao_idx);
656 instance->ao_control_task_flag = 0;
657 cancel_delayed_work(&instance->ao_control_task);
658 (instance->ao_regs_shadows)->trigger &= ~(0x1 << instance->ao_idx); //Cancell waiting for trigger.
659
660 if (time_out) {
661 delay = (time_out * HZ) / 1000;
662
663 if (delay == 0)
664 delay = 1;
665 }
666 //Write value.
667 spin_lock(instance->ao_shadows_lock);
668 (instance->ao_regs_shadows)->shadow[instance->ao_idx] =
669 (uint16_t) value;
670
671 if (flags & ME_IO_SINGLE_TYPE_TRIG_SYNCHRONOUS) { // Trigger all outputs from synchronous list.
672 for (i = 0; i < (instance->ao_regs_shadows)->count; i++) {
673 if (((instance->ao_regs_shadows)->synchronous & (0x1 << i)) || (i == instance->ao_idx)) { // Set all from synchronous list to correct state.
674 PDEBUG
675 ("Synchronous triggering: output %d. idx=%d\n",
676 i, instance->ao_idx);
677 (instance->ao_regs_shadows)->mirror[i] =
678 (instance->ao_regs_shadows)->shadow[i];
679
680 outw((instance->ao_regs_shadows)->shadow[i],
681 (instance->ao_regs_shadows)->registry[i]);
682 PDEBUG_REG
683 ("channel_reg outw(0x%lX+0x%lX)=0x%x\n",
684 instance->reg_base,
685 (instance->ao_regs_shadows)->registry[i] -
686 instance->reg_base,
687 (instance->ao_regs_shadows)->shadow[i]);
688
689 (instance->ao_regs_shadows)->trigger &=
690 ~(0x1 << i);
691 }
692 }
693
694 // Trigger output.
695 outw(0x0000, instance->sim_output_reg);
696 PDEBUG_REG("sim_output_reg outl(0x%lX+0x%lX)=0x%x\n",
697 instance->reg_base,
698 instance->sim_output_reg - instance->reg_base, 0);
699 outw(0xFFFF, instance->sim_output_reg);
700 PDEBUG_REG("sim_output_reg outl(0x%lX+0x%lX)=0x%x\n",
701 instance->reg_base,
702 instance->sim_output_reg - instance->reg_base,
703 0xFFFF);
704 instance->status = ao_status_single_end;
705 } else { // Individual mode.
706 if ((instance->ao_regs_shadows)->synchronous & (0x1 << instance->ao_idx)) { // Put on synchronous start list. Set output as waiting for trigger.
707 PDEBUG("Add to synchronous list. idx=%d\n",
708 instance->ao_idx);
709 (instance->ao_regs_shadows)->trigger |=
710 (0x1 << instance->ao_idx);
711 instance->status = ao_status_single_run;
712 PDEBUG("Synchronous list: 0x%x.\n",
713 (instance->ao_regs_shadows)->synchronous);
714 } else { // Fired this one.
715 PDEBUG("Triggering. idx=%d\n", instance->ao_idx);
716 (instance->ao_regs_shadows)->mirror[instance->ao_idx] =
717 (instance->ao_regs_shadows)->shadow[instance->
718 ao_idx];
719
720 outw((instance->ao_regs_shadows)->
721 shadow[instance->ao_idx],
722 (instance->ao_regs_shadows)->registry[instance->
723 ao_idx]);
724 PDEBUG_REG("channel_reg outw(0x%lX+0x%lX)=0x%x\n",
725 instance->reg_base,
726 (instance->ao_regs_shadows)->
727 registry[instance->ao_idx] -
728 instance->reg_base,
729 (instance->ao_regs_shadows)->
730 shadow[instance->ao_idx]);
731
732 // Set output as triggered.
733 (instance->ao_regs_shadows)->trigger &=
734 ~(0x1 << instance->ao_idx);
735
736 // Trigger output.
737 outw(0x0000, instance->sim_output_reg);
738 PDEBUG_REG("sim_output_reg outl(0x%lX+0x%lX)=0x%x\n",
739 instance->reg_base,
740 instance->sim_output_reg -
741 instance->reg_base, 0);
742 outw(0xFFFF, instance->sim_output_reg);
743 PDEBUG_REG("sim_output_reg outl(0x%lX+0x%lX)=0x%x\n",
744 instance->reg_base,
745 instance->sim_output_reg -
746 instance->reg_base, 0xFFFF);
747 instance->status = ao_status_single_end;
748 }
749 }
750 spin_unlock(instance->ao_shadows_lock);
751
752 //Init control task
753 instance->timeout.delay = delay;
754 instance->timeout.start_time = jiffies;
755 instance->ao_control_task_flag = 1;
756 queue_delayed_work(instance->me1600_workqueue,
757 &instance->ao_control_task, 1);
758
759 if ((!flags & ME_IO_SINGLE_TYPE_WRITE_NONBLOCKING) && ((instance->ao_regs_shadows)->trigger & instance->ao_idx)) { //Blocking mode. Wait for software trigger.
760 if (time_out) {
761 delay = (time_out * HZ) / 1000;
762 if (delay == 0)
763 delay = 1;
764 }
765
766 j = jiffies;
767
768 //Only runing process will interrupt this call. Events are signaled when status change. This procedure has own timeout.
769 wait_event_interruptible_timeout(instance->wait_queue,
770 (!((instance->
771 ao_regs_shadows)->
772 trigger & instance->
773 ao_idx)),
774 (delay) ? delay : LONG_MAX);
775
776 if (instance == ao_status_none) {
777 PDEBUG("Single canceled.\n");
778 err = ME_ERRNO_CANCELLED;
779 }
780 if (signal_pending(current)) {
781 PERROR("Wait on start of state machine interrupted.\n");
782 err = ME_ERRNO_SIGNAL;
783 }
784
785 if ((delay) && ((jiffies - j) >= delay)) {
786 PDEBUG("Timeout reached.\n");
787 err = ME_ERRNO_TIMEOUT;
788 }
789 }
790
791 ME_SUBDEVICE_EXIT;
792
793 return err;
794 }
795
me1600_ao_query_number_channels(me_subdevice_t * subdevice,int * number)796 static int me1600_ao_query_number_channels(me_subdevice_t * subdevice,
797 int *number)
798 {
799 me1600_ao_subdevice_t *instance;
800 instance = (me1600_ao_subdevice_t *) subdevice;
801
802 PDEBUG("executed. idx=%d\n", instance->ao_idx);
803
804 *number = 1; //Every subdevice has only 1 channel.
805 return ME_ERRNO_SUCCESS;
806 }
807
me1600_ao_query_subdevice_type(me_subdevice_t * subdevice,int * type,int * subtype)808 static int me1600_ao_query_subdevice_type(me_subdevice_t * subdevice, int *type,
809 int *subtype)
810 {
811 me1600_ao_subdevice_t *instance;
812 instance = (me1600_ao_subdevice_t *) subdevice;
813
814 PDEBUG("executed. idx=%d\n", instance->ao_idx);
815
816 *type = ME_TYPE_AO;
817 *subtype = ME_SUBTYPE_SINGLE;
818 return ME_ERRNO_SUCCESS;
819 }
820
me1600_ao_query_subdevice_caps(me_subdevice_t * subdevice,int * caps)821 static int me1600_ao_query_subdevice_caps(me_subdevice_t * subdevice, int *caps)
822 {
823 PDEBUG("executed.\n");
824 *caps = ME_CAPS_AO_TRIG_SYNCHRONOUS;
825 return ME_ERRNO_SUCCESS;
826 }
827
me1600_ao_query_range_by_min_max(me_subdevice_t * subdevice,int unit,int * min,int * max,int * maxdata,int * range)828 static int me1600_ao_query_range_by_min_max(me_subdevice_t * subdevice,
829 int unit,
830 int *min,
831 int *max, int *maxdata, int *range)
832 {
833 me1600_ao_subdevice_t *instance;
834 int i;
835 int r = -1;
836 int diff = 21E6;
837
838 instance = (me1600_ao_subdevice_t *) subdevice;
839
840 PDEBUG("executed. idx=%d\n", instance->ao_idx);
841
842 if ((*max - *min) < 0) {
843 PERROR("Invalid minimum and maximum values specified.\n");
844 return ME_ERRNO_INVALID_MIN_MAX;
845 }
846 // Maximum ranges are slightly less then 10V or 20mA. For convenient we accepted this value as valid one.
847 if (unit == ME_UNIT_VOLT) {
848 for (i = 0; i < instance->u_ranges_count; i++) {
849 if ((instance->u_ranges[i].min <= *min)
850 && ((instance->u_ranges[i].max + 5000) >= *max)) {
851 if ((instance->u_ranges[i].max -
852 instance->u_ranges[i].min) - (*max -
853 *min) <
854 diff) {
855 r = i;
856 diff =
857 (instance->u_ranges[i].max -
858 instance->u_ranges[i].min) -
859 (*max - *min);
860 }
861 }
862 }
863
864 if (r < 0) {
865 PERROR("No matching range found.\n");
866 return ME_ERRNO_NO_RANGE;
867 } else {
868 *min = instance->u_ranges[r].min;
869 *max = instance->u_ranges[r].max;
870 *range = r;
871 }
872 } else if (unit == ME_UNIT_AMPERE) {
873 for (i = 0; i < instance->i_ranges_count; i++) {
874 if ((instance->i_ranges[i].min <= *min)
875 && (instance->i_ranges[i].max + 5000 >= *max)) {
876 if ((instance->i_ranges[i].max -
877 instance->i_ranges[i].min) - (*max -
878 *min) <
879 diff) {
880 r = i;
881 diff =
882 (instance->i_ranges[i].max -
883 instance->i_ranges[i].min) -
884 (*max - *min);
885 }
886 }
887 }
888
889 if (r < 0) {
890 PERROR("No matching range found.\n");
891 return ME_ERRNO_NO_RANGE;
892 } else {
893 *min = instance->i_ranges[r].min;
894 *max = instance->i_ranges[r].max;
895 *range = r + instance->u_ranges_count;
896 }
897 } else {
898 PERROR("Invalid physical unit specified.\n");
899 return ME_ERRNO_INVALID_UNIT;
900 }
901 *maxdata = ME1600_AO_MAX_DATA;
902
903 return ME_ERRNO_SUCCESS;
904 }
905
me1600_ao_query_number_ranges(me_subdevice_t * subdevice,int unit,int * count)906 static int me1600_ao_query_number_ranges(me_subdevice_t * subdevice,
907 int unit, int *count)
908 {
909 me1600_ao_subdevice_t *instance;
910
911 PDEBUG("executed.\n");
912
913 instance = (me1600_ao_subdevice_t *) subdevice;
914 switch (unit) {
915 case ME_UNIT_VOLT:
916 *count = instance->u_ranges_count;
917 break;
918 case ME_UNIT_AMPERE:
919 *count = instance->i_ranges_count;
920 break;
921 case ME_UNIT_ANY:
922 *count = instance->u_ranges_count + instance->i_ranges_count;
923 break;
924 default:
925 *count = 0;
926 }
927
928 return ME_ERRNO_SUCCESS;
929 }
930
me1600_ao_query_range_info(me_subdevice_t * subdevice,int range,int * unit,int * min,int * max,int * maxdata)931 static int me1600_ao_query_range_info(me_subdevice_t * subdevice,
932 int range,
933 int *unit,
934 int *min, int *max, int *maxdata)
935 {
936 me1600_ao_subdevice_t *instance;
937
938 PDEBUG("executed.\n");
939
940 instance = (me1600_ao_subdevice_t *) subdevice;
941
942 if (((range + 1) >
943 (instance->u_ranges_count + instance->i_ranges_count))
944 || (range < 0)) {
945 PERROR("Invalid range number specified.\n");
946 return ME_ERRNO_INVALID_RANGE;
947 }
948
949 if (range < instance->u_ranges_count) {
950 *unit = ME_UNIT_VOLT;
951 *min = instance->u_ranges[range].min;
952 *max = instance->u_ranges[range].max;
953 } else if (range < instance->u_ranges_count + instance->i_ranges_count) {
954 *unit = ME_UNIT_AMPERE;
955 *min = instance->i_ranges[range - instance->u_ranges_count].min;
956 *max = instance->i_ranges[range - instance->u_ranges_count].max;
957 }
958 *maxdata = ME1600_AO_MAX_DATA;
959
960 return ME_ERRNO_SUCCESS;
961 }
962
963 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
me1600_ao_work_control_task(void * subdevice)964 static void me1600_ao_work_control_task(void *subdevice)
965 #else
966 static void me1600_ao_work_control_task(struct work_struct *work)
967 #endif
968 {
969 me1600_ao_subdevice_t *instance;
970 int reschedule = 1;
971 int signaling = 0;
972
973 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
974 instance = (me1600_ao_subdevice_t *) subdevice;
975 #else
976 instance =
977 container_of((void *)work, me1600_ao_subdevice_t, ao_control_task);
978 #endif
979
980 PINFO("<%s: %ld> executed. idx=%d\n", __func__, jiffies,
981 instance->ao_idx);
982
983 if (!((instance->ao_regs_shadows)->trigger & instance->ao_idx)) { // Output was triggerd.
984 // Signal the end.
985 signaling = 1;
986 reschedule = 0;
987 if (instance->status == ao_status_single_run) {
988 instance->status = ao_status_single_end;
989 }
990
991 } else if ((instance->timeout.delay) && ((jiffies - instance->timeout.start_time) >= instance->timeout.delay)) { // Timeout
992 PDEBUG("Timeout reached.\n");
993 spin_lock(instance->ao_shadows_lock);
994 // Restore old settings.
995 PDEBUG("Write old value back to register.\n");
996 (instance->ao_regs_shadows)->shadow[instance->ao_idx] =
997 (instance->ao_regs_shadows)->mirror[instance->ao_idx];
998
999 outw((instance->ao_regs_shadows)->mirror[instance->ao_idx],
1000 (instance->ao_regs_shadows)->registry[instance->ao_idx]);
1001 PDEBUG_REG("channel_reg outw(0x%lX+0x%lX)=0x%x\n",
1002 instance->reg_base,
1003 (instance->ao_regs_shadows)->registry[instance->
1004 ao_idx] -
1005 instance->reg_base,
1006 (instance->ao_regs_shadows)->mirror[instance->
1007 ao_idx]);
1008
1009 //Remove from synchronous strt list.
1010 (instance->ao_regs_shadows)->trigger &=
1011 ~(0x1 << instance->ao_idx);
1012 if (instance->status == ao_status_none) {
1013 instance->status = ao_status_single_end;
1014 }
1015 spin_unlock(instance->ao_shadows_lock);
1016
1017 // Signal the end.
1018 signaling = 1;
1019 reschedule = 0;
1020 }
1021
1022 if (signaling) { //Signal it.
1023 wake_up_interruptible_all(&instance->wait_queue);
1024 }
1025
1026 if (instance->ao_control_task_flag && reschedule) { // Reschedule task
1027 queue_delayed_work(instance->me1600_workqueue,
1028 &instance->ao_control_task, 1);
1029 } else {
1030 PINFO("<%s> Ending control task.\n", __func__);
1031 }
1032
1033 }
1034