?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] W1: w1_netlink: New init/fini netlink callbacks.
[linux-2.6/verdex.git] / drivers / media / video / bt819.c
blob3ee0afca76a7f1b206a39688648aacbd68e4ae5e
1 /*
2 * bt819 - BT819A VideoStream Decoder (Rockwell Part)
3 *
4 * Copyright (C) 1999 Mike Bernson <mike@mlb.org>
5 * Copyright (C) 1998 Dave Perks <dperks@ibm.net>
6 *
7 * Modifications for LML33/DC10plus unified driver
8 * Copyright (C) 2000 Serguei Miridonov <mirsev@cicese.mx>
9 *
10 * Changes by Ronald Bultje <rbultje@ronald.bitfreak.net>
11 * - moved over to linux>=2.4.x i2c protocol (9/9/2002)
12 *
13 * This code was modify/ported from the saa7111 driver written
14 * by Dave Perks.
15 *
16 * This program is free software; you can redistribute it and/or modify
17 * it under the terms of the GNU General Public License as published by
18 * the Free Software Foundation; either version 2 of the License, or
19 * (at your option) any later version.
20 *
21 * This program is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 * GNU General Public License for more details.
25 *
26 * You should have received a copy of the GNU General Public License
27 * along with this program; if not, write to the Free Software
28 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
29 */
30
31 #include <linux/module.h>
32 #include <linux/init.h>
33 #include <linux/delay.h>
34 #include <linux/errno.h>
35 #include <linux/fs.h>
36 #include <linux/kernel.h>
37 #include <linux/major.h>
38 #include <linux/slab.h>
39 #include <linux/mm.h>
40 #include <linux/pci.h>
41 #include <linux/signal.h>
42 #include <asm/io.h>
43 #include <asm/pgtable.h>
44 #include <asm/page.h>
45 #include <linux/sched.h>
46 #include <linux/types.h>
47
48 #include <linux/videodev.h>
49 #include <asm/uaccess.h>
50
51 MODULE_DESCRIPTION("Brooktree-819 video decoder driver");
52 MODULE_AUTHOR("Mike Bernson & Dave Perks");
53 MODULE_LICENSE("GPL");
54
55 #include <linux/i2c.h>
56 #include <linux/i2c-dev.h>
57
58 #define I2C_NAME(s) (s)->name
59
60 #include <linux/video_decoder.h>
61
62 static int debug = 0;
63 module_param(debug, int, 0);
64 MODULE_PARM_DESC(debug, "Debug level (0-1)");
65
66 #define dprintk(num, format, args...) \
67 do { \
68 if (debug >= num) \
69 printk(format, ##args); \
70 } while (0)
71
72 /* ----------------------------------------------------------------------- */
73
74 struct bt819 {
75 unsigned char reg[32];
76
77 int initialized;
78 int norm;
79 int input;
80 int enable;
81 int bright;
82 int contrast;
83 int hue;
84 int sat;
85 };
86
87 struct timing {
88 int hactive;
89 int hdelay;
90 int vactive;
91 int vdelay;
92 int hscale;
93 int vscale;
94 };
95
96 /* for values, see the bt819 datasheet */
97 static struct timing timing_data[] = {
98 {864 - 24, 20, 625 - 2, 1, 0x0504, 0x0000},
99 {858 - 24, 20, 525 - 2, 1, 0x00f8, 0x0000},
100 };
101
102 #define I2C_BT819 0x8a
103
104 /* ----------------------------------------------------------------------- */
105
106 static inline int
107 bt819_write (struct i2c_client *client,
108 u8 reg,
109 u8 value)
110 {
111 struct bt819 *decoder = i2c_get_clientdata(client);
112
113 decoder->reg[reg] = value;
114 return i2c_smbus_write_byte_data(client, reg, value);
115 }
116
117 static inline int
118 bt819_setbit (struct i2c_client *client,
119 u8 reg,
120 u8 bit,
121 u8 value)
122 {
123 struct bt819 *decoder = i2c_get_clientdata(client);
124
125 return bt819_write(client, reg,
126 (decoder->
127 reg[reg] & ~(1 << bit)) |
128 (value ? (1 << bit) : 0));
129 }
130
131 static int
132 bt819_write_block (struct i2c_client *client,
133 const u8 *data,
134 unsigned int len)
135 {
136 int ret = -1;
137 u8 reg;
138
139 /* the bt819 has an autoincrement function, use it if
140 * the adapter understands raw I2C */
141 if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
142 /* do raw I2C, not smbus compatible */
143 struct bt819 *decoder = i2c_get_clientdata(client);
144 struct i2c_msg msg;
145 u8 block_data[32];
146
147 msg.addr = client->addr;
148 msg.flags = 0;
149 while (len >= 2) {
150 msg.buf = (char *) block_data;
151 msg.len = 0;
152 block_data[msg.len++] = reg = data[0];
153 do {
154 block_data[msg.len++] =
155 decoder->reg[reg++] = data[1];
156 len -= 2;
157 data += 2;
158 } while (len >= 2 && data[0] == reg &&
159 msg.len < 32);
160 if ((ret = i2c_transfer(client->adapter,
161 &msg, 1)) < 0)
162 break;
163 }
164 } else {
165 /* do some slow I2C emulation kind of thing */
166 while (len >= 2) {
167 reg = *data++;
168 if ((ret = bt819_write(client, reg, *data++)) < 0)
169 break;
170 len -= 2;
171 }
172 }
173
174 return ret;
175 }
176
177 static inline int
178 bt819_read (struct i2c_client *client,
179 u8 reg)
180 {
181 return i2c_smbus_read_byte_data(client, reg);
182 }
183
184 static int
185 bt819_init (struct i2c_client *client)
186 {
187 struct bt819 *decoder = i2c_get_clientdata(client);
188
189 static unsigned char init[] = {
190 //0x1f, 0x00, /* Reset */
191 0x01, 0x59, /* 0x01 input format */
192 0x02, 0x00, /* 0x02 temporal decimation */
193 0x03, 0x12, /* 0x03 Cropping msb */
194 0x04, 0x16, /* 0x04 Vertical Delay, lsb */
195 0x05, 0xe0, /* 0x05 Vertical Active lsb */
196 0x06, 0x80, /* 0x06 Horizontal Delay lsb */
197 0x07, 0xd0, /* 0x07 Horizontal Active lsb */
198 0x08, 0x00, /* 0x08 Horizontal Scaling msb */
199 0x09, 0xf8, /* 0x09 Horizontal Scaling lsb */
200 0x0a, 0x00, /* 0x0a Brightness control */
201 0x0b, 0x30, /* 0x0b Miscellaneous control */
202 0x0c, 0xd8, /* 0x0c Luma Gain lsb */
203 0x0d, 0xfe, /* 0x0d Chroma Gain (U) lsb */
204 0x0e, 0xb4, /* 0x0e Chroma Gain (V) msb */
205 0x0f, 0x00, /* 0x0f Hue control */
206 0x12, 0x04, /* 0x12 Output Format */
207 0x13, 0x20, /* 0x13 Vertial Scaling msb 0x00
208 chroma comb OFF, line drop scaling, interlace scaling
209 BUG? Why does turning the chroma comb on fuck up color?
210 Bug in the bt819 stepping on my board?
211 */
212 0x14, 0x00, /* 0x14 Vertial Scaling lsb */
213 0x16, 0x07, /* 0x16 Video Timing Polarity
214 ACTIVE=active low
215 FIELD: high=odd,
216 vreset=active high,
217 hreset=active high */
218 0x18, 0x68, /* 0x18 AGC Delay */
219 0x19, 0x5d, /* 0x19 Burst Gate Delay */
220 0x1a, 0x80, /* 0x1a ADC Interface */
221 };
222
223 struct timing *timing = &timing_data[decoder->norm];
224
225 init[0x03 * 2 - 1] =
226 (((timing->vdelay >> 8) & 0x03) << 6) | (((timing->
227 vactive >> 8) &
228 0x03) << 4) |
229 (((timing->hdelay >> 8) & 0x03) << 2) | ((timing->
230 hactive >> 8) &
231 0x03);
232 init[0x04 * 2 - 1] = timing->vdelay & 0xff;
233 init[0x05 * 2 - 1] = timing->vactive & 0xff;
234 init[0x06 * 2 - 1] = timing->hdelay & 0xff;
235 init[0x07 * 2 - 1] = timing->hactive & 0xff;
236 init[0x08 * 2 - 1] = timing->hscale >> 8;
237 init[0x09 * 2 - 1] = timing->hscale & 0xff;
238 /* 0x15 in array is address 0x19 */
239 init[0x15 * 2 - 1] = (decoder->norm == 0) ? 115 : 93; /* Chroma burst delay */
240 /* reset */
241 bt819_write(client, 0x1f, 0x00);
242 mdelay(1);
243
244 /* init */
245 return bt819_write_block(client, init, sizeof(init));
246
247 }
248
249 /* ----------------------------------------------------------------------- */
250
251 static int
252 bt819_command (struct i2c_client *client,
253 unsigned int cmd,
254 void *arg)
255 {
256 int temp;
257
258 struct bt819 *decoder = i2c_get_clientdata(client);
259
260 if (!decoder->initialized) { // First call to bt819_init could be
261 bt819_init(client); // without #FRST = 0
262 decoder->initialized = 1;
263 }
264
265 switch (cmd) {
266
267 case 0:
268 /* This is just for testing!!! */
269 bt819_init(client);
270 break;
271
272 case DECODER_GET_CAPABILITIES:
273 {
274 struct video_decoder_capability *cap = arg;
275
276 cap->flags = VIDEO_DECODER_PAL |
277 VIDEO_DECODER_NTSC |
278 VIDEO_DECODER_AUTO |
279 VIDEO_DECODER_CCIR;
280 cap->inputs = 8;
281 cap->outputs = 1;
282 }
283 break;
284
285 case DECODER_GET_STATUS:
286 {
287 int *iarg = arg;
288 int status;
289 int res;
290
291 status = bt819_read(client, 0x00);
292 res = 0;
293 if ((status & 0x80)) {
294 res |= DECODER_STATUS_GOOD;
295 }
296 switch (decoder->norm) {
297 case VIDEO_MODE_NTSC:
298 res |= DECODER_STATUS_NTSC;
299 break;
300 case VIDEO_MODE_PAL:
301 res |= DECODER_STATUS_PAL;
302 break;
303 default:
304 case VIDEO_MODE_AUTO:
305 if ((status & 0x10)) {
306 res |= DECODER_STATUS_PAL;
307 } else {
308 res |= DECODER_STATUS_NTSC;
309 }
310 break;
311 }
312 res |= DECODER_STATUS_COLOR;
313 *iarg = res;
314
315 dprintk(1, KERN_INFO "%s: get status %x\n", I2C_NAME(client),
316 *iarg);
317 }
318 break;
319
320 case DECODER_SET_NORM:
321 {
322 int *iarg = arg;
323 struct timing *timing = NULL;
324
325 dprintk(1, KERN_INFO "%s: set norm %x\n", I2C_NAME(client),
326 *iarg);
327
328 switch (*iarg) {
329 case VIDEO_MODE_NTSC:
330 bt819_setbit(client, 0x01, 0, 1);
331 bt819_setbit(client, 0x01, 1, 0);
332 bt819_setbit(client, 0x01, 5, 0);
333 bt819_write(client, 0x18, 0x68);
334 bt819_write(client, 0x19, 0x5d);
335 //bt819_setbit(client, 0x1a, 5, 1);
336 timing = &timing_data[VIDEO_MODE_NTSC];
337 break;
338 case VIDEO_MODE_PAL:
339 bt819_setbit(client, 0x01, 0, 1);
340 bt819_setbit(client, 0x01, 1, 1);
341 bt819_setbit(client, 0x01, 5, 1);
342 bt819_write(client, 0x18, 0x7f);
343 bt819_write(client, 0x19, 0x72);
344 //bt819_setbit(client, 0x1a, 5, 0);
345 timing = &timing_data[VIDEO_MODE_PAL];
346 break;
347 case VIDEO_MODE_AUTO:
348 bt819_setbit(client, 0x01, 0, 0);
349 bt819_setbit(client, 0x01, 1, 0);
350 break;
351 default:
352 dprintk(1,
353 KERN_ERR
354 "%s: unsupported norm %d\n",
355 I2C_NAME(client), *iarg);
356 return -EINVAL;
357 }
358
359 if (timing) {
360 bt819_write(client, 0x03,
361 (((timing->vdelay >> 8) & 0x03) << 6) |
362 (((timing->vactive >> 8) & 0x03) << 4) |
363 (((timing->hdelay >> 8) & 0x03) << 2) |
364 ((timing->hactive >> 8) & 0x03) );
365 bt819_write(client, 0x04, timing->vdelay & 0xff);
366 bt819_write(client, 0x05, timing->vactive & 0xff);
367 bt819_write(client, 0x06, timing->hdelay & 0xff);
368 bt819_write(client, 0x07, timing->hactive & 0xff);
369 bt819_write(client, 0x08, (timing->hscale >> 8) & 0xff);
370 bt819_write(client, 0x09, timing->hscale & 0xff);
371 }
372
373 decoder->norm = *iarg;
374 }
375 break;
376
377 case DECODER_SET_INPUT:
378 {
379 int *iarg = arg;
380
381 dprintk(1, KERN_INFO "%s: set input %x\n", I2C_NAME(client),
382 *iarg);
383
384 if (*iarg < 0 || *iarg > 7) {
385 return -EINVAL;
386 }
387
388 if (decoder->input != *iarg) {
389 decoder->input = *iarg;
390 /* select mode */
391 if (decoder->input == 0) {
392 bt819_setbit(client, 0x0b, 6, 0);
393 bt819_setbit(client, 0x1a, 1, 1);
394 } else {
395 bt819_setbit(client, 0x0b, 6, 1);
396 bt819_setbit(client, 0x1a, 1, 0);
397 }
398 }
399 }
400 break;
401
402 case DECODER_SET_OUTPUT:
403 {
404 int *iarg = arg;
405
406 dprintk(1, KERN_INFO "%s: set output %x\n", I2C_NAME(client),
407 *iarg);
408
409 /* not much choice of outputs */
410 if (*iarg != 0) {
411 return -EINVAL;
412 }
413 }
414 break;
415
416 case DECODER_ENABLE_OUTPUT:
417 {
418 int *iarg = arg;
419 int enable = (*iarg != 0);
420
421 dprintk(1, KERN_INFO "%s: enable output %x\n",
422 I2C_NAME(client), *iarg);
423
424 if (decoder->enable != enable) {
425 decoder->enable = enable;
426
427 if (decoder->enable) {
428 bt819_setbit(client, 0x16, 7, 0);
429 } else {
430 bt819_setbit(client, 0x16, 7, 1);
431 }
432 }
433 }
434 break;
435
436 case DECODER_SET_PICTURE:
437 {
438 struct video_picture *pic = arg;
439
440 dprintk(1,
441 KERN_INFO
442 "%s: set picture brightness %d contrast %d colour %d\n",
443 I2C_NAME(client), pic->brightness, pic->contrast,
444 pic->colour);
445
446
447 if (decoder->bright != pic->brightness) {
448 /* We want -128 to 127 we get 0-65535 */
449 decoder->bright = pic->brightness;
450 bt819_write(client, 0x0a,
451 (decoder->bright >> 8) - 128);
452 }
453
454 if (decoder->contrast != pic->contrast) {
455 /* We want 0 to 511 we get 0-65535 */
456 decoder->contrast = pic->contrast;
457 bt819_write(client, 0x0c,
458 (decoder->contrast >> 7) & 0xff);
459 bt819_setbit(client, 0x0b, 2,
460 ((decoder->contrast >> 15) & 0x01));
461 }
462
463 if (decoder->sat != pic->colour) {
464 /* We want 0 to 511 we get 0-65535 */
465 decoder->sat = pic->colour;
466 bt819_write(client, 0x0d,
467 (decoder->sat >> 7) & 0xff);
468 bt819_setbit(client, 0x0b, 1,
469 ((decoder->sat >> 15) & 0x01));
470
471 temp = (decoder->sat * 201) / 237;
472 bt819_write(client, 0x0e, (temp >> 7) & 0xff);
473 bt819_setbit(client, 0x0b, 0, (temp >> 15) & 0x01);
474 }
475
476 if (decoder->hue != pic->hue) {
477 /* We want -128 to 127 we get 0-65535 */
478 decoder->hue = pic->hue;
479 bt819_write(client, 0x0f,
480 128 - (decoder->hue >> 8));
481 }
482 }
483 break;
484
485 default:
486 return -EINVAL;
487 }
488
489 return 0;
490 }
491
492 /* ----------------------------------------------------------------------- */
493
494 /*
495 * Generic i2c probe
496 * concerning the addresses: i2c wants 7 bit (without the r/w bit), so '>>1'
497 */
498 static unsigned short normal_i2c[] = {
499 I2C_BT819 >> 1,
500 I2C_CLIENT_END,
501 };
502
503 static unsigned short ignore = I2C_CLIENT_END;
504
505 static struct i2c_client_address_data addr_data = {
506 .normal_i2c = normal_i2c,
507 .probe = &ignore,
508 .ignore = &ignore,
509 };
510
511 static struct i2c_driver i2c_driver_bt819;
512
513 static int
514 bt819_detect_client (struct i2c_adapter *adapter,
515 int address,
516 int kind)
517 {
518 int i, id;
519 struct bt819 *decoder;
520 struct i2c_client *client;
521
522 dprintk(1,
523 KERN_INFO
524 "saa7111.c: detecting bt819 client on address 0x%x\n",
525 address << 1);
526
527 /* Check if the adapter supports the needed features */
528 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
529 return 0;
530
531 client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
532 if (client == 0)
533 return -ENOMEM;
534 memset(client, 0, sizeof(struct i2c_client));
535 client->addr = address;
536 client->adapter = adapter;
537 client->driver = &i2c_driver_bt819;
538 client->flags = I2C_CLIENT_ALLOW_USE;
539
540 decoder = kmalloc(sizeof(struct bt819), GFP_KERNEL);
541 if (decoder == NULL) {
542 kfree(client);
543 return -ENOMEM;
544 }
545
546 memset(decoder, 0, sizeof(struct bt819));
547 decoder->norm = VIDEO_MODE_NTSC;
548 decoder->input = 0;
549 decoder->enable = 1;
550 decoder->bright = 32768;
551 decoder->contrast = 32768;
552 decoder->hue = 32768;
553 decoder->sat = 32768;
554 decoder->initialized = 0;
555 i2c_set_clientdata(client, decoder);
556
557 id = bt819_read(client, 0x17);
558 switch (id & 0xf0) {
559 case 0x70:
560 strlcpy(I2C_NAME(client), "bt819a", sizeof(I2C_NAME(client)));
561 break;
562 case 0x60:
563 strlcpy(I2C_NAME(client), "bt817a", sizeof(I2C_NAME(client)));
564 break;
565 case 0x20:
566 strlcpy(I2C_NAME(client), "bt815a", sizeof(I2C_NAME(client)));
567 break;
568 default:
569 dprintk(1,
570 KERN_ERR
571 "bt819: unknown chip version 0x%x (ver 0x%x)\n",
572 id & 0xf0, id & 0x0f);
573 kfree(decoder);
574 kfree(client);
575 return 0;
576 }
577
578 i = i2c_attach_client(client);
579 if (i) {
580 kfree(client);
581 kfree(decoder);
582 return i;
583 }
584
585 i = bt819_init(client);
586 if (i < 0) {
587 dprintk(1, KERN_ERR "%s_attach: init status %d\n",
588 I2C_NAME(client), i);
589 } else {
590 dprintk(1,
591 KERN_INFO
592 "%s_attach: chip version 0x%x at address 0x%x\n",
593 I2C_NAME(client), id & 0x0f,
594 client->addr << 1);
595 }
596
597 return 0;
598 }
599
600 static int
601 bt819_attach_adapter (struct i2c_adapter *adapter)
602 {
603 return i2c_probe(adapter, &addr_data, &bt819_detect_client);
604 }
605
606 static int
607 bt819_detach_client (struct i2c_client *client)
608 {
609 struct bt819 *decoder = i2c_get_clientdata(client);
610 int err;
611
612 err = i2c_detach_client(client);
613 if (err) {
614 return err;
615 }
616
617 kfree(decoder);
618 kfree(client);
619
620 return 0;
621 }
622
623 /* ----------------------------------------------------------------------- */
624
625 static struct i2c_driver i2c_driver_bt819 = {
626 .owner = THIS_MODULE,
627 .name = "bt819",
628
629 .id = I2C_DRIVERID_BT819,
630 .flags = I2C_DF_NOTIFY,
631
632 .attach_adapter = bt819_attach_adapter,
633 .detach_client = bt819_detach_client,
634 .command = bt819_command,
635 };
636
637 static int __init
638 bt819_init_module (void)
639 {
640 return i2c_add_driver(&i2c_driver_bt819);
641 }
642
643 static void __exit
644 bt819_exit (void)
645 {
646 i2c_del_driver(&i2c_driver_bt819);
647 }
648
649 module_init(bt819_init_module);
650 module_exit(bt819_exit);
Verdex Pro support