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