1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Driver for Xceive XC4000 "QAM/8VSB single chip tuner"
4 *
5 * Copyright (c) 2007 Xceive Corporation
6 * Copyright (c) 2007 Steven Toth <stoth@linuxtv.org>
7 * Copyright (c) 2009 Devin Heitmueller <dheitmueller@kernellabs.com>
8 * Copyright (c) 2009 Davide Ferri <d.ferri@zero11.it>
9 * Copyright (c) 2010 Istvan Varga <istvan_v@mailbox.hu>
10 */
11
12 #include <linux/module.h>
13 #include <linux/moduleparam.h>
14 #include <linux/videodev2.h>
15 #include <linux/delay.h>
16 #include <linux/dvb/frontend.h>
17 #include <linux/i2c.h>
18 #include <linux/mutex.h>
19 #include <linux/unaligned.h>
20
21 #include <media/dvb_frontend.h>
22
23 #include "xc4000.h"
24 #include "tuner-i2c.h"
25 #include "xc2028-types.h"
26
27 static int debug;
28 module_param(debug, int, 0644);
29 MODULE_PARM_DESC(debug, "Debugging level (0 to 2, default: 0 (off)).");
30
31 static int no_poweroff;
32 module_param(no_poweroff, int, 0644);
33 MODULE_PARM_DESC(no_poweroff, "Power management (1: disabled, 2: enabled, 0 (default): use device-specific default mode).");
34
35 static int audio_std;
36 module_param(audio_std, int, 0644);
37 MODULE_PARM_DESC(audio_std, "Audio standard. XC4000 audio decoder explicitly needs to know what audio standard is needed for some video standards with audio A2 or NICAM. The valid settings are a sum of:\n"
38 " 1: use NICAM/B or A2/B instead of NICAM/A or A2/A\n"
39 " 2: use A2 instead of NICAM or BTSC\n"
40 " 4: use SECAM/K3 instead of K1\n"
41 " 8: use PAL-D/K audio for SECAM-D/K\n"
42 "16: use FM radio input 1 instead of input 2\n"
43 "32: use mono audio (the lower three bits are ignored)");
44
45 static char firmware_name[30];
46 module_param_string(firmware_name, firmware_name, sizeof(firmware_name), 0);
47 MODULE_PARM_DESC(firmware_name, "Firmware file name. Allows overriding the default firmware name.");
48
49 static DEFINE_MUTEX(xc4000_list_mutex);
50 static LIST_HEAD(hybrid_tuner_instance_list);
51
52 #define dprintk(level, fmt, arg...) if (debug >= level) \
53 printk(KERN_INFO "%s: " fmt, "xc4000", ## arg)
54
55 /* struct for storing firmware table */
56 struct firmware_description {
57 unsigned int type;
58 v4l2_std_id id;
59 __u16 int_freq;
60 unsigned char *ptr;
61 unsigned int size;
62 };
63
64 struct firmware_properties {
65 unsigned int type;
66 v4l2_std_id id;
67 v4l2_std_id std_req;
68 __u16 int_freq;
69 unsigned int scode_table;
70 int scode_nr;
71 };
72
73 struct xc4000_priv {
74 struct tuner_i2c_props i2c_props;
75 struct list_head hybrid_tuner_instance_list;
76 struct firmware_description *firm;
77 int firm_size;
78 u32 if_khz;
79 u32 freq_hz, freq_offset;
80 u32 bandwidth;
81 u8 video_standard;
82 u8 rf_mode;
83 u8 default_pm;
84 u8 dvb_amplitude;
85 u8 set_smoothedcvbs;
86 u8 ignore_i2c_write_errors;
87 __u16 firm_version;
88 struct firmware_properties cur_fw;
89 __u16 hwmodel;
90 __u16 hwvers;
91 struct mutex lock;
92 };
93
94 #define XC4000_AUDIO_STD_B 1
95 #define XC4000_AUDIO_STD_A2 2
96 #define XC4000_AUDIO_STD_K3 4
97 #define XC4000_AUDIO_STD_L 8
98 #define XC4000_AUDIO_STD_INPUT1 16
99 #define XC4000_AUDIO_STD_MONO 32
100
101 #define XC4000_DEFAULT_FIRMWARE "dvb-fe-xc4000-1.4.fw"
102 #define XC4000_DEFAULT_FIRMWARE_NEW "dvb-fe-xc4000-1.4.1.fw"
103
104 /* Misc Defines */
105 #define MAX_TV_STANDARD 24
106 #define XC_MAX_I2C_WRITE_LENGTH 64
107 #define XC_POWERED_DOWN 0x80000000U
108
109 /* Signal Types */
110 #define XC_RF_MODE_AIR 0
111 #define XC_RF_MODE_CABLE 1
112
113 /* Product id */
114 #define XC_PRODUCT_ID_FW_NOT_LOADED 0x2000
115 #define XC_PRODUCT_ID_XC4000 0x0FA0
116 #define XC_PRODUCT_ID_XC4100 0x1004
117
118 /* Registers (Write-only) */
119 #define XREG_INIT 0x00
120 #define XREG_VIDEO_MODE 0x01
121 #define XREG_AUDIO_MODE 0x02
122 #define XREG_RF_FREQ 0x03
123 #define XREG_D_CODE 0x04
124 #define XREG_DIRECTSITTING_MODE 0x05
125 #define XREG_SEEK_MODE 0x06
126 #define XREG_POWER_DOWN 0x08
127 #define XREG_SIGNALSOURCE 0x0A
128 #define XREG_SMOOTHEDCVBS 0x0E
129 #define XREG_AMPLITUDE 0x10
130
131 /* Registers (Read-only) */
132 #define XREG_ADC_ENV 0x00
133 #define XREG_QUALITY 0x01
134 #define XREG_FRAME_LINES 0x02
135 #define XREG_HSYNC_FREQ 0x03
136 #define XREG_LOCK 0x04
137 #define XREG_FREQ_ERROR 0x05
138 #define XREG_SNR 0x06
139 #define XREG_VERSION 0x07
140 #define XREG_PRODUCT_ID 0x08
141 #define XREG_SIGNAL_LEVEL 0x0A
142 #define XREG_NOISE_LEVEL 0x0B
143
144 /*
145 Basic firmware description. This will remain with
146 the driver for documentation purposes.
147
148 This represents an I2C firmware file encoded as a
149 string of unsigned char. Format is as follows:
150
151 char[0 ]=len0_MSB -> len = len_MSB * 256 + len_LSB
152 char[1 ]=len0_LSB -> length of first write transaction
153 char[2 ]=data0 -> first byte to be sent
154 char[3 ]=data1
155 char[4 ]=data2
156 char[ ]=...
157 char[M ]=dataN -> last byte to be sent
158 char[M+1]=len1_MSB -> len = len_MSB * 256 + len_LSB
159 char[M+2]=len1_LSB -> length of second write transaction
160 char[M+3]=data0
161 char[M+4]=data1
162 ...
163 etc.
164
165 The [len] value should be interpreted as follows:
166
167 len= len_MSB _ len_LSB
168 len=1111_1111_1111_1111 : End of I2C_SEQUENCE
169 len=0000_0000_0000_0000 : Reset command: Do hardware reset
170 len=0NNN_NNNN_NNNN_NNNN : Normal transaction: number of bytes = {1:32767)
171 len=1WWW_WWWW_WWWW_WWWW : Wait command: wait for {1:32767} ms
172
173 For the RESET and WAIT commands, the two following bytes will contain
174 immediately the length of the following transaction.
175 */
176
177 struct XC_TV_STANDARD {
178 const char *Name;
179 u16 audio_mode;
180 u16 video_mode;
181 u16 int_freq;
182 };
183
184 /* Tuner standards */
185 #define XC4000_MN_NTSC_PAL_BTSC 0
186 #define XC4000_MN_NTSC_PAL_A2 1
187 #define XC4000_MN_NTSC_PAL_EIAJ 2
188 #define XC4000_MN_NTSC_PAL_Mono 3
189 #define XC4000_BG_PAL_A2 4
190 #define XC4000_BG_PAL_NICAM 5
191 #define XC4000_BG_PAL_MONO 6
192 #define XC4000_I_PAL_NICAM 7
193 #define XC4000_I_PAL_NICAM_MONO 8
194 #define XC4000_DK_PAL_A2 9
195 #define XC4000_DK_PAL_NICAM 10
196 #define XC4000_DK_PAL_MONO 11
197 #define XC4000_DK_SECAM_A2DK1 12
198 #define XC4000_DK_SECAM_A2LDK3 13
199 #define XC4000_DK_SECAM_A2MONO 14
200 #define XC4000_DK_SECAM_NICAM 15
201 #define XC4000_L_SECAM_NICAM 16
202 #define XC4000_LC_SECAM_NICAM 17
203 #define XC4000_DTV6 18
204 #define XC4000_DTV8 19
205 #define XC4000_DTV7_8 20
206 #define XC4000_DTV7 21
207 #define XC4000_FM_Radio_INPUT2 22
208 #define XC4000_FM_Radio_INPUT1 23
209
210 static struct XC_TV_STANDARD xc4000_standard[MAX_TV_STANDARD] = {
211 {"M/N-NTSC/PAL-BTSC", 0x0000, 0x80A0, 4500},
212 {"M/N-NTSC/PAL-A2", 0x0000, 0x80A0, 4600},
213 {"M/N-NTSC/PAL-EIAJ", 0x0040, 0x80A0, 4500},
214 {"M/N-NTSC/PAL-Mono", 0x0078, 0x80A0, 4500},
215 {"B/G-PAL-A2", 0x0000, 0x8159, 5640},
216 {"B/G-PAL-NICAM", 0x0004, 0x8159, 5740},
217 {"B/G-PAL-MONO", 0x0078, 0x8159, 5500},
218 {"I-PAL-NICAM", 0x0080, 0x8049, 6240},
219 {"I-PAL-NICAM-MONO", 0x0078, 0x8049, 6000},
220 {"D/K-PAL-A2", 0x0000, 0x8049, 6380},
221 {"D/K-PAL-NICAM", 0x0080, 0x8049, 6200},
222 {"D/K-PAL-MONO", 0x0078, 0x8049, 6500},
223 {"D/K-SECAM-A2 DK1", 0x0000, 0x8049, 6340},
224 {"D/K-SECAM-A2 L/DK3", 0x0000, 0x8049, 6000},
225 {"D/K-SECAM-A2 MONO", 0x0078, 0x8049, 6500},
226 {"D/K-SECAM-NICAM", 0x0080, 0x8049, 6200},
227 {"L-SECAM-NICAM", 0x8080, 0x0009, 6200},
228 {"L'-SECAM-NICAM", 0x8080, 0x4009, 6200},
229 {"DTV6", 0x00C0, 0x8002, 0},
230 {"DTV8", 0x00C0, 0x800B, 0},
231 {"DTV7/8", 0x00C0, 0x801B, 0},
232 {"DTV7", 0x00C0, 0x8007, 0},
233 {"FM Radio-INPUT2", 0x0008, 0x9800, 10700},
234 {"FM Radio-INPUT1", 0x0008, 0x9000, 10700}
235 };
236
237 static int xc4000_readreg(struct xc4000_priv *priv, u16 reg, u16 *val);
238 static int xc4000_tuner_reset(struct dvb_frontend *fe);
239 static void xc_debug_dump(struct xc4000_priv *priv);
240
xc_send_i2c_data(struct xc4000_priv * priv,u8 * buf,int len)241 static int xc_send_i2c_data(struct xc4000_priv *priv, u8 *buf, int len)
242 {
243 struct i2c_msg msg = { .addr = priv->i2c_props.addr,
244 .flags = 0, .buf = buf, .len = len };
245 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
246 if (priv->ignore_i2c_write_errors == 0) {
247 printk(KERN_ERR "xc4000: I2C write failed (len=%i)\n",
248 len);
249 if (len == 4) {
250 printk(KERN_ERR "bytes %*ph\n", 4, buf);
251 }
252 return -EREMOTEIO;
253 }
254 }
255 return 0;
256 }
257
xc4000_tuner_reset(struct dvb_frontend * fe)258 static int xc4000_tuner_reset(struct dvb_frontend *fe)
259 {
260 struct xc4000_priv *priv = fe->tuner_priv;
261 int ret;
262
263 dprintk(1, "%s()\n", __func__);
264
265 if (fe->callback) {
266 ret = fe->callback(((fe->dvb) && (fe->dvb->priv)) ?
267 fe->dvb->priv :
268 priv->i2c_props.adap->algo_data,
269 DVB_FRONTEND_COMPONENT_TUNER,
270 XC4000_TUNER_RESET, 0);
271 if (ret) {
272 printk(KERN_ERR "xc4000: reset failed\n");
273 return -EREMOTEIO;
274 }
275 } else {
276 printk(KERN_ERR "xc4000: no tuner reset callback function, fatal\n");
277 return -EINVAL;
278 }
279 return 0;
280 }
281
xc_write_reg(struct xc4000_priv * priv,u16 regAddr,u16 i2cData)282 static int xc_write_reg(struct xc4000_priv *priv, u16 regAddr, u16 i2cData)
283 {
284 u8 buf[4];
285
286 buf[0] = (regAddr >> 8) & 0xFF;
287 buf[1] = regAddr & 0xFF;
288 buf[2] = (i2cData >> 8) & 0xFF;
289 buf[3] = i2cData & 0xFF;
290
291 return xc_send_i2c_data(priv, buf, 4);
292 }
293
xc_load_i2c_sequence(struct dvb_frontend * fe,const u8 * i2c_sequence)294 static int xc_load_i2c_sequence(struct dvb_frontend *fe, const u8 *i2c_sequence)
295 {
296 struct xc4000_priv *priv = fe->tuner_priv;
297
298 int i, nbytes_to_send, result;
299 unsigned int len, pos, index;
300 u8 buf[XC_MAX_I2C_WRITE_LENGTH];
301
302 index = 0;
303 while ((i2c_sequence[index] != 0xFF) ||
304 (i2c_sequence[index + 1] != 0xFF)) {
305 len = i2c_sequence[index] * 256 + i2c_sequence[index+1];
306 if (len == 0x0000) {
307 /* RESET command */
308 /* NOTE: this is ignored, as the reset callback was */
309 /* already called by check_firmware() */
310 index += 2;
311 } else if (len & 0x8000) {
312 /* WAIT command */
313 msleep(len & 0x7FFF);
314 index += 2;
315 } else {
316 /* Send i2c data whilst ensuring individual transactions
317 * do not exceed XC_MAX_I2C_WRITE_LENGTH bytes.
318 */
319 index += 2;
320 buf[0] = i2c_sequence[index];
321 buf[1] = i2c_sequence[index + 1];
322 pos = 2;
323 while (pos < len) {
324 if ((len - pos) > XC_MAX_I2C_WRITE_LENGTH - 2)
325 nbytes_to_send =
326 XC_MAX_I2C_WRITE_LENGTH;
327 else
328 nbytes_to_send = (len - pos + 2);
329 for (i = 2; i < nbytes_to_send; i++) {
330 buf[i] = i2c_sequence[index + pos +
331 i - 2];
332 }
333 result = xc_send_i2c_data(priv, buf,
334 nbytes_to_send);
335
336 if (result != 0)
337 return result;
338
339 pos += nbytes_to_send - 2;
340 }
341 index += len;
342 }
343 }
344 return 0;
345 }
346
xc_set_tv_standard(struct xc4000_priv * priv,u16 video_mode,u16 audio_mode)347 static int xc_set_tv_standard(struct xc4000_priv *priv,
348 u16 video_mode, u16 audio_mode)
349 {
350 int ret;
351 dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, video_mode, audio_mode);
352 dprintk(1, "%s() Standard = %s\n",
353 __func__,
354 xc4000_standard[priv->video_standard].Name);
355
356 /* Don't complain when the request fails because of i2c stretching */
357 priv->ignore_i2c_write_errors = 1;
358
359 ret = xc_write_reg(priv, XREG_VIDEO_MODE, video_mode);
360 if (ret == 0)
361 ret = xc_write_reg(priv, XREG_AUDIO_MODE, audio_mode);
362
363 priv->ignore_i2c_write_errors = 0;
364
365 return ret;
366 }
367
xc_set_signal_source(struct xc4000_priv * priv,u16 rf_mode)368 static int xc_set_signal_source(struct xc4000_priv *priv, u16 rf_mode)
369 {
370 dprintk(1, "%s(%d) Source = %s\n", __func__, rf_mode,
371 rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE");
372
373 if ((rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE)) {
374 rf_mode = XC_RF_MODE_CABLE;
375 printk(KERN_ERR
376 "%s(), Invalid mode, defaulting to CABLE",
377 __func__);
378 }
379 return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode);
380 }
381
382 static const struct dvb_tuner_ops xc4000_tuner_ops;
383
xc_set_rf_frequency(struct xc4000_priv * priv,u32 freq_hz)384 static int xc_set_rf_frequency(struct xc4000_priv *priv, u32 freq_hz)
385 {
386 u16 freq_code;
387
388 dprintk(1, "%s(%u)\n", __func__, freq_hz);
389
390 if ((freq_hz > xc4000_tuner_ops.info.frequency_max_hz) ||
391 (freq_hz < xc4000_tuner_ops.info.frequency_min_hz))
392 return -EINVAL;
393
394 freq_code = (u16)(freq_hz / 15625);
395
396 /* WAS: Starting in firmware version 1.1.44, Xceive recommends using the
397 FINERFREQ for all normal tuning (the doc indicates reg 0x03 should
398 only be used for fast scanning for channel lock) */
399 /* WAS: XREG_FINERFREQ */
400 return xc_write_reg(priv, XREG_RF_FREQ, freq_code);
401 }
402
xc_get_adc_envelope(struct xc4000_priv * priv,u16 * adc_envelope)403 static int xc_get_adc_envelope(struct xc4000_priv *priv, u16 *adc_envelope)
404 {
405 return xc4000_readreg(priv, XREG_ADC_ENV, adc_envelope);
406 }
407
xc_get_frequency_error(struct xc4000_priv * priv,u32 * freq_error_hz)408 static int xc_get_frequency_error(struct xc4000_priv *priv, u32 *freq_error_hz)
409 {
410 int result;
411 u16 regData;
412 u32 tmp;
413
414 result = xc4000_readreg(priv, XREG_FREQ_ERROR, ®Data);
415 if (result != 0)
416 return result;
417
418 tmp = (u32)regData & 0xFFFFU;
419 tmp = (tmp < 0x8000U ? tmp : 0x10000U - tmp);
420 (*freq_error_hz) = tmp * 15625;
421 return result;
422 }
423
xc_get_lock_status(struct xc4000_priv * priv,u16 * lock_status)424 static int xc_get_lock_status(struct xc4000_priv *priv, u16 *lock_status)
425 {
426 return xc4000_readreg(priv, XREG_LOCK, lock_status);
427 }
428
xc_get_version(struct xc4000_priv * priv,u8 * hw_majorversion,u8 * hw_minorversion,u8 * fw_majorversion,u8 * fw_minorversion)429 static int xc_get_version(struct xc4000_priv *priv,
430 u8 *hw_majorversion, u8 *hw_minorversion,
431 u8 *fw_majorversion, u8 *fw_minorversion)
432 {
433 u16 data;
434 int result;
435
436 result = xc4000_readreg(priv, XREG_VERSION, &data);
437 if (result != 0)
438 return result;
439
440 (*hw_majorversion) = (data >> 12) & 0x0F;
441 (*hw_minorversion) = (data >> 8) & 0x0F;
442 (*fw_majorversion) = (data >> 4) & 0x0F;
443 (*fw_minorversion) = data & 0x0F;
444
445 return 0;
446 }
447
xc_get_hsync_freq(struct xc4000_priv * priv,u32 * hsync_freq_hz)448 static int xc_get_hsync_freq(struct xc4000_priv *priv, u32 *hsync_freq_hz)
449 {
450 u16 regData;
451 int result;
452
453 result = xc4000_readreg(priv, XREG_HSYNC_FREQ, ®Data);
454 if (result != 0)
455 return result;
456
457 (*hsync_freq_hz) = ((regData & 0x0fff) * 763)/100;
458 return result;
459 }
460
xc_get_frame_lines(struct xc4000_priv * priv,u16 * frame_lines)461 static int xc_get_frame_lines(struct xc4000_priv *priv, u16 *frame_lines)
462 {
463 return xc4000_readreg(priv, XREG_FRAME_LINES, frame_lines);
464 }
465
xc_get_quality(struct xc4000_priv * priv,u16 * quality)466 static int xc_get_quality(struct xc4000_priv *priv, u16 *quality)
467 {
468 return xc4000_readreg(priv, XREG_QUALITY, quality);
469 }
470
xc_get_signal_level(struct xc4000_priv * priv,u16 * signal)471 static int xc_get_signal_level(struct xc4000_priv *priv, u16 *signal)
472 {
473 return xc4000_readreg(priv, XREG_SIGNAL_LEVEL, signal);
474 }
475
xc_get_noise_level(struct xc4000_priv * priv,u16 * noise)476 static int xc_get_noise_level(struct xc4000_priv *priv, u16 *noise)
477 {
478 return xc4000_readreg(priv, XREG_NOISE_LEVEL, noise);
479 }
480
xc_wait_for_lock(struct xc4000_priv * priv)481 static u16 xc_wait_for_lock(struct xc4000_priv *priv)
482 {
483 u16 lock_state = 0;
484 int watchdog_count = 40;
485
486 while ((lock_state == 0) && (watchdog_count > 0)) {
487 xc_get_lock_status(priv, &lock_state);
488 if (lock_state != 1) {
489 msleep(5);
490 watchdog_count--;
491 }
492 }
493 return lock_state;
494 }
495
xc_tune_channel(struct xc4000_priv * priv,u32 freq_hz)496 static int xc_tune_channel(struct xc4000_priv *priv, u32 freq_hz)
497 {
498 int found = 1;
499 int result;
500
501 dprintk(1, "%s(%u)\n", __func__, freq_hz);
502
503 /* Don't complain when the request fails because of i2c stretching */
504 priv->ignore_i2c_write_errors = 1;
505 result = xc_set_rf_frequency(priv, freq_hz);
506 priv->ignore_i2c_write_errors = 0;
507
508 if (result != 0)
509 return 0;
510
511 /* wait for lock only in analog TV mode */
512 if ((priv->cur_fw.type & (FM | DTV6 | DTV7 | DTV78 | DTV8)) == 0) {
513 if (xc_wait_for_lock(priv) != 1)
514 found = 0;
515 }
516
517 /* Wait for stats to stabilize.
518 * Frame Lines needs two frame times after initial lock
519 * before it is valid.
520 */
521 msleep(debug ? 100 : 10);
522
523 if (debug)
524 xc_debug_dump(priv);
525
526 return found;
527 }
528
xc4000_readreg(struct xc4000_priv * priv,u16 reg,u16 * val)529 static int xc4000_readreg(struct xc4000_priv *priv, u16 reg, u16 *val)
530 {
531 u8 buf[2] = { reg >> 8, reg & 0xff };
532 u8 bval[2] = { 0, 0 };
533 struct i2c_msg msg[2] = {
534 { .addr = priv->i2c_props.addr,
535 .flags = 0, .buf = &buf[0], .len = 2 },
536 { .addr = priv->i2c_props.addr,
537 .flags = I2C_M_RD, .buf = &bval[0], .len = 2 },
538 };
539
540 if (i2c_transfer(priv->i2c_props.adap, msg, 2) != 2) {
541 printk(KERN_ERR "xc4000: I2C read failed\n");
542 return -EREMOTEIO;
543 }
544
545 *val = (bval[0] << 8) | bval[1];
546 return 0;
547 }
548
549 #define dump_firm_type(t) dump_firm_type_and_int_freq(t, 0)
dump_firm_type_and_int_freq(unsigned int type,u16 int_freq)550 static void dump_firm_type_and_int_freq(unsigned int type, u16 int_freq)
551 {
552 if (type & BASE)
553 printk(KERN_CONT "BASE ");
554 if (type & INIT1)
555 printk(KERN_CONT "INIT1 ");
556 if (type & F8MHZ)
557 printk(KERN_CONT "F8MHZ ");
558 if (type & MTS)
559 printk(KERN_CONT "MTS ");
560 if (type & D2620)
561 printk(KERN_CONT "D2620 ");
562 if (type & D2633)
563 printk(KERN_CONT "D2633 ");
564 if (type & DTV6)
565 printk(KERN_CONT "DTV6 ");
566 if (type & QAM)
567 printk(KERN_CONT "QAM ");
568 if (type & DTV7)
569 printk(KERN_CONT "DTV7 ");
570 if (type & DTV78)
571 printk(KERN_CONT "DTV78 ");
572 if (type & DTV8)
573 printk(KERN_CONT "DTV8 ");
574 if (type & FM)
575 printk(KERN_CONT "FM ");
576 if (type & INPUT1)
577 printk(KERN_CONT "INPUT1 ");
578 if (type & LCD)
579 printk(KERN_CONT "LCD ");
580 if (type & NOGD)
581 printk(KERN_CONT "NOGD ");
582 if (type & MONO)
583 printk(KERN_CONT "MONO ");
584 if (type & ATSC)
585 printk(KERN_CONT "ATSC ");
586 if (type & IF)
587 printk(KERN_CONT "IF ");
588 if (type & LG60)
589 printk(KERN_CONT "LG60 ");
590 if (type & ATI638)
591 printk(KERN_CONT "ATI638 ");
592 if (type & OREN538)
593 printk(KERN_CONT "OREN538 ");
594 if (type & OREN36)
595 printk(KERN_CONT "OREN36 ");
596 if (type & TOYOTA388)
597 printk(KERN_CONT "TOYOTA388 ");
598 if (type & TOYOTA794)
599 printk(KERN_CONT "TOYOTA794 ");
600 if (type & DIBCOM52)
601 printk(KERN_CONT "DIBCOM52 ");
602 if (type & ZARLINK456)
603 printk(KERN_CONT "ZARLINK456 ");
604 if (type & CHINA)
605 printk(KERN_CONT "CHINA ");
606 if (type & F6MHZ)
607 printk(KERN_CONT "F6MHZ ");
608 if (type & INPUT2)
609 printk(KERN_CONT "INPUT2 ");
610 if (type & SCODE)
611 printk(KERN_CONT "SCODE ");
612 if (type & HAS_IF)
613 printk(KERN_CONT "HAS_IF_%d ", int_freq);
614 }
615
seek_firmware(struct dvb_frontend * fe,unsigned int type,v4l2_std_id * id)616 static int seek_firmware(struct dvb_frontend *fe, unsigned int type,
617 v4l2_std_id *id)
618 {
619 struct xc4000_priv *priv = fe->tuner_priv;
620 int i, best_i = -1;
621 unsigned int best_nr_diffs = 255U;
622
623 if (!priv->firm) {
624 printk(KERN_ERR "Error! firmware not loaded\n");
625 return -EINVAL;
626 }
627
628 if (((type & ~SCODE) == 0) && (*id == 0))
629 *id = V4L2_STD_PAL;
630
631 /* Seek for generic video standard match */
632 for (i = 0; i < priv->firm_size; i++) {
633 v4l2_std_id id_diff_mask =
634 (priv->firm[i].id ^ (*id)) & (*id);
635 unsigned int type_diff_mask =
636 (priv->firm[i].type ^ type)
637 & (BASE_TYPES | DTV_TYPES | LCD | NOGD | MONO | SCODE);
638 unsigned int nr_diffs;
639
640 if (type_diff_mask
641 & (BASE | INIT1 | FM | DTV6 | DTV7 | DTV78 | DTV8 | SCODE))
642 continue;
643
644 nr_diffs = hweight64(id_diff_mask) + hweight32(type_diff_mask);
645 if (!nr_diffs) /* Supports all the requested standards */
646 goto found;
647
648 if (nr_diffs < best_nr_diffs) {
649 best_nr_diffs = nr_diffs;
650 best_i = i;
651 }
652 }
653
654 /* FIXME: Would make sense to seek for type "hint" match ? */
655 if (best_i < 0) {
656 i = -ENOENT;
657 goto ret;
658 }
659
660 if (best_nr_diffs > 0U) {
661 printk(KERN_WARNING
662 "Selecting best matching firmware (%u bits differ) for type=(%x), id %016llx:\n",
663 best_nr_diffs, type, (unsigned long long)*id);
664 i = best_i;
665 }
666
667 found:
668 *id = priv->firm[i].id;
669
670 ret:
671 if (debug) {
672 printk(KERN_DEBUG "%s firmware for type=",
673 (i < 0) ? "Can't find" : "Found");
674 dump_firm_type(type);
675 printk(KERN_DEBUG "(%x), id %016llx.\n", type, (unsigned long long)*id);
676 }
677 return i;
678 }
679
load_firmware(struct dvb_frontend * fe,unsigned int type,v4l2_std_id * id)680 static int load_firmware(struct dvb_frontend *fe, unsigned int type,
681 v4l2_std_id *id)
682 {
683 struct xc4000_priv *priv = fe->tuner_priv;
684 int pos, rc;
685 unsigned char *p;
686
687 pos = seek_firmware(fe, type, id);
688 if (pos < 0)
689 return pos;
690
691 p = priv->firm[pos].ptr;
692
693 /* Don't complain when the request fails because of i2c stretching */
694 priv->ignore_i2c_write_errors = 1;
695
696 rc = xc_load_i2c_sequence(fe, p);
697
698 priv->ignore_i2c_write_errors = 0;
699
700 return rc;
701 }
702
xc4000_fwupload(struct dvb_frontend * fe)703 static int xc4000_fwupload(struct dvb_frontend *fe)
704 {
705 struct xc4000_priv *priv = fe->tuner_priv;
706 const struct firmware *fw = NULL;
707 const unsigned char *p, *endp;
708 int rc = 0;
709 int n, n_array;
710 char name[33];
711 const char *fname;
712
713 if (firmware_name[0] != '\0') {
714 fname = firmware_name;
715
716 dprintk(1, "Reading custom firmware %s\n", fname);
717 rc = request_firmware(&fw, fname,
718 priv->i2c_props.adap->dev.parent);
719 } else {
720 fname = XC4000_DEFAULT_FIRMWARE_NEW;
721 dprintk(1, "Trying to read firmware %s\n", fname);
722 rc = request_firmware(&fw, fname,
723 priv->i2c_props.adap->dev.parent);
724 if (rc == -ENOENT) {
725 fname = XC4000_DEFAULT_FIRMWARE;
726 dprintk(1, "Trying to read firmware %s\n", fname);
727 rc = request_firmware(&fw, fname,
728 priv->i2c_props.adap->dev.parent);
729 }
730 }
731
732 if (rc < 0) {
733 if (rc == -ENOENT)
734 printk(KERN_ERR "Error: firmware %s not found.\n", fname);
735 else
736 printk(KERN_ERR "Error %d while requesting firmware %s\n",
737 rc, fname);
738
739 return rc;
740 }
741 dprintk(1, "Loading Firmware: %s\n", fname);
742
743 p = fw->data;
744 endp = p + fw->size;
745
746 if (fw->size < sizeof(name) - 1 + 2 + 2) {
747 printk(KERN_ERR "Error: firmware file %s has invalid size!\n",
748 fname);
749 goto corrupt;
750 }
751
752 memcpy(name, p, sizeof(name) - 1);
753 name[sizeof(name) - 1] = '\0';
754 p += sizeof(name) - 1;
755
756 priv->firm_version = get_unaligned_le16(p);
757 p += 2;
758
759 n_array = get_unaligned_le16(p);
760 p += 2;
761
762 dprintk(1, "Loading %d firmware images from %s, type: %s, ver %d.%d\n",
763 n_array, fname, name,
764 priv->firm_version >> 8, priv->firm_version & 0xff);
765
766 priv->firm = kcalloc(n_array, sizeof(*priv->firm), GFP_KERNEL);
767 if (priv->firm == NULL) {
768 printk(KERN_ERR "Not enough memory to load firmware file.\n");
769 rc = -ENOMEM;
770 goto done;
771 }
772 priv->firm_size = n_array;
773
774 n = -1;
775 while (p < endp) {
776 __u32 type, size;
777 v4l2_std_id id;
778 __u16 int_freq = 0;
779
780 n++;
781 if (n >= n_array) {
782 printk(KERN_ERR "More firmware images in file than were expected!\n");
783 goto corrupt;
784 }
785
786 /* Checks if there's enough bytes to read */
787 if (endp - p < sizeof(type) + sizeof(id) + sizeof(size))
788 goto header;
789
790 type = get_unaligned_le32(p);
791 p += sizeof(type);
792
793 id = get_unaligned_le64(p);
794 p += sizeof(id);
795
796 if (type & HAS_IF) {
797 int_freq = get_unaligned_le16(p);
798 p += sizeof(int_freq);
799 if (endp - p < sizeof(size))
800 goto header;
801 }
802
803 size = get_unaligned_le32(p);
804 p += sizeof(size);
805
806 if (!size || size > endp - p) {
807 printk(KERN_ERR "Firmware type (%x), id %llx is corrupted (size=%zd, expected %d)\n",
808 type, (unsigned long long)id,
809 endp - p, size);
810 goto corrupt;
811 }
812
813 priv->firm[n].ptr = kmemdup(p, size, GFP_KERNEL);
814 if (priv->firm[n].ptr == NULL) {
815 printk(KERN_ERR "Not enough memory to load firmware file.\n");
816 rc = -ENOMEM;
817 goto done;
818 }
819
820 if (debug) {
821 printk(KERN_DEBUG "Reading firmware type ");
822 dump_firm_type_and_int_freq(type, int_freq);
823 printk(KERN_DEBUG "(%x), id %llx, size=%d.\n",
824 type, (unsigned long long)id, size);
825 }
826
827 priv->firm[n].type = type;
828 priv->firm[n].id = id;
829 priv->firm[n].size = size;
830 priv->firm[n].int_freq = int_freq;
831
832 p += size;
833 }
834
835 if (n + 1 != priv->firm_size) {
836 printk(KERN_ERR "Firmware file is incomplete!\n");
837 goto corrupt;
838 }
839
840 goto done;
841
842 header:
843 printk(KERN_ERR "Firmware header is incomplete!\n");
844 corrupt:
845 rc = -EINVAL;
846 printk(KERN_ERR "Error: firmware file is corrupted!\n");
847
848 done:
849 release_firmware(fw);
850 if (rc == 0)
851 dprintk(1, "Firmware files loaded.\n");
852
853 return rc;
854 }
855
load_scode(struct dvb_frontend * fe,unsigned int type,v4l2_std_id * id,__u16 int_freq,int scode)856 static int load_scode(struct dvb_frontend *fe, unsigned int type,
857 v4l2_std_id *id, __u16 int_freq, int scode)
858 {
859 struct xc4000_priv *priv = fe->tuner_priv;
860 int pos, rc;
861 unsigned char *p;
862 u8 scode_buf[13];
863 u8 indirect_mode[5];
864
865 dprintk(1, "%s called int_freq=%d\n", __func__, int_freq);
866
867 if (!int_freq) {
868 pos = seek_firmware(fe, type, id);
869 if (pos < 0)
870 return pos;
871 } else {
872 for (pos = 0; pos < priv->firm_size; pos++) {
873 if ((priv->firm[pos].int_freq == int_freq) &&
874 (priv->firm[pos].type & HAS_IF))
875 break;
876 }
877 if (pos == priv->firm_size)
878 return -ENOENT;
879 }
880
881 p = priv->firm[pos].ptr;
882
883 if (priv->firm[pos].size != 12 * 16 || scode >= 16)
884 return -EINVAL;
885 p += 12 * scode;
886
887 if (debug) {
888 tuner_info("Loading SCODE for type=");
889 dump_firm_type_and_int_freq(priv->firm[pos].type,
890 priv->firm[pos].int_freq);
891 printk(KERN_CONT "(%x), id %016llx.\n", priv->firm[pos].type,
892 (unsigned long long)*id);
893 }
894
895 scode_buf[0] = 0x00;
896 memcpy(&scode_buf[1], p, 12);
897
898 /* Enter direct-mode */
899 rc = xc_write_reg(priv, XREG_DIRECTSITTING_MODE, 0);
900 if (rc < 0) {
901 printk(KERN_ERR "failed to put device into direct mode!\n");
902 return -EIO;
903 }
904
905 rc = xc_send_i2c_data(priv, scode_buf, 13);
906 if (rc != 0) {
907 /* Even if the send failed, make sure we set back to indirect
908 mode */
909 printk(KERN_ERR "Failed to set scode %d\n", rc);
910 }
911
912 /* Switch back to indirect-mode */
913 memset(indirect_mode, 0, sizeof(indirect_mode));
914 indirect_mode[4] = 0x88;
915 xc_send_i2c_data(priv, indirect_mode, sizeof(indirect_mode));
916 msleep(10);
917
918 return 0;
919 }
920
check_firmware(struct dvb_frontend * fe,unsigned int type,v4l2_std_id std,__u16 int_freq)921 static int check_firmware(struct dvb_frontend *fe, unsigned int type,
922 v4l2_std_id std, __u16 int_freq)
923 {
924 struct xc4000_priv *priv = fe->tuner_priv;
925 struct firmware_properties new_fw;
926 int rc = 0, is_retry = 0;
927 u16 hwmodel;
928 v4l2_std_id std0;
929 u8 hw_major = 0, hw_minor = 0, fw_major = 0, fw_minor = 0;
930
931 dprintk(1, "%s called\n", __func__);
932
933 if (!priv->firm) {
934 rc = xc4000_fwupload(fe);
935 if (rc < 0)
936 return rc;
937 }
938
939 retry:
940 new_fw.type = type;
941 new_fw.id = std;
942 new_fw.std_req = std;
943 new_fw.scode_table = SCODE;
944 new_fw.scode_nr = 0;
945 new_fw.int_freq = int_freq;
946
947 dprintk(1, "checking firmware, user requested type=");
948 if (debug) {
949 dump_firm_type(new_fw.type);
950 printk(KERN_CONT "(%x), id %016llx, ", new_fw.type,
951 (unsigned long long)new_fw.std_req);
952 if (!int_freq)
953 printk(KERN_CONT "scode_tbl ");
954 else
955 printk(KERN_CONT "int_freq %d, ", new_fw.int_freq);
956 printk(KERN_CONT "scode_nr %d\n", new_fw.scode_nr);
957 }
958
959 /* No need to reload base firmware if it matches */
960 if (priv->cur_fw.type & BASE) {
961 dprintk(1, "BASE firmware not changed.\n");
962 goto skip_base;
963 }
964
965 /* Updating BASE - forget about all currently loaded firmware */
966 memset(&priv->cur_fw, 0, sizeof(priv->cur_fw));
967
968 /* Reset is needed before loading firmware */
969 rc = xc4000_tuner_reset(fe);
970 if (rc < 0)
971 goto fail;
972
973 /* BASE firmwares are all std0 */
974 std0 = 0;
975 rc = load_firmware(fe, BASE, &std0);
976 if (rc < 0) {
977 printk(KERN_ERR "Error %d while loading base firmware\n", rc);
978 goto fail;
979 }
980
981 /* Load INIT1, if needed */
982 dprintk(1, "Load init1 firmware, if exists\n");
983
984 rc = load_firmware(fe, BASE | INIT1, &std0);
985 if (rc == -ENOENT)
986 rc = load_firmware(fe, BASE | INIT1, &std0);
987 if (rc < 0 && rc != -ENOENT) {
988 tuner_err("Error %d while loading init1 firmware\n",
989 rc);
990 goto fail;
991 }
992
993 skip_base:
994 /*
995 * No need to reload standard specific firmware if base firmware
996 * was not reloaded and requested video standards have not changed.
997 */
998 if (priv->cur_fw.type == (BASE | new_fw.type) &&
999 priv->cur_fw.std_req == std) {
1000 dprintk(1, "Std-specific firmware already loaded.\n");
1001 goto skip_std_specific;
1002 }
1003
1004 /* Reloading std-specific firmware forces a SCODE update */
1005 priv->cur_fw.scode_table = 0;
1006
1007 /* Load the standard firmware */
1008 rc = load_firmware(fe, new_fw.type, &new_fw.id);
1009
1010 if (rc < 0)
1011 goto fail;
1012
1013 skip_std_specific:
1014 if (priv->cur_fw.scode_table == new_fw.scode_table &&
1015 priv->cur_fw.scode_nr == new_fw.scode_nr) {
1016 dprintk(1, "SCODE firmware already loaded.\n");
1017 goto check_device;
1018 }
1019
1020 /* Load SCODE firmware, if exists */
1021 rc = load_scode(fe, new_fw.type | new_fw.scode_table, &new_fw.id,
1022 new_fw.int_freq, new_fw.scode_nr);
1023 if (rc != 0)
1024 dprintk(1, "load scode failed %d\n", rc);
1025
1026 check_device:
1027 if (xc4000_readreg(priv, XREG_PRODUCT_ID, &hwmodel) < 0) {
1028 printk(KERN_ERR "Unable to read tuner registers.\n");
1029 goto fail;
1030 }
1031
1032 if (xc_get_version(priv, &hw_major, &hw_minor, &fw_major,
1033 &fw_minor) != 0) {
1034 printk(KERN_ERR "Unable to read tuner registers.\n");
1035 goto fail;
1036 }
1037
1038 dprintk(1, "Device is Xceive %d version %d.%d, firmware version %d.%d\n",
1039 hwmodel, hw_major, hw_minor, fw_major, fw_minor);
1040
1041 /* Check firmware version against what we downloaded. */
1042 if (priv->firm_version != ((fw_major << 8) | fw_minor)) {
1043 printk(KERN_WARNING
1044 "Incorrect readback of firmware version %d.%d.\n",
1045 fw_major, fw_minor);
1046 goto fail;
1047 }
1048
1049 /* Check that the tuner hardware model remains consistent over time. */
1050 if (priv->hwmodel == 0 &&
1051 (hwmodel == XC_PRODUCT_ID_XC4000 ||
1052 hwmodel == XC_PRODUCT_ID_XC4100)) {
1053 priv->hwmodel = hwmodel;
1054 priv->hwvers = (hw_major << 8) | hw_minor;
1055 } else if (priv->hwmodel == 0 || priv->hwmodel != hwmodel ||
1056 priv->hwvers != ((hw_major << 8) | hw_minor)) {
1057 printk(KERN_WARNING
1058 "Read invalid device hardware information - tuner hung?\n");
1059 goto fail;
1060 }
1061
1062 priv->cur_fw = new_fw;
1063
1064 /*
1065 * By setting BASE in cur_fw.type only after successfully loading all
1066 * firmwares, we can:
1067 * 1. Identify that BASE firmware with type=0 has been loaded;
1068 * 2. Tell whether BASE firmware was just changed the next time through.
1069 */
1070 priv->cur_fw.type |= BASE;
1071
1072 return 0;
1073
1074 fail:
1075 memset(&priv->cur_fw, 0, sizeof(priv->cur_fw));
1076 if (!is_retry) {
1077 msleep(50);
1078 is_retry = 1;
1079 dprintk(1, "Retrying firmware load\n");
1080 goto retry;
1081 }
1082
1083 if (rc == -ENOENT)
1084 rc = -EINVAL;
1085 return rc;
1086 }
1087
xc_debug_dump(struct xc4000_priv * priv)1088 static void xc_debug_dump(struct xc4000_priv *priv)
1089 {
1090 u16 adc_envelope;
1091 u32 freq_error_hz = 0;
1092 u16 lock_status;
1093 u32 hsync_freq_hz = 0;
1094 u16 frame_lines;
1095 u16 quality;
1096 u16 signal = 0;
1097 u16 noise = 0;
1098 u8 hw_majorversion = 0, hw_minorversion = 0;
1099 u8 fw_majorversion = 0, fw_minorversion = 0;
1100
1101 xc_get_adc_envelope(priv, &adc_envelope);
1102 dprintk(1, "*** ADC envelope (0-1023) = %d\n", adc_envelope);
1103
1104 xc_get_frequency_error(priv, &freq_error_hz);
1105 dprintk(1, "*** Frequency error = %d Hz\n", freq_error_hz);
1106
1107 xc_get_lock_status(priv, &lock_status);
1108 dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %d\n",
1109 lock_status);
1110
1111 xc_get_version(priv, &hw_majorversion, &hw_minorversion,
1112 &fw_majorversion, &fw_minorversion);
1113 dprintk(1, "*** HW: V%02x.%02x, FW: V%02x.%02x\n",
1114 hw_majorversion, hw_minorversion,
1115 fw_majorversion, fw_minorversion);
1116
1117 if (priv->video_standard < XC4000_DTV6) {
1118 xc_get_hsync_freq(priv, &hsync_freq_hz);
1119 dprintk(1, "*** Horizontal sync frequency = %d Hz\n",
1120 hsync_freq_hz);
1121
1122 xc_get_frame_lines(priv, &frame_lines);
1123 dprintk(1, "*** Frame lines = %d\n", frame_lines);
1124 }
1125
1126 xc_get_quality(priv, &quality);
1127 dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %d\n", quality);
1128
1129 xc_get_signal_level(priv, &signal);
1130 dprintk(1, "*** Signal level = -%ddB (%d)\n", signal >> 8, signal);
1131
1132 xc_get_noise_level(priv, &noise);
1133 dprintk(1, "*** Noise level = %ddB (%d)\n", noise >> 8, noise);
1134 }
1135
xc4000_set_params(struct dvb_frontend * fe)1136 static int xc4000_set_params(struct dvb_frontend *fe)
1137 {
1138 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
1139 u32 delsys = c->delivery_system;
1140 u32 bw = c->bandwidth_hz;
1141 struct xc4000_priv *priv = fe->tuner_priv;
1142 unsigned int type;
1143 int ret = -EREMOTEIO;
1144
1145 dprintk(1, "%s() frequency=%d (Hz)\n", __func__, c->frequency);
1146
1147 mutex_lock(&priv->lock);
1148
1149 switch (delsys) {
1150 case SYS_ATSC:
1151 dprintk(1, "%s() VSB modulation\n", __func__);
1152 priv->rf_mode = XC_RF_MODE_AIR;
1153 priv->freq_offset = 1750000;
1154 priv->video_standard = XC4000_DTV6;
1155 type = DTV6;
1156 break;
1157 case SYS_DVBC_ANNEX_B:
1158 dprintk(1, "%s() QAM modulation\n", __func__);
1159 priv->rf_mode = XC_RF_MODE_CABLE;
1160 priv->freq_offset = 1750000;
1161 priv->video_standard = XC4000_DTV6;
1162 type = DTV6;
1163 break;
1164 case SYS_DVBT:
1165 case SYS_DVBT2:
1166 dprintk(1, "%s() OFDM\n", __func__);
1167 if (bw == 0) {
1168 if (c->frequency < 400000000) {
1169 priv->freq_offset = 2250000;
1170 } else {
1171 priv->freq_offset = 2750000;
1172 }
1173 priv->video_standard = XC4000_DTV7_8;
1174 type = DTV78;
1175 } else if (bw <= 6000000) {
1176 priv->video_standard = XC4000_DTV6;
1177 priv->freq_offset = 1750000;
1178 type = DTV6;
1179 } else if (bw <= 7000000) {
1180 priv->video_standard = XC4000_DTV7;
1181 priv->freq_offset = 2250000;
1182 type = DTV7;
1183 } else {
1184 priv->video_standard = XC4000_DTV8;
1185 priv->freq_offset = 2750000;
1186 type = DTV8;
1187 }
1188 priv->rf_mode = XC_RF_MODE_AIR;
1189 break;
1190 default:
1191 printk(KERN_ERR "xc4000 delivery system not supported!\n");
1192 ret = -EINVAL;
1193 goto fail;
1194 }
1195
1196 priv->freq_hz = c->frequency - priv->freq_offset;
1197
1198 dprintk(1, "%s() frequency=%d (compensated)\n",
1199 __func__, priv->freq_hz);
1200
1201 /* Make sure the correct firmware type is loaded */
1202 if (check_firmware(fe, type, 0, priv->if_khz) != 0)
1203 goto fail;
1204
1205 priv->bandwidth = c->bandwidth_hz;
1206
1207 ret = xc_set_signal_source(priv, priv->rf_mode);
1208 if (ret != 0) {
1209 printk(KERN_ERR "xc4000: xc_set_signal_source(%d) failed\n",
1210 priv->rf_mode);
1211 goto fail;
1212 } else {
1213 u16 video_mode, audio_mode;
1214 video_mode = xc4000_standard[priv->video_standard].video_mode;
1215 audio_mode = xc4000_standard[priv->video_standard].audio_mode;
1216 if (type == DTV6 && priv->firm_version != 0x0102)
1217 video_mode |= 0x0001;
1218 ret = xc_set_tv_standard(priv, video_mode, audio_mode);
1219 if (ret != 0) {
1220 printk(KERN_ERR "xc4000: xc_set_tv_standard failed\n");
1221 /* DJH - do not return when it fails... */
1222 /* goto fail; */
1223 }
1224 }
1225
1226 if (xc_write_reg(priv, XREG_D_CODE, 0) == 0)
1227 ret = 0;
1228 if (priv->dvb_amplitude != 0) {
1229 if (xc_write_reg(priv, XREG_AMPLITUDE,
1230 (priv->firm_version != 0x0102 ||
1231 priv->dvb_amplitude != 134 ?
1232 priv->dvb_amplitude : 132)) != 0)
1233 ret = -EREMOTEIO;
1234 }
1235 if (priv->set_smoothedcvbs != 0) {
1236 if (xc_write_reg(priv, XREG_SMOOTHEDCVBS, 1) != 0)
1237 ret = -EREMOTEIO;
1238 }
1239 if (ret != 0) {
1240 printk(KERN_ERR "xc4000: setting registers failed\n");
1241 /* goto fail; */
1242 }
1243
1244 xc_tune_channel(priv, priv->freq_hz);
1245
1246 ret = 0;
1247
1248 fail:
1249 mutex_unlock(&priv->lock);
1250
1251 return ret;
1252 }
1253
xc4000_set_analog_params(struct dvb_frontend * fe,struct analog_parameters * params)1254 static int xc4000_set_analog_params(struct dvb_frontend *fe,
1255 struct analog_parameters *params)
1256 {
1257 struct xc4000_priv *priv = fe->tuner_priv;
1258 unsigned int type = 0;
1259 int ret = -EREMOTEIO;
1260
1261 if (params->mode == V4L2_TUNER_RADIO) {
1262 dprintk(1, "%s() frequency=%d (in units of 62.5Hz)\n",
1263 __func__, params->frequency);
1264
1265 mutex_lock(&priv->lock);
1266
1267 params->std = 0;
1268 priv->freq_hz = params->frequency * 125L / 2;
1269
1270 if (audio_std & XC4000_AUDIO_STD_INPUT1) {
1271 priv->video_standard = XC4000_FM_Radio_INPUT1;
1272 type = FM | INPUT1;
1273 } else {
1274 priv->video_standard = XC4000_FM_Radio_INPUT2;
1275 type = FM | INPUT2;
1276 }
1277
1278 goto tune_channel;
1279 }
1280
1281 dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
1282 __func__, params->frequency);
1283
1284 mutex_lock(&priv->lock);
1285
1286 /* params->frequency is in units of 62.5khz */
1287 priv->freq_hz = params->frequency * 62500;
1288
1289 params->std &= V4L2_STD_ALL;
1290 /* if std is not defined, choose one */
1291 if (!params->std)
1292 params->std = V4L2_STD_PAL_BG;
1293
1294 if (audio_std & XC4000_AUDIO_STD_MONO)
1295 type = MONO;
1296
1297 if (params->std & V4L2_STD_MN) {
1298 params->std = V4L2_STD_MN;
1299 if (audio_std & XC4000_AUDIO_STD_MONO) {
1300 priv->video_standard = XC4000_MN_NTSC_PAL_Mono;
1301 } else if (audio_std & XC4000_AUDIO_STD_A2) {
1302 params->std |= V4L2_STD_A2;
1303 priv->video_standard = XC4000_MN_NTSC_PAL_A2;
1304 } else {
1305 params->std |= V4L2_STD_BTSC;
1306 priv->video_standard = XC4000_MN_NTSC_PAL_BTSC;
1307 }
1308 goto tune_channel;
1309 }
1310
1311 if (params->std & V4L2_STD_PAL_BG) {
1312 params->std = V4L2_STD_PAL_BG;
1313 if (audio_std & XC4000_AUDIO_STD_MONO) {
1314 priv->video_standard = XC4000_BG_PAL_MONO;
1315 } else if (!(audio_std & XC4000_AUDIO_STD_A2)) {
1316 if (!(audio_std & XC4000_AUDIO_STD_B)) {
1317 params->std |= V4L2_STD_NICAM_A;
1318 priv->video_standard = XC4000_BG_PAL_NICAM;
1319 } else {
1320 params->std |= V4L2_STD_NICAM_B;
1321 priv->video_standard = XC4000_BG_PAL_NICAM;
1322 }
1323 } else {
1324 if (!(audio_std & XC4000_AUDIO_STD_B)) {
1325 params->std |= V4L2_STD_A2_A;
1326 priv->video_standard = XC4000_BG_PAL_A2;
1327 } else {
1328 params->std |= V4L2_STD_A2_B;
1329 priv->video_standard = XC4000_BG_PAL_A2;
1330 }
1331 }
1332 goto tune_channel;
1333 }
1334
1335 if (params->std & V4L2_STD_PAL_I) {
1336 /* default to NICAM audio standard */
1337 params->std = V4L2_STD_PAL_I | V4L2_STD_NICAM;
1338 if (audio_std & XC4000_AUDIO_STD_MONO)
1339 priv->video_standard = XC4000_I_PAL_NICAM_MONO;
1340 else
1341 priv->video_standard = XC4000_I_PAL_NICAM;
1342 goto tune_channel;
1343 }
1344
1345 if (params->std & V4L2_STD_PAL_DK) {
1346 params->std = V4L2_STD_PAL_DK;
1347 if (audio_std & XC4000_AUDIO_STD_MONO) {
1348 priv->video_standard = XC4000_DK_PAL_MONO;
1349 } else if (audio_std & XC4000_AUDIO_STD_A2) {
1350 params->std |= V4L2_STD_A2;
1351 priv->video_standard = XC4000_DK_PAL_A2;
1352 } else {
1353 params->std |= V4L2_STD_NICAM;
1354 priv->video_standard = XC4000_DK_PAL_NICAM;
1355 }
1356 goto tune_channel;
1357 }
1358
1359 if (params->std & V4L2_STD_SECAM_DK) {
1360 /* default to A2 audio standard */
1361 params->std = V4L2_STD_SECAM_DK | V4L2_STD_A2;
1362 if (audio_std & XC4000_AUDIO_STD_L) {
1363 type = 0;
1364 priv->video_standard = XC4000_DK_SECAM_NICAM;
1365 } else if (audio_std & XC4000_AUDIO_STD_MONO) {
1366 priv->video_standard = XC4000_DK_SECAM_A2MONO;
1367 } else if (audio_std & XC4000_AUDIO_STD_K3) {
1368 params->std |= V4L2_STD_SECAM_K3;
1369 priv->video_standard = XC4000_DK_SECAM_A2LDK3;
1370 } else {
1371 priv->video_standard = XC4000_DK_SECAM_A2DK1;
1372 }
1373 goto tune_channel;
1374 }
1375
1376 if (params->std & V4L2_STD_SECAM_L) {
1377 /* default to NICAM audio standard */
1378 type = 0;
1379 params->std = V4L2_STD_SECAM_L | V4L2_STD_NICAM;
1380 priv->video_standard = XC4000_L_SECAM_NICAM;
1381 goto tune_channel;
1382 }
1383
1384 if (params->std & V4L2_STD_SECAM_LC) {
1385 /* default to NICAM audio standard */
1386 type = 0;
1387 params->std = V4L2_STD_SECAM_LC | V4L2_STD_NICAM;
1388 priv->video_standard = XC4000_LC_SECAM_NICAM;
1389 goto tune_channel;
1390 }
1391
1392 tune_channel:
1393 /* FIXME: it could be air. */
1394 priv->rf_mode = XC_RF_MODE_CABLE;
1395
1396 if (check_firmware(fe, type, params->std,
1397 xc4000_standard[priv->video_standard].int_freq) != 0)
1398 goto fail;
1399
1400 ret = xc_set_signal_source(priv, priv->rf_mode);
1401 if (ret != 0) {
1402 printk(KERN_ERR
1403 "xc4000: xc_set_signal_source(%d) failed\n",
1404 priv->rf_mode);
1405 goto fail;
1406 } else {
1407 u16 video_mode, audio_mode;
1408 video_mode = xc4000_standard[priv->video_standard].video_mode;
1409 audio_mode = xc4000_standard[priv->video_standard].audio_mode;
1410 if (priv->video_standard < XC4000_BG_PAL_A2) {
1411 if (type & NOGD)
1412 video_mode &= 0xFF7F;
1413 } else if (priv->video_standard < XC4000_I_PAL_NICAM) {
1414 if (priv->firm_version == 0x0102)
1415 video_mode &= 0xFEFF;
1416 if (audio_std & XC4000_AUDIO_STD_B)
1417 video_mode |= 0x0080;
1418 }
1419 ret = xc_set_tv_standard(priv, video_mode, audio_mode);
1420 if (ret != 0) {
1421 printk(KERN_ERR "xc4000: xc_set_tv_standard failed\n");
1422 goto fail;
1423 }
1424 }
1425
1426 if (xc_write_reg(priv, XREG_D_CODE, 0) == 0)
1427 ret = 0;
1428 if (xc_write_reg(priv, XREG_AMPLITUDE, 1) != 0)
1429 ret = -EREMOTEIO;
1430 if (priv->set_smoothedcvbs != 0) {
1431 if (xc_write_reg(priv, XREG_SMOOTHEDCVBS, 1) != 0)
1432 ret = -EREMOTEIO;
1433 }
1434 if (ret != 0) {
1435 printk(KERN_ERR "xc4000: setting registers failed\n");
1436 goto fail;
1437 }
1438
1439 xc_tune_channel(priv, priv->freq_hz);
1440
1441 ret = 0;
1442
1443 fail:
1444 mutex_unlock(&priv->lock);
1445
1446 return ret;
1447 }
1448
xc4000_get_signal(struct dvb_frontend * fe,u16 * strength)1449 static int xc4000_get_signal(struct dvb_frontend *fe, u16 *strength)
1450 {
1451 struct xc4000_priv *priv = fe->tuner_priv;
1452 u16 value = 0;
1453 int rc;
1454
1455 mutex_lock(&priv->lock);
1456 rc = xc4000_readreg(priv, XREG_SIGNAL_LEVEL, &value);
1457 mutex_unlock(&priv->lock);
1458
1459 if (rc < 0)
1460 goto ret;
1461
1462 /* Information from real testing of DVB-T and radio part,
1463 coefficient for one dB is 0xff.
1464 */
1465 tuner_dbg("Signal strength: -%ddB (%05d)\n", value >> 8, value);
1466
1467 /* all known digital modes */
1468 if ((priv->video_standard == XC4000_DTV6) ||
1469 (priv->video_standard == XC4000_DTV7) ||
1470 (priv->video_standard == XC4000_DTV7_8) ||
1471 (priv->video_standard == XC4000_DTV8))
1472 goto digital;
1473
1474 /* Analog mode has NOISE LEVEL important, signal
1475 depends only on gain of antenna and amplifiers,
1476 but it doesn't tell anything about real quality
1477 of reception.
1478 */
1479 mutex_lock(&priv->lock);
1480 rc = xc4000_readreg(priv, XREG_NOISE_LEVEL, &value);
1481 mutex_unlock(&priv->lock);
1482
1483 tuner_dbg("Noise level: %ddB (%05d)\n", value >> 8, value);
1484
1485 /* highest noise level: 32dB */
1486 if (value >= 0x2000) {
1487 value = 0;
1488 } else {
1489 value = (~value << 3) & 0xffff;
1490 }
1491
1492 goto ret;
1493
1494 /* Digital mode has SIGNAL LEVEL important and real
1495 noise level is stored in demodulator registers.
1496 */
1497 digital:
1498 /* best signal: -50dB */
1499 if (value <= 0x3200) {
1500 value = 0xffff;
1501 /* minimum: -114dB - should be 0x7200 but real zero is 0x713A */
1502 } else if (value >= 0x713A) {
1503 value = 0;
1504 } else {
1505 value = ~(value - 0x3200) << 2;
1506 }
1507
1508 ret:
1509 *strength = value;
1510
1511 return rc;
1512 }
1513
xc4000_get_frequency(struct dvb_frontend * fe,u32 * freq)1514 static int xc4000_get_frequency(struct dvb_frontend *fe, u32 *freq)
1515 {
1516 struct xc4000_priv *priv = fe->tuner_priv;
1517
1518 mutex_lock(&priv->lock);
1519 *freq = priv->freq_hz + priv->freq_offset;
1520
1521 if (debug) {
1522 if ((priv->cur_fw.type
1523 & (BASE | FM | DTV6 | DTV7 | DTV78 | DTV8)) == BASE) {
1524 u16 snr = 0;
1525 if (xc4000_readreg(priv, XREG_SNR, &snr) == 0) {
1526 mutex_unlock(&priv->lock);
1527 dprintk(1, "%s() freq = %u, SNR = %d\n",
1528 __func__, *freq, snr);
1529 return 0;
1530 }
1531 }
1532 }
1533 mutex_unlock(&priv->lock);
1534
1535 dprintk(1, "%s()\n", __func__);
1536
1537 return 0;
1538 }
1539
xc4000_get_bandwidth(struct dvb_frontend * fe,u32 * bw)1540 static int xc4000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
1541 {
1542 struct xc4000_priv *priv = fe->tuner_priv;
1543 dprintk(1, "%s()\n", __func__);
1544
1545 *bw = priv->bandwidth;
1546 return 0;
1547 }
1548
xc4000_get_status(struct dvb_frontend * fe,u32 * status)1549 static int xc4000_get_status(struct dvb_frontend *fe, u32 *status)
1550 {
1551 struct xc4000_priv *priv = fe->tuner_priv;
1552 u16 lock_status = 0;
1553
1554 mutex_lock(&priv->lock);
1555
1556 if (priv->cur_fw.type & BASE)
1557 xc_get_lock_status(priv, &lock_status);
1558
1559 *status = (lock_status == 1 ?
1560 TUNER_STATUS_LOCKED | TUNER_STATUS_STEREO : 0);
1561 if (priv->cur_fw.type & (DTV6 | DTV7 | DTV78 | DTV8))
1562 *status &= (~TUNER_STATUS_STEREO);
1563
1564 mutex_unlock(&priv->lock);
1565
1566 dprintk(2, "%s() lock_status = %d\n", __func__, lock_status);
1567
1568 return 0;
1569 }
1570
xc4000_sleep(struct dvb_frontend * fe)1571 static int xc4000_sleep(struct dvb_frontend *fe)
1572 {
1573 struct xc4000_priv *priv = fe->tuner_priv;
1574 int ret = 0;
1575
1576 dprintk(1, "%s()\n", __func__);
1577
1578 mutex_lock(&priv->lock);
1579
1580 /* Avoid firmware reload on slow devices */
1581 if ((no_poweroff == 2 ||
1582 (no_poweroff == 0 && priv->default_pm != 0)) &&
1583 (priv->cur_fw.type & BASE) != 0) {
1584 /* force reset and firmware reload */
1585 priv->cur_fw.type = XC_POWERED_DOWN;
1586
1587 if (xc_write_reg(priv, XREG_POWER_DOWN, 0) != 0) {
1588 printk(KERN_ERR
1589 "xc4000: %s() unable to shutdown tuner\n",
1590 __func__);
1591 ret = -EREMOTEIO;
1592 }
1593 msleep(20);
1594 }
1595
1596 mutex_unlock(&priv->lock);
1597
1598 return ret;
1599 }
1600
xc4000_init(struct dvb_frontend * fe)1601 static int xc4000_init(struct dvb_frontend *fe)
1602 {
1603 dprintk(1, "%s()\n", __func__);
1604
1605 return 0;
1606 }
1607
xc4000_release(struct dvb_frontend * fe)1608 static void xc4000_release(struct dvb_frontend *fe)
1609 {
1610 struct xc4000_priv *priv = fe->tuner_priv;
1611
1612 dprintk(1, "%s()\n", __func__);
1613
1614 mutex_lock(&xc4000_list_mutex);
1615
1616 if (priv)
1617 hybrid_tuner_release_state(priv);
1618
1619 mutex_unlock(&xc4000_list_mutex);
1620
1621 fe->tuner_priv = NULL;
1622 }
1623
1624 static const struct dvb_tuner_ops xc4000_tuner_ops = {
1625 .info = {
1626 .name = "Xceive XC4000",
1627 .frequency_min_hz = 1 * MHz,
1628 .frequency_max_hz = 1023 * MHz,
1629 .frequency_step_hz = 50 * kHz,
1630 },
1631
1632 .release = xc4000_release,
1633 .init = xc4000_init,
1634 .sleep = xc4000_sleep,
1635
1636 .set_params = xc4000_set_params,
1637 .set_analog_params = xc4000_set_analog_params,
1638 .get_frequency = xc4000_get_frequency,
1639 .get_rf_strength = xc4000_get_signal,
1640 .get_bandwidth = xc4000_get_bandwidth,
1641 .get_status = xc4000_get_status
1642 };
1643
xc4000_attach(struct dvb_frontend * fe,struct i2c_adapter * i2c,struct xc4000_config * cfg)1644 struct dvb_frontend *xc4000_attach(struct dvb_frontend *fe,
1645 struct i2c_adapter *i2c,
1646 struct xc4000_config *cfg)
1647 {
1648 struct xc4000_priv *priv = NULL;
1649 int instance;
1650 u16 id = 0;
1651
1652 dprintk(1, "%s(%d-%04x)\n", __func__,
1653 i2c ? i2c_adapter_id(i2c) : -1,
1654 cfg ? cfg->i2c_address : -1);
1655
1656 mutex_lock(&xc4000_list_mutex);
1657
1658 instance = hybrid_tuner_request_state(struct xc4000_priv, priv,
1659 hybrid_tuner_instance_list,
1660 i2c, cfg->i2c_address, "xc4000");
1661 switch (instance) {
1662 case 0:
1663 goto fail;
1664 case 1:
1665 /* new tuner instance */
1666 priv->bandwidth = 6000000;
1667 /* set default configuration */
1668 priv->if_khz = 4560;
1669 priv->default_pm = 0;
1670 priv->dvb_amplitude = 134;
1671 priv->set_smoothedcvbs = 1;
1672 mutex_init(&priv->lock);
1673 fe->tuner_priv = priv;
1674 break;
1675 default:
1676 /* existing tuner instance */
1677 fe->tuner_priv = priv;
1678 break;
1679 }
1680
1681 if (cfg->if_khz != 0) {
1682 /* copy configuration if provided by the caller */
1683 priv->if_khz = cfg->if_khz;
1684 priv->default_pm = cfg->default_pm;
1685 priv->dvb_amplitude = cfg->dvb_amplitude;
1686 priv->set_smoothedcvbs = cfg->set_smoothedcvbs;
1687 }
1688
1689 /* Check if firmware has been loaded. It is possible that another
1690 instance of the driver has loaded the firmware.
1691 */
1692
1693 if (instance == 1) {
1694 if (xc4000_readreg(priv, XREG_PRODUCT_ID, &id) != 0)
1695 goto fail;
1696 } else {
1697 id = ((priv->cur_fw.type & BASE) != 0 ?
1698 priv->hwmodel : XC_PRODUCT_ID_FW_NOT_LOADED);
1699 }
1700
1701 switch (id) {
1702 case XC_PRODUCT_ID_XC4000:
1703 case XC_PRODUCT_ID_XC4100:
1704 printk(KERN_INFO
1705 "xc4000: Successfully identified at address 0x%02x\n",
1706 cfg->i2c_address);
1707 printk(KERN_INFO
1708 "xc4000: Firmware has been loaded previously\n");
1709 break;
1710 case XC_PRODUCT_ID_FW_NOT_LOADED:
1711 printk(KERN_INFO
1712 "xc4000: Successfully identified at address 0x%02x\n",
1713 cfg->i2c_address);
1714 printk(KERN_INFO
1715 "xc4000: Firmware has not been loaded previously\n");
1716 break;
1717 default:
1718 printk(KERN_ERR
1719 "xc4000: Device not found at addr 0x%02x (0x%x)\n",
1720 cfg->i2c_address, id);
1721 goto fail;
1722 }
1723
1724 mutex_unlock(&xc4000_list_mutex);
1725
1726 memcpy(&fe->ops.tuner_ops, &xc4000_tuner_ops,
1727 sizeof(struct dvb_tuner_ops));
1728
1729 if (instance == 1) {
1730 int ret;
1731 mutex_lock(&priv->lock);
1732 ret = xc4000_fwupload(fe);
1733 mutex_unlock(&priv->lock);
1734 if (ret != 0)
1735 goto fail2;
1736 }
1737
1738 return fe;
1739 fail:
1740 mutex_unlock(&xc4000_list_mutex);
1741 fail2:
1742 xc4000_release(fe);
1743 return NULL;
1744 }
1745 EXPORT_SYMBOL_GPL(xc4000_attach);
1746
1747 MODULE_AUTHOR("Steven Toth, Davide Ferri");
1748 MODULE_DESCRIPTION("Xceive xc4000 silicon tuner driver");
1749 MODULE_LICENSE("GPL");
1750 MODULE_FIRMWARE(XC4000_DEFAULT_FIRMWARE_NEW);
1751 MODULE_FIRMWARE(XC4000_DEFAULT_FIRMWARE);
1752