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