Merge branch 'linux-next' of git://git.kernel.org/pub/scm/linux/kernel/git/jbarnes...
[linux-2.6] / drivers / media / video / cx25840 / cx25840-core.c
1 /* cx25840 - Conexant CX25840 audio/video decoder driver
2  *
3  * Copyright (C) 2004 Ulf Eklund
4  *
5  * Based on the saa7115 driver and on the first verison of Chris Kennedy's
6  * cx25840 driver.
7  *
8  * Changes by Tyler Trafford <tatrafford@comcast.net>
9  *    - cleanup/rewrite for V4L2 API (2005)
10  *
11  * VBI support by Hans Verkuil <hverkuil@xs4all.nl>.
12  *
13  * NTSC sliced VBI support by Christopher Neufeld <television@cneufeld.ca>
14  * with additional fixes by Hans Verkuil <hverkuil@xs4all.nl>.
15  *
16  * CX23885 support by Steven Toth <stoth@linuxtv.org>.
17  *
18  * This program is free software; you can redistribute it and/or
19  * modify it under the terms of the GNU General Public License
20  * as published by the Free Software Foundation; either version 2
21  * of the License, or (at your option) any later version.
22  *
23  * This program is distributed in the hope that it will be useful,
24  * but WITHOUT ANY WARRANTY; without even the implied warranty of
25  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
26  * GNU General Public License for more details.
27  *
28  * You should have received a copy of the GNU General Public License
29  * along with this program; if not, write to the Free Software
30  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
31  */
32
33
34 #include <linux/kernel.h>
35 #include <linux/module.h>
36 #include <linux/slab.h>
37 #include <linux/videodev2.h>
38 #include <linux/i2c.h>
39 #include <linux/delay.h>
40 #include <media/v4l2-common.h>
41 #include <media/v4l2-chip-ident.h>
42 #include <media/v4l2-i2c-drv.h>
43 #include <media/cx25840.h>
44
45 #include "cx25840-core.h"
46
47 MODULE_DESCRIPTION("Conexant CX25840 audio/video decoder driver");
48 MODULE_AUTHOR("Ulf Eklund, Chris Kennedy, Hans Verkuil, Tyler Trafford");
49 MODULE_LICENSE("GPL");
50
51 static int cx25840_debug;
52
53 module_param_named(debug,cx25840_debug, int, 0644);
54
55 MODULE_PARM_DESC(debug, "Debugging messages [0=Off (default) 1=On]");
56
57
58 /* ----------------------------------------------------------------------- */
59
60 int cx25840_write(struct i2c_client *client, u16 addr, u8 value)
61 {
62         u8 buffer[3];
63         buffer[0] = addr >> 8;
64         buffer[1] = addr & 0xff;
65         buffer[2] = value;
66         return i2c_master_send(client, buffer, 3);
67 }
68
69 int cx25840_write4(struct i2c_client *client, u16 addr, u32 value)
70 {
71         u8 buffer[6];
72         buffer[0] = addr >> 8;
73         buffer[1] = addr & 0xff;
74         buffer[2] = value & 0xff;
75         buffer[3] = (value >> 8) & 0xff;
76         buffer[4] = (value >> 16) & 0xff;
77         buffer[5] = value >> 24;
78         return i2c_master_send(client, buffer, 6);
79 }
80
81 u8 cx25840_read(struct i2c_client * client, u16 addr)
82 {
83         u8 buffer[2];
84         buffer[0] = addr >> 8;
85         buffer[1] = addr & 0xff;
86
87         if (i2c_master_send(client, buffer, 2) < 2)
88                 return 0;
89
90         if (i2c_master_recv(client, buffer, 1) < 1)
91                 return 0;
92
93         return buffer[0];
94 }
95
96 u32 cx25840_read4(struct i2c_client * client, u16 addr)
97 {
98         u8 buffer[4];
99         buffer[0] = addr >> 8;
100         buffer[1] = addr & 0xff;
101
102         if (i2c_master_send(client, buffer, 2) < 2)
103                 return 0;
104
105         if (i2c_master_recv(client, buffer, 4) < 4)
106                 return 0;
107
108         return (buffer[3] << 24) | (buffer[2] << 16) |
109             (buffer[1] << 8) | buffer[0];
110 }
111
112 int cx25840_and_or(struct i2c_client *client, u16 addr, unsigned and_mask,
113                    u8 or_value)
114 {
115         return cx25840_write(client, addr,
116                              (cx25840_read(client, addr) & and_mask) |
117                              or_value);
118 }
119
120 /* ----------------------------------------------------------------------- */
121
122 static int set_input(struct i2c_client *client, enum cx25840_video_input vid_input,
123                                                 enum cx25840_audio_input aud_input);
124
125 /* ----------------------------------------------------------------------- */
126
127 static void init_dll1(struct i2c_client *client)
128 {
129         /* This is the Hauppauge sequence used to
130          * initialize the Delay Lock Loop 1 (ADC DLL). */
131         cx25840_write(client, 0x159, 0x23);
132         cx25840_write(client, 0x15a, 0x87);
133         cx25840_write(client, 0x15b, 0x06);
134         udelay(10);
135         cx25840_write(client, 0x159, 0xe1);
136         udelay(10);
137         cx25840_write(client, 0x15a, 0x86);
138         cx25840_write(client, 0x159, 0xe0);
139         cx25840_write(client, 0x159, 0xe1);
140         cx25840_write(client, 0x15b, 0x10);
141 }
142
143 static void init_dll2(struct i2c_client *client)
144 {
145         /* This is the Hauppauge sequence used to
146          * initialize the Delay Lock Loop 2 (ADC DLL). */
147         cx25840_write(client, 0x15d, 0xe3);
148         cx25840_write(client, 0x15e, 0x86);
149         cx25840_write(client, 0x15f, 0x06);
150         udelay(10);
151         cx25840_write(client, 0x15d, 0xe1);
152         cx25840_write(client, 0x15d, 0xe0);
153         cx25840_write(client, 0x15d, 0xe1);
154 }
155
156 static void cx25836_initialize(struct i2c_client *client)
157 {
158         /* reset configuration is described on page 3-77 of the CX25836 datasheet */
159         /* 2. */
160         cx25840_and_or(client, 0x000, ~0x01, 0x01);
161         cx25840_and_or(client, 0x000, ~0x01, 0x00);
162         /* 3a. */
163         cx25840_and_or(client, 0x15a, ~0x70, 0x00);
164         /* 3b. */
165         cx25840_and_or(client, 0x15b, ~0x1e, 0x06);
166         /* 3c. */
167         cx25840_and_or(client, 0x159, ~0x02, 0x02);
168         /* 3d. */
169         udelay(10);
170         /* 3e. */
171         cx25840_and_or(client, 0x159, ~0x02, 0x00);
172         /* 3f. */
173         cx25840_and_or(client, 0x159, ~0xc0, 0xc0);
174         /* 3g. */
175         cx25840_and_or(client, 0x159, ~0x01, 0x00);
176         cx25840_and_or(client, 0x159, ~0x01, 0x01);
177         /* 3h. */
178         cx25840_and_or(client, 0x15b, ~0x1e, 0x10);
179 }
180
181 static void cx25840_work_handler(struct work_struct *work)
182 {
183         struct cx25840_state *state = container_of(work, struct cx25840_state, fw_work);
184         cx25840_loadfw(state->c);
185         wake_up(&state->fw_wait);
186 }
187
188 static void cx25840_initialize(struct i2c_client *client)
189 {
190         DEFINE_WAIT(wait);
191         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
192         struct workqueue_struct *q;
193
194         /* datasheet startup in numbered steps, refer to page 3-77 */
195         /* 2. */
196         cx25840_and_or(client, 0x803, ~0x10, 0x00);
197         /* The default of this register should be 4, but I get 0 instead.
198          * Set this register to 4 manually. */
199         cx25840_write(client, 0x000, 0x04);
200         /* 3. */
201         init_dll1(client);
202         init_dll2(client);
203         cx25840_write(client, 0x136, 0x0a);
204         /* 4. */
205         cx25840_write(client, 0x13c, 0x01);
206         cx25840_write(client, 0x13c, 0x00);
207         /* 5. */
208         /* Do the firmware load in a work handler to prevent.
209            Otherwise the kernel is blocked waiting for the
210            bit-banging i2c interface to finish uploading the
211            firmware. */
212         INIT_WORK(&state->fw_work, cx25840_work_handler);
213         init_waitqueue_head(&state->fw_wait);
214         q = create_singlethread_workqueue("cx25840_fw");
215         prepare_to_wait(&state->fw_wait, &wait, TASK_UNINTERRUPTIBLE);
216         queue_work(q, &state->fw_work);
217         schedule();
218         finish_wait(&state->fw_wait, &wait);
219         destroy_workqueue(q);
220
221         /* 6. */
222         cx25840_write(client, 0x115, 0x8c);
223         cx25840_write(client, 0x116, 0x07);
224         cx25840_write(client, 0x118, 0x02);
225         /* 7. */
226         cx25840_write(client, 0x4a5, 0x80);
227         cx25840_write(client, 0x4a5, 0x00);
228         cx25840_write(client, 0x402, 0x00);
229         /* 8. */
230         cx25840_and_or(client, 0x401, ~0x18, 0);
231         cx25840_and_or(client, 0x4a2, ~0x10, 0x10);
232         /* steps 8c and 8d are done in change_input() */
233         /* 10. */
234         cx25840_write(client, 0x8d3, 0x1f);
235         cx25840_write(client, 0x8e3, 0x03);
236
237         cx25840_std_setup(client);
238
239         /* trial and error says these are needed to get audio */
240         cx25840_write(client, 0x914, 0xa0);
241         cx25840_write(client, 0x918, 0xa0);
242         cx25840_write(client, 0x919, 0x01);
243
244         /* stereo prefered */
245         cx25840_write(client, 0x809, 0x04);
246         /* AC97 shift */
247         cx25840_write(client, 0x8cf, 0x0f);
248
249         /* (re)set input */
250         set_input(client, state->vid_input, state->aud_input);
251
252         /* start microcontroller */
253         cx25840_and_or(client, 0x803, ~0x10, 0x10);
254 }
255
256 static void cx23885_initialize(struct i2c_client *client)
257 {
258         DEFINE_WAIT(wait);
259         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
260         struct workqueue_struct *q;
261
262         /* Internal Reset */
263         cx25840_and_or(client, 0x102, ~0x01, 0x01);
264         cx25840_and_or(client, 0x102, ~0x01, 0x00);
265
266         /* Stop microcontroller */
267         cx25840_and_or(client, 0x803, ~0x10, 0x00);
268
269         /* DIF in reset? */
270         cx25840_write(client, 0x398, 0);
271
272         /* Trust the default xtal, no division */
273         /* This changes for the cx23888 products */
274         cx25840_write(client, 0x2, 0x76);
275
276         /* Bring down the regulator for AUX clk */
277         cx25840_write(client, 0x1, 0x40);
278
279         /* Sys PLL frac */
280         cx25840_write4(client, 0x11c, 0x01d1744c);
281
282         /* Sys PLL int */
283         cx25840_write4(client, 0x118, 0x00000416);
284
285         /* Disable DIF bypass */
286         cx25840_write4(client, 0x33c, 0x00000001);
287
288         /* DIF Src phase inc */
289         cx25840_write4(client, 0x340, 0x0df7df83);
290
291         /* Vid PLL frac */
292         cx25840_write4(client, 0x10c, 0x01b6db7b);
293
294         /* Vid PLL int */
295         cx25840_write4(client, 0x108, 0x00000512);
296
297         /* Luma */
298         cx25840_write4(client, 0x414, 0x00107d12);
299
300         /* Chroma */
301         cx25840_write4(client, 0x420, 0x3d008282);
302
303         /* Aux PLL frac */
304         cx25840_write4(client, 0x114, 0x017dbf48);
305
306         /* Aux PLL int */
307         cx25840_write4(client, 0x110, 0x000a030e);
308
309         /* ADC2 input select */
310         cx25840_write(client, 0x102, 0x10);
311
312         /* VIN1 & VIN5 */
313         cx25840_write(client, 0x103, 0x11);
314
315         /* Enable format auto detect */
316         cx25840_write(client, 0x400, 0);
317         /* Fast subchroma lock */
318         /* White crush, Chroma AGC & Chroma Killer enabled */
319         cx25840_write(client, 0x401, 0xe8);
320
321         /* Select AFE clock pad output source */
322         cx25840_write(client, 0x144, 0x05);
323
324         /* Do the firmware load in a work handler to prevent.
325            Otherwise the kernel is blocked waiting for the
326            bit-banging i2c interface to finish uploading the
327            firmware. */
328         INIT_WORK(&state->fw_work, cx25840_work_handler);
329         init_waitqueue_head(&state->fw_wait);
330         q = create_singlethread_workqueue("cx25840_fw");
331         prepare_to_wait(&state->fw_wait, &wait, TASK_UNINTERRUPTIBLE);
332         queue_work(q, &state->fw_work);
333         schedule();
334         finish_wait(&state->fw_wait, &wait);
335         destroy_workqueue(q);
336
337         cx25840_std_setup(client);
338
339         /* (re)set input */
340         set_input(client, state->vid_input, state->aud_input);
341
342         /* start microcontroller */
343         cx25840_and_or(client, 0x803, ~0x10, 0x10);
344 }
345
346 /* ----------------------------------------------------------------------- */
347
348 void cx25840_std_setup(struct i2c_client *client)
349 {
350         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
351         v4l2_std_id std = state->std;
352         int hblank, hactive, burst, vblank, vactive, sc;
353         int vblank656, src_decimation;
354         int luma_lpf, uv_lpf, comb;
355         u32 pll_int, pll_frac, pll_post;
356
357         /* datasheet startup, step 8d */
358         if (std & ~V4L2_STD_NTSC)
359                 cx25840_write(client, 0x49f, 0x11);
360         else
361                 cx25840_write(client, 0x49f, 0x14);
362
363         if (std & V4L2_STD_625_50) {
364                 hblank = 132;
365                 hactive = 720;
366                 burst = 93;
367                 vblank = 36;
368                 vactive = 580;
369                 vblank656 = 40;
370                 src_decimation = 0x21f;
371                 luma_lpf = 2;
372
373                 if (std & V4L2_STD_SECAM) {
374                         uv_lpf = 0;
375                         comb = 0;
376                         sc = 0x0a425f;
377                 } else if (std == V4L2_STD_PAL_Nc) {
378                         uv_lpf = 1;
379                         comb = 0x20;
380                         sc = 556453;
381                 } else {
382                         uv_lpf = 1;
383                         comb = 0x20;
384                         sc = 688739;
385                 }
386         } else {
387                 hactive = 720;
388                 hblank = 122;
389                 vactive = 487;
390                 luma_lpf = 1;
391                 uv_lpf = 1;
392
393                 src_decimation = 0x21f;
394                 if (std == V4L2_STD_PAL_60) {
395                         vblank = 26;
396                         vblank656 = 26;
397                         burst = 0x5b;
398                         luma_lpf = 2;
399                         comb = 0x20;
400                         sc = 688739;
401                 } else if (std == V4L2_STD_PAL_M) {
402                         vblank = 20;
403                         vblank656 = 24;
404                         burst = 0x61;
405                         comb = 0x20;
406                         sc = 555452;
407                 } else {
408                         vblank = 26;
409                         vblank656 = 26;
410                         burst = 0x5b;
411                         comb = 0x66;
412                         sc = 556063;
413                 }
414         }
415
416         /* DEBUG: Displays configured PLL frequency */
417         pll_int = cx25840_read(client, 0x108);
418         pll_frac = cx25840_read4(client, 0x10c) & 0x1ffffff;
419         pll_post = cx25840_read(client, 0x109);
420         v4l_dbg(1, cx25840_debug, client,
421                                 "PLL regs = int: %u, frac: %u, post: %u\n",
422                                 pll_int, pll_frac, pll_post);
423
424         if (pll_post) {
425                 int fin, fsc;
426                 int pll = (28636363L * ((((u64)pll_int) << 25L) + pll_frac)) >> 25L;
427
428                 pll /= pll_post;
429                 v4l_dbg(1, cx25840_debug, client, "PLL = %d.%06d MHz\n",
430                                 pll / 1000000, pll % 1000000);
431                 v4l_dbg(1, cx25840_debug, client, "PLL/8 = %d.%06d MHz\n",
432                                 pll / 8000000, (pll / 8) % 1000000);
433
434                 fin = ((u64)src_decimation * pll) >> 12;
435                 v4l_dbg(1, cx25840_debug, client,
436                                 "ADC Sampling freq = %d.%06d MHz\n",
437                                 fin / 1000000, fin % 1000000);
438
439                 fsc = (((u64)sc) * pll) >> 24L;
440                 v4l_dbg(1, cx25840_debug, client,
441                                 "Chroma sub-carrier freq = %d.%06d MHz\n",
442                                 fsc / 1000000, fsc % 1000000);
443
444                 v4l_dbg(1, cx25840_debug, client, "hblank %i, hactive %i, "
445                         "vblank %i, vactive %i, vblank656 %i, src_dec %i, "
446                         "burst 0x%02x, luma_lpf %i, uv_lpf %i, comb 0x%02x, "
447                         "sc 0x%06x\n",
448                         hblank, hactive, vblank, vactive, vblank656,
449                         src_decimation, burst, luma_lpf, uv_lpf, comb, sc);
450         }
451
452         /* Sets horizontal blanking delay and active lines */
453         cx25840_write(client, 0x470, hblank);
454         cx25840_write(client, 0x471,
455                         0xff & (((hblank >> 8) & 0x3) | (hactive << 4)));
456         cx25840_write(client, 0x472, hactive >> 4);
457
458         /* Sets burst gate delay */
459         cx25840_write(client, 0x473, burst);
460
461         /* Sets vertical blanking delay and active duration */
462         cx25840_write(client, 0x474, vblank);
463         cx25840_write(client, 0x475,
464                         0xff & (((vblank >> 8) & 0x3) | (vactive << 4)));
465         cx25840_write(client, 0x476, vactive >> 4);
466         cx25840_write(client, 0x477, vblank656);
467
468         /* Sets src decimation rate */
469         cx25840_write(client, 0x478, 0xff & src_decimation);
470         cx25840_write(client, 0x479, 0xff & (src_decimation >> 8));
471
472         /* Sets Luma and UV Low pass filters */
473         cx25840_write(client, 0x47a, luma_lpf << 6 | ((uv_lpf << 4) & 0x30));
474
475         /* Enables comb filters */
476         cx25840_write(client, 0x47b, comb);
477
478         /* Sets SC Step*/
479         cx25840_write(client, 0x47c, sc);
480         cx25840_write(client, 0x47d, 0xff & sc >> 8);
481         cx25840_write(client, 0x47e, 0xff & sc >> 16);
482
483         /* Sets VBI parameters */
484         if (std & V4L2_STD_625_50) {
485                 cx25840_write(client, 0x47f, 0x01);
486                 state->vbi_line_offset = 5;
487         } else {
488                 cx25840_write(client, 0x47f, 0x00);
489                 state->vbi_line_offset = 8;
490         }
491 }
492
493 /* ----------------------------------------------------------------------- */
494
495 static void input_change(struct i2c_client *client)
496 {
497         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
498         v4l2_std_id std = state->std;
499
500         /* Follow step 8c and 8d of section 3.16 in the cx25840 datasheet */
501         if (std & V4L2_STD_SECAM) {
502                 cx25840_write(client, 0x402, 0);
503         }
504         else {
505                 cx25840_write(client, 0x402, 0x04);
506                 cx25840_write(client, 0x49f, (std & V4L2_STD_NTSC) ? 0x14 : 0x11);
507         }
508         cx25840_and_or(client, 0x401, ~0x60, 0);
509         cx25840_and_or(client, 0x401, ~0x60, 0x60);
510         cx25840_and_or(client, 0x810, ~0x01, 1);
511
512         if (state->radio) {
513                 cx25840_write(client, 0x808, 0xf9);
514                 cx25840_write(client, 0x80b, 0x00);
515         }
516         else if (std & V4L2_STD_525_60) {
517                 /* Certain Hauppauge PVR150 models have a hardware bug
518                    that causes audio to drop out. For these models the
519                    audio standard must be set explicitly.
520                    To be precise: it affects cards with tuner models
521                    85, 99 and 112 (model numbers from tveeprom). */
522                 int hw_fix = state->pvr150_workaround;
523
524                 if (std == V4L2_STD_NTSC_M_JP) {
525                         /* Japan uses EIAJ audio standard */
526                         cx25840_write(client, 0x808, hw_fix ? 0x2f : 0xf7);
527                 } else if (std == V4L2_STD_NTSC_M_KR) {
528                         /* South Korea uses A2 audio standard */
529                         cx25840_write(client, 0x808, hw_fix ? 0x3f : 0xf8);
530                 } else {
531                         /* Others use the BTSC audio standard */
532                         cx25840_write(client, 0x808, hw_fix ? 0x1f : 0xf6);
533                 }
534                 cx25840_write(client, 0x80b, 0x00);
535         } else if (std & V4L2_STD_PAL) {
536                 /* Follow tuner change procedure for PAL */
537                 cx25840_write(client, 0x808, 0xff);
538                 cx25840_write(client, 0x80b, 0x10);
539         } else if (std & V4L2_STD_SECAM) {
540                 /* Select autodetect for SECAM */
541                 cx25840_write(client, 0x808, 0xff);
542                 cx25840_write(client, 0x80b, 0x10);
543         }
544
545         cx25840_and_or(client, 0x810, ~0x01, 0);
546 }
547
548 static int set_input(struct i2c_client *client, enum cx25840_video_input vid_input,
549                                                 enum cx25840_audio_input aud_input)
550 {
551         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
552         u8 is_composite = (vid_input >= CX25840_COMPOSITE1 &&
553                            vid_input <= CX25840_COMPOSITE8);
554         u8 reg;
555
556         v4l_dbg(1, cx25840_debug, client,
557                 "decoder set video input %d, audio input %d\n",
558                 vid_input, aud_input);
559
560         if (vid_input >= CX25840_VIN1_CH1) {
561                 v4l_dbg(1, cx25840_debug, client, "vid_input 0x%x\n",
562                         vid_input);
563                 reg = vid_input & 0xff;
564                 if ((vid_input & CX25840_SVIDEO_ON) == CX25840_SVIDEO_ON)
565                         is_composite = 0;
566                 else
567                         is_composite = 1;
568
569                 v4l_dbg(1, cx25840_debug, client, "mux cfg 0x%x comp=%d\n",
570                         reg, is_composite);
571         } else
572         if (is_composite) {
573                 reg = 0xf0 + (vid_input - CX25840_COMPOSITE1);
574         } else {
575                 int luma = vid_input & 0xf0;
576                 int chroma = vid_input & 0xf00;
577
578                 if ((vid_input & ~0xff0) ||
579                     luma < CX25840_SVIDEO_LUMA1 || luma > CX25840_SVIDEO_LUMA8 ||
580                     chroma < CX25840_SVIDEO_CHROMA4 || chroma > CX25840_SVIDEO_CHROMA8) {
581                         v4l_err(client, "0x%04x is not a valid video input!\n",
582                                 vid_input);
583                         return -EINVAL;
584                 }
585                 reg = 0xf0 + ((luma - CX25840_SVIDEO_LUMA1) >> 4);
586                 if (chroma >= CX25840_SVIDEO_CHROMA7) {
587                         reg &= 0x3f;
588                         reg |= (chroma - CX25840_SVIDEO_CHROMA7) >> 2;
589                 } else {
590                         reg &= 0xcf;
591                         reg |= (chroma - CX25840_SVIDEO_CHROMA4) >> 4;
592                 }
593         }
594
595         /* The caller has previously prepared the correct routing
596          * configuration in reg (for the cx23885) so we have no
597          * need to attempt to flip bits for earlier av decoders.
598          */
599         if (!state->is_cx23885) {
600                 switch (aud_input) {
601                 case CX25840_AUDIO_SERIAL:
602                         /* do nothing, use serial audio input */
603                         break;
604                 case CX25840_AUDIO4: reg &= ~0x30; break;
605                 case CX25840_AUDIO5: reg &= ~0x30; reg |= 0x10; break;
606                 case CX25840_AUDIO6: reg &= ~0x30; reg |= 0x20; break;
607                 case CX25840_AUDIO7: reg &= ~0xc0; break;
608                 case CX25840_AUDIO8: reg &= ~0xc0; reg |= 0x40; break;
609
610                 default:
611                         v4l_err(client, "0x%04x is not a valid audio input!\n",
612                                 aud_input);
613                         return -EINVAL;
614                 }
615         }
616
617         cx25840_write(client, 0x103, reg);
618
619         /* Set INPUT_MODE to Composite (0) or S-Video (1) */
620         cx25840_and_or(client, 0x401, ~0x6, is_composite ? 0 : 0x02);
621
622         if (!state->is_cx23885) {
623                 /* Set CH_SEL_ADC2 to 1 if input comes from CH3 */
624                 cx25840_and_or(client, 0x102, ~0x2, (reg & 0x80) == 0 ? 2 : 0);
625                 /* Set DUAL_MODE_ADC2 to 1 if input comes from both CH2&CH3 */
626                 if ((reg & 0xc0) != 0xc0 && (reg & 0x30) != 0x30)
627                         cx25840_and_or(client, 0x102, ~0x4, 4);
628                 else
629                         cx25840_and_or(client, 0x102, ~0x4, 0);
630         } else {
631                 if (is_composite)
632                         /* ADC2 input select channel 2 */
633                         cx25840_and_or(client, 0x102, ~0x2, 0);
634                 else
635                         /* ADC2 input select channel 3 */
636                         cx25840_and_or(client, 0x102, ~0x2, 2);
637         }
638
639         state->vid_input = vid_input;
640         state->aud_input = aud_input;
641         if (!state->is_cx25836) {
642                 cx25840_audio_set_path(client);
643                 input_change(client);
644         }
645
646         if (state->is_cx23885) {
647                 /* Audio channel 1 src : Parallel 1 */
648                 cx25840_write(client, 0x124, 0x03);
649
650                 /* Select AFE clock pad output source */
651                 cx25840_write(client, 0x144, 0x05);
652
653                 /* I2S_IN_CTL: I2S_IN_SONY_MODE, LEFT SAMPLE on WS=1 */
654                 cx25840_write(client, 0x914, 0xa0);
655
656                 /* I2S_OUT_CTL:
657                  * I2S_IN_SONY_MODE, LEFT SAMPLE on WS=1
658                  * I2S_OUT_MASTER_MODE = Master
659                  */
660                 cx25840_write(client, 0x918, 0xa0);
661                 cx25840_write(client, 0x919, 0x01);
662         }
663
664         return 0;
665 }
666
667 /* ----------------------------------------------------------------------- */
668
669 static int set_v4lstd(struct i2c_client *client)
670 {
671         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
672         u8 fmt = 0;     /* zero is autodetect */
673         u8 pal_m = 0;
674
675         /* First tests should be against specific std */
676         if (state->std == V4L2_STD_NTSC_M_JP) {
677                 fmt = 0x2;
678         } else if (state->std == V4L2_STD_NTSC_443) {
679                 fmt = 0x3;
680         } else if (state->std == V4L2_STD_PAL_M) {
681                 pal_m = 1;
682                 fmt = 0x5;
683         } else if (state->std == V4L2_STD_PAL_N) {
684                 fmt = 0x6;
685         } else if (state->std == V4L2_STD_PAL_Nc) {
686                 fmt = 0x7;
687         } else if (state->std == V4L2_STD_PAL_60) {
688                 fmt = 0x8;
689         } else {
690                 /* Then, test against generic ones */
691                 if (state->std & V4L2_STD_NTSC)
692                         fmt = 0x1;
693                 else if (state->std & V4L2_STD_PAL)
694                         fmt = 0x4;
695                 else if (state->std & V4L2_STD_SECAM)
696                         fmt = 0xc;
697         }
698
699         v4l_dbg(1, cx25840_debug, client, "changing video std to fmt %i\n",fmt);
700
701         /* Follow step 9 of section 3.16 in the cx25840 datasheet.
702            Without this PAL may display a vertical ghosting effect.
703            This happens for example with the Yuan MPC622. */
704         if (fmt >= 4 && fmt < 8) {
705                 /* Set format to NTSC-M */
706                 cx25840_and_or(client, 0x400, ~0xf, 1);
707                 /* Turn off LCOMB */
708                 cx25840_and_or(client, 0x47b, ~6, 0);
709         }
710         cx25840_and_or(client, 0x400, ~0xf, fmt);
711         cx25840_and_or(client, 0x403, ~0x3, pal_m);
712         cx25840_std_setup(client);
713         if (!state->is_cx25836)
714                 input_change(client);
715         return 0;
716 }
717
718 /* ----------------------------------------------------------------------- */
719
720 static int cx25840_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
721 {
722         struct cx25840_state *state = to_state(sd);
723         struct i2c_client *client = v4l2_get_subdevdata(sd);
724
725         switch (ctrl->id) {
726         case CX25840_CID_ENABLE_PVR150_WORKAROUND:
727                 state->pvr150_workaround = ctrl->value;
728                 set_input(client, state->vid_input, state->aud_input);
729                 break;
730
731         case V4L2_CID_BRIGHTNESS:
732                 if (ctrl->value < 0 || ctrl->value > 255) {
733                         v4l_err(client, "invalid brightness setting %d\n",
734                                     ctrl->value);
735                         return -ERANGE;
736                 }
737
738                 cx25840_write(client, 0x414, ctrl->value - 128);
739                 break;
740
741         case V4L2_CID_CONTRAST:
742                 if (ctrl->value < 0 || ctrl->value > 127) {
743                         v4l_err(client, "invalid contrast setting %d\n",
744                                     ctrl->value);
745                         return -ERANGE;
746                 }
747
748                 cx25840_write(client, 0x415, ctrl->value << 1);
749                 break;
750
751         case V4L2_CID_SATURATION:
752                 if (ctrl->value < 0 || ctrl->value > 127) {
753                         v4l_err(client, "invalid saturation setting %d\n",
754                                     ctrl->value);
755                         return -ERANGE;
756                 }
757
758                 cx25840_write(client, 0x420, ctrl->value << 1);
759                 cx25840_write(client, 0x421, ctrl->value << 1);
760                 break;
761
762         case V4L2_CID_HUE:
763                 if (ctrl->value < -128 || ctrl->value > 127) {
764                         v4l_err(client, "invalid hue setting %d\n", ctrl->value);
765                         return -ERANGE;
766                 }
767
768                 cx25840_write(client, 0x422, ctrl->value);
769                 break;
770
771         case V4L2_CID_AUDIO_VOLUME:
772         case V4L2_CID_AUDIO_BASS:
773         case V4L2_CID_AUDIO_TREBLE:
774         case V4L2_CID_AUDIO_BALANCE:
775         case V4L2_CID_AUDIO_MUTE:
776                 if (state->is_cx25836)
777                         return -EINVAL;
778                 return cx25840_audio_s_ctrl(sd, ctrl);
779
780         default:
781                 return -EINVAL;
782         }
783
784         return 0;
785 }
786
787 static int cx25840_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
788 {
789         struct cx25840_state *state = to_state(sd);
790         struct i2c_client *client = v4l2_get_subdevdata(sd);
791
792         switch (ctrl->id) {
793         case CX25840_CID_ENABLE_PVR150_WORKAROUND:
794                 ctrl->value = state->pvr150_workaround;
795                 break;
796         case V4L2_CID_BRIGHTNESS:
797                 ctrl->value = (s8)cx25840_read(client, 0x414) + 128;
798                 break;
799         case V4L2_CID_CONTRAST:
800                 ctrl->value = cx25840_read(client, 0x415) >> 1;
801                 break;
802         case V4L2_CID_SATURATION:
803                 ctrl->value = cx25840_read(client, 0x420) >> 1;
804                 break;
805         case V4L2_CID_HUE:
806                 ctrl->value = (s8)cx25840_read(client, 0x422);
807                 break;
808         case V4L2_CID_AUDIO_VOLUME:
809         case V4L2_CID_AUDIO_BASS:
810         case V4L2_CID_AUDIO_TREBLE:
811         case V4L2_CID_AUDIO_BALANCE:
812         case V4L2_CID_AUDIO_MUTE:
813                 if (state->is_cx25836)
814                         return -EINVAL;
815                 return cx25840_audio_g_ctrl(sd, ctrl);
816         default:
817                 return -EINVAL;
818         }
819
820         return 0;
821 }
822
823 /* ----------------------------------------------------------------------- */
824
825 static int cx25840_g_fmt(struct v4l2_subdev *sd, struct v4l2_format *fmt)
826 {
827         switch (fmt->type) {
828         case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
829                 return cx25840_vbi_g_fmt(sd, fmt);
830         default:
831                 return -EINVAL;
832         }
833         return 0;
834 }
835
836 static int cx25840_s_fmt(struct v4l2_subdev *sd, struct v4l2_format *fmt)
837 {
838         struct cx25840_state *state = to_state(sd);
839         struct i2c_client *client = v4l2_get_subdevdata(sd);
840         struct v4l2_pix_format *pix;
841         int HSC, VSC, Vsrc, Hsrc, filter, Vlines;
842         int is_50Hz = !(state->std & V4L2_STD_525_60);
843
844         switch (fmt->type) {
845         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
846                 pix = &(fmt->fmt.pix);
847
848                 Vsrc = (cx25840_read(client, 0x476) & 0x3f) << 4;
849                 Vsrc |= (cx25840_read(client, 0x475) & 0xf0) >> 4;
850
851                 Hsrc = (cx25840_read(client, 0x472) & 0x3f) << 4;
852                 Hsrc |= (cx25840_read(client, 0x471) & 0xf0) >> 4;
853
854                 Vlines = pix->height + (is_50Hz ? 4 : 7);
855
856                 if ((pix->width * 16 < Hsrc) || (Hsrc < pix->width) ||
857                     (Vlines * 8 < Vsrc) || (Vsrc < Vlines)) {
858                         v4l_err(client, "%dx%d is not a valid size!\n",
859                                     pix->width, pix->height);
860                         return -ERANGE;
861                 }
862
863                 HSC = (Hsrc * (1 << 20)) / pix->width - (1 << 20);
864                 VSC = (1 << 16) - (Vsrc * (1 << 9) / Vlines - (1 << 9));
865                 VSC &= 0x1fff;
866
867                 if (pix->width >= 385)
868                         filter = 0;
869                 else if (pix->width > 192)
870                         filter = 1;
871                 else if (pix->width > 96)
872                         filter = 2;
873                 else
874                         filter = 3;
875
876                 v4l_dbg(1, cx25840_debug, client, "decoder set size %dx%d -> scale  %ux%u\n",
877                             pix->width, pix->height, HSC, VSC);
878
879                 /* HSCALE=HSC */
880                 cx25840_write(client, 0x418, HSC & 0xff);
881                 cx25840_write(client, 0x419, (HSC >> 8) & 0xff);
882                 cx25840_write(client, 0x41a, HSC >> 16);
883                 /* VSCALE=VSC */
884                 cx25840_write(client, 0x41c, VSC & 0xff);
885                 cx25840_write(client, 0x41d, VSC >> 8);
886                 /* VS_INTRLACE=1 VFILT=filter */
887                 cx25840_write(client, 0x41e, 0x8 | filter);
888                 break;
889
890         case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
891                 return cx25840_vbi_s_fmt(sd, fmt);
892
893         case V4L2_BUF_TYPE_VBI_CAPTURE:
894                 return cx25840_vbi_s_fmt(sd, fmt);
895
896         default:
897                 return -EINVAL;
898         }
899
900         return 0;
901 }
902
903 /* ----------------------------------------------------------------------- */
904
905 static void log_video_status(struct i2c_client *client)
906 {
907         static const char *const fmt_strs[] = {
908                 "0x0",
909                 "NTSC-M", "NTSC-J", "NTSC-4.43",
910                 "PAL-BDGHI", "PAL-M", "PAL-N", "PAL-Nc", "PAL-60",
911                 "0x9", "0xA", "0xB",
912                 "SECAM",
913                 "0xD", "0xE", "0xF"
914         };
915
916         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
917         u8 vidfmt_sel = cx25840_read(client, 0x400) & 0xf;
918         u8 gen_stat1 = cx25840_read(client, 0x40d);
919         u8 gen_stat2 = cx25840_read(client, 0x40e);
920         int vid_input = state->vid_input;
921
922         v4l_info(client, "Video signal:              %spresent\n",
923                     (gen_stat2 & 0x20) ? "" : "not ");
924         v4l_info(client, "Detected format:           %s\n",
925                     fmt_strs[gen_stat1 & 0xf]);
926
927         v4l_info(client, "Specified standard:        %s\n",
928                     vidfmt_sel ? fmt_strs[vidfmt_sel] : "automatic detection");
929
930         if (vid_input >= CX25840_COMPOSITE1 &&
931             vid_input <= CX25840_COMPOSITE8) {
932                 v4l_info(client, "Specified video input:     Composite %d\n",
933                         vid_input - CX25840_COMPOSITE1 + 1);
934         } else {
935                 v4l_info(client, "Specified video input:     S-Video (Luma In%d, Chroma In%d)\n",
936                         (vid_input & 0xf0) >> 4, (vid_input & 0xf00) >> 8);
937         }
938
939         v4l_info(client, "Specified audioclock freq: %d Hz\n", state->audclk_freq);
940 }
941
942 /* ----------------------------------------------------------------------- */
943
944 static void log_audio_status(struct i2c_client *client)
945 {
946         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
947         u8 download_ctl = cx25840_read(client, 0x803);
948         u8 mod_det_stat0 = cx25840_read(client, 0x804);
949         u8 mod_det_stat1 = cx25840_read(client, 0x805);
950         u8 audio_config = cx25840_read(client, 0x808);
951         u8 pref_mode = cx25840_read(client, 0x809);
952         u8 afc0 = cx25840_read(client, 0x80b);
953         u8 mute_ctl = cx25840_read(client, 0x8d3);
954         int aud_input = state->aud_input;
955         char *p;
956
957         switch (mod_det_stat0) {
958         case 0x00: p = "mono"; break;
959         case 0x01: p = "stereo"; break;
960         case 0x02: p = "dual"; break;
961         case 0x04: p = "tri"; break;
962         case 0x10: p = "mono with SAP"; break;
963         case 0x11: p = "stereo with SAP"; break;
964         case 0x12: p = "dual with SAP"; break;
965         case 0x14: p = "tri with SAP"; break;
966         case 0xfe: p = "forced mode"; break;
967         default: p = "not defined";
968         }
969         v4l_info(client, "Detected audio mode:       %s\n", p);
970
971         switch (mod_det_stat1) {
972         case 0x00: p = "not defined"; break;
973         case 0x01: p = "EIAJ"; break;
974         case 0x02: p = "A2-M"; break;
975         case 0x03: p = "A2-BG"; break;
976         case 0x04: p = "A2-DK1"; break;
977         case 0x05: p = "A2-DK2"; break;
978         case 0x06: p = "A2-DK3"; break;
979         case 0x07: p = "A1 (6.0 MHz FM Mono)"; break;
980         case 0x08: p = "AM-L"; break;
981         case 0x09: p = "NICAM-BG"; break;
982         case 0x0a: p = "NICAM-DK"; break;
983         case 0x0b: p = "NICAM-I"; break;
984         case 0x0c: p = "NICAM-L"; break;
985         case 0x0d: p = "BTSC/EIAJ/A2-M Mono (4.5 MHz FMMono)"; break;
986         case 0x0e: p = "IF FM Radio"; break;
987         case 0x0f: p = "BTSC"; break;
988         case 0x10: p = "high-deviation FM"; break;
989         case 0x11: p = "very high-deviation FM"; break;
990         case 0xfd: p = "unknown audio standard"; break;
991         case 0xfe: p = "forced audio standard"; break;
992         case 0xff: p = "no detected audio standard"; break;
993         default: p = "not defined";
994         }
995         v4l_info(client, "Detected audio standard:   %s\n", p);
996         v4l_info(client, "Audio muted:               %s\n",
997                     (state->unmute_volume >= 0) ? "yes" : "no");
998         v4l_info(client, "Audio microcontroller:     %s\n",
999                     (download_ctl & 0x10) ?
1000                                 ((mute_ctl & 0x2) ? "detecting" : "running") : "stopped");
1001
1002         switch (audio_config >> 4) {
1003         case 0x00: p = "undefined"; break;
1004         case 0x01: p = "BTSC"; break;
1005         case 0x02: p = "EIAJ"; break;
1006         case 0x03: p = "A2-M"; break;
1007         case 0x04: p = "A2-BG"; break;
1008         case 0x05: p = "A2-DK1"; break;
1009         case 0x06: p = "A2-DK2"; break;
1010         case 0x07: p = "A2-DK3"; break;
1011         case 0x08: p = "A1 (6.0 MHz FM Mono)"; break;
1012         case 0x09: p = "AM-L"; break;
1013         case 0x0a: p = "NICAM-BG"; break;
1014         case 0x0b: p = "NICAM-DK"; break;
1015         case 0x0c: p = "NICAM-I"; break;
1016         case 0x0d: p = "NICAM-L"; break;
1017         case 0x0e: p = "FM radio"; break;
1018         case 0x0f: p = "automatic detection"; break;
1019         default: p = "undefined";
1020         }
1021         v4l_info(client, "Configured audio standard: %s\n", p);
1022
1023         if ((audio_config >> 4) < 0xF) {
1024                 switch (audio_config & 0xF) {
1025                 case 0x00: p = "MONO1 (LANGUAGE A/Mono L+R channel for BTSC, EIAJ, A2)"; break;
1026                 case 0x01: p = "MONO2 (LANGUAGE B)"; break;
1027                 case 0x02: p = "MONO3 (STEREO forced MONO)"; break;
1028                 case 0x03: p = "MONO4 (NICAM ANALOG-Language C/Analog Fallback)"; break;
1029                 case 0x04: p = "STEREO"; break;
1030                 case 0x05: p = "DUAL1 (AB)"; break;
1031                 case 0x06: p = "DUAL2 (AC) (FM)"; break;
1032                 case 0x07: p = "DUAL3 (BC) (FM)"; break;
1033                 case 0x08: p = "DUAL4 (AC) (AM)"; break;
1034                 case 0x09: p = "DUAL5 (BC) (AM)"; break;
1035                 case 0x0a: p = "SAP"; break;
1036                 default: p = "undefined";
1037                 }
1038                 v4l_info(client, "Configured audio mode:     %s\n", p);
1039         } else {
1040                 switch (audio_config & 0xF) {
1041                 case 0x00: p = "BG"; break;
1042                 case 0x01: p = "DK1"; break;
1043                 case 0x02: p = "DK2"; break;
1044                 case 0x03: p = "DK3"; break;
1045                 case 0x04: p = "I"; break;
1046                 case 0x05: p = "L"; break;
1047                 case 0x06: p = "BTSC"; break;
1048                 case 0x07: p = "EIAJ"; break;
1049                 case 0x08: p = "A2-M"; break;
1050                 case 0x09: p = "FM Radio"; break;
1051                 case 0x0f: p = "automatic standard and mode detection"; break;
1052                 default: p = "undefined";
1053                 }
1054                 v4l_info(client, "Configured audio system:   %s\n", p);
1055         }
1056
1057         if (aud_input) {
1058                 v4l_info(client, "Specified audio input:     Tuner (In%d)\n", aud_input);
1059         } else {
1060                 v4l_info(client, "Specified audio input:     External\n");
1061         }
1062
1063         switch (pref_mode & 0xf) {
1064         case 0: p = "mono/language A"; break;
1065         case 1: p = "language B"; break;
1066         case 2: p = "language C"; break;
1067         case 3: p = "analog fallback"; break;
1068         case 4: p = "stereo"; break;
1069         case 5: p = "language AC"; break;
1070         case 6: p = "language BC"; break;
1071         case 7: p = "language AB"; break;
1072         default: p = "undefined";
1073         }
1074         v4l_info(client, "Preferred audio mode:      %s\n", p);
1075
1076         if ((audio_config & 0xf) == 0xf) {
1077                 switch ((afc0 >> 3) & 0x3) {
1078                 case 0: p = "system DK"; break;
1079                 case 1: p = "system L"; break;
1080                 case 2: p = "autodetect"; break;
1081                 default: p = "undefined";
1082                 }
1083                 v4l_info(client, "Selected 65 MHz format:    %s\n", p);
1084
1085                 switch (afc0 & 0x7) {
1086                 case 0: p = "chroma"; break;
1087                 case 1: p = "BTSC"; break;
1088                 case 2: p = "EIAJ"; break;
1089                 case 3: p = "A2-M"; break;
1090                 case 4: p = "autodetect"; break;
1091                 default: p = "undefined";
1092                 }
1093                 v4l_info(client, "Selected 45 MHz format:    %s\n", p);
1094         }
1095 }
1096
1097 /* ----------------------------------------------------------------------- */
1098
1099 /* This init operation must be called to load the driver's firmware.
1100    Without this the audio standard detection will fail and you will
1101    only get mono.
1102
1103    Since loading the firmware is often problematic when the driver is
1104    compiled into the kernel I recommend postponing calling this function
1105    until the first open of the video device. Another reason for
1106    postponing it is that loading this firmware takes a long time (seconds)
1107    due to the slow i2c bus speed. So it will speed up the boot process if
1108    you can avoid loading the fw as long as the video device isn't used.  */
1109 static int cx25840_init(struct v4l2_subdev *sd, u32 val)
1110 {
1111         struct cx25840_state *state = to_state(sd);
1112         struct i2c_client *client = v4l2_get_subdevdata(sd);
1113
1114         if (!state->is_initialized) {
1115                 /* initialize on first use */
1116                 state->is_initialized = 1;
1117                 if (state->is_cx25836)
1118                         cx25836_initialize(client);
1119                 else if (state->is_cx23885)
1120                         cx23885_initialize(client);
1121                 else
1122                         cx25840_initialize(client);
1123         }
1124         return 0;
1125 }
1126
1127 #ifdef CONFIG_VIDEO_ADV_DEBUG
1128 static int cx25840_g_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
1129 {
1130         struct i2c_client *client = v4l2_get_subdevdata(sd);
1131
1132         if (!v4l2_chip_match_i2c_client(client, &reg->match))
1133                 return -EINVAL;
1134         if (!capable(CAP_SYS_ADMIN))
1135                 return -EPERM;
1136         reg->size = 1;
1137         reg->val = cx25840_read(client, reg->reg & 0x0fff);
1138         return 0;
1139 }
1140
1141 static int cx25840_s_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
1142 {
1143         struct i2c_client *client = v4l2_get_subdevdata(sd);
1144
1145         if (!v4l2_chip_match_i2c_client(client, &reg->match))
1146                 return -EINVAL;
1147         if (!capable(CAP_SYS_ADMIN))
1148                 return -EPERM;
1149         cx25840_write(client, reg->reg & 0x0fff, reg->val & 0xff);
1150         return 0;
1151 }
1152 #endif
1153
1154 static int cx25840_s_stream(struct v4l2_subdev *sd, int enable)
1155 {
1156         struct cx25840_state *state = to_state(sd);
1157         struct i2c_client *client = v4l2_get_subdevdata(sd);
1158
1159         v4l_dbg(1, cx25840_debug, client, "%s output\n",
1160                         enable ? "enable" : "disable");
1161         if (enable) {
1162                 if (state->is_cx23885) {
1163                         u8 v = (cx25840_read(client, 0x421) | 0x0b);
1164                         cx25840_write(client, 0x421, v);
1165                 } else {
1166                         cx25840_write(client, 0x115,
1167                                         state->is_cx25836 ? 0x0c : 0x8c);
1168                         cx25840_write(client, 0x116,
1169                                         state->is_cx25836 ? 0x04 : 0x07);
1170                 }
1171         } else {
1172                 if (state->is_cx23885) {
1173                         u8 v = cx25840_read(client, 0x421) & ~(0x0b);
1174                         cx25840_write(client, 0x421, v);
1175                 } else {
1176                         cx25840_write(client, 0x115, 0x00);
1177                         cx25840_write(client, 0x116, 0x00);
1178                 }
1179         }
1180         return 0;
1181 }
1182
1183 static int cx25840_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qc)
1184 {
1185         struct cx25840_state *state = to_state(sd);
1186
1187         switch (qc->id) {
1188         case V4L2_CID_BRIGHTNESS:
1189                 return v4l2_ctrl_query_fill(qc, 0, 255, 1, 128);
1190         case V4L2_CID_CONTRAST:
1191         case V4L2_CID_SATURATION:
1192                 return v4l2_ctrl_query_fill(qc, 0, 127, 1, 64);
1193         case V4L2_CID_HUE:
1194                 return v4l2_ctrl_query_fill(qc, -128, 127, 1, 0);
1195         default:
1196                 break;
1197         }
1198         if (state->is_cx25836)
1199                 return -EINVAL;
1200
1201         switch (qc->id) {
1202         case V4L2_CID_AUDIO_VOLUME:
1203                 return v4l2_ctrl_query_fill(qc, 0, 65535,
1204                                 65535 / 100, state->default_volume);
1205         case V4L2_CID_AUDIO_MUTE:
1206                 return v4l2_ctrl_query_fill(qc, 0, 1, 1, 0);
1207         case V4L2_CID_AUDIO_BALANCE:
1208         case V4L2_CID_AUDIO_BASS:
1209         case V4L2_CID_AUDIO_TREBLE:
1210                 return v4l2_ctrl_query_fill(qc, 0, 65535, 65535 / 100, 32768);
1211         default:
1212                 return -EINVAL;
1213         }
1214         return -EINVAL;
1215 }
1216
1217 static int cx25840_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
1218 {
1219         struct cx25840_state *state = to_state(sd);
1220         struct i2c_client *client = v4l2_get_subdevdata(sd);
1221
1222         if (state->radio == 0 && state->std == std)
1223                 return 0;
1224         state->radio = 0;
1225         state->std = std;
1226         return set_v4lstd(client);
1227 }
1228
1229 static int cx25840_s_radio(struct v4l2_subdev *sd)
1230 {
1231         struct cx25840_state *state = to_state(sd);
1232
1233         state->radio = 1;
1234         return 0;
1235 }
1236
1237 static int cx25840_s_video_routing(struct v4l2_subdev *sd, const struct v4l2_routing *route)
1238 {
1239         struct cx25840_state *state = to_state(sd);
1240         struct i2c_client *client = v4l2_get_subdevdata(sd);
1241
1242         return set_input(client, route->input, state->aud_input);
1243 }
1244
1245 static int cx25840_s_audio_routing(struct v4l2_subdev *sd, const struct v4l2_routing *route)
1246 {
1247         struct cx25840_state *state = to_state(sd);
1248         struct i2c_client *client = v4l2_get_subdevdata(sd);
1249
1250         if (state->is_cx25836)
1251                 return -EINVAL;
1252         return set_input(client, state->vid_input, route->input);
1253 }
1254
1255 static int cx25840_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *freq)
1256 {
1257         struct cx25840_state *state = to_state(sd);
1258         struct i2c_client *client = v4l2_get_subdevdata(sd);
1259
1260         if (!state->is_cx25836)
1261                 input_change(client);
1262         return 0;
1263 }
1264
1265 static int cx25840_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1266 {
1267         struct cx25840_state *state = to_state(sd);
1268         struct i2c_client *client = v4l2_get_subdevdata(sd);
1269         u8 vpres = cx25840_read(client, 0x40e) & 0x20;
1270         u8 mode;
1271         int val = 0;
1272
1273         if (state->radio)
1274                 return 0;
1275
1276         vt->signal = vpres ? 0xffff : 0x0;
1277         if (state->is_cx25836)
1278                 return 0;
1279
1280         vt->capability |=
1281                 V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_LANG1 |
1282                 V4L2_TUNER_CAP_LANG2 | V4L2_TUNER_CAP_SAP;
1283
1284         mode = cx25840_read(client, 0x804);
1285
1286         /* get rxsubchans and audmode */
1287         if ((mode & 0xf) == 1)
1288                 val |= V4L2_TUNER_SUB_STEREO;
1289         else
1290                 val |= V4L2_TUNER_SUB_MONO;
1291
1292         if (mode == 2 || mode == 4)
1293                 val = V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2;
1294
1295         if (mode & 0x10)
1296                 val |= V4L2_TUNER_SUB_SAP;
1297
1298         vt->rxsubchans = val;
1299         vt->audmode = state->audmode;
1300         return 0;
1301 }
1302
1303 static int cx25840_s_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1304 {
1305         struct cx25840_state *state = to_state(sd);
1306         struct i2c_client *client = v4l2_get_subdevdata(sd);
1307
1308         if (state->radio || state->is_cx25836)
1309                 return 0;
1310
1311         switch (vt->audmode) {
1312                 case V4L2_TUNER_MODE_MONO:
1313                         /* mono      -> mono
1314                            stereo    -> mono
1315                            bilingual -> lang1 */
1316                         cx25840_and_or(client, 0x809, ~0xf, 0x00);
1317                         break;
1318                 case V4L2_TUNER_MODE_STEREO:
1319                 case V4L2_TUNER_MODE_LANG1:
1320                         /* mono      -> mono
1321                            stereo    -> stereo
1322                            bilingual -> lang1 */
1323                         cx25840_and_or(client, 0x809, ~0xf, 0x04);
1324                         break;
1325                 case V4L2_TUNER_MODE_LANG1_LANG2:
1326                         /* mono      -> mono
1327                            stereo    -> stereo
1328                            bilingual -> lang1/lang2 */
1329                         cx25840_and_or(client, 0x809, ~0xf, 0x07);
1330                         break;
1331                 case V4L2_TUNER_MODE_LANG2:
1332                         /* mono      -> mono
1333                            stereo    -> stereo
1334                            bilingual -> lang2 */
1335                         cx25840_and_or(client, 0x809, ~0xf, 0x01);
1336                         break;
1337                 default:
1338                         return -EINVAL;
1339         }
1340         state->audmode = vt->audmode;
1341         return 0;
1342 }
1343
1344 static int cx25840_reset(struct v4l2_subdev *sd, u32 val)
1345 {
1346         struct cx25840_state *state = to_state(sd);
1347         struct i2c_client *client = v4l2_get_subdevdata(sd);
1348
1349         if (state->is_cx25836)
1350                 cx25836_initialize(client);
1351         else if (state->is_cx23885)
1352                 cx23885_initialize(client);
1353         else
1354                 cx25840_initialize(client);
1355         return 0;
1356 }
1357
1358 static int cx25840_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip)
1359 {
1360         struct cx25840_state *state = to_state(sd);
1361         struct i2c_client *client = v4l2_get_subdevdata(sd);
1362
1363         return v4l2_chip_ident_i2c_client(client, chip, state->id, state->rev);
1364 }
1365
1366 static int cx25840_log_status(struct v4l2_subdev *sd)
1367 {
1368         struct cx25840_state *state = to_state(sd);
1369         struct i2c_client *client = v4l2_get_subdevdata(sd);
1370
1371         log_video_status(client);
1372         if (!state->is_cx25836)
1373                 log_audio_status(client);
1374         return 0;
1375 }
1376
1377 /* ----------------------------------------------------------------------- */
1378
1379 static const struct v4l2_subdev_core_ops cx25840_core_ops = {
1380         .log_status = cx25840_log_status,
1381         .g_chip_ident = cx25840_g_chip_ident,
1382         .g_ctrl = cx25840_g_ctrl,
1383         .s_ctrl = cx25840_s_ctrl,
1384         .queryctrl = cx25840_queryctrl,
1385         .reset = cx25840_reset,
1386         .init = cx25840_init,
1387 #ifdef CONFIG_VIDEO_ADV_DEBUG
1388         .g_register = cx25840_g_register,
1389         .s_register = cx25840_s_register,
1390 #endif
1391 };
1392
1393 static const struct v4l2_subdev_tuner_ops cx25840_tuner_ops = {
1394         .s_frequency = cx25840_s_frequency,
1395         .s_std = cx25840_s_std,
1396         .s_radio = cx25840_s_radio,
1397         .g_tuner = cx25840_g_tuner,
1398         .s_tuner = cx25840_s_tuner,
1399 };
1400
1401 static const struct v4l2_subdev_audio_ops cx25840_audio_ops = {
1402         .s_clock_freq = cx25840_s_clock_freq,
1403         .s_routing = cx25840_s_audio_routing,
1404 };
1405
1406 static const struct v4l2_subdev_video_ops cx25840_video_ops = {
1407         .s_routing = cx25840_s_video_routing,
1408         .g_fmt = cx25840_g_fmt,
1409         .s_fmt = cx25840_s_fmt,
1410         .decode_vbi_line = cx25840_decode_vbi_line,
1411         .s_stream = cx25840_s_stream,
1412 };
1413
1414 static const struct v4l2_subdev_ops cx25840_ops = {
1415         .core = &cx25840_core_ops,
1416         .tuner = &cx25840_tuner_ops,
1417         .audio = &cx25840_audio_ops,
1418         .video = &cx25840_video_ops,
1419 };
1420
1421 /* ----------------------------------------------------------------------- */
1422
1423 static int cx25840_probe(struct i2c_client *client,
1424                          const struct i2c_device_id *did)
1425 {
1426         struct cx25840_state *state;
1427         struct v4l2_subdev *sd;
1428         u32 id;
1429         u16 device_id;
1430
1431         /* Check if the adapter supports the needed features */
1432         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1433                 return -EIO;
1434
1435         v4l_dbg(1, cx25840_debug, client, "detecting cx25840 client on address 0x%x\n", client->addr << 1);
1436
1437         device_id = cx25840_read(client, 0x101) << 8;
1438         device_id |= cx25840_read(client, 0x100);
1439         v4l_dbg(1, cx25840_debug, client, "device_id = 0x%04x\n", device_id);
1440
1441         /* The high byte of the device ID should be
1442          * 0x83 for the cx2583x and 0x84 for the cx2584x */
1443         if ((device_id & 0xff00) == 0x8300) {
1444                 id = V4L2_IDENT_CX25836 + ((device_id >> 4) & 0xf) - 6;
1445         }
1446         else if ((device_id & 0xff00) == 0x8400) {
1447                 id = V4L2_IDENT_CX25840 + ((device_id >> 4) & 0xf);
1448         } else if (device_id == 0x0000) {
1449                 id = V4L2_IDENT_CX25836 + ((device_id >> 4) & 0xf) - 6;
1450         } else if (device_id == 0x1313) {
1451                 id = V4L2_IDENT_CX25836 + ((device_id >> 4) & 0xf) - 6;
1452         }
1453         else {
1454                 v4l_dbg(1, cx25840_debug, client, "cx25840 not found\n");
1455                 return -ENODEV;
1456         }
1457
1458         state = kzalloc(sizeof(struct cx25840_state), GFP_KERNEL);
1459         if (state == NULL)
1460                 return -ENOMEM;
1461
1462         sd = &state->sd;
1463         v4l2_i2c_subdev_init(sd, client, &cx25840_ops);
1464         /* Note: revision '(device_id & 0x0f) == 2' was never built. The
1465            marking skips from 0x1 == 22 to 0x3 == 23. */
1466         v4l_info(client, "cx25%3x-2%x found @ 0x%x (%s)\n",
1467                     (device_id & 0xfff0) >> 4,
1468                     (device_id & 0x0f) < 3 ? (device_id & 0x0f) + 1 : (device_id & 0x0f),
1469                     client->addr << 1, client->adapter->name);
1470
1471         state->c = client;
1472         state->is_cx25836 = ((device_id & 0xff00) == 0x8300);
1473         state->is_cx23885 = (device_id == 0x0000) || (device_id == 0x1313);
1474         state->vid_input = CX25840_COMPOSITE7;
1475         state->aud_input = CX25840_AUDIO8;
1476         state->audclk_freq = 48000;
1477         state->pvr150_workaround = 0;
1478         state->audmode = V4L2_TUNER_MODE_LANG1;
1479         state->unmute_volume = -1;
1480         state->default_volume = 228 - cx25840_read(client, 0x8d4);
1481         state->default_volume = ((state->default_volume / 2) + 23) << 9;
1482         state->vbi_line_offset = 8;
1483         state->id = id;
1484         state->rev = device_id;
1485
1486         if (state->is_cx23885) {
1487                 /* Drive GPIO2 direction and values */
1488                 cx25840_write(client, 0x160, 0x1d);
1489                 cx25840_write(client, 0x164, 0x00);
1490         }
1491
1492         return 0;
1493 }
1494
1495 static int cx25840_remove(struct i2c_client *client)
1496 {
1497         struct v4l2_subdev *sd = i2c_get_clientdata(client);
1498
1499         v4l2_device_unregister_subdev(sd);
1500         kfree(to_state(sd));
1501         return 0;
1502 }
1503
1504 static const struct i2c_device_id cx25840_id[] = {
1505         { "cx25840", 0 },
1506         { }
1507 };
1508 MODULE_DEVICE_TABLE(i2c, cx25840_id);
1509
1510 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1511         .name = "cx25840",
1512         .probe = cx25840_probe,
1513         .remove = cx25840_remove,
1514         .id_table = cx25840_id,
1515 };