?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'work.regset' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs
[linux/fpc-iii.git] / drivers / media / i2c / saa7115.c
blob88dc6baac6391bf4bb686eaacfc4122f8834292d
1 // SPDX-License-Identifier: GPL-2.0+
2 // saa711x - Philips SAA711x video decoder driver
3 // This driver can work with saa7111, saa7111a, saa7113, saa7114,
4 // saa7115 and saa7118.
5 //
6 // Based on saa7114 driver by Maxim Yevtyushkin, which is based on
7 // the saa7111 driver by Dave Perks.
8 //
9 // Copyright (C) 1998 Dave Perks <dperks@ibm.net>
10 // Copyright (C) 2002 Maxim Yevtyushkin <max@linuxmedialabs.com>
11 //
12 // Slight changes for video timing and attachment output by
13 // Wolfgang Scherr <scherr@net4you.net>
14 //
15 // Moved over to the linux >= 2.4.x i2c protocol (1/1/2003)
16 // by Ronald Bultje <rbultje@ronald.bitfreak.net>
17 //
18 // Added saa7115 support by Kevin Thayer <nufan_wfk at yahoo.com>
19 // (2/17/2003)
20 //
21 // VBI support (2004) and cleanups (2005) by Hans Verkuil <hverkuil@xs4all.nl>
22 //
23 // Copyright (c) 2005-2006 Mauro Carvalho Chehab <mchehab@kernel.org>
24 // SAA7111, SAA7113 and SAA7118 support
25
26 #include "saa711x_regs.h"
27
28 #include <linux/kernel.h>
29 #include <linux/module.h>
30 #include <linux/slab.h>
31 #include <linux/i2c.h>
32 #include <linux/videodev2.h>
33 #include <media/v4l2-device.h>
34 #include <media/v4l2-ctrls.h>
35 #include <media/v4l2-mc.h>
36 #include <media/i2c/saa7115.h>
37 #include <asm/div64.h>
38
39 #define VRES_60HZ (480+16)
40
41 MODULE_DESCRIPTION("Philips SAA7111/SAA7113/SAA7114/SAA7115/SAA7118 video decoder driver");
42 MODULE_AUTHOR( "Maxim Yevtyushkin, Kevin Thayer, Chris Kennedy, "
43 "Hans Verkuil, Mauro Carvalho Chehab");
44 MODULE_LICENSE("GPL");
45
46 static bool debug;
47 module_param(debug, bool, 0644);
48
49 MODULE_PARM_DESC(debug, "Debug level (0-1)");
50
51
52 enum saa711x_model {
53 SAA7111A,
54 SAA7111,
55 SAA7113,
56 GM7113C,
57 SAA7114,
58 SAA7115,
59 SAA7118,
60 };
61
62 enum saa711x_pads {
63 SAA711X_PAD_IF_INPUT,
64 SAA711X_PAD_VID_OUT,
65 SAA711X_NUM_PADS
66 };
67
68 struct saa711x_state {
69 struct v4l2_subdev sd;
70 #ifdef CONFIG_MEDIA_CONTROLLER
71 struct media_pad pads[SAA711X_NUM_PADS];
72 #endif
73 struct v4l2_ctrl_handler hdl;
74
75 struct {
76 /* chroma gain control cluster */
77 struct v4l2_ctrl *agc;
78 struct v4l2_ctrl *gain;
79 };
80
81 v4l2_std_id std;
82 int input;
83 int output;
84 int enable;
85 int radio;
86 int width;
87 int height;
88 enum saa711x_model ident;
89 u32 audclk_freq;
90 u32 crystal_freq;
91 bool ucgc;
92 u8 cgcdiv;
93 bool apll;
94 bool double_asclk;
95 };
96
97 static inline struct saa711x_state *to_state(struct v4l2_subdev *sd)
98 {
99 return container_of(sd, struct saa711x_state, sd);
100 }
101
102 static inline struct v4l2_subdev *to_sd(struct v4l2_ctrl *ctrl)
103 {
104 return &container_of(ctrl->handler, struct saa711x_state, hdl)->sd;
105 }
106
107 /* ----------------------------------------------------------------------- */
108
109 static inline int saa711x_write(struct v4l2_subdev *sd, u8 reg, u8 value)
110 {
111 struct i2c_client *client = v4l2_get_subdevdata(sd);
112
113 return i2c_smbus_write_byte_data(client, reg, value);
114 }
115
116 /* Sanity routine to check if a register is present */
117 static int saa711x_has_reg(const int id, const u8 reg)
118 {
119 if (id == SAA7111)
120 return reg < 0x20 && reg != 0x01 && reg != 0x0f &&
121 (reg < 0x13 || reg > 0x19) && reg != 0x1d && reg != 0x1e;
122 if (id == SAA7111A)
123 return reg < 0x20 && reg != 0x01 && reg != 0x0f &&
124 reg != 0x14 && reg != 0x18 && reg != 0x19 &&
125 reg != 0x1d && reg != 0x1e;
126
127 /* common for saa7113/4/5/8 */
128 if (unlikely((reg >= 0x3b && reg <= 0x3f) || reg == 0x5c || reg == 0x5f ||
129 reg == 0xa3 || reg == 0xa7 || reg == 0xab || reg == 0xaf || (reg >= 0xb5 && reg <= 0xb7) ||
130 reg == 0xd3 || reg == 0xd7 || reg == 0xdb || reg == 0xdf || (reg >= 0xe5 && reg <= 0xe7) ||
131 reg == 0x82 || (reg >= 0x89 && reg <= 0x8e)))
132 return 0;
133
134 switch (id) {
135 case GM7113C:
136 return reg != 0x14 && (reg < 0x18 || reg > 0x1e) && reg < 0x20;
137 case SAA7113:
138 return reg != 0x14 && (reg < 0x18 || reg > 0x1e) && (reg < 0x20 || reg > 0x3f) &&
139 reg != 0x5d && reg < 0x63;
140 case SAA7114:
141 return (reg < 0x1a || reg > 0x1e) && (reg < 0x20 || reg > 0x2f) &&
142 (reg < 0x63 || reg > 0x7f) && reg != 0x33 && reg != 0x37 &&
143 reg != 0x81 && reg < 0xf0;
144 case SAA7115:
145 return (reg < 0x20 || reg > 0x2f) && reg != 0x65 && (reg < 0xfc || reg > 0xfe);
146 case SAA7118:
147 return (reg < 0x1a || reg > 0x1d) && (reg < 0x20 || reg > 0x22) &&
148 (reg < 0x26 || reg > 0x28) && reg != 0x33 && reg != 0x37 &&
149 (reg < 0x63 || reg > 0x7f) && reg != 0x81 && reg < 0xf0;
150 }
151 return 1;
152 }
153
154 static int saa711x_writeregs(struct v4l2_subdev *sd, const unsigned char *regs)
155 {
156 struct saa711x_state *state = to_state(sd);
157 unsigned char reg, data;
158
159 while (*regs != 0x00) {
160 reg = *(regs++);
161 data = *(regs++);
162
163 /* According with datasheets, reserved regs should be
164 filled with 0 - seems better not to touch on they */
165 if (saa711x_has_reg(state->ident, reg)) {
166 if (saa711x_write(sd, reg, data) < 0)
167 return -1;
168 } else {
169 v4l2_dbg(1, debug, sd, "tried to access reserved reg 0x%02x\n", reg);
170 }
171 }
172 return 0;
173 }
174
175 static inline int saa711x_read(struct v4l2_subdev *sd, u8 reg)
176 {
177 struct i2c_client *client = v4l2_get_subdevdata(sd);
178
179 return i2c_smbus_read_byte_data(client, reg);
180 }
181
182 /* ----------------------------------------------------------------------- */
183
184 /* SAA7111 initialization table */
185 static const unsigned char saa7111_init[] = {
186 R_01_INC_DELAY, 0x00, /* reserved */
187
188 /*front end */
189 R_02_INPUT_CNTL_1, 0xd0, /* FUSE=3, GUDL=2, MODE=0 */
190 R_03_INPUT_CNTL_2, 0x23, /* HLNRS=0, VBSL=1, WPOFF=0, HOLDG=0,
191 * GAFIX=0, GAI1=256, GAI2=256 */
192 R_04_INPUT_CNTL_3, 0x00, /* GAI1=256 */
193 R_05_INPUT_CNTL_4, 0x00, /* GAI2=256 */
194
195 /* decoder */
196 R_06_H_SYNC_START, 0xf3, /* HSB at 13(50Hz) / 17(60Hz)
197 * pixels after end of last line */
198 R_07_H_SYNC_STOP, 0xe8, /* HSS seems to be needed to
199 * work with NTSC, too */
200 R_08_SYNC_CNTL, 0xc8, /* AUFD=1, FSEL=1, EXFIL=0,
201 * VTRC=1, HPLL=0, VNOI=0 */
202 R_09_LUMA_CNTL, 0x01, /* BYPS=0, PREF=0, BPSS=0,
203 * VBLB=0, UPTCV=0, APER=1 */
204 R_0A_LUMA_BRIGHT_CNTL, 0x80,
205 R_0B_LUMA_CONTRAST_CNTL, 0x47, /* 0b - CONT=1.109 */
206 R_0C_CHROMA_SAT_CNTL, 0x40,
207 R_0D_CHROMA_HUE_CNTL, 0x00,
208 R_0E_CHROMA_CNTL_1, 0x01, /* 0e - CDTO=0, CSTD=0, DCCF=0,
209 * FCTC=0, CHBW=1 */
210 R_0F_CHROMA_GAIN_CNTL, 0x00, /* reserved */
211 R_10_CHROMA_CNTL_2, 0x48, /* 10 - OFTS=1, HDEL=0, VRLN=1, YDEL=0 */
212 R_11_MODE_DELAY_CNTL, 0x1c, /* 11 - GPSW=0, CM99=0, FECO=0, COMPO=1,
213 * OEYC=1, OEHV=1, VIPB=0, COLO=0 */
214 R_12_RT_SIGNAL_CNTL, 0x00, /* 12 - output control 2 */
215 R_13_RT_X_PORT_OUT_CNTL, 0x00, /* 13 - output control 3 */
216 R_14_ANAL_ADC_COMPAT_CNTL, 0x00,
217 R_15_VGATE_START_FID_CHG, 0x00,
218 R_16_VGATE_STOP, 0x00,
219 R_17_MISC_VGATE_CONF_AND_MSB, 0x00,
220
221 0x00, 0x00
222 };
223
224 /*
225 * This table has one illegal value, and some values that are not
226 * correct according to the datasheet initialization table.
227 *
228 * If you need a table with legal/default values tell the driver in
229 * i2c_board_info.platform_data, and you will get the gm7113c_init
230 * table instead.
231 */
232
233 /* SAA7113 Init codes */
234 static const unsigned char saa7113_init[] = {
235 R_01_INC_DELAY, 0x08,
236 R_02_INPUT_CNTL_1, 0xc2,
237 R_03_INPUT_CNTL_2, 0x30,
238 R_04_INPUT_CNTL_3, 0x00,
239 R_05_INPUT_CNTL_4, 0x00,
240 R_06_H_SYNC_START, 0x89, /* Illegal value -119,
241 * min. value = -108 (0x94) */
242 R_07_H_SYNC_STOP, 0x0d,
243 R_08_SYNC_CNTL, 0x88, /* Not datasheet default.
244 * HTC = VTR mode, should be 0x98 */
245 R_09_LUMA_CNTL, 0x01,
246 R_0A_LUMA_BRIGHT_CNTL, 0x80,
247 R_0B_LUMA_CONTRAST_CNTL, 0x47,
248 R_0C_CHROMA_SAT_CNTL, 0x40,
249 R_0D_CHROMA_HUE_CNTL, 0x00,
250 R_0E_CHROMA_CNTL_1, 0x01,
251 R_0F_CHROMA_GAIN_CNTL, 0x2a,
252 R_10_CHROMA_CNTL_2, 0x08, /* Not datsheet default.
253 * VRLN enabled, should be 0x00 */
254 R_11_MODE_DELAY_CNTL, 0x0c,
255 R_12_RT_SIGNAL_CNTL, 0x07, /* Not datasheet default,
256 * should be 0x01 */
257 R_13_RT_X_PORT_OUT_CNTL, 0x00,
258 R_14_ANAL_ADC_COMPAT_CNTL, 0x00,
259 R_15_VGATE_START_FID_CHG, 0x00,
260 R_16_VGATE_STOP, 0x00,
261 R_17_MISC_VGATE_CONF_AND_MSB, 0x00,
262
263 0x00, 0x00
264 };
265
266 /*
267 * GM7113C is a clone of the SAA7113 chip
268 * This init table is copied out of the saa7113 datasheet.
269 * In R_08 we enable "Automatic Field Detection" [AUFD],
270 * this is disabled when saa711x_set_v4lstd is called.
271 */
272 static const unsigned char gm7113c_init[] = {
273 R_01_INC_DELAY, 0x08,
274 R_02_INPUT_CNTL_1, 0xc0,
275 R_03_INPUT_CNTL_2, 0x33,
276 R_04_INPUT_CNTL_3, 0x00,
277 R_05_INPUT_CNTL_4, 0x00,
278 R_06_H_SYNC_START, 0xe9,
279 R_07_H_SYNC_STOP, 0x0d,
280 R_08_SYNC_CNTL, 0x98,
281 R_09_LUMA_CNTL, 0x01,
282 R_0A_LUMA_BRIGHT_CNTL, 0x80,
283 R_0B_LUMA_CONTRAST_CNTL, 0x47,
284 R_0C_CHROMA_SAT_CNTL, 0x40,
285 R_0D_CHROMA_HUE_CNTL, 0x00,
286 R_0E_CHROMA_CNTL_1, 0x01,
287 R_0F_CHROMA_GAIN_CNTL, 0x2a,
288 R_10_CHROMA_CNTL_2, 0x00,
289 R_11_MODE_DELAY_CNTL, 0x0c,
290 R_12_RT_SIGNAL_CNTL, 0x01,
291 R_13_RT_X_PORT_OUT_CNTL, 0x00,
292 R_14_ANAL_ADC_COMPAT_CNTL, 0x00,
293 R_15_VGATE_START_FID_CHG, 0x00,
294 R_16_VGATE_STOP, 0x00,
295 R_17_MISC_VGATE_CONF_AND_MSB, 0x00,
296
297 0x00, 0x00
298 };
299
300 /* If a value differs from the Hauppauge driver values, then the comment starts with
301 'was 0xXX' to denote the Hauppauge value. Otherwise the value is identical to what the
302 Hauppauge driver sets. */
303
304 /* SAA7114 and SAA7115 initialization table */
305 static const unsigned char saa7115_init_auto_input[] = {
306 /* Front-End Part */
307 R_01_INC_DELAY, 0x48, /* white peak control disabled */
308 R_03_INPUT_CNTL_2, 0x20, /* was 0x30. 0x20: long vertical blanking */
309 R_04_INPUT_CNTL_3, 0x90, /* analog gain set to 0 */
310 R_05_INPUT_CNTL_4, 0x90, /* analog gain set to 0 */
311 /* Decoder Part */
312 R_06_H_SYNC_START, 0xeb, /* horiz sync begin = -21 */
313 R_07_H_SYNC_STOP, 0xe0, /* horiz sync stop = -17 */
314 R_09_LUMA_CNTL, 0x53, /* 0x53, was 0x56 for 60hz. luminance control */
315 R_0A_LUMA_BRIGHT_CNTL, 0x80, /* was 0x88. decoder brightness, 0x80 is itu standard */
316 R_0B_LUMA_CONTRAST_CNTL, 0x44, /* was 0x48. decoder contrast, 0x44 is itu standard */
317 R_0C_CHROMA_SAT_CNTL, 0x40, /* was 0x47. decoder saturation, 0x40 is itu standard */
318 R_0D_CHROMA_HUE_CNTL, 0x00,
319 R_0F_CHROMA_GAIN_CNTL, 0x00, /* use automatic gain */
320 R_10_CHROMA_CNTL_2, 0x06, /* chroma: active adaptive combfilter */
321 R_11_MODE_DELAY_CNTL, 0x00,
322 R_12_RT_SIGNAL_CNTL, 0x9d, /* RTS0 output control: VGATE */
323 R_13_RT_X_PORT_OUT_CNTL, 0x80, /* ITU656 standard mode, RTCO output enable RTCE */
324 R_14_ANAL_ADC_COMPAT_CNTL, 0x00,
325 R_18_RAW_DATA_GAIN_CNTL, 0x40, /* gain 0x00 = nominal */
326 R_19_RAW_DATA_OFF_CNTL, 0x80,
327 R_1A_COLOR_KILL_LVL_CNTL, 0x77, /* recommended value */
328 R_1B_MISC_TVVCRDET, 0x42, /* recommended value */
329 R_1C_ENHAN_COMB_CTRL1, 0xa9, /* recommended value */
330 R_1D_ENHAN_COMB_CTRL2, 0x01, /* recommended value */
331
332
333 R_80_GLOBAL_CNTL_1, 0x0, /* No tasks enabled at init */
334
335 /* Power Device Control */
336 R_88_POWER_SAVE_ADC_PORT_CNTL, 0xd0, /* reset device */
337 R_88_POWER_SAVE_ADC_PORT_CNTL, 0xf0, /* set device programmed, all in operational mode */
338 0x00, 0x00
339 };
340
341 /* Used to reset saa7113, saa7114 and saa7115 */
342 static const unsigned char saa7115_cfg_reset_scaler[] = {
343 R_87_I_PORT_I_O_ENA_OUT_CLK_AND_GATED, 0x00, /* disable I-port output */
344 R_88_POWER_SAVE_ADC_PORT_CNTL, 0xd0, /* reset scaler */
345 R_88_POWER_SAVE_ADC_PORT_CNTL, 0xf0, /* activate scaler */
346 R_87_I_PORT_I_O_ENA_OUT_CLK_AND_GATED, 0x01, /* enable I-port output */
347 0x00, 0x00
348 };
349
350 /* ============== SAA7715 VIDEO templates ============= */
351
352 static const unsigned char saa7115_cfg_60hz_video[] = {
353 R_80_GLOBAL_CNTL_1, 0x00, /* reset tasks */
354 R_88_POWER_SAVE_ADC_PORT_CNTL, 0xd0, /* reset scaler */
355
356 R_15_VGATE_START_FID_CHG, 0x03,
357 R_16_VGATE_STOP, 0x11,
358 R_17_MISC_VGATE_CONF_AND_MSB, 0x9c,
359
360 R_08_SYNC_CNTL, 0x68, /* 0xBO: auto detection, 0x68 = NTSC */
361 R_0E_CHROMA_CNTL_1, 0x07, /* video autodetection is on */
362
363 R_5A_V_OFF_FOR_SLICER, 0x06, /* standard 60hz value for ITU656 line counting */
364
365 /* Task A */
366 R_90_A_TASK_HANDLING_CNTL, 0x80,
367 R_91_A_X_PORT_FORMATS_AND_CONF, 0x48,
368 R_92_A_X_PORT_INPUT_REFERENCE_SIGNAL, 0x40,
369 R_93_A_I_PORT_OUTPUT_FORMATS_AND_CONF, 0x84,
370
371 /* hoffset low (input), 0x0002 is minimum */
372 R_94_A_HORIZ_INPUT_WINDOW_START, 0x01,
373 R_95_A_HORIZ_INPUT_WINDOW_START_MSB, 0x00,
374
375 /* hsize low (input), 0x02d0 = 720 */
376 R_96_A_HORIZ_INPUT_WINDOW_LENGTH, 0xd0,
377 R_97_A_HORIZ_INPUT_WINDOW_LENGTH_MSB, 0x02,
378
379 R_98_A_VERT_INPUT_WINDOW_START, 0x05,
380 R_99_A_VERT_INPUT_WINDOW_START_MSB, 0x00,
381
382 R_9A_A_VERT_INPUT_WINDOW_LENGTH, 0x0c,
383 R_9B_A_VERT_INPUT_WINDOW_LENGTH_MSB, 0x00,
384
385 R_9C_A_HORIZ_OUTPUT_WINDOW_LENGTH, 0xa0,
386 R_9D_A_HORIZ_OUTPUT_WINDOW_LENGTH_MSB, 0x05,
387
388 R_9E_A_VERT_OUTPUT_WINDOW_LENGTH, 0x0c,
389 R_9F_A_VERT_OUTPUT_WINDOW_LENGTH_MSB, 0x00,
390
391 /* Task B */
392 R_C0_B_TASK_HANDLING_CNTL, 0x00,
393 R_C1_B_X_PORT_FORMATS_AND_CONF, 0x08,
394 R_C2_B_INPUT_REFERENCE_SIGNAL_DEFINITION, 0x00,
395 R_C3_B_I_PORT_FORMATS_AND_CONF, 0x80,
396
397 /* 0x0002 is minimum */
398 R_C4_B_HORIZ_INPUT_WINDOW_START, 0x02,
399 R_C5_B_HORIZ_INPUT_WINDOW_START_MSB, 0x00,
400
401 /* 0x02d0 = 720 */
402 R_C6_B_HORIZ_INPUT_WINDOW_LENGTH, 0xd0,
403 R_C7_B_HORIZ_INPUT_WINDOW_LENGTH_MSB, 0x02,
404
405 /* vwindow start 0x12 = 18 */
406 R_C8_B_VERT_INPUT_WINDOW_START, 0x12,
407 R_C9_B_VERT_INPUT_WINDOW_START_MSB, 0x00,
408
409 /* vwindow length 0xf8 = 248 */
410 R_CA_B_VERT_INPUT_WINDOW_LENGTH, VRES_60HZ>>1,
411 R_CB_B_VERT_INPUT_WINDOW_LENGTH_MSB, VRES_60HZ>>9,
412
413 /* hwindow 0x02d0 = 720 */
414 R_CC_B_HORIZ_OUTPUT_WINDOW_LENGTH, 0xd0,
415 R_CD_B_HORIZ_OUTPUT_WINDOW_LENGTH_MSB, 0x02,
416
417 R_F0_LFCO_PER_LINE, 0xad, /* Set PLL Register. 60hz 525 lines per frame, 27 MHz */
418 R_F1_P_I_PARAM_SELECT, 0x05, /* low bit with 0xF0 */
419 R_F5_PULSGEN_LINE_LENGTH, 0xad,
420 R_F6_PULSE_A_POS_LSB_AND_PULSEGEN_CONFIG, 0x01,
421
422 0x00, 0x00
423 };
424
425 static const unsigned char saa7115_cfg_50hz_video[] = {
426 R_80_GLOBAL_CNTL_1, 0x00,
427 R_88_POWER_SAVE_ADC_PORT_CNTL, 0xd0, /* reset scaler */
428
429 R_15_VGATE_START_FID_CHG, 0x37, /* VGATE start */
430 R_16_VGATE_STOP, 0x16,
431 R_17_MISC_VGATE_CONF_AND_MSB, 0x99,
432
433 R_08_SYNC_CNTL, 0x28, /* 0x28 = PAL */
434 R_0E_CHROMA_CNTL_1, 0x07,
435
436 R_5A_V_OFF_FOR_SLICER, 0x03, /* standard 50hz value */
437
438 /* Task A */
439 R_90_A_TASK_HANDLING_CNTL, 0x81,
440 R_91_A_X_PORT_FORMATS_AND_CONF, 0x48,
441 R_92_A_X_PORT_INPUT_REFERENCE_SIGNAL, 0x40,
442 R_93_A_I_PORT_OUTPUT_FORMATS_AND_CONF, 0x84,
443
444 /* This is weird: the datasheet says that you should use 2 as the minimum value, */
445 /* but Hauppauge uses 0, and changing that to 2 causes indeed problems (for 50hz) */
446 /* hoffset low (input), 0x0002 is minimum */
447 R_94_A_HORIZ_INPUT_WINDOW_START, 0x00,
448 R_95_A_HORIZ_INPUT_WINDOW_START_MSB, 0x00,
449
450 /* hsize low (input), 0x02d0 = 720 */
451 R_96_A_HORIZ_INPUT_WINDOW_LENGTH, 0xd0,
452 R_97_A_HORIZ_INPUT_WINDOW_LENGTH_MSB, 0x02,
453
454 R_98_A_VERT_INPUT_WINDOW_START, 0x03,
455 R_99_A_VERT_INPUT_WINDOW_START_MSB, 0x00,
456
457 /* vsize 0x12 = 18 */
458 R_9A_A_VERT_INPUT_WINDOW_LENGTH, 0x12,
459 R_9B_A_VERT_INPUT_WINDOW_LENGTH_MSB, 0x00,
460
461 /* hsize 0x05a0 = 1440 */
462 R_9C_A_HORIZ_OUTPUT_WINDOW_LENGTH, 0xa0,
463 R_9D_A_HORIZ_OUTPUT_WINDOW_LENGTH_MSB, 0x05, /* hsize hi (output) */
464 R_9E_A_VERT_OUTPUT_WINDOW_LENGTH, 0x12, /* vsize low (output), 0x12 = 18 */
465 R_9F_A_VERT_OUTPUT_WINDOW_LENGTH_MSB, 0x00, /* vsize hi (output) */
466
467 /* Task B */
468 R_C0_B_TASK_HANDLING_CNTL, 0x00,
469 R_C1_B_X_PORT_FORMATS_AND_CONF, 0x08,
470 R_C2_B_INPUT_REFERENCE_SIGNAL_DEFINITION, 0x00,
471 R_C3_B_I_PORT_FORMATS_AND_CONF, 0x80,
472
473 /* This is weird: the datasheet says that you should use 2 as the minimum value, */
474 /* but Hauppauge uses 0, and changing that to 2 causes indeed problems (for 50hz) */
475 /* hoffset low (input), 0x0002 is minimum. See comment above. */
476 R_C4_B_HORIZ_INPUT_WINDOW_START, 0x00,
477 R_C5_B_HORIZ_INPUT_WINDOW_START_MSB, 0x00,
478
479 /* hsize 0x02d0 = 720 */
480 R_C6_B_HORIZ_INPUT_WINDOW_LENGTH, 0xd0,
481 R_C7_B_HORIZ_INPUT_WINDOW_LENGTH_MSB, 0x02,
482
483 /* voffset 0x16 = 22 */
484 R_C8_B_VERT_INPUT_WINDOW_START, 0x16,
485 R_C9_B_VERT_INPUT_WINDOW_START_MSB, 0x00,
486
487 /* vsize 0x0120 = 288 */
488 R_CA_B_VERT_INPUT_WINDOW_LENGTH, 0x20,
489 R_CB_B_VERT_INPUT_WINDOW_LENGTH_MSB, 0x01,
490
491 /* hsize 0x02d0 = 720 */
492 R_CC_B_HORIZ_OUTPUT_WINDOW_LENGTH, 0xd0,
493 R_CD_B_HORIZ_OUTPUT_WINDOW_LENGTH_MSB, 0x02,
494
495 R_F0_LFCO_PER_LINE, 0xb0, /* Set PLL Register. 50hz 625 lines per frame, 27 MHz */
496 R_F1_P_I_PARAM_SELECT, 0x05, /* low bit with 0xF0, (was 0x05) */
497 R_F5_PULSGEN_LINE_LENGTH, 0xb0,
498 R_F6_PULSE_A_POS_LSB_AND_PULSEGEN_CONFIG, 0x01,
499
500 0x00, 0x00
501 };
502
503 /* ============== SAA7715 VIDEO templates (end) ======= */
504
505 static const unsigned char saa7115_cfg_vbi_on[] = {
506 R_80_GLOBAL_CNTL_1, 0x00, /* reset tasks */
507 R_88_POWER_SAVE_ADC_PORT_CNTL, 0xd0, /* reset scaler */
508 R_80_GLOBAL_CNTL_1, 0x30, /* Activate both tasks */
509 R_88_POWER_SAVE_ADC_PORT_CNTL, 0xf0, /* activate scaler */
510 R_87_I_PORT_I_O_ENA_OUT_CLK_AND_GATED, 0x01, /* Enable I-port output */
511
512 0x00, 0x00
513 };
514
515 static const unsigned char saa7115_cfg_vbi_off[] = {
516 R_80_GLOBAL_CNTL_1, 0x00, /* reset tasks */
517 R_88_POWER_SAVE_ADC_PORT_CNTL, 0xd0, /* reset scaler */
518 R_80_GLOBAL_CNTL_1, 0x20, /* Activate only task "B" */
519 R_88_POWER_SAVE_ADC_PORT_CNTL, 0xf0, /* activate scaler */
520 R_87_I_PORT_I_O_ENA_OUT_CLK_AND_GATED, 0x01, /* Enable I-port output */
521
522 0x00, 0x00
523 };
524
525
526 static const unsigned char saa7115_init_misc[] = {
527 R_81_V_SYNC_FLD_ID_SRC_SEL_AND_RETIMED_V_F, 0x01,
528 R_83_X_PORT_I_O_ENA_AND_OUT_CLK, 0x01,
529 R_84_I_PORT_SIGNAL_DEF, 0x20,
530 R_85_I_PORT_SIGNAL_POLAR, 0x21,
531 R_86_I_PORT_FIFO_FLAG_CNTL_AND_ARBIT, 0xc5,
532 R_87_I_PORT_I_O_ENA_OUT_CLK_AND_GATED, 0x01,
533
534 /* Task A */
535 R_A0_A_HORIZ_PRESCALING, 0x01,
536 R_A1_A_ACCUMULATION_LENGTH, 0x00,
537 R_A2_A_PRESCALER_DC_GAIN_AND_FIR_PREFILTER, 0x00,
538
539 /* Configure controls at nominal value*/
540 R_A4_A_LUMA_BRIGHTNESS_CNTL, 0x80,
541 R_A5_A_LUMA_CONTRAST_CNTL, 0x40,
542 R_A6_A_CHROMA_SATURATION_CNTL, 0x40,
543
544 /* note: 2 x zoom ensures that VBI lines have same length as video lines. */
545 R_A8_A_HORIZ_LUMA_SCALING_INC, 0x00,
546 R_A9_A_HORIZ_LUMA_SCALING_INC_MSB, 0x02,
547
548 R_AA_A_HORIZ_LUMA_PHASE_OFF, 0x00,
549
550 /* must be horiz lum scaling / 2 */
551 R_AC_A_HORIZ_CHROMA_SCALING_INC, 0x00,
552 R_AD_A_HORIZ_CHROMA_SCALING_INC_MSB, 0x01,
553
554 /* must be offset luma / 2 */
555 R_AE_A_HORIZ_CHROMA_PHASE_OFF, 0x00,
556
557 R_B0_A_VERT_LUMA_SCALING_INC, 0x00,
558 R_B1_A_VERT_LUMA_SCALING_INC_MSB, 0x04,
559
560 R_B2_A_VERT_CHROMA_SCALING_INC, 0x00,
561 R_B3_A_VERT_CHROMA_SCALING_INC_MSB, 0x04,
562
563 R_B4_A_VERT_SCALING_MODE_CNTL, 0x01,
564
565 R_B8_A_VERT_CHROMA_PHASE_OFF_00, 0x00,
566 R_B9_A_VERT_CHROMA_PHASE_OFF_01, 0x00,
567 R_BA_A_VERT_CHROMA_PHASE_OFF_10, 0x00,
568 R_BB_A_VERT_CHROMA_PHASE_OFF_11, 0x00,
569
570 R_BC_A_VERT_LUMA_PHASE_OFF_00, 0x00,
571 R_BD_A_VERT_LUMA_PHASE_OFF_01, 0x00,
572 R_BE_A_VERT_LUMA_PHASE_OFF_10, 0x00,
573 R_BF_A_VERT_LUMA_PHASE_OFF_11, 0x00,
574
575 /* Task B */
576 R_D0_B_HORIZ_PRESCALING, 0x01,
577 R_D1_B_ACCUMULATION_LENGTH, 0x00,
578 R_D2_B_PRESCALER_DC_GAIN_AND_FIR_PREFILTER, 0x00,
579
580 /* Configure controls at nominal value*/
581 R_D4_B_LUMA_BRIGHTNESS_CNTL, 0x80,
582 R_D5_B_LUMA_CONTRAST_CNTL, 0x40,
583 R_D6_B_CHROMA_SATURATION_CNTL, 0x40,
584
585 /* hor lum scaling 0x0400 = 1 */
586 R_D8_B_HORIZ_LUMA_SCALING_INC, 0x00,
587 R_D9_B_HORIZ_LUMA_SCALING_INC_MSB, 0x04,
588
589 R_DA_B_HORIZ_LUMA_PHASE_OFF, 0x00,
590
591 /* must be hor lum scaling / 2 */
592 R_DC_B_HORIZ_CHROMA_SCALING, 0x00,
593 R_DD_B_HORIZ_CHROMA_SCALING_MSB, 0x02,
594
595 /* must be offset luma / 2 */
596 R_DE_B_HORIZ_PHASE_OFFSET_CRHOMA, 0x00,
597
598 R_E0_B_VERT_LUMA_SCALING_INC, 0x00,
599 R_E1_B_VERT_LUMA_SCALING_INC_MSB, 0x04,
600
601 R_E2_B_VERT_CHROMA_SCALING_INC, 0x00,
602 R_E3_B_VERT_CHROMA_SCALING_INC_MSB, 0x04,
603
604 R_E4_B_VERT_SCALING_MODE_CNTL, 0x01,
605
606 R_E8_B_VERT_CHROMA_PHASE_OFF_00, 0x00,
607 R_E9_B_VERT_CHROMA_PHASE_OFF_01, 0x00,
608 R_EA_B_VERT_CHROMA_PHASE_OFF_10, 0x00,
609 R_EB_B_VERT_CHROMA_PHASE_OFF_11, 0x00,
610
611 R_EC_B_VERT_LUMA_PHASE_OFF_00, 0x00,
612 R_ED_B_VERT_LUMA_PHASE_OFF_01, 0x00,
613 R_EE_B_VERT_LUMA_PHASE_OFF_10, 0x00,
614 R_EF_B_VERT_LUMA_PHASE_OFF_11, 0x00,
615
616 R_F2_NOMINAL_PLL2_DTO, 0x50, /* crystal clock = 24.576 MHz, target = 27MHz */
617 R_F3_PLL_INCREMENT, 0x46,
618 R_F4_PLL2_STATUS, 0x00,
619 R_F7_PULSE_A_POS_MSB, 0x4b, /* not the recommended settings! */
620 R_F8_PULSE_B_POS, 0x00,
621 R_F9_PULSE_B_POS_MSB, 0x4b,
622 R_FA_PULSE_C_POS, 0x00,
623 R_FB_PULSE_C_POS_MSB, 0x4b,
624
625 /* PLL2 lock detection settings: 71 lines 50% phase error */
626 R_FF_S_PLL_MAX_PHASE_ERR_THRESH_NUM_LINES, 0x88,
627
628 /* Turn off VBI */
629 R_40_SLICER_CNTL_1, 0x20, /* No framing code errors allowed. */
630 R_41_LCR_BASE, 0xff,
631 R_41_LCR_BASE+1, 0xff,
632 R_41_LCR_BASE+2, 0xff,
633 R_41_LCR_BASE+3, 0xff,
634 R_41_LCR_BASE+4, 0xff,
635 R_41_LCR_BASE+5, 0xff,
636 R_41_LCR_BASE+6, 0xff,
637 R_41_LCR_BASE+7, 0xff,
638 R_41_LCR_BASE+8, 0xff,
639 R_41_LCR_BASE+9, 0xff,
640 R_41_LCR_BASE+10, 0xff,
641 R_41_LCR_BASE+11, 0xff,
642 R_41_LCR_BASE+12, 0xff,
643 R_41_LCR_BASE+13, 0xff,
644 R_41_LCR_BASE+14, 0xff,
645 R_41_LCR_BASE+15, 0xff,
646 R_41_LCR_BASE+16, 0xff,
647 R_41_LCR_BASE+17, 0xff,
648 R_41_LCR_BASE+18, 0xff,
649 R_41_LCR_BASE+19, 0xff,
650 R_41_LCR_BASE+20, 0xff,
651 R_41_LCR_BASE+21, 0xff,
652 R_41_LCR_BASE+22, 0xff,
653 R_58_PROGRAM_FRAMING_CODE, 0x40,
654 R_59_H_OFF_FOR_SLICER, 0x47,
655 R_5B_FLD_OFF_AND_MSB_FOR_H_AND_V_OFF, 0x83,
656 R_5D_DID, 0xbd,
657 R_5E_SDID, 0x35,
658
659 R_02_INPUT_CNTL_1, 0xc4, /* input tuner -> input 4, amplifier active */
660
661 R_80_GLOBAL_CNTL_1, 0x20, /* enable task B */
662 R_88_POWER_SAVE_ADC_PORT_CNTL, 0xd0,
663 R_88_POWER_SAVE_ADC_PORT_CNTL, 0xf0,
664 0x00, 0x00
665 };
666
667 static int saa711x_odd_parity(u8 c)
668 {
669 c ^= (c >> 4);
670 c ^= (c >> 2);
671 c ^= (c >> 1);
672
673 return c & 1;
674 }
675
676 static int saa711x_decode_vps(u8 *dst, u8 *p)
677 {
678 static const u8 biphase_tbl[] = {
679 0xf0, 0x78, 0x70, 0xf0, 0xb4, 0x3c, 0x34, 0xb4,
680 0xb0, 0x38, 0x30, 0xb0, 0xf0, 0x78, 0x70, 0xf0,
681 0xd2, 0x5a, 0x52, 0xd2, 0x96, 0x1e, 0x16, 0x96,
682 0x92, 0x1a, 0x12, 0x92, 0xd2, 0x5a, 0x52, 0xd2,
683 0xd0, 0x58, 0x50, 0xd0, 0x94, 0x1c, 0x14, 0x94,
684 0x90, 0x18, 0x10, 0x90, 0xd0, 0x58, 0x50, 0xd0,
685 0xf0, 0x78, 0x70, 0xf0, 0xb4, 0x3c, 0x34, 0xb4,
686 0xb0, 0x38, 0x30, 0xb0, 0xf0, 0x78, 0x70, 0xf0,
687 0xe1, 0x69, 0x61, 0xe1, 0xa5, 0x2d, 0x25, 0xa5,
688 0xa1, 0x29, 0x21, 0xa1, 0xe1, 0x69, 0x61, 0xe1,
689 0xc3, 0x4b, 0x43, 0xc3, 0x87, 0x0f, 0x07, 0x87,
690 0x83, 0x0b, 0x03, 0x83, 0xc3, 0x4b, 0x43, 0xc3,
691 0xc1, 0x49, 0x41, 0xc1, 0x85, 0x0d, 0x05, 0x85,
692 0x81, 0x09, 0x01, 0x81, 0xc1, 0x49, 0x41, 0xc1,
693 0xe1, 0x69, 0x61, 0xe1, 0xa5, 0x2d, 0x25, 0xa5,
694 0xa1, 0x29, 0x21, 0xa1, 0xe1, 0x69, 0x61, 0xe1,
695 0xe0, 0x68, 0x60, 0xe0, 0xa4, 0x2c, 0x24, 0xa4,
696 0xa0, 0x28, 0x20, 0xa0, 0xe0, 0x68, 0x60, 0xe0,
697 0xc2, 0x4a, 0x42, 0xc2, 0x86, 0x0e, 0x06, 0x86,
698 0x82, 0x0a, 0x02, 0x82, 0xc2, 0x4a, 0x42, 0xc2,
699 0xc0, 0x48, 0x40, 0xc0, 0x84, 0x0c, 0x04, 0x84,
700 0x80, 0x08, 0x00, 0x80, 0xc0, 0x48, 0x40, 0xc0,
701 0xe0, 0x68, 0x60, 0xe0, 0xa4, 0x2c, 0x24, 0xa4,
702 0xa0, 0x28, 0x20, 0xa0, 0xe0, 0x68, 0x60, 0xe0,
703 0xf0, 0x78, 0x70, 0xf0, 0xb4, 0x3c, 0x34, 0xb4,
704 0xb0, 0x38, 0x30, 0xb0, 0xf0, 0x78, 0x70, 0xf0,
705 0xd2, 0x5a, 0x52, 0xd2, 0x96, 0x1e, 0x16, 0x96,
706 0x92, 0x1a, 0x12, 0x92, 0xd2, 0x5a, 0x52, 0xd2,
707 0xd0, 0x58, 0x50, 0xd0, 0x94, 0x1c, 0x14, 0x94,
708 0x90, 0x18, 0x10, 0x90, 0xd0, 0x58, 0x50, 0xd0,
709 0xf0, 0x78, 0x70, 0xf0, 0xb4, 0x3c, 0x34, 0xb4,
710 0xb0, 0x38, 0x30, 0xb0, 0xf0, 0x78, 0x70, 0xf0,
711 };
712 int i;
713 u8 c, err = 0;
714
715 for (i = 0; i < 2 * 13; i += 2) {
716 err |= biphase_tbl[p[i]] | biphase_tbl[p[i + 1]];
717 c = (biphase_tbl[p[i + 1]] & 0xf) | ((biphase_tbl[p[i]] & 0xf) << 4);
718 dst[i / 2] = c;
719 }
720 return err & 0xf0;
721 }
722
723 static int saa711x_decode_wss(u8 *p)
724 {
725 static const int wss_bits[8] = {
726 0, 0, 0, 1, 0, 1, 1, 1
727 };
728 unsigned char parity;
729 int wss = 0;
730 int i;
731
732 for (i = 0; i < 16; i++) {
733 int b1 = wss_bits[p[i] & 7];
734 int b2 = wss_bits[(p[i] >> 3) & 7];
735
736 if (b1 == b2)
737 return -1;
738 wss |= b2 << i;
739 }
740 parity = wss & 15;
741 parity ^= parity >> 2;
742 parity ^= parity >> 1;
743
744 if (!(parity & 1))
745 return -1;
746
747 return wss;
748 }
749
750 static int saa711x_s_clock_freq(struct v4l2_subdev *sd, u32 freq)
751 {
752 struct saa711x_state *state = to_state(sd);
753 u32 acpf;
754 u32 acni;
755 u32 hz;
756 u64 f;
757 u8 acc = 0; /* reg 0x3a, audio clock control */
758
759 /* Checks for chips that don't have audio clock (saa7111, saa7113) */
760 if (!saa711x_has_reg(state->ident, R_30_AUD_MAST_CLK_CYCLES_PER_FIELD))
761 return 0;
762
763 v4l2_dbg(1, debug, sd, "set audio clock freq: %d\n", freq);
764
765 /* sanity check */
766 if (freq < 32000 || freq > 48000)
767 return -EINVAL;
768
769 /* hz is the refresh rate times 100 */
770 hz = (state->std & V4L2_STD_525_60) ? 5994 : 5000;
771 /* acpf = (256 * freq) / field_frequency == (256 * 100 * freq) / hz */
772 acpf = (25600 * freq) / hz;
773 /* acni = (256 * freq * 2^23) / crystal_frequency =
774 (freq * 2^(8+23)) / crystal_frequency =
775 (freq << 31) / crystal_frequency */
776 f = freq;
777 f = f << 31;
778 do_div(f, state->crystal_freq);
779 acni = f;
780 if (state->ucgc) {
781 acpf = acpf * state->cgcdiv / 16;
782 acni = acni * state->cgcdiv / 16;
783 acc = 0x80;
784 if (state->cgcdiv == 3)
785 acc |= 0x40;
786 }
787 if (state->apll)
788 acc |= 0x08;
789
790 if (state->double_asclk) {
791 acpf <<= 1;
792 acni <<= 1;
793 }
794 saa711x_write(sd, R_38_CLK_RATIO_AMXCLK_TO_ASCLK, 0x03);
795 saa711x_write(sd, R_39_CLK_RATIO_ASCLK_TO_ALRCLK, 0x10 << state->double_asclk);
796 saa711x_write(sd, R_3A_AUD_CLK_GEN_BASIC_SETUP, acc);
797
798 saa711x_write(sd, R_30_AUD_MAST_CLK_CYCLES_PER_FIELD, acpf & 0xff);
799 saa711x_write(sd, R_30_AUD_MAST_CLK_CYCLES_PER_FIELD+1,
800 (acpf >> 8) & 0xff);
801 saa711x_write(sd, R_30_AUD_MAST_CLK_CYCLES_PER_FIELD+2,
802 (acpf >> 16) & 0x03);
803
804 saa711x_write(sd, R_34_AUD_MAST_CLK_NOMINAL_INC, acni & 0xff);
805 saa711x_write(sd, R_34_AUD_MAST_CLK_NOMINAL_INC+1, (acni >> 8) & 0xff);
806 saa711x_write(sd, R_34_AUD_MAST_CLK_NOMINAL_INC+2, (acni >> 16) & 0x3f);
807 state->audclk_freq = freq;
808 return 0;
809 }
810
811 static int saa711x_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
812 {
813 struct v4l2_subdev *sd = to_sd(ctrl);
814 struct saa711x_state *state = to_state(sd);
815
816 switch (ctrl->id) {
817 case V4L2_CID_CHROMA_AGC:
818 /* chroma gain cluster */
819 if (state->agc->val)
820 state->gain->val =
821 saa711x_read(sd, R_0F_CHROMA_GAIN_CNTL) & 0x7f;
822 break;
823 }
824 return 0;
825 }
826
827 static int saa711x_s_ctrl(struct v4l2_ctrl *ctrl)
828 {
829 struct v4l2_subdev *sd = to_sd(ctrl);
830 struct saa711x_state *state = to_state(sd);
831
832 switch (ctrl->id) {
833 case V4L2_CID_BRIGHTNESS:
834 saa711x_write(sd, R_0A_LUMA_BRIGHT_CNTL, ctrl->val);
835 break;
836
837 case V4L2_CID_CONTRAST:
838 saa711x_write(sd, R_0B_LUMA_CONTRAST_CNTL, ctrl->val);
839 break;
840
841 case V4L2_CID_SATURATION:
842 saa711x_write(sd, R_0C_CHROMA_SAT_CNTL, ctrl->val);
843 break;
844
845 case V4L2_CID_HUE:
846 saa711x_write(sd, R_0D_CHROMA_HUE_CNTL, ctrl->val);
847 break;
848
849 case V4L2_CID_CHROMA_AGC:
850 /* chroma gain cluster */
851 if (state->agc->val)
852 saa711x_write(sd, R_0F_CHROMA_GAIN_CNTL, state->gain->val);
853 else
854 saa711x_write(sd, R_0F_CHROMA_GAIN_CNTL, state->gain->val | 0x80);
855 break;
856
857 default:
858 return -EINVAL;
859 }
860
861 return 0;
862 }
863
864 static int saa711x_set_size(struct v4l2_subdev *sd, int width, int height)
865 {
866 struct saa711x_state *state = to_state(sd);
867 int HPSC, HFSC;
868 int VSCY;
869 int res;
870 int is_50hz = state->std & V4L2_STD_625_50;
871 int Vsrc = is_50hz ? 576 : 480;
872
873 v4l2_dbg(1, debug, sd, "decoder set size to %ix%i\n", width, height);
874
875 /* FIXME need better bounds checking here */
876 if ((width < 1) || (width > 1440))
877 return -EINVAL;
878 if ((height < 1) || (height > Vsrc))
879 return -EINVAL;
880
881 if (!saa711x_has_reg(state->ident, R_D0_B_HORIZ_PRESCALING)) {
882 /* Decoder only supports 720 columns and 480 or 576 lines */
883 if (width != 720)
884 return -EINVAL;
885 if (height != Vsrc)
886 return -EINVAL;
887 }
888
889 state->width = width;
890 state->height = height;
891
892 if (!saa711x_has_reg(state->ident, R_CC_B_HORIZ_OUTPUT_WINDOW_LENGTH))
893 return 0;
894
895 /* probably have a valid size, let's set it */
896 /* Set output width/height */
897 /* width */
898
899 saa711x_write(sd, R_CC_B_HORIZ_OUTPUT_WINDOW_LENGTH,
900 (u8) (width & 0xff));
901 saa711x_write(sd, R_CD_B_HORIZ_OUTPUT_WINDOW_LENGTH_MSB,
902 (u8) ((width >> 8) & 0xff));
903
904 /* Vertical Scaling uses height/2 */
905 res = height / 2;
906
907 /* On 60Hz, it is using a higher Vertical Output Size */
908 if (!is_50hz)
909 res += (VRES_60HZ - 480) >> 1;
910
911 /* height */
912 saa711x_write(sd, R_CE_B_VERT_OUTPUT_WINDOW_LENGTH,
913 (u8) (res & 0xff));
914 saa711x_write(sd, R_CF_B_VERT_OUTPUT_WINDOW_LENGTH_MSB,
915 (u8) ((res >> 8) & 0xff));
916
917 /* Scaling settings */
918 /* Hprescaler is floor(inres/outres) */
919 HPSC = (int)(720 / width);
920 /* 0 is not allowed (div. by zero) */
921 HPSC = HPSC ? HPSC : 1;
922 HFSC = (int)((1024 * 720) / (HPSC * width));
923 /* FIXME hardcodes to "Task B"
924 * write H prescaler integer */
925 saa711x_write(sd, R_D0_B_HORIZ_PRESCALING,
926 (u8) (HPSC & 0x3f));
927
928 v4l2_dbg(1, debug, sd, "Hpsc: 0x%05x, Hfsc: 0x%05x\n", HPSC, HFSC);
929 /* write H fine-scaling (luminance) */
930 saa711x_write(sd, R_D8_B_HORIZ_LUMA_SCALING_INC,
931 (u8) (HFSC & 0xff));
932 saa711x_write(sd, R_D9_B_HORIZ_LUMA_SCALING_INC_MSB,
933 (u8) ((HFSC >> 8) & 0xff));
934 /* write H fine-scaling (chrominance)
935 * must be lum/2, so i'll just bitshift :) */
936 saa711x_write(sd, R_DC_B_HORIZ_CHROMA_SCALING,
937 (u8) ((HFSC >> 1) & 0xff));
938 saa711x_write(sd, R_DD_B_HORIZ_CHROMA_SCALING_MSB,
939 (u8) ((HFSC >> 9) & 0xff));
940
941 VSCY = (int)((1024 * Vsrc) / height);
942 v4l2_dbg(1, debug, sd, "Vsrc: %d, Vscy: 0x%05x\n", Vsrc, VSCY);
943
944 /* Correct Contrast and Luminance */
945 saa711x_write(sd, R_D5_B_LUMA_CONTRAST_CNTL,
946 (u8) (64 * 1024 / VSCY));
947 saa711x_write(sd, R_D6_B_CHROMA_SATURATION_CNTL,
948 (u8) (64 * 1024 / VSCY));
949
950 /* write V fine-scaling (luminance) */
951 saa711x_write(sd, R_E0_B_VERT_LUMA_SCALING_INC,
952 (u8) (VSCY & 0xff));
953 saa711x_write(sd, R_E1_B_VERT_LUMA_SCALING_INC_MSB,
954 (u8) ((VSCY >> 8) & 0xff));
955 /* write V fine-scaling (chrominance) */
956 saa711x_write(sd, R_E2_B_VERT_CHROMA_SCALING_INC,
957 (u8) (VSCY & 0xff));
958 saa711x_write(sd, R_E3_B_VERT_CHROMA_SCALING_INC_MSB,
959 (u8) ((VSCY >> 8) & 0xff));
960
961 saa711x_writeregs(sd, saa7115_cfg_reset_scaler);
962
963 /* Activates task "B" */
964 saa711x_write(sd, R_80_GLOBAL_CNTL_1,
965 saa711x_read(sd, R_80_GLOBAL_CNTL_1) | 0x20);
966
967 return 0;
968 }
969
970 static void saa711x_set_v4lstd(struct v4l2_subdev *sd, v4l2_std_id std)
971 {
972 struct saa711x_state *state = to_state(sd);
973
974 /* Prevent unnecessary standard changes. During a standard
975 change the I-Port is temporarily disabled. Any devices
976 reading from that port can get confused.
977 Note that s_std is also used to switch from
978 radio to TV mode, so if a s_std is broadcast to
979 all I2C devices then you do not want to have an unwanted
980 side-effect here. */
981 if (std == state->std)
982 return;
983
984 state->std = std;
985
986 // This works for NTSC-M, SECAM-L and the 50Hz PAL variants.
987 if (std & V4L2_STD_525_60) {
988 v4l2_dbg(1, debug, sd, "decoder set standard 60 Hz\n");
989 if (state->ident == GM7113C) {
990 u8 reg = saa711x_read(sd, R_08_SYNC_CNTL);
991 reg &= ~(SAA7113_R_08_FSEL | SAA7113_R_08_AUFD);
992 reg |= SAA7113_R_08_FSEL;
993 saa711x_write(sd, R_08_SYNC_CNTL, reg);
994 } else {
995 saa711x_writeregs(sd, saa7115_cfg_60hz_video);
996 }
997 saa711x_set_size(sd, 720, 480);
998 } else {
999 v4l2_dbg(1, debug, sd, "decoder set standard 50 Hz\n");
1000 if (state->ident == GM7113C) {
1001 u8 reg = saa711x_read(sd, R_08_SYNC_CNTL);
1002 reg &= ~(SAA7113_R_08_FSEL | SAA7113_R_08_AUFD);
1003 saa711x_write(sd, R_08_SYNC_CNTL, reg);
1004 } else {
1005 saa711x_writeregs(sd, saa7115_cfg_50hz_video);
1006 }
1007 saa711x_set_size(sd, 720, 576);
1008 }
1009
1010 /* Register 0E - Bits D6-D4 on NO-AUTO mode
1011 (SAA7111 and SAA7113 doesn't have auto mode)
1012 50 Hz / 625 lines 60 Hz / 525 lines
1013 000 PAL BGDHI (4.43Mhz) NTSC M (3.58MHz)
1014 001 NTSC 4.43 (50 Hz) PAL 4.43 (60 Hz)
1015 010 Combination-PAL N (3.58MHz) NTSC 4.43 (60 Hz)
1016 011 NTSC N (3.58MHz) PAL M (3.58MHz)
1017 100 reserved NTSC-Japan (3.58MHz)
1018 */
1019 if (state->ident <= SAA7113 ||
1020 state->ident == GM7113C) {
1021 u8 reg = saa711x_read(sd, R_0E_CHROMA_CNTL_1) & 0x8f;
1022
1023 if (std == V4L2_STD_PAL_M) {
1024 reg |= 0x30;
1025 } else if (std == V4L2_STD_PAL_Nc) {
1026 reg |= 0x20;
1027 } else if (std == V4L2_STD_PAL_60) {
1028 reg |= 0x10;
1029 } else if (std == V4L2_STD_NTSC_M_JP) {
1030 reg |= 0x40;
1031 } else if (std & V4L2_STD_SECAM) {
1032 reg |= 0x50;
1033 }
1034 saa711x_write(sd, R_0E_CHROMA_CNTL_1, reg);
1035 } else {
1036 /* restart task B if needed */
1037 int taskb = saa711x_read(sd, R_80_GLOBAL_CNTL_1) & 0x10;
1038
1039 if (taskb && state->ident == SAA7114)
1040 saa711x_writeregs(sd, saa7115_cfg_vbi_on);
1041
1042 /* switch audio mode too! */
1043 saa711x_s_clock_freq(sd, state->audclk_freq);
1044 }
1045 }
1046
1047 /* setup the sliced VBI lcr registers according to the sliced VBI format */
1048 static void saa711x_set_lcr(struct v4l2_subdev *sd, struct v4l2_sliced_vbi_format *fmt)
1049 {
1050 struct saa711x_state *state = to_state(sd);
1051 int is_50hz = (state->std & V4L2_STD_625_50);
1052 u8 lcr[24];
1053 int i, x;
1054
1055 #if 1
1056 /* saa7113/7114/7118 VBI support are experimental */
1057 if (!saa711x_has_reg(state->ident, R_41_LCR_BASE))
1058 return;
1059
1060 #else
1061 /* SAA7113 and SAA7118 also should support VBI - Need testing */
1062 if (state->ident != SAA7115)
1063 return;
1064 #endif
1065
1066 for (i = 0; i <= 23; i++)
1067 lcr[i] = 0xff;
1068
1069 if (fmt == NULL) {
1070 /* raw VBI */
1071 if (is_50hz)
1072 for (i = 6; i <= 23; i++)
1073 lcr[i] = 0xdd;
1074 else
1075 for (i = 10; i <= 21; i++)
1076 lcr[i] = 0xdd;
1077 } else {
1078 /* sliced VBI */
1079 /* first clear lines that cannot be captured */
1080 if (is_50hz) {
1081 for (i = 0; i <= 5; i++)
1082 fmt->service_lines[0][i] =
1083 fmt->service_lines[1][i] = 0;
1084 }
1085 else {
1086 for (i = 0; i <= 9; i++)
1087 fmt->service_lines[0][i] =
1088 fmt->service_lines[1][i] = 0;
1089 for (i = 22; i <= 23; i++)
1090 fmt->service_lines[0][i] =
1091 fmt->service_lines[1][i] = 0;
1092 }
1093
1094 /* Now set the lcr values according to the specified service */
1095 for (i = 6; i <= 23; i++) {
1096 lcr[i] = 0;
1097 for (x = 0; x <= 1; x++) {
1098 switch (fmt->service_lines[1-x][i]) {
1099 case 0:
1100 lcr[i] |= 0xf << (4 * x);
1101 break;
1102 case V4L2_SLICED_TELETEXT_B:
1103 lcr[i] |= 1 << (4 * x);
1104 break;
1105 case V4L2_SLICED_CAPTION_525:
1106 lcr[i] |= 4 << (4 * x);
1107 break;
1108 case V4L2_SLICED_WSS_625:
1109 lcr[i] |= 5 << (4 * x);
1110 break;
1111 case V4L2_SLICED_VPS:
1112 lcr[i] |= 7 << (4 * x);
1113 break;
1114 }
1115 }
1116 }
1117 }
1118
1119 /* write the lcr registers */
1120 for (i = 2; i <= 23; i++) {
1121 saa711x_write(sd, i - 2 + R_41_LCR_BASE, lcr[i]);
1122 }
1123
1124 /* enable/disable raw VBI capturing */
1125 saa711x_writeregs(sd, fmt == NULL ?
1126 saa7115_cfg_vbi_on :
1127 saa7115_cfg_vbi_off);
1128 }
1129
1130 static int saa711x_g_sliced_fmt(struct v4l2_subdev *sd, struct v4l2_sliced_vbi_format *sliced)
1131 {
1132 static u16 lcr2vbi[] = {
1133 0, V4L2_SLICED_TELETEXT_B, 0, /* 1 */
1134 0, V4L2_SLICED_CAPTION_525, /* 4 */
1135 V4L2_SLICED_WSS_625, 0, /* 5 */
1136 V4L2_SLICED_VPS, 0, 0, 0, 0, /* 7 */
1137 0, 0, 0, 0
1138 };
1139 int i;
1140
1141 memset(sliced->service_lines, 0, sizeof(sliced->service_lines));
1142 sliced->service_set = 0;
1143 /* done if using raw VBI */
1144 if (saa711x_read(sd, R_80_GLOBAL_CNTL_1) & 0x10)
1145 return 0;
1146 for (i = 2; i <= 23; i++) {
1147 u8 v = saa711x_read(sd, i - 2 + R_41_LCR_BASE);
1148
1149 sliced->service_lines[0][i] = lcr2vbi[v >> 4];
1150 sliced->service_lines[1][i] = lcr2vbi[v & 0xf];
1151 sliced->service_set |=
1152 sliced->service_lines[0][i] | sliced->service_lines[1][i];
1153 }
1154 return 0;
1155 }
1156
1157 static int saa711x_s_raw_fmt(struct v4l2_subdev *sd, struct v4l2_vbi_format *fmt)
1158 {
1159 saa711x_set_lcr(sd, NULL);
1160 return 0;
1161 }
1162
1163 static int saa711x_s_sliced_fmt(struct v4l2_subdev *sd, struct v4l2_sliced_vbi_format *fmt)
1164 {
1165 saa711x_set_lcr(sd, fmt);
1166 return 0;
1167 }
1168
1169 static int saa711x_set_fmt(struct v4l2_subdev *sd,
1170 struct v4l2_subdev_pad_config *cfg,
1171 struct v4l2_subdev_format *format)
1172 {
1173 struct v4l2_mbus_framefmt *fmt = &format->format;
1174
1175 if (format->pad || fmt->code != MEDIA_BUS_FMT_FIXED)
1176 return -EINVAL;
1177 fmt->field = V4L2_FIELD_INTERLACED;
1178 fmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
1179 if (format->which == V4L2_SUBDEV_FORMAT_TRY)
1180 return 0;
1181 return saa711x_set_size(sd, fmt->width, fmt->height);
1182 }
1183
1184 /* Decode the sliced VBI data stream as created by the saa7115.
1185 The format is described in the saa7115 datasheet in Tables 25 and 26
1186 and in Figure 33.
1187 The current implementation uses SAV/EAV codes and not the ancillary data
1188 headers. The vbi->p pointer points to the R_5E_SDID byte right after the SAV
1189 code. */
1190 static int saa711x_decode_vbi_line(struct v4l2_subdev *sd, struct v4l2_decode_vbi_line *vbi)
1191 {
1192 struct saa711x_state *state = to_state(sd);
1193 static const char vbi_no_data_pattern[] = {
1194 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0
1195 };
1196 u8 *p = vbi->p;
1197 u32 wss;
1198 int id1, id2; /* the ID1 and ID2 bytes from the internal header */
1199
1200 vbi->type = 0; /* mark result as a failure */
1201 id1 = p[2];
1202 id2 = p[3];
1203 /* Note: the field bit is inverted for 60 Hz video */
1204 if (state->std & V4L2_STD_525_60)
1205 id1 ^= 0x40;
1206
1207 /* Skip internal header, p now points to the start of the payload */
1208 p += 4;
1209 vbi->p = p;
1210
1211 /* calculate field and line number of the VBI packet (1-23) */
1212 vbi->is_second_field = ((id1 & 0x40) != 0);
1213 vbi->line = (id1 & 0x3f) << 3;
1214 vbi->line |= (id2 & 0x70) >> 4;
1215
1216 /* Obtain data type */
1217 id2 &= 0xf;
1218
1219 /* If the VBI slicer does not detect any signal it will fill up
1220 the payload buffer with 0xa0 bytes. */
1221 if (!memcmp(p, vbi_no_data_pattern, sizeof(vbi_no_data_pattern)))
1222 return 0;
1223
1224 /* decode payloads */
1225 switch (id2) {
1226 case 1:
1227 vbi->type = V4L2_SLICED_TELETEXT_B;
1228 break;
1229 case 4:
1230 if (!saa711x_odd_parity(p[0]) || !saa711x_odd_parity(p[1]))
1231 return 0;
1232 vbi->type = V4L2_SLICED_CAPTION_525;
1233 break;
1234 case 5:
1235 wss = saa711x_decode_wss(p);
1236 if (wss == -1)
1237 return 0;
1238 p[0] = wss & 0xff;
1239 p[1] = wss >> 8;
1240 vbi->type = V4L2_SLICED_WSS_625;
1241 break;
1242 case 7:
1243 if (saa711x_decode_vps(p, p) != 0)
1244 return 0;
1245 vbi->type = V4L2_SLICED_VPS;
1246 break;
1247 default:
1248 break;
1249 }
1250 return 0;
1251 }
1252
1253 /* ============ SAA7115 AUDIO settings (end) ============= */
1254
1255 static int saa711x_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1256 {
1257 struct saa711x_state *state = to_state(sd);
1258 int status;
1259
1260 if (state->radio)
1261 return 0;
1262 status = saa711x_read(sd, R_1F_STATUS_BYTE_2_VD_DEC);
1263
1264 v4l2_dbg(1, debug, sd, "status: 0x%02x\n", status);
1265 vt->signal = ((status & (1 << 6)) == 0) ? 0xffff : 0x0;
1266 return 0;
1267 }
1268
1269 static int saa711x_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
1270 {
1271 struct saa711x_state *state = to_state(sd);
1272
1273 state->radio = 0;
1274 saa711x_set_v4lstd(sd, std);
1275 return 0;
1276 }
1277
1278 static int saa711x_s_radio(struct v4l2_subdev *sd)
1279 {
1280 struct saa711x_state *state = to_state(sd);
1281
1282 state->radio = 1;
1283 return 0;
1284 }
1285
1286 static int saa711x_s_routing(struct v4l2_subdev *sd,
1287 u32 input, u32 output, u32 config)
1288 {
1289 struct saa711x_state *state = to_state(sd);
1290 u8 mask = (state->ident <= SAA7111A) ? 0xf8 : 0xf0;
1291
1292 v4l2_dbg(1, debug, sd, "decoder set input %d output %d\n",
1293 input, output);
1294
1295 /* saa7111/3 does not have these inputs */
1296 if ((state->ident <= SAA7113 ||
1297 state->ident == GM7113C) &&
1298 (input == SAA7115_COMPOSITE4 ||
1299 input == SAA7115_COMPOSITE5)) {
1300 return -EINVAL;
1301 }
1302 if (input > SAA7115_SVIDEO3)
1303 return -EINVAL;
1304 if (state->input == input && state->output == output)
1305 return 0;
1306 v4l2_dbg(1, debug, sd, "now setting %s input %s output\n",
1307 (input >= SAA7115_SVIDEO0) ? "S-Video" : "Composite",
1308 (output == SAA7115_IPORT_ON) ? "iport on" : "iport off");
1309 state->input = input;
1310
1311 /* saa7111 has slightly different input numbering */
1312 if (state->ident <= SAA7111A) {
1313 if (input >= SAA7115_COMPOSITE4)
1314 input -= 2;
1315 /* saa7111 specific */
1316 saa711x_write(sd, R_10_CHROMA_CNTL_2,
1317 (saa711x_read(sd, R_10_CHROMA_CNTL_2) & 0x3f) |
1318 ((output & 0xc0) ^ 0x40));
1319 saa711x_write(sd, R_13_RT_X_PORT_OUT_CNTL,
1320 (saa711x_read(sd, R_13_RT_X_PORT_OUT_CNTL) & 0xf0) |
1321 ((output & 2) ? 0x0a : 0));
1322 }
1323
1324 /* select mode */
1325 saa711x_write(sd, R_02_INPUT_CNTL_1,
1326 (saa711x_read(sd, R_02_INPUT_CNTL_1) & mask) |
1327 input);
1328
1329 /* bypass chrominance trap for S-Video modes */
1330 saa711x_write(sd, R_09_LUMA_CNTL,
1331 (saa711x_read(sd, R_09_LUMA_CNTL) & 0x7f) |
1332 (state->input >= SAA7115_SVIDEO0 ? 0x80 : 0x0));
1333
1334 state->output = output;
1335 if (state->ident == SAA7114 ||
1336 state->ident == SAA7115) {
1337 saa711x_write(sd, R_83_X_PORT_I_O_ENA_AND_OUT_CLK,
1338 (saa711x_read(sd, R_83_X_PORT_I_O_ENA_AND_OUT_CLK) & 0xfe) |
1339 (state->output & 0x01));
1340 }
1341 if (state->ident > SAA7111A) {
1342 if (config & SAA7115_IDQ_IS_DEFAULT)
1343 saa711x_write(sd, R_85_I_PORT_SIGNAL_POLAR, 0x20);
1344 else
1345 saa711x_write(sd, R_85_I_PORT_SIGNAL_POLAR, 0x21);
1346 }
1347 return 0;
1348 }
1349
1350 static int saa711x_s_gpio(struct v4l2_subdev *sd, u32 val)
1351 {
1352 struct saa711x_state *state = to_state(sd);
1353
1354 if (state->ident > SAA7111A)
1355 return -EINVAL;
1356 saa711x_write(sd, 0x11, (saa711x_read(sd, 0x11) & 0x7f) |
1357 (val ? 0x80 : 0));
1358 return 0;
1359 }
1360
1361 static int saa711x_s_stream(struct v4l2_subdev *sd, int enable)
1362 {
1363 struct saa711x_state *state = to_state(sd);
1364
1365 v4l2_dbg(1, debug, sd, "%s output\n",
1366 enable ? "enable" : "disable");
1367
1368 if (state->enable == enable)
1369 return 0;
1370 state->enable = enable;
1371 if (!saa711x_has_reg(state->ident, R_87_I_PORT_I_O_ENA_OUT_CLK_AND_GATED))
1372 return 0;
1373 saa711x_write(sd, R_87_I_PORT_I_O_ENA_OUT_CLK_AND_GATED, state->enable);
1374 return 0;
1375 }
1376
1377 static int saa711x_s_crystal_freq(struct v4l2_subdev *sd, u32 freq, u32 flags)
1378 {
1379 struct saa711x_state *state = to_state(sd);
1380
1381 if (freq != SAA7115_FREQ_32_11_MHZ && freq != SAA7115_FREQ_24_576_MHZ)
1382 return -EINVAL;
1383 state->crystal_freq = freq;
1384 state->double_asclk = flags & SAA7115_FREQ_FL_DOUBLE_ASCLK;
1385 state->cgcdiv = (flags & SAA7115_FREQ_FL_CGCDIV) ? 3 : 4;
1386 state->ucgc = flags & SAA7115_FREQ_FL_UCGC;
1387 state->apll = flags & SAA7115_FREQ_FL_APLL;
1388 saa711x_s_clock_freq(sd, state->audclk_freq);
1389 return 0;
1390 }
1391
1392 static int saa711x_reset(struct v4l2_subdev *sd, u32 val)
1393 {
1394 v4l2_dbg(1, debug, sd, "decoder RESET\n");
1395 saa711x_writeregs(sd, saa7115_cfg_reset_scaler);
1396 return 0;
1397 }
1398
1399 static int saa711x_g_vbi_data(struct v4l2_subdev *sd, struct v4l2_sliced_vbi_data *data)
1400 {
1401 /* Note: the internal field ID is inverted for NTSC,
1402 so data->field 0 maps to the saa7115 even field,
1403 whereas for PAL it maps to the saa7115 odd field. */
1404 switch (data->id) {
1405 case V4L2_SLICED_WSS_625:
1406 if (saa711x_read(sd, 0x6b) & 0xc0)
1407 return -EIO;
1408 data->data[0] = saa711x_read(sd, 0x6c);
1409 data->data[1] = saa711x_read(sd, 0x6d);
1410 return 0;
1411 case V4L2_SLICED_CAPTION_525:
1412 if (data->field == 0) {
1413 /* CC */
1414 if (saa711x_read(sd, 0x66) & 0x30)
1415 return -EIO;
1416 data->data[0] = saa711x_read(sd, 0x69);
1417 data->data[1] = saa711x_read(sd, 0x6a);
1418 return 0;
1419 }
1420 /* XDS */
1421 if (saa711x_read(sd, 0x66) & 0xc0)
1422 return -EIO;
1423 data->data[0] = saa711x_read(sd, 0x67);
1424 data->data[1] = saa711x_read(sd, 0x68);
1425 return 0;
1426 default:
1427 return -EINVAL;
1428 }
1429 }
1430
1431 static int saa711x_querystd(struct v4l2_subdev *sd, v4l2_std_id *std)
1432 {
1433 struct saa711x_state *state = to_state(sd);
1434 int reg1f, reg1e;
1435
1436 /*
1437 * The V4L2 core already initializes std with all supported
1438 * Standards. All driver needs to do is to mask it, to remove
1439 * standards that don't apply from the mask
1440 */
1441
1442 reg1f = saa711x_read(sd, R_1F_STATUS_BYTE_2_VD_DEC);
1443
1444 if (state->ident == SAA7115) {
1445 reg1e = saa711x_read(sd, R_1E_STATUS_BYTE_1_VD_DEC);
1446
1447 v4l2_dbg(1, debug, sd, "Status byte 1 (0x1e)=0x%02x\n", reg1e);
1448
1449 switch (reg1e & 0x03) {
1450 case 1:
1451 *std &= V4L2_STD_NTSC;
1452 break;
1453 case 2:
1454 /*
1455 * V4L2_STD_PAL just cover the european PAL standards.
1456 * This is wrong, as the device could also be using an
1457 * other PAL standard.
1458 */
1459 *std &= V4L2_STD_PAL | V4L2_STD_PAL_N | V4L2_STD_PAL_Nc |
1460 V4L2_STD_PAL_M | V4L2_STD_PAL_60;
1461 break;
1462 case 3:
1463 *std &= V4L2_STD_SECAM;
1464 break;
1465 default:
1466 *std = V4L2_STD_UNKNOWN;
1467 /* Can't detect anything */
1468 break;
1469 }
1470 }
1471
1472 v4l2_dbg(1, debug, sd, "Status byte 2 (0x1f)=0x%02x\n", reg1f);
1473
1474 /* horizontal/vertical not locked */
1475 if (reg1f & 0x40) {
1476 *std = V4L2_STD_UNKNOWN;
1477 goto ret;
1478 }
1479
1480 if (reg1f & 0x20)
1481 *std &= V4L2_STD_525_60;
1482 else
1483 *std &= V4L2_STD_625_50;
1484
1485 ret:
1486 v4l2_dbg(1, debug, sd, "detected std mask = %08Lx\n", *std);
1487
1488 return 0;
1489 }
1490
1491 static int saa711x_g_input_status(struct v4l2_subdev *sd, u32 *status)
1492 {
1493 struct saa711x_state *state = to_state(sd);
1494 int reg1e = 0x80;
1495 int reg1f;
1496
1497 *status = V4L2_IN_ST_NO_SIGNAL;
1498 if (state->ident == SAA7115)
1499 reg1e = saa711x_read(sd, R_1E_STATUS_BYTE_1_VD_DEC);
1500 reg1f = saa711x_read(sd, R_1F_STATUS_BYTE_2_VD_DEC);
1501 if ((reg1f & 0xc1) == 0x81 && (reg1e & 0xc0) == 0x80)
1502 *status = 0;
1503 return 0;
1504 }
1505
1506 #ifdef CONFIG_VIDEO_ADV_DEBUG
1507 static int saa711x_g_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
1508 {
1509 reg->val = saa711x_read(sd, reg->reg & 0xff);
1510 reg->size = 1;
1511 return 0;
1512 }
1513
1514 static int saa711x_s_register(struct v4l2_subdev *sd, const struct v4l2_dbg_register *reg)
1515 {
1516 saa711x_write(sd, reg->reg & 0xff, reg->val & 0xff);
1517 return 0;
1518 }
1519 #endif
1520
1521 static int saa711x_log_status(struct v4l2_subdev *sd)
1522 {
1523 struct saa711x_state *state = to_state(sd);
1524 int reg1e, reg1f;
1525 int signalOk;
1526 int vcr;
1527
1528 v4l2_info(sd, "Audio frequency: %d Hz\n", state->audclk_freq);
1529 if (state->ident != SAA7115) {
1530 /* status for the saa7114 */
1531 reg1f = saa711x_read(sd, R_1F_STATUS_BYTE_2_VD_DEC);
1532 signalOk = (reg1f & 0xc1) == 0x81;
1533 v4l2_info(sd, "Video signal: %s\n", signalOk ? "ok" : "bad");
1534 v4l2_info(sd, "Frequency: %s\n", (reg1f & 0x20) ? "60 Hz" : "50 Hz");
1535 return 0;
1536 }
1537
1538 /* status for the saa7115 */
1539 reg1e = saa711x_read(sd, R_1E_STATUS_BYTE_1_VD_DEC);
1540 reg1f = saa711x_read(sd, R_1F_STATUS_BYTE_2_VD_DEC);
1541
1542 signalOk = (reg1f & 0xc1) == 0x81 && (reg1e & 0xc0) == 0x80;
1543 vcr = !(reg1f & 0x10);
1544
1545 if (state->input >= 6)
1546 v4l2_info(sd, "Input: S-Video %d\n", state->input - 6);
1547 else
1548 v4l2_info(sd, "Input: Composite %d\n", state->input);
1549 v4l2_info(sd, "Video signal: %s\n", signalOk ? (vcr ? "VCR" : "broadcast/DVD") : "bad");
1550 v4l2_info(sd, "Frequency: %s\n", (reg1f & 0x20) ? "60 Hz" : "50 Hz");
1551
1552 switch (reg1e & 0x03) {
1553 case 1:
1554 v4l2_info(sd, "Detected format: NTSC\n");
1555 break;
1556 case 2:
1557 v4l2_info(sd, "Detected format: PAL\n");
1558 break;
1559 case 3:
1560 v4l2_info(sd, "Detected format: SECAM\n");
1561 break;
1562 default:
1563 v4l2_info(sd, "Detected format: BW/No color\n");
1564 break;
1565 }
1566 v4l2_info(sd, "Width, Height: %d, %d\n", state->width, state->height);
1567 v4l2_ctrl_handler_log_status(&state->hdl, sd->name);
1568 return 0;
1569 }
1570
1571 /* ----------------------------------------------------------------------- */
1572
1573 static const struct v4l2_ctrl_ops saa711x_ctrl_ops = {
1574 .s_ctrl = saa711x_s_ctrl,
1575 .g_volatile_ctrl = saa711x_g_volatile_ctrl,
1576 };
1577
1578 static const struct v4l2_subdev_core_ops saa711x_core_ops = {
1579 .log_status = saa711x_log_status,
1580 .reset = saa711x_reset,
1581 .s_gpio = saa711x_s_gpio,
1582 #ifdef CONFIG_VIDEO_ADV_DEBUG
1583 .g_register = saa711x_g_register,
1584 .s_register = saa711x_s_register,
1585 #endif
1586 };
1587
1588 static const struct v4l2_subdev_tuner_ops saa711x_tuner_ops = {
1589 .s_radio = saa711x_s_radio,
1590 .g_tuner = saa711x_g_tuner,
1591 };
1592
1593 static const struct v4l2_subdev_audio_ops saa711x_audio_ops = {
1594 .s_clock_freq = saa711x_s_clock_freq,
1595 };
1596
1597 static const struct v4l2_subdev_video_ops saa711x_video_ops = {
1598 .s_std = saa711x_s_std,
1599 .s_routing = saa711x_s_routing,
1600 .s_crystal_freq = saa711x_s_crystal_freq,
1601 .s_stream = saa711x_s_stream,
1602 .querystd = saa711x_querystd,
1603 .g_input_status = saa711x_g_input_status,
1604 };
1605
1606 static const struct v4l2_subdev_vbi_ops saa711x_vbi_ops = {
1607 .g_vbi_data = saa711x_g_vbi_data,
1608 .decode_vbi_line = saa711x_decode_vbi_line,
1609 .g_sliced_fmt = saa711x_g_sliced_fmt,
1610 .s_sliced_fmt = saa711x_s_sliced_fmt,
1611 .s_raw_fmt = saa711x_s_raw_fmt,
1612 };
1613
1614 static const struct v4l2_subdev_pad_ops saa711x_pad_ops = {
1615 .set_fmt = saa711x_set_fmt,
1616 };
1617
1618 static const struct v4l2_subdev_ops saa711x_ops = {
1619 .core = &saa711x_core_ops,
1620 .tuner = &saa711x_tuner_ops,
1621 .audio = &saa711x_audio_ops,
1622 .video = &saa711x_video_ops,
1623 .vbi = &saa711x_vbi_ops,
1624 .pad = &saa711x_pad_ops,
1625 };
1626
1627 #define CHIP_VER_SIZE 16
1628
1629 /* ----------------------------------------------------------------------- */
1630
1631 static void saa711x_write_platform_data(struct saa711x_state *state,
1632 struct saa7115_platform_data *data)
1633 {
1634 struct v4l2_subdev *sd = &state->sd;
1635 u8 work;
1636
1637 if (state->ident != GM7113C &&
1638 state->ident != SAA7113)
1639 return;
1640
1641 if (data->saa7113_r08_htc) {
1642 work = saa711x_read(sd, R_08_SYNC_CNTL);
1643 work &= ~SAA7113_R_08_HTC_MASK;
1644 work |= ((*data->saa7113_r08_htc) << SAA7113_R_08_HTC_OFFSET);
1645 saa711x_write(sd, R_08_SYNC_CNTL, work);
1646 }
1647
1648 if (data->saa7113_r10_vrln) {
1649 work = saa711x_read(sd, R_10_CHROMA_CNTL_2);
1650 work &= ~SAA7113_R_10_VRLN_MASK;
1651 if (*data->saa7113_r10_vrln)
1652 work |= (1 << SAA7113_R_10_VRLN_OFFSET);
1653 saa711x_write(sd, R_10_CHROMA_CNTL_2, work);
1654 }
1655
1656 if (data->saa7113_r10_ofts) {
1657 work = saa711x_read(sd, R_10_CHROMA_CNTL_2);
1658 work &= ~SAA7113_R_10_OFTS_MASK;
1659 work |= (*data->saa7113_r10_ofts << SAA7113_R_10_OFTS_OFFSET);
1660 saa711x_write(sd, R_10_CHROMA_CNTL_2, work);
1661 }
1662
1663 if (data->saa7113_r12_rts0) {
1664 work = saa711x_read(sd, R_12_RT_SIGNAL_CNTL);
1665 work &= ~SAA7113_R_12_RTS0_MASK;
1666 work |= (*data->saa7113_r12_rts0 << SAA7113_R_12_RTS0_OFFSET);
1667
1668 /* According to the datasheet,
1669 * SAA7113_RTS_DOT_IN should only be used on RTS1 */
1670 WARN_ON(*data->saa7113_r12_rts0 == SAA7113_RTS_DOT_IN);
1671 saa711x_write(sd, R_12_RT_SIGNAL_CNTL, work);
1672 }
1673
1674 if (data->saa7113_r12_rts1) {
1675 work = saa711x_read(sd, R_12_RT_SIGNAL_CNTL);
1676 work &= ~SAA7113_R_12_RTS1_MASK;
1677 work |= (*data->saa7113_r12_rts1 << SAA7113_R_12_RTS1_OFFSET);
1678 saa711x_write(sd, R_12_RT_SIGNAL_CNTL, work);
1679 }
1680
1681 if (data->saa7113_r13_adlsb) {
1682 work = saa711x_read(sd, R_13_RT_X_PORT_OUT_CNTL);
1683 work &= ~SAA7113_R_13_ADLSB_MASK;
1684 if (*data->saa7113_r13_adlsb)
1685 work |= (1 << SAA7113_R_13_ADLSB_OFFSET);
1686 saa711x_write(sd, R_13_RT_X_PORT_OUT_CNTL, work);
1687 }
1688 }
1689
1690 /**
1691 * saa711x_detect_chip - Detects the saa711x (or clone) variant
1692 * @client: I2C client structure.
1693 * @id: I2C device ID structure.
1694 * @name: Name of the device to be filled.
1695 *
1696 * Detects the Philips/NXP saa711x chip, or some clone of it.
1697 * if 'id' is NULL or id->driver_data is equal to 1, it auto-probes
1698 * the analog demod.
1699 * If the tuner is not found, it returns -ENODEV.
1700 * If auto-detection is disabled and the tuner doesn't match what it was
1701 * required, it returns -EINVAL and fills 'name'.
1702 * If the chip is found, it returns the chip ID and fills 'name'.
1703 */
1704 static int saa711x_detect_chip(struct i2c_client *client,
1705 const struct i2c_device_id *id,
1706 char *name)
1707 {
1708 char chip_ver[CHIP_VER_SIZE];
1709 char chip_id;
1710 int i;
1711 int autodetect;
1712
1713 autodetect = !id || id->driver_data == 1;
1714
1715 /* Read the chip version register */
1716 for (i = 0; i < CHIP_VER_SIZE; i++) {
1717 i2c_smbus_write_byte_data(client, 0, i);
1718 chip_ver[i] = i2c_smbus_read_byte_data(client, 0);
1719 name[i] = (chip_ver[i] & 0x0f) + '0';
1720 if (name[i] > '9')
1721 name[i] += 'a' - '9' - 1;
1722 }
1723 name[i] = '\0';
1724
1725 /* Check if it is a Philips/NXP chip */
1726 if (!memcmp(name + 1, "f711", 4)) {
1727 chip_id = name[5];
1728 snprintf(name, CHIP_VER_SIZE, "saa711%c", chip_id);
1729
1730 if (!autodetect && strcmp(name, id->name))
1731 return -EINVAL;
1732
1733 switch (chip_id) {
1734 case '1':
1735 if (chip_ver[0] & 0xf0) {
1736 snprintf(name, CHIP_VER_SIZE, "saa711%ca", chip_id);
1737 v4l_info(client, "saa7111a variant found\n");
1738 return SAA7111A;
1739 }
1740 return SAA7111;
1741 case '3':
1742 return SAA7113;
1743 case '4':
1744 return SAA7114;
1745 case '5':
1746 return SAA7115;
1747 case '8':
1748 return SAA7118;
1749 default:
1750 v4l2_info(client,
1751 "WARNING: Philips/NXP chip unknown - Falling back to saa7111\n");
1752 return SAA7111;
1753 }
1754 }
1755
1756 /* Check if it is a gm7113c */
1757 if (!memcmp(name, "0000", 4)) {
1758 chip_id = 0;
1759 for (i = 0; i < 4; i++) {
1760 chip_id = chip_id << 1;
1761 chip_id |= (chip_ver[i] & 0x80) ? 1 : 0;
1762 }
1763
1764 /*
1765 * Note: From the datasheet, only versions 1 and 2
1766 * exists. However, tests on a device labeled as:
1767 * "GM7113C 1145" returned "10" on all 16 chip
1768 * version (reg 0x00) reads. So, we need to also
1769 * accept at least version 0. For now, let's just
1770 * assume that a device that returns "0000" for
1771 * the lower nibble is a gm7113c.
1772 */
1773
1774 strscpy(name, "gm7113c", CHIP_VER_SIZE);
1775
1776 if (!autodetect && strcmp(name, id->name))
1777 return -EINVAL;
1778
1779 v4l_dbg(1, debug, client,
1780 "It seems to be a %s chip (%*ph) @ 0x%x.\n",
1781 name, 16, chip_ver, client->addr << 1);
1782
1783 return GM7113C;
1784 }
1785
1786 /* Check if it is a CJC7113 */
1787 if (!memcmp(name, "1111111111111111", CHIP_VER_SIZE)) {
1788 strscpy(name, "cjc7113", CHIP_VER_SIZE);
1789
1790 if (!autodetect && strcmp(name, id->name))
1791 return -EINVAL;
1792
1793 v4l_dbg(1, debug, client,
1794 "It seems to be a %s chip (%*ph) @ 0x%x.\n",
1795 name, 16, chip_ver, client->addr << 1);
1796
1797 /* CJC7113 seems to be SAA7113-compatible */
1798 return SAA7113;
1799 }
1800
1801 /* Chip was not discovered. Return its ID and don't bind */
1802 v4l_dbg(1, debug, client, "chip %*ph @ 0x%x is unknown.\n",
1803 16, chip_ver, client->addr << 1);
1804 return -ENODEV;
1805 }
1806
1807 static int saa711x_probe(struct i2c_client *client,
1808 const struct i2c_device_id *id)
1809 {
1810 struct saa711x_state *state;
1811 struct v4l2_subdev *sd;
1812 struct v4l2_ctrl_handler *hdl;
1813 struct saa7115_platform_data *pdata;
1814 int ident;
1815 char name[CHIP_VER_SIZE + 1];
1816 #if defined(CONFIG_MEDIA_CONTROLLER)
1817 int ret;
1818 #endif
1819
1820 /* Check if the adapter supports the needed features */
1821 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1822 return -EIO;
1823
1824 ident = saa711x_detect_chip(client, id, name);
1825 if (ident == -EINVAL) {
1826 /* Chip exists, but doesn't match */
1827 v4l_warn(client, "found %s while %s was expected\n",
1828 name, id->name);
1829 return -ENODEV;
1830 }
1831 if (ident < 0)
1832 return ident;
1833
1834 strscpy(client->name, name, sizeof(client->name));
1835
1836 state = devm_kzalloc(&client->dev, sizeof(*state), GFP_KERNEL);
1837 if (state == NULL)
1838 return -ENOMEM;
1839 sd = &state->sd;
1840 v4l2_i2c_subdev_init(sd, client, &saa711x_ops);
1841
1842 #if defined(CONFIG_MEDIA_CONTROLLER)
1843 state->pads[SAA711X_PAD_IF_INPUT].flags = MEDIA_PAD_FL_SINK;
1844 state->pads[SAA711X_PAD_IF_INPUT].sig_type = PAD_SIGNAL_ANALOG;
1845 state->pads[SAA711X_PAD_VID_OUT].flags = MEDIA_PAD_FL_SOURCE;
1846 state->pads[SAA711X_PAD_VID_OUT].sig_type = PAD_SIGNAL_DV;
1847
1848 sd->entity.function = MEDIA_ENT_F_ATV_DECODER;
1849
1850 ret = media_entity_pads_init(&sd->entity, SAA711X_NUM_PADS,
1851 state->pads);
1852 if (ret < 0)
1853 return ret;
1854 #endif
1855
1856 v4l_info(client, "%s found @ 0x%x (%s)\n", name,
1857 client->addr << 1, client->adapter->name);
1858 hdl = &state->hdl;
1859 v4l2_ctrl_handler_init(hdl, 6);
1860 /* add in ascending ID order */
1861 v4l2_ctrl_new_std(hdl, &saa711x_ctrl_ops,
1862 V4L2_CID_BRIGHTNESS, 0, 255, 1, 128);
1863 v4l2_ctrl_new_std(hdl, &saa711x_ctrl_ops,
1864 V4L2_CID_CONTRAST, 0, 127, 1, 64);
1865 v4l2_ctrl_new_std(hdl, &saa711x_ctrl_ops,
1866 V4L2_CID_SATURATION, 0, 127, 1, 64);
1867 v4l2_ctrl_new_std(hdl, &saa711x_ctrl_ops,
1868 V4L2_CID_HUE, -128, 127, 1, 0);
1869 state->agc = v4l2_ctrl_new_std(hdl, &saa711x_ctrl_ops,
1870 V4L2_CID_CHROMA_AGC, 0, 1, 1, 1);
1871 state->gain = v4l2_ctrl_new_std(hdl, &saa711x_ctrl_ops,
1872 V4L2_CID_CHROMA_GAIN, 0, 127, 1, 40);
1873 sd->ctrl_handler = hdl;
1874 if (hdl->error) {
1875 int err = hdl->error;
1876
1877 v4l2_ctrl_handler_free(hdl);
1878 return err;
1879 }
1880 v4l2_ctrl_auto_cluster(2, &state->agc, 0, true);
1881
1882 state->input = -1;
1883 state->output = SAA7115_IPORT_ON;
1884 state->enable = 1;
1885 state->radio = 0;
1886 state->ident = ident;
1887
1888 state->audclk_freq = 48000;
1889
1890 v4l2_dbg(1, debug, sd, "writing init values\n");
1891
1892 /* init to 60hz/48khz */
1893 state->crystal_freq = SAA7115_FREQ_24_576_MHZ;
1894 pdata = client->dev.platform_data;
1895 switch (state->ident) {
1896 case SAA7111:
1897 case SAA7111A:
1898 saa711x_writeregs(sd, saa7111_init);
1899 break;
1900 case GM7113C:
1901 saa711x_writeregs(sd, gm7113c_init);
1902 break;
1903 case SAA7113:
1904 if (pdata && pdata->saa7113_force_gm7113c_init)
1905 saa711x_writeregs(sd, gm7113c_init);
1906 else
1907 saa711x_writeregs(sd, saa7113_init);
1908 break;
1909 default:
1910 state->crystal_freq = SAA7115_FREQ_32_11_MHZ;
1911 saa711x_writeregs(sd, saa7115_init_auto_input);
1912 }
1913 if (state->ident > SAA7111A && state->ident != GM7113C)
1914 saa711x_writeregs(sd, saa7115_init_misc);
1915
1916 if (pdata)
1917 saa711x_write_platform_data(state, pdata);
1918
1919 saa711x_set_v4lstd(sd, V4L2_STD_NTSC);
1920 v4l2_ctrl_handler_setup(hdl);
1921
1922 v4l2_dbg(1, debug, sd, "status: (1E) 0x%02x, (1F) 0x%02x\n",
1923 saa711x_read(sd, R_1E_STATUS_BYTE_1_VD_DEC),
1924 saa711x_read(sd, R_1F_STATUS_BYTE_2_VD_DEC));
1925 return 0;
1926 }
1927
1928 /* ----------------------------------------------------------------------- */
1929
1930 static int saa711x_remove(struct i2c_client *client)
1931 {
1932 struct v4l2_subdev *sd = i2c_get_clientdata(client);
1933
1934 v4l2_device_unregister_subdev(sd);
1935 v4l2_ctrl_handler_free(sd->ctrl_handler);
1936 return 0;
1937 }
1938
1939 static const struct i2c_device_id saa711x_id[] = {
1940 { "saa7115_auto", 1 }, /* autodetect */
1941 { "saa7111", 0 },
1942 { "saa7113", 0 },
1943 { "saa7114", 0 },
1944 { "saa7115", 0 },
1945 { "saa7118", 0 },
1946 { "gm7113c", 0 },
1947 { }
1948 };
1949 MODULE_DEVICE_TABLE(i2c, saa711x_id);
1950
1951 static struct i2c_driver saa711x_driver = {
1952 .driver = {
1953 .name = "saa7115",
1954 },
1955 .probe = saa711x_probe,
1956 .remove = saa711x_remove,
1957 .id_table = saa711x_id,
1958 };
1959
1960 module_i2c_driver(saa711x_driver);
Linux with added FPC-III support