?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
moved kdeaccessibility kdeaddons kdeadmin kdeartwork kdebindings kdeedu kdegames...
[kdeedu.git] / kstars / kstars / indi / fli / libfli-camera.c
blob369b00388be0292d17babba91dddaebecbe3afc2
1 /*
2
3 Copyright (c) 2002 Finger Lakes Instrumentation (FLI), L.L.C.
4 All rights reserved.
5
6 Redistribution and use in source and binary forms, with or without
7 modification, are permitted provided that the following conditions
8 are met:
9
10 Redistributions of source code must retain the above copyright
11 notice, this list of conditions and the following disclaimer.
12
13 Redistributions in binary form must reproduce the above
14 copyright notice, this list of conditions and the following
15 disclaimer in the documentation and/or other materials
16 provided with the distribution.
17
18 Neither the name of Finger Lakes Instrumentation (FLI), LLC
19 nor the names of its contributors may be used to endorse or
20 promote products derived from this software without specific
21 prior written permission.
22
23 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24 ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
26 FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
27 REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
28 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
29 BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
30 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
31 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
33 ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34 POSSIBILITY OF SUCH DAMAGE.
35
36 ======================================================================
37
38 Finger Lakes Instrumentation, L.L.C. (FLI)
39 web: http://www.fli-cam.com
40 email: support@fli-cam.com
41
42 */
43
44 #include <stdio.h>
45 #include <errno.h>
46 #include <stdarg.h>
47
48 #include "libfli-libfli.h"
49 #include "libfli-debug.h"
50 #include "libfli-mem.h"
51 #include "libfli-camera.h"
52 #include "libfli-camera-parport.h"
53 #include "libfli-camera-usb.h"
54
55 const fliccdinfo_t knowndev[] = {
56 /* id model array_area visible_area */
57 {1, "KAF-0260C0-2", {{0, 0}, {534, 520}}, {{12, 4}, {524, 516}}, 1.0, 20.0, 20.0},
58 {2, "KAF-0400C0-2", {{0, 0}, {796, 520}}, {{14, 4}, {782, 516}}, 1.0, 20.0, 20.0},
59 {3, "KAF-1000C0-2", {{0, 0}, {1042, 1032}}, {{8, 4}, {1032, 1028}}, 1.0, 24.0, 24.0},
60 {4, "KAF-1300C0-2", {{0, 0}, {1304, 1028}}, {{4, 2}, {1284, 1026}}, 1.0, 20.0, 20.0},
61 {5, "KAF-1400C0-2", {{0, 0}, {1348, 1037}}, {{14,14}, {782, 526}}, 1.0, 20.0, 20.0},
62 {6, "KAF-1600C0-2", {{0, 0}, {1564, 1032}}, {{14, 4}, {1550, 1028}}, 1.0, 20.0, 20.0},
63 {7, "KAF-4200C0-2", {{0, 0}, {2060, 2048}}, {{25, 2}, {2057, 2046}}, 1.0, 20.0, 20.0},
64 {8, "SITe-502S", {{0, 0}, {527, 512}}, {{15, 0}, {527, 512}}, 1.0, 20.0, 20.0},
65 {9, "TK-1024", {{0, 0}, {1124, 1024}}, {{50, 0}, {1074, 1024}}, 1.0, 24.0, 24.0},
66 {10, "TK-512", {{0, 0}, {563, 512}}, {{51, 0}, {563, 512}}, 1.0, 24.0, 24.0},
67 {11, "SI-003A", {{0, 0}, {1056, 1024}}, {{16, 0}, {1040, 1024}}, 1.0, 24.0, 24.0},
68 {12, "KAF-6300", {{0, 0}, {3100, 2056}}, {{16, 4}, {3088, 2052}}, 1.0, 9.0, 9.0},
69 {13, "KAF-3200", {{0, 0}, {2267, 1510}}, {{46,34}, {2230, 1506}}, 1.0, 6.8, 6.8},
70 {14, "SI424A", {{0, 0}, {2088, 2049}}, {{20, 0}, {2068, 2049}}, 1.0, 6.8, 6.8},
71 {15, "CCD47-10", {{0, 0}, {1072, 1027}}, {{8, 0}, {1064, 1027}}, 0.0, 0.0, 0.0},
72 {16, "CCD77", {{0, 0}, {527, 512}}, {{15, 0}, {527, 512}}, 0.0, 0.0, 0.0},
73 {17, "CCD42-40", {{0, 0}, {2148, 2048}}, {{50, 0}, {2098, 2048}}, 1.0, 13.5, 13.5},
74 {18, "KAF-4300", {{0, 0}, {2102, 2092}}, {{8, 4}, {2092, 2088}}, 1.0, 24.0, 24.0},
75 {19, "KAF-16801", {{0, 0}, {4145, 4128}}, {{44,29}, {4124, 4109}}, 1.0, 9.0, 9.0},
76 {0, "Unknown Model", {{0, 0}, {0, 0}}, {{0, 0}, {0, 0}}, 0.0, 0.0, 0.0}
77 };
78
79 /* Common camera routines */
80 static long fli_camera_get_pixel_size(flidev_t dev,
81 double *pixel_x, double *pixel_y);
82 #define fli_camera_parport_get_pixel_size fli_camera_get_pixel_size
83 #define fli_camera_usb_get_pixel_size fli_camera_get_pixel_size
84
85 static long fli_camera_set_frame_type(flidev_t dev, fliframe_t frametype);
86 #define fli_camera_parport_set_frame_type fli_camera_set_frame_type
87 #define fli_camera_usb_set_frame_type fli_camera_set_frame_type
88
89 static long fli_camera_set_flushes(flidev_t dev, long nflushes);
90 #define fli_camera_parport_set_flushes fli_camera_set_flushes
91 #define fli_camera_usb_set_flushes fli_camera_set_flushes
92
93 long fli_camera_open(flidev_t dev)
94 {
95 int r;
96
97 CHKDEVICE(dev);
98
99 if ((DEVICE->device_data = xcalloc(1, sizeof(flicamdata_t))) == NULL)
100 return -ENOMEM;
101
102 switch (DEVICE->domain)
103 {
104 case FLIDOMAIN_PARALLEL_PORT:
105 r = fli_camera_parport_open(dev);
106 break;
107
108 case FLIDOMAIN_USB:
109 r = fli_camera_usb_open(dev);
110 break;
111
112 default:
113 r = -EINVAL;
114 }
115
116 if (r)
117 {
118 xfree(DEVICE->device_data);
119 DEVICE->device_data = NULL;
120 }
121
122 return r;
123 }
124
125 long fli_camera_close(flidev_t dev)
126 {
127 flicamdata_t *cam;
128
129 CHKDEVICE(dev);
130
131 cam = DEVICE->device_data;
132
133 if (cam->gbuf != NULL)
134 {
135 xfree(cam->gbuf);
136 cam->gbuf = NULL;
137 }
138
139 if (DEVICE->devinfo.model != NULL)
140 {
141 xfree(DEVICE->devinfo.model);
142 DEVICE->devinfo.model = NULL;
143 }
144
145 if (DEVICE->devinfo.devnam != NULL)
146 {
147 xfree(DEVICE->devinfo.devnam);
148 DEVICE->devinfo.devnam = NULL;
149 }
150
151 if (DEVICE->device_data != NULL)
152 {
153 xfree(DEVICE->device_data);
154 DEVICE->device_data = NULL;
155 }
156
157 return 0;
158 }
159
160 long fli_camera_command(flidev_t dev, int cmd, int argc, ...)
161 {
162 long r;
163 va_list ap;
164
165 va_start(ap, argc);
166 CHKDEVICE(dev);
167
168 switch (cmd)
169 {
170 case FLI_GET_PIXEL_SIZE:
171 if (argc != 2)
172 r = -EINVAL;
173 else
174 {
175 double *pixel_x, *pixel_y;
176
177 pixel_x = va_arg(ap, double *);
178 pixel_y = va_arg(ap, double *);
179
180 switch (DEVICE->domain)
181 {
182 case FLIDOMAIN_PARALLEL_PORT:
183 r = fli_camera_parport_get_pixel_size(dev, pixel_x, pixel_y);
184 break;
185
186 case FLIDOMAIN_USB:
187 r = fli_camera_usb_get_pixel_size(dev, pixel_x, pixel_y);
188 break;
189
190 default:
191 r = -EINVAL;
192 }
193 }
194 break;
195
196 case FLI_GET_ARRAY_AREA:
197 if (argc != 4)
198 r = -EINVAL;
199 else
200 {
201 long *ul_x, *ul_y, *lr_x, *lr_y;
202
203 ul_x = va_arg(ap, long *);
204 ul_y = va_arg(ap, long *);
205 lr_x = va_arg(ap, long *);
206 lr_y = va_arg(ap, long *);
207
208 switch (DEVICE->domain)
209 {
210 case FLIDOMAIN_PARALLEL_PORT:
211 r = fli_camera_parport_get_array_area(dev, ul_x, ul_y, lr_x, lr_y);
212 break;
213
214 case FLIDOMAIN_USB:
215 r = fli_camera_usb_get_array_area(dev, ul_x, ul_y, lr_x, lr_y);
216 break;
217
218 default:
219 r = -EINVAL;
220 }
221 }
222 break;
223
224 case FLI_GET_VISIBLE_AREA:
225 if (argc != 4)
226 r = -EINVAL;
227 else
228 {
229 long *ul_x, *ul_y, *lr_x, *lr_y;
230
231 ul_x = va_arg(ap, long *);
232 ul_y = va_arg(ap, long *);
233 lr_x = va_arg(ap, long *);
234 lr_y = va_arg(ap, long *);
235
236 switch (DEVICE->domain)
237 {
238 case FLIDOMAIN_PARALLEL_PORT:
239 r = fli_camera_parport_get_visible_area(dev, ul_x, ul_y, lr_x, lr_y);
240 break;
241
242 case FLIDOMAIN_USB:
243 r = fli_camera_usb_get_visible_area(dev, ul_x, ul_y, lr_x, lr_y);
244 break;
245
246 default:
247 r = -EINVAL;
248 }
249 }
250 break;
251
252 case FLI_SET_EXPOSURE_TIME:
253 if (argc != 1)
254 r = -EINVAL;
255 else
256 {
257 long exptime;
258
259 exptime = *va_arg(ap, long *);
260
261 switch (DEVICE->domain)
262 {
263 case FLIDOMAIN_PARALLEL_PORT:
264 r = fli_camera_parport_set_exposure_time(dev, exptime);
265 break;
266
267 case FLIDOMAIN_USB:
268 r = fli_camera_usb_set_exposure_time(dev, exptime);
269 break;
270
271 default:
272 r = -EINVAL;
273 }
274 }
275 break;
276
277 case FLI_SET_IMAGE_AREA:
278 if (argc != 4)
279 r = -EINVAL;
280 else
281 {
282 long ul_x, ul_y, lr_x, lr_y;
283
284 ul_x = *va_arg(ap, long *);
285 ul_y = *va_arg(ap, long *);
286 lr_x = *va_arg(ap, long *);
287 lr_y = *va_arg(ap, long *);
288
289 switch (DEVICE->domain)
290 {
291 case FLIDOMAIN_PARALLEL_PORT:
292 r = fli_camera_parport_set_image_area(dev, ul_x, ul_y, lr_x, lr_y);
293 break;
294
295 case FLIDOMAIN_USB:
296 r = fli_camera_usb_set_image_area(dev, ul_x, ul_y, lr_x, lr_y);
297 break;
298
299 default:
300 r = -EINVAL;
301 }
302 }
303 break;
304
305 case FLI_SET_HBIN:
306 if (argc != 1)
307 r = -EINVAL;
308 else
309 {
310 long hbin;
311
312 hbin = *va_arg(ap, long *);
313
314 switch (DEVICE->domain)
315 {
316 case FLIDOMAIN_PARALLEL_PORT:
317 r = fli_camera_parport_set_hbin(dev, hbin);
318 break;
319
320 case FLIDOMAIN_USB:
321 r = fli_camera_usb_set_hbin(dev, hbin);
322 break;
323
324 default:
325 r = -EINVAL;
326 }
327 }
328 break;
329
330 case FLI_SET_VBIN:
331 if (argc != 1)
332 r = -EINVAL;
333 else
334 {
335 long vbin;
336
337 vbin = *va_arg(ap, long *);
338
339 switch (DEVICE->domain)
340 {
341 case FLIDOMAIN_PARALLEL_PORT:
342 r = fli_camera_parport_set_vbin(dev, vbin);
343 break;
344
345 case FLIDOMAIN_USB:
346 r = fli_camera_usb_set_vbin(dev, vbin);
347 break;
348
349 default:
350 r = -EINVAL;
351 }
352 }
353 break;
354
355 case FLI_SET_FRAME_TYPE:
356 if (argc != 1)
357 r = -EINVAL;
358 else
359 {
360 long frametype;
361
362 frametype = *va_arg(ap, long *);
363
364 switch (DEVICE->domain)
365 {
366 case FLIDOMAIN_PARALLEL_PORT:
367 r = fli_camera_parport_set_frame_type(dev, frametype);
368 break;
369
370 case FLIDOMAIN_USB:
371 r = fli_camera_usb_set_frame_type(dev, frametype);
372 break;
373
374 default:
375 r = -EINVAL;
376 }
377 }
378 break;
379
380 case FLI_CANCEL_EXPOSURE:
381 if (argc != 0)
382 r = -EINVAL;
383 else
384 {
385 flicamdata_t *cam;
386
387 cam = DEVICE->device_data;
388
389 cam->grabrowcount = 1;
390 cam->grabrowcounttot = cam->grabrowcount;
391 cam->grabrowindex = 0;
392 cam->grabrowbatchsize = 1;
393 cam->grabrowbufferindex = cam->grabrowcount;
394 cam->flushcountbeforefirstrow = 0;
395 cam->flushcountafterlastrow = 0;
396
397 r = DEVICE->fli_command(dev, FLI_CONTROL_SHUTTER, (long) FLI_SHUTTER_CLOSE);
398 }
399 break;
400
401 case FLI_GET_EXPOSURE_STATUS:
402 if (argc != 1)
403 r = -EINVAL;
404 else
405 {
406 long *timeleft;
407
408 timeleft = va_arg(ap, long *);
409
410 switch (DEVICE->domain)
411 {
412 case FLIDOMAIN_PARALLEL_PORT:
413 r = fli_camera_parport_get_exposure_status(dev, timeleft);
414 break;
415
416 case FLIDOMAIN_USB:
417 r = fli_camera_usb_get_exposure_status(dev, timeleft);
418 break;
419
420 default:
421 r = -EINVAL;
422 }
423 }
424 break;
425
426 case FLI_SET_TEMPERATURE:
427 if (argc != 1)
428 r = -EINVAL;
429 else
430 {
431 double temperature;
432
433 temperature = *va_arg(ap, double *);
434
435 switch (DEVICE->domain)
436 {
437 case FLIDOMAIN_PARALLEL_PORT:
438 r = fli_camera_parport_set_temperature(dev, temperature);
439 break;
440
441 case FLIDOMAIN_USB:
442 r = fli_camera_usb_set_temperature(dev, temperature);
443 break;
444
445 default:
446 r = -EINVAL;
447 }
448 }
449 break;
450
451 case FLI_GET_TEMPERATURE:
452 if (argc != 1)
453 r = -EINVAL;
454 else
455 {
456 double *temperature;
457
458 temperature = va_arg(ap, double *);
459
460 switch (DEVICE->domain)
461 {
462 case FLIDOMAIN_PARALLEL_PORT:
463 r = fli_camera_parport_get_temperature(dev, temperature);
464 break;
465
466 case FLIDOMAIN_USB:
467 r = fli_camera_usb_get_temperature(dev, temperature);
468 break;
469
470 default:
471 r = -EINVAL;
472 }
473 }
474 break;
475
476 case FLI_GRAB_ROW:
477 if (argc != 2)
478 r = -EINVAL;
479 else
480 {
481 void *buf;
482 size_t width;
483
484 buf = va_arg(ap, void *);
485 width = *va_arg(ap, size_t *);
486
487 switch (DEVICE->domain)
488 {
489 case FLIDOMAIN_PARALLEL_PORT:
490 r = fli_camera_parport_grab_row(dev, buf, width);
491 break;
492
493 case FLIDOMAIN_USB:
494 r = fli_camera_usb_grab_row(dev, buf, width);
495 break;
496
497 default:
498 r = -EINVAL;
499 }
500 }
501 break;
502
503 case FLI_EXPOSE_FRAME:
504 if (argc != 0)
505 r = -EINVAL;
506 else
507 {
508 switch (DEVICE->domain)
509 {
510 case FLIDOMAIN_PARALLEL_PORT:
511 r = fli_camera_parport_expose_frame(dev);
512 break;
513
514 case FLIDOMAIN_USB:
515 r = fli_camera_usb_expose_frame(dev);
516 break;
517
518 default:
519 r = -EINVAL;
520 }
521 }
522 break;
523
524 case FLI_FLUSH_ROWS:
525 if (argc != 2)
526 r = -EINVAL;
527 else
528 {
529 long rows, repeat;
530
531 rows = *va_arg(ap, long *);
532 repeat = *va_arg(ap, long *);
533
534 switch (DEVICE->domain)
535 {
536 case FLIDOMAIN_PARALLEL_PORT:
537 r = fli_camera_parport_flush_rows(dev, rows, repeat);
538 break;
539
540 case FLIDOMAIN_USB:
541 r = fli_camera_usb_flush_rows(dev, rows, repeat);
542 break;
543
544 default:
545 r = -EINVAL;
546 }
547 }
548 break;
549
550 case FLI_SET_FLUSHES:
551 if (argc != 1)
552 r = -EINVAL;
553 else
554 {
555 long nflushes;
556
557 nflushes = *va_arg(ap, long *);
558
559 switch (DEVICE->domain)
560 {
561 case FLIDOMAIN_PARALLEL_PORT:
562 r = fli_camera_parport_set_flushes(dev, nflushes);
563 break;
564
565 case FLIDOMAIN_USB:
566 r = fli_camera_usb_set_flushes(dev, nflushes);
567 break;
568
569 default:
570 r = -EINVAL;
571 }
572 }
573 break;
574
575 case FLI_SET_BIT_DEPTH:
576 if (argc != 1)
577 r = -EINVAL;
578 else
579 {
580 flibitdepth_t bitdepth;
581
582 bitdepth = *va_arg(ap, flibitdepth_t *);
583
584 switch (DEVICE->domain)
585 {
586 case FLIDOMAIN_PARALLEL_PORT:
587 r = fli_camera_parport_set_bit_depth(dev, bitdepth);
588 break;
589
590 case FLIDOMAIN_USB:
591 r = fli_camera_usb_set_bit_depth(dev, bitdepth);
592 break;
593
594 default:
595 r = -EINVAL;
596 }
597 }
598 break;
599
600 case FLI_READ_IOPORT:
601 if (argc != 1)
602 r = -EINVAL;
603 else
604 {
605 long *ioportset;
606
607 ioportset = va_arg(ap, long *);
608
609 switch (DEVICE->domain)
610 {
611 case FLIDOMAIN_PARALLEL_PORT:
612 r = fli_camera_parport_read_ioport(dev, ioportset);
613 break;
614
615 case FLIDOMAIN_USB:
616 r = fli_camera_usb_read_ioport(dev, ioportset);
617 break;
618
619 default:
620 r = -EINVAL;
621 }
622 }
623 break;
624
625 case FLI_WRITE_IOPORT:
626 if (argc != 1)
627 r = -EINVAL;
628 else
629 {
630 long ioportset;
631
632 ioportset = *va_arg(ap, long *);
633
634 switch (DEVICE->domain)
635 {
636 case FLIDOMAIN_PARALLEL_PORT:
637 r = fli_camera_parport_write_ioport(dev, ioportset);
638 break;
639
640 case FLIDOMAIN_USB:
641 r = fli_camera_usb_write_ioport(dev, ioportset);
642 break;
643
644 default:
645 r = -EINVAL;
646 }
647 }
648 break;
649
650 case FLI_CONFIGURE_IOPORT:
651 if (argc != 1)
652 r = -EINVAL;
653 else
654 {
655 long ioportset;
656
657 ioportset = *va_arg(ap, long *);
658
659 switch (DEVICE->domain)
660 {
661 case FLIDOMAIN_PARALLEL_PORT:
662 r = fli_camera_parport_configure_ioport(dev, ioportset);
663 break;
664
665 case FLIDOMAIN_USB:
666 r = fli_camera_usb_configure_ioport(dev, ioportset);
667 break;
668
669 default:
670 r = -EINVAL;
671 }
672 }
673 break;
674
675 case FLI_CONTROL_SHUTTER:
676 if (argc != 1)
677 r = -EINVAL;
678 else
679 {
680 long shutter;
681 flicamdata_t *cam;
682
683 cam = DEVICE->device_data;
684
685 shutter = *va_arg(ap, long *);
686
687 if( (shutter == FLI_SHUTTER_EXTERNAL_TRIGGER_LOW) ||
688 (shutter == FLI_SHUTTER_EXTERNAL_TRIGGER_HIGH) )
689 {
690 debug(FLIDEBUG_INFO, "External trigger.\n");
691 cam->exttrigger = 1;
692 cam->exttriggerpol = (shutter == FLI_SHUTTER_EXTERNAL_TRIGGER_LOW)?0:1;
693 r = 0;
694 }
695 else
696 {
697 cam->exttrigger = 0;
698 switch (DEVICE->domain)
699 {
700 case FLIDOMAIN_PARALLEL_PORT:
701 r = fli_camera_parport_control_shutter(dev, shutter);
702 break;
703
704 case FLIDOMAIN_USB:
705 r = fli_camera_usb_control_shutter(dev, shutter);
706 break;
707
708 default:
709 r = -EINVAL;
710 }
711 }
712 }
713 break;
714
715 case FLI_CONTROL_BGFLUSH:
716 if (argc != 1)
717 r = -EINVAL;
718 else
719 {
720 long bgflush;
721 flicamdata_t *cam;
722
723 cam = DEVICE->device_data;
724
725 bgflush = *va_arg(ap, long *);
726
727 switch (DEVICE->domain)
728 {
729 case FLIDOMAIN_PARALLEL_PORT:
730 r = -EFAULT;
731 break;
732
733 case FLIDOMAIN_USB:
734 r = fli_camera_usb_control_bgflush(dev, bgflush);
735 break;
736
737 default:
738 r = -EINVAL;
739 }
740 }
741 break;
742
743 default:
744 r = -EINVAL;
745 }
746
747 va_end(ap);
748
749 return r;
750 }
751
752 static long fli_camera_get_pixel_size(flidev_t dev,
753 double *pixel_x, double *pixel_y)
754 {
755 flicamdata_t *cam;
756
757 cam = DEVICE->device_data;
758 *pixel_x = (double)cam->ccd.pixelwidth;
759 *pixel_y = (double)cam->ccd.pixelheight;
760
761 return 0;
762 }
763
764 static long fli_camera_set_frame_type(flidev_t dev, fliframe_t frametype)
765 {
766 flicamdata_t *cam;
767
768 cam = DEVICE->device_data;
769
770 if ((frametype < FLI_FRAME_TYPE_NORMAL) || (frametype > FLI_FRAME_TYPE_DARK))
771 return -EINVAL;
772
773 cam->frametype = frametype;
774
775 return 0;
776 }
777
778 static long fli_camera_set_flushes(flidev_t dev, long nflushes)
779 {
780 flicamdata_t *cam;
781
782 cam = DEVICE->device_data;
783
784 if((nflushes < 0) || (nflushes > 5))
785 return -EINVAL;
786
787 cam->flushes = nflushes;
788
789 return 0;
790 }
Experimental kdeedu stuff