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