xref: /linux/drivers/media/tuners/xc5000.c (revision 6fd600d742744dc7ef7fc65ca26daa2b1163158a)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *  Driver for Xceive XC5000 "QAM/8VSB single chip tuner"
4  *
5  *  Copyright (c) 2007 Xceive Corporation
6  *  Copyright (c) 2007 Steven Toth <stoth@linuxtv.org>
7  *  Copyright (c) 2009 Devin Heitmueller <dheitmueller@kernellabs.com>
8  */
9 
10 #include <linux/module.h>
11 #include <linux/moduleparam.h>
12 #include <linux/videodev2.h>
13 #include <linux/delay.h>
14 #include <linux/workqueue.h>
15 #include <linux/dvb/frontend.h>
16 #include <linux/i2c.h>
17 
18 #include <media/dvb_frontend.h>
19 
20 #include "xc5000.h"
21 #include "tuner-i2c.h"
22 
23 static int debug;
24 module_param(debug, int, 0644);
25 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
26 
27 static int no_poweroff;
28 module_param(no_poweroff, int, 0644);
29 MODULE_PARM_DESC(no_poweroff, "0 (default) powers device off when not used.\n"
30 	"\t\t1 keep device energized and with tuner ready all the times.\n"
31 	"\t\tFaster, but consumes more power and keeps the device hotter");
32 
33 static DEFINE_MUTEX(xc5000_list_mutex);
34 static LIST_HEAD(hybrid_tuner_instance_list);
35 
36 #define dprintk(level, fmt, arg...) if (debug >= level) \
37 	printk(KERN_INFO "%s: " fmt, "xc5000", ## arg)
38 
39 struct xc5000_priv {
40 	struct tuner_i2c_props i2c_props;
41 	struct list_head hybrid_tuner_instance_list;
42 
43 	u32 if_khz;
44 	u16 xtal_khz;
45 	u32 freq_hz, freq_offset;
46 	u32 bandwidth;
47 	u8  video_standard;
48 	unsigned int mode;
49 	u8  rf_mode;
50 	u8  radio_input;
51 	u16  output_amp;
52 
53 	int chip_id;
54 	u16 pll_register_no;
55 	u8 init_status_supported;
56 	u8 fw_checksum_supported;
57 
58 	struct dvb_frontend *fe;
59 	struct delayed_work timer_sleep;
60 
61 	bool inited;
62 };
63 
64 /* Misc Defines */
65 #define MAX_TV_STANDARD			24
66 #define XC_MAX_I2C_WRITE_LENGTH		64
67 
68 /* Time to suspend after the .sleep callback is called */
69 #define XC5000_SLEEP_TIME		5000 /* ms */
70 
71 /* Signal Types */
72 #define XC_RF_MODE_AIR			0
73 #define XC_RF_MODE_CABLE		1
74 
75 /* Product id */
76 #define XC_PRODUCT_ID_FW_NOT_LOADED	0x2000
77 #define XC_PRODUCT_ID_FW_LOADED	0x1388
78 
79 /* Registers */
80 #define XREG_INIT         0x00
81 #define XREG_VIDEO_MODE   0x01
82 #define XREG_AUDIO_MODE   0x02
83 #define XREG_RF_FREQ      0x03
84 #define XREG_D_CODE       0x04
85 #define XREG_IF_OUT       0x05
86 #define XREG_SEEK_MODE    0x07
87 #define XREG_POWER_DOWN   0x0A /* Obsolete */
88 /* Set the output amplitude - SIF for analog, DTVP/DTVN for digital */
89 #define XREG_OUTPUT_AMP   0x0B
90 #define XREG_SIGNALSOURCE 0x0D /* 0=Air, 1=Cable */
91 #define XREG_SMOOTHEDCVBS 0x0E
92 #define XREG_XTALFREQ     0x0F
93 #define XREG_FINERFREQ    0x10
94 #define XREG_DDIMODE      0x11
95 
96 #define XREG_ADC_ENV      0x00
97 #define XREG_QUALITY      0x01
98 #define XREG_FRAME_LINES  0x02
99 #define XREG_HSYNC_FREQ   0x03
100 #define XREG_LOCK         0x04
101 #define XREG_FREQ_ERROR   0x05
102 #define XREG_SNR          0x06
103 #define XREG_VERSION      0x07
104 #define XREG_PRODUCT_ID   0x08
105 #define XREG_BUSY         0x09
106 #define XREG_BUILD        0x0D
107 #define XREG_TOTALGAIN    0x0F
108 #define XREG_FW_CHECKSUM  0x12
109 #define XREG_INIT_STATUS  0x13
110 
111 /*
112    Basic firmware description. This will remain with
113    the driver for documentation purposes.
114 
115    This represents an I2C firmware file encoded as a
116    string of unsigned char. Format is as follows:
117 
118    char[0  ]=len0_MSB  -> len = len_MSB * 256 + len_LSB
119    char[1  ]=len0_LSB  -> length of first write transaction
120    char[2  ]=data0 -> first byte to be sent
121    char[3  ]=data1
122    char[4  ]=data2
123    char[   ]=...
124    char[M  ]=dataN  -> last byte to be sent
125    char[M+1]=len1_MSB  -> len = len_MSB * 256 + len_LSB
126    char[M+2]=len1_LSB  -> length of second write transaction
127    char[M+3]=data0
128    char[M+4]=data1
129    ...
130    etc.
131 
132    The [len] value should be interpreted as follows:
133 
134    len= len_MSB _ len_LSB
135    len=1111_1111_1111_1111   : End of I2C_SEQUENCE
136    len=0000_0000_0000_0000   : Reset command: Do hardware reset
137    len=0NNN_NNNN_NNNN_NNNN   : Normal transaction: number of bytes = {1:32767)
138    len=1WWW_WWWW_WWWW_WWWW   : Wait command: wait for {1:32767} ms
139 
140    For the RESET and WAIT commands, the two following bytes will contain
141    immediately the length of the following transaction.
142 
143 */
144 struct XC_TV_STANDARD {
145 	char *name;
146 	u16 audio_mode;
147 	u16 video_mode;
148 };
149 
150 /* Tuner standards */
151 #define MN_NTSC_PAL_BTSC	0
152 #define MN_NTSC_PAL_A2		1
153 #define MN_NTSC_PAL_EIAJ	2
154 #define MN_NTSC_PAL_MONO	3
155 #define BG_PAL_A2		4
156 #define BG_PAL_NICAM		5
157 #define BG_PAL_MONO		6
158 #define I_PAL_NICAM		7
159 #define I_PAL_NICAM_MONO	8
160 #define DK_PAL_A2		9
161 #define DK_PAL_NICAM		10
162 #define DK_PAL_MONO		11
163 #define DK_SECAM_A2DK1		12
164 #define DK_SECAM_A2LDK3		13
165 #define DK_SECAM_A2MONO		14
166 #define L_SECAM_NICAM		15
167 #define LC_SECAM_NICAM		16
168 #define DTV6			17
169 #define DTV8			18
170 #define DTV7_8			19
171 #define DTV7			20
172 #define FM_RADIO_INPUT2		21
173 #define FM_RADIO_INPUT1		22
174 #define FM_RADIO_INPUT1_MONO	23
175 
176 static struct XC_TV_STANDARD xc5000_standard[MAX_TV_STANDARD] = {
177 	{"M/N-NTSC/PAL-BTSC", 0x0400, 0x8020},
178 	{"M/N-NTSC/PAL-A2",   0x0600, 0x8020},
179 	{"M/N-NTSC/PAL-EIAJ", 0x0440, 0x8020},
180 	{"M/N-NTSC/PAL-Mono", 0x0478, 0x8020},
181 	{"B/G-PAL-A2",        0x0A00, 0x8049},
182 	{"B/G-PAL-NICAM",     0x0C04, 0x8049},
183 	{"B/G-PAL-MONO",      0x0878, 0x8059},
184 	{"I-PAL-NICAM",       0x1080, 0x8009},
185 	{"I-PAL-NICAM-MONO",  0x0E78, 0x8009},
186 	{"D/K-PAL-A2",        0x1600, 0x8009},
187 	{"D/K-PAL-NICAM",     0x0E80, 0x8009},
188 	{"D/K-PAL-MONO",      0x1478, 0x8009},
189 	{"D/K-SECAM-A2 DK1",  0x1200, 0x8009},
190 	{"D/K-SECAM-A2 L/DK3", 0x0E00, 0x8009},
191 	{"D/K-SECAM-A2 MONO", 0x1478, 0x8009},
192 	{"L-SECAM-NICAM",     0x8E82, 0x0009},
193 	{"L'-SECAM-NICAM",    0x8E82, 0x4009},
194 	{"DTV6",              0x00C0, 0x8002},
195 	{"DTV8",              0x00C0, 0x800B},
196 	{"DTV7/8",            0x00C0, 0x801B},
197 	{"DTV7",              0x00C0, 0x8007},
198 	{"FM Radio-INPUT2",   0x9802, 0x9002},
199 	{"FM Radio-INPUT1",   0x0208, 0x9002},
200 	{"FM Radio-INPUT1_MONO", 0x0278, 0x9002}
201 };
202 
203 
204 struct xc5000_fw_cfg {
205 	char *name;
206 	u16 size;
207 	u16 pll_reg;
208 	u8 init_status_supported;
209 	u8 fw_checksum_supported;
210 };
211 
212 #define XC5000A_FIRMWARE "dvb-fe-xc5000-1.6.114.fw"
213 static const struct xc5000_fw_cfg xc5000a_1_6_114 = {
214 	.name = XC5000A_FIRMWARE,
215 	.size = 12401,
216 	.pll_reg = 0x806c,
217 };
218 
219 #define XC5000C_FIRMWARE "dvb-fe-xc5000c-4.1.30.7.fw"
220 static const struct xc5000_fw_cfg xc5000c_41_024_5 = {
221 	.name = XC5000C_FIRMWARE,
222 	.size = 16497,
223 	.pll_reg = 0x13,
224 	.init_status_supported = 1,
225 	.fw_checksum_supported = 1,
226 };
227 
xc5000_assign_firmware(int chip_id)228 static inline const struct xc5000_fw_cfg *xc5000_assign_firmware(int chip_id)
229 {
230 	switch (chip_id) {
231 	default:
232 	case XC5000A:
233 		return &xc5000a_1_6_114;
234 	case XC5000C:
235 		return &xc5000c_41_024_5;
236 	}
237 }
238 
239 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe, int force);
240 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe);
241 static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val);
242 static int xc5000_tuner_reset(struct dvb_frontend *fe);
243 
xc_send_i2c_data(struct xc5000_priv * priv,u8 * buf,int len)244 static int xc_send_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
245 {
246 	struct i2c_msg msg = { .addr = priv->i2c_props.addr,
247 			       .flags = 0, .buf = buf, .len = len };
248 
249 	if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
250 		printk(KERN_ERR "xc5000: I2C write failed (len=%i)\n", len);
251 		return -EREMOTEIO;
252 	}
253 	return 0;
254 }
255 
256 #if 0
257 /* This routine is never used because the only time we read data from the
258    i2c bus is when we read registers, and we want that to be an atomic i2c
259    transaction in case we are on a multi-master bus */
260 static int xc_read_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
261 {
262 	struct i2c_msg msg = { .addr = priv->i2c_props.addr,
263 		.flags = I2C_M_RD, .buf = buf, .len = len };
264 
265 	if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
266 		printk(KERN_ERR "xc5000 I2C read failed (len=%i)\n", len);
267 		return -EREMOTEIO;
268 	}
269 	return 0;
270 }
271 #endif
272 
xc5000_readreg(struct xc5000_priv * priv,u16 reg,u16 * val)273 static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val)
274 {
275 	u8 buf[2] = { reg >> 8, reg & 0xff };
276 	u8 bval[2] = { 0, 0 };
277 	struct i2c_msg msg[2] = {
278 		{ .addr = priv->i2c_props.addr,
279 			.flags = 0, .buf = &buf[0], .len = 2 },
280 		{ .addr = priv->i2c_props.addr,
281 			.flags = I2C_M_RD, .buf = &bval[0], .len = 2 },
282 	};
283 
284 	if (i2c_transfer(priv->i2c_props.adap, msg, 2) != 2) {
285 		printk(KERN_WARNING "xc5000: I2C read failed\n");
286 		return -EREMOTEIO;
287 	}
288 
289 	*val = (bval[0] << 8) | bval[1];
290 	return 0;
291 }
292 
xc5000_tuner_reset(struct dvb_frontend * fe)293 static int xc5000_tuner_reset(struct dvb_frontend *fe)
294 {
295 	struct xc5000_priv *priv = fe->tuner_priv;
296 	int ret;
297 
298 	dprintk(1, "%s()\n", __func__);
299 
300 	if (fe->callback) {
301 		ret = fe->callback(((fe->dvb) && (fe->dvb->priv)) ?
302 					   fe->dvb->priv :
303 					   priv->i2c_props.adap->algo_data,
304 					   DVB_FRONTEND_COMPONENT_TUNER,
305 					   XC5000_TUNER_RESET, 0);
306 		if (ret) {
307 			printk(KERN_ERR "xc5000: reset failed\n");
308 			return ret;
309 		}
310 	} else {
311 		printk(KERN_ERR "xc5000: no tuner reset callback function, fatal\n");
312 		return -EINVAL;
313 	}
314 	return 0;
315 }
316 
xc_write_reg(struct xc5000_priv * priv,u16 reg_addr,u16 i2c_data)317 static int xc_write_reg(struct xc5000_priv *priv, u16 reg_addr, u16 i2c_data)
318 {
319 	u8 buf[4];
320 	int watch_dog_timer = 100;
321 	int result;
322 
323 	buf[0] = (reg_addr >> 8) & 0xFF;
324 	buf[1] = reg_addr & 0xFF;
325 	buf[2] = (i2c_data >> 8) & 0xFF;
326 	buf[3] = i2c_data & 0xFF;
327 	result = xc_send_i2c_data(priv, buf, 4);
328 	if (result == 0) {
329 		/* wait for busy flag to clear */
330 		while ((watch_dog_timer > 0) && (result == 0)) {
331 			result = xc5000_readreg(priv, XREG_BUSY, (u16 *)buf);
332 			if (result == 0) {
333 				if ((buf[0] == 0) && (buf[1] == 0)) {
334 					/* busy flag cleared */
335 					break;
336 				} else {
337 					msleep(5); /* wait 5 ms */
338 					watch_dog_timer--;
339 				}
340 			}
341 		}
342 	}
343 	if (watch_dog_timer <= 0)
344 		result = -EREMOTEIO;
345 
346 	return result;
347 }
348 
xc_load_i2c_sequence(struct dvb_frontend * fe,const u8 * i2c_sequence)349 static int xc_load_i2c_sequence(struct dvb_frontend *fe, const u8 *i2c_sequence)
350 {
351 	struct xc5000_priv *priv = fe->tuner_priv;
352 
353 	int i, nbytes_to_send, result;
354 	unsigned int len, pos, index;
355 	u8 buf[XC_MAX_I2C_WRITE_LENGTH];
356 
357 	index = 0;
358 	while ((i2c_sequence[index] != 0xFF) ||
359 		(i2c_sequence[index + 1] != 0xFF)) {
360 		len = i2c_sequence[index] * 256 + i2c_sequence[index+1];
361 		if (len == 0x0000) {
362 			/* RESET command */
363 			result = xc5000_tuner_reset(fe);
364 			index += 2;
365 			if (result != 0)
366 				return result;
367 		} else if (len & 0x8000) {
368 			/* WAIT command */
369 			msleep(len & 0x7FFF);
370 			index += 2;
371 		} else {
372 			/* Send i2c data whilst ensuring individual transactions
373 			 * do not exceed XC_MAX_I2C_WRITE_LENGTH bytes.
374 			 */
375 			index += 2;
376 			buf[0] = i2c_sequence[index];
377 			buf[1] = i2c_sequence[index + 1];
378 			pos = 2;
379 			while (pos < len) {
380 				if ((len - pos) > XC_MAX_I2C_WRITE_LENGTH - 2)
381 					nbytes_to_send =
382 						XC_MAX_I2C_WRITE_LENGTH;
383 				else
384 					nbytes_to_send = (len - pos + 2);
385 				for (i = 2; i < nbytes_to_send; i++) {
386 					buf[i] = i2c_sequence[index + pos +
387 						i - 2];
388 				}
389 				result = xc_send_i2c_data(priv, buf,
390 					nbytes_to_send);
391 
392 				if (result != 0)
393 					return result;
394 
395 				pos += nbytes_to_send - 2;
396 			}
397 			index += len;
398 		}
399 	}
400 	return 0;
401 }
402 
xc_initialize(struct xc5000_priv * priv)403 static int xc_initialize(struct xc5000_priv *priv)
404 {
405 	dprintk(1, "%s()\n", __func__);
406 	return xc_write_reg(priv, XREG_INIT, 0);
407 }
408 
xc_set_tv_standard(struct xc5000_priv * priv,u16 video_mode,u16 audio_mode,u8 radio_mode)409 static int xc_set_tv_standard(struct xc5000_priv *priv,
410 	u16 video_mode, u16 audio_mode, u8 radio_mode)
411 {
412 	int ret;
413 	dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, video_mode, audio_mode);
414 	if (radio_mode) {
415 		dprintk(1, "%s() Standard = %s\n",
416 			__func__,
417 			xc5000_standard[radio_mode].name);
418 	} else {
419 		dprintk(1, "%s() Standard = %s\n",
420 			__func__,
421 			xc5000_standard[priv->video_standard].name);
422 	}
423 
424 	ret = xc_write_reg(priv, XREG_VIDEO_MODE, video_mode);
425 	if (ret == 0)
426 		ret = xc_write_reg(priv, XREG_AUDIO_MODE, audio_mode);
427 
428 	return ret;
429 }
430 
xc_set_signal_source(struct xc5000_priv * priv,u16 rf_mode)431 static int xc_set_signal_source(struct xc5000_priv *priv, u16 rf_mode)
432 {
433 	dprintk(1, "%s(%d) Source = %s\n", __func__, rf_mode,
434 		rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE");
435 
436 	if ((rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE)) {
437 		rf_mode = XC_RF_MODE_CABLE;
438 		printk(KERN_ERR
439 			"%s(), Invalid mode, defaulting to CABLE",
440 			__func__);
441 	}
442 	return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode);
443 }
444 
445 static const struct dvb_tuner_ops xc5000_tuner_ops;
446 
xc_set_rf_frequency(struct xc5000_priv * priv,u32 freq_hz)447 static int xc_set_rf_frequency(struct xc5000_priv *priv, u32 freq_hz)
448 {
449 	u16 freq_code;
450 
451 	dprintk(1, "%s(%u)\n", __func__, freq_hz);
452 
453 	if ((freq_hz > xc5000_tuner_ops.info.frequency_max_hz) ||
454 		(freq_hz < xc5000_tuner_ops.info.frequency_min_hz))
455 		return -EINVAL;
456 
457 	freq_code = (u16)(freq_hz / 15625);
458 
459 	/* Starting in firmware version 1.1.44, Xceive recommends using the
460 	   FINERFREQ for all normal tuning (the doc indicates reg 0x03 should
461 	   only be used for fast scanning for channel lock) */
462 	return xc_write_reg(priv, XREG_FINERFREQ, freq_code);
463 }
464 
465 
xc_set_IF_frequency(struct xc5000_priv * priv,u32 freq_khz)466 static int xc_set_IF_frequency(struct xc5000_priv *priv, u32 freq_khz)
467 {
468 	u32 freq_code = (freq_khz * 1024)/1000;
469 	dprintk(1, "%s(freq_khz = %d) freq_code = 0x%x\n",
470 		__func__, freq_khz, freq_code);
471 
472 	return xc_write_reg(priv, XREG_IF_OUT, freq_code);
473 }
474 
475 
xc_get_adc_envelope(struct xc5000_priv * priv,u16 * adc_envelope)476 static int xc_get_adc_envelope(struct xc5000_priv *priv, u16 *adc_envelope)
477 {
478 	return xc5000_readreg(priv, XREG_ADC_ENV, adc_envelope);
479 }
480 
xc_get_frequency_error(struct xc5000_priv * priv,u32 * freq_error_hz)481 static int xc_get_frequency_error(struct xc5000_priv *priv, u32 *freq_error_hz)
482 {
483 	int result;
484 	u16 reg_data;
485 	u32 tmp;
486 
487 	result = xc5000_readreg(priv, XREG_FREQ_ERROR, &reg_data);
488 	if (result != 0)
489 		return result;
490 
491 	tmp = (u32)reg_data;
492 	(*freq_error_hz) = (tmp * 15625) / 1000;
493 	return result;
494 }
495 
xc_get_lock_status(struct xc5000_priv * priv,u16 * lock_status)496 static int xc_get_lock_status(struct xc5000_priv *priv, u16 *lock_status)
497 {
498 	return xc5000_readreg(priv, XREG_LOCK, lock_status);
499 }
500 
xc_get_version(struct xc5000_priv * priv,u8 * hw_majorversion,u8 * hw_minorversion,u8 * fw_majorversion,u8 * fw_minorversion)501 static int xc_get_version(struct xc5000_priv *priv,
502 	u8 *hw_majorversion, u8 *hw_minorversion,
503 	u8 *fw_majorversion, u8 *fw_minorversion)
504 {
505 	u16 data;
506 	int result;
507 
508 	result = xc5000_readreg(priv, XREG_VERSION, &data);
509 	if (result != 0)
510 		return result;
511 
512 	(*hw_majorversion) = (data >> 12) & 0x0F;
513 	(*hw_minorversion) = (data >>  8) & 0x0F;
514 	(*fw_majorversion) = (data >>  4) & 0x0F;
515 	(*fw_minorversion) = data & 0x0F;
516 
517 	return 0;
518 }
519 
xc_get_buildversion(struct xc5000_priv * priv,u16 * buildrev)520 static int xc_get_buildversion(struct xc5000_priv *priv, u16 *buildrev)
521 {
522 	return xc5000_readreg(priv, XREG_BUILD, buildrev);
523 }
524 
xc_get_hsync_freq(struct xc5000_priv * priv,u32 * hsync_freq_hz)525 static int xc_get_hsync_freq(struct xc5000_priv *priv, u32 *hsync_freq_hz)
526 {
527 	u16 reg_data;
528 	int result;
529 
530 	result = xc5000_readreg(priv, XREG_HSYNC_FREQ, &reg_data);
531 	if (result != 0)
532 		return result;
533 
534 	(*hsync_freq_hz) = ((reg_data & 0x0fff) * 763)/100;
535 	return result;
536 }
537 
xc_get_frame_lines(struct xc5000_priv * priv,u16 * frame_lines)538 static int xc_get_frame_lines(struct xc5000_priv *priv, u16 *frame_lines)
539 {
540 	return xc5000_readreg(priv, XREG_FRAME_LINES, frame_lines);
541 }
542 
xc_get_quality(struct xc5000_priv * priv,u16 * quality)543 static int xc_get_quality(struct xc5000_priv *priv, u16 *quality)
544 {
545 	return xc5000_readreg(priv, XREG_QUALITY, quality);
546 }
547 
xc_get_analogsnr(struct xc5000_priv * priv,u16 * snr)548 static int xc_get_analogsnr(struct xc5000_priv *priv, u16 *snr)
549 {
550 	return xc5000_readreg(priv, XREG_SNR, snr);
551 }
552 
xc_get_totalgain(struct xc5000_priv * priv,u16 * totalgain)553 static int xc_get_totalgain(struct xc5000_priv *priv, u16 *totalgain)
554 {
555 	return xc5000_readreg(priv, XREG_TOTALGAIN, totalgain);
556 }
557 
558 #define XC_TUNE_ANALOG  0
559 #define XC_TUNE_DIGITAL 1
xc_tune_channel(struct xc5000_priv * priv,u32 freq_hz,int mode)560 static int xc_tune_channel(struct xc5000_priv *priv, u32 freq_hz, int mode)
561 {
562 	dprintk(1, "%s(%u)\n", __func__, freq_hz);
563 
564 	if (xc_set_rf_frequency(priv, freq_hz) != 0)
565 		return -EREMOTEIO;
566 
567 	return 0;
568 }
569 
xc_set_xtal(struct dvb_frontend * fe)570 static int xc_set_xtal(struct dvb_frontend *fe)
571 {
572 	struct xc5000_priv *priv = fe->tuner_priv;
573 	int ret = 0;
574 
575 	switch (priv->chip_id) {
576 	default:
577 	case XC5000A:
578 		/* 32.000 MHz xtal is default */
579 		break;
580 	case XC5000C:
581 		switch (priv->xtal_khz) {
582 		default:
583 		case 32000:
584 			/* 32.000 MHz xtal is default */
585 			break;
586 		case 31875:
587 			/* 31.875 MHz xtal configuration */
588 			ret = xc_write_reg(priv, 0x000f, 0x8081);
589 			break;
590 		}
591 		break;
592 	}
593 	return ret;
594 }
595 
xc5000_fwupload(struct dvb_frontend * fe,const struct xc5000_fw_cfg * desired_fw,const struct firmware * fw)596 static int xc5000_fwupload(struct dvb_frontend *fe,
597 			   const struct xc5000_fw_cfg *desired_fw,
598 			   const struct firmware *fw)
599 {
600 	struct xc5000_priv *priv = fe->tuner_priv;
601 	int ret;
602 
603 	/* request the firmware, this will block and timeout */
604 	dprintk(1, "waiting for firmware upload (%s)...\n",
605 		desired_fw->name);
606 
607 	priv->pll_register_no = desired_fw->pll_reg;
608 	priv->init_status_supported = desired_fw->init_status_supported;
609 	priv->fw_checksum_supported = desired_fw->fw_checksum_supported;
610 
611 
612 	dprintk(1, "firmware uploading...\n");
613 	ret = xc_load_i2c_sequence(fe,  fw->data);
614 	if (!ret) {
615 		ret = xc_set_xtal(fe);
616 		dprintk(1, "Firmware upload complete...\n");
617 	} else
618 		printk(KERN_ERR "xc5000: firmware upload failed...\n");
619 
620 	return ret;
621 }
622 
xc_debug_dump(struct xc5000_priv * priv)623 static void xc_debug_dump(struct xc5000_priv *priv)
624 {
625 	u16 adc_envelope;
626 	u32 freq_error_hz = 0;
627 	u16 lock_status;
628 	u32 hsync_freq_hz = 0;
629 	u16 frame_lines;
630 	u16 quality;
631 	u16 snr;
632 	u16 totalgain;
633 	u8 hw_majorversion = 0, hw_minorversion = 0;
634 	u8 fw_majorversion = 0, fw_minorversion = 0;
635 	u16 fw_buildversion = 0;
636 	u16 regval;
637 
638 	/* Wait for stats to stabilize.
639 	 * Frame Lines needs two frame times after initial lock
640 	 * before it is valid.
641 	 */
642 	msleep(100);
643 
644 	xc_get_adc_envelope(priv,  &adc_envelope);
645 	dprintk(1, "*** ADC envelope (0-1023) = %d\n", adc_envelope);
646 
647 	xc_get_frequency_error(priv, &freq_error_hz);
648 	dprintk(1, "*** Frequency error = %d Hz\n", freq_error_hz);
649 
650 	xc_get_lock_status(priv,  &lock_status);
651 	dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %d\n",
652 		lock_status);
653 
654 	xc_get_version(priv,  &hw_majorversion, &hw_minorversion,
655 		&fw_majorversion, &fw_minorversion);
656 	xc_get_buildversion(priv,  &fw_buildversion);
657 	dprintk(1, "*** HW: V%d.%d, FW: V %d.%d.%d\n",
658 		hw_majorversion, hw_minorversion,
659 		fw_majorversion, fw_minorversion, fw_buildversion);
660 
661 	xc_get_hsync_freq(priv,  &hsync_freq_hz);
662 	dprintk(1, "*** Horizontal sync frequency = %d Hz\n", hsync_freq_hz);
663 
664 	xc_get_frame_lines(priv,  &frame_lines);
665 	dprintk(1, "*** Frame lines = %d\n", frame_lines);
666 
667 	xc_get_quality(priv,  &quality);
668 	dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %d\n", quality & 0x07);
669 
670 	xc_get_analogsnr(priv,  &snr);
671 	dprintk(1, "*** Unweighted analog SNR = %d dB\n", snr & 0x3f);
672 
673 	xc_get_totalgain(priv,  &totalgain);
674 	dprintk(1, "*** Total gain = %d.%d dB\n", totalgain / 256,
675 		(totalgain % 256) * 100 / 256);
676 
677 	if (priv->pll_register_no) {
678 		if (!xc5000_readreg(priv, priv->pll_register_no, &regval))
679 			dprintk(1, "*** PLL lock status = 0x%04x\n", regval);
680 	}
681 }
682 
xc5000_tune_digital(struct dvb_frontend * fe)683 static int xc5000_tune_digital(struct dvb_frontend *fe)
684 {
685 	struct xc5000_priv *priv = fe->tuner_priv;
686 	int ret;
687 	u32 bw = fe->dtv_property_cache.bandwidth_hz;
688 
689 	ret = xc_set_signal_source(priv, priv->rf_mode);
690 	if (ret != 0) {
691 		printk(KERN_ERR
692 			"xc5000: xc_set_signal_source(%d) failed\n",
693 			priv->rf_mode);
694 		return -EREMOTEIO;
695 	}
696 
697 	ret = xc_set_tv_standard(priv,
698 		xc5000_standard[priv->video_standard].video_mode,
699 		xc5000_standard[priv->video_standard].audio_mode, 0);
700 	if (ret != 0) {
701 		printk(KERN_ERR "xc5000: xc_set_tv_standard failed\n");
702 		return -EREMOTEIO;
703 	}
704 
705 	ret = xc_set_IF_frequency(priv, priv->if_khz);
706 	if (ret != 0) {
707 		printk(KERN_ERR "xc5000: xc_Set_IF_frequency(%d) failed\n",
708 		       priv->if_khz);
709 		return -EIO;
710 	}
711 
712 	dprintk(1, "%s() setting OUTPUT_AMP to 0x%x\n",
713 		__func__, priv->output_amp);
714 	xc_write_reg(priv, XREG_OUTPUT_AMP, priv->output_amp);
715 
716 	xc_tune_channel(priv, priv->freq_hz, XC_TUNE_DIGITAL);
717 
718 	if (debug)
719 		xc_debug_dump(priv);
720 
721 	priv->bandwidth = bw;
722 
723 	return 0;
724 }
725 
xc5000_set_digital_params(struct dvb_frontend * fe)726 static int xc5000_set_digital_params(struct dvb_frontend *fe)
727 {
728 	int b;
729 	struct xc5000_priv *priv = fe->tuner_priv;
730 	u32 bw = fe->dtv_property_cache.bandwidth_hz;
731 	u32 freq = fe->dtv_property_cache.frequency;
732 	u32 delsys  = fe->dtv_property_cache.delivery_system;
733 
734 	if (xc_load_fw_and_init_tuner(fe, 0) != 0) {
735 		dprintk(1, "Unable to load firmware and init tuner\n");
736 		return -EINVAL;
737 	}
738 
739 	dprintk(1, "%s() frequency=%d (Hz)\n", __func__, freq);
740 
741 	switch (delsys) {
742 	case SYS_ATSC:
743 		dprintk(1, "%s() VSB modulation\n", __func__);
744 		priv->rf_mode = XC_RF_MODE_AIR;
745 		priv->freq_offset = 1750000;
746 		priv->video_standard = DTV6;
747 		break;
748 	case SYS_DVBC_ANNEX_B:
749 		dprintk(1, "%s() QAM modulation\n", __func__);
750 		priv->rf_mode = XC_RF_MODE_CABLE;
751 		priv->freq_offset = 1750000;
752 		priv->video_standard = DTV6;
753 		break;
754 	case SYS_ISDBT:
755 		/* All ISDB-T are currently for 6 MHz bw */
756 		if (!bw)
757 			bw = 6000000;
758 		/* fall to OFDM handling */
759 		fallthrough;
760 	case SYS_DMBTH:
761 	case SYS_DVBT:
762 	case SYS_DVBT2:
763 		dprintk(1, "%s() OFDM\n", __func__);
764 		switch (bw) {
765 		case 6000000:
766 			priv->video_standard = DTV6;
767 			priv->freq_offset = 1750000;
768 			break;
769 		case 7000000:
770 			priv->video_standard = DTV7;
771 			priv->freq_offset = 2250000;
772 			break;
773 		case 8000000:
774 			priv->video_standard = DTV8;
775 			priv->freq_offset = 2750000;
776 			break;
777 		default:
778 			printk(KERN_ERR "xc5000 bandwidth not set!\n");
779 			return -EINVAL;
780 		}
781 		priv->rf_mode = XC_RF_MODE_AIR;
782 		break;
783 	case SYS_DVBC_ANNEX_A:
784 	case SYS_DVBC_ANNEX_C:
785 		dprintk(1, "%s() QAM modulation\n", __func__);
786 		priv->rf_mode = XC_RF_MODE_CABLE;
787 		if (bw <= 6000000) {
788 			priv->video_standard = DTV6;
789 			priv->freq_offset = 1750000;
790 			b = 6;
791 		} else if (bw <= 7000000) {
792 			priv->video_standard = DTV7;
793 			priv->freq_offset = 2250000;
794 			b = 7;
795 		} else {
796 			priv->video_standard = DTV7_8;
797 			priv->freq_offset = 2750000;
798 			b = 8;
799 		}
800 		dprintk(1, "%s() Bandwidth %dMHz (%d)\n", __func__,
801 			b, bw);
802 		break;
803 	default:
804 		printk(KERN_ERR "xc5000: delivery system is not supported!\n");
805 		return -EINVAL;
806 	}
807 
808 	priv->freq_hz = freq - priv->freq_offset;
809 	priv->mode = V4L2_TUNER_DIGITAL_TV;
810 
811 	dprintk(1, "%s() frequency=%d (compensated to %d)\n",
812 		__func__, freq, priv->freq_hz);
813 
814 	return xc5000_tune_digital(fe);
815 }
816 
xc5000_is_firmware_loaded(struct dvb_frontend * fe)817 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe)
818 {
819 	struct xc5000_priv *priv = fe->tuner_priv;
820 	int ret;
821 	u16 id;
822 
823 	ret = xc5000_readreg(priv, XREG_PRODUCT_ID, &id);
824 	if (!ret) {
825 		if (id == XC_PRODUCT_ID_FW_NOT_LOADED)
826 			ret = -ENOENT;
827 		else
828 			ret = 0;
829 		dprintk(1, "%s() returns id = 0x%x\n", __func__, id);
830 	} else {
831 		dprintk(1, "%s() returns error %d\n", __func__, ret);
832 	}
833 
834 	return ret;
835 }
836 
xc5000_config_tv(struct dvb_frontend * fe,struct analog_parameters * params)837 static void xc5000_config_tv(struct dvb_frontend *fe,
838 			     struct analog_parameters *params)
839 {
840 	struct xc5000_priv *priv = fe->tuner_priv;
841 
842 	dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
843 		__func__, params->frequency);
844 
845 	/* Fix me: it could be air. */
846 	priv->rf_mode = params->mode;
847 	if (params->mode > XC_RF_MODE_CABLE)
848 		priv->rf_mode = XC_RF_MODE_CABLE;
849 
850 	/* params->frequency is in units of 62.5khz */
851 	priv->freq_hz = params->frequency * 62500;
852 
853 	/* FIX ME: Some video standards may have several possible audio
854 		   standards. We simply default to one of them here.
855 	 */
856 	if (params->std & V4L2_STD_MN) {
857 		/* default to BTSC audio standard */
858 		priv->video_standard = MN_NTSC_PAL_BTSC;
859 		return;
860 	}
861 
862 	if (params->std & V4L2_STD_PAL_BG) {
863 		/* default to NICAM audio standard */
864 		priv->video_standard = BG_PAL_NICAM;
865 		return;
866 	}
867 
868 	if (params->std & V4L2_STD_PAL_I) {
869 		/* default to NICAM audio standard */
870 		priv->video_standard = I_PAL_NICAM;
871 		return;
872 	}
873 
874 	if (params->std & V4L2_STD_PAL_DK) {
875 		/* default to NICAM audio standard */
876 		priv->video_standard = DK_PAL_NICAM;
877 		return;
878 	}
879 
880 	if (params->std & V4L2_STD_SECAM_DK) {
881 		/* default to A2 DK1 audio standard */
882 		priv->video_standard = DK_SECAM_A2DK1;
883 		return;
884 	}
885 
886 	if (params->std & V4L2_STD_SECAM_L) {
887 		priv->video_standard = L_SECAM_NICAM;
888 		return;
889 	}
890 
891 	if (params->std & V4L2_STD_SECAM_LC) {
892 		priv->video_standard = LC_SECAM_NICAM;
893 		return;
894 	}
895 }
896 
xc5000_set_tv_freq(struct dvb_frontend * fe)897 static int xc5000_set_tv_freq(struct dvb_frontend *fe)
898 {
899 	struct xc5000_priv *priv = fe->tuner_priv;
900 	u16 pll_lock_status;
901 	int ret;
902 
903 tune_channel:
904 	ret = xc_set_signal_source(priv, priv->rf_mode);
905 	if (ret != 0) {
906 		printk(KERN_ERR
907 			"xc5000: xc_set_signal_source(%d) failed\n",
908 			priv->rf_mode);
909 		return -EREMOTEIO;
910 	}
911 
912 	ret = xc_set_tv_standard(priv,
913 		xc5000_standard[priv->video_standard].video_mode,
914 		xc5000_standard[priv->video_standard].audio_mode, 0);
915 	if (ret != 0) {
916 		printk(KERN_ERR "xc5000: xc_set_tv_standard failed\n");
917 		return -EREMOTEIO;
918 	}
919 
920 	xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
921 
922 	xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
923 
924 	if (debug)
925 		xc_debug_dump(priv);
926 
927 	if (priv->pll_register_no != 0) {
928 		msleep(20);
929 		ret = xc5000_readreg(priv, priv->pll_register_no,
930 				     &pll_lock_status);
931 		if (ret)
932 			return ret;
933 		if (pll_lock_status > 63) {
934 			/* PLL is unlocked, force reload of the firmware */
935 			dprintk(1, "xc5000: PLL not locked (0x%x).  Reloading...\n",
936 				pll_lock_status);
937 			if (xc_load_fw_and_init_tuner(fe, 1) != 0) {
938 				printk(KERN_ERR "xc5000: Unable to reload fw\n");
939 				return -EREMOTEIO;
940 			}
941 			goto tune_channel;
942 		}
943 	}
944 
945 	return 0;
946 }
947 
xc5000_config_radio(struct dvb_frontend * fe,struct analog_parameters * params)948 static int xc5000_config_radio(struct dvb_frontend *fe,
949 			       struct analog_parameters *params)
950 
951 {
952 	struct xc5000_priv *priv = fe->tuner_priv;
953 
954 	dprintk(1, "%s() frequency=%d (in units of khz)\n",
955 		__func__, params->frequency);
956 
957 	if (priv->radio_input == XC5000_RADIO_NOT_CONFIGURED) {
958 		dprintk(1, "%s() radio input not configured\n", __func__);
959 		return -EINVAL;
960 	}
961 
962 	priv->freq_hz = params->frequency * 125 / 2;
963 	priv->rf_mode = XC_RF_MODE_AIR;
964 
965 	return 0;
966 }
967 
xc5000_set_radio_freq(struct dvb_frontend * fe)968 static int xc5000_set_radio_freq(struct dvb_frontend *fe)
969 {
970 	struct xc5000_priv *priv = fe->tuner_priv;
971 	int ret;
972 	u8 radio_input;
973 
974 	if (priv->radio_input == XC5000_RADIO_FM1)
975 		radio_input = FM_RADIO_INPUT1;
976 	else if  (priv->radio_input == XC5000_RADIO_FM2)
977 		radio_input = FM_RADIO_INPUT2;
978 	else if  (priv->radio_input == XC5000_RADIO_FM1_MONO)
979 		radio_input = FM_RADIO_INPUT1_MONO;
980 	else {
981 		dprintk(1, "%s() unknown radio input %d\n", __func__,
982 			priv->radio_input);
983 		return -EINVAL;
984 	}
985 
986 	ret = xc_set_tv_standard(priv, xc5000_standard[radio_input].video_mode,
987 			       xc5000_standard[radio_input].audio_mode, radio_input);
988 
989 	if (ret != 0) {
990 		printk(KERN_ERR "xc5000: xc_set_tv_standard failed\n");
991 		return -EREMOTEIO;
992 	}
993 
994 	ret = xc_set_signal_source(priv, priv->rf_mode);
995 	if (ret != 0) {
996 		printk(KERN_ERR
997 			"xc5000: xc_set_signal_source(%d) failed\n",
998 			priv->rf_mode);
999 		return -EREMOTEIO;
1000 	}
1001 
1002 	if ((priv->radio_input == XC5000_RADIO_FM1) ||
1003 				(priv->radio_input == XC5000_RADIO_FM2))
1004 		xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
1005 	else if  (priv->radio_input == XC5000_RADIO_FM1_MONO)
1006 		xc_write_reg(priv, XREG_OUTPUT_AMP, 0x06);
1007 
1008 	xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
1009 
1010 	return 0;
1011 }
1012 
xc5000_set_params(struct dvb_frontend * fe)1013 static int xc5000_set_params(struct dvb_frontend *fe)
1014 {
1015 	struct xc5000_priv *priv = fe->tuner_priv;
1016 
1017 	if (xc_load_fw_and_init_tuner(fe, 0) != 0) {
1018 		dprintk(1, "Unable to load firmware and init tuner\n");
1019 		return -EINVAL;
1020 	}
1021 
1022 	switch (priv->mode) {
1023 	case V4L2_TUNER_RADIO:
1024 		return xc5000_set_radio_freq(fe);
1025 	case V4L2_TUNER_ANALOG_TV:
1026 		return xc5000_set_tv_freq(fe);
1027 	case V4L2_TUNER_DIGITAL_TV:
1028 		return xc5000_tune_digital(fe);
1029 	}
1030 
1031 	return 0;
1032 }
1033 
xc5000_set_analog_params(struct dvb_frontend * fe,struct analog_parameters * params)1034 static int xc5000_set_analog_params(struct dvb_frontend *fe,
1035 			     struct analog_parameters *params)
1036 {
1037 	struct xc5000_priv *priv = fe->tuner_priv;
1038 	int ret;
1039 
1040 	if (priv->i2c_props.adap == NULL)
1041 		return -EINVAL;
1042 
1043 	switch (params->mode) {
1044 	case V4L2_TUNER_RADIO:
1045 		ret = xc5000_config_radio(fe, params);
1046 		if (ret)
1047 			return ret;
1048 		break;
1049 	case V4L2_TUNER_ANALOG_TV:
1050 		xc5000_config_tv(fe, params);
1051 		break;
1052 	default:
1053 		break;
1054 	}
1055 	priv->mode = params->mode;
1056 
1057 	return xc5000_set_params(fe);
1058 }
1059 
xc5000_get_frequency(struct dvb_frontend * fe,u32 * freq)1060 static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq)
1061 {
1062 	struct xc5000_priv *priv = fe->tuner_priv;
1063 	dprintk(1, "%s()\n", __func__);
1064 	*freq = priv->freq_hz + priv->freq_offset;
1065 	return 0;
1066 }
1067 
xc5000_get_if_frequency(struct dvb_frontend * fe,u32 * freq)1068 static int xc5000_get_if_frequency(struct dvb_frontend *fe, u32 *freq)
1069 {
1070 	struct xc5000_priv *priv = fe->tuner_priv;
1071 	dprintk(1, "%s()\n", __func__);
1072 	*freq = priv->if_khz * 1000;
1073 	return 0;
1074 }
1075 
xc5000_get_bandwidth(struct dvb_frontend * fe,u32 * bw)1076 static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
1077 {
1078 	struct xc5000_priv *priv = fe->tuner_priv;
1079 	dprintk(1, "%s()\n", __func__);
1080 
1081 	*bw = priv->bandwidth;
1082 	return 0;
1083 }
1084 
xc5000_get_status(struct dvb_frontend * fe,u32 * status)1085 static int xc5000_get_status(struct dvb_frontend *fe, u32 *status)
1086 {
1087 	struct xc5000_priv *priv = fe->tuner_priv;
1088 	u16 lock_status = 0;
1089 
1090 	xc_get_lock_status(priv, &lock_status);
1091 
1092 	dprintk(1, "%s() lock_status = 0x%08x\n", __func__, lock_status);
1093 
1094 	*status = lock_status;
1095 
1096 	return 0;
1097 }
1098 
xc_load_fw_and_init_tuner(struct dvb_frontend * fe,int force)1099 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe, int force)
1100 {
1101 	struct xc5000_priv *priv = fe->tuner_priv;
1102 	const struct xc5000_fw_cfg *desired_fw = xc5000_assign_firmware(priv->chip_id);
1103 	const struct firmware *fw;
1104 	int ret, i;
1105 	u16 pll_lock_status;
1106 	u16 fw_ck;
1107 
1108 	cancel_delayed_work(&priv->timer_sleep);
1109 
1110 	if (!force && xc5000_is_firmware_loaded(fe) == 0)
1111 		return 0;
1112 
1113 	ret = request_firmware(&fw, desired_fw->name,
1114 			       priv->i2c_props.adap->dev.parent);
1115 	if (ret) {
1116 		pr_err("xc5000: Upload failed. rc %d\n", ret);
1117 		return ret;
1118 	}
1119 	dprintk(1, "firmware read %zu bytes.\n", fw->size);
1120 
1121 	if (fw->size != desired_fw->size) {
1122 		pr_err("xc5000: Firmware file with incorrect size\n");
1123 		release_firmware(fw);
1124 		return -EINVAL;
1125 	}
1126 
1127 	/* Try up to 5 times to load firmware */
1128 	for (i = 0; i < 5; i++) {
1129 		if (i)
1130 			printk(KERN_CONT " - retrying to upload firmware.\n");
1131 
1132 		ret = xc5000_fwupload(fe, desired_fw, fw);
1133 		if (ret != 0)
1134 			goto err;
1135 
1136 		msleep(20);
1137 
1138 		if (priv->fw_checksum_supported) {
1139 			if (xc5000_readreg(priv, XREG_FW_CHECKSUM, &fw_ck)) {
1140 				printk(KERN_ERR
1141 				       "xc5000: FW checksum reading failed.");
1142 				continue;
1143 			}
1144 
1145 			if (!fw_ck) {
1146 				printk(KERN_ERR
1147 				       "xc5000: FW checksum failed = 0x%04x.",
1148 				       fw_ck);
1149 				continue;
1150 			}
1151 		}
1152 
1153 		/* Start the tuner self-calibration process */
1154 		ret = xc_initialize(priv);
1155 		if (ret) {
1156 			printk(KERN_ERR "xc5000: Can't request self-calibration.");
1157 			continue;
1158 		}
1159 
1160 		/* Wait for calibration to complete.
1161 		 * We could continue but XC5000 will clock stretch subsequent
1162 		 * I2C transactions until calibration is complete.  This way we
1163 		 * don't have to rely on clock stretching working.
1164 		 */
1165 		msleep(100);
1166 
1167 		if (priv->init_status_supported) {
1168 			if (xc5000_readreg(priv, XREG_INIT_STATUS, &fw_ck)) {
1169 				printk(KERN_ERR
1170 				       "xc5000: FW failed reading init status.");
1171 				continue;
1172 			}
1173 
1174 			if (!fw_ck) {
1175 				printk(KERN_ERR
1176 				       "xc5000: FW init status failed = 0x%04x.",
1177 				       fw_ck);
1178 				continue;
1179 			}
1180 		}
1181 
1182 		if (priv->pll_register_no) {
1183 			ret = xc5000_readreg(priv, priv->pll_register_no,
1184 					     &pll_lock_status);
1185 			if (ret)
1186 				continue;
1187 			if (pll_lock_status > 63) {
1188 				/* PLL is unlocked, force reload of the firmware */
1189 				printk(KERN_ERR
1190 				       "xc5000: PLL not running after fwload.");
1191 				continue;
1192 			}
1193 		}
1194 
1195 		/* Default to "CABLE" mode */
1196 		ret = xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE);
1197 		if (!ret)
1198 			break;
1199 		printk(KERN_ERR "xc5000: can't set to cable mode.");
1200 	}
1201 
1202 err:
1203 	release_firmware(fw);
1204 	if (!ret)
1205 		printk(KERN_INFO "xc5000: Firmware %s loaded and running.\n",
1206 		       desired_fw->name);
1207 	else
1208 		printk(KERN_CONT " - too many retries. Giving up\n");
1209 
1210 	return ret;
1211 }
1212 
xc5000_do_timer_sleep(struct work_struct * timer_sleep)1213 static void xc5000_do_timer_sleep(struct work_struct *timer_sleep)
1214 {
1215 	struct xc5000_priv *priv =container_of(timer_sleep, struct xc5000_priv,
1216 					       timer_sleep.work);
1217 	struct dvb_frontend *fe = priv->fe;
1218 	int ret;
1219 
1220 	dprintk(1, "%s()\n", __func__);
1221 
1222 	/* According to Xceive technical support, the "powerdown" register
1223 	   was removed in newer versions of the firmware.  The "supported"
1224 	   way to sleep the tuner is to pull the reset pin low for 10ms */
1225 	ret = xc5000_tuner_reset(fe);
1226 	if (ret != 0)
1227 		printk(KERN_ERR
1228 			"xc5000: %s() unable to shutdown tuner\n",
1229 			__func__);
1230 }
1231 
xc5000_sleep(struct dvb_frontend * fe)1232 static int xc5000_sleep(struct dvb_frontend *fe)
1233 {
1234 	struct xc5000_priv *priv = fe->tuner_priv;
1235 
1236 	dprintk(1, "%s()\n", __func__);
1237 
1238 	/* Avoid firmware reload on slow devices */
1239 	if (no_poweroff)
1240 		return 0;
1241 
1242 	schedule_delayed_work(&priv->timer_sleep,
1243 			      msecs_to_jiffies(XC5000_SLEEP_TIME));
1244 
1245 	return 0;
1246 }
1247 
xc5000_suspend(struct dvb_frontend * fe)1248 static int xc5000_suspend(struct dvb_frontend *fe)
1249 {
1250 	struct xc5000_priv *priv = fe->tuner_priv;
1251 	int ret;
1252 
1253 	dprintk(1, "%s()\n", __func__);
1254 
1255 	cancel_delayed_work(&priv->timer_sleep);
1256 
1257 	ret = xc5000_tuner_reset(fe);
1258 	if (ret != 0)
1259 		printk(KERN_ERR
1260 			"xc5000: %s() unable to shutdown tuner\n",
1261 			__func__);
1262 
1263 	return 0;
1264 }
1265 
xc5000_resume(struct dvb_frontend * fe)1266 static int xc5000_resume(struct dvb_frontend *fe)
1267 {
1268 	struct xc5000_priv *priv = fe->tuner_priv;
1269 
1270 	dprintk(1, "%s()\n", __func__);
1271 
1272 	/* suspended before firmware is loaded.
1273 	   Avoid firmware load in resume path. */
1274 	if (!priv->inited)
1275 		return 0;
1276 
1277 	return xc5000_set_params(fe);
1278 }
1279 
xc5000_init(struct dvb_frontend * fe)1280 static int xc5000_init(struct dvb_frontend *fe)
1281 {
1282 	struct xc5000_priv *priv = fe->tuner_priv;
1283 	dprintk(1, "%s()\n", __func__);
1284 
1285 	if (xc_load_fw_and_init_tuner(fe, 0) != 0) {
1286 		printk(KERN_ERR "xc5000: Unable to initialise tuner\n");
1287 		return -EREMOTEIO;
1288 	}
1289 
1290 	if (debug)
1291 		xc_debug_dump(priv);
1292 
1293 	priv->inited = true;
1294 
1295 	return 0;
1296 }
1297 
xc5000_release(struct dvb_frontend * fe)1298 static void xc5000_release(struct dvb_frontend *fe)
1299 {
1300 	struct xc5000_priv *priv = fe->tuner_priv;
1301 
1302 	dprintk(1, "%s()\n", __func__);
1303 
1304 	mutex_lock(&xc5000_list_mutex);
1305 
1306 	if (priv) {
1307 		cancel_delayed_work(&priv->timer_sleep);
1308 		hybrid_tuner_release_state(priv);
1309 	}
1310 
1311 	mutex_unlock(&xc5000_list_mutex);
1312 
1313 	fe->tuner_priv = NULL;
1314 }
1315 
xc5000_set_config(struct dvb_frontend * fe,void * priv_cfg)1316 static int xc5000_set_config(struct dvb_frontend *fe, void *priv_cfg)
1317 {
1318 	struct xc5000_priv *priv = fe->tuner_priv;
1319 	struct xc5000_config *p = priv_cfg;
1320 
1321 	dprintk(1, "%s()\n", __func__);
1322 
1323 	if (p->if_khz)
1324 		priv->if_khz = p->if_khz;
1325 
1326 	if (p->radio_input)
1327 		priv->radio_input = p->radio_input;
1328 
1329 	if (p->output_amp)
1330 		priv->output_amp = p->output_amp;
1331 
1332 	return 0;
1333 }
1334 
1335 
1336 static const struct dvb_tuner_ops xc5000_tuner_ops = {
1337 	.info = {
1338 		.name              = "Xceive XC5000",
1339 		.frequency_min_hz  =    1 * MHz,
1340 		.frequency_max_hz  = 1023 * MHz,
1341 		.frequency_step_hz =   50 * kHz,
1342 	},
1343 
1344 	.release	   = xc5000_release,
1345 	.init		   = xc5000_init,
1346 	.sleep		   = xc5000_sleep,
1347 	.suspend	   = xc5000_suspend,
1348 	.resume		   = xc5000_resume,
1349 
1350 	.set_config	   = xc5000_set_config,
1351 	.set_params	   = xc5000_set_digital_params,
1352 	.set_analog_params = xc5000_set_analog_params,
1353 	.get_frequency	   = xc5000_get_frequency,
1354 	.get_if_frequency  = xc5000_get_if_frequency,
1355 	.get_bandwidth	   = xc5000_get_bandwidth,
1356 	.get_status	   = xc5000_get_status
1357 };
1358 
xc5000_attach(struct dvb_frontend * fe,struct i2c_adapter * i2c,const struct xc5000_config * cfg)1359 struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe,
1360 				   struct i2c_adapter *i2c,
1361 				   const struct xc5000_config *cfg)
1362 {
1363 	struct xc5000_priv *priv = NULL;
1364 	int instance;
1365 	u16 id = 0;
1366 
1367 	dprintk(1, "%s(%d-%04x)\n", __func__,
1368 		i2c ? i2c_adapter_id(i2c) : -1,
1369 		cfg ? cfg->i2c_address : -1);
1370 
1371 	mutex_lock(&xc5000_list_mutex);
1372 
1373 	instance = hybrid_tuner_request_state(struct xc5000_priv, priv,
1374 					      hybrid_tuner_instance_list,
1375 					      i2c, cfg->i2c_address, "xc5000");
1376 	switch (instance) {
1377 	case 0:
1378 		goto fail;
1379 	case 1:
1380 		/* new tuner instance */
1381 		priv->bandwidth = 6000000;
1382 		fe->tuner_priv = priv;
1383 		priv->fe = fe;
1384 		INIT_DELAYED_WORK(&priv->timer_sleep, xc5000_do_timer_sleep);
1385 		break;
1386 	default:
1387 		/* existing tuner instance */
1388 		fe->tuner_priv = priv;
1389 		break;
1390 	}
1391 
1392 	if (priv->if_khz == 0) {
1393 		/* If the IF hasn't been set yet, use the value provided by
1394 		   the caller (occurs in hybrid devices where the analog
1395 		   call to xc5000_attach occurs before the digital side) */
1396 		priv->if_khz = cfg->if_khz;
1397 	}
1398 
1399 	if (priv->xtal_khz == 0)
1400 		priv->xtal_khz = cfg->xtal_khz;
1401 
1402 	if (priv->radio_input == 0)
1403 		priv->radio_input = cfg->radio_input;
1404 
1405 	/* don't override chip id if it's already been set
1406 	   unless explicitly specified */
1407 	if ((priv->chip_id == 0) || (cfg->chip_id))
1408 		/* use default chip id if none specified, set to 0 so
1409 		   it can be overridden if this is a hybrid driver */
1410 		priv->chip_id = (cfg->chip_id) ? cfg->chip_id : 0;
1411 
1412 	/* don't override output_amp if it's already been set
1413 	   unless explicitly specified */
1414 	if ((priv->output_amp == 0) || (cfg->output_amp))
1415 		/* use default output_amp value if none specified */
1416 		priv->output_amp = (cfg->output_amp) ? cfg->output_amp : 0x8a;
1417 
1418 	/* Check if firmware has been loaded. It is possible that another
1419 	   instance of the driver has loaded the firmware.
1420 	 */
1421 	if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != 0)
1422 		goto fail;
1423 
1424 	switch (id) {
1425 	case XC_PRODUCT_ID_FW_LOADED:
1426 		printk(KERN_INFO
1427 			"xc5000: Successfully identified at address 0x%02x\n",
1428 			cfg->i2c_address);
1429 		printk(KERN_INFO
1430 			"xc5000: Firmware has been loaded previously\n");
1431 		break;
1432 	case XC_PRODUCT_ID_FW_NOT_LOADED:
1433 		printk(KERN_INFO
1434 			"xc5000: Successfully identified at address 0x%02x\n",
1435 			cfg->i2c_address);
1436 		printk(KERN_INFO
1437 			"xc5000: Firmware has not been loaded previously\n");
1438 		break;
1439 	default:
1440 		printk(KERN_ERR
1441 			"xc5000: Device not found at addr 0x%02x (0x%x)\n",
1442 			cfg->i2c_address, id);
1443 		goto fail;
1444 	}
1445 
1446 	mutex_unlock(&xc5000_list_mutex);
1447 
1448 	memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops,
1449 		sizeof(struct dvb_tuner_ops));
1450 
1451 	return fe;
1452 fail:
1453 	mutex_unlock(&xc5000_list_mutex);
1454 
1455 	xc5000_release(fe);
1456 	return NULL;
1457 }
1458 EXPORT_SYMBOL_GPL(xc5000_attach);
1459 
1460 MODULE_AUTHOR("Steven Toth");
1461 MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver");
1462 MODULE_LICENSE("GPL");
1463 MODULE_FIRMWARE(XC5000A_FIRMWARE);
1464 MODULE_FIRMWARE(XC5000C_FIRMWARE);
1465