diff options
author | Jonathan Herman <hermanjl@cs.unc.edu> | 2013-01-22 10:38:37 -0500 |
---|---|---|
committer | Jonathan Herman <hermanjl@cs.unc.edu> | 2013-01-22 10:38:37 -0500 |
commit | fcc9d2e5a6c89d22b8b773a64fb4ad21ac318446 (patch) | |
tree | a57612d1888735a2ec7972891b68c1ac5ec8faea /drivers/media/video/saa717x.c | |
parent | 8dea78da5cee153b8af9c07a2745f6c55057fe12 (diff) |
Diffstat (limited to 'drivers/media/video/saa717x.c')
-rw-r--r-- | drivers/media/video/saa717x.c | 1389 |
1 files changed, 1389 insertions, 0 deletions
diff --git a/drivers/media/video/saa717x.c b/drivers/media/video/saa717x.c new file mode 100644 index 00000000000..b6172c2c517 --- /dev/null +++ b/drivers/media/video/saa717x.c | |||
@@ -0,0 +1,1389 @@ | |||
1 | /* | ||
2 | * saa717x - Philips SAA717xHL video decoder driver | ||
3 | * | ||
4 | * Based on the saa7115 driver | ||
5 | * | ||
6 | * Changes by Ohta Kyuma <alpha292@bremen.or.jp> | ||
7 | * - Apply to SAA717x,NEC uPD64031,uPD64083. (1/31/2004) | ||
8 | * | ||
9 | * Changes by T.Adachi (tadachi@tadachi-net.com) | ||
10 | * - support audio, video scaler etc, and checked the initialize sequence. | ||
11 | * | ||
12 | * Cleaned up by Hans Verkuil <hverkuil@xs4all.nl> | ||
13 | * | ||
14 | * Note: this is a reversed engineered driver based on captures from | ||
15 | * the I2C bus under Windows. This chip is very similar to the saa7134, | ||
16 | * though. Unfortunately, this driver is currently only working for NTSC. | ||
17 | * | ||
18 | * This program is free software; you can redistribute it and/or modify | ||
19 | * it under the terms of the GNU General Public License as published by | ||
20 | * the Free Software Foundation; either version 2 of the License, or | ||
21 | * (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., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
31 | */ | ||
32 | |||
33 | #include <linux/module.h> | ||
34 | #include <linux/kernel.h> | ||
35 | #include <linux/slab.h> | ||
36 | #include <linux/sched.h> | ||
37 | |||
38 | #include <linux/videodev2.h> | ||
39 | #include <linux/i2c.h> | ||
40 | #include <media/v4l2-device.h> | ||
41 | #include <media/v4l2-ctrls.h> | ||
42 | |||
43 | MODULE_DESCRIPTION("Philips SAA717x audio/video decoder driver"); | ||
44 | MODULE_AUTHOR("K. Ohta, T. Adachi, Hans Verkuil"); | ||
45 | MODULE_LICENSE("GPL"); | ||
46 | |||
47 | static int debug; | ||
48 | module_param(debug, int, 0644); | ||
49 | MODULE_PARM_DESC(debug, "Debug level (0-1)"); | ||
50 | |||
51 | /* | ||
52 | * Generic i2c probe | ||
53 | * concerning the addresses: i2c wants 7 bit (without the r/w bit), so '>>1' | ||
54 | */ | ||
55 | |||
56 | struct saa717x_state { | ||
57 | struct v4l2_subdev sd; | ||
58 | struct v4l2_ctrl_handler hdl; | ||
59 | v4l2_std_id std; | ||
60 | int input; | ||
61 | int enable; | ||
62 | int radio; | ||
63 | int playback; | ||
64 | int audio; | ||
65 | int tuner_audio_mode; | ||
66 | int audio_main_mute; | ||
67 | int audio_main_vol_r; | ||
68 | int audio_main_vol_l; | ||
69 | u16 audio_main_bass; | ||
70 | u16 audio_main_treble; | ||
71 | u16 audio_main_volume; | ||
72 | u16 audio_main_balance; | ||
73 | int audio_input; | ||
74 | }; | ||
75 | |||
76 | static inline struct saa717x_state *to_state(struct v4l2_subdev *sd) | ||
77 | { | ||
78 | return container_of(sd, struct saa717x_state, sd); | ||
79 | } | ||
80 | |||
81 | static inline struct v4l2_subdev *to_sd(struct v4l2_ctrl *ctrl) | ||
82 | { | ||
83 | return &container_of(ctrl->handler, struct saa717x_state, hdl)->sd; | ||
84 | } | ||
85 | |||
86 | /* ----------------------------------------------------------------------- */ | ||
87 | |||
88 | /* for audio mode */ | ||
89 | #define TUNER_AUDIO_MONO 0 /* LL */ | ||
90 | #define TUNER_AUDIO_STEREO 1 /* LR */ | ||
91 | #define TUNER_AUDIO_LANG1 2 /* LL */ | ||
92 | #define TUNER_AUDIO_LANG2 3 /* RR */ | ||
93 | |||
94 | #define SAA717X_NTSC_WIDTH (704) | ||
95 | #define SAA717X_NTSC_HEIGHT (480) | ||
96 | |||
97 | /* ----------------------------------------------------------------------- */ | ||
98 | |||
99 | static int saa717x_write(struct v4l2_subdev *sd, u32 reg, u32 value) | ||
100 | { | ||
101 | struct i2c_client *client = v4l2_get_subdevdata(sd); | ||
102 | struct i2c_adapter *adap = client->adapter; | ||
103 | int fw_addr = reg == 0x454 || (reg >= 0x464 && reg <= 0x478) || reg == 0x480 || reg == 0x488; | ||
104 | unsigned char mm1[6]; | ||
105 | struct i2c_msg msg; | ||
106 | |||
107 | msg.flags = 0; | ||
108 | msg.addr = client->addr; | ||
109 | mm1[0] = (reg >> 8) & 0xff; | ||
110 | mm1[1] = reg & 0xff; | ||
111 | |||
112 | if (fw_addr) { | ||
113 | mm1[4] = (value >> 16) & 0xff; | ||
114 | mm1[3] = (value >> 8) & 0xff; | ||
115 | mm1[2] = value & 0xff; | ||
116 | } else { | ||
117 | mm1[2] = value & 0xff; | ||
118 | } | ||
119 | msg.len = fw_addr ? 5 : 3; /* Long Registers have *only* three bytes! */ | ||
120 | msg.buf = mm1; | ||
121 | v4l2_dbg(2, debug, sd, "wrote: reg 0x%03x=%08x\n", reg, value); | ||
122 | return i2c_transfer(adap, &msg, 1) == 1; | ||
123 | } | ||
124 | |||
125 | static void saa717x_write_regs(struct v4l2_subdev *sd, u32 *data) | ||
126 | { | ||
127 | while (data[0] || data[1]) { | ||
128 | saa717x_write(sd, data[0], data[1]); | ||
129 | data += 2; | ||
130 | } | ||
131 | } | ||
132 | |||
133 | static u32 saa717x_read(struct v4l2_subdev *sd, u32 reg) | ||
134 | { | ||
135 | struct i2c_client *client = v4l2_get_subdevdata(sd); | ||
136 | struct i2c_adapter *adap = client->adapter; | ||
137 | int fw_addr = (reg >= 0x404 && reg <= 0x4b8) || reg == 0x528; | ||
138 | unsigned char mm1[2]; | ||
139 | unsigned char mm2[4] = { 0, 0, 0, 0 }; | ||
140 | struct i2c_msg msgs[2]; | ||
141 | u32 value; | ||
142 | |||
143 | msgs[0].flags = 0; | ||
144 | msgs[1].flags = I2C_M_RD; | ||
145 | msgs[0].addr = msgs[1].addr = client->addr; | ||
146 | mm1[0] = (reg >> 8) & 0xff; | ||
147 | mm1[1] = reg & 0xff; | ||
148 | msgs[0].len = 2; | ||
149 | msgs[0].buf = mm1; | ||
150 | msgs[1].len = fw_addr ? 3 : 1; /* Multibyte Registers contains *only* 3 bytes */ | ||
151 | msgs[1].buf = mm2; | ||
152 | i2c_transfer(adap, msgs, 2); | ||
153 | |||
154 | if (fw_addr) | ||
155 | value = (mm2[2] & 0xff) | ((mm2[1] & 0xff) >> 8) | ((mm2[0] & 0xff) >> 16); | ||
156 | else | ||
157 | value = mm2[0] & 0xff; | ||
158 | |||
159 | v4l2_dbg(2, debug, sd, "read: reg 0x%03x=0x%08x\n", reg, value); | ||
160 | return value; | ||
161 | } | ||
162 | |||
163 | /* ----------------------------------------------------------------------- */ | ||
164 | |||
165 | static u32 reg_init_initialize[] = | ||
166 | { | ||
167 | /* from linux driver */ | ||
168 | 0x101, 0x008, /* Increment delay */ | ||
169 | |||
170 | 0x103, 0x000, /* Analog input control 2 */ | ||
171 | 0x104, 0x090, /* Analog input control 3 */ | ||
172 | 0x105, 0x090, /* Analog input control 4 */ | ||
173 | 0x106, 0x0eb, /* Horizontal sync start */ | ||
174 | 0x107, 0x0e0, /* Horizontal sync stop */ | ||
175 | 0x109, 0x055, /* Luminance control */ | ||
176 | |||
177 | 0x10f, 0x02a, /* Chroma gain control */ | ||
178 | 0x110, 0x000, /* Chroma control 2 */ | ||
179 | |||
180 | 0x114, 0x045, /* analog/ADC */ | ||
181 | |||
182 | 0x118, 0x040, /* RAW data gain */ | ||
183 | 0x119, 0x080, /* RAW data offset */ | ||
184 | |||
185 | 0x044, 0x000, /* VBI horizontal input window start (L) TASK A */ | ||
186 | 0x045, 0x000, /* VBI horizontal input window start (H) TASK A */ | ||
187 | 0x046, 0x0cf, /* VBI horizontal input window stop (L) TASK A */ | ||
188 | 0x047, 0x002, /* VBI horizontal input window stop (H) TASK A */ | ||
189 | |||
190 | 0x049, 0x000, /* VBI vertical input window start (H) TASK A */ | ||
191 | |||
192 | 0x04c, 0x0d0, /* VBI horizontal output length (L) TASK A */ | ||
193 | 0x04d, 0x002, /* VBI horizontal output length (H) TASK A */ | ||
194 | |||
195 | 0x064, 0x080, /* Lumina brightness TASK A */ | ||
196 | 0x065, 0x040, /* Luminance contrast TASK A */ | ||
197 | 0x066, 0x040, /* Chroma saturation TASK A */ | ||
198 | /* 067H: Reserved */ | ||
199 | 0x068, 0x000, /* VBI horizontal scaling increment (L) TASK A */ | ||
200 | 0x069, 0x004, /* VBI horizontal scaling increment (H) TASK A */ | ||
201 | 0x06a, 0x000, /* VBI phase offset TASK A */ | ||
202 | |||
203 | 0x06e, 0x000, /* Horizontal phase offset Luma TASK A */ | ||
204 | 0x06f, 0x000, /* Horizontal phase offset Chroma TASK A */ | ||
205 | |||
206 | 0x072, 0x000, /* Vertical filter mode TASK A */ | ||
207 | |||
208 | 0x084, 0x000, /* VBI horizontal input window start (L) TAKS B */ | ||
209 | 0x085, 0x000, /* VBI horizontal input window start (H) TAKS B */ | ||
210 | 0x086, 0x0cf, /* VBI horizontal input window stop (L) TAKS B */ | ||
211 | 0x087, 0x002, /* VBI horizontal input window stop (H) TAKS B */ | ||
212 | |||
213 | 0x089, 0x000, /* VBI vertical input window start (H) TAKS B */ | ||
214 | |||
215 | 0x08c, 0x0d0, /* VBI horizontal output length (L) TASK B */ | ||
216 | 0x08d, 0x002, /* VBI horizontal output length (H) TASK B */ | ||
217 | |||
218 | 0x0a4, 0x080, /* Lumina brightness TASK B */ | ||
219 | 0x0a5, 0x040, /* Luminance contrast TASK B */ | ||
220 | 0x0a6, 0x040, /* Chroma saturation TASK B */ | ||
221 | /* 0A7H reserved */ | ||
222 | 0x0a8, 0x000, /* VBI horizontal scaling increment (L) TASK B */ | ||
223 | 0x0a9, 0x004, /* VBI horizontal scaling increment (H) TASK B */ | ||
224 | 0x0aa, 0x000, /* VBI phase offset TASK B */ | ||
225 | |||
226 | 0x0ae, 0x000, /* Horizontal phase offset Luma TASK B */ | ||
227 | 0x0af, 0x000, /*Horizontal phase offset Chroma TASK B */ | ||
228 | |||
229 | 0x0b2, 0x000, /* Vertical filter mode TASK B */ | ||
230 | |||
231 | 0x00c, 0x000, /* Start point GREEN path */ | ||
232 | 0x00d, 0x000, /* Start point BLUE path */ | ||
233 | 0x00e, 0x000, /* Start point RED path */ | ||
234 | |||
235 | 0x010, 0x010, /* GREEN path gamma curve --- */ | ||
236 | 0x011, 0x020, | ||
237 | 0x012, 0x030, | ||
238 | 0x013, 0x040, | ||
239 | 0x014, 0x050, | ||
240 | 0x015, 0x060, | ||
241 | 0x016, 0x070, | ||
242 | 0x017, 0x080, | ||
243 | 0x018, 0x090, | ||
244 | 0x019, 0x0a0, | ||
245 | 0x01a, 0x0b0, | ||
246 | 0x01b, 0x0c0, | ||
247 | 0x01c, 0x0d0, | ||
248 | 0x01d, 0x0e0, | ||
249 | 0x01e, 0x0f0, | ||
250 | 0x01f, 0x0ff, /* --- GREEN path gamma curve */ | ||
251 | |||
252 | 0x020, 0x010, /* BLUE path gamma curve --- */ | ||
253 | 0x021, 0x020, | ||
254 | 0x022, 0x030, | ||
255 | 0x023, 0x040, | ||
256 | 0x024, 0x050, | ||
257 | 0x025, 0x060, | ||
258 | 0x026, 0x070, | ||
259 | 0x027, 0x080, | ||
260 | 0x028, 0x090, | ||
261 | 0x029, 0x0a0, | ||
262 | 0x02a, 0x0b0, | ||
263 | 0x02b, 0x0c0, | ||
264 | 0x02c, 0x0d0, | ||
265 | 0x02d, 0x0e0, | ||
266 | 0x02e, 0x0f0, | ||
267 | 0x02f, 0x0ff, /* --- BLUE path gamma curve */ | ||
268 | |||
269 | 0x030, 0x010, /* RED path gamma curve --- */ | ||
270 | 0x031, 0x020, | ||
271 | 0x032, 0x030, | ||
272 | 0x033, 0x040, | ||
273 | 0x034, 0x050, | ||
274 | 0x035, 0x060, | ||
275 | 0x036, 0x070, | ||
276 | 0x037, 0x080, | ||
277 | 0x038, 0x090, | ||
278 | 0x039, 0x0a0, | ||
279 | 0x03a, 0x0b0, | ||
280 | 0x03b, 0x0c0, | ||
281 | 0x03c, 0x0d0, | ||
282 | 0x03d, 0x0e0, | ||
283 | 0x03e, 0x0f0, | ||
284 | 0x03f, 0x0ff, /* --- RED path gamma curve */ | ||
285 | |||
286 | 0x109, 0x085, /* Luminance control */ | ||
287 | |||
288 | /**** from app start ****/ | ||
289 | 0x584, 0x000, /* AGC gain control */ | ||
290 | 0x585, 0x000, /* Program count */ | ||
291 | 0x586, 0x003, /* Status reset */ | ||
292 | 0x588, 0x0ff, /* Number of audio samples (L) */ | ||
293 | 0x589, 0x00f, /* Number of audio samples (M) */ | ||
294 | 0x58a, 0x000, /* Number of audio samples (H) */ | ||
295 | 0x58b, 0x000, /* Audio select */ | ||
296 | 0x58c, 0x010, /* Audio channel assign1 */ | ||
297 | 0x58d, 0x032, /* Audio channel assign2 */ | ||
298 | 0x58e, 0x054, /* Audio channel assign3 */ | ||
299 | 0x58f, 0x023, /* Audio format */ | ||
300 | 0x590, 0x000, /* SIF control */ | ||
301 | |||
302 | 0x595, 0x000, /* ?? */ | ||
303 | 0x596, 0x000, /* ?? */ | ||
304 | 0x597, 0x000, /* ?? */ | ||
305 | |||
306 | 0x464, 0x00, /* Digital input crossbar1 */ | ||
307 | |||
308 | 0x46c, 0xbbbb10, /* Digital output selection1-3 */ | ||
309 | 0x470, 0x101010, /* Digital output selection4-6 */ | ||
310 | |||
311 | 0x478, 0x00, /* Sound feature control */ | ||
312 | |||
313 | 0x474, 0x18, /* Softmute control */ | ||
314 | |||
315 | 0x454, 0x0425b9, /* Sound Easy programming(reset) */ | ||
316 | 0x454, 0x042539, /* Sound Easy programming(reset) */ | ||
317 | |||
318 | |||
319 | /**** common setting( of DVD play, including scaler commands) ****/ | ||
320 | 0x042, 0x003, /* Data path configuration for VBI (TASK A) */ | ||
321 | |||
322 | 0x082, 0x003, /* Data path configuration for VBI (TASK B) */ | ||
323 | |||
324 | 0x108, 0x0f8, /* Sync control */ | ||
325 | 0x2a9, 0x0fd, /* ??? */ | ||
326 | 0x102, 0x089, /* select video input "mode 9" */ | ||
327 | 0x111, 0x000, /* Mode/delay control */ | ||
328 | |||
329 | 0x10e, 0x00a, /* Chroma control 1 */ | ||
330 | |||
331 | 0x594, 0x002, /* SIF, analog I/O select */ | ||
332 | |||
333 | 0x454, 0x0425b9, /* Sound */ | ||
334 | 0x454, 0x042539, | ||
335 | |||
336 | 0x111, 0x000, | ||
337 | 0x10e, 0x00a, | ||
338 | 0x464, 0x000, | ||
339 | 0x300, 0x000, | ||
340 | 0x301, 0x006, | ||
341 | 0x302, 0x000, | ||
342 | 0x303, 0x006, | ||
343 | 0x308, 0x040, | ||
344 | 0x309, 0x000, | ||
345 | 0x30a, 0x000, | ||
346 | 0x30b, 0x000, | ||
347 | 0x000, 0x002, | ||
348 | 0x001, 0x000, | ||
349 | 0x002, 0x000, | ||
350 | 0x003, 0x000, | ||
351 | 0x004, 0x033, | ||
352 | 0x040, 0x01d, | ||
353 | 0x041, 0x001, | ||
354 | 0x042, 0x004, | ||
355 | 0x043, 0x000, | ||
356 | 0x080, 0x01e, | ||
357 | 0x081, 0x001, | ||
358 | 0x082, 0x004, | ||
359 | 0x083, 0x000, | ||
360 | 0x190, 0x018, | ||
361 | 0x115, 0x000, | ||
362 | 0x116, 0x012, | ||
363 | 0x117, 0x018, | ||
364 | 0x04a, 0x011, | ||
365 | 0x08a, 0x011, | ||
366 | 0x04b, 0x000, | ||
367 | 0x08b, 0x000, | ||
368 | 0x048, 0x000, | ||
369 | 0x088, 0x000, | ||
370 | 0x04e, 0x012, | ||
371 | 0x08e, 0x012, | ||
372 | 0x058, 0x012, | ||
373 | 0x098, 0x012, | ||
374 | 0x059, 0x000, | ||
375 | 0x099, 0x000, | ||
376 | 0x05a, 0x003, | ||
377 | 0x09a, 0x003, | ||
378 | 0x05b, 0x001, | ||
379 | 0x09b, 0x001, | ||
380 | 0x054, 0x008, | ||
381 | 0x094, 0x008, | ||
382 | 0x055, 0x000, | ||
383 | 0x095, 0x000, | ||
384 | 0x056, 0x0c7, | ||
385 | 0x096, 0x0c7, | ||
386 | 0x057, 0x002, | ||
387 | 0x097, 0x002, | ||
388 | 0x0ff, 0x0ff, | ||
389 | 0x060, 0x001, | ||
390 | 0x0a0, 0x001, | ||
391 | 0x061, 0x000, | ||
392 | 0x0a1, 0x000, | ||
393 | 0x062, 0x000, | ||
394 | 0x0a2, 0x000, | ||
395 | 0x063, 0x000, | ||
396 | 0x0a3, 0x000, | ||
397 | 0x070, 0x000, | ||
398 | 0x0b0, 0x000, | ||
399 | 0x071, 0x004, | ||
400 | 0x0b1, 0x004, | ||
401 | 0x06c, 0x0e9, | ||
402 | 0x0ac, 0x0e9, | ||
403 | 0x06d, 0x003, | ||
404 | 0x0ad, 0x003, | ||
405 | 0x05c, 0x0d0, | ||
406 | 0x09c, 0x0d0, | ||
407 | 0x05d, 0x002, | ||
408 | 0x09d, 0x002, | ||
409 | 0x05e, 0x0f2, | ||
410 | 0x09e, 0x0f2, | ||
411 | 0x05f, 0x000, | ||
412 | 0x09f, 0x000, | ||
413 | 0x074, 0x000, | ||
414 | 0x0b4, 0x000, | ||
415 | 0x075, 0x000, | ||
416 | 0x0b5, 0x000, | ||
417 | 0x076, 0x000, | ||
418 | 0x0b6, 0x000, | ||
419 | 0x077, 0x000, | ||
420 | 0x0b7, 0x000, | ||
421 | 0x195, 0x008, | ||
422 | 0x0ff, 0x0ff, | ||
423 | 0x108, 0x0f8, | ||
424 | 0x111, 0x000, | ||
425 | 0x10e, 0x00a, | ||
426 | 0x2a9, 0x0fd, | ||
427 | 0x464, 0x001, | ||
428 | 0x454, 0x042135, | ||
429 | 0x598, 0x0e7, | ||
430 | 0x599, 0x07d, | ||
431 | 0x59a, 0x018, | ||
432 | 0x59c, 0x066, | ||
433 | 0x59d, 0x090, | ||
434 | 0x59e, 0x001, | ||
435 | 0x584, 0x000, | ||
436 | 0x585, 0x000, | ||
437 | 0x586, 0x003, | ||
438 | 0x588, 0x0ff, | ||
439 | 0x589, 0x00f, | ||
440 | 0x58a, 0x000, | ||
441 | 0x58b, 0x000, | ||
442 | 0x58c, 0x010, | ||
443 | 0x58d, 0x032, | ||
444 | 0x58e, 0x054, | ||
445 | 0x58f, 0x023, | ||
446 | 0x590, 0x000, | ||
447 | 0x595, 0x000, | ||
448 | 0x596, 0x000, | ||
449 | 0x597, 0x000, | ||
450 | 0x464, 0x000, | ||
451 | 0x46c, 0xbbbb10, | ||
452 | 0x470, 0x101010, | ||
453 | |||
454 | |||
455 | 0x478, 0x000, | ||
456 | 0x474, 0x018, | ||
457 | 0x454, 0x042135, | ||
458 | 0x598, 0x0e7, | ||
459 | 0x599, 0x07d, | ||
460 | 0x59a, 0x018, | ||
461 | 0x59c, 0x066, | ||
462 | 0x59d, 0x090, | ||
463 | 0x59e, 0x001, | ||
464 | 0x584, 0x000, | ||
465 | 0x585, 0x000, | ||
466 | 0x586, 0x003, | ||
467 | 0x588, 0x0ff, | ||
468 | 0x589, 0x00f, | ||
469 | 0x58a, 0x000, | ||
470 | 0x58b, 0x000, | ||
471 | 0x58c, 0x010, | ||
472 | 0x58d, 0x032, | ||
473 | 0x58e, 0x054, | ||
474 | 0x58f, 0x023, | ||
475 | 0x590, 0x000, | ||
476 | 0x595, 0x000, | ||
477 | 0x596, 0x000, | ||
478 | 0x597, 0x000, | ||
479 | 0x464, 0x000, | ||
480 | 0x46c, 0xbbbb10, | ||
481 | 0x470, 0x101010, | ||
482 | |||
483 | 0x478, 0x000, | ||
484 | 0x474, 0x018, | ||
485 | 0x454, 0x042135, | ||
486 | 0x598, 0x0e7, | ||
487 | 0x599, 0x07d, | ||
488 | 0x59a, 0x018, | ||
489 | 0x59c, 0x066, | ||
490 | 0x59d, 0x090, | ||
491 | 0x59e, 0x001, | ||
492 | 0x584, 0x000, | ||
493 | 0x585, 0x000, | ||
494 | 0x586, 0x003, | ||
495 | 0x588, 0x0ff, | ||
496 | 0x589, 0x00f, | ||
497 | 0x58a, 0x000, | ||
498 | 0x58b, 0x000, | ||
499 | 0x58c, 0x010, | ||
500 | 0x58d, 0x032, | ||
501 | 0x58e, 0x054, | ||
502 | 0x58f, 0x023, | ||
503 | 0x590, 0x000, | ||
504 | 0x595, 0x000, | ||
505 | 0x596, 0x000, | ||
506 | 0x597, 0x000, | ||
507 | 0x464, 0x000, | ||
508 | 0x46c, 0xbbbb10, | ||
509 | 0x470, 0x101010, | ||
510 | 0x478, 0x000, | ||
511 | 0x474, 0x018, | ||
512 | 0x454, 0x042135, | ||
513 | 0x193, 0x000, | ||
514 | 0x300, 0x000, | ||
515 | 0x301, 0x006, | ||
516 | 0x302, 0x000, | ||
517 | 0x303, 0x006, | ||
518 | 0x308, 0x040, | ||
519 | 0x309, 0x000, | ||
520 | 0x30a, 0x000, | ||
521 | 0x30b, 0x000, | ||
522 | 0x000, 0x002, | ||
523 | 0x001, 0x000, | ||
524 | 0x002, 0x000, | ||
525 | 0x003, 0x000, | ||
526 | 0x004, 0x033, | ||
527 | 0x040, 0x01d, | ||
528 | 0x041, 0x001, | ||
529 | 0x042, 0x004, | ||
530 | 0x043, 0x000, | ||
531 | 0x080, 0x01e, | ||
532 | 0x081, 0x001, | ||
533 | 0x082, 0x004, | ||
534 | 0x083, 0x000, | ||
535 | 0x190, 0x018, | ||
536 | 0x115, 0x000, | ||
537 | 0x116, 0x012, | ||
538 | 0x117, 0x018, | ||
539 | 0x04a, 0x011, | ||
540 | 0x08a, 0x011, | ||
541 | 0x04b, 0x000, | ||
542 | 0x08b, 0x000, | ||
543 | 0x048, 0x000, | ||
544 | 0x088, 0x000, | ||
545 | 0x04e, 0x012, | ||
546 | 0x08e, 0x012, | ||
547 | 0x058, 0x012, | ||
548 | 0x098, 0x012, | ||
549 | 0x059, 0x000, | ||
550 | 0x099, 0x000, | ||
551 | 0x05a, 0x003, | ||
552 | 0x09a, 0x003, | ||
553 | 0x05b, 0x001, | ||
554 | 0x09b, 0x001, | ||
555 | 0x054, 0x008, | ||
556 | 0x094, 0x008, | ||
557 | 0x055, 0x000, | ||
558 | 0x095, 0x000, | ||
559 | 0x056, 0x0c7, | ||
560 | 0x096, 0x0c7, | ||
561 | 0x057, 0x002, | ||
562 | 0x097, 0x002, | ||
563 | 0x060, 0x001, | ||
564 | 0x0a0, 0x001, | ||
565 | 0x061, 0x000, | ||
566 | 0x0a1, 0x000, | ||
567 | 0x062, 0x000, | ||
568 | 0x0a2, 0x000, | ||
569 | 0x063, 0x000, | ||
570 | 0x0a3, 0x000, | ||
571 | 0x070, 0x000, | ||
572 | 0x0b0, 0x000, | ||
573 | 0x071, 0x004, | ||
574 | 0x0b1, 0x004, | ||
575 | 0x06c, 0x0e9, | ||
576 | 0x0ac, 0x0e9, | ||
577 | 0x06d, 0x003, | ||
578 | 0x0ad, 0x003, | ||
579 | 0x05c, 0x0d0, | ||
580 | 0x09c, 0x0d0, | ||
581 | 0x05d, 0x002, | ||
582 | 0x09d, 0x002, | ||
583 | 0x05e, 0x0f2, | ||
584 | 0x09e, 0x0f2, | ||
585 | 0x05f, 0x000, | ||
586 | 0x09f, 0x000, | ||
587 | 0x074, 0x000, | ||
588 | 0x0b4, 0x000, | ||
589 | 0x075, 0x000, | ||
590 | 0x0b5, 0x000, | ||
591 | 0x076, 0x000, | ||
592 | 0x0b6, 0x000, | ||
593 | 0x077, 0x000, | ||
594 | 0x0b7, 0x000, | ||
595 | 0x195, 0x008, | ||
596 | 0x598, 0x0e7, | ||
597 | 0x599, 0x07d, | ||
598 | 0x59a, 0x018, | ||
599 | 0x59c, 0x066, | ||
600 | 0x59d, 0x090, | ||
601 | 0x59e, 0x001, | ||
602 | 0x584, 0x000, | ||
603 | 0x585, 0x000, | ||
604 | 0x586, 0x003, | ||
605 | 0x588, 0x0ff, | ||
606 | 0x589, 0x00f, | ||
607 | 0x58a, 0x000, | ||
608 | 0x58b, 0x000, | ||
609 | 0x58c, 0x010, | ||
610 | 0x58d, 0x032, | ||
611 | 0x58e, 0x054, | ||
612 | 0x58f, 0x023, | ||
613 | 0x590, 0x000, | ||
614 | 0x595, 0x000, | ||
615 | 0x596, 0x000, | ||
616 | 0x597, 0x000, | ||
617 | 0x464, 0x000, | ||
618 | 0x46c, 0xbbbb10, | ||
619 | 0x470, 0x101010, | ||
620 | 0x478, 0x000, | ||
621 | 0x474, 0x018, | ||
622 | 0x454, 0x042135, | ||
623 | 0x193, 0x0a6, | ||
624 | 0x108, 0x0f8, | ||
625 | 0x042, 0x003, | ||
626 | 0x082, 0x003, | ||
627 | 0x454, 0x0425b9, | ||
628 | 0x454, 0x042539, | ||
629 | 0x193, 0x000, | ||
630 | 0x193, 0x0a6, | ||
631 | 0x464, 0x000, | ||
632 | |||
633 | 0, 0 | ||
634 | }; | ||
635 | |||
636 | /* Tuner */ | ||
637 | static u32 reg_init_tuner_input[] = { | ||
638 | 0x108, 0x0f8, /* Sync control */ | ||
639 | 0x111, 0x000, /* Mode/delay control */ | ||
640 | 0x10e, 0x00a, /* Chroma control 1 */ | ||
641 | 0, 0 | ||
642 | }; | ||
643 | |||
644 | /* Composite */ | ||
645 | static u32 reg_init_composite_input[] = { | ||
646 | 0x108, 0x0e8, /* Sync control */ | ||
647 | 0x111, 0x000, /* Mode/delay control */ | ||
648 | 0x10e, 0x04a, /* Chroma control 1 */ | ||
649 | 0, 0 | ||
650 | }; | ||
651 | |||
652 | /* S-Video */ | ||
653 | static u32 reg_init_svideo_input[] = { | ||
654 | 0x108, 0x0e8, /* Sync control */ | ||
655 | 0x111, 0x000, /* Mode/delay control */ | ||
656 | 0x10e, 0x04a, /* Chroma control 1 */ | ||
657 | 0, 0 | ||
658 | }; | ||
659 | |||
660 | static u32 reg_set_audio_template[4][2] = | ||
661 | { | ||
662 | { /* for MONO | ||
663 | tadachi 6/29 DMA audio output select? | ||
664 | Register 0x46c | ||
665 | 7-4: DMA2, 3-0: DMA1 ch. DMA4, DMA3 DMA2, DMA1 | ||
666 | 0: MAIN left, 1: MAIN right | ||
667 | 2: AUX1 left, 3: AUX1 right | ||
668 | 4: AUX2 left, 5: AUX2 right | ||
669 | 6: DPL left, 7: DPL right | ||
670 | 8: DPL center, 9: DPL surround | ||
671 | A: monitor output, B: digital sense */ | ||
672 | 0xbbbb00, | ||
673 | |||
674 | /* tadachi 6/29 DAC and I2S output select? | ||
675 | Register 0x470 | ||
676 | 7-4:DAC right ch. 3-0:DAC left ch. | ||
677 | I2S1 right,left I2S2 right,left */ | ||
678 | 0x00, | ||
679 | }, | ||
680 | { /* for STEREO */ | ||
681 | 0xbbbb10, 0x101010, | ||
682 | }, | ||
683 | { /* for LANG1 */ | ||
684 | 0xbbbb00, 0x00, | ||
685 | }, | ||
686 | { /* for LANG2/SAP */ | ||
687 | 0xbbbb11, 0x111111, | ||
688 | } | ||
689 | }; | ||
690 | |||
691 | |||
692 | /* Get detected audio flags (from saa7134 driver) */ | ||
693 | static void get_inf_dev_status(struct v4l2_subdev *sd, | ||
694 | int *dual_flag, int *stereo_flag) | ||
695 | { | ||
696 | u32 reg_data3; | ||
697 | |||
698 | static char *stdres[0x20] = { | ||
699 | [0x00] = "no standard detected", | ||
700 | [0x01] = "B/G (in progress)", | ||
701 | [0x02] = "D/K (in progress)", | ||
702 | [0x03] = "M (in progress)", | ||
703 | |||
704 | [0x04] = "B/G A2", | ||
705 | [0x05] = "B/G NICAM", | ||
706 | [0x06] = "D/K A2 (1)", | ||
707 | [0x07] = "D/K A2 (2)", | ||
708 | [0x08] = "D/K A2 (3)", | ||
709 | [0x09] = "D/K NICAM", | ||
710 | [0x0a] = "L NICAM", | ||
711 | [0x0b] = "I NICAM", | ||
712 | |||
713 | [0x0c] = "M Korea", | ||
714 | [0x0d] = "M BTSC ", | ||
715 | [0x0e] = "M EIAJ", | ||
716 | |||
717 | [0x0f] = "FM radio / IF 10.7 / 50 deemp", | ||
718 | [0x10] = "FM radio / IF 10.7 / 75 deemp", | ||
719 | [0x11] = "FM radio / IF sel / 50 deemp", | ||
720 | [0x12] = "FM radio / IF sel / 75 deemp", | ||
721 | |||
722 | [0x13 ... 0x1e] = "unknown", | ||
723 | [0x1f] = "??? [in progress]", | ||
724 | }; | ||
725 | |||
726 | |||
727 | *dual_flag = *stereo_flag = 0; | ||
728 | |||
729 | /* (demdec status: 0x528) */ | ||
730 | |||
731 | /* read current status */ | ||
732 | reg_data3 = saa717x_read(sd, 0x0528); | ||
733 | |||
734 | v4l2_dbg(1, debug, sd, "tvaudio thread status: 0x%x [%s%s%s]\n", | ||
735 | reg_data3, stdres[reg_data3 & 0x1f], | ||
736 | (reg_data3 & 0x000020) ? ",stereo" : "", | ||
737 | (reg_data3 & 0x000040) ? ",dual" : ""); | ||
738 | v4l2_dbg(1, debug, sd, "detailed status: " | ||
739 | "%s#%s#%s#%s#%s#%s#%s#%s#%s#%s#%s#%s#%s#%s\n", | ||
740 | (reg_data3 & 0x000080) ? " A2/EIAJ pilot tone " : "", | ||
741 | (reg_data3 & 0x000100) ? " A2/EIAJ dual " : "", | ||
742 | (reg_data3 & 0x000200) ? " A2/EIAJ stereo " : "", | ||
743 | (reg_data3 & 0x000400) ? " A2/EIAJ noise mute " : "", | ||
744 | |||
745 | (reg_data3 & 0x000800) ? " BTSC/FM radio pilot " : "", | ||
746 | (reg_data3 & 0x001000) ? " SAP carrier " : "", | ||
747 | (reg_data3 & 0x002000) ? " BTSC stereo noise mute " : "", | ||
748 | (reg_data3 & 0x004000) ? " SAP noise mute " : "", | ||
749 | (reg_data3 & 0x008000) ? " VDSP " : "", | ||
750 | |||
751 | (reg_data3 & 0x010000) ? " NICST " : "", | ||
752 | (reg_data3 & 0x020000) ? " NICDU " : "", | ||
753 | (reg_data3 & 0x040000) ? " NICAM muted " : "", | ||
754 | (reg_data3 & 0x080000) ? " NICAM reserve sound " : "", | ||
755 | |||
756 | (reg_data3 & 0x100000) ? " init done " : ""); | ||
757 | |||
758 | if (reg_data3 & 0x000220) { | ||
759 | v4l2_dbg(1, debug, sd, "ST!!!\n"); | ||
760 | *stereo_flag = 1; | ||
761 | } | ||
762 | |||
763 | if (reg_data3 & 0x000140) { | ||
764 | v4l2_dbg(1, debug, sd, "DUAL!!!\n"); | ||
765 | *dual_flag = 1; | ||
766 | } | ||
767 | } | ||
768 | |||
769 | /* regs write to set audio mode */ | ||
770 | static void set_audio_mode(struct v4l2_subdev *sd, int audio_mode) | ||
771 | { | ||
772 | v4l2_dbg(1, debug, sd, "writing registers to set audio mode by set %d\n", | ||
773 | audio_mode); | ||
774 | |||
775 | saa717x_write(sd, 0x46c, reg_set_audio_template[audio_mode][0]); | ||
776 | saa717x_write(sd, 0x470, reg_set_audio_template[audio_mode][1]); | ||
777 | } | ||
778 | |||
779 | /* write regs to set audio volume, bass and treble */ | ||
780 | static int set_audio_regs(struct v4l2_subdev *sd, | ||
781 | struct saa717x_state *decoder) | ||
782 | { | ||
783 | u8 mute = 0xac; /* -84 dB */ | ||
784 | u32 val; | ||
785 | unsigned int work_l, work_r; | ||
786 | |||
787 | /* set SIF analog I/O select */ | ||
788 | saa717x_write(sd, 0x0594, decoder->audio_input); | ||
789 | v4l2_dbg(1, debug, sd, "set audio input %d\n", | ||
790 | decoder->audio_input); | ||
791 | |||
792 | /* normalize ( 65535 to 0 -> 24 to -40 (not -84)) */ | ||
793 | work_l = (min(65536 - decoder->audio_main_balance, 32768) * decoder->audio_main_volume) / 32768; | ||
794 | work_r = (min(decoder->audio_main_balance, (u16)32768) * decoder->audio_main_volume) / 32768; | ||
795 | decoder->audio_main_vol_l = (long)work_l * (24 - (-40)) / 65535 - 40; | ||
796 | decoder->audio_main_vol_r = (long)work_r * (24 - (-40)) / 65535 - 40; | ||
797 | |||
798 | /* set main volume */ | ||
799 | /* main volume L[7-0],R[7-0],0x00 24=24dB,-83dB, -84(mute) */ | ||
800 | /* def:0dB->6dB(MPG600GR) */ | ||
801 | /* if mute is on, set mute */ | ||
802 | if (decoder->audio_main_mute) { | ||
803 | val = mute | (mute << 8); | ||
804 | } else { | ||
805 | val = (u8)decoder->audio_main_vol_l | | ||
806 | ((u8)decoder->audio_main_vol_r << 8); | ||
807 | } | ||
808 | |||
809 | saa717x_write(sd, 0x480, val); | ||
810 | |||
811 | /* set bass and treble */ | ||
812 | val = decoder->audio_main_bass & 0x1f; | ||
813 | val |= (decoder->audio_main_treble & 0x1f) << 5; | ||
814 | saa717x_write(sd, 0x488, val); | ||
815 | return 0; | ||
816 | } | ||
817 | |||
818 | /********** scaling staff ***********/ | ||
819 | static void set_h_prescale(struct v4l2_subdev *sd, | ||
820 | int task, int prescale) | ||
821 | { | ||
822 | static const struct { | ||
823 | int xpsc; | ||
824 | int xacl; | ||
825 | int xc2_1; | ||
826 | int xdcg; | ||
827 | int vpfy; | ||
828 | } vals[] = { | ||
829 | /* XPSC XACL XC2_1 XDCG VPFY */ | ||
830 | { 1, 0, 0, 0, 0 }, | ||
831 | { 2, 2, 1, 2, 2 }, | ||
832 | { 3, 4, 1, 3, 2 }, | ||
833 | { 4, 8, 1, 4, 2 }, | ||
834 | { 5, 8, 1, 4, 2 }, | ||
835 | { 6, 8, 1, 4, 3 }, | ||
836 | { 7, 8, 1, 4, 3 }, | ||
837 | { 8, 15, 0, 4, 3 }, | ||
838 | { 9, 15, 0, 4, 3 }, | ||
839 | { 10, 16, 1, 5, 3 }, | ||
840 | }; | ||
841 | static const int count = ARRAY_SIZE(vals); | ||
842 | int i, task_shift; | ||
843 | |||
844 | task_shift = task * 0x40; | ||
845 | for (i = 0; i < count; i++) | ||
846 | if (vals[i].xpsc == prescale) | ||
847 | break; | ||
848 | if (i == count) | ||
849 | return; | ||
850 | |||
851 | /* horizonal prescaling */ | ||
852 | saa717x_write(sd, 0x60 + task_shift, vals[i].xpsc); | ||
853 | /* accumulation length */ | ||
854 | saa717x_write(sd, 0x61 + task_shift, vals[i].xacl); | ||
855 | /* level control */ | ||
856 | saa717x_write(sd, 0x62 + task_shift, | ||
857 | (vals[i].xc2_1 << 3) | vals[i].xdcg); | ||
858 | /*FIR prefilter control */ | ||
859 | saa717x_write(sd, 0x63 + task_shift, | ||
860 | (vals[i].vpfy << 2) | vals[i].vpfy); | ||
861 | } | ||
862 | |||
863 | /********** scaling staff ***********/ | ||
864 | static void set_v_scale(struct v4l2_subdev *sd, int task, int yscale) | ||
865 | { | ||
866 | int task_shift; | ||
867 | |||
868 | task_shift = task * 0x40; | ||
869 | /* Vertical scaling ratio (LOW) */ | ||
870 | saa717x_write(sd, 0x70 + task_shift, yscale & 0xff); | ||
871 | /* Vertical scaling ratio (HI) */ | ||
872 | saa717x_write(sd, 0x71 + task_shift, yscale >> 8); | ||
873 | } | ||
874 | |||
875 | static int saa717x_s_ctrl(struct v4l2_ctrl *ctrl) | ||
876 | { | ||
877 | struct v4l2_subdev *sd = to_sd(ctrl); | ||
878 | struct saa717x_state *state = to_state(sd); | ||
879 | |||
880 | switch (ctrl->id) { | ||
881 | case V4L2_CID_BRIGHTNESS: | ||
882 | saa717x_write(sd, 0x10a, ctrl->val); | ||
883 | return 0; | ||
884 | |||
885 | case V4L2_CID_CONTRAST: | ||
886 | saa717x_write(sd, 0x10b, ctrl->val); | ||
887 | return 0; | ||
888 | |||
889 | case V4L2_CID_SATURATION: | ||
890 | saa717x_write(sd, 0x10c, ctrl->val); | ||
891 | return 0; | ||
892 | |||
893 | case V4L2_CID_HUE: | ||
894 | saa717x_write(sd, 0x10d, ctrl->val); | ||
895 | return 0; | ||
896 | |||
897 | case V4L2_CID_AUDIO_MUTE: | ||
898 | state->audio_main_mute = ctrl->val; | ||
899 | break; | ||
900 | |||
901 | case V4L2_CID_AUDIO_VOLUME: | ||
902 | state->audio_main_volume = ctrl->val; | ||
903 | break; | ||
904 | |||
905 | case V4L2_CID_AUDIO_BALANCE: | ||
906 | state->audio_main_balance = ctrl->val; | ||
907 | break; | ||
908 | |||
909 | case V4L2_CID_AUDIO_TREBLE: | ||
910 | state->audio_main_treble = ctrl->val; | ||
911 | break; | ||
912 | |||
913 | case V4L2_CID_AUDIO_BASS: | ||
914 | state->audio_main_bass = ctrl->val; | ||
915 | break; | ||
916 | |||
917 | default: | ||
918 | return 0; | ||
919 | } | ||
920 | set_audio_regs(sd, state); | ||
921 | return 0; | ||
922 | } | ||
923 | |||
924 | static int saa717x_s_video_routing(struct v4l2_subdev *sd, | ||
925 | u32 input, u32 output, u32 config) | ||
926 | { | ||
927 | struct saa717x_state *decoder = to_state(sd); | ||
928 | int is_tuner = input & 0x80; /* tuner input flag */ | ||
929 | |||
930 | input &= 0x7f; | ||
931 | |||
932 | v4l2_dbg(1, debug, sd, "decoder set input (%d)\n", input); | ||
933 | /* inputs from 0-9 are available*/ | ||
934 | /* saa717x have mode0-mode9 but mode5 is reserved. */ | ||
935 | if (input > 9 || input == 5) | ||
936 | return -EINVAL; | ||
937 | |||
938 | if (decoder->input != input) { | ||
939 | int input_line = input; | ||
940 | |||
941 | decoder->input = input_line; | ||
942 | v4l2_dbg(1, debug, sd, "now setting %s input %d\n", | ||
943 | input_line >= 6 ? "S-Video" : "Composite", | ||
944 | input_line); | ||
945 | |||
946 | /* select mode */ | ||
947 | saa717x_write(sd, 0x102, | ||
948 | (saa717x_read(sd, 0x102) & 0xf0) | | ||
949 | input_line); | ||
950 | |||
951 | /* bypass chrominance trap for modes 6..9 */ | ||
952 | saa717x_write(sd, 0x109, | ||
953 | (saa717x_read(sd, 0x109) & 0x7f) | | ||
954 | (input_line < 6 ? 0x0 : 0x80)); | ||
955 | |||
956 | /* change audio_mode */ | ||
957 | if (is_tuner) { | ||
958 | /* tuner */ | ||
959 | set_audio_mode(sd, decoder->tuner_audio_mode); | ||
960 | } else { | ||
961 | /* Force to STEREO mode if Composite or | ||
962 | * S-Video were chosen */ | ||
963 | set_audio_mode(sd, TUNER_AUDIO_STEREO); | ||
964 | } | ||
965 | /* change initialize procedure (Composite/S-Video) */ | ||
966 | if (is_tuner) | ||
967 | saa717x_write_regs(sd, reg_init_tuner_input); | ||
968 | else if (input_line >= 6) | ||
969 | saa717x_write_regs(sd, reg_init_svideo_input); | ||
970 | else | ||
971 | saa717x_write_regs(sd, reg_init_composite_input); | ||
972 | } | ||
973 | |||
974 | return 0; | ||
975 | } | ||
976 | |||
977 | #ifdef CONFIG_VIDEO_ADV_DEBUG | ||
978 | static int saa717x_g_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg) | ||
979 | { | ||
980 | struct i2c_client *client = v4l2_get_subdevdata(sd); | ||
981 | |||
982 | if (!v4l2_chip_match_i2c_client(client, ®->match)) | ||
983 | return -EINVAL; | ||
984 | if (!capable(CAP_SYS_ADMIN)) | ||
985 | return -EPERM; | ||
986 | reg->val = saa717x_read(sd, reg->reg); | ||
987 | reg->size = 1; | ||
988 | return 0; | ||
989 | } | ||
990 | |||
991 | static int saa717x_s_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg) | ||
992 | { | ||
993 | struct i2c_client *client = v4l2_get_subdevdata(sd); | ||
994 | u16 addr = reg->reg & 0xffff; | ||
995 | u8 val = reg->val & 0xff; | ||
996 | |||
997 | if (!v4l2_chip_match_i2c_client(client, ®->match)) | ||
998 | return -EINVAL; | ||
999 | if (!capable(CAP_SYS_ADMIN)) | ||
1000 | return -EPERM; | ||
1001 | saa717x_write(sd, addr, val); | ||
1002 | return 0; | ||
1003 | } | ||
1004 | #endif | ||
1005 | |||
1006 | static int saa717x_s_mbus_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *fmt) | ||
1007 | { | ||
1008 | int prescale, h_scale, v_scale; | ||
1009 | |||
1010 | v4l2_dbg(1, debug, sd, "decoder set size\n"); | ||
1011 | |||
1012 | if (fmt->code != V4L2_MBUS_FMT_FIXED) | ||
1013 | return -EINVAL; | ||
1014 | |||
1015 | /* FIXME need better bounds checking here */ | ||
1016 | if (fmt->width < 1 || fmt->width > 1440) | ||
1017 | return -EINVAL; | ||
1018 | if (fmt->height < 1 || fmt->height > 960) | ||
1019 | return -EINVAL; | ||
1020 | |||
1021 | fmt->field = V4L2_FIELD_INTERLACED; | ||
1022 | fmt->colorspace = V4L2_COLORSPACE_SMPTE170M; | ||
1023 | |||
1024 | /* scaling setting */ | ||
1025 | /* NTSC and interlace only */ | ||
1026 | prescale = SAA717X_NTSC_WIDTH / fmt->width; | ||
1027 | if (prescale == 0) | ||
1028 | prescale = 1; | ||
1029 | h_scale = 1024 * SAA717X_NTSC_WIDTH / prescale / fmt->width; | ||
1030 | /* interlace */ | ||
1031 | v_scale = 512 * 2 * SAA717X_NTSC_HEIGHT / fmt->height; | ||
1032 | |||
1033 | /* Horizontal prescaling etc */ | ||
1034 | set_h_prescale(sd, 0, prescale); | ||
1035 | set_h_prescale(sd, 1, prescale); | ||
1036 | |||
1037 | /* Horizontal scaling increment */ | ||
1038 | /* TASK A */ | ||
1039 | saa717x_write(sd, 0x6C, (u8)(h_scale & 0xFF)); | ||
1040 | saa717x_write(sd, 0x6D, (u8)((h_scale >> 8) & 0xFF)); | ||
1041 | /* TASK B */ | ||
1042 | saa717x_write(sd, 0xAC, (u8)(h_scale & 0xFF)); | ||
1043 | saa717x_write(sd, 0xAD, (u8)((h_scale >> 8) & 0xFF)); | ||
1044 | |||
1045 | /* Vertical prescaling etc */ | ||
1046 | set_v_scale(sd, 0, v_scale); | ||
1047 | set_v_scale(sd, 1, v_scale); | ||
1048 | |||
1049 | /* set video output size */ | ||
1050 | /* video number of pixels at output */ | ||
1051 | /* TASK A */ | ||
1052 | saa717x_write(sd, 0x5C, (u8)(fmt->width & 0xFF)); | ||
1053 | saa717x_write(sd, 0x5D, (u8)((fmt->width >> 8) & 0xFF)); | ||
1054 | /* TASK B */ | ||
1055 | saa717x_write(sd, 0x9C, (u8)(fmt->width & 0xFF)); | ||
1056 | saa717x_write(sd, 0x9D, (u8)((fmt->width >> 8) & 0xFF)); | ||
1057 | |||
1058 | /* video number of lines at output */ | ||
1059 | /* TASK A */ | ||
1060 | saa717x_write(sd, 0x5E, (u8)(fmt->height & 0xFF)); | ||
1061 | saa717x_write(sd, 0x5F, (u8)((fmt->height >> 8) & 0xFF)); | ||
1062 | /* TASK B */ | ||
1063 | saa717x_write(sd, 0x9E, (u8)(fmt->height & 0xFF)); | ||
1064 | saa717x_write(sd, 0x9F, (u8)((fmt->height >> 8) & 0xFF)); | ||
1065 | return 0; | ||
1066 | } | ||
1067 | |||
1068 | static int saa717x_s_radio(struct v4l2_subdev *sd) | ||
1069 | { | ||
1070 | struct saa717x_state *decoder = to_state(sd); | ||
1071 | |||
1072 | decoder->radio = 1; | ||
1073 | return 0; | ||
1074 | } | ||
1075 | |||
1076 | static int saa717x_s_std(struct v4l2_subdev *sd, v4l2_std_id std) | ||
1077 | { | ||
1078 | struct saa717x_state *decoder = to_state(sd); | ||
1079 | |||
1080 | v4l2_dbg(1, debug, sd, "decoder set norm "); | ||
1081 | v4l2_dbg(1, debug, sd, "(not yet implementd)\n"); | ||
1082 | |||
1083 | decoder->radio = 0; | ||
1084 | decoder->std = std; | ||
1085 | return 0; | ||
1086 | } | ||
1087 | |||
1088 | static int saa717x_s_audio_routing(struct v4l2_subdev *sd, | ||
1089 | u32 input, u32 output, u32 config) | ||
1090 | { | ||
1091 | struct saa717x_state *decoder = to_state(sd); | ||
1092 | |||
1093 | if (input < 3) { /* FIXME! --tadachi */ | ||
1094 | decoder->audio_input = input; | ||
1095 | v4l2_dbg(1, debug, sd, | ||
1096 | "set decoder audio input to %d\n", | ||
1097 | decoder->audio_input); | ||
1098 | set_audio_regs(sd, decoder); | ||
1099 | return 0; | ||
1100 | } | ||
1101 | return -ERANGE; | ||
1102 | } | ||
1103 | |||
1104 | static int saa717x_s_stream(struct v4l2_subdev *sd, int enable) | ||
1105 | { | ||
1106 | struct saa717x_state *decoder = to_state(sd); | ||
1107 | |||
1108 | v4l2_dbg(1, debug, sd, "decoder %s output\n", | ||
1109 | enable ? "enable" : "disable"); | ||
1110 | decoder->enable = enable; | ||
1111 | saa717x_write(sd, 0x193, enable ? 0xa6 : 0x26); | ||
1112 | return 0; | ||
1113 | } | ||
1114 | |||
1115 | /* change audio mode */ | ||
1116 | static int saa717x_s_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt) | ||
1117 | { | ||
1118 | struct saa717x_state *decoder = to_state(sd); | ||
1119 | int audio_mode; | ||
1120 | char *mes[4] = { | ||
1121 | "MONO", "STEREO", "LANG1", "LANG2/SAP" | ||
1122 | }; | ||
1123 | |||
1124 | audio_mode = TUNER_AUDIO_STEREO; | ||
1125 | |||
1126 | switch (vt->audmode) { | ||
1127 | case V4L2_TUNER_MODE_MONO: | ||
1128 | audio_mode = TUNER_AUDIO_MONO; | ||
1129 | break; | ||
1130 | case V4L2_TUNER_MODE_STEREO: | ||
1131 | audio_mode = TUNER_AUDIO_STEREO; | ||
1132 | break; | ||
1133 | case V4L2_TUNER_MODE_LANG2: | ||
1134 | audio_mode = TUNER_AUDIO_LANG2; | ||
1135 | break; | ||
1136 | case V4L2_TUNER_MODE_LANG1: | ||
1137 | audio_mode = TUNER_AUDIO_LANG1; | ||
1138 | break; | ||
1139 | } | ||
1140 | |||
1141 | v4l2_dbg(1, debug, sd, "change audio mode to %s\n", | ||
1142 | mes[audio_mode]); | ||
1143 | decoder->tuner_audio_mode = audio_mode; | ||
1144 | /* The registers are not changed here. */ | ||
1145 | /* See DECODER_ENABLE_OUTPUT section. */ | ||
1146 | set_audio_mode(sd, decoder->tuner_audio_mode); | ||
1147 | return 0; | ||
1148 | } | ||
1149 | |||
1150 | static int saa717x_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt) | ||
1151 | { | ||
1152 | struct saa717x_state *decoder = to_state(sd); | ||
1153 | int dual_f, stereo_f; | ||
1154 | |||
1155 | if (decoder->radio) | ||
1156 | return 0; | ||
1157 | get_inf_dev_status(sd, &dual_f, &stereo_f); | ||
1158 | |||
1159 | v4l2_dbg(1, debug, sd, "DETECT==st:%d dual:%d\n", | ||
1160 | stereo_f, dual_f); | ||
1161 | |||
1162 | /* mono */ | ||
1163 | if ((dual_f == 0) && (stereo_f == 0)) { | ||
1164 | vt->rxsubchans = V4L2_TUNER_SUB_MONO; | ||
1165 | v4l2_dbg(1, debug, sd, "DETECT==MONO\n"); | ||
1166 | } | ||
1167 | |||
1168 | /* stereo */ | ||
1169 | if (stereo_f == 1) { | ||
1170 | if (vt->audmode == V4L2_TUNER_MODE_STEREO || | ||
1171 | vt->audmode == V4L2_TUNER_MODE_LANG1) { | ||
1172 | vt->rxsubchans = V4L2_TUNER_SUB_STEREO; | ||
1173 | v4l2_dbg(1, debug, sd, "DETECT==ST(ST)\n"); | ||
1174 | } else { | ||
1175 | vt->rxsubchans = V4L2_TUNER_SUB_MONO; | ||
1176 | v4l2_dbg(1, debug, sd, "DETECT==ST(MONO)\n"); | ||
1177 | } | ||
1178 | } | ||
1179 | |||
1180 | /* dual */ | ||
1181 | if (dual_f == 1) { | ||
1182 | if (vt->audmode == V4L2_TUNER_MODE_LANG2) { | ||
1183 | vt->rxsubchans = V4L2_TUNER_SUB_LANG2 | V4L2_TUNER_SUB_MONO; | ||
1184 | v4l2_dbg(1, debug, sd, "DETECT==DUAL1\n"); | ||
1185 | } else { | ||
1186 | vt->rxsubchans = V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_MONO; | ||
1187 | v4l2_dbg(1, debug, sd, "DETECT==DUAL2\n"); | ||
1188 | } | ||
1189 | } | ||
1190 | return 0; | ||
1191 | } | ||
1192 | |||
1193 | static int saa717x_log_status(struct v4l2_subdev *sd) | ||
1194 | { | ||
1195 | struct saa717x_state *state = to_state(sd); | ||
1196 | |||
1197 | v4l2_ctrl_handler_log_status(&state->hdl, sd->name); | ||
1198 | return 0; | ||
1199 | } | ||
1200 | |||
1201 | /* ----------------------------------------------------------------------- */ | ||
1202 | |||
1203 | static const struct v4l2_ctrl_ops saa717x_ctrl_ops = { | ||
1204 | .s_ctrl = saa717x_s_ctrl, | ||
1205 | }; | ||
1206 | |||
1207 | static const struct v4l2_subdev_core_ops saa717x_core_ops = { | ||
1208 | #ifdef CONFIG_VIDEO_ADV_DEBUG | ||
1209 | .g_register = saa717x_g_register, | ||
1210 | .s_register = saa717x_s_register, | ||
1211 | #endif | ||
1212 | .s_std = saa717x_s_std, | ||
1213 | .g_ext_ctrls = v4l2_subdev_g_ext_ctrls, | ||
1214 | .try_ext_ctrls = v4l2_subdev_try_ext_ctrls, | ||
1215 | .s_ext_ctrls = v4l2_subdev_s_ext_ctrls, | ||
1216 | .g_ctrl = v4l2_subdev_g_ctrl, | ||
1217 | .s_ctrl = v4l2_subdev_s_ctrl, | ||
1218 | .queryctrl = v4l2_subdev_queryctrl, | ||
1219 | .querymenu = v4l2_subdev_querymenu, | ||
1220 | .log_status = saa717x_log_status, | ||
1221 | }; | ||
1222 | |||
1223 | static const struct v4l2_subdev_tuner_ops saa717x_tuner_ops = { | ||
1224 | .g_tuner = saa717x_g_tuner, | ||
1225 | .s_tuner = saa717x_s_tuner, | ||
1226 | .s_radio = saa717x_s_radio, | ||
1227 | }; | ||
1228 | |||
1229 | static const struct v4l2_subdev_video_ops saa717x_video_ops = { | ||
1230 | .s_routing = saa717x_s_video_routing, | ||
1231 | .s_mbus_fmt = saa717x_s_mbus_fmt, | ||
1232 | .s_stream = saa717x_s_stream, | ||
1233 | }; | ||
1234 | |||
1235 | static const struct v4l2_subdev_audio_ops saa717x_audio_ops = { | ||
1236 | .s_routing = saa717x_s_audio_routing, | ||
1237 | }; | ||
1238 | |||
1239 | static const struct v4l2_subdev_ops saa717x_ops = { | ||
1240 | .core = &saa717x_core_ops, | ||
1241 | .tuner = &saa717x_tuner_ops, | ||
1242 | .audio = &saa717x_audio_ops, | ||
1243 | .video = &saa717x_video_ops, | ||
1244 | }; | ||
1245 | |||
1246 | /* ----------------------------------------------------------------------- */ | ||
1247 | |||
1248 | |||
1249 | /* i2c implementation */ | ||
1250 | |||
1251 | /* ----------------------------------------------------------------------- */ | ||
1252 | static int saa717x_probe(struct i2c_client *client, | ||
1253 | const struct i2c_device_id *did) | ||
1254 | { | ||
1255 | struct saa717x_state *decoder; | ||
1256 | struct v4l2_ctrl_handler *hdl; | ||
1257 | struct v4l2_subdev *sd; | ||
1258 | u8 id = 0; | ||
1259 | char *p = ""; | ||
1260 | |||
1261 | /* Check if the adapter supports the needed features */ | ||
1262 | if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) | ||
1263 | return -EIO; | ||
1264 | |||
1265 | decoder = kzalloc(sizeof(struct saa717x_state), GFP_KERNEL); | ||
1266 | if (decoder == NULL) | ||
1267 | return -ENOMEM; | ||
1268 | |||
1269 | sd = &decoder->sd; | ||
1270 | v4l2_i2c_subdev_init(sd, client, &saa717x_ops); | ||
1271 | |||
1272 | if (saa717x_write(sd, 0x5a4, 0xfe) && | ||
1273 | saa717x_write(sd, 0x5a5, 0x0f) && | ||
1274 | saa717x_write(sd, 0x5a6, 0x00) && | ||
1275 | saa717x_write(sd, 0x5a7, 0x01)) | ||
1276 | id = saa717x_read(sd, 0x5a0); | ||
1277 | if (id != 0xc2 && id != 0x32 && id != 0xf2 && id != 0x6c) { | ||
1278 | v4l2_dbg(1, debug, sd, "saa717x not found (id=%02x)\n", id); | ||
1279 | kfree(decoder); | ||
1280 | return -ENODEV; | ||
1281 | } | ||
1282 | if (id == 0xc2) | ||
1283 | p = "saa7173"; | ||
1284 | else if (id == 0x32) | ||
1285 | p = "saa7174A"; | ||
1286 | else if (id == 0x6c) | ||
1287 | p = "saa7174HL"; | ||
1288 | else | ||
1289 | p = "saa7171"; | ||
1290 | v4l2_info(sd, "%s found @ 0x%x (%s)\n", p, | ||
1291 | client->addr << 1, client->adapter->name); | ||
1292 | |||
1293 | hdl = &decoder->hdl; | ||
1294 | v4l2_ctrl_handler_init(hdl, 9); | ||
1295 | /* add in ascending ID order */ | ||
1296 | v4l2_ctrl_new_std(hdl, &saa717x_ctrl_ops, | ||
1297 | V4L2_CID_BRIGHTNESS, 0, 255, 1, 128); | ||
1298 | v4l2_ctrl_new_std(hdl, &saa717x_ctrl_ops, | ||
1299 | V4L2_CID_CONTRAST, 0, 255, 1, 68); | ||
1300 | v4l2_ctrl_new_std(hdl, &saa717x_ctrl_ops, | ||
1301 | V4L2_CID_SATURATION, 0, 255, 1, 64); | ||
1302 | v4l2_ctrl_new_std(hdl, &saa717x_ctrl_ops, | ||
1303 | V4L2_CID_HUE, -128, 127, 1, 0); | ||
1304 | v4l2_ctrl_new_std(hdl, &saa717x_ctrl_ops, | ||
1305 | V4L2_CID_AUDIO_VOLUME, 0, 65535, 65535 / 100, 42000); | ||
1306 | v4l2_ctrl_new_std(hdl, &saa717x_ctrl_ops, | ||
1307 | V4L2_CID_AUDIO_BALANCE, 0, 65535, 65535 / 100, 32768); | ||
1308 | v4l2_ctrl_new_std(hdl, &saa717x_ctrl_ops, | ||
1309 | V4L2_CID_AUDIO_BASS, -16, 15, 1, 0); | ||
1310 | v4l2_ctrl_new_std(hdl, &saa717x_ctrl_ops, | ||
1311 | V4L2_CID_AUDIO_TREBLE, -16, 15, 1, 0); | ||
1312 | v4l2_ctrl_new_std(hdl, &saa717x_ctrl_ops, | ||
1313 | V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0); | ||
1314 | sd->ctrl_handler = hdl; | ||
1315 | if (hdl->error) { | ||
1316 | int err = hdl->error; | ||
1317 | |||
1318 | v4l2_ctrl_handler_free(hdl); | ||
1319 | kfree(decoder); | ||
1320 | return err; | ||
1321 | } | ||
1322 | |||
1323 | decoder->std = V4L2_STD_NTSC; | ||
1324 | decoder->input = -1; | ||
1325 | decoder->enable = 1; | ||
1326 | |||
1327 | /* FIXME!! */ | ||
1328 | decoder->playback = 0; /* initially capture mode used */ | ||
1329 | decoder->audio = 1; /* DECODER_AUDIO_48_KHZ */ | ||
1330 | |||
1331 | decoder->audio_input = 2; /* FIXME!! */ | ||
1332 | |||
1333 | decoder->tuner_audio_mode = TUNER_AUDIO_STEREO; | ||
1334 | /* set volume, bass and treble */ | ||
1335 | decoder->audio_main_vol_l = 6; | ||
1336 | decoder->audio_main_vol_r = 6; | ||
1337 | |||
1338 | v4l2_dbg(1, debug, sd, "writing init values\n"); | ||
1339 | |||
1340 | /* FIXME!! */ | ||
1341 | saa717x_write_regs(sd, reg_init_initialize); | ||
1342 | |||
1343 | v4l2_ctrl_handler_setup(hdl); | ||
1344 | |||
1345 | set_current_state(TASK_INTERRUPTIBLE); | ||
1346 | schedule_timeout(2*HZ); | ||
1347 | return 0; | ||
1348 | } | ||
1349 | |||
1350 | static int saa717x_remove(struct i2c_client *client) | ||
1351 | { | ||
1352 | struct v4l2_subdev *sd = i2c_get_clientdata(client); | ||
1353 | |||
1354 | v4l2_device_unregister_subdev(sd); | ||
1355 | v4l2_ctrl_handler_free(sd->ctrl_handler); | ||
1356 | kfree(to_state(sd)); | ||
1357 | return 0; | ||
1358 | } | ||
1359 | |||
1360 | /* ----------------------------------------------------------------------- */ | ||
1361 | |||
1362 | static const struct i2c_device_id saa717x_id[] = { | ||
1363 | { "saa717x", 0 }, | ||
1364 | { } | ||
1365 | }; | ||
1366 | MODULE_DEVICE_TABLE(i2c, saa717x_id); | ||
1367 | |||
1368 | static struct i2c_driver saa717x_driver = { | ||
1369 | .driver = { | ||
1370 | .owner = THIS_MODULE, | ||
1371 | .name = "saa717x", | ||
1372 | }, | ||
1373 | .probe = saa717x_probe, | ||
1374 | .remove = saa717x_remove, | ||
1375 | .id_table = saa717x_id, | ||
1376 | }; | ||
1377 | |||
1378 | static __init int init_saa717x(void) | ||
1379 | { | ||
1380 | return i2c_add_driver(&saa717x_driver); | ||
1381 | } | ||
1382 | |||
1383 | static __exit void exit_saa717x(void) | ||
1384 | { | ||
1385 | i2c_del_driver(&saa717x_driver); | ||
1386 | } | ||
1387 | |||
1388 | module_init(init_saa717x); | ||
1389 | module_exit(exit_saa717x); | ||