2 * Media Vision Pro Movie Studio
4 * "all you need is an I2C bus some RAM and a prayer"
6 * This draws heavily on code
8 * (c) Wolfgang Koehler, wolf@first.gmd.de, Dec. 1994
10 * 14478 Potsdam, Germany
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...
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
23 #include <linux/module.h>
24 #include <linux/delay.h>
25 #include <linux/errno.h>
27 #include <linux/kernel.h>
29 #include <linux/ioport.h>
30 #include <linux/init.h>
31 #include <linux/mutex.h>
32 #include <linux/uaccess.h>
33 #include <linux/isa.h>
36 #include <linux/videodev2.h>
37 #include <media/v4l2-common.h>
38 #include <media/v4l2-ioctl.h>
39 #include <media/v4l2-ctrls.h>
40 #include <media/v4l2-fh.h>
41 #include <media/v4l2-event.h>
42 #include <media/v4l2-device.h>
44 MODULE_LICENSE("GPL");
45 MODULE_VERSION("0.0.5");
48 #define PHILIPS2 2 /* SAA7191 */
50 #define MVVMEMORYWIDTH 0x40 /* 512 bytes */
60 struct v4l2_device v4l2_dev
;
61 struct video_device vdev
;
62 struct v4l2_ctrl_handler hdl
;
69 struct i2c_info i2cinfo
[64];
72 int standard
; /* 0 - auto 1 - ntsc 2 - pal 3 - secam */
80 * I/O ports and Shared Memory
83 static int io_port
= 0x250;
84 module_param(io_port
, int, 0);
86 static int mem_base
= 0xc8000;
87 module_param(mem_base
, int, 0);
89 static int video_nr
= -1;
90 module_param(video_nr
, int, 0);
93 static inline void mvv_write(struct pms
*dev
, u8 index
, u8 value
)
95 outw(index
| (value
<< 8), dev
->io
);
98 static inline u8
mvv_read(struct pms
*dev
, u8 index
)
100 outb(index
, dev
->io
);
101 return inb(dev
->data
);
104 static int pms_i2c_stat(struct pms
*dev
, u8 slave
)
111 while ((inb(dev
->data
) & 0x01) == 0)
112 if (counter
++ == 256)
115 while ((inb(dev
->data
) & 0x01) != 0)
116 if (counter
++ == 256)
119 outb(slave
, dev
->io
);
122 while ((inb(dev
->data
) & 0x01) == 0)
123 if (counter
++ == 256)
126 while ((inb(dev
->data
) & 0x01) != 0)
127 if (counter
++ == 256)
130 for (i
= 0; i
< 12; i
++) {
131 char st
= inb(dev
->data
);
139 return inb(dev
->data
);
142 static int pms_i2c_write(struct pms
*dev
, u16 slave
, u16 sub
, u16 data
)
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
)
153 dev
->i2cinfo
[i
].data
= data
;
154 i
= dev
->i2c_count
+ 1;
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
;
168 mvv_write(dev
, 0x29, sub
);
169 mvv_write(dev
, 0x2A, data
);
170 mvv_write(dev
, 0x28, slave
);
175 while ((inb(dev
->data
) & 1) == 0)
178 while ((inb(dev
->data
) & 1) != 0)
182 count
= inb(dev
->data
);
189 static int pms_i2c_read(struct pms
*dev
, int slave
, int sub
)
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
;
201 static void pms_i2c_andor(struct pms
*dev
, int slave
, int sub
, int and, int or)
205 tmp
= pms_i2c_read(dev
, slave
, sub
);
206 tmp
= (tmp
& and) | or;
207 pms_i2c_write(dev
, slave
, sub
, tmp
);
215 static void pms_videosource(struct pms
*dev
, short source
)
217 switch (dev
->decoder
) {
221 pms_i2c_andor(dev
, 0x8a, 0x06, 0x7f, source
? 0x80 : 0);
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
232 static void pms_hue(struct pms
*dev
, short hue
)
234 switch (dev
->decoder
) {
236 pms_i2c_write(dev
, 0x8a, 0x00, hue
);
239 pms_i2c_write(dev
, 0x8a, 0x07, hue
);
242 pms_i2c_write(dev
, 0x42, 0x07, hue
);
247 static void pms_saturation(struct pms
*dev
, short sat
)
249 switch (dev
->decoder
) {
251 pms_i2c_write(dev
, 0x8a, 0x00, sat
);
254 pms_i2c_write(dev
, 0x42, 0x12, sat
);
260 static void pms_contrast(struct pms
*dev
, short contrast
)
262 switch (dev
->decoder
) {
264 pms_i2c_write(dev
, 0x8a, 0x00, contrast
);
267 pms_i2c_write(dev
, 0x42, 0x13, contrast
);
272 static void pms_brightness(struct pms
*dev
, short brightness
)
274 switch (dev
->decoder
) {
276 pms_i2c_write(dev
, 0x8a, 0x00, brightness
);
277 pms_i2c_write(dev
, 0x8a, 0x00, brightness
);
278 pms_i2c_write(dev
, 0x8a, 0x00, brightness
);
281 pms_i2c_write(dev
, 0x42, 0x19, brightness
);
287 static void pms_format(struct pms
*dev
, short format
)
291 dev
->standard
= format
;
293 if (dev
->decoder
== PHILIPS1
)
295 else if (dev
->decoder
== PHILIPS2
)
302 pms_i2c_andor(dev
, target
, 0x0d, 0xfe, 0x00);
303 pms_i2c_andor(dev
, target
, 0x0f, 0x3f, 0x80);
306 pms_i2c_andor(dev
, target
, 0x0d, 0xfe, 0x00);
307 pms_i2c_andor(dev
, target
, 0x0f, 0x3f, 0x40);
310 pms_i2c_andor(dev
, target
, 0x0d, 0xfe, 0x00);
311 pms_i2c_andor(dev
, target
, 0x0f, 0x3f, 0x00);
314 pms_i2c_andor(dev
, target
, 0x0d, 0xfe, 0x01);
315 pms_i2c_andor(dev
, target
, 0x0f, 0x3f, 0x00);
320 #ifdef FOR_FUTURE_EXPANSION
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.
328 static void pms_hstart(struct pms
*dev
, short start
)
330 switch (dev
->decoder
) {
332 pms_i2c_write(dev
, 0x8a, 0x05, start
);
333 pms_i2c_write(dev
, 0x8a, 0x18, start
);
336 pms_i2c_write(dev
, 0x42, 0x05, start
);
337 pms_i2c_write(dev
, 0x42, 0x18, start
);
346 static void pms_bandpass(struct pms
*dev
, short pass
)
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);
354 static void pms_antisnow(struct pms
*dev
, short snow
)
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);
362 static void pms_sharpness(struct pms
*dev
, short sharp
)
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);
370 static void pms_chromaagc(struct pms
*dev
, short agc
)
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);
378 static void pms_vertnoise(struct pms
*dev
, short noise
)
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);
386 static void pms_forcecolour(struct pms
*dev
, short colour
)
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);
394 static void pms_antigamma(struct pms
*dev
, short gamma
)
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);
402 static void pms_prefilter(struct pms
*dev
, short filter
)
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);
410 static void pms_hfilter(struct pms
*dev
, short filter
)
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);
418 static void pms_vfilter(struct pms
*dev
, short filter
)
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);
426 static void pms_killcolour(struct pms
*dev
, short colour
)
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);
437 static void pms_chromagain(struct pms
*dev
, short chroma
)
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
);
446 static void pms_spacialcompl(struct pms
*dev
, short data
)
448 mvv_write(dev
, 0x3b, data
);
451 static void pms_spacialcomph(struct pms
*dev
, short data
)
453 mvv_write(dev
, 0x3a, data
);
456 static void pms_vstart(struct pms
*dev
, short start
)
458 mvv_write(dev
, 0x16, start
);
459 mvv_write(dev
, 0x17, (start
>> 8) & 0x01);
464 static void pms_secamcross(struct pms
*dev
, short cross
)
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);
473 static void pms_swsense(struct pms
*dev
, short sense
)
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
);
485 static void pms_framerate(struct pms
*dev
, short frr
)
487 int fps
= (dev
->std
& V4L2_STD_525_60
) ? 30 : 25;
492 mvv_write(dev
, 0x14, 0x80 | fps
);
493 mvv_write(dev
, 0x15, 1);
496 static void pms_vert(struct pms
*dev
, u8 deciden
, u8 decinum
)
498 mvv_write(dev
, 0x1c, deciden
); /* Denominator */
499 mvv_write(dev
, 0x1d, decinum
); /* Numerator */
503 * Turn 16bit ratios into best small ratio the chipset can grok
506 static void pms_vertdeci(struct pms
*dev
, unsigned short decinum
, unsigned short deciden
)
508 /* Knock it down by / 5 once */
509 if (decinum
% 5 == 0) {
516 while (decinum
% 3 == 0 && deciden
% 3 == 0) {
523 while (decinum
% 2 == 0 && deciden
% 2 == 0) {
530 while (deciden
> 32) {
532 decinum
= (decinum
+ 1) / 2;
536 pms_vert(dev
, deciden
, decinum
);
539 static void pms_horzdeci(struct pms
*dev
, short decinum
, short deciden
)
541 if (decinum
<= 512) {
542 if (decinum
% 5 == 0) {
548 deciden
= 640; /* 768 would be ideal */
551 while (((decinum
| deciden
) & 1) == 0) {
555 while (deciden
> 32) {
557 decinum
= (decinum
+ 1) >> 1;
562 mvv_write(dev
, 0x24, 0x80 | deciden
);
563 mvv_write(dev
, 0x25, decinum
);
566 static void pms_resolution(struct pms
*dev
, short width
, short height
)
574 mvv_write(dev
, 0x18, fg_height
);
575 mvv_write(dev
, 0x19, fg_height
>> 8);
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);
583 pms_vertdeci(dev
, fg_height
, 240);
585 mvv_write(dev
, 0x1a, 0x1a);
586 mvv_write(dev
, 0x1b, 0x01);
588 pms_vertdeci(dev
, 270, 270);
590 pms_vertdeci(dev
, fg_height
, 270);
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
);
598 mvv_write(dev
, 0x22, width
+ 8);
599 mvv_write(dev
, 0x23, (width
+ 8) >> 8);
601 if (dev
->std
& V4L2_STD_525_60
)
602 pms_horzdeci(dev
, width
, 640);
604 pms_horzdeci(dev
, width
+ 8, 768);
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
);
618 static void pms_vcrinput(struct pms
*dev
, short input
)
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);
627 static int pms_capture(struct pms
*dev
, char __user
*buf
, int rgb555
, int count
)
630 int dw
= 2 * dev
->width
;
631 char tmp
[dw
+ 32]; /* using a temp buffer is faster than direct */
634 unsigned char r8
= 0x5; /* value for reg8 */
637 r8
|= 0x20; /* else use untranslated rgb = 565 */
638 mvv_write(dev
, 0x08, r8
); /* capture rgb555/565, init DRAM, PC enable */
640 /* printf("%d %d %d %d %d %x %x\n",width,height,voff,nom,den,mvv_buf); */
642 for (y
= 0; y
< dev
->height
; y
++) {
643 writeb(0, dev
->mem
); /* synchronisiert neue Zeile */
646 * This is in truth a fifo, be very careful as if you
647 * forgot this odd things will occur 8)
650 memcpy_fromio(tmp
, dev
->mem
, dw
+ 32); /* discard 16 word */
657 if (dt
+ len
> count
)
660 if (copy_to_user(buf
, tmp
+ 32, dt
))
661 return len
? len
: -EFAULT
;
671 * Video4linux interfacing
674 static int pms_querycap(struct file
*file
, void *priv
,
675 struct v4l2_capability
*vcap
)
677 struct pms
*dev
= video_drvdata(file
);
679 strlcpy(vcap
->driver
, dev
->v4l2_dev
.name
, sizeof(vcap
->driver
));
680 strlcpy(vcap
->card
, "Mediavision PMS", sizeof(vcap
->card
));
681 snprintf(vcap
->bus_info
, sizeof(vcap
->bus_info
),
682 "ISA:%s", dev
->v4l2_dev
.name
);
683 vcap
->device_caps
= V4L2_CAP_VIDEO_CAPTURE
| V4L2_CAP_READWRITE
;
684 vcap
->capabilities
= vcap
->device_caps
| V4L2_CAP_DEVICE_CAPS
;
688 static int pms_enum_input(struct file
*file
, void *fh
, struct v4l2_input
*vin
)
690 static const char *inputs
[4] = {
699 strlcpy(vin
->name
, inputs
[vin
->index
], sizeof(vin
->name
));
700 vin
->type
= V4L2_INPUT_TYPE_CAMERA
;
703 vin
->std
= V4L2_STD_ALL
;
708 static int pms_g_input(struct file
*file
, void *fh
, unsigned int *inp
)
710 struct pms
*dev
= video_drvdata(file
);
716 static int pms_s_input(struct file
*file
, void *fh
, unsigned int inp
)
718 struct pms
*dev
= video_drvdata(file
);
724 pms_videosource(dev
, inp
& 1);
725 pms_vcrinput(dev
, inp
>> 1);
729 static int pms_g_std(struct file
*file
, void *fh
, v4l2_std_id
*std
)
731 struct pms
*dev
= video_drvdata(file
);
737 static int pms_s_std(struct file
*file
, void *fh
, v4l2_std_id
*std
)
739 struct pms
*dev
= video_drvdata(file
);
743 if (dev
->std
& V4L2_STD_NTSC
) {
744 pms_framerate(dev
, 30);
745 pms_secamcross(dev
, 0);
747 } else if (dev
->std
& V4L2_STD_PAL
) {
748 pms_framerate(dev
, 25);
749 pms_secamcross(dev
, 0);
751 } else if (dev
->std
& V4L2_STD_SECAM
) {
752 pms_framerate(dev
, 25);
753 pms_secamcross(dev
, 1);
760 case VIDEO_MODE_AUTO:
761 pms_framerate(dev, 25);
762 pms_secamcross(dev, 0);
769 static int pms_s_ctrl(struct v4l2_ctrl
*ctrl
)
771 struct pms
*dev
= container_of(ctrl
->handler
, struct pms
, hdl
);
775 case V4L2_CID_BRIGHTNESS
:
776 pms_brightness(dev
, ctrl
->val
);
778 case V4L2_CID_CONTRAST
:
779 pms_contrast(dev
, ctrl
->val
);
781 case V4L2_CID_SATURATION
:
782 pms_saturation(dev
, ctrl
->val
);
785 pms_hue(dev
, ctrl
->val
);
794 static int pms_g_fmt_vid_cap(struct file
*file
, void *fh
, struct v4l2_format
*fmt
)
796 struct pms
*dev
= video_drvdata(file
);
797 struct v4l2_pix_format
*pix
= &fmt
->fmt
.pix
;
799 pix
->width
= dev
->width
;
800 pix
->height
= dev
->height
;
801 pix
->pixelformat
= dev
->width
== 15 ?
802 V4L2_PIX_FMT_RGB555
: V4L2_PIX_FMT_RGB565
;
803 pix
->field
= V4L2_FIELD_NONE
;
804 pix
->bytesperline
= 2 * dev
->width
;
805 pix
->sizeimage
= 2 * dev
->width
* dev
->height
;
807 pix
->colorspace
= V4L2_COLORSPACE_SRGB
;
811 static int pms_try_fmt_vid_cap(struct file
*file
, void *fh
, struct v4l2_format
*fmt
)
813 struct v4l2_pix_format
*pix
= &fmt
->fmt
.pix
;
815 if (pix
->height
< 16 || pix
->height
> 480)
817 if (pix
->width
< 16 || pix
->width
> 640)
819 if (pix
->pixelformat
!= V4L2_PIX_FMT_RGB555
&&
820 pix
->pixelformat
!= V4L2_PIX_FMT_RGB565
)
822 pix
->field
= V4L2_FIELD_NONE
;
823 pix
->bytesperline
= 2 * pix
->width
;
824 pix
->sizeimage
= 2 * pix
->width
* pix
->height
;
826 pix
->colorspace
= V4L2_COLORSPACE_SRGB
;
830 static int pms_s_fmt_vid_cap(struct file
*file
, void *fh
, struct v4l2_format
*fmt
)
832 struct pms
*dev
= video_drvdata(file
);
833 struct v4l2_pix_format
*pix
= &fmt
->fmt
.pix
;
834 int ret
= pms_try_fmt_vid_cap(file
, fh
, fmt
);
838 dev
->width
= pix
->width
;
839 dev
->height
= pix
->height
;
840 dev
->depth
= (pix
->pixelformat
== V4L2_PIX_FMT_RGB555
) ? 15 : 16;
841 pms_resolution(dev
, dev
->width
, dev
->height
);
842 /* Ok we figured out what to use from our wide choice */
846 static int pms_enum_fmt_vid_cap(struct file
*file
, void *fh
, struct v4l2_fmtdesc
*fmt
)
848 static struct v4l2_fmtdesc formats
[] = {
850 "RGB 5:5:5", V4L2_PIX_FMT_RGB555
,
854 "RGB 5:6:5", V4L2_PIX_FMT_RGB565
,
858 enum v4l2_buf_type type
= fmt
->type
;
863 *fmt
= formats
[fmt
->index
];
868 static ssize_t
pms_read(struct file
*file
, char __user
*buf
,
869 size_t count
, loff_t
*ppos
)
871 struct pms
*dev
= video_drvdata(file
);
874 len
= pms_capture(dev
, buf
, (dev
->depth
== 15), count
);
878 static unsigned int pms_poll(struct file
*file
, struct poll_table_struct
*wait
)
880 struct v4l2_fh
*fh
= file
->private_data
;
881 unsigned int res
= POLLIN
| POLLRDNORM
;
883 if (v4l2_event_pending(fh
))
885 poll_wait(file
, &fh
->wait
, wait
);
889 static const struct v4l2_file_operations pms_fops
= {
890 .owner
= THIS_MODULE
,
891 .open
= v4l2_fh_open
,
892 .release
= v4l2_fh_release
,
894 .unlocked_ioctl
= video_ioctl2
,
898 static const struct v4l2_ioctl_ops pms_ioctl_ops
= {
899 .vidioc_querycap
= pms_querycap
,
900 .vidioc_g_input
= pms_g_input
,
901 .vidioc_s_input
= pms_s_input
,
902 .vidioc_enum_input
= pms_enum_input
,
903 .vidioc_g_std
= pms_g_std
,
904 .vidioc_s_std
= pms_s_std
,
905 .vidioc_enum_fmt_vid_cap
= pms_enum_fmt_vid_cap
,
906 .vidioc_g_fmt_vid_cap
= pms_g_fmt_vid_cap
,
907 .vidioc_s_fmt_vid_cap
= pms_s_fmt_vid_cap
,
908 .vidioc_try_fmt_vid_cap
= pms_try_fmt_vid_cap
,
909 .vidioc_subscribe_event
= v4l2_ctrl_subscribe_event
,
910 .vidioc_unsubscribe_event
= v4l2_event_unsubscribe
,
914 * Probe for and initialise the Mediavision PMS
917 static int init_mediavision(struct pms
*dev
)
921 static const unsigned char i2c_defs
[] = {
922 0x4c, 0x30, 0x00, 0xe8,
923 0xb6, 0xe2, 0x00, 0x00,
924 0xff, 0xff, 0x00, 0x00,
925 0x00, 0x00, 0x78, 0x98,
926 0x00, 0x00, 0x00, 0x00,
927 0x34, 0x0a, 0xf4, 0xce,
931 dev
->mem
= ioremap(mem_base
, 0x800);
935 if (!request_region(0x9a01, 1, "Mediavision PMS config")) {
936 printk(KERN_WARNING
"mediavision: unable to detect: 0x9a01 in use.\n");
940 if (!request_region(dev
->io
, 3, "Mediavision PMS")) {
941 printk(KERN_WARNING
"mediavision: I/O port %d in use.\n", dev
->io
);
942 release_region(0x9a01, 1);
946 outb(0xb8, 0x9a01); /* Unlock */
947 outb(dev
->io
>> 4, 0x9a01); /* Set IO port */
950 decst
= pms_i2c_stat(dev
, 0x43);
954 else if (pms_i2c_stat(dev
, 0xb9) != -1)
956 else if (pms_i2c_stat(dev
, 0x8b) != -1)
961 printk(KERN_INFO
"PMS type is %d\n", idec
);
963 release_region(dev
->io
, 3);
964 release_region(0x9a01, 1);
970 * Ok we have a PMS of some sort
973 mvv_write(dev
, 0x04, mem_base
>> 12); /* Set the memory area */
975 /* Ok now load the defaults */
977 for (i
= 0; i
< 0x19; i
++) {
978 if (i2c_defs
[i
] == 0xff)
979 pms_i2c_andor(dev
, 0x8a, i
, 0x07, 0x00);
981 pms_i2c_write(dev
, 0x8a, i
, i2c_defs
[i
]);
984 pms_i2c_write(dev
, 0xb8, 0x00, 0x12);
985 pms_i2c_write(dev
, 0xb8, 0x04, 0x00);
986 pms_i2c_write(dev
, 0xb8, 0x07, 0x00);
987 pms_i2c_write(dev
, 0xb8, 0x08, 0x00);
988 pms_i2c_write(dev
, 0xb8, 0x09, 0xff);
989 pms_i2c_write(dev
, 0xb8, 0x0a, 0x00);
990 pms_i2c_write(dev
, 0xb8, 0x0b, 0x10);
991 pms_i2c_write(dev
, 0xb8, 0x10, 0x03);
993 mvv_write(dev
, 0x01, 0x00);
994 mvv_write(dev
, 0x05, 0xa0);
995 mvv_write(dev
, 0x08, 0x25);
996 mvv_write(dev
, 0x09, 0x00);
997 mvv_write(dev
, 0x0a, 0x20 | MVVMEMORYWIDTH
);
999 mvv_write(dev
, 0x10, 0x02);
1000 mvv_write(dev
, 0x1e, 0x0c);
1001 mvv_write(dev
, 0x1f, 0x03);
1002 mvv_write(dev
, 0x26, 0x06);
1004 mvv_write(dev
, 0x2b, 0x00);
1005 mvv_write(dev
, 0x2c, 0x20);
1006 mvv_write(dev
, 0x2d, 0x00);
1007 mvv_write(dev
, 0x2f, 0x70);
1008 mvv_write(dev
, 0x32, 0x00);
1009 mvv_write(dev
, 0x33, MVVMEMORYWIDTH
);
1010 mvv_write(dev
, 0x34, 0x00);
1011 mvv_write(dev
, 0x35, 0x00);
1012 mvv_write(dev
, 0x3a, 0x80);
1013 mvv_write(dev
, 0x3b, 0x10);
1014 mvv_write(dev
, 0x20, 0x00);
1015 mvv_write(dev
, 0x21, 0x00);
1016 mvv_write(dev
, 0x30, 0x22);
1021 * Initialization and module stuff
1026 module_param(enable
, int, 0);
1029 static const struct v4l2_ctrl_ops pms_ctrl_ops
= {
1030 .s_ctrl
= pms_s_ctrl
,
1033 static int pms_probe(struct device
*pdev
, unsigned int card
)
1036 struct v4l2_device
*v4l2_dev
;
1037 struct v4l2_ctrl_handler
*hdl
;
1042 pr_err("PMS: not enabled, use pms.enable=1 to probe\n");
1047 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
1051 dev
->decoder
= PHILIPS2
;
1053 dev
->data
= io_port
+ 1;
1054 v4l2_dev
= &dev
->v4l2_dev
;
1057 res
= v4l2_device_register(pdev
, v4l2_dev
);
1059 v4l2_err(v4l2_dev
, "Could not register v4l2_device\n");
1062 v4l2_info(v4l2_dev
, "Mediavision Pro Movie Studio driver 0.05\n");
1064 res
= init_mediavision(dev
);
1066 v4l2_err(v4l2_dev
, "Board not found.\n");
1070 v4l2_ctrl_handler_init(hdl
, 4);
1071 v4l2_ctrl_new_std(hdl
, &pms_ctrl_ops
,
1072 V4L2_CID_BRIGHTNESS
, 0, 255, 1, 139);
1073 v4l2_ctrl_new_std(hdl
, &pms_ctrl_ops
,
1074 V4L2_CID_CONTRAST
, 0, 255, 1, 70);
1075 v4l2_ctrl_new_std(hdl
, &pms_ctrl_ops
,
1076 V4L2_CID_SATURATION
, 0, 255, 1, 64);
1077 v4l2_ctrl_new_std(hdl
, &pms_ctrl_ops
,
1078 V4L2_CID_HUE
, 0, 255, 1, 0);
1084 mutex_init(&dev
->lock
);
1085 strlcpy(dev
->vdev
.name
, v4l2_dev
->name
, sizeof(dev
->vdev
.name
));
1086 dev
->vdev
.v4l2_dev
= v4l2_dev
;
1087 dev
->vdev
.ctrl_handler
= hdl
;
1088 dev
->vdev
.fops
= &pms_fops
;
1089 dev
->vdev
.ioctl_ops
= &pms_ioctl_ops
;
1090 dev
->vdev
.release
= video_device_release_empty
;
1091 dev
->vdev
.lock
= &dev
->lock
;
1092 dev
->vdev
.tvnorms
= V4L2_STD_NTSC
| V4L2_STD_PAL
| V4L2_STD_SECAM
;
1093 set_bit(V4L2_FL_USE_FH_PRIO
, &dev
->vdev
.flags
);
1094 video_set_drvdata(&dev
->vdev
, dev
);
1095 dev
->std
= V4L2_STD_NTSC_M
;
1099 pms_swsense(dev
, 75);
1100 pms_resolution(dev
, 320, 240);
1101 pms_videosource(dev
, 0);
1102 pms_vcrinput(dev
, 0);
1103 v4l2_ctrl_handler_setup(hdl
);
1104 res
= video_register_device(&dev
->vdev
, VFL_TYPE_GRABBER
, video_nr
);
1109 v4l2_ctrl_handler_free(hdl
);
1110 v4l2_device_unregister(&dev
->v4l2_dev
);
1112 release_region(dev
->io
, 3);
1113 release_region(0x9a01, 1);
1120 static int pms_remove(struct device
*pdev
, unsigned int card
)
1122 struct pms
*dev
= dev_get_drvdata(pdev
);
1124 video_unregister_device(&dev
->vdev
);
1125 v4l2_ctrl_handler_free(&dev
->hdl
);
1126 release_region(dev
->io
, 3);
1127 release_region(0x9a01, 1);
1132 static struct isa_driver pms_driver
= {
1134 .remove
= pms_remove
,
1140 static int __init
pms_init(void)
1142 return isa_register_driver(&pms_driver
, 1);
1145 static void __exit
pms_exit(void)
1147 isa_unregister_driver(&pms_driver
);
1150 module_init(pms_init
);
1151 module_exit(pms_exit
);