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