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