1 /*
2 saa7111 - Philips SAA7111A video decoder driver version 0.0.3
3
4 Copyright (C) 1998 Dave Perks <dperks@ibm.net>
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21 #include <linux/module.h>
22 #include <linux/delay.h>
23 #include <linux/errno.h>
24 #include <linux/fs.h>
25 #include <linux/kernel.h>
26 #include <linux/major.h>
27 #include <linux/malloc.h>
28 #include <linux/mm.h>
29 #include <linux/pci.h>
30 #include <linux/signal.h>
31 #include <asm/io.h>
32 #include <asm/pgtable.h>
33 #include <asm/page.h>
34 #include <linux/sched.h>
35 #include <asm/segment.h>
36 #include <linux/types.h>
37 #include <linux/wrapper.h>
38
39 #include <linux/videodev.h>
40 #include <linux/version.h>
41 #include <asm/uaccess.h>
42
43 #include <linux/i2c-old.h>
44 #include <linux/video_decoder.h>
45
46 #define DEBUG(x) /* Debug driver */
47
48 /* ----------------------------------------------------------------------- */
49
50 struct saa7111 {
51 struct i2c_bus *bus;
52 int addr;
53 unsigned char reg[32];
54
55 int norm;
56 int input;
57 int enable;
58 int bright;
59 int contrast;
60 int hue;
61 int sat;
62 };
63
64 #define I2C_SAA7111 0x48
65
66 #define I2C_DELAY 10
67
68 /* ----------------------------------------------------------------------- */
69
70 static int saa7111_write(struct saa7111 *dev, unsigned char subaddr, unsigned char data)
71 {
72 int ack;
73
74 LOCK_I2C_BUS(dev->bus);
75 i2c_start(dev->bus);
76 i2c_sendbyte(dev->bus, dev->addr, I2C_DELAY);
77 i2c_sendbyte(dev->bus, subaddr, I2C_DELAY);
78 ack = i2c_sendbyte(dev->bus, data, I2C_DELAY);
79 dev->reg[subaddr] = data;
80 i2c_stop(dev->bus);
81 UNLOCK_I2C_BUS(dev->bus);
82 return ack;
83 }
84
85 static int saa7111_write_block(struct saa7111 *dev, unsigned const char *data, unsigned int len)
86 {
87 int ack = 0;
88 unsigned subaddr;
89
90 while (len > 1) {
91 LOCK_I2C_BUS(dev->bus);
92 i2c_start(dev->bus);
93 i2c_sendbyte(dev->bus, dev->addr, I2C_DELAY);
94 ack = i2c_sendbyte(dev->bus, (subaddr = *data++), I2C_DELAY);
95 ack = i2c_sendbyte(dev->bus, (dev->reg[subaddr] = *data++), I2C_DELAY);
96 len -= 2;
97 while (len > 1 && *data == ++subaddr) {
98 data++;
99 ack = i2c_sendbyte(dev->bus, (dev->reg[subaddr] = *data++), I2C_DELAY);
100 len -= 2;
101 }
102 i2c_stop(dev->bus);
103 UNLOCK_I2C_BUS(dev->bus);
104 }
105 return ack;
106 }
107
108 static int saa7111_read(struct saa7111 *dev, unsigned char subaddr)
109 {
110 int data;
111
112 LOCK_I2C_BUS(dev->bus);
113 i2c_start(dev->bus);
114 i2c_sendbyte(dev->bus, dev->addr, I2C_DELAY);
115 i2c_sendbyte(dev->bus, subaddr, I2C_DELAY);
116 i2c_start(dev->bus);
117 i2c_sendbyte(dev->bus, dev->addr | 1, I2C_DELAY);
118 data = i2c_readbyte(dev->bus, 1);
119 i2c_stop(dev->bus);
120 UNLOCK_I2C_BUS(dev->bus);
121 return data;
122 }
123
124 /* ----------------------------------------------------------------------- */
125
126 static int saa7111_attach(struct i2c_device *device)
127 {
128 int i;
129 struct saa7111 *decoder;
130
131 static const unsigned char init[] =
132 {
133 0x00, 0x00, /* 00 - ID byte */
134 0x01, 0x00, /* 01 - reserved */
135
136 /*front end */
137 0x02, 0xd0, /* 02 - FUSE=3, GUDL=2, MODE=0 */
138 0x03, 0x23, /* 03 - HLNRS=0, VBSL=1, WPOFF=0, HOLDG=0, GAFIX=0, GAI1=256, GAI2=256 */
139 0x04, 0x00, /* 04 - GAI1=256 */
140 0x05, 0x00, /* 05 - GAI2=256 */
141
142 /* decoder */
143 0x06, 0xf6, /* 06 - HSB at 13(50Hz) / 17(60Hz) pixels after end of last line */
144 0x07, 0xdd, /* 07 - HSS at 113(50Hz) / 117(60Hz) pixels after end of last line */
145 0x08, 0xc8, /* 08 - AUFD=1, FSEL=1, EXFIL=0, VTRC=1, HPLL=0, VNOI=0 */
146 0x09, 0x01, /* 09 - BYPS=0, PREF=0, BPSS=0, VBLB=0, UPTCV=0, APER=1 */
147 0x0a, 0x80, /* 0a - BRIG=128 */
148 0x0b, 0x47, /* 0b - CONT=1.109 */
149 0x0c, 0x40, /* 0c - SATN=1.0 */
150 0x0d, 0x00, /* 0d - HUE=0 */
151 0x0e, 0x01, /* 0e - CDTO=0, CSTD=0, DCCF=0, FCTC=0, CHBW=1 */
152 0x0f, 0x00, /* 0f - reserved */
153 0x10, 0x48, /* 10 - OFTS=1, HDEL=0, VRLN=1, YDEL=0 */
154 0x11, 0x1c, /* 11 - GPSW=0, CM99=0, FECO=0, COMPO=1, OEYC=1, OEHV=1, VIPB=0, COLO=0 */
155 0x12, 0x00, /* 12 - output control 2 */
156 0x13, 0x00, /* 13 - output control 3 */
157 0x14, 0x00, /* 14 - reserved */
158 0x15, 0x00, /* 15 - VBI */
159 0x16, 0x00, /* 16 - VBI */
160 0x17, 0x00, /* 17 - VBI */
161 };
162
163 device->data = decoder = kmalloc(sizeof(struct saa7111), GFP_KERNEL);
164 if (decoder == NULL) {
165 return -ENOMEM;
166 }
167 MOD_INC_USE_COUNT;
168
169 memset(decoder, 0, sizeof(struct saa7111));
170 strcpy(device->name, "saa7111");
171 decoder->bus = device->bus;
172 decoder->addr = device->addr;
173 decoder->norm = VIDEO_MODE_NTSC;
174 decoder->input = 0;
175 decoder->enable = 1;
176 decoder->bright = 32768;
177 decoder->contrast = 32768;
178 decoder->hue = 32768;
179 decoder->sat = 32768;
180
181 i = saa7111_write_block(decoder, init, sizeof(init));
182 if (i < 0) {
183 printk(KERN_ERR "%s_attach: init status %d\n", device->name, i);
184 } else {
185 printk(KERN_INFO "%s_attach: chip version %x\n", device->name, saa7111_read(decoder, 0x00));
186 }
187 return 0;
188 }
189
190
191 static int saa7111_detach(struct i2c_device *device)
192 {
193 kfree(device->data);
194 MOD_DEC_USE_COUNT;
195 return 0;
196 }
197
198 static int saa7111_command(struct i2c_device *device, unsigned int cmd, void *arg)
199 {
200 struct saa7111 *decoder = device->data;
201
202 switch (cmd) {
203
204 #if defined(DECODER_DUMP)
205 case DECODER_DUMP:
206 {
207 int i;
208
209 for (i = 0; i < 32; i += 16) {
210 int j;
211
212 printk("KERN_DEBUG %s: %03x", device->name, i);
213 for (j = 0; j < 16; ++j) {
214 printk(" %02x", saa7111_read(decoder, i + j));
215 }
216 printk("\n");
217 }
218 }
219 break;
220 #endif /* defined(DECODER_DUMP) */
221
222 case DECODER_GET_CAPABILITIES:
223 {
224 struct video_decoder_capability *cap = arg;
225
226 cap->flags
227 = VIDEO_DECODER_PAL
228 | VIDEO_DECODER_NTSC
229 | VIDEO_DECODER_AUTO
230 | VIDEO_DECODER_CCIR;
231 cap->inputs = 8;
232 cap->outputs = 1;
233 }
234 break;
235
236 case DECODER_GET_STATUS:
237 {
238 int *iarg = arg;
239 int status;
240 int res;
241
242 status = saa7111_read(decoder, 0x1f);
243 res = 0;
244 if ((status & (1 << 6)) == 0) {
245 res |= DECODER_STATUS_GOOD;
246 }
247 switch (decoder->norm) {
248 case VIDEO_MODE_NTSC:
249 res |= DECODER_STATUS_NTSC;
250 break;
251 case VIDEO_MODE_PAL:
252 res |= DECODER_STATUS_PAL;
253 break;
254 default:
255 case VIDEO_MODE_AUTO:
256 if ((status & (1 << 5)) != 0) {
257 res |= DECODER_STATUS_NTSC;
258 } else {
259 res |= DECODER_STATUS_PAL;
260 }
261 break;
262 }
263 if ((status & (1 << 0)) != 0) {
264 res |= DECODER_STATUS_COLOR;
265 }
266 *iarg = res;
267 }
268 break;
269
270 case DECODER_SET_NORM:
271 {
272 int *iarg = arg;
273
274 switch (*iarg) {
275
276 case VIDEO_MODE_NTSC:
277 saa7111_write(decoder, 0x08, (decoder->reg[0x08] & 0x3f) | 0x40);
278 break;
279
280 case VIDEO_MODE_PAL:
281 saa7111_write(decoder, 0x08, (decoder->reg[0x08] & 0x3f) | 0x00);
282 break;
283
284 case VIDEO_MODE_AUTO:
285 saa7111_write(decoder, 0x08, (decoder->reg[0x08] & 0x3f) | 0x80);
286 break;
287
288 default:
289 return -EINVAL;
290
291 }
292 decoder->norm = *iarg;
293 }
294 break;
295
296 case DECODER_SET_INPUT:
297 {
298 int *iarg = arg;
299
300 if (*iarg < 0 || *iarg > 7) {
301 return -EINVAL;
302 }
303 if (decoder->input != *iarg) {
304 decoder->input = *iarg;
305 /* select mode */
306 saa7111_write(decoder, 0x02, (decoder->reg[0x02] & 0xf8) | decoder->input);
307 /* bypass chrominance trap for modes 4..7 */
308 saa7111_write(decoder, 0x09, (decoder->reg[0x09] & 0x7f) | ((decoder->input > 3) ? 0x80 : 0));
309 }
310 }
311 break;
312
313 case DECODER_SET_OUTPUT:
314 {
315 int *iarg = arg;
316
317 /* not much choice of outputs */
318 if (*iarg != 0) {
319 return -EINVAL;
320 }
321 }
322 break;
323
324 case DECODER_ENABLE_OUTPUT:
325 {
326 int *iarg = arg;
327 int enable = (*iarg != 0);
328
329 if (decoder->enable != enable) {
330 decoder->enable = enable;
331
332 // RJ: If output should be disabled (for playing videos), we also need a open PLL.
333 // The input is set to 0 (where no input source is connected), although this
334 // is not necessary.
335 //
336 // If output should be enabled, we have to reverse the above.
337
338 if (decoder->enable) {
339 saa7111_write(decoder, 0x02, (decoder->reg[0x02] & 0xf8) | decoder->input);
340 saa7111_write(decoder, 0x08, (decoder->reg[0x08] & 0xfb));
341 saa7111_write(decoder, 0x11, (decoder->reg[0x11] & 0xf3) | 0x0c);
342 } else {
343 saa7111_write(decoder, 0x02, (decoder->reg[0x02] & 0xf8));
344 saa7111_write(decoder, 0x08, (decoder->reg[0x08] & 0xfb) | 0x04);
345 saa7111_write(decoder, 0x11, (decoder->reg[0x11] & 0xf3));
346 }
347 }
348 }
349 break;
350
351 case DECODER_SET_PICTURE:
352 {
353 struct video_picture *pic = arg;
354
355 if (decoder->bright != pic->brightness) {
356 /* We want 0 to 255 we get 0-65535 */
357 decoder->bright = pic->brightness;
358 saa7111_write(decoder, 0x0a, decoder->bright >> 8);
359 }
360 if (decoder->contrast != pic->contrast) {
361 /* We want 0 to 127 we get 0-65535 */
362 decoder->contrast = pic->contrast;
363 saa7111_write(decoder, 0x0b, decoder->contrast >> 9);
364 }
365 if (decoder->sat != pic->colour) {
366 /* We want 0 to 127 we get 0-65535 */
367 decoder->sat = pic->colour;
368 saa7111_write(decoder, 0x0c, decoder->sat >> 9);
369 }
370 if (decoder->hue != pic->hue) {
371 /* We want -128 to 127 we get 0-65535 */
372 decoder->hue = pic->hue;
373 saa7111_write(decoder, 0x0d, (decoder->hue - 32768) >> 8);
374 }
375 }
376 break;
377
378 default:
379 return -EINVAL;
380 }
381
382 return 0;
383 }
384
385 /* ----------------------------------------------------------------------- */
386
387 struct i2c_driver i2c_driver_saa7111 =
388 {
389 "saa7111", /* name */
390 I2C_DRIVERID_VIDEODECODER, /* ID */
391 I2C_SAA7111, I2C_SAA7111 + 1,
392
393 saa7111_attach,
394 saa7111_detach,
395 saa7111_command
396 };
397
398 EXPORT_NO_SYMBOLS;
399
400 #ifdef MODULE
401 int init_module(void)
402 #else
403 int saa7111_init(void)
404 #endif
405 {
406 return i2c_register_driver(&i2c_driver_saa7111);
407 }
408
409
410
411 #ifdef MODULE
412
413 void cleanup_module(void)
414 {
415 i2c_unregister_driver(&i2c_driver_saa7111);
416 }
417
418 #endif
419
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.