Merge branch 'linus' into core/iommu
[linux-2.6] / drivers / staging / go7007 / wis-tw2804.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_tw2804 {
27         int channel;
28         int norm;
29         int brightness;
30         int contrast;
31         int saturation;
32         int hue;
33 };
34
35 static u8 global_registers[] =
36 {
37         0x39, 0x00,
38         0x3a, 0xff,
39         0x3b, 0x84,
40         0x3c, 0x80,
41         0x3d, 0x80,
42         0x3e, 0x82,
43         0x3f, 0x82,
44         0xff, 0xff, /* Terminator (reg 0xff does not exist) */
45 };
46
47 static u8 channel_registers[] =
48 {
49         0x01, 0xc4,
50         0x02, 0xa5,
51         0x03, 0x20,
52         0x04, 0xd0,
53         0x05, 0x20,
54         0x06, 0xd0,
55         0x07, 0x88,
56         0x08, 0x20,
57         0x09, 0x07,
58         0x0a, 0xf0,
59         0x0b, 0x07,
60         0x0c, 0xf0,
61         0x0d, 0x40,
62         0x0e, 0xd2,
63         0x0f, 0x80,
64         0x10, 0x80,
65         0x11, 0x80,
66         0x12, 0x80,
67         0x13, 0x1f,
68         0x14, 0x00,
69         0x15, 0x00,
70         0x16, 0x00,
71         0x17, 0x00,
72         0x18, 0xff,
73         0x19, 0xff,
74         0x1a, 0xff,
75         0x1b, 0xff,
76         0x1c, 0xff,
77         0x1d, 0xff,
78         0x1e, 0xff,
79         0x1f, 0xff,
80         0x20, 0x07,
81         0x21, 0x07,
82         0x22, 0x00,
83         0x23, 0x91,
84         0x24, 0x51,
85         0x25, 0x03,
86         0x26, 0x00,
87         0x27, 0x00,
88         0x28, 0x00,
89         0x29, 0x00,
90         0x2a, 0x00,
91         0x2b, 0x00,
92         0x2c, 0x00,
93         0x2d, 0x00,
94         0x2e, 0x00,
95         0x2f, 0x00,
96         0x30, 0x00,
97         0x31, 0x00,
98         0x32, 0x00,
99         0x33, 0x00,
100         0x34, 0x00,
101         0x35, 0x00,
102         0x36, 0x00,
103         0x37, 0x00,
104         0xff, 0xff, /* Terminator (reg 0xff does not exist) */
105 };
106
107 static int write_reg(struct i2c_client *client, u8 reg, u8 value, int channel)
108 {
109         return i2c_smbus_write_byte_data(client, reg | (channel << 6), value);
110 }
111
112 static int write_regs(struct i2c_client *client, u8 *regs, int channel)
113 {
114         int i;
115
116         for (i = 0; regs[i] != 0xff; i += 2)
117                 if (i2c_smbus_write_byte_data(client,
118                                 regs[i] | (channel << 6), regs[i + 1]) < 0)
119                         return -1;
120         return 0;
121 }
122
123 static int wis_tw2804_command(struct i2c_client *client,
124                                 unsigned int cmd, void *arg)
125 {
126         struct wis_tw2804 *dec = i2c_get_clientdata(client);
127
128         if (cmd == DECODER_SET_CHANNEL) {
129                 int *input = arg;
130
131                 if (*input < 0 || *input > 3) {
132                         printk(KERN_ERR "wis-tw2804: channel %d is not "
133                                         "between 0 and 3!\n", *input);
134                         return 0;
135                 }
136                 dec->channel = *input;
137                 printk(KERN_DEBUG "wis-tw2804: initializing TW2804 "
138                                 "channel %d\n", dec->channel);
139                 if (dec->channel == 0 &&
140                                 write_regs(client, global_registers, 0) < 0) {
141                         printk(KERN_ERR "wis-tw2804: error initializing "
142                                         "TW2804 global registers\n");
143                         return 0;
144                 }
145                 if (write_regs(client, channel_registers, dec->channel) < 0) {
146                         printk(KERN_ERR "wis-tw2804: error initializing "
147                                         "TW2804 channel %d\n", dec->channel);
148                         return 0;
149                 }
150                 return 0;
151         }
152
153         if (dec->channel < 0) {
154                 printk(KERN_DEBUG "wis-tw2804: ignoring command %08x until "
155                                 "channel number is set\n", cmd);
156                 return 0;
157         }
158
159         switch (cmd) {
160         case VIDIOC_S_STD:
161         {
162                 v4l2_std_id *input = arg;
163                 u8 regs[] = {
164                         0x01, *input & V4L2_STD_NTSC ? 0xc4 : 0x84,
165                         0x09, *input & V4L2_STD_NTSC ? 0x07 : 0x04,
166                         0x0a, *input & V4L2_STD_NTSC ? 0xf0 : 0x20,
167                         0x0b, *input & V4L2_STD_NTSC ? 0x07 : 0x04,
168                         0x0c, *input & V4L2_STD_NTSC ? 0xf0 : 0x20,
169                         0x0d, *input & V4L2_STD_NTSC ? 0x40 : 0x4a,
170                         0x16, *input & V4L2_STD_NTSC ? 0x00 : 0x40,
171                         0x17, *input & V4L2_STD_NTSC ? 0x00 : 0x40,
172                         0x20, *input & V4L2_STD_NTSC ? 0x07 : 0x0f,
173                         0x21, *input & V4L2_STD_NTSC ? 0x07 : 0x0f,
174                         0xff,   0xff,
175                 };
176                 write_regs(client, regs, dec->channel);
177                 dec->norm = *input;
178                 break;
179         }
180         case VIDIOC_QUERYCTRL:
181         {
182                 struct v4l2_queryctrl *ctrl = arg;
183
184                 switch (ctrl->id) {
185                 case V4L2_CID_BRIGHTNESS:
186                         ctrl->type = V4L2_CTRL_TYPE_INTEGER;
187                         strncpy(ctrl->name, "Brightness", sizeof(ctrl->name));
188                         ctrl->minimum = 0;
189                         ctrl->maximum = 255;
190                         ctrl->step = 1;
191                         ctrl->default_value = 128;
192                         ctrl->flags = 0;
193                         break;
194                 case V4L2_CID_CONTRAST:
195                         ctrl->type = V4L2_CTRL_TYPE_INTEGER;
196                         strncpy(ctrl->name, "Contrast", sizeof(ctrl->name));
197                         ctrl->minimum = 0;
198                         ctrl->maximum = 255;
199                         ctrl->step = 1;
200                         ctrl->default_value = 128;
201                         ctrl->flags = 0;
202                         break;
203                 case V4L2_CID_SATURATION:
204                         ctrl->type = V4L2_CTRL_TYPE_INTEGER;
205                         strncpy(ctrl->name, "Saturation", sizeof(ctrl->name));
206                         ctrl->minimum = 0;
207                         ctrl->maximum = 255;
208                         ctrl->step = 1;
209                         ctrl->default_value = 128;
210                         ctrl->flags = 0;
211                         break;
212                 case V4L2_CID_HUE:
213                         ctrl->type = V4L2_CTRL_TYPE_INTEGER;
214                         strncpy(ctrl->name, "Hue", sizeof(ctrl->name));
215                         ctrl->minimum = 0;
216                         ctrl->maximum = 255;
217                         ctrl->step = 1;
218                         ctrl->default_value = 128;
219                         ctrl->flags = 0;
220                         break;
221                 }
222                 break;
223         }
224         case VIDIOC_S_CTRL:
225         {
226                 struct v4l2_control *ctrl = arg;
227
228                 switch (ctrl->id) {
229                 case V4L2_CID_BRIGHTNESS:
230                         if (ctrl->value > 255)
231                                 dec->brightness = 255;
232                         else if (ctrl->value < 0)
233                                 dec->brightness = 0;
234                         else
235                                 dec->brightness = ctrl->value;
236                         write_reg(client, 0x12, dec->brightness, dec->channel);
237                         break;
238                 case V4L2_CID_CONTRAST:
239                         if (ctrl->value > 255)
240                                 dec->contrast = 255;
241                         else if (ctrl->value < 0)
242                                 dec->contrast = 0;
243                         else
244                                 dec->contrast = ctrl->value;
245                         write_reg(client, 0x11, dec->contrast, dec->channel);
246                         break;
247                 case V4L2_CID_SATURATION:
248                         if (ctrl->value > 255)
249                                 dec->saturation = 255;
250                         else if (ctrl->value < 0)
251                                 dec->saturation = 0;
252                         else
253                                 dec->saturation = ctrl->value;
254                         write_reg(client, 0x10, dec->saturation, dec->channel);
255                         break;
256                 case V4L2_CID_HUE:
257                         if (ctrl->value > 255)
258                                 dec->hue = 255;
259                         else if (ctrl->value < 0)
260                                 dec->hue = 0;
261                         else
262                                 dec->hue = ctrl->value;
263                         write_reg(client, 0x0f, dec->hue, dec->channel);
264                         break;
265                 }
266                 break;
267         }
268         case VIDIOC_G_CTRL:
269         {
270                 struct v4l2_control *ctrl = arg;
271
272                 switch (ctrl->id) {
273                 case V4L2_CID_BRIGHTNESS:
274                         ctrl->value = dec->brightness;
275                         break;
276                 case V4L2_CID_CONTRAST:
277                         ctrl->value = dec->contrast;
278                         break;
279                 case V4L2_CID_SATURATION:
280                         ctrl->value = dec->saturation;
281                         break;
282                 case V4L2_CID_HUE:
283                         ctrl->value = dec->hue;
284                         break;
285                 }
286                 break;
287         }
288         default:
289                 break;
290         }
291         return 0;
292 }
293
294 static struct i2c_driver wis_tw2804_driver;
295
296 static struct i2c_client wis_tw2804_client_templ = {
297         .name           = "TW2804 (WIS)",
298         .driver         = &wis_tw2804_driver,
299 };
300
301 static int wis_tw2804_detect(struct i2c_adapter *adapter, int addr, int kind)
302 {
303         struct i2c_client *client;
304         struct wis_tw2804 *dec;
305
306         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
307                 return 0;
308
309         client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
310         if (client == NULL)
311                 return -ENOMEM;
312         memcpy(client, &wis_tw2804_client_templ,
313                         sizeof(wis_tw2804_client_templ));
314         client->adapter = adapter;
315         client->addr = addr;
316
317         dec = kmalloc(sizeof(struct wis_tw2804), GFP_KERNEL);
318         if (dec == NULL) {
319                 kfree(client);
320                 return -ENOMEM;
321         }
322         dec->channel = -1;
323         dec->norm = V4L2_STD_NTSC;
324         dec->brightness = 128;
325         dec->contrast = 128;
326         dec->saturation = 128;
327         dec->hue = 128;
328         i2c_set_clientdata(client, dec);
329
330         printk(KERN_DEBUG "wis-tw2804: creating TW2804 at address %d on %s\n",
331                 addr, adapter->name);
332
333         i2c_attach_client(client);
334         return 0;
335 }
336
337 static int wis_tw2804_detach(struct i2c_client *client)
338 {
339         struct wis_tw2804 *dec = i2c_get_clientdata(client);
340         int r;
341
342         r = i2c_detach_client(client);
343         if (r < 0)
344                 return r;
345
346         kfree(client);
347         kfree(dec);
348         return 0;
349 }
350
351 static struct i2c_driver wis_tw2804_driver = {
352         .driver = {
353                 .name   = "WIS TW2804 I2C driver",
354         },
355         .id             = I2C_DRIVERID_WIS_TW2804,
356         .detach_client  = wis_tw2804_detach,
357         .command        = wis_tw2804_command,
358 };
359
360 static int __init wis_tw2804_init(void)
361 {
362         int r;
363
364         r = i2c_add_driver(&wis_tw2804_driver);
365         if (r < 0)
366                 return r;
367         return wis_i2c_add_driver(wis_tw2804_driver.id, wis_tw2804_detect);
368 }
369
370 static void __exit wis_tw2804_cleanup(void)
371 {
372         wis_i2c_del_driver(wis_tw2804_detect);
373         i2c_del_driver(&wis_tw2804_driver);
374 }
375
376 module_init(wis_tw2804_init);
377 module_exit(wis_tw2804_cleanup);
378
379 MODULE_LICENSE("GPL v2");