blob: 73ec970ca5ca0a53c34f6ad933f021570a2d5b55 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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.
Alan Coxd9b01442008-10-27 15:13:47 -030013 * His driver works so send any reports to alan@lxorguk.ukuu.org.uk
14 * unless the userspace driver also doesn't work for you...
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -030015 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070016 * Changes:
Hans Verkuilfeba2f82009-11-25 12:47:02 -030017 * 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070021 */
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>
Hans Verkuilfeba2f82009-11-25 12:47:02 -030032#include <linux/version.h>
33#include <linux/mutex.h>
34#include <asm/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <asm/io.h>
Hans Verkuilfeba2f82009-11-25 12:47:02 -030036
37#include <linux/videodev2.h>
Mauro Carvalho Chehab5e87efa2006-06-05 10:26:32 -030038#include <media/v4l2-common.h>
Hans Verkuil35ea11f2008-07-20 08:12:02 -030039#include <media/v4l2-ioctl.h>
Hans Verkuil1ce79812009-11-25 12:37:00 -030040#include <media/v4l2-device.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
Hans Verkuil1ce79812009-11-25 12:37:00 -030042MODULE_LICENSE("GPL");
43
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
45#define MOTOROLA 1
Hans Verkuilfeba2f82009-11-25 12:47:02 -030046#define PHILIPS2 2 /* SAA7191 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070047#define PHILIPS1 3
48#define MVVMEMORYWIDTH 0x40 /* 512 bytes */
49
Hans Verkuil1ce79812009-11-25 12:37:00 -030050struct i2c_info {
Linus Torvalds1da177e2005-04-16 15:20:36 -070051 u8 slave;
52 u8 sub;
53 u8 data;
54 u8 hits;
55};
56
Hans Verkuil1ce79812009-11-25 12:37:00 -030057struct pms {
58 struct v4l2_device v4l2_dev;
59 struct video_device vdev;
Hans Verkuil1ce79812009-11-25 12:37:00 -030060 int height;
61 int width;
Hans Verkuilfeba2f82009-11-25 12:47:02 -030062 int depth;
63 int input;
64 s32 brightness, saturation, hue, contrast;
Hans Verkuil1ce79812009-11-25 12:37:00 -030065 unsigned long in_use;
66 struct mutex lock;
67 int i2c_count;
68 struct i2c_info i2cinfo[64];
Linus Torvalds1da177e2005-04-16 15:20:36 -070069
Hans Verkuil1ce79812009-11-25 12:37:00 -030070 int decoder;
71 int standard; /* 0 - auto 1 - ntsc 2 - pal 3 - secam */
Hans Verkuilfeba2f82009-11-25 12:47:02 -030072 v4l2_std_id std;
Hans Verkuil1ce79812009-11-25 12:37:00 -030073 int io;
74 int data;
75 void __iomem *mem;
76};
77
78static struct pms pms_card;
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
80/*
81 * I/O ports and Shared Memory
82 */
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -030083
Hans Verkuil1ce79812009-11-25 12:37:00 -030084static int io_port = 0x250;
85module_param(io_port, int, 0);
86
87static int mem_base = 0xc8000;
88module_param(mem_base, int, 0);
89
90static int video_nr = -1;
91module_param(video_nr, int, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -070092
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -030093
Hans Verkuil1ce79812009-11-25 12:37:00 -030094static inline void mvv_write(struct pms *dev, u8 index, u8 value)
Linus Torvalds1da177e2005-04-16 15:20:36 -070095{
Hans Verkuil1ce79812009-11-25 12:37:00 -030096 outw(index | (value << 8), dev->io);
Linus Torvalds1da177e2005-04-16 15:20:36 -070097}
98
Hans Verkuil1ce79812009-11-25 12:37:00 -030099static inline u8 mvv_read(struct pms *dev, u8 index)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300101 outb(index, dev->io);
102 return inb(dev->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103}
104
Hans Verkuil1ce79812009-11-25 12:37:00 -0300105static int pms_i2c_stat(struct pms *dev, u8 slave)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300107 int counter = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 int i;
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300109
Hans Verkuil1ce79812009-11-25 12:37:00 -0300110 outb(0x28, dev->io);
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300111
Hans Verkuil1ce79812009-11-25 12:37:00 -0300112 while ((inb(dev->data) & 0x01) == 0)
113 if (counter++ == 256)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 break;
115
Hans Verkuil1ce79812009-11-25 12:37:00 -0300116 while ((inb(dev->data) & 0x01) != 0)
117 if (counter++ == 256)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118 break;
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300119
Hans Verkuil1ce79812009-11-25 12:37:00 -0300120 outb(slave, dev->io);
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300121
Hans Verkuil1ce79812009-11-25 12:37:00 -0300122 counter = 0;
123 while ((inb(dev->data) & 0x01) == 0)
124 if (counter++ == 256)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 break;
126
Hans Verkuil1ce79812009-11-25 12:37:00 -0300127 while ((inb(dev->data) & 0x01) != 0)
128 if (counter++ == 256)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 break;
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300130
Hans Verkuil1ce79812009-11-25 12:37:00 -0300131 for (i = 0; i < 12; i++) {
132 char st = inb(dev->data);
133
134 if ((st & 2) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 return -1;
Hans Verkuil1ce79812009-11-25 12:37:00 -0300136 if ((st & 1) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 break;
138 }
Hans Verkuil1ce79812009-11-25 12:37:00 -0300139 outb(0x29, dev->io);
140 return inb(dev->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141}
142
Hans Verkuil1ce79812009-11-25 12:37:00 -0300143static int pms_i2c_write(struct pms *dev, u16 slave, u16 sub, u16 data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300145 int skip = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 int count;
147 int i;
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300148
Hans Verkuil1ce79812009-11-25 12:37:00 -0300149 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 }
157 }
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300158
Hans Verkuil1ce79812009-11-25 12:37:00 -0300159 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++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 }
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300165
Hans Verkuil1ce79812009-11-25 12:37:00 -0300166 if (skip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 return 0;
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300168
Hans Verkuil1ce79812009-11-25 12:37:00 -0300169 mvv_write(dev, 0x29, sub);
170 mvv_write(dev, 0x2A, data);
171 mvv_write(dev, 0x28, slave);
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300172
Hans Verkuil1ce79812009-11-25 12:37:00 -0300173 outb(0x28, dev->io);
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300174
Hans Verkuil1ce79812009-11-25 12:37:00 -0300175 count = 0;
176 while ((inb(dev->data) & 1) == 0)
177 if (count > 255)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 break;
Hans Verkuil1ce79812009-11-25 12:37:00 -0300179 while ((inb(dev->data) & 1) != 0)
180 if (count > 255)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 break;
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300182
Hans Verkuil1ce79812009-11-25 12:37:00 -0300183 count = inb(dev->data);
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300184
Hans Verkuil1ce79812009-11-25 12:37:00 -0300185 if (count & 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 return -1;
187 return count;
188}
189
Hans Verkuil1ce79812009-11-25 12:37:00 -0300190static int pms_i2c_read(struct pms *dev, int slave, int sub)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300192 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 }
198 return 0;
199}
200
201
Hans Verkuil1ce79812009-11-25 12:37:00 -0300202static void pms_i2c_andor(struct pms *dev, int slave, int sub, int and, int or)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203{
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300204 u8 tmp;
205
Hans Verkuil1ce79812009-11-25 12:37:00 -0300206 tmp = pms_i2c_read(dev, slave, sub);
207 tmp = (tmp & and) | or;
208 pms_i2c_write(dev, slave, sub, tmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209}
210
211/*
212 * Control functions
213 */
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300214
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215
Hans Verkuil1ce79812009-11-25 12:37:00 -0300216static void pms_videosource(struct pms *dev, short source)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217{
Hans Verkuilfeba2f82009-11-25 12:47:02 -0300218 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. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231}
232
Hans Verkuil1ce79812009-11-25 12:37:00 -0300233static void pms_hue(struct pms *dev, short hue)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300235 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 }
246}
247
Hans Verkuilfeba2f82009-11-25 12:47:02 -0300248static void pms_saturation(struct pms *dev, short sat)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300250 switch (dev->decoder) {
251 case MOTOROLA:
Hans Verkuilfeba2f82009-11-25 12:47:02 -0300252 pms_i2c_write(dev, 0x8a, 0x00, sat);
Hans Verkuil1ce79812009-11-25 12:37:00 -0300253 break;
254 case PHILIPS1:
Hans Verkuilfeba2f82009-11-25 12:47:02 -0300255 pms_i2c_write(dev, 0x42, 0x12, sat);
Hans Verkuil1ce79812009-11-25 12:37:00 -0300256 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 }
258}
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300259
260
Hans Verkuil1ce79812009-11-25 12:37:00 -0300261static void pms_contrast(struct pms *dev, short contrast)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300263 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 }
271}
272
Hans Verkuil1ce79812009-11-25 12:37:00 -0300273static void pms_brightness(struct pms *dev, short brightness)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300275 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 }
285}
286
287
Hans Verkuil1ce79812009-11-25 12:37:00 -0300288static void pms_format(struct pms *dev, short format)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289{
290 int target;
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300291
Hans Verkuil1ce79812009-11-25 12:37:00 -0300292 dev->standard = format;
293
294 if (dev->decoder == PHILIPS1)
295 target = 0x42;
296 else if (dev->decoder == PHILIPS2)
297 target = 0x8a;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 else
299 return;
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300300
Hans Verkuil1ce79812009-11-25 12:37:00 -0300301 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 }
319}
320
321#ifdef FOR_FUTURE_EXPANSION
322
323/*
324 * These features of the PMS card are not currently exposes. They
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300325 * could become a private v4l ioctl for PMSCONFIG or somesuch if
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 * people need it. We also don't yet use the PMS interrupt.
327 */
328
Hans Verkuil1ce79812009-11-25 12:37:00 -0300329static void pms_hstart(struct pms *dev, short start)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300331 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 }
341}
342
343/*
344 * Bandpass filters
345 */
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300346
Hans Verkuil1ce79812009-11-25 12:37:00 -0300347static void pms_bandpass(struct pms *dev, short pass)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300349 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353}
354
Hans Verkuil1ce79812009-11-25 12:37:00 -0300355static void pms_antisnow(struct pms *dev, short snow)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300357 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361}
362
Hans Verkuil1ce79812009-11-25 12:37:00 -0300363static void pms_sharpness(struct pms *dev, short sharp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300365 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369}
370
Hans Verkuil1ce79812009-11-25 12:37:00 -0300371static void pms_chromaagc(struct pms *dev, short agc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300373 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377}
378
Hans Verkuil1ce79812009-11-25 12:37:00 -0300379static void pms_vertnoise(struct pms *dev, short noise)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300381 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385}
386
Hans Verkuil1ce79812009-11-25 12:37:00 -0300387static void pms_forcecolour(struct pms *dev, short colour)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300389 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393}
394
Hans Verkuil1ce79812009-11-25 12:37:00 -0300395static void pms_antigamma(struct pms *dev, short gamma)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300397 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401}
402
Hans Verkuil1ce79812009-11-25 12:37:00 -0300403static void pms_prefilter(struct pms *dev, short filter)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300405 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409}
410
Hans Verkuil1ce79812009-11-25 12:37:00 -0300411static void pms_hfilter(struct pms *dev, short filter)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300413 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417}
418
Hans Verkuil1ce79812009-11-25 12:37:00 -0300419static void pms_vfilter(struct pms *dev, short filter)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300421 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425}
426
Hans Verkuil1ce79812009-11-25 12:37:00 -0300427static void pms_killcolour(struct pms *dev, short colour)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300429 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 }
436}
437
Hans Verkuil1ce79812009-11-25 12:37:00 -0300438static void pms_chromagain(struct pms *dev, short chroma)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300440 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444}
445
446
Hans Verkuil1ce79812009-11-25 12:37:00 -0300447static void pms_spacialcompl(struct pms *dev, short data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300449 mvv_write(dev, 0x3b, data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450}
451
Hans Verkuil1ce79812009-11-25 12:37:00 -0300452static void pms_spacialcomph(struct pms *dev, short data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300454 mvv_write(dev, 0x3a, data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455}
456
Hans Verkuil1ce79812009-11-25 12:37:00 -0300457static void pms_vstart(struct pms *dev, short start)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300459 mvv_write(dev, 0x16, start);
460 mvv_write(dev, 0x17, (start >> 8) & 0x01);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461}
462
463#endif
464
Hans Verkuil1ce79812009-11-25 12:37:00 -0300465static void pms_secamcross(struct pms *dev, short cross)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300467 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471}
472
473
Hans Verkuil1ce79812009-11-25 12:37:00 -0300474static void pms_swsense(struct pms *dev, short sense)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300476 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 }
483}
484
485
Hans Verkuil1ce79812009-11-25 12:37:00 -0300486static void pms_framerate(struct pms *dev, short frr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487{
Hans Verkuilfeba2f82009-11-25 12:47:02 -0300488 int fps = (dev->std & V4L2_STD_525_60) ? 30 : 25;
Hans Verkuil1ce79812009-11-25 12:37:00 -0300489
490 if (frr == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 return;
Hans Verkuil1ce79812009-11-25 12:37:00 -0300492 fps = fps/frr;
493 mvv_write(dev, 0x14, 0x80 | fps);
494 mvv_write(dev, 0x15, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495}
496
Hans Verkuil1ce79812009-11-25 12:37:00 -0300497static void pms_vert(struct pms *dev, u8 deciden, u8 decinum)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300499 mvv_write(dev, 0x1c, deciden); /* Denominator */
500 mvv_write(dev, 0x1d, decinum); /* Numerator */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501}
502
503/*
504 * Turn 16bit ratios into best small ratio the chipset can grok
505 */
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300506
Hans Verkuil1ce79812009-11-25 12:37:00 -0300507static void pms_vertdeci(struct pms *dev, unsigned short decinum, unsigned short deciden)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300509 /* Knock it down by / 5 once */
510 if (decinum % 5 == 0) {
511 deciden /= 5;
512 decinum /= 5;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 }
514 /*
515 * 3's
516 */
Hans Verkuil1ce79812009-11-25 12:37:00 -0300517 while (decinum % 3 == 0 && deciden % 3 == 0) {
518 deciden /= 3;
519 decinum /= 3;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 }
521 /*
522 * 2's
523 */
Hans Verkuil1ce79812009-11-25 12:37:00 -0300524 while (decinum % 2 == 0 && deciden % 2 == 0) {
525 decinum /= 2;
526 deciden /= 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 }
528 /*
529 * Fudgyify
530 */
Hans Verkuil1ce79812009-11-25 12:37:00 -0300531 while (deciden > 32) {
532 deciden /= 2;
533 decinum = (decinum + 1) / 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 }
Hans Verkuil1ce79812009-11-25 12:37:00 -0300535 if (deciden == 32)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 deciden--;
Hans Verkuil1ce79812009-11-25 12:37:00 -0300537 pms_vert(dev, deciden, decinum);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538}
539
Hans Verkuil1ce79812009-11-25 12:37:00 -0300540static void pms_horzdeci(struct pms *dev, short decinum, short deciden)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300542 if (decinum <= 512) {
543 if (decinum % 5 == 0) {
544 decinum /= 5;
545 deciden /= 5;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 }
Hans Verkuil1ce79812009-11-25 12:37:00 -0300547 } else {
548 decinum = 512;
549 deciden = 640; /* 768 would be ideal */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 }
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300551
Hans Verkuil1ce79812009-11-25 12:37:00 -0300552 while (((decinum | deciden) & 1) == 0) {
553 decinum >>= 1;
554 deciden >>= 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 }
Hans Verkuil1ce79812009-11-25 12:37:00 -0300556 while (deciden > 32) {
557 deciden >>= 1;
558 decinum = (decinum + 1) >> 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 }
Hans Verkuil1ce79812009-11-25 12:37:00 -0300560 if (deciden == 32)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 deciden--;
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300562
Hans Verkuil1ce79812009-11-25 12:37:00 -0300563 mvv_write(dev, 0x24, 0x80 | deciden);
564 mvv_write(dev, 0x25, decinum);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565}
566
Hans Verkuil1ce79812009-11-25 12:37:00 -0300567static void pms_resolution(struct pms *dev, short width, short height)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568{
569 int fg_height;
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300570
Hans Verkuil1ce79812009-11-25 12:37:00 -0300571 fg_height = height;
572 if (fg_height > 280)
573 fg_height = 280;
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300574
Hans Verkuil1ce79812009-11-25 12:37:00 -0300575 mvv_write(dev, 0x18, fg_height);
576 mvv_write(dev, 0x19, fg_height >> 8);
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300577
Hans Verkuilfeba2f82009-11-25 12:47:02 -0300578 if (dev->std & V4L2_STD_525_60) {
Hans Verkuil1ce79812009-11-25 12:37:00 -0300579 mvv_write(dev, 0x1a, 0xfc);
580 mvv_write(dev, 0x1b, 0x00);
581 if (height > fg_height)
582 pms_vertdeci(dev, 240, 240);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 else
Hans Verkuil1ce79812009-11-25 12:37:00 -0300584 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 else
Hans Verkuil1ce79812009-11-25 12:37:00 -0300591 pms_vertdeci(dev, fg_height, 270);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 }
Hans Verkuil1ce79812009-11-25 12:37:00 -0300593 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);
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300598
Hans Verkuil1ce79812009-11-25 12:37:00 -0300599 mvv_write(dev, 0x22, width + 8);
600 mvv_write(dev, 0x23, (width + 8) >> 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601
Hans Verkuilfeba2f82009-11-25 12:47:02 -0300602 if (dev->std & V4L2_STD_525_60)
Hans Verkuil1ce79812009-11-25 12:37:00 -0300603 pms_horzdeci(dev, width, 640);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 else
Hans Verkuil1ce79812009-11-25 12:37:00 -0300605 pms_horzdeci(dev, width + 8, 768);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606
Hans Verkuil1ce79812009-11-25 12:37:00 -0300607 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612}
613
614
615/*
616 * Set Input
617 */
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300618
Hans Verkuil1ce79812009-11-25 12:37:00 -0300619static void pms_vcrinput(struct pms *dev, short input)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300621 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625}
626
627
Hans Verkuil1ce79812009-11-25 12:37:00 -0300628static int pms_capture(struct pms *dev, char __user *buf, int rgb555, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629{
630 int y;
Hans Verkuil1ce79812009-11-25 12:37:00 -0300631 int dw = 2 * dev->width;
632 char tmp[dw + 32]; /* using a temp buffer is faster than direct */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 int cnt = 0;
Hans Verkuil1ce79812009-11-25 12:37:00 -0300634 int len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 unsigned char r8 = 0x5; /* value for reg8 */
636
637 if (rgb555)
638 r8 |= 0x20; /* else use untranslated rgb = 565 */
Hans Verkuil1ce79812009-11-25 12:37:00 -0300639 mvv_write(dev, 0x08, r8); /* capture rgb555/565, init DRAM, PC enable */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640
641/* printf("%d %d %d %d %d %x %x\n",width,height,voff,nom,den,mvv_buf); */
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300642
Hans Verkuil1ce79812009-11-25 12:37:00 -0300643 for (y = 0; y < dev->height; y++) {
644 writeb(0, dev->mem); /* synchronisiert neue Zeile */
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300645
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 /*
647 * This is in truth a fifo, be very careful as if you
648 * forgot this odd things will occur 8)
649 */
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300650
Hans Verkuil1ce79812009-11-25 12:37:00 -0300651 memcpy_fromio(tmp, dev->mem, dw + 32); /* discard 16 word */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 cnt -= dev->height;
Hans Verkuil1ce79812009-11-25 12:37:00 -0300653 while (cnt <= 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 /*
655 * Don't copy too far
656 */
Hans Verkuil1ce79812009-11-25 12:37:00 -0300657 int dt = dw;
658 if (dt + len > count)
659 dt = count - len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 cnt += dev->height;
Hans Verkuil1ce79812009-11-25 12:37:00 -0300661 if (copy_to_user(buf, tmp + 32, dt))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 return len ? len : -EFAULT;
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300663 buf += dt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 len += dt;
665 }
666 }
667 return len;
668}
669
670
671/*
672 * Video4linux interfacing
673 */
674
Hans Verkuilfeba2f82009-11-25 12:47:02 -0300675static int pms_querycap(struct file *file, void *priv,
676 struct v4l2_capability *vcap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300678 struct pms *dev = video_drvdata(file);
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300679
Hans Verkuilfeba2f82009-11-25 12:47:02 -0300680 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 return 0;
686}
687
Hans Verkuilfeba2f82009-11-25 12:47:02 -0300688static int pms_enum_input(struct file *file, void *fh, struct v4l2_input *vin)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689{
Hans Verkuilfeba2f82009-11-25 12:47:02 -0300690 static const char *inputs[4] = {
691 "Composite",
692 "S-Video",
693 "Composite (VCR)",
694 "S-Video (VCR)"
695 };
696
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}
707
708static int pms_g_input(struct file *file, void *fh, unsigned int *inp)
709{
710 struct pms *dev = video_drvdata(file);
711
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;
760 }
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);
785 }
786 return -EINVAL;
787}
788
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;
811 }
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;
839 default:
840 ret = -EINVAL;
841 break;
842 }
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;
880 return 0;
881}
882
883static int pms_s_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
884{
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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921}
922
923static ssize_t pms_read(struct file *file, char __user *buf,
924 size_t count, loff_t *ppos)
925{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300926 struct pms *dev = video_drvdata(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 int len;
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300928
Hans Verkuil1ce79812009-11-25 12:37:00 -0300929 mutex_lock(&dev->lock);
Hans Verkuilfeba2f82009-11-25 12:47:02 -0300930 len = pms_capture(dev, buf, (dev->depth == 15), count);
Hans Verkuil1ce79812009-11-25 12:37:00 -0300931 mutex_unlock(&dev->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932 return len;
933}
934
Hans Verkuilbec43662008-12-30 06:58:20 -0300935static int pms_exclusive_open(struct file *file)
Hans Verkuil7d43cd52008-08-23 05:31:47 -0300936{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300937 struct pms *dev = video_drvdata(file);
Hans Verkuil7d43cd52008-08-23 05:31:47 -0300938
Hans Verkuil1ce79812009-11-25 12:37:00 -0300939 return test_and_set_bit(0, &dev->in_use) ? -EBUSY : 0;
Hans Verkuil7d43cd52008-08-23 05:31:47 -0300940}
941
Hans Verkuilbec43662008-12-30 06:58:20 -0300942static int pms_exclusive_release(struct file *file)
Hans Verkuil7d43cd52008-08-23 05:31:47 -0300943{
Hans Verkuil1ce79812009-11-25 12:37:00 -0300944 struct pms *dev = video_drvdata(file);
Hans Verkuil7d43cd52008-08-23 05:31:47 -0300945
Hans Verkuil1ce79812009-11-25 12:37:00 -0300946 clear_bit(0, &dev->in_use);
Hans Verkuil7d43cd52008-08-23 05:31:47 -0300947 return 0;
948}
949
Hans Verkuilbec43662008-12-30 06:58:20 -0300950static const struct v4l2_file_operations pms_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 .owner = THIS_MODULE,
Hans Verkuil7d43cd52008-08-23 05:31:47 -0300952 .open = pms_exclusive_open,
953 .release = pms_exclusive_release,
Hans Verkuilfeba2f82009-11-25 12:47:02 -0300954 .ioctl = video_ioctl2,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 .read = pms_read,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956};
957
Hans Verkuilfeba2f82009-11-25 12:47:02 -0300958static 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};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973
974/*
975 * Probe for and initialise the Mediavision PMS
976 */
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300977
Hans Verkuil1ce79812009-11-25 12:37:00 -0300978static int init_mediavision(struct pms *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979{
980 int id;
981 int idec, decst;
982 int i;
Hans Verkuil1ce79812009-11-25 12:37:00 -0300983 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991 };
992
Hans Verkuil1ce79812009-11-25 12:37:00 -0300993 dev->mem = ioremap(mem_base, 0x800);
994 if (!dev->mem)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995 return -ENOMEM;
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300996
Hans Verkuil1ce79812009-11-25 12:37:00 -0300997 if (!request_region(0x9a01, 1, "Mediavision PMS config")) {
998 printk(KERN_WARNING "mediavision: unable to detect: 0x9a01 in use.\n");
999 iounmap(dev->mem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000 return -EBUSY;
1001 }
Hans Verkuil1ce79812009-11-25 12:37:00 -03001002 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 return -EBUSY;
1007 }
Hans Verkuil1ce79812009-11-25 12:37:00 -03001008 outb(0xb8, 0x9a01); /* Unlock */
1009 outb(dev->io >> 4, 0x9a01); /* Set IO port */
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -03001010
1011
Hans Verkuil1ce79812009-11-25 12:37:00 -03001012 id = mvv_read(dev, 3);
1013 decst = pms_i2c_stat(dev, 0x43);
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -03001014
Hans Verkuil1ce79812009-11-25 12:37:00 -03001015 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;
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -03001021 else
Hans Verkuil1ce79812009-11-25 12:37:00 -03001022 idec = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023
1024 printk(KERN_INFO "PMS type is %d\n", idec);
Hans Verkuil1ce79812009-11-25 12:37:00 -03001025 if (idec == 0) {
1026 release_region(dev->io, 3);
1027 release_region(0x9a01, 1);
1028 iounmap(dev->mem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 return -ENODEV;
1030 }
1031
1032 /*
1033 * Ok we have a PMS of some sort
1034 */
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -03001035
Hans Verkuil1ce79812009-11-25 12:37:00 -03001036 mvv_write(dev, 0x04, mem_base >> 12); /* Set the memory area */
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -03001037
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038 /* Ok now load the defaults */
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -03001039
Hans Verkuil1ce79812009-11-25 12:37:00 -03001040 for (i = 0; i < 0x19; i++) {
1041 if (i2c_defs[i] == 0xff)
1042 pms_i2c_andor(dev, 0x8a, i, 0x07, 0x00);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043 else
Hans Verkuil1ce79812009-11-25 12:37:00 -03001044 pms_i2c_write(dev, 0x8a, i, i2c_defs[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045 }
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -03001046
Hans Verkuil1ce79812009-11-25 12:37:00 -03001047 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);
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -03001055
Hans Verkuil1ce79812009-11-25 12:37:00 -03001056 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);
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -03001061
Hans Verkuil1ce79812009-11-25 12:37:00 -03001062 mvv_write(dev, 0x10, 0x02);
1063 mvv_write(dev, 0x1e, 0x0c);
1064 mvv_write(dev, 0x1f, 0x03);
1065 mvv_write(dev, 0x26, 0x06);
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -03001066
Hans Verkuil1ce79812009-11-25 12:37:00 -03001067 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080 return 0;
1081}
1082
1083/*
1084 * Initialization and module stuff
1085 */
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -03001086
Rene Hermanb54ff932008-09-03 16:48:21 -03001087#ifndef MODULE
1088static int enable;
1089module_param(enable, int, 0);
1090#endif
1091
Hans Verkuil1ce79812009-11-25 12:37:00 -03001092static int __init pms_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093{
Hans Verkuil1ce79812009-11-25 12:37:00 -03001094 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");
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -03001101
Rene Hermanb54ff932008-09-03 16:48:21 -03001102#ifndef MODULE
1103 if (!enable) {
Hans Verkuil1ce79812009-11-25 12:37:00 -03001104 v4l2_err(v4l2_dev,
1105 "PMS: not enabled, use pms.enable=1 to probe\n");
Rene Hermanb54ff932008-09-03 16:48:21 -03001106 return -ENODEV;
1107 }
1108#endif
1109
Hans Verkuil1ce79812009-11-25 12:37:00 -03001110 dev->decoder = PHILIPS2;
1111 dev->io = io_port;
1112 dev->data = io_port + 1;
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -03001113
Hans Verkuil1ce79812009-11-25 12:37:00 -03001114 if (init_mediavision(dev)) {
1115 v4l2_err(v4l2_dev, "Board not found.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116 return -ENODEV;
1117 }
Hans Verkuil1ce79812009-11-25 12:37:00 -03001118
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 }
1124
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;
Hans Verkuilfeba2f82009-11-25 12:47:02 -03001128 dev->vdev.ioctl_ops = &pms_ioctl_ops;
Hans Verkuil1ce79812009-11-25 12:37:00 -03001129 dev->vdev.release = video_device_release_empty;
1130 video_set_drvdata(&dev->vdev, dev);
1131 mutex_init(&dev->lock);
Hans Verkuilfeba2f82009-11-25 12:47:02 -03001132 dev->std = V4L2_STD_NTSC_M;
Hans Verkuil1ce79812009-11-25 12:37:00 -03001133 dev->height = 240;
1134 dev->width = 320;
Hans Verkuilfeba2f82009-11-25 12:47:02 -03001135 dev->depth = 15;
1136 dev->brightness = 139;
1137 dev->contrast = 70;
1138 dev->hue = 0;
1139 dev->saturation = 64;
Hans Verkuil1ce79812009-11-25 12:37:00 -03001140 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152}
1153
Hans Verkuil1ce79812009-11-25 12:37:00 -03001154static void __exit pms_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155{
Hans Verkuil1ce79812009-11-25 12:37:00 -03001156 struct pms *dev = &pms_card;
1157
1158 video_unregister_device(&dev->vdev);
1159 release_region(dev->io, 3);
1160 release_region(0x9a01, 1);
1161 iounmap(dev->mem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162}
1163
Hans Verkuil1ce79812009-11-25 12:37:00 -03001164module_init(pms_init);
1165module_exit(pms_exit);