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