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