]> git.proxmox.com Git - mirror_ubuntu-kernels.git/blob - drivers/media/video/cx25840/cx25840-core.c
projects / mirror_ubuntu-kernels.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
loop: mutex already unlocked in loop_clr_fd()
[mirror_ubuntu-kernels.git] / 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 };
Ubuntu combined Linux kernel mirror