1 /*
2 * Copyright (C) 2005-2006 Micronas USA Inc.
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License (Version 2) as
6 * published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software Foundation,
15 * Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
16 */
17
18 #include <linux/module.h>
19 #include <linux/init.h>
20 #include <linux/i2c.h>
21 #include <linux/videodev2.h>
22 #include <media/tuner.h>
23 #include <media/v4l2-common.h>
24 #include <media/v4l2-ioctl.h>
25
26 #include "wis-i2c.h"
27
28 /* #define MPX_DEBUG */
29
30 /* AS(IF/MPX) pin: LOW HIGH/OPEN
31 * IF/MPX address: 0x42/0x40 0x43/0x44
32 */
33 #define IF_I2C_ADDR 0x43
34 #define MPX_I2C_ADDR 0x44
35
36 static v4l2_std_id force_band;
37 static char force_band_str[] = "-";
38 module_param_string(force_band, force_band_str, sizeof(force_band_str), 0644);
39 static int force_mpx_mode = -1;
40 module_param(force_mpx_mode, int, 0644);
41
42 /* Store tuner info in the same format as tuner.c, so maybe we can put the
43 * Sony tuner support in there. */
44 struct sony_tunertype {
45 char *name;
46 unsigned char Vendor; /* unused here */
47 unsigned char Type; /* unused here */
48
49 unsigned short thresh1; /* band switch VHF_LO <=> VHF_HI */
50 unsigned short thresh2; /* band switch VHF_HI <=> UHF */
51 unsigned char VHF_L;
52 unsigned char VHF_H;
53 unsigned char UHF;
54 unsigned char config;
55 unsigned short IFPCoff;
56 };
57
58 /* This array is indexed by (tuner_type - 200) */
59 static struct sony_tunertype sony_tuners[] = {
60 { "Sony PAL+SECAM (BTF-PG472Z)", 0, 0,
61 16*144.25, 16*427.25, 0x01, 0x02, 0x04, 0xc6, 623},
62 { "Sony NTSC_JP (BTF-PK467Z)", 0, 0,
63 16*220.25, 16*467.25, 0x01, 0x02, 0x04, 0xc6, 940},
64 { "Sony NTSC (BTF-PB463Z)", 0, 0,
65 16*130.25, 16*364.25, 0x01, 0x02, 0x04, 0xc6, 732},
66 };
67
68 struct wis_sony_tuner {
69 int type;
70 v4l2_std_id std;
71 unsigned int freq;
72 int mpxmode;
73 u32 audmode;
74 };
75
76 /* Basically the same as default_set_tv_freq() in tuner.c */
set_freq(struct i2c_client * client,int freq)77 static int set_freq(struct i2c_client *client, int freq)
78 {
79 struct wis_sony_tuner *t = i2c_get_clientdata(client);
80 char *band_name;
81 int n;
82 int band_select;
83 struct sony_tunertype *tun;
84 u8 buffer[4];
85
86 tun = &sony_tuners[t->type - 200];
87 if (freq < tun->thresh1) {
88 band_name = "VHF_L";
89 band_select = tun->VHF_L;
90 } else if (freq < tun->thresh2) {
91 band_name = "VHF_H";
92 band_select = tun->VHF_H;
93 } else {
94 band_name = "UHF";
95 band_select = tun->UHF;
96 }
97 printk(KERN_DEBUG "wis-sony-tuner: tuning to frequency %d.%04d (%s)\n",
98 freq / 16, (freq % 16) * 625, band_name);
99 n = freq + tun->IFPCoff;
100
101 buffer[0] = n >> 8;
102 buffer[1] = n & 0xff;
103 buffer[2] = tun->config;
104 buffer[3] = band_select;
105 i2c_master_send(client, buffer, 4);
106
107 return 0;
108 }
109
mpx_write(struct i2c_client * client,int dev,int addr,int val)110 static int mpx_write(struct i2c_client *client, int dev, int addr, int val)
111 {
112 u8 buffer[5];
113 struct i2c_msg msg;
114
115 buffer[0] = dev;
116 buffer[1] = addr >> 8;
117 buffer[2] = addr & 0xff;
118 buffer[3] = val >> 8;
119 buffer[4] = val & 0xff;
120 msg.addr = MPX_I2C_ADDR;
121 msg.flags = 0;
122 msg.len = 5;
123 msg.buf = buffer;
124 i2c_transfer(client->adapter, &msg, 1);
125 return 0;
126 }
127
128 /*
129 * MPX register values for the BTF-PG472Z:
130 *
131 * FM_ NICAM_ SCART_
132 * MODUS SOURCE ACB PRESCAL PRESCAL PRESCAL SYSTEM VOLUME
133 * 10/0030 12/0008 12/0013 12/000E 12/0010 12/0000 10/0020 12/0000
134 * ---------------------------------------------------------------
135 * Auto 1003 0020 0100 2603 5000 XXXX 0001 7500
136 *
137 * B/G
138 * Mono 1003 0020 0100 2603 5000 XXXX 0003 7500
139 * A2 1003 0020 0100 2601 5000 XXXX 0003 7500
140 * NICAM 1003 0120 0100 2603 5000 XXXX 0008 7500
141 *
142 * I
143 * Mono 1003 0020 0100 2603 7900 XXXX 000A 7500
144 * NICAM 1003 0120 0100 2603 7900 XXXX 000A 7500
145 *
146 * D/K
147 * Mono 1003 0020 0100 2603 5000 XXXX 0004 7500
148 * A2-1 1003 0020 0100 2601 5000 XXXX 0004 7500
149 * A2-2 1003 0020 0100 2601 5000 XXXX 0005 7500
150 * A2-3 1003 0020 0100 2601 5000 XXXX 0007 7500
151 * NICAM 1003 0120 0100 2603 5000 XXXX 000B 7500
152 *
153 * L/L'
154 * Mono 0003 0200 0100 7C03 5000 2200 0009 7500
155 * NICAM 0003 0120 0100 7C03 5000 XXXX 0009 7500
156 *
157 * M
158 * Mono 1003 0200 0100 2B03 5000 2B00 0002 7500
159 *
160 * For Asia, replace the 0x26XX in FM_PRESCALE with 0x14XX.
161 *
162 * Bilingual selection in A2/NICAM:
163 *
164 * High byte of SOURCE Left chan Right chan
165 * 0x01 MAIN SUB
166 * 0x03 MAIN MAIN
167 * 0x04 SUB SUB
168 *
169 * Force mono in NICAM by setting the high byte of SOURCE to 0x02 (L/L') or
170 * 0x00 (all other bands). Force mono in A2 with FMONO_A2:
171 *
172 * FMONO_A2
173 * 10/0022
174 * --------
175 * Forced mono ON 07F0
176 * Forced mono OFF 0190
177 */
178
179 static struct {
180 enum { AUD_MONO, AUD_A2, AUD_NICAM, AUD_NICAM_L } audio_mode;
181 u16 modus;
182 u16 source;
183 u16 acb;
184 u16 fm_prescale;
185 u16 nicam_prescale;
186 u16 scart_prescale;
187 u16 system;
188 u16 volume;
189 } mpx_audio_modes[] = {
190 /* Auto */ { AUD_MONO, 0x1003, 0x0020, 0x0100, 0x2603,
191 0x5000, 0x0000, 0x0001, 0x7500 },
192 /* B/G Mono */ { AUD_MONO, 0x1003, 0x0020, 0x0100, 0x2603,
193 0x5000, 0x0000, 0x0003, 0x7500 },
194 /* B/G A2 */ { AUD_A2, 0x1003, 0x0020, 0x0100, 0x2601,
195 0x5000, 0x0000, 0x0003, 0x7500 },
196 /* B/G NICAM */ { AUD_NICAM, 0x1003, 0x0120, 0x0100, 0x2603,
197 0x5000, 0x0000, 0x0008, 0x7500 },
198 /* I Mono */ { AUD_MONO, 0x1003, 0x0020, 0x0100, 0x2603,
199 0x7900, 0x0000, 0x000A, 0x7500 },
200 /* I NICAM */ { AUD_NICAM, 0x1003, 0x0120, 0x0100, 0x2603,
201 0x7900, 0x0000, 0x000A, 0x7500 },
202 /* D/K Mono */ { AUD_MONO, 0x1003, 0x0020, 0x0100, 0x2603,
203 0x5000, 0x0000, 0x0004, 0x7500 },
204 /* D/K A2-1 */ { AUD_A2, 0x1003, 0x0020, 0x0100, 0x2601,
205 0x5000, 0x0000, 0x0004, 0x7500 },
206 /* D/K A2-2 */ { AUD_A2, 0x1003, 0x0020, 0x0100, 0x2601,
207 0x5000, 0x0000, 0x0005, 0x7500 },
208 /* D/K A2-3 */ { AUD_A2, 0x1003, 0x0020, 0x0100, 0x2601,
209 0x5000, 0x0000, 0x0007, 0x7500 },
210 /* D/K NICAM */ { AUD_NICAM, 0x1003, 0x0120, 0x0100, 0x2603,
211 0x5000, 0x0000, 0x000B, 0x7500 },
212 /* L/L' Mono */ { AUD_MONO, 0x0003, 0x0200, 0x0100, 0x7C03,
213 0x5000, 0x2200, 0x0009, 0x7500 },
214 /* L/L' NICAM */{ AUD_NICAM_L, 0x0003, 0x0120, 0x0100, 0x7C03,
215 0x5000, 0x0000, 0x0009, 0x7500 },
216 };
217
218 #define MPX_NUM_MODES ARRAY_SIZE(mpx_audio_modes)
219
mpx_setup(struct i2c_client * client)220 static int mpx_setup(struct i2c_client *client)
221 {
222 struct wis_sony_tuner *t = i2c_get_clientdata(client);
223 u16 source = 0;
224 u8 buffer[3];
225 struct i2c_msg msg;
226
227 /* reset MPX */
228 buffer[0] = 0x00;
229 buffer[1] = 0x80;
230 buffer[2] = 0x00;
231 msg.addr = MPX_I2C_ADDR;
232 msg.flags = 0;
233 msg.len = 3;
234 msg.buf = buffer;
235 i2c_transfer(client->adapter, &msg, 1);
236 buffer[1] = 0x00;
237 i2c_transfer(client->adapter, &msg, 1);
238
239 if (mpx_audio_modes[t->mpxmode].audio_mode != AUD_MONO) {
240 switch (t->audmode) {
241 case V4L2_TUNER_MODE_MONO:
242 switch (mpx_audio_modes[t->mpxmode].audio_mode) {
243 case AUD_A2:
244 source = mpx_audio_modes[t->mpxmode].source;
245 break;
246 case AUD_NICAM:
247 source = 0x0000;
248 break;
249 case AUD_NICAM_L:
250 source = 0x0200;
251 break;
252 default:
253 break;
254 }
255 break;
256 case V4L2_TUNER_MODE_STEREO:
257 source = mpx_audio_modes[t->mpxmode].source;
258 break;
259 case V4L2_TUNER_MODE_LANG1:
260 source = 0x0300;
261 break;
262 case V4L2_TUNER_MODE_LANG2:
263 source = 0x0400;
264 break;
265 }
266 source |= mpx_audio_modes[t->mpxmode].source & 0x00ff;
267 } else
268 source = mpx_audio_modes[t->mpxmode].source;
269
270 mpx_write(client, 0x10, 0x0030, mpx_audio_modes[t->mpxmode].modus);
271 mpx_write(client, 0x12, 0x0008, source);
272 mpx_write(client, 0x12, 0x0013, mpx_audio_modes[t->mpxmode].acb);
273 mpx_write(client, 0x12, 0x000e,
274 mpx_audio_modes[t->mpxmode].fm_prescale);
275 mpx_write(client, 0x12, 0x0010,
276 mpx_audio_modes[t->mpxmode].nicam_prescale);
277 mpx_write(client, 0x12, 0x000d,
278 mpx_audio_modes[t->mpxmode].scart_prescale);
279 mpx_write(client, 0x10, 0x0020, mpx_audio_modes[t->mpxmode].system);
280 mpx_write(client, 0x12, 0x0000, mpx_audio_modes[t->mpxmode].volume);
281 if (mpx_audio_modes[t->mpxmode].audio_mode == AUD_A2)
282 mpx_write(client, 0x10, 0x0022,
283 t->audmode == V4L2_TUNER_MODE_MONO ? 0x07f0 : 0x0190);
284
285 #ifdef MPX_DEBUG
286 {
287 u8 buf1[3], buf2[2];
288 struct i2c_msg msgs[2];
289
290 printk(KERN_DEBUG "wis-sony-tuner: MPX registers: %04x %04x "
291 "%04x %04x %04x %04x %04x %04x\n",
292 mpx_audio_modes[t->mpxmode].modus,
293 source,
294 mpx_audio_modes[t->mpxmode].acb,
295 mpx_audio_modes[t->mpxmode].fm_prescale,
296 mpx_audio_modes[t->mpxmode].nicam_prescale,
297 mpx_audio_modes[t->mpxmode].scart_prescale,
298 mpx_audio_modes[t->mpxmode].system,
299 mpx_audio_modes[t->mpxmode].volume);
300 buf1[0] = 0x11;
301 buf1[1] = 0x00;
302 buf1[2] = 0x7e;
303 msgs[0].addr = MPX_I2C_ADDR;
304 msgs[0].flags = 0;
305 msgs[0].len = 3;
306 msgs[0].buf = buf1;
307 msgs[1].addr = MPX_I2C_ADDR;
308 msgs[1].flags = I2C_M_RD;
309 msgs[1].len = 2;
310 msgs[1].buf = buf2;
311 i2c_transfer(client->adapter, msgs, 2);
312 printk(KERN_DEBUG "wis-sony-tuner: MPX system: %02x%02x\n",
313 buf2[0], buf2[1]);
314 buf1[0] = 0x11;
315 buf1[1] = 0x02;
316 buf1[2] = 0x00;
317 i2c_transfer(client->adapter, msgs, 2);
318 printk(KERN_DEBUG "wis-sony-tuner: MPX status: %02x%02x\n",
319 buf2[0], buf2[1]);
320 }
321 #endif
322 return 0;
323 }
324
325 /*
326 * IF configuration values for the BTF-PG472Z:
327 *
328 * B/G: 0x94 0x70 0x49
329 * I: 0x14 0x70 0x4a
330 * D/K: 0x14 0x70 0x4b
331 * L: 0x04 0x70 0x4b
332 * L': 0x44 0x70 0x53
333 * M: 0x50 0x30 0x4c
334 */
335
set_if(struct i2c_client * client)336 static int set_if(struct i2c_client *client)
337 {
338 struct wis_sony_tuner *t = i2c_get_clientdata(client);
339 u8 buffer[4];
340 struct i2c_msg msg;
341 int default_mpx_mode = 0;
342
343 /* configure IF */
344 buffer[0] = 0;
345 if (t->std & V4L2_STD_PAL_BG) {
346 buffer[1] = 0x94;
347 buffer[2] = 0x70;
348 buffer[3] = 0x49;
349 default_mpx_mode = 1;
350 } else if (t->std & V4L2_STD_PAL_I) {
351 buffer[1] = 0x14;
352 buffer[2] = 0x70;
353 buffer[3] = 0x4a;
354 default_mpx_mode = 4;
355 } else if (t->std & V4L2_STD_PAL_DK) {
356 buffer[1] = 0x14;
357 buffer[2] = 0x70;
358 buffer[3] = 0x4b;
359 default_mpx_mode = 6;
360 } else if (t->std & V4L2_STD_SECAM_L) {
361 buffer[1] = 0x04;
362 buffer[2] = 0x70;
363 buffer[3] = 0x4b;
364 default_mpx_mode = 11;
365 }
366 msg.addr = IF_I2C_ADDR;
367 msg.flags = 0;
368 msg.len = 4;
369 msg.buf = buffer;
370 i2c_transfer(client->adapter, &msg, 1);
371
372 /* Select MPX mode if not forced by the user */
373 if (force_mpx_mode >= 0 || force_mpx_mode < MPX_NUM_MODES)
374 t->mpxmode = force_mpx_mode;
375 else
376 t->mpxmode = default_mpx_mode;
377 printk(KERN_DEBUG "wis-sony-tuner: setting MPX to mode %d\n",
378 t->mpxmode);
379 mpx_setup(client);
380
381 return 0;
382 }
383
tuner_command(struct i2c_client * client,unsigned int cmd,void * arg)384 static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
385 {
386 struct wis_sony_tuner *t = i2c_get_clientdata(client);
387
388 switch (cmd) {
389 #ifdef TUNER_SET_TYPE_ADDR
390 case TUNER_SET_TYPE_ADDR:
391 {
392 struct tuner_setup *tun_setup = arg;
393 int *type = &tun_setup->type;
394 #else
395 case TUNER_SET_TYPE:
396 {
397 int *type = arg;
398 #endif
399
400 if (t->type >= 0) {
401 if (t->type != *type)
402 printk(KERN_ERR "wis-sony-tuner: type already "
403 "set to %d, ignoring request for %d\n",
404 t->type, *type);
405 break;
406 }
407 t->type = *type;
408 switch (t->type) {
409 case TUNER_SONY_BTF_PG472Z:
410 switch (force_band_str[0]) {
411 case 'b':
412 case 'B':
413 case 'g':
414 case 'G':
415 printk(KERN_INFO "wis-sony-tuner: forcing "
416 "tuner to PAL-B/G bands\n");
417 force_band = V4L2_STD_PAL_BG;
418 break;
419 case 'i':
420 case 'I':
421 printk(KERN_INFO "wis-sony-tuner: forcing "
422 "tuner to PAL-I band\n");
423 force_band = V4L2_STD_PAL_I;
424 break;
425 case 'd':
426 case 'D':
427 case 'k':
428 case 'K':
429 printk(KERN_INFO "wis-sony-tuner: forcing "
430 "tuner to PAL-D/K bands\n");
431 force_band = V4L2_STD_PAL_I;
432 break;
433 case 'l':
434 case 'L':
435 printk(KERN_INFO "wis-sony-tuner: forcing "
436 "tuner to SECAM-L band\n");
437 force_band = V4L2_STD_SECAM_L;
438 break;
439 default:
440 force_band = 0;
441 break;
442 }
443 if (force_band)
444 t->std = force_band;
445 else
446 t->std = V4L2_STD_PAL_BG;
447 set_if(client);
448 break;
449 case TUNER_SONY_BTF_PK467Z:
450 t->std = V4L2_STD_NTSC_M_JP;
451 break;
452 case TUNER_SONY_BTF_PB463Z:
453 t->std = V4L2_STD_NTSC_M;
454 break;
455 default:
456 printk(KERN_ERR "wis-sony-tuner: tuner type %d is not "
457 "supported by this module\n", *type);
458 break;
459 }
460 if (type >= 0)
461 printk(KERN_INFO
462 "wis-sony-tuner: type set to %d (%s)\n",
463 t->type, sony_tuners[t->type - 200].name);
464 break;
465 }
466 case VIDIOC_G_FREQUENCY:
467 {
468 struct v4l2_frequency *f = arg;
469
470 f->frequency = t->freq;
471 break;
472 }
473 case VIDIOC_S_FREQUENCY:
474 {
475 struct v4l2_frequency *f = arg;
476
477 t->freq = f->frequency;
478 set_freq(client, t->freq);
479 break;
480 }
481 case VIDIOC_ENUMSTD:
482 {
483 struct v4l2_standard *std = arg;
484
485 switch (t->type) {
486 case TUNER_SONY_BTF_PG472Z:
487 switch (std->index) {
488 case 0:
489 v4l2_video_std_construct(std,
490 V4L2_STD_PAL_BG, "PAL-B/G");
491 break;
492 case 1:
493 v4l2_video_std_construct(std,
494 V4L2_STD_PAL_I, "PAL-I");
495 break;
496 case 2:
497 v4l2_video_std_construct(std,
498 V4L2_STD_PAL_DK, "PAL-D/K");
499 break;
500 case 3:
501 v4l2_video_std_construct(std,
502 V4L2_STD_SECAM_L, "SECAM-L");
503 break;
504 default:
505 std->id = 0; /* hack to indicate EINVAL */
506 break;
507 }
508 break;
509 case TUNER_SONY_BTF_PK467Z:
510 if (std->index != 0) {
511 std->id = 0; /* hack to indicate EINVAL */
512 break;
513 }
514 v4l2_video_std_construct(std,
515 V4L2_STD_NTSC_M_JP, "NTSC-J");
516 break;
517 case TUNER_SONY_BTF_PB463Z:
518 if (std->index != 0) {
519 std->id = 0; /* hack to indicate EINVAL */
520 break;
521 }
522 v4l2_video_std_construct(std, V4L2_STD_NTSC_M, "NTSC");
523 break;
524 }
525 break;
526 }
527 case VIDIOC_G_STD:
528 {
529 v4l2_std_id *std = arg;
530
531 *std = t->std;
532 break;
533 }
534 case VIDIOC_S_STD:
535 {
536 v4l2_std_id *std = arg;
537 v4l2_std_id old = t->std;
538
539 switch (t->type) {
540 case TUNER_SONY_BTF_PG472Z:
541 if (force_band && (*std & force_band) != *std &&
542 *std != V4L2_STD_PAL &&
543 *std != V4L2_STD_SECAM) {
544 printk(KERN_DEBUG "wis-sony-tuner: ignoring "
545 "requested TV standard in "
546 "favor of force_band value\n");
547 t->std = force_band;
548 } else if (*std & V4L2_STD_PAL_BG) { /* default */
549 t->std = V4L2_STD_PAL_BG;
550 } else if (*std & V4L2_STD_PAL_I) {
551 t->std = V4L2_STD_PAL_I;
552 } else if (*std & V4L2_STD_PAL_DK) {
553 t->std = V4L2_STD_PAL_DK;
554 } else if (*std & V4L2_STD_SECAM_L) {
555 t->std = V4L2_STD_SECAM_L;
556 } else {
557 printk(KERN_ERR "wis-sony-tuner: TV standard "
558 "not supported\n");
559 *std = 0; /* hack to indicate EINVAL */
560 break;
561 }
562 if (old != t->std)
563 set_if(client);
564 break;
565 case TUNER_SONY_BTF_PK467Z:
566 if (!(*std & V4L2_STD_NTSC_M_JP)) {
567 printk(KERN_ERR "wis-sony-tuner: TV standard "
568 "not supported\n");
569 *std = 0; /* hack to indicate EINVAL */
570 }
571 break;
572 case TUNER_SONY_BTF_PB463Z:
573 if (!(*std & V4L2_STD_NTSC_M)) {
574 printk(KERN_ERR "wis-sony-tuner: TV standard "
575 "not supported\n");
576 *std = 0; /* hack to indicate EINVAL */
577 }
578 break;
579 }
580 break;
581 }
582 case VIDIOC_QUERYSTD:
583 {
584 v4l2_std_id *std = arg;
585
586 switch (t->type) {
587 case TUNER_SONY_BTF_PG472Z:
588 if (force_band)
589 *std = force_band;
590 else
591 *std = V4L2_STD_PAL_BG | V4L2_STD_PAL_I |
592 V4L2_STD_PAL_DK | V4L2_STD_SECAM_L;
593 break;
594 case TUNER_SONY_BTF_PK467Z:
595 *std = V4L2_STD_NTSC_M_JP;
596 break;
597 case TUNER_SONY_BTF_PB463Z:
598 *std = V4L2_STD_NTSC_M;
599 break;
600 }
601 break;
602 }
603 case VIDIOC_G_TUNER:
604 {
605 struct v4l2_tuner *tun = arg;
606
607 memset(tun, 0, sizeof(*tun));
608 strcpy(tun->name, "Television");
609 tun->type = V4L2_TUNER_ANALOG_TV;
610 tun->rangelow = 0UL; /* does anything use these? */
611 tun->rangehigh = 0xffffffffUL;
612 switch (t->type) {
613 case TUNER_SONY_BTF_PG472Z:
614 tun->capability = V4L2_TUNER_CAP_NORM |
615 V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_LANG1 |
616 V4L2_TUNER_CAP_LANG2;
617 tun->rxsubchans = V4L2_TUNER_SUB_MONO |
618 V4L2_TUNER_SUB_STEREO | V4L2_TUNER_SUB_LANG1 |
619 V4L2_TUNER_SUB_LANG2;
620 break;
621 case TUNER_SONY_BTF_PK467Z:
622 case TUNER_SONY_BTF_PB463Z:
623 tun->capability = V4L2_TUNER_CAP_STEREO;
624 tun->rxsubchans = V4L2_TUNER_SUB_MONO |
625 V4L2_TUNER_SUB_STEREO;
626 break;
627 }
628 tun->audmode = t->audmode;
629 return 0;
630 }
631 case VIDIOC_S_TUNER:
632 {
633 struct v4l2_tuner *tun = arg;
634
635 switch (t->type) {
636 case TUNER_SONY_BTF_PG472Z:
637 if (tun->audmode != t->audmode) {
638 t->audmode = tun->audmode;
639 mpx_setup(client);
640 }
641 break;
642 case TUNER_SONY_BTF_PK467Z:
643 case TUNER_SONY_BTF_PB463Z:
644 break;
645 }
646 return 0;
647 }
648 default:
649 break;
650 }
651 return 0;
652 }
653
654 static struct i2c_driver wis_sony_tuner_driver;
655
656 static struct i2c_client wis_sony_tuner_client_templ = {
657 .name = "Sony TV Tuner (WIS)",
658 .driver = &wis_sony_tuner_driver,
659 };
660
661 static int wis_sony_tuner_detect(struct i2c_adapter *adapter,
662 int addr, int kind)
663 {
664 struct i2c_client *client;
665 struct wis_sony_tuner *t;
666
667 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_I2C_BLOCK))
668 return 0;
669
670 client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
671 if (client == NULL)
672 return -ENOMEM;
673 memcpy(client, &wis_sony_tuner_client_templ,
674 sizeof(wis_sony_tuner_client_templ));
675 client->adapter = adapter;
676 client->addr = addr;
677
678 t = kmalloc(sizeof(struct wis_sony_tuner), GFP_KERNEL);
679 if (t == NULL) {
680 kfree(client);
681 return -ENOMEM;
682 }
683 t->type = -1;
684 t->freq = 0;
685 t->mpxmode = 0;
686 t->audmode = V4L2_TUNER_MODE_STEREO;
687 i2c_set_clientdata(client, t);
688
689 printk(KERN_DEBUG
690 "wis-sony-tuner: initializing tuner at address %d on %s\n",
691 addr, adapter->name);
692
693 i2c_attach_client(client);
694
695 return 0;
696 }
697
698 static int wis_sony_tuner_detach(struct i2c_client *client)
699 {
700 struct wis_sony_tuner *t = i2c_get_clientdata(client);
701 int r;
702
703 r = i2c_detach_client(client);
704 if (r < 0)
705 return r;
706
707 kfree(t);
708 kfree(client);
709 return 0;
710 }
711
712 static struct i2c_driver wis_sony_tuner_driver = {
713 .driver = {
714 .name = "WIS Sony TV Tuner I2C driver",
715 },
716 .id = I2C_DRIVERID_WIS_SONY_TUNER,
717 .detach_client = wis_sony_tuner_detach,
718 .command = tuner_command,
719 };
720
721 static int __init wis_sony_tuner_init(void)
722 {
723 int r;
724
725 r = i2c_add_driver(&wis_sony_tuner_driver);
726 if (r < 0)
727 return r;
728 return wis_i2c_add_driver(wis_sony_tuner_driver.id,
729 wis_sony_tuner_detect);
730 }
731
732 static void __exit wis_sony_tuner_cleanup(void)
733 {
734 wis_i2c_del_driver(wis_sony_tuner_detect);
735 i2c_del_driver(&wis_sony_tuner_driver);
736 }
737
738 module_init(wis_sony_tuner_init);
739 module_exit(wis_sony_tuner_cleanup);
740
741 MODULE_LICENSE("GPL v2");
742