Merge branch 'for-linus' of git://git.o-hand.com/linux-rpurdie-backlight
[linux-2.6] / drivers / staging / go7007 / wis-tw9903.c
1 /*
2  * Copyright (C) 2005-2006 Micronas USA Inc.
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License (Version 2) as
6  * published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11  * GNU General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public License
14  * along with this program; if not, write to the Free Software Foundation,
15  * Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
16  */
17
18 #include <linux/module.h>
19 #include <linux/init.h>
20 #include <linux/i2c.h>
21 #include <linux/videodev2.h>
22 #include <linux/ioctl.h>
23
24 #include "wis-i2c.h"
25
26 struct wis_tw9903 {
27         int norm;
28         int brightness;
29         int contrast;
30         int hue;
31 };
32
33 static u8 initial_registers[] =
34 {
35         0x02, 0x44, /* input 1, composite */
36         0x03, 0x92, /* correct digital format */
37         0x04, 0x00,
38         0x05, 0x80, /* or 0x00 for PAL */
39         0x06, 0x40, /* second internal current reference */
40         0x07, 0x02, /* window */
41         0x08, 0x14, /* window */
42         0x09, 0xf0, /* window */
43         0x0a, 0x81, /* window */
44         0x0b, 0xd0, /* window */
45         0x0c, 0x8c,
46         0x0d, 0x00, /* scaling */
47         0x0e, 0x11, /* scaling */
48         0x0f, 0x00, /* scaling */
49         0x10, 0x00, /* brightness */
50         0x11, 0x60, /* contrast */
51         0x12, 0x01, /* sharpness */
52         0x13, 0x7f, /* U gain */
53         0x14, 0x5a, /* V gain */
54         0x15, 0x00, /* hue */
55         0x16, 0xc3, /* sharpness */
56         0x18, 0x00,
57         0x19, 0x58, /* vbi */
58         0x1a, 0x80,
59         0x1c, 0x0f, /* video norm */
60         0x1d, 0x7f, /* video norm */
61         0x20, 0xa0, /* clamping gain (working 0x50) */
62         0x21, 0x22,
63         0x22, 0xf0,
64         0x23, 0xfe,
65         0x24, 0x3c,
66         0x25, 0x38,
67         0x26, 0x44,
68         0x27, 0x20,
69         0x28, 0x00,
70         0x29, 0x15,
71         0x2a, 0xa0,
72         0x2b, 0x44,
73         0x2c, 0x37,
74         0x2d, 0x00,
75         0x2e, 0xa5, /* burst PLL control (working: a9) */
76         0x2f, 0xe0, /* 0xea is blue test frame -- 0xe0 for normal */
77         0x31, 0x00,
78         0x33, 0x22,
79         0x34, 0x11,
80         0x35, 0x35,
81         0x3b, 0x05,
82         0x06, 0xc0, /* reset device */
83         0x00, 0x00, /* Terminator (reg 0x00 is read-only) */
84 };
85
86 static int write_reg(struct i2c_client *client, u8 reg, u8 value)
87 {
88         return i2c_smbus_write_byte_data(client, reg, value);
89 }
90
91 static int write_regs(struct i2c_client *client, u8 *regs)
92 {
93         int i;
94
95         for (i = 0; regs[i] != 0x00; i += 2)
96                 if (i2c_smbus_write_byte_data(client, regs[i], regs[i + 1]) < 0)
97                         return -1;
98         return 0;
99 }
100
101 static int wis_tw9903_command(struct i2c_client *client,
102                                 unsigned int cmd, void *arg)
103 {
104         struct wis_tw9903 *dec = i2c_get_clientdata(client);
105
106         switch (cmd) {
107         case VIDIOC_S_INPUT:
108         {
109                 int *input = arg;
110
111                 i2c_smbus_write_byte_data(client, 0x02, 0x40 | (*input << 1));
112                 break;
113         }
114 #if 0   /* The scaler on this thing seems to be horribly broken */
115         case DECODER_SET_RESOLUTION:
116         {
117                 struct video_decoder_resolution *res = arg;
118                 /*int hscale = 256 * 720 / res->width;*/
119                 int hscale = 256 * 720 / (res->width - (res->width > 704 ? 0 : 8));
120                 int vscale = 256 * (dec->norm & V4L2_STD_NTSC ?  240 : 288)
121                                 / res->height;
122                 u8 regs[] = {
123                         0x0d, vscale & 0xff,
124                         0x0f, hscale & 0xff,
125                         0x0e, ((vscale & 0xf00) >> 4) | ((hscale & 0xf00) >> 8),
126                         0x06, 0xc0, /* reset device */
127                         0,      0,
128                 };
129                 printk(KERN_DEBUG "vscale is %04x, hscale is %04x\n",
130                                 vscale, hscale);
131                 /*write_regs(client, regs);*/
132                 break;
133         }
134 #endif
135         case VIDIOC_S_STD:
136         {
137                 v4l2_std_id *input = arg;
138                 u8 regs[] = {
139                         0x05, *input & V4L2_STD_NTSC ? 0x80 : 0x00,
140                         0x07, *input & V4L2_STD_NTSC ? 0x02 : 0x12,
141                         0x08, *input & V4L2_STD_NTSC ? 0x14 : 0x18,
142                         0x09, *input & V4L2_STD_NTSC ? 0xf0 : 0x20,
143                         0,      0,
144                 };
145                 write_regs(client, regs);
146                 dec->norm = *input;
147                 break;
148         }
149         case VIDIOC_QUERYCTRL:
150         {
151                 struct v4l2_queryctrl *ctrl = arg;
152
153                 switch (ctrl->id) {
154                 case V4L2_CID_BRIGHTNESS:
155                         ctrl->type = V4L2_CTRL_TYPE_INTEGER;
156                         strncpy(ctrl->name, "Brightness", sizeof(ctrl->name));
157                         ctrl->minimum = -128;
158                         ctrl->maximum = 127;
159                         ctrl->step = 1;
160                         ctrl->default_value = 0x00;
161                         ctrl->flags = 0;
162                         break;
163                 case V4L2_CID_CONTRAST:
164                         ctrl->type = V4L2_CTRL_TYPE_INTEGER;
165                         strncpy(ctrl->name, "Contrast", sizeof(ctrl->name));
166                         ctrl->minimum = 0;
167                         ctrl->maximum = 255;
168                         ctrl->step = 1;
169                         ctrl->default_value = 0x60;
170                         ctrl->flags = 0;
171                         break;
172 #if 0
173                 /* I don't understand how the Chroma Gain registers work... */
174                 case V4L2_CID_SATURATION:
175                         ctrl->type = V4L2_CTRL_TYPE_INTEGER;
176                         strncpy(ctrl->name, "Saturation", sizeof(ctrl->name));
177                         ctrl->minimum = 0;
178                         ctrl->maximum = 127;
179                         ctrl->step = 1;
180                         ctrl->default_value = 64;
181                         ctrl->flags = 0;
182                         break;
183 #endif
184                 case V4L2_CID_HUE:
185                         ctrl->type = V4L2_CTRL_TYPE_INTEGER;
186                         strncpy(ctrl->name, "Hue", sizeof(ctrl->name));
187                         ctrl->minimum = -128;
188                         ctrl->maximum = 127;
189                         ctrl->step = 1;
190                         ctrl->default_value = 0;
191                         ctrl->flags = 0;
192                         break;
193                 }
194                 break;
195         }
196         case VIDIOC_S_CTRL:
197         {
198                 struct v4l2_control *ctrl = arg;
199
200                 switch (ctrl->id) {
201                 case V4L2_CID_BRIGHTNESS:
202                         if (ctrl->value > 127)
203                                 dec->brightness = 127;
204                         else if (ctrl->value < -128)
205                                 dec->brightness = -128;
206                         else
207                                 dec->brightness = ctrl->value;
208                         write_reg(client, 0x10, dec->brightness);
209                         break;
210                 case V4L2_CID_CONTRAST:
211                         if (ctrl->value > 255)
212                                 dec->contrast = 255;
213                         else if (ctrl->value < 0)
214                                 dec->contrast = 0;
215                         else
216                                 dec->contrast = ctrl->value;
217                         write_reg(client, 0x11, dec->contrast);
218                         break;
219 #if 0
220                 case V4L2_CID_SATURATION:
221                         if (ctrl->value > 127)
222                                 dec->saturation = 127;
223                         else if (ctrl->value < 0)
224                                 dec->saturation = 0;
225                         else
226                                 dec->saturation = ctrl->value;
227                         /*write_reg(client, 0x0c, dec->saturation);*/
228                         break;
229 #endif
230                 case V4L2_CID_HUE:
231                         if (ctrl->value > 127)
232                                 dec->hue = 127;
233                         else if (ctrl->value < -128)
234                                 dec->hue = -128;
235                         else
236                                 dec->hue = ctrl->value;
237                         write_reg(client, 0x15, dec->hue);
238                         break;
239                 }
240                 break;
241         }
242         case VIDIOC_G_CTRL:
243         {
244                 struct v4l2_control *ctrl = arg;
245
246                 switch (ctrl->id) {
247                 case V4L2_CID_BRIGHTNESS:
248                         ctrl->value = dec->brightness;
249                         break;
250                 case V4L2_CID_CONTRAST:
251                         ctrl->value = dec->contrast;
252                         break;
253 #if 0
254                 case V4L2_CID_SATURATION:
255                         ctrl->value = dec->saturation;
256                         break;
257 #endif
258                 case V4L2_CID_HUE:
259                         ctrl->value = dec->hue;
260                         break;
261                 }
262                 break;
263         }
264         default:
265                 break;
266         }
267         return 0;
268 }
269
270 static struct i2c_driver wis_tw9903_driver;
271
272 static struct i2c_client wis_tw9903_client_templ = {
273         .name           = "TW9903 (WIS)",
274         .driver         = &wis_tw9903_driver,
275 };
276
277 static int wis_tw9903_detect(struct i2c_adapter *adapter, int addr, int kind)
278 {
279         struct i2c_client *client;
280         struct wis_tw9903 *dec;
281
282         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
283                 return 0;
284
285         client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
286         if (client == NULL)
287                 return -ENOMEM;
288         memcpy(client, &wis_tw9903_client_templ,
289                         sizeof(wis_tw9903_client_templ));
290         client->adapter = adapter;
291         client->addr = addr;
292
293         dec = kmalloc(sizeof(struct wis_tw9903), GFP_KERNEL);
294         if (dec == NULL) {
295                 kfree(client);
296                 return -ENOMEM;
297         }
298         dec->norm = V4L2_STD_NTSC;
299         dec->brightness = 0;
300         dec->contrast = 0x60;
301         dec->hue = 0;
302         i2c_set_clientdata(client, dec);
303
304         printk(KERN_DEBUG
305                 "wis-tw9903: initializing TW9903 at address %d on %s\n",
306                 addr, adapter->name);
307
308         if (write_regs(client, initial_registers) < 0) {
309                 printk(KERN_ERR "wis-tw9903: error initializing TW9903\n");
310                 kfree(client);
311                 kfree(dec);
312                 return 0;
313         }
314
315         i2c_attach_client(client);
316         return 0;
317 }
318
319 static int wis_tw9903_detach(struct i2c_client *client)
320 {
321         struct wis_tw9903 *dec = i2c_get_clientdata(client);
322         int r;
323
324         r = i2c_detach_client(client);
325         if (r < 0)
326                 return r;
327
328         kfree(client);
329         kfree(dec);
330         return 0;
331 }
332
333 static struct i2c_driver wis_tw9903_driver = {
334         .driver = {
335                 .name   = "WIS TW9903 I2C driver",
336         },
337         .id             = I2C_DRIVERID_WIS_TW9903,
338         .detach_client  = wis_tw9903_detach,
339         .command        = wis_tw9903_command,
340 };
341
342 static int __init wis_tw9903_init(void)
343 {
344         int r;
345
346         r = i2c_add_driver(&wis_tw9903_driver);
347         if (r < 0)
348                 return r;
349         return wis_i2c_add_driver(wis_tw9903_driver.id, wis_tw9903_detect);
350 }
351
352 static void __exit wis_tw9903_cleanup(void)
353 {
354         wis_i2c_del_driver(wis_tw9903_detect);
355         i2c_del_driver(&wis_tw9903_driver);
356 }
357
358 module_init(wis_tw9903_init);
359 module_exit(wis_tw9903_cleanup);
360
361 MODULE_LICENSE("GPL v2");