?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Staging: strip: delete the driver
[linux/fpc-iii.git] / drivers / media / video / pms.c
blob0598bbd3f368da323398fedbf378ebedcc21ff3d
1 /*
2 * Media Vision Pro Movie Studio
3 * or
4 * "all you need is an I2C bus some RAM and a prayer"
5 *
6 * This draws heavily on code
7 *
8 * (c) Wolfgang Koehler, wolf@first.gmd.de, Dec. 1994
9 * Kiefernring 15
10 * 14478 Potsdam, Germany
11 *
12 * Most of this code is directly derived from his userspace driver.
13 * His driver works so send any reports to alan@lxorguk.ukuu.org.uk
14 * unless the userspace driver also doesn't work for you...
15 *
16 * Changes:
17 * 25-11-2009 Hans Verkuil <hverkuil@xs4all.nl>
18 * - converted to version 2 of the V4L API.
19 * 08/07/2003 Daniele Bellucci <bellucda@tiscali.it>
20 * - pms_capture: report back -EFAULT
21 */
22
23 #include <linux/module.h>
24 #include <linux/delay.h>
25 #include <linux/errno.h>
26 #include <linux/fs.h>
27 #include <linux/kernel.h>
28 #include <linux/mm.h>
29 #include <linux/ioport.h>
30 #include <linux/init.h>
31 #include <linux/version.h>
32 #include <linux/mutex.h>
33 #include <linux/uaccess.h>
34 #include <asm/io.h>
35
36 #include <linux/videodev2.h>
37 #include <media/v4l2-common.h>
38 #include <media/v4l2-ioctl.h>
39 #include <media/v4l2-device.h>
40
41 MODULE_LICENSE("GPL");
42
43
44 #define MOTOROLA 1
45 #define PHILIPS2 2 /* SAA7191 */
46 #define PHILIPS1 3
47 #define MVVMEMORYWIDTH 0x40 /* 512 bytes */
48
49 struct i2c_info {
50 u8 slave;
51 u8 sub;
52 u8 data;
53 u8 hits;
54 };
55
56 struct pms {
57 struct v4l2_device v4l2_dev;
58 struct video_device vdev;
59 int height;
60 int width;
61 int depth;
62 int input;
63 s32 brightness, saturation, hue, contrast;
64 unsigned long in_use;
65 struct mutex lock;
66 int i2c_count;
67 struct i2c_info i2cinfo[64];
68
69 int decoder;
70 int standard; /* 0 - auto 1 - ntsc 2 - pal 3 - secam */
71 v4l2_std_id std;
72 int io;
73 int data;
74 void __iomem *mem;
75 };
76
77 static struct pms pms_card;
78
79 /*
80 * I/O ports and Shared Memory
81 */
82
83 static int io_port = 0x250;
84 module_param(io_port, int, 0);
85
86 static int mem_base = 0xc8000;
87 module_param(mem_base, int, 0);
88
89 static int video_nr = -1;
90 module_param(video_nr, int, 0);
91
92
93 static inline void mvv_write(struct pms *dev, u8 index, u8 value)
94 {
95 outw(index | (value << 8), dev->io);
96 }
97
98 static inline u8 mvv_read(struct pms *dev, u8 index)
99 {
100 outb(index, dev->io);
101 return inb(dev->data);
102 }
103
104 static int pms_i2c_stat(struct pms *dev, u8 slave)
105 {
106 int counter = 0;
107 int i;
108
109 outb(0x28, dev->io);
110
111 while ((inb(dev->data) & 0x01) == 0)
112 if (counter++ == 256)
113 break;
114
115 while ((inb(dev->data) & 0x01) != 0)
116 if (counter++ == 256)
117 break;
118
119 outb(slave, dev->io);
120
121 counter = 0;
122 while ((inb(dev->data) & 0x01) == 0)
123 if (counter++ == 256)
124 break;
125
126 while ((inb(dev->data) & 0x01) != 0)
127 if (counter++ == 256)
128 break;
129
130 for (i = 0; i < 12; i++) {
131 char st = inb(dev->data);
132
133 if ((st & 2) != 0)
134 return -1;
135 if ((st & 1) == 0)
136 break;
137 }
138 outb(0x29, dev->io);
139 return inb(dev->data);
140 }
141
142 static int pms_i2c_write(struct pms *dev, u16 slave, u16 sub, u16 data)
143 {
144 int skip = 0;
145 int count;
146 int i;
147
148 for (i = 0; i < dev->i2c_count; i++) {
149 if ((dev->i2cinfo[i].slave == slave) &&
150 (dev->i2cinfo[i].sub == sub)) {
151 if (dev->i2cinfo[i].data == data)
152 skip = 1;
153 dev->i2cinfo[i].data = data;
154 i = dev->i2c_count + 1;
155 }
156 }
157
158 if (i == dev->i2c_count && dev->i2c_count < 64) {
159 dev->i2cinfo[dev->i2c_count].slave = slave;
160 dev->i2cinfo[dev->i2c_count].sub = sub;
161 dev->i2cinfo[dev->i2c_count].data = data;
162 dev->i2c_count++;
163 }
164
165 if (skip)
166 return 0;
167
168 mvv_write(dev, 0x29, sub);
169 mvv_write(dev, 0x2A, data);
170 mvv_write(dev, 0x28, slave);
171
172 outb(0x28, dev->io);
173
174 count = 0;
175 while ((inb(dev->data) & 1) == 0)
176 if (count > 255)
177 break;
178 while ((inb(dev->data) & 1) != 0)
179 if (count > 255)
180 break;
181
182 count = inb(dev->data);
183
184 if (count & 2)
185 return -1;
186 return count;
187 }
188
189 static int pms_i2c_read(struct pms *dev, int slave, int sub)
190 {
191 int i;
192
193 for (i = 0; i < dev->i2c_count; i++) {
194 if (dev->i2cinfo[i].slave == slave && dev->i2cinfo[i].sub == sub)
195 return dev->i2cinfo[i].data;
196 }
197 return 0;
198 }
199
200
201 static void pms_i2c_andor(struct pms *dev, int slave, int sub, int and, int or)
202 {
203 u8 tmp;
204
205 tmp = pms_i2c_read(dev, slave, sub);
206 tmp = (tmp & and) | or;
207 pms_i2c_write(dev, slave, sub, tmp);
208 }
209
210 /*
211 * Control functions
212 */
213
214
215 static void pms_videosource(struct pms *dev, short source)
216 {
217 switch (dev->decoder) {
218 case MOTOROLA:
219 break;
220 case PHILIPS2:
221 pms_i2c_andor(dev, 0x8a, 0x06, 0x7f, source ? 0x80 : 0);
222 break;
223 case PHILIPS1:
224 break;
225 }
226 mvv_write(dev, 0x2E, 0x31);
227 /* Was: mvv_write(dev, 0x2E, source ? 0x31 : 0x30);
228 But could not make this work correctly. Only Composite input
229 worked for me. */
230 }
231
232 static void pms_hue(struct pms *dev, short hue)
233 {
234 switch (dev->decoder) {
235 case MOTOROLA:
236 pms_i2c_write(dev, 0x8a, 0x00, hue);
237 break;
238 case PHILIPS2:
239 pms_i2c_write(dev, 0x8a, 0x07, hue);
240 break;
241 case PHILIPS1:
242 pms_i2c_write(dev, 0x42, 0x07, hue);
243 break;
244 }
245 }
246
247 static void pms_saturation(struct pms *dev, short sat)
248 {
249 switch (dev->decoder) {
250 case MOTOROLA:
251 pms_i2c_write(dev, 0x8a, 0x00, sat);
252 break;
253 case PHILIPS1:
254 pms_i2c_write(dev, 0x42, 0x12, sat);
255 break;
256 }
257 }
258
259
260 static void pms_contrast(struct pms *dev, short contrast)
261 {
262 switch (dev->decoder) {
263 case MOTOROLA:
264 pms_i2c_write(dev, 0x8a, 0x00, contrast);
265 break;
266 case PHILIPS1:
267 pms_i2c_write(dev, 0x42, 0x13, contrast);
268 break;
269 }
270 }
271
272 static void pms_brightness(struct pms *dev, short brightness)
273 {
274 switch (dev->decoder) {
275 case MOTOROLA:
276 pms_i2c_write(dev, 0x8a, 0x00, brightness);
277 pms_i2c_write(dev, 0x8a, 0x00, brightness);
278 pms_i2c_write(dev, 0x8a, 0x00, brightness);
279 break;
280 case PHILIPS1:
281 pms_i2c_write(dev, 0x42, 0x19, brightness);
282 break;
283 }
284 }
285
286
287 static void pms_format(struct pms *dev, short format)
288 {
289 int target;
290
291 dev->standard = format;
292
293 if (dev->decoder == PHILIPS1)
294 target = 0x42;
295 else if (dev->decoder == PHILIPS2)
296 target = 0x8a;
297 else
298 return;
299
300 switch (format) {
301 case 0: /* Auto */
302 pms_i2c_andor(dev, target, 0x0d, 0xfe, 0x00);
303 pms_i2c_andor(dev, target, 0x0f, 0x3f, 0x80);
304 break;
305 case 1: /* NTSC */
306 pms_i2c_andor(dev, target, 0x0d, 0xfe, 0x00);
307 pms_i2c_andor(dev, target, 0x0f, 0x3f, 0x40);
308 break;
309 case 2: /* PAL */
310 pms_i2c_andor(dev, target, 0x0d, 0xfe, 0x00);
311 pms_i2c_andor(dev, target, 0x0f, 0x3f, 0x00);
312 break;
313 case 3: /* SECAM */
314 pms_i2c_andor(dev, target, 0x0d, 0xfe, 0x01);
315 pms_i2c_andor(dev, target, 0x0f, 0x3f, 0x00);
316 break;
317 }
318 }
319
320 #ifdef FOR_FUTURE_EXPANSION
321
322 /*
323 * These features of the PMS card are not currently exposes. They
324 * could become a private v4l ioctl for PMSCONFIG or somesuch if
325 * people need it. We also don't yet use the PMS interrupt.
326 */
327
328 static void pms_hstart(struct pms *dev, short start)
329 {
330 switch (dev->decoder) {
331 case PHILIPS1:
332 pms_i2c_write(dev, 0x8a, 0x05, start);
333 pms_i2c_write(dev, 0x8a, 0x18, start);
334 break;
335 case PHILIPS2:
336 pms_i2c_write(dev, 0x42, 0x05, start);
337 pms_i2c_write(dev, 0x42, 0x18, start);
338 break;
339 }
340 }
341
342 /*
343 * Bandpass filters
344 */
345
346 static void pms_bandpass(struct pms *dev, short pass)
347 {
348 if (dev->decoder == PHILIPS2)
349 pms_i2c_andor(dev, 0x8a, 0x06, 0xcf, (pass & 0x03) << 4);
350 else if (dev->decoder == PHILIPS1)
351 pms_i2c_andor(dev, 0x42, 0x06, 0xcf, (pass & 0x03) << 4);
352 }
353
354 static void pms_antisnow(struct pms *dev, short snow)
355 {
356 if (dev->decoder == PHILIPS2)
357 pms_i2c_andor(dev, 0x8a, 0x06, 0xf3, (snow & 0x03) << 2);
358 else if (dev->decoder == PHILIPS1)
359 pms_i2c_andor(dev, 0x42, 0x06, 0xf3, (snow & 0x03) << 2);
360 }
361
362 static void pms_sharpness(struct pms *dev, short sharp)
363 {
364 if (dev->decoder == PHILIPS2)
365 pms_i2c_andor(dev, 0x8a, 0x06, 0xfc, sharp & 0x03);
366 else if (dev->decoder == PHILIPS1)
367 pms_i2c_andor(dev, 0x42, 0x06, 0xfc, sharp & 0x03);
368 }
369
370 static void pms_chromaagc(struct pms *dev, short agc)
371 {
372 if (dev->decoder == PHILIPS2)
373 pms_i2c_andor(dev, 0x8a, 0x0c, 0x9f, (agc & 0x03) << 5);
374 else if (dev->decoder == PHILIPS1)
375 pms_i2c_andor(dev, 0x42, 0x0c, 0x9f, (agc & 0x03) << 5);
376 }
377
378 static void pms_vertnoise(struct pms *dev, short noise)
379 {
380 if (dev->decoder == PHILIPS2)
381 pms_i2c_andor(dev, 0x8a, 0x10, 0xfc, noise & 3);
382 else if (dev->decoder == PHILIPS1)
383 pms_i2c_andor(dev, 0x42, 0x10, 0xfc, noise & 3);
384 }
385
386 static void pms_forcecolour(struct pms *dev, short colour)
387 {
388 if (dev->decoder == PHILIPS2)
389 pms_i2c_andor(dev, 0x8a, 0x0c, 0x7f, (colour & 1) << 7);
390 else if (dev->decoder == PHILIPS1)
391 pms_i2c_andor(dev, 0x42, 0x0c, 0x7, (colour & 1) << 7);
392 }
393
394 static void pms_antigamma(struct pms *dev, short gamma)
395 {
396 if (dev->decoder == PHILIPS2)
397 pms_i2c_andor(dev, 0xb8, 0x00, 0x7f, (gamma & 1) << 7);
398 else if (dev->decoder == PHILIPS1)
399 pms_i2c_andor(dev, 0x42, 0x20, 0x7, (gamma & 1) << 7);
400 }
401
402 static void pms_prefilter(struct pms *dev, short filter)
403 {
404 if (dev->decoder == PHILIPS2)
405 pms_i2c_andor(dev, 0x8a, 0x06, 0xbf, (filter & 1) << 6);
406 else if (dev->decoder == PHILIPS1)
407 pms_i2c_andor(dev, 0x42, 0x06, 0xbf, (filter & 1) << 6);
408 }
409
410 static void pms_hfilter(struct pms *dev, short filter)
411 {
412 if (dev->decoder == PHILIPS2)
413 pms_i2c_andor(dev, 0xb8, 0x04, 0x1f, (filter & 7) << 5);
414 else if (dev->decoder == PHILIPS1)
415 pms_i2c_andor(dev, 0x42, 0x24, 0x1f, (filter & 7) << 5);
416 }
417
418 static void pms_vfilter(struct pms *dev, short filter)
419 {
420 if (dev->decoder == PHILIPS2)
421 pms_i2c_andor(dev, 0xb8, 0x08, 0x9f, (filter & 3) << 5);
422 else if (dev->decoder == PHILIPS1)
423 pms_i2c_andor(dev, 0x42, 0x28, 0x9f, (filter & 3) << 5);
424 }
425
426 static void pms_killcolour(struct pms *dev, short colour)
427 {
428 if (dev->decoder == PHILIPS2) {
429 pms_i2c_andor(dev, 0x8a, 0x08, 0x07, (colour & 0x1f) << 3);
430 pms_i2c_andor(dev, 0x8a, 0x09, 0x07, (colour & 0x1f) << 3);
431 } else if (dev->decoder == PHILIPS1) {
432 pms_i2c_andor(dev, 0x42, 0x08, 0x07, (colour & 0x1f) << 3);
433 pms_i2c_andor(dev, 0x42, 0x09, 0x07, (colour & 0x1f) << 3);
434 }
435 }
436
437 static void pms_chromagain(struct pms *dev, short chroma)
438 {
439 if (dev->decoder == PHILIPS2)
440 pms_i2c_write(dev, 0x8a, 0x11, chroma);
441 else if (dev->decoder == PHILIPS1)
442 pms_i2c_write(dev, 0x42, 0x11, chroma);
443 }
444
445
446 static void pms_spacialcompl(struct pms *dev, short data)
447 {
448 mvv_write(dev, 0x3b, data);
449 }
450
451 static void pms_spacialcomph(struct pms *dev, short data)
452 {
453 mvv_write(dev, 0x3a, data);
454 }
455
456 static void pms_vstart(struct pms *dev, short start)
457 {
458 mvv_write(dev, 0x16, start);
459 mvv_write(dev, 0x17, (start >> 8) & 0x01);
460 }
461
462 #endif
463
464 static void pms_secamcross(struct pms *dev, short cross)
465 {
466 if (dev->decoder == PHILIPS2)
467 pms_i2c_andor(dev, 0x8a, 0x0f, 0xdf, (cross & 1) << 5);
468 else if (dev->decoder == PHILIPS1)
469 pms_i2c_andor(dev, 0x42, 0x0f, 0xdf, (cross & 1) << 5);
470 }
471
472
473 static void pms_swsense(struct pms *dev, short sense)
474 {
475 if (dev->decoder == PHILIPS2) {
476 pms_i2c_write(dev, 0x8a, 0x0a, sense);
477 pms_i2c_write(dev, 0x8a, 0x0b, sense);
478 } else if (dev->decoder == PHILIPS1) {
479 pms_i2c_write(dev, 0x42, 0x0a, sense);
480 pms_i2c_write(dev, 0x42, 0x0b, sense);
481 }
482 }
483
484
485 static void pms_framerate(struct pms *dev, short frr)
486 {
487 int fps = (dev->std & V4L2_STD_525_60) ? 30 : 25;
488
489 if (frr == 0)
490 return;
491 fps = fps/frr;
492 mvv_write(dev, 0x14, 0x80 | fps);
493 mvv_write(dev, 0x15, 1);
494 }
495
496 static void pms_vert(struct pms *dev, u8 deciden, u8 decinum)
497 {
498 mvv_write(dev, 0x1c, deciden); /* Denominator */
499 mvv_write(dev, 0x1d, decinum); /* Numerator */
500 }
501
502 /*
503 * Turn 16bit ratios into best small ratio the chipset can grok
504 */
505
506 static void pms_vertdeci(struct pms *dev, unsigned short decinum, unsigned short deciden)
507 {
508 /* Knock it down by / 5 once */
509 if (decinum % 5 == 0) {
510 deciden /= 5;
511 decinum /= 5;
512 }
513 /*
514 * 3's
515 */
516 while (decinum % 3 == 0 && deciden % 3 == 0) {
517 deciden /= 3;
518 decinum /= 3;
519 }
520 /*
521 * 2's
522 */
523 while (decinum % 2 == 0 && deciden % 2 == 0) {
524 decinum /= 2;
525 deciden /= 2;
526 }
527 /*
528 * Fudgyify
529 */
530 while (deciden > 32) {
531 deciden /= 2;
532 decinum = (decinum + 1) / 2;
533 }
534 if (deciden == 32)
535 deciden--;
536 pms_vert(dev, deciden, decinum);
537 }
538
539 static void pms_horzdeci(struct pms *dev, short decinum, short deciden)
540 {
541 if (decinum <= 512) {
542 if (decinum % 5 == 0) {
543 decinum /= 5;
544 deciden /= 5;
545 }
546 } else {
547 decinum = 512;
548 deciden = 640; /* 768 would be ideal */
549 }
550
551 while (((decinum | deciden) & 1) == 0) {
552 decinum >>= 1;
553 deciden >>= 1;
554 }
555 while (deciden > 32) {
556 deciden >>= 1;
557 decinum = (decinum + 1) >> 1;
558 }
559 if (deciden == 32)
560 deciden--;
561
562 mvv_write(dev, 0x24, 0x80 | deciden);
563 mvv_write(dev, 0x25, decinum);
564 }
565
566 static void pms_resolution(struct pms *dev, short width, short height)
567 {
568 int fg_height;
569
570 fg_height = height;
571 if (fg_height > 280)
572 fg_height = 280;
573
574 mvv_write(dev, 0x18, fg_height);
575 mvv_write(dev, 0x19, fg_height >> 8);
576
577 if (dev->std & V4L2_STD_525_60) {
578 mvv_write(dev, 0x1a, 0xfc);
579 mvv_write(dev, 0x1b, 0x00);
580 if (height > fg_height)
581 pms_vertdeci(dev, 240, 240);
582 else
583 pms_vertdeci(dev, fg_height, 240);
584 } else {
585 mvv_write(dev, 0x1a, 0x1a);
586 mvv_write(dev, 0x1b, 0x01);
587 if (fg_height > 256)
588 pms_vertdeci(dev, 270, 270);
589 else
590 pms_vertdeci(dev, fg_height, 270);
591 }
592 mvv_write(dev, 0x12, 0);
593 mvv_write(dev, 0x13, MVVMEMORYWIDTH);
594 mvv_write(dev, 0x42, 0x00);
595 mvv_write(dev, 0x43, 0x00);
596 mvv_write(dev, 0x44, MVVMEMORYWIDTH);
597
598 mvv_write(dev, 0x22, width + 8);
599 mvv_write(dev, 0x23, (width + 8) >> 8);
600
601 if (dev->std & V4L2_STD_525_60)
602 pms_horzdeci(dev, width, 640);
603 else
604 pms_horzdeci(dev, width + 8, 768);
605
606 mvv_write(dev, 0x30, mvv_read(dev, 0x30) & 0xfe);
607 mvv_write(dev, 0x08, mvv_read(dev, 0x08) | 0x01);
608 mvv_write(dev, 0x01, mvv_read(dev, 0x01) & 0xfd);
609 mvv_write(dev, 0x32, 0x00);
610 mvv_write(dev, 0x33, MVVMEMORYWIDTH);
611 }
612
613
614 /*
615 * Set Input
616 */
617
618 static void pms_vcrinput(struct pms *dev, short input)
619 {
620 if (dev->decoder == PHILIPS2)
621 pms_i2c_andor(dev, 0x8a, 0x0d, 0x7f, (input & 1) << 7);
622 else if (dev->decoder == PHILIPS1)
623 pms_i2c_andor(dev, 0x42, 0x0d, 0x7f, (input & 1) << 7);
624 }
625
626
627 static int pms_capture(struct pms *dev, char __user *buf, int rgb555, int count)
628 {
629 int y;
630 int dw = 2 * dev->width;
631 char tmp[dw + 32]; /* using a temp buffer is faster than direct */
632 int cnt = 0;
633 int len = 0;
634 unsigned char r8 = 0x5; /* value for reg8 */
635
636 if (rgb555)
637 r8 |= 0x20; /* else use untranslated rgb = 565 */
638 mvv_write(dev, 0x08, r8); /* capture rgb555/565, init DRAM, PC enable */
639
640 /* printf("%d %d %d %d %d %x %x\n",width,height,voff,nom,den,mvv_buf); */
641
642 for (y = 0; y < dev->height; y++) {
643 writeb(0, dev->mem); /* synchronisiert neue Zeile */
644
645 /*
646 * This is in truth a fifo, be very careful as if you
647 * forgot this odd things will occur 8)
648 */
649
650 memcpy_fromio(tmp, dev->mem, dw + 32); /* discard 16 word */
651 cnt -= dev->height;
652 while (cnt <= 0) {
653 /*
654 * Don't copy too far
655 */
656 int dt = dw;
657 if (dt + len > count)
658 dt = count - len;
659 cnt += dev->height;
660 if (copy_to_user(buf, tmp + 32, dt))
661 return len ? len : -EFAULT;
662 buf += dt;
663 len += dt;
664 }
665 }
666 return len;
667 }
668
669
670 /*
671 * Video4linux interfacing
672 */
673
674 static int pms_querycap(struct file *file, void *priv,
675 struct v4l2_capability *vcap)
676 {
677 struct pms *dev = video_drvdata(file);
678
679 strlcpy(vcap->driver, dev->v4l2_dev.name, sizeof(vcap->driver));
680 strlcpy(vcap->card, "Mediavision PMS", sizeof(vcap->card));
681 strlcpy(vcap->bus_info, "ISA", sizeof(vcap->bus_info));
682 vcap->version = KERNEL_VERSION(0, 0, 3);
683 vcap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE;
684 return 0;
685 }
686
687 static int pms_enum_input(struct file *file, void *fh, struct v4l2_input *vin)
688 {
689 static const char *inputs[4] = {
690 "Composite",
691 "S-Video",
692 "Composite (VCR)",
693 "S-Video (VCR)"
694 };
695
696 if (vin->index > 3)
697 return -EINVAL;
698 strlcpy(vin->name, inputs[vin->index], sizeof(vin->name));
699 vin->type = V4L2_INPUT_TYPE_CAMERA;
700 vin->audioset = 0;
701 vin->tuner = 0;
702 vin->std = V4L2_STD_ALL;
703 vin->status = 0;
704 return 0;
705 }
706
707 static int pms_g_input(struct file *file, void *fh, unsigned int *inp)
708 {
709 struct pms *dev = video_drvdata(file);
710
711 *inp = dev->input;
712 return 0;
713 }
714
715 static int pms_s_input(struct file *file, void *fh, unsigned int inp)
716 {
717 struct pms *dev = video_drvdata(file);
718
719 if (inp > 3)
720 return -EINVAL;
721
722 mutex_lock(&dev->lock);
723 dev->input = inp;
724 pms_videosource(dev, inp & 1);
725 pms_vcrinput(dev, inp >> 1);
726 mutex_unlock(&dev->lock);
727 return 0;
728 }
729
730 static int pms_g_std(struct file *file, void *fh, v4l2_std_id *std)
731 {
732 struct pms *dev = video_drvdata(file);
733
734 *std = dev->std;
735 return 0;
736 }
737
738 static int pms_s_std(struct file *file, void *fh, v4l2_std_id *std)
739 {
740 struct pms *dev = video_drvdata(file);
741 int ret = 0;
742
743 dev->std = *std;
744 mutex_lock(&dev->lock);
745 if (dev->std & V4L2_STD_NTSC) {
746 pms_framerate(dev, 30);
747 pms_secamcross(dev, 0);
748 pms_format(dev, 1);
749 } else if (dev->std & V4L2_STD_PAL) {
750 pms_framerate(dev, 25);
751 pms_secamcross(dev, 0);
752 pms_format(dev, 2);
753 } else if (dev->std & V4L2_STD_SECAM) {
754 pms_framerate(dev, 25);
755 pms_secamcross(dev, 1);
756 pms_format(dev, 2);
757 } else {
758 ret = -EINVAL;
759 }
760 /*
761 switch (v->mode) {
762 case VIDEO_MODE_AUTO:
763 pms_framerate(dev, 25);
764 pms_secamcross(dev, 0);
765 pms_format(dev, 0);
766 break;
767 }*/
768 mutex_unlock(&dev->lock);
769 return 0;
770 }
771
772 static int pms_queryctrl(struct file *file, void *priv,
773 struct v4l2_queryctrl *qc)
774 {
775 switch (qc->id) {
776 case V4L2_CID_BRIGHTNESS:
777 return v4l2_ctrl_query_fill(qc, 0, 255, 1, 139);
778 case V4L2_CID_CONTRAST:
779 return v4l2_ctrl_query_fill(qc, 0, 255, 1, 70);
780 case V4L2_CID_SATURATION:
781 return v4l2_ctrl_query_fill(qc, 0, 255, 1, 64);
782 case V4L2_CID_HUE:
783 return v4l2_ctrl_query_fill(qc, 0, 255, 1, 0);
784 }
785 return -EINVAL;
786 }
787
788 static int pms_g_ctrl(struct file *file, void *priv,
789 struct v4l2_control *ctrl)
790 {
791 struct pms *dev = video_drvdata(file);
792 int ret = 0;
793
794 switch (ctrl->id) {
795 case V4L2_CID_BRIGHTNESS:
796 ctrl->value = dev->brightness;
797 break;
798 case V4L2_CID_CONTRAST:
799 ctrl->value = dev->contrast;
800 break;
801 case V4L2_CID_SATURATION:
802 ctrl->value = dev->saturation;
803 break;
804 case V4L2_CID_HUE:
805 ctrl->value = dev->hue;
806 break;
807 default:
808 ret = -EINVAL;
809 break;
810 }
811 return ret;
812 }
813
814 static int pms_s_ctrl(struct file *file, void *priv,
815 struct v4l2_control *ctrl)
816 {
817 struct pms *dev = video_drvdata(file);
818 int ret = 0;
819
820 mutex_lock(&dev->lock);
821 switch (ctrl->id) {
822 case V4L2_CID_BRIGHTNESS:
823 dev->brightness = ctrl->value;
824 pms_brightness(dev, dev->brightness);
825 break;
826 case V4L2_CID_CONTRAST:
827 dev->contrast = ctrl->value;
828 pms_contrast(dev, dev->contrast);
829 break;
830 case V4L2_CID_SATURATION:
831 dev->saturation = ctrl->value;
832 pms_saturation(dev, dev->saturation);
833 break;
834 case V4L2_CID_HUE:
835 dev->hue = ctrl->value;
836 pms_hue(dev, dev->hue);
837 break;
838 default:
839 ret = -EINVAL;
840 break;
841 }
842 mutex_unlock(&dev->lock);
843 return ret;
844 }
845
846 static int pms_g_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
847 {
848 struct pms *dev = video_drvdata(file);
849 struct v4l2_pix_format *pix = &fmt->fmt.pix;
850
851 pix->width = dev->width;
852 pix->height = dev->height;
853 pix->pixelformat = dev->width == 15 ?
854 V4L2_PIX_FMT_RGB555 : V4L2_PIX_FMT_RGB565;
855 pix->field = V4L2_FIELD_NONE;
856 pix->bytesperline = 2 * dev->width;
857 pix->sizeimage = 2 * dev->width * dev->height;
858 /* Just a guess */
859 pix->colorspace = V4L2_COLORSPACE_SRGB;
860 return 0;
861 }
862
863 static int pms_try_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
864 {
865 struct v4l2_pix_format *pix = &fmt->fmt.pix;
866
867 if (pix->height < 16 || pix->height > 480)
868 return -EINVAL;
869 if (pix->width < 16 || pix->width > 640)
870 return -EINVAL;
871 if (pix->pixelformat != V4L2_PIX_FMT_RGB555 &&
872 pix->pixelformat != V4L2_PIX_FMT_RGB565)
873 return -EINVAL;
874 pix->field = V4L2_FIELD_NONE;
875 pix->bytesperline = 2 * pix->width;
876 pix->sizeimage = 2 * pix->width * pix->height;
877 /* Just a guess */
878 pix->colorspace = V4L2_COLORSPACE_SRGB;
879 return 0;
880 }
881
882 static int pms_s_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
883 {
884 struct pms *dev = video_drvdata(file);
885 struct v4l2_pix_format *pix = &fmt->fmt.pix;
886 int ret = pms_try_fmt_vid_cap(file, fh, fmt);
887
888 if (ret)
889 return ret;
890 mutex_lock(&dev->lock);
891 dev->width = pix->width;
892 dev->height = pix->height;
893 dev->depth = (pix->pixelformat == V4L2_PIX_FMT_RGB555) ? 15 : 16;
894 pms_resolution(dev, dev->width, dev->height);
895 /* Ok we figured out what to use from our wide choice */
896 mutex_unlock(&dev->lock);
897 return 0;
898 }
899
900 static int pms_enum_fmt_vid_cap(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
901 {
902 static struct v4l2_fmtdesc formats[] = {
903 { 0, 0, 0,
904 "RGB 5:5:5", V4L2_PIX_FMT_RGB555,
905 { 0, 0, 0, 0 }
906 },
907 { 0, 0, 0,
908 "RGB 5:6:5", V4L2_PIX_FMT_RGB565,
909 { 0, 0, 0, 0 }
910 },
911 };
912 enum v4l2_buf_type type = fmt->type;
913
914 if (fmt->index > 1)
915 return -EINVAL;
916
917 *fmt = formats[fmt->index];
918 fmt->type = type;
919 return 0;
920 }
921
922 static ssize_t pms_read(struct file *file, char __user *buf,
923 size_t count, loff_t *ppos)
924 {
925 struct pms *dev = video_drvdata(file);
926 int len;
927
928 mutex_lock(&dev->lock);
929 len = pms_capture(dev, buf, (dev->depth == 15), count);
930 mutex_unlock(&dev->lock);
931 return len;
932 }
933
934 static int pms_exclusive_open(struct file *file)
935 {
936 struct pms *dev = video_drvdata(file);
937
938 return test_and_set_bit(0, &dev->in_use) ? -EBUSY : 0;
939 }
940
941 static int pms_exclusive_release(struct file *file)
942 {
943 struct pms *dev = video_drvdata(file);
944
945 clear_bit(0, &dev->in_use);
946 return 0;
947 }
948
949 static const struct v4l2_file_operations pms_fops = {
950 .owner = THIS_MODULE,
951 .open = pms_exclusive_open,
952 .release = pms_exclusive_release,
953 .ioctl = video_ioctl2,
954 .read = pms_read,
955 };
956
957 static const struct v4l2_ioctl_ops pms_ioctl_ops = {
958 .vidioc_querycap = pms_querycap,
959 .vidioc_g_input = pms_g_input,
960 .vidioc_s_input = pms_s_input,
961 .vidioc_enum_input = pms_enum_input,
962 .vidioc_g_std = pms_g_std,
963 .vidioc_s_std = pms_s_std,
964 .vidioc_queryctrl = pms_queryctrl,
965 .vidioc_g_ctrl = pms_g_ctrl,
966 .vidioc_s_ctrl = pms_s_ctrl,
967 .vidioc_enum_fmt_vid_cap = pms_enum_fmt_vid_cap,
968 .vidioc_g_fmt_vid_cap = pms_g_fmt_vid_cap,
969 .vidioc_s_fmt_vid_cap = pms_s_fmt_vid_cap,
970 .vidioc_try_fmt_vid_cap = pms_try_fmt_vid_cap,
971 };
972
973 /*
974 * Probe for and initialise the Mediavision PMS
975 */
976
977 static int init_mediavision(struct pms *dev)
978 {
979 int id;
980 int idec, decst;
981 int i;
982 static const unsigned char i2c_defs[] = {
983 0x4c, 0x30, 0x00, 0xe8,
984 0xb6, 0xe2, 0x00, 0x00,
985 0xff, 0xff, 0x00, 0x00,
986 0x00, 0x00, 0x78, 0x98,
987 0x00, 0x00, 0x00, 0x00,
988 0x34, 0x0a, 0xf4, 0xce,
989 0xe4
990 };
991
992 dev->mem = ioremap(mem_base, 0x800);
993 if (!dev->mem)
994 return -ENOMEM;
995
996 if (!request_region(0x9a01, 1, "Mediavision PMS config")) {
997 printk(KERN_WARNING "mediavision: unable to detect: 0x9a01 in use.\n");
998 iounmap(dev->mem);
999 return -EBUSY;
1000 }
1001 if (!request_region(dev->io, 3, "Mediavision PMS")) {
1002 printk(KERN_WARNING "mediavision: I/O port %d in use.\n", dev->io);
1003 release_region(0x9a01, 1);
1004 iounmap(dev->mem);
1005 return -EBUSY;
1006 }
1007 outb(0xb8, 0x9a01); /* Unlock */
1008 outb(dev->io >> 4, 0x9a01); /* Set IO port */
1009
1010
1011 id = mvv_read(dev, 3);
1012 decst = pms_i2c_stat(dev, 0x43);
1013
1014 if (decst != -1)
1015 idec = 2;
1016 else if (pms_i2c_stat(dev, 0xb9) != -1)
1017 idec = 3;
1018 else if (pms_i2c_stat(dev, 0x8b) != -1)
1019 idec = 1;
1020 else
1021 idec = 0;
1022
1023 printk(KERN_INFO "PMS type is %d\n", idec);
1024 if (idec == 0) {
1025 release_region(dev->io, 3);
1026 release_region(0x9a01, 1);
1027 iounmap(dev->mem);
1028 return -ENODEV;
1029 }
1030
1031 /*
1032 * Ok we have a PMS of some sort
1033 */
1034
1035 mvv_write(dev, 0x04, mem_base >> 12); /* Set the memory area */
1036
1037 /* Ok now load the defaults */
1038
1039 for (i = 0; i < 0x19; i++) {
1040 if (i2c_defs[i] == 0xff)
1041 pms_i2c_andor(dev, 0x8a, i, 0x07, 0x00);
1042 else
1043 pms_i2c_write(dev, 0x8a, i, i2c_defs[i]);
1044 }
1045
1046 pms_i2c_write(dev, 0xb8, 0x00, 0x12);
1047 pms_i2c_write(dev, 0xb8, 0x04, 0x00);
1048 pms_i2c_write(dev, 0xb8, 0x07, 0x00);
1049 pms_i2c_write(dev, 0xb8, 0x08, 0x00);
1050 pms_i2c_write(dev, 0xb8, 0x09, 0xff);
1051 pms_i2c_write(dev, 0xb8, 0x0a, 0x00);
1052 pms_i2c_write(dev, 0xb8, 0x0b, 0x10);
1053 pms_i2c_write(dev, 0xb8, 0x10, 0x03);
1054
1055 mvv_write(dev, 0x01, 0x00);
1056 mvv_write(dev, 0x05, 0xa0);
1057 mvv_write(dev, 0x08, 0x25);
1058 mvv_write(dev, 0x09, 0x00);
1059 mvv_write(dev, 0x0a, 0x20 | MVVMEMORYWIDTH);
1060
1061 mvv_write(dev, 0x10, 0x02);
1062 mvv_write(dev, 0x1e, 0x0c);
1063 mvv_write(dev, 0x1f, 0x03);
1064 mvv_write(dev, 0x26, 0x06);
1065
1066 mvv_write(dev, 0x2b, 0x00);
1067 mvv_write(dev, 0x2c, 0x20);
1068 mvv_write(dev, 0x2d, 0x00);
1069 mvv_write(dev, 0x2f, 0x70);
1070 mvv_write(dev, 0x32, 0x00);
1071 mvv_write(dev, 0x33, MVVMEMORYWIDTH);
1072 mvv_write(dev, 0x34, 0x00);
1073 mvv_write(dev, 0x35, 0x00);
1074 mvv_write(dev, 0x3a, 0x80);
1075 mvv_write(dev, 0x3b, 0x10);
1076 mvv_write(dev, 0x20, 0x00);
1077 mvv_write(dev, 0x21, 0x00);
1078 mvv_write(dev, 0x30, 0x22);
1079 return 0;
1080 }
1081
1082 /*
1083 * Initialization and module stuff
1084 */
1085
1086 #ifndef MODULE
1087 static int enable;
1088 module_param(enable, int, 0);
1089 #endif
1090
1091 static int __init pms_init(void)
1092 {
1093 struct pms *dev = &pms_card;
1094 struct v4l2_device *v4l2_dev = &dev->v4l2_dev;
1095 int res;
1096
1097 strlcpy(v4l2_dev->name, "pms", sizeof(v4l2_dev->name));
1098
1099 v4l2_info(v4l2_dev, "Mediavision Pro Movie Studio driver 0.03\n");
1100
1101 #ifndef MODULE
1102 if (!enable) {
1103 v4l2_err(v4l2_dev,
1104 "PMS: not enabled, use pms.enable=1 to probe\n");
1105 return -ENODEV;
1106 }
1107 #endif
1108
1109 dev->decoder = PHILIPS2;
1110 dev->io = io_port;
1111 dev->data = io_port + 1;
1112
1113 if (init_mediavision(dev)) {
1114 v4l2_err(v4l2_dev, "Board not found.\n");
1115 return -ENODEV;
1116 }
1117
1118 res = v4l2_device_register(NULL, v4l2_dev);
1119 if (res < 0) {
1120 v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
1121 return res;
1122 }
1123
1124 strlcpy(dev->vdev.name, v4l2_dev->name, sizeof(dev->vdev.name));
1125 dev->vdev.v4l2_dev = v4l2_dev;
1126 dev->vdev.fops = &pms_fops;
1127 dev->vdev.ioctl_ops = &pms_ioctl_ops;
1128 dev->vdev.release = video_device_release_empty;
1129 video_set_drvdata(&dev->vdev, dev);
1130 mutex_init(&dev->lock);
1131 dev->std = V4L2_STD_NTSC_M;
1132 dev->height = 240;
1133 dev->width = 320;
1134 dev->depth = 15;
1135 dev->brightness = 139;
1136 dev->contrast = 70;
1137 dev->hue = 0;
1138 dev->saturation = 64;
1139 pms_swsense(dev, 75);
1140 pms_resolution(dev, 320, 240);
1141 pms_videosource(dev, 0);
1142 pms_vcrinput(dev, 0);
1143 if (video_register_device(&dev->vdev, VFL_TYPE_GRABBER, video_nr) < 0) {
1144 v4l2_device_unregister(&dev->v4l2_dev);
1145 release_region(dev->io, 3);
1146 release_region(0x9a01, 1);
1147 iounmap(dev->mem);
1148 return -EINVAL;
1149 }
1150 return 0;
1151 }
1152
1153 static void __exit pms_exit(void)
1154 {
1155 struct pms *dev = &pms_card;
1156
1157 video_unregister_device(&dev->vdev);
1158 release_region(dev->io, 3);
1159 release_region(0x9a01, 1);
1160 iounmap(dev->mem);
1161 }
1162
1163 module_init(pms_init);
1164 module_exit(pms_exit);
Linux with added FPC-III support