Merge branch 'work'
[linux-2.6] / drivers / media / video / tvp5150.c
1 /*
2  * tvp5150 - Texas Instruments TVP5150A(M) video decoder driver
3  *
4  * Copyright (c) 2005 Mauro Carvalho Chehab (mchehab@brturbo.com.br)
5  * This code is placed under the terms of the GNU General Public License
6  */
7
8 #include <linux/i2c.h>
9 #include <linux/videodev.h>
10 #include <linux/delay.h>
11 #include <linux/video_decoder.h>
12 #include <media/v4l2-common.h>
13
14 #include "tvp5150_reg.h"
15
16 MODULE_DESCRIPTION("Texas Instruments TVP5150A video decoder driver");  /* standard i2c insmod options */
17 MODULE_AUTHOR("Mauro Carvalho Chehab");
18 MODULE_LICENSE("GPL");
19
20 static unsigned short normal_i2c[] = {
21         0xb8 >> 1,
22         0xba >> 1,
23         I2C_CLIENT_END
24 };
25
26 I2C_CLIENT_INSMOD;
27
28 static int debug = 0;
29 module_param(debug, int, 0);
30 MODULE_PARM_DESC(debug, "Debug level (0-1)");
31
32 #define tvp5150_info(fmt, arg...) do { \
33         printk(KERN_INFO "%s %d-%04x: " fmt, c->driver->driver.name, \
34                i2c_adapter_id(c->adapter), c->addr , ## arg); } while (0)
35 #define tvp5150_dbg(num, fmt, arg...) \
36         do { \
37                 if (debug >= num) \
38                         printk(KERN_DEBUG "%s debug %d-%04x: " fmt,\
39                                 c->driver->driver.name, \
40                                 i2c_adapter_id(c->adapter), \
41                                 c->addr , ## arg); } while (0)
42
43 /* supported controls */
44 static struct v4l2_queryctrl tvp5150_qctrl[] = {
45         {
46                 .id = V4L2_CID_BRIGHTNESS,
47                 .type = V4L2_CTRL_TYPE_INTEGER,
48                 .name = "Brightness",
49                 .minimum = 0,
50                 .maximum = 255,
51                 .step = 1,
52                 .default_value = 0,
53                 .flags = 0,
54         }, {
55                 .id = V4L2_CID_CONTRAST,
56                 .type = V4L2_CTRL_TYPE_INTEGER,
57                 .name = "Contrast",
58                 .minimum = 0,
59                 .maximum = 255,
60                 .step = 0x1,
61                 .default_value = 0x10,
62                 .flags = 0,
63         }, {
64                  .id = V4L2_CID_SATURATION,
65                  .type = V4L2_CTRL_TYPE_INTEGER,
66                  .name = "Saturation",
67                  .minimum = 0,
68                  .maximum = 255,
69                  .step = 0x1,
70                  .default_value = 0x10,
71                  .flags = 0,
72         }, {
73                 .id = V4L2_CID_HUE,
74                 .type = V4L2_CTRL_TYPE_INTEGER,
75                 .name = "Hue",
76                 .minimum = -128,
77                 .maximum = 127,
78                 .step = 0x1,
79                 .default_value = 0x10,
80                 .flags = 0,
81         }
82 };
83
84 struct tvp5150 {
85         struct i2c_client *client;
86
87         int norm;
88         int input;
89         int enable;
90         int bright;
91         int contrast;
92         int hue;
93         int sat;
94 };
95
96 static int tvp5150_read(struct i2c_client *c, unsigned char addr)
97 {
98         unsigned char buffer[1];
99         int rc;
100
101         buffer[0] = addr;
102         if (1 != (rc = i2c_master_send(c, buffer, 1)))
103                 tvp5150_dbg(0, "i2c i/o error: rc == %d (should be 1)\n", rc);
104
105         msleep(10);
106
107         if (1 != (rc = i2c_master_recv(c, buffer, 1)))
108                 tvp5150_dbg(0, "i2c i/o error: rc == %d (should be 1)\n", rc);
109
110         tvp5150_dbg(2, "tvp5150: read 0x%02x = 0x%02x\n", addr, buffer[0]);
111
112         return (buffer[0]);
113 }
114
115 static inline void tvp5150_write(struct i2c_client *c, unsigned char addr,
116                                  unsigned char value)
117 {
118         unsigned char buffer[2];
119         int rc;
120
121         buffer[0] = addr;
122         buffer[1] = value;
123         tvp5150_dbg(2, "tvp5150: writing 0x%02x 0x%02x\n", buffer[0], buffer[1]);
124         if (2 != (rc = i2c_master_send(c, buffer, 2)))
125                 tvp5150_dbg(0, "i2c i/o error: rc == %d (should be 2)\n", rc);
126 }
127
128 static void dump_reg(struct i2c_client *c)
129 {
130         printk("tvp5150: Video input source selection #1 = 0x%02x\n",
131                tvp5150_read(c, TVP5150_VD_IN_SRC_SEL_1));
132         printk("tvp5150: Analog channel controls = 0x%02x\n",
133                tvp5150_read(c, TVP5150_ANAL_CHL_CTL));
134         printk("tvp5150: Operation mode controls = 0x%02x\n",
135                tvp5150_read(c, TVP5150_OP_MODE_CTL));
136         printk("tvp5150: Miscellaneous controls = 0x%02x\n",
137                tvp5150_read(c, TVP5150_MISC_CTL));
138         printk("tvp5150: Autoswitch mask: TVP5150A / TVP5150AM = 0x%02x\n",
139                tvp5150_read(c, TVP5150_AUTOSW_MSK));
140         printk("tvp5150: Color killer threshold control = 0x%02x\n",
141                tvp5150_read(c, TVP5150_COLOR_KIL_THSH_CTL));
142         printk("tvp5150: Luminance processing control #1 = 0x%02x\n",
143                tvp5150_read(c, TVP5150_LUMA_PROC_CTL_1));
144         printk("tvp5150: Luminance processing control #2 = 0x%02x\n",
145                tvp5150_read(c, TVP5150_LUMA_PROC_CTL_2));
146         printk("tvp5150: Brightness control = 0x%02x\n",
147                tvp5150_read(c, TVP5150_BRIGHT_CTL));
148         printk("tvp5150: Color saturation control = 0x%02x\n",
149                tvp5150_read(c, TVP5150_SATURATION_CTL));
150         printk("tvp5150: Hue control = 0x%02x\n",
151                tvp5150_read(c, TVP5150_HUE_CTL));
152         printk("tvp5150: Contrast control = 0x%02x\n",
153                tvp5150_read(c, TVP5150_CONTRAST_CTL));
154         printk("tvp5150: Outputs and data rates select = 0x%02x\n",
155                tvp5150_read(c, TVP5150_DATA_RATE_SEL));
156         printk("tvp5150: Luminance processing control #3 = 0x%02x\n",
157                tvp5150_read(c, TVP5150_LUMA_PROC_CTL_3));
158         printk("tvp5150: Configuration shared pins = 0x%02x\n",
159                tvp5150_read(c, TVP5150_CONF_SHARED_PIN));
160         printk("tvp5150: Active video cropping start MSB = 0x%02x\n",
161                tvp5150_read(c, TVP5150_ACT_VD_CROP_ST_MSB));
162         printk("tvp5150: Active video cropping start LSB = 0x%02x\n",
163                tvp5150_read(c, TVP5150_ACT_VD_CROP_ST_LSB));
164         printk("tvp5150: Active video cropping stop MSB = 0x%02x\n",
165                tvp5150_read(c, TVP5150_ACT_VD_CROP_STP_MSB));
166         printk("tvp5150: Active video cropping stop LSB = 0x%02x\n",
167                tvp5150_read(c, TVP5150_ACT_VD_CROP_STP_LSB));
168         printk("tvp5150: Genlock/RTC = 0x%02x\n",
169                tvp5150_read(c, TVP5150_GENLOCK));
170         printk("tvp5150: Horizontal sync start = 0x%02x\n",
171                tvp5150_read(c, TVP5150_HORIZ_SYNC_START));
172         printk("tvp5150: Vertical blanking start = 0x%02x\n",
173                tvp5150_read(c, TVP5150_VERT_BLANKING_START));
174         printk("tvp5150: Vertical blanking stop = 0x%02x\n",
175                tvp5150_read(c, TVP5150_VERT_BLANKING_STOP));
176         printk("tvp5150: Chrominance processing control #1 = 0x%02x\n",
177                tvp5150_read(c, TVP5150_CHROMA_PROC_CTL_1));
178         printk("tvp5150: Chrominance processing control #2 = 0x%02x\n",
179                tvp5150_read(c, TVP5150_CHROMA_PROC_CTL_2));
180         printk("tvp5150: Interrupt reset register B = 0x%02x\n",
181                tvp5150_read(c, TVP5150_INT_RESET_REG_B));
182         printk("tvp5150: Interrupt enable register B = 0x%02x\n",
183                tvp5150_read(c, TVP5150_INT_ENABLE_REG_B));
184         printk("tvp5150: Interrupt configuration register B = 0x%02x\n",
185                tvp5150_read(c, TVP5150_INTT_CONFIG_REG_B));
186         printk("tvp5150: Video standard = 0x%02x\n",
187                tvp5150_read(c, TVP5150_VIDEO_STD));
188         printk("tvp5150: Cb gain factor = 0x%02x\n",
189                tvp5150_read(c, TVP5150_CB_GAIN_FACT));
190         printk("tvp5150: Cr gain factor = 0x%02x\n",
191                tvp5150_read(c, TVP5150_CR_GAIN_FACTOR));
192         printk("tvp5150: Macrovision on counter = 0x%02x\n",
193                tvp5150_read(c, TVP5150_MACROVISION_ON_CTR));
194         printk("tvp5150: Macrovision off counter = 0x%02x\n",
195                tvp5150_read(c, TVP5150_MACROVISION_OFF_CTR));
196         printk("tvp5150: revision select (TVP5150AM1 only) = 0x%02x\n",
197                tvp5150_read(c, TVP5150_REV_SELECT));
198         printk("tvp5150: MSB of device ID = 0x%02x\n",
199                tvp5150_read(c, TVP5150_MSB_DEV_ID));
200         printk("tvp5150: LSB of device ID = 0x%02x\n",
201                tvp5150_read(c, TVP5150_LSB_DEV_ID));
202         printk("tvp5150: ROM major version = 0x%02x\n",
203                tvp5150_read(c, TVP5150_ROM_MAJOR_VER));
204         printk("tvp5150: ROM minor version = 0x%02x\n",
205                tvp5150_read(c, TVP5150_ROM_MINOR_VER));
206         printk("tvp5150: Vertical line count MSB = 0x%02x\n",
207                tvp5150_read(c, TVP5150_VERT_LN_COUNT_MSB));
208         printk("tvp5150: Vertical line count LSB = 0x%02x\n",
209                tvp5150_read(c, TVP5150_VERT_LN_COUNT_LSB));
210         printk("tvp5150: Interrupt status register B = 0x%02x\n",
211                tvp5150_read(c, TVP5150_INT_STATUS_REG_B));
212         printk("tvp5150: Interrupt active register B = 0x%02x\n",
213                tvp5150_read(c, TVP5150_INT_ACTIVE_REG_B));
214         printk("tvp5150: Status register #1 = 0x%02x\n",
215                tvp5150_read(c, TVP5150_STATUS_REG_1));
216         printk("tvp5150: Status register #2 = 0x%02x\n",
217                tvp5150_read(c, TVP5150_STATUS_REG_2));
218         printk("tvp5150: Status register #3 = 0x%02x\n",
219                tvp5150_read(c, TVP5150_STATUS_REG_3));
220         printk("tvp5150: Status register #4 = 0x%02x\n",
221                tvp5150_read(c, TVP5150_STATUS_REG_4));
222         printk("tvp5150: Status register #5 = 0x%02x\n",
223                tvp5150_read(c, TVP5150_STATUS_REG_5));
224         printk("tvp5150: Closed caption data registers = 0x%02x\n",
225                tvp5150_read(c, TVP5150_CC_DATA_REG1));
226         printk("tvp5150: Closed caption data registers = 0x%02x\n",
227                tvp5150_read(c, TVP5150_CC_DATA_REG2));
228         printk("tvp5150: Closed caption data registers = 0x%02x\n",
229                tvp5150_read(c, TVP5150_CC_DATA_REG3));
230         printk("tvp5150: Closed caption data registers = 0x%02x\n",
231                tvp5150_read(c, TVP5150_CC_DATA_REG4));
232         printk("tvp5150: WSS data registers = 0x%02x\n",
233                tvp5150_read(c, TVP5150_WSS_DATA_REG1));
234         printk("tvp5150: WSS data registers = 0x%02x\n",
235                tvp5150_read(c, TVP5150_WSS_DATA_REG2));
236         printk("tvp5150: WSS data registers = 0x%02x\n",
237                tvp5150_read(c, TVP5150_WSS_DATA_REG3));
238         printk("tvp5150: WSS data registers = 0x%02x\n",
239                tvp5150_read(c, TVP5150_WSS_DATA_REG4));
240         printk("tvp5150: WSS data registers = 0x%02x\n",
241                tvp5150_read(c, TVP5150_WSS_DATA_REG5));
242         printk("tvp5150: WSS data registers = 0x%02x\n",
243                tvp5150_read(c, TVP5150_WSS_DATA_REG6));
244         printk("tvp5150: VPS data registers = 0x%02x\n",
245                tvp5150_read(c, TVP5150_VPS_DATA_REG1));
246         printk("tvp5150: VPS data registers = 0x%02x\n",
247                tvp5150_read(c, TVP5150_VPS_DATA_REG2));
248         printk("tvp5150: VPS data registers = 0x%02x\n",
249                tvp5150_read(c, TVP5150_VPS_DATA_REG3));
250         printk("tvp5150: VPS data registers = 0x%02x\n",
251                tvp5150_read(c, TVP5150_VPS_DATA_REG4));
252         printk("tvp5150: VPS data registers = 0x%02x\n",
253                tvp5150_read(c, TVP5150_VPS_DATA_REG5));
254         printk("tvp5150: VPS data registers = 0x%02x\n",
255                tvp5150_read(c, TVP5150_VPS_DATA_REG6));
256         printk("tvp5150: VPS data registers = 0x%02x\n",
257                tvp5150_read(c, TVP5150_VPS_DATA_REG7));
258         printk("tvp5150: VPS data registers = 0x%02x\n",
259                tvp5150_read(c, TVP5150_VPS_DATA_REG8));
260         printk("tvp5150: VPS data registers = 0x%02x\n",
261                tvp5150_read(c, TVP5150_VPS_DATA_REG9));
262         printk("tvp5150: VPS data registers = 0x%02x\n",
263                tvp5150_read(c, TVP5150_VPS_DATA_REG10));
264         printk("tvp5150: VPS data registers = 0x%02x\n",
265                tvp5150_read(c, TVP5150_VPS_DATA_REG11));
266         printk("tvp5150: VPS data registers = 0x%02x\n",
267                tvp5150_read(c, TVP5150_VPS_DATA_REG12));
268         printk("tvp5150: VPS data registers = 0x%02x\n",
269                tvp5150_read(c, TVP5150_VPS_DATA_REG13));
270         printk("tvp5150: VITC data registers = 0x%02x\n",
271                tvp5150_read(c, TVP5150_VITC_DATA_REG1));
272         printk("tvp5150: VITC data registers = 0x%02x\n",
273                tvp5150_read(c, TVP5150_VITC_DATA_REG2));
274         printk("tvp5150: VITC data registers = 0x%02x\n",
275                tvp5150_read(c, TVP5150_VITC_DATA_REG3));
276         printk("tvp5150: VITC data registers = 0x%02x\n",
277                tvp5150_read(c, TVP5150_VITC_DATA_REG4));
278         printk("tvp5150: VITC data registers = 0x%02x\n",
279                tvp5150_read(c, TVP5150_VITC_DATA_REG5));
280         printk("tvp5150: VITC data registers = 0x%02x\n",
281                tvp5150_read(c, TVP5150_VITC_DATA_REG6));
282         printk("tvp5150: VITC data registers = 0x%02x\n",
283                tvp5150_read(c, TVP5150_VITC_DATA_REG7));
284         printk("tvp5150: VITC data registers = 0x%02x\n",
285                tvp5150_read(c, TVP5150_VITC_DATA_REG8));
286         printk("tvp5150: VITC data registers = 0x%02x\n",
287                tvp5150_read(c, TVP5150_VITC_DATA_REG9));
288         printk("tvp5150: VBI FIFO read data = 0x%02x\n",
289                tvp5150_read(c, TVP5150_VBI_FIFO_READ_DATA));
290         printk("tvp5150: Teletext filter 1 = 0x%02x\n",
291                tvp5150_read(c, TVP5150_TELETEXT_FIL_1_1));
292         printk("tvp5150: Teletext filter 1 = 0x%02x\n",
293                tvp5150_read(c, TVP5150_TELETEXT_FIL_1_2));
294         printk("tvp5150: Teletext filter 1 = 0x%02x\n",
295                tvp5150_read(c, TVP5150_TELETEXT_FIL_1_3));
296         printk("tvp5150: Teletext filter 1 = 0x%02x\n",
297                tvp5150_read(c, TVP5150_TELETEXT_FIL_1_4));
298         printk("tvp5150: Teletext filter 1 = 0x%02x\n",
299                tvp5150_read(c, TVP5150_TELETEXT_FIL_1_5));
300         printk("tvp5150: Teletext filter 2 = 0x%02x\n",
301                tvp5150_read(c, TVP5150_TELETEXT_FIL_2_1));
302         printk("tvp5150: Teletext filter 2 = 0x%02x\n",
303                tvp5150_read(c, TVP5150_TELETEXT_FIL_2_2));
304         printk("tvp5150: Teletext filter 2 = 0x%02x\n",
305                tvp5150_read(c, TVP5150_TELETEXT_FIL_2_3));
306         printk("tvp5150: Teletext filter 2 = 0x%02x\n",
307                tvp5150_read(c, TVP5150_TELETEXT_FIL_2_4));
308         printk("tvp5150: Teletext filter 2 = 0x%02x\n",
309                tvp5150_read(c, TVP5150_TELETEXT_FIL_2_5));
310         printk("tvp5150: Teletext filter enable = 0x%02x\n",
311                tvp5150_read(c, TVP5150_TELETEXT_FIL_ENA));
312         printk("tvp5150: Interrupt status register A = 0x%02x\n",
313                tvp5150_read(c, TVP5150_INT_STATUS_REG_A));
314         printk("tvp5150: Interrupt enable register A = 0x%02x\n",
315                tvp5150_read(c, TVP5150_INT_ENABLE_REG_A));
316         printk("tvp5150: Interrupt configuration = 0x%02x\n",
317                tvp5150_read(c, TVP5150_INT_CONF));
318         printk("tvp5150: VDP configuration RAM data = 0x%02x\n",
319                tvp5150_read(c, TVP5150_VDP_CONF_RAM_DATA));
320         printk("tvp5150: Configuration RAM address low byte = 0x%02x\n",
321                tvp5150_read(c, TVP5150_CONF_RAM_ADDR_LOW));
322         printk("tvp5150: Configuration RAM address high byte = 0x%02x\n",
323                tvp5150_read(c, TVP5150_CONF_RAM_ADDR_HIGH));
324         printk("tvp5150: VDP status register = 0x%02x\n",
325                tvp5150_read(c, TVP5150_VDP_STATUS_REG));
326         printk("tvp5150: FIFO word count = 0x%02x\n",
327                tvp5150_read(c, TVP5150_FIFO_WORD_COUNT));
328         printk("tvp5150: FIFO interrupt threshold = 0x%02x\n",
329                tvp5150_read(c, TVP5150_FIFO_INT_THRESHOLD));
330         printk("tvp5150: FIFO reset = 0x%02x\n",
331                tvp5150_read(c, TVP5150_FIFO_RESET));
332         printk("tvp5150: Line number interrupt = 0x%02x\n",
333                tvp5150_read(c, TVP5150_LINE_NUMBER_INT));
334         printk("tvp5150: Pixel alignment register low byte = 0x%02x\n",
335                tvp5150_read(c, TVP5150_PIX_ALIGN_REG_LOW));
336         printk("tvp5150: Pixel alignment register high byte = 0x%02x\n",
337                tvp5150_read(c, TVP5150_PIX_ALIGN_REG_HIGH));
338         printk("tvp5150: FIFO output control = 0x%02x\n",
339                tvp5150_read(c, TVP5150_FIFO_OUT_CTRL));
340         printk("tvp5150: Full field enable 1 = 0x%02x\n",
341                tvp5150_read(c, TVP5150_FULL_FIELD_ENA_1));
342         printk("tvp5150: Full field enable 2 = 0x%02x\n",
343                tvp5150_read(c, TVP5150_FULL_FIELD_ENA_2));
344         printk("tvp5150: Line mode registers = 0x%02x\n",
345                tvp5150_read(c, TVP5150_LINE_MODE_REG_1));
346         printk("tvp5150: Line mode registers = 0x%02x\n",
347                tvp5150_read(c, TVP5150_LINE_MODE_REG_2));
348         printk("tvp5150: Line mode registers = 0x%02x\n",
349                tvp5150_read(c, TVP5150_LINE_MODE_REG_3));
350         printk("tvp5150: Line mode registers = 0x%02x\n",
351                tvp5150_read(c, TVP5150_LINE_MODE_REG_4));
352         printk("tvp5150: Line mode registers = 0x%02x\n",
353                tvp5150_read(c, TVP5150_LINE_MODE_REG_5));
354         printk("tvp5150: Line mode registers = 0x%02x\n",
355                tvp5150_read(c, TVP5150_LINE_MODE_REG_6));
356         printk("tvp5150: Line mode registers = 0x%02x\n",
357                tvp5150_read(c, TVP5150_LINE_MODE_REG_7));
358         printk("tvp5150: Line mode registers = 0x%02x\n",
359                tvp5150_read(c, TVP5150_LINE_MODE_REG_8));
360         printk("tvp5150: Line mode registers = 0x%02x\n",
361                tvp5150_read(c, TVP5150_LINE_MODE_REG_9));
362         printk("tvp5150: Line mode registers = 0x%02x\n",
363                tvp5150_read(c, TVP5150_LINE_MODE_REG_10));
364         printk("tvp5150: Line mode registers = 0x%02x\n",
365                tvp5150_read(c, TVP5150_LINE_MODE_REG_11));
366         printk("tvp5150: Line mode registers = 0x%02x\n",
367                tvp5150_read(c, TVP5150_LINE_MODE_REG_12));
368         printk("tvp5150: Line mode registers = 0x%02x\n",
369                tvp5150_read(c, TVP5150_LINE_MODE_REG_13));
370         printk("tvp5150: Line mode registers = 0x%02x\n",
371                tvp5150_read(c, TVP5150_LINE_MODE_REG_14));
372         printk("tvp5150: Line mode registers = 0x%02x\n",
373                tvp5150_read(c, TVP5150_LINE_MODE_REG_15));
374         printk("tvp5150: Line mode registers = 0x%02x\n",
375                tvp5150_read(c, TVP5150_LINE_MODE_REG_16));
376         printk("tvp5150: Line mode registers = 0x%02x\n",
377                tvp5150_read(c, TVP5150_LINE_MODE_REG_17));
378         printk("tvp5150: Line mode registers = 0x%02x\n",
379                tvp5150_read(c, TVP5150_LINE_MODE_REG_18));
380         printk("tvp5150: Line mode registers = 0x%02x\n",
381                tvp5150_read(c, TVP5150_LINE_MODE_REG_19));
382         printk("tvp5150: Line mode registers = 0x%02x\n",
383                tvp5150_read(c, TVP5150_LINE_MODE_REG_20));
384         printk("tvp5150: Line mode registers = 0x%02x\n",
385                tvp5150_read(c, TVP5150_LINE_MODE_REG_21));
386         printk("tvp5150: Line mode registers = 0x%02x\n",
387                tvp5150_read(c, TVP5150_LINE_MODE_REG_22));
388         printk("tvp5150: Line mode registers = 0x%02x\n",
389                tvp5150_read(c, TVP5150_LINE_MODE_REG_23));
390         printk("tvp5150: Line mode registers = 0x%02x\n",
391                tvp5150_read(c, TVP5150_LINE_MODE_REG_24));
392         printk("tvp5150: Line mode registers = 0x%02x\n",
393                tvp5150_read(c, TVP5150_LINE_MODE_REG_25));
394         printk("tvp5150: Line mode registers = 0x%02x\n",
395                tvp5150_read(c, TVP5150_LINE_MODE_REG_27));
396         printk("tvp5150: Line mode registers = 0x%02x\n",
397                tvp5150_read(c, TVP5150_LINE_MODE_REG_28));
398         printk("tvp5150: Line mode registers = 0x%02x\n",
399                tvp5150_read(c, TVP5150_LINE_MODE_REG_29));
400         printk("tvp5150: Line mode registers = 0x%02x\n",
401                tvp5150_read(c, TVP5150_LINE_MODE_REG_30));
402         printk("tvp5150: Line mode registers = 0x%02x\n",
403                tvp5150_read(c, TVP5150_LINE_MODE_REG_31));
404         printk("tvp5150: Line mode registers = 0x%02x\n",
405                tvp5150_read(c, TVP5150_LINE_MODE_REG_32));
406         printk("tvp5150: Line mode registers = 0x%02x\n",
407                tvp5150_read(c, TVP5150_LINE_MODE_REG_33));
408         printk("tvp5150: Line mode registers = 0x%02x\n",
409                tvp5150_read(c, TVP5150_LINE_MODE_REG_34));
410         printk("tvp5150: Line mode registers = 0x%02x\n",
411                tvp5150_read(c, TVP5150_LINE_MODE_REG_35));
412         printk("tvp5150: Line mode registers = 0x%02x\n",
413                tvp5150_read(c, TVP5150_LINE_MODE_REG_36));
414         printk("tvp5150: Line mode registers = 0x%02x\n",
415                tvp5150_read(c, TVP5150_LINE_MODE_REG_37));
416         printk("tvp5150: Line mode registers = 0x%02x\n",
417                tvp5150_read(c, TVP5150_LINE_MODE_REG_38));
418         printk("tvp5150: Line mode registers = 0x%02x\n",
419                tvp5150_read(c, TVP5150_LINE_MODE_REG_39));
420         printk("tvp5150: Line mode registers = 0x%02x\n",
421                tvp5150_read(c, TVP5150_LINE_MODE_REG_40));
422         printk("tvp5150: Line mode registers = 0x%02x\n",
423                tvp5150_read(c, TVP5150_LINE_MODE_REG_41));
424         printk("tvp5150: Line mode registers = 0x%02x\n",
425                tvp5150_read(c, TVP5150_LINE_MODE_REG_42));
426         printk("tvp5150: Line mode registers = 0x%02x\n",
427                tvp5150_read(c, TVP5150_LINE_MODE_REG_43));
428         printk("tvp5150: Line mode registers = 0x%02x\n",
429                tvp5150_read(c, TVP5150_LINE_MODE_REG_44));
430         printk("tvp5150: Full field mode register = 0x%02x\n",
431                tvp5150_read(c, TVP5150_FULL_FIELD_MODE_REG));
432 }
433
434 /****************************************************************************
435                         Basic functions
436  ****************************************************************************/
437 enum tvp5150_input {
438         TVP5150_ANALOG_CH0 = 0,
439         TVP5150_SVIDEO = 1,
440         TVP5150_ANALOG_CH1 = 2,
441         TVP5150_BLACK_SCREEN = 8
442 };
443
444 static inline void tvp5150_selmux(struct i2c_client *c,
445                                   enum tvp5150_input input)
446 {
447         int opmode=0;
448
449         struct tvp5150 *decoder = i2c_get_clientdata(c);
450
451         if (!decoder->enable)
452                 input |= TVP5150_BLACK_SCREEN;
453
454         switch (input) {
455         case TVP5150_ANALOG_CH0:
456         case TVP5150_ANALOG_CH1:
457                 opmode=0x30;            /* TV Mode */
458                 break;
459         default:
460                 opmode=0;               /* Auto Mode */
461                 break;
462         }
463
464         tvp5150_write(c, TVP5150_OP_MODE_CTL, opmode);
465         tvp5150_write(c, TVP5150_VD_IN_SRC_SEL_1, input);
466 };
467
468 struct i2c_reg_value {
469         unsigned char reg;
470         unsigned char value;
471 };
472
473 /* Default values as sugested at TVP5150AM1 datasheet */
474 static const struct i2c_reg_value tvp5150_init_default[] = {
475         { /* 0x00 */
476                 TVP5150_VD_IN_SRC_SEL_1,0x00
477         },
478         { /* 0x01 */
479                 TVP5150_ANAL_CHL_CTL,0x15
480         },
481         { /* 0x02 */
482                 TVP5150_OP_MODE_CTL,0x00
483         },
484         { /* 0x03 */
485                 TVP5150_MISC_CTL,0x01
486         },
487         { /* 0x06 */
488                 TVP5150_COLOR_KIL_THSH_CTL,0x10
489         },
490         { /* 0x07 */
491                 TVP5150_LUMA_PROC_CTL_1,0x60
492         },
493         { /* 0x08 */
494                 TVP5150_LUMA_PROC_CTL_2,0x00
495         },
496         { /* 0x09 */
497                 TVP5150_BRIGHT_CTL,0x80
498         },
499         { /* 0x0a */
500                 TVP5150_SATURATION_CTL,0x80
501         },
502         { /* 0x0b */
503                 TVP5150_HUE_CTL,0x00
504         },
505         { /* 0x0c */
506                 TVP5150_CONTRAST_CTL,0x80
507         },
508         { /* 0x0d */
509                 TVP5150_DATA_RATE_SEL,0x47
510         },
511         { /* 0x0e */
512                 TVP5150_LUMA_PROC_CTL_3,0x00
513         },
514         { /* 0x0f */
515                 TVP5150_CONF_SHARED_PIN,0x08
516         },
517         { /* 0x11 */
518                 TVP5150_ACT_VD_CROP_ST_MSB,0x00
519         },
520         { /* 0x12 */
521                 TVP5150_ACT_VD_CROP_ST_LSB,0x00
522         },
523         { /* 0x13 */
524                 TVP5150_ACT_VD_CROP_STP_MSB,0x00
525         },
526         { /* 0x14 */
527                 TVP5150_ACT_VD_CROP_STP_LSB,0x00
528         },
529         { /* 0x15 */
530                 TVP5150_GENLOCK,0x01
531         },
532         { /* 0x16 */
533                 TVP5150_HORIZ_SYNC_START,0x80
534         },
535         { /* 0x18 */
536                 TVP5150_VERT_BLANKING_START,0x00
537         },
538         { /* 0x19 */
539                 TVP5150_VERT_BLANKING_STOP,0x00
540         },
541         { /* 0x1a */
542                 TVP5150_CHROMA_PROC_CTL_1,0x0c
543         },
544         { /* 0x1b */
545                 TVP5150_CHROMA_PROC_CTL_2,0x14
546         },
547         { /* 0x1c */
548                 TVP5150_INT_RESET_REG_B,0x00
549         },
550         { /* 0x1d */
551                 TVP5150_INT_ENABLE_REG_B,0x00
552         },
553         { /* 0x1e */
554                 TVP5150_INTT_CONFIG_REG_B,0x00
555         },
556         { /* 0x28 */
557                 TVP5150_VIDEO_STD,0x00
558         },
559         { /* 0x2e */
560                 TVP5150_MACROVISION_ON_CTR,0x0f
561         },
562         { /* 0x2f */
563                 TVP5150_MACROVISION_OFF_CTR,0x01
564         },
565         { /* 0xbb */
566                 TVP5150_TELETEXT_FIL_ENA,0x00
567         },
568         { /* 0xc0 */
569                 TVP5150_INT_STATUS_REG_A,0x00
570         },
571         { /* 0xc1 */
572                 TVP5150_INT_ENABLE_REG_A,0x00
573         },
574         { /* 0xc2 */
575                 TVP5150_INT_CONF,0x04
576         },
577         { /* 0xc8 */
578                 TVP5150_FIFO_INT_THRESHOLD,0x80
579         },
580         { /* 0xc9 */
581                 TVP5150_FIFO_RESET,0x00
582         },
583         { /* 0xca */
584                 TVP5150_LINE_NUMBER_INT,0x00
585         },
586         { /* 0xcb */
587                 TVP5150_PIX_ALIGN_REG_LOW,0x4e
588         },
589         { /* 0xcc */
590                 TVP5150_PIX_ALIGN_REG_HIGH,0x00
591         },
592         { /* 0xcd */
593                 TVP5150_FIFO_OUT_CTRL,0x01
594         },
595         { /* 0xcf */
596                 TVP5150_FULL_FIELD_ENA_1,0x00
597         },
598         { /* 0xd0 */
599                 TVP5150_FULL_FIELD_ENA_2,0x00
600         },
601         { /* 0xfc */
602                 TVP5150_FULL_FIELD_MODE_REG,0x7f
603         },
604         { /* end of data */
605                 0xff,0xff
606         }
607 };
608
609 /* Default values as sugested at TVP5150AM1 datasheet */
610 static const struct i2c_reg_value tvp5150_init_enable[] = {
611         {
612                 TVP5150_CONF_SHARED_PIN, 2
613         },{     /* Automatic offset and AGC enabled */
614                 TVP5150_ANAL_CHL_CTL, 0x15
615         },{     /* Activate YCrCb output 0x9 or 0xd ? */
616                 TVP5150_MISC_CTL, 0x6f
617         },{     /* Activates video std autodetection for all standards */
618                 TVP5150_AUTOSW_MSK, 0x0
619         },{     /* Default format: 0x47. For 4:2:2: 0x40 */
620                 TVP5150_DATA_RATE_SEL, 0x47
621         },{
622                 TVP5150_CHROMA_PROC_CTL_1, 0x0c
623         },{
624                 TVP5150_CHROMA_PROC_CTL_2, 0x54
625         },{     /* Non documented, but initialized on WinTV USB2 */
626                 0x27, 0x20
627         },{
628                 0xff,0xff
629         }
630 };
631
632 struct i2c_vbi_ram_value {
633         u16 reg;
634         unsigned char values[26];
635 };
636
637 static struct i2c_vbi_ram_value vbi_ram_default[] =
638 {
639         {0x010, /* WST SECAM 6 */
640                 { 0xaa, 0xaa, 0xff, 0xff , 0xe7, 0x2e, 0x20, 0x26, 0xe6, 0xb4, 0x0e, 0x0, 0x0, 0x0, 0x10, 0x0 }
641         },
642         {0x030, /* WST PAL B 6 */
643                 { 0xaa, 0xaa, 0xff, 0xff , 0x27, 0x2e, 0x20, 0x2b, 0xa6, 0x72, 0x10, 0x0, 0x0, 0x0, 0x10, 0x0 }
644         },
645         {0x050, /* WST PAL C 6 */
646                 { 0xaa, 0xaa, 0xff, 0xff , 0xe7, 0x2e, 0x20, 0x22, 0xa6, 0x98, 0x0d, 0x0, 0x0, 0x0, 0x10, 0x0 }
647         },
648         {0x070, /* WST NTSC 6 */
649                 { 0xaa, 0xaa, 0xff, 0xff , 0x27, 0x2e, 0x20, 0x23, 0x69, 0x93, 0x0d, 0x0, 0x0, 0x0, 0x10, 0x0 }
650         },
651         {0x090, /* NABTS, NTSC 6 */
652                 { 0xaa, 0xaa, 0xff, 0xff , 0xe7, 0x2e, 0x20, 0x22, 0x69, 0x93, 0x0d, 0x0, 0x0, 0x0, 0x15, 0x0 }
653         },
654         {0x0b0, /* NABTS, NTSC-J 6 */
655                 { 0xaa, 0xaa, 0xff, 0xff , 0xa7, 0x2e, 0x20, 0x23, 0x69, 0x93, 0x0d, 0x0, 0x0, 0x0, 0x10, 0x0 }
656         },
657         {0x0d0, /* CC, PAL/SECAM 6 */
658                 { 0xaa, 0x2a, 0xff, 0x3f , 0x04, 0x51, 0x6e, 0x02, 0xa6, 0x7b, 0x09, 0x0, 0x0, 0x0, 0x27, 0x0 }
659         },
660         {0x0f0, /* CC, NTSC 6 */
661                 { 0xaa, 0x2a, 0xff, 0x3f , 0x04, 0x51, 0x6e, 0x02, 0x69, 0x8c, 0x09, 0x0, 0x0, 0x0, 0x27, 0x0 }
662         },
663         {0x110, /* WSS, PAL/SECAM 6 */
664                 { 0x5b, 0x55, 0xc5, 0xff , 0x0, 0x71, 0x6e, 0x42, 0xa6, 0xcd, 0x0f, 0x0, 0x0, 0x0, 0x3a, 0x0 }
665         },
666         {0x130, /* WSS, NTSC C */
667                 { 0x38, 0x00, 0x3f, 0x00 , 0x0, 0x71, 0x6e, 0x43, 0x69, 0x7c, 0x08, 0x0, 0x0, 0x0, 0x39, 0x0 }
668         },
669         {0x150, /* VITC, PAL/SECAM 6 */
670                 { 0x0, 0x0, 0x0, 0x0 , 0x0, 0x8f, 0x6d, 0x49, 0xa6, 0x85, 0x08, 0x0, 0x0, 0x0, 0x4c, 0x0 }
671         },
672         {0x170, /* VITC, NTSC 6 */
673                 { 0x0, 0x0, 0x0, 0x0 , 0x0, 0x8f, 0x6d, 0x49, 0x69, 0x94, 0x08, 0x0, 0x0, 0x0, 0x4c, 0x0 }
674         },
675         { (u16)-1 }
676 };
677
678 static int tvp5150_write_inittab(struct i2c_client *c,
679                                  const struct i2c_reg_value *regs)
680 {
681         while (regs->reg != 0xff) {
682                 tvp5150_write(c, regs->reg, regs->value);
683                 regs++;
684         }
685         return 0;
686 }
687
688 static int tvp5150_vdp_init(struct i2c_client *c,
689                                  const struct i2c_vbi_ram_value *regs)
690 {
691         unsigned int i;
692
693         /* Disable Full Field */
694         tvp5150_write(c, TVP5150_FULL_FIELD_ENA_1, 0);
695
696         /* Before programming, Line mode should be at 0xff */
697         for (i=TVP5150_FULL_FIELD_ENA_2; i<=TVP5150_LINE_MODE_REG_44; i++)
698                 tvp5150_write(c, i, 0xff);
699
700         /* Load Ram Table */
701         while (regs->reg != (u16)-1 ) {
702                 tvp5150_write(c, TVP5150_CONF_RAM_ADDR_HIGH,regs->reg>>8);
703                 tvp5150_write(c, TVP5150_CONF_RAM_ADDR_LOW,regs->reg);
704
705                 for (i=0;i<16;i++)
706                         tvp5150_write(c, TVP5150_VDP_CONF_RAM_DATA,regs->values[i]);
707
708                 regs++;
709         }
710         return 0;
711 }
712
713 static int tvp5150_set_std(struct i2c_client *c, v4l2_std_id std)
714 {
715         struct tvp5150 *decoder = i2c_get_clientdata(c);
716         int fmt=0;
717
718         decoder->norm=std;
719
720         /* First tests should be against specific std */
721
722         if (std == V4L2_STD_ALL) {
723                 fmt=0;  /* Autodetect mode */
724         } else if (std & V4L2_STD_NTSC_443) {
725                 fmt=0xa;
726         } else if (std & V4L2_STD_PAL_M) {
727                 fmt=0x6;
728         } else if (std & (V4L2_STD_PAL_N| V4L2_STD_PAL_Nc)) {
729                 fmt=0x8;
730         } else {
731                 /* Then, test against generic ones */
732                 if (std & V4L2_STD_NTSC) {
733                         fmt=0x2;
734                 } else if (std & V4L2_STD_PAL) {
735                         fmt=0x4;
736                 } else if (std & V4L2_STD_SECAM) {
737                         fmt=0xc;
738                 }
739         }
740
741         tvp5150_dbg(1,"Set video std register to %d.\n",fmt);
742         tvp5150_write(c, TVP5150_VIDEO_STD, fmt);
743
744         return 0;
745 }
746
747 static inline void tvp5150_reset(struct i2c_client *c)
748 {
749         u8 type, ver_656, msb_id, lsb_id, msb_rom, lsb_rom;
750         struct tvp5150 *decoder = i2c_get_clientdata(c);
751
752         type=tvp5150_read(c,TVP5150_AUTOSW_MSK);
753         msb_id=tvp5150_read(c,TVP5150_MSB_DEV_ID);
754         lsb_id=tvp5150_read(c,TVP5150_LSB_DEV_ID);
755         msb_rom=tvp5150_read(c,TVP5150_ROM_MAJOR_VER);
756         lsb_rom=tvp5150_read(c,TVP5150_ROM_MINOR_VER);
757
758         if (type==0xdc) {
759                 ver_656=tvp5150_read(c,TVP5150_REV_SELECT);
760                 tvp5150_info("tvp%02x%02xam1 detected 656 version is %d.\n",msb_id, lsb_id,ver_656);
761         } else if (type==0xfc) {
762                 tvp5150_info("tvp%02x%02xa detected.\n",msb_id, lsb_id);
763         } else {
764                 tvp5150_info("unknown tvp%02x%02x chip detected(%d).\n",msb_id,lsb_id,type);
765         }
766         tvp5150_info("Rom ver is %d.%d\n",msb_rom,lsb_rom);
767
768         /* Initializes TVP5150 to its default values */
769         tvp5150_write_inittab(c, tvp5150_init_default);
770
771         /* Initializes VDP registers */
772         tvp5150_vdp_init(c, vbi_ram_default);
773
774         /* Selects decoder input */
775         tvp5150_selmux(c, decoder->input);
776
777         /* Initializes TVP5150 to stream enabled values */
778         tvp5150_write_inittab(c, tvp5150_init_enable);
779
780         /* Initialize image preferences */
781         tvp5150_write(c, TVP5150_BRIGHT_CTL, decoder->bright >> 8);
782         tvp5150_write(c, TVP5150_CONTRAST_CTL, decoder->contrast >> 8);
783         tvp5150_write(c, TVP5150_SATURATION_CTL, decoder->contrast >> 8);
784         tvp5150_write(c, TVP5150_HUE_CTL, (decoder->hue - 32768) >> 8);
785
786         tvp5150_set_std(c, decoder->norm);
787 };
788
789 static int tvp5150_get_ctrl(struct i2c_client *c, struct v4l2_control *ctrl)
790 {
791 /*      struct tvp5150 *decoder = i2c_get_clientdata(c); */
792
793         switch (ctrl->id) {
794         case V4L2_CID_BRIGHTNESS:
795                 ctrl->value = tvp5150_read(c, TVP5150_BRIGHT_CTL);
796                 return 0;
797         case V4L2_CID_CONTRAST:
798                 ctrl->value = tvp5150_read(c, TVP5150_CONTRAST_CTL);
799                 return 0;
800         case V4L2_CID_SATURATION:
801                 ctrl->value = tvp5150_read(c, TVP5150_SATURATION_CTL);
802                 return 0;
803         case V4L2_CID_HUE:
804                 ctrl->value = tvp5150_read(c, TVP5150_HUE_CTL);
805                 return 0;
806         }
807         return -EINVAL;
808 }
809
810 static int tvp5150_set_ctrl(struct i2c_client *c, struct v4l2_control *ctrl)
811 {
812 /*      struct tvp5150 *decoder = i2c_get_clientdata(c); */
813
814         switch (ctrl->id) {
815         case V4L2_CID_BRIGHTNESS:
816                 tvp5150_write(c, TVP5150_BRIGHT_CTL, ctrl->value);
817                 return 0;
818         case V4L2_CID_CONTRAST:
819                 tvp5150_write(c, TVP5150_CONTRAST_CTL, ctrl->value);
820                 return 0;
821         case V4L2_CID_SATURATION:
822                 tvp5150_write(c, TVP5150_SATURATION_CTL, ctrl->value);
823                 return 0;
824         case V4L2_CID_HUE:
825                 tvp5150_write(c, TVP5150_HUE_CTL, ctrl->value);
826                 return 0;
827         }
828         return -EINVAL;
829 }
830
831 /****************************************************************************
832                         I2C Command
833  ****************************************************************************/
834 static int tvp5150_command(struct i2c_client *c,
835                            unsigned int cmd, void *arg)
836 {
837         struct tvp5150 *decoder = i2c_get_clientdata(c);
838
839         switch (cmd) {
840
841         case 0:
842         case VIDIOC_INT_RESET:
843         case DECODER_INIT:
844                 tvp5150_reset(c);
845                 break;
846         case VIDIOC_S_STD:
847                 if (decoder->norm == *(v4l2_std_id *)arg)
848                         break;
849                 return tvp5150_set_std(c, *(v4l2_std_id *)arg);
850         case VIDIOC_G_STD:
851                 *(v4l2_std_id *)arg = decoder->norm;
852                 break;
853
854 #ifdef CONFIG_VIDEO_ADV_DEBUG
855         case VIDIOC_INT_G_REGISTER:
856         {
857                 struct v4l2_register *reg = arg;
858
859                 if (reg->i2c_id != I2C_DRIVERID_TVP5150)
860                         return -EINVAL;
861                 reg->val = tvp5150_read(c, reg->reg & 0xff);
862                 break;
863         }
864
865         case VIDIOC_INT_S_REGISTER:
866         {
867                 struct v4l2_register *reg = arg;
868
869                 if (reg->i2c_id != I2C_DRIVERID_TVP5150)
870                         return -EINVAL;
871                 if (!capable(CAP_SYS_ADMIN))
872                         return -EPERM;
873                 tvp5150_write(c, reg->reg & 0xff, reg->val & 0xff);
874                 break;
875         }
876 #endif
877
878         case DECODER_DUMP:
879                 dump_reg(c);
880                 break;
881
882         case DECODER_GET_CAPABILITIES:
883                 {
884                         struct video_decoder_capability *cap = arg;
885
886                         cap->flags = VIDEO_DECODER_PAL |
887                             VIDEO_DECODER_NTSC |
888                             VIDEO_DECODER_SECAM |
889                             VIDEO_DECODER_AUTO | VIDEO_DECODER_CCIR;
890                         cap->inputs = 3;
891                         cap->outputs = 1;
892                         break;
893                 }
894         case DECODER_GET_STATUS:
895                 {
896                         break;
897                 }
898
899         case DECODER_SET_GPIO:
900                 break;
901
902         case DECODER_SET_VBI_BYPASS:
903                 break;
904
905         case DECODER_SET_NORM:
906                 {
907                         int *iarg = arg;
908
909                         switch (*iarg) {
910
911                         case VIDEO_MODE_NTSC:
912                                 break;
913
914                         case VIDEO_MODE_PAL:
915                                 break;
916
917                         case VIDEO_MODE_SECAM:
918                                 break;
919
920                         case VIDEO_MODE_AUTO:
921                                 break;
922
923                         default:
924                                 return -EINVAL;
925
926                         }
927                         decoder->norm = *iarg;
928                         break;
929                 }
930         case DECODER_SET_INPUT:
931                 {
932                         int *iarg = arg;
933                         if (*iarg < 0 || *iarg > 3) {
934                                 return -EINVAL;
935                         }
936
937                         decoder->input = *iarg;
938                         tvp5150_selmux(c, decoder->input);
939
940                         break;
941                 }
942         case DECODER_SET_OUTPUT:
943                 {
944                         int *iarg = arg;
945
946                         /* not much choice of outputs */
947                         if (*iarg != 0) {
948                                 return -EINVAL;
949                         }
950                         break;
951                 }
952         case DECODER_ENABLE_OUTPUT:
953                 {
954                         int *iarg = arg;
955
956                         decoder->enable = (*iarg != 0);
957
958                         tvp5150_selmux(c, decoder->input);
959
960                         break;
961                 }
962         case VIDIOC_QUERYCTRL:
963                 {
964                         struct v4l2_queryctrl *qc = arg;
965                         int i;
966
967                         tvp5150_dbg(1, "VIDIOC_QUERYCTRL called\n");
968
969                         for (i = 0; i < ARRAY_SIZE(tvp5150_qctrl); i++)
970                                 if (qc->id && qc->id == tvp5150_qctrl[i].id) {
971                                         memcpy(qc, &(tvp5150_qctrl[i]),
972                                                sizeof(*qc));
973                                         return 0;
974                                 }
975
976                         return -EINVAL;
977                 }
978         case VIDIOC_G_CTRL:
979                 {
980                         struct v4l2_control *ctrl = arg;
981                         tvp5150_dbg(1, "VIDIOC_G_CTRL called\n");
982
983                         return tvp5150_get_ctrl(c, ctrl);
984                 }
985         case VIDIOC_S_CTRL:
986                 {
987                         struct v4l2_control *ctrl = arg;
988                         u8 i, n;
989                         n = sizeof(tvp5150_qctrl) / sizeof(tvp5150_qctrl[0]);
990                         for (i = 0; i < n; i++)
991                                 if (ctrl->id == tvp5150_qctrl[i].id) {
992                                         if (ctrl->value <
993                                             tvp5150_qctrl[i].minimum
994                                             || ctrl->value >
995                                             tvp5150_qctrl[i].maximum)
996                                                 return -ERANGE;
997                                         tvp5150_dbg(1,
998                                                 "VIDIOC_S_CTRL: id=%d, value=%d\n",
999                                                 ctrl->id, ctrl->value);
1000                                         return tvp5150_set_ctrl(c, ctrl);
1001                                 }
1002                         return -EINVAL;
1003                 }
1004
1005         case DECODER_SET_PICTURE:
1006                 {
1007                         struct video_picture *pic = arg;
1008                         if (decoder->bright != pic->brightness) {
1009                                 /* We want 0 to 255 we get 0-65535 */
1010                                 decoder->bright = pic->brightness;
1011                                 tvp5150_write(c, TVP5150_BRIGHT_CTL,
1012                                               decoder->bright >> 8);
1013                         }
1014                         if (decoder->contrast != pic->contrast) {
1015                                 /* We want 0 to 255 we get 0-65535 */
1016                                 decoder->contrast = pic->contrast;
1017                                 tvp5150_write(c, TVP5150_CONTRAST_CTL,
1018                                               decoder->contrast >> 8);
1019                         }
1020                         if (decoder->sat != pic->colour) {
1021                                 /* We want 0 to 255 we get 0-65535 */
1022                                 decoder->sat = pic->colour;
1023                                 tvp5150_write(c, TVP5150_SATURATION_CTL,
1024                                               decoder->contrast >> 8);
1025                         }
1026                         if (decoder->hue != pic->hue) {
1027                                 /* We want -128 to 127 we get 0-65535 */
1028                                 decoder->hue = pic->hue;
1029                                 tvp5150_write(c, TVP5150_HUE_CTL,
1030                                               (decoder->hue - 32768) >> 8);
1031                         }
1032                         break;
1033                 }
1034         default:
1035                 return -EINVAL;
1036         }
1037
1038         return 0;
1039 }
1040
1041 /****************************************************************************
1042                         I2C Client & Driver
1043  ****************************************************************************/
1044 static struct i2c_driver driver;
1045
1046 static struct i2c_client client_template = {
1047         .name = "(unset)",
1048         .driver = &driver,
1049 };
1050
1051 static int tvp5150_detect_client(struct i2c_adapter *adapter,
1052                                  int address, int kind)
1053 {
1054         struct i2c_client *c;
1055         struct tvp5150 *core;
1056         int rv;
1057
1058         if (debug)
1059                 printk( KERN_INFO
1060                 "tvp5150.c: detecting tvp5150 client on address 0x%x\n",
1061                 address << 1);
1062
1063         client_template.adapter = adapter;
1064         client_template.addr = address;
1065
1066         /* Check if the adapter supports the needed features */
1067         if (!i2c_check_functionality
1068             (adapter,
1069              I2C_FUNC_SMBUS_READ_BYTE | I2C_FUNC_SMBUS_WRITE_BYTE_DATA))
1070                 return 0;
1071
1072         c = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
1073         if (c == 0)
1074                 return -ENOMEM;
1075         memcpy(c, &client_template, sizeof(struct i2c_client));
1076
1077         core = kzalloc(sizeof(struct tvp5150), GFP_KERNEL);
1078         if (core == 0) {
1079                 kfree(c);
1080                 return -ENOMEM;
1081         }
1082         i2c_set_clientdata(c, core);
1083
1084         rv = i2c_attach_client(c);
1085
1086         core->norm = V4L2_STD_ALL;
1087         core->input = 2;
1088         core->enable = 1;
1089         core->bright = 32768;
1090         core->contrast = 32768;
1091         core->hue = 32768;
1092         core->sat = 32768;
1093
1094         if (rv) {
1095                 kfree(c);
1096                 kfree(core);
1097                 return rv;
1098         }
1099
1100         if (debug > 1)
1101                 dump_reg(c);
1102         return 0;
1103 }
1104
1105 static int tvp5150_attach_adapter(struct i2c_adapter *adapter)
1106 {
1107         if (debug)
1108                 printk( KERN_INFO
1109                 "tvp5150.c: starting probe for adapter %s (0x%x)\n",
1110                 adapter->name, adapter->id);
1111         return i2c_probe(adapter, &addr_data, &tvp5150_detect_client);
1112 }
1113
1114 static int tvp5150_detach_client(struct i2c_client *c)
1115 {
1116         struct tvp5150 *decoder = i2c_get_clientdata(c);
1117         int err;
1118
1119         tvp5150_dbg(1,
1120                 "tvp5150.c: removing tvp5150 adapter on address 0x%x\n",
1121                 c->addr << 1);
1122
1123         err = i2c_detach_client(c);
1124         if (err) {
1125                 return err;
1126         }
1127
1128         kfree(decoder);
1129         kfree(c);
1130
1131         return 0;
1132 }
1133
1134 /* ----------------------------------------------------------------------- */
1135
1136 static struct i2c_driver driver = {
1137         .driver = {
1138                 .name = "tvp5150",
1139         },
1140         .id = I2C_DRIVERID_TVP5150,
1141
1142         .attach_adapter = tvp5150_attach_adapter,
1143         .detach_client = tvp5150_detach_client,
1144
1145         .command = tvp5150_command,
1146 };
1147
1148 static int __init tvp5150_init(void)
1149 {
1150         return i2c_add_driver(&driver);
1151 }
1152
1153 static void __exit tvp5150_exit(void)
1154 {
1155         i2c_del_driver(&driver);
1156 }
1157
1158 module_init(tvp5150_init);
1159 module_exit(tvp5150_exit);