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