]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/media/common/tuners/xc5000.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'x86-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git...
[mirror_ubuntu-bionic-kernel.git] / drivers / media / common / tuners / xc5000.c
1 /*
2 * Driver for Xceive XC5000 "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 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 *
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23
24 #include <linux/module.h>
25 #include <linux/moduleparam.h>
26 #include <linux/videodev2.h>
27 #include <linux/delay.h>
28 #include <linux/dvb/frontend.h>
29 #include <linux/i2c.h>
30
31 #include "dvb_frontend.h"
32
33 #include "xc5000.h"
34 #include "tuner-i2c.h"
35
36 static int debug;
37 module_param(debug, int, 0644);
38 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
39
40 static int no_poweroff;
41 module_param(no_poweroff, int, 0644);
42 MODULE_PARM_DESC(no_poweroff, "0 (default) powers device off when not used.\n"
43 "\t\t1 keep device energized and with tuner ready all the times.\n"
44 "\t\tFaster, but consumes more power and keeps the device hotter");
45
46 static DEFINE_MUTEX(xc5000_list_mutex);
47 static LIST_HEAD(hybrid_tuner_instance_list);
48
49 #define dprintk(level, fmt, arg...) if (debug >= level) \
50 printk(KERN_INFO "%s: " fmt, "xc5000", ## arg)
51
52 #define XC5000_DEFAULT_FIRMWARE "dvb-fe-xc5000-1.6.114.fw"
53 #define XC5000_DEFAULT_FIRMWARE_SIZE 12401
54
55 struct xc5000_priv {
56 struct tuner_i2c_props i2c_props;
57 struct list_head hybrid_tuner_instance_list;
58
59 u32 if_khz;
60 u32 freq_hz;
61 u32 bandwidth;
62 u8 video_standard;
63 u8 rf_mode;
64 u8 radio_input;
65 };
66
67 /* Misc Defines */
68 #define MAX_TV_STANDARD 23
69 #define XC_MAX_I2C_WRITE_LENGTH 64
70
71 /* Signal Types */
72 #define XC_RF_MODE_AIR 0
73 #define XC_RF_MODE_CABLE 1
74
75 /* Result codes */
76 #define XC_RESULT_SUCCESS 0
77 #define XC_RESULT_RESET_FAILURE 1
78 #define XC_RESULT_I2C_WRITE_FAILURE 2
79 #define XC_RESULT_I2C_READ_FAILURE 3
80 #define XC_RESULT_OUT_OF_RANGE 5
81
82 /* Product id */
83 #define XC_PRODUCT_ID_FW_NOT_LOADED 0x2000
84 #define XC_PRODUCT_ID_FW_LOADED 0x1388
85
86 /* Registers */
87 #define XREG_INIT 0x00
88 #define XREG_VIDEO_MODE 0x01
89 #define XREG_AUDIO_MODE 0x02
90 #define XREG_RF_FREQ 0x03
91 #define XREG_D_CODE 0x04
92 #define XREG_IF_OUT 0x05
93 #define XREG_SEEK_MODE 0x07
94 #define XREG_POWER_DOWN 0x0A /* Obsolete */
95 #define XREG_SIGNALSOURCE 0x0D /* 0=Air, 1=Cable */
96 #define XREG_SMOOTHEDCVBS 0x0E
97 #define XREG_XTALFREQ 0x0F
98 #define XREG_FINERFREQ 0x10
99 #define XREG_DDIMODE 0x11
100
101 #define XREG_ADC_ENV 0x00
102 #define XREG_QUALITY 0x01
103 #define XREG_FRAME_LINES 0x02
104 #define XREG_HSYNC_FREQ 0x03
105 #define XREG_LOCK 0x04
106 #define XREG_FREQ_ERROR 0x05
107 #define XREG_SNR 0x06
108 #define XREG_VERSION 0x07
109 #define XREG_PRODUCT_ID 0x08
110 #define XREG_BUSY 0x09
111 #define XREG_BUILD 0x0D
112
113 /*
114 Basic firmware description. This will remain with
115 the driver for documentation purposes.
116
117 This represents an I2C firmware file encoded as a
118 string of unsigned char. Format is as follows:
119
120 char[0 ]=len0_MSB -> len = len_MSB * 256 + len_LSB
121 char[1 ]=len0_LSB -> length of first write transaction
122 char[2 ]=data0 -> first byte to be sent
123 char[3 ]=data1
124 char[4 ]=data2
125 char[ ]=...
126 char[M ]=dataN -> last byte to be sent
127 char[M+1]=len1_MSB -> len = len_MSB * 256 + len_LSB
128 char[M+2]=len1_LSB -> length of second write transaction
129 char[M+3]=data0
130 char[M+4]=data1
131 ...
132 etc.
133
134 The [len] value should be interpreted as follows:
135
136 len= len_MSB _ len_LSB
137 len=1111_1111_1111_1111 : End of I2C_SEQUENCE
138 len=0000_0000_0000_0000 : Reset command: Do hardware reset
139 len=0NNN_NNNN_NNNN_NNNN : Normal transaction: number of bytes = {1:32767)
140 len=1WWW_WWWW_WWWW_WWWW : Wait command: wait for {1:32767} ms
141
142 For the RESET and WAIT commands, the two following bytes will contain
143 immediately the length of the following transaction.
144
145 */
146 struct XC_TV_STANDARD {
147 char *Name;
148 u16 AudioMode;
149 u16 VideoMode;
150 };
151
152 /* Tuner standards */
153 #define MN_NTSC_PAL_BTSC 0
154 #define MN_NTSC_PAL_A2 1
155 #define MN_NTSC_PAL_EIAJ 2
156 #define MN_NTSC_PAL_Mono 3
157 #define BG_PAL_A2 4
158 #define BG_PAL_NICAM 5
159 #define BG_PAL_MONO 6
160 #define I_PAL_NICAM 7
161 #define I_PAL_NICAM_MONO 8
162 #define DK_PAL_A2 9
163 #define DK_PAL_NICAM 10
164 #define DK_PAL_MONO 11
165 #define DK_SECAM_A2DK1 12
166 #define DK_SECAM_A2LDK3 13
167 #define DK_SECAM_A2MONO 14
168 #define L_SECAM_NICAM 15
169 #define LC_SECAM_NICAM 16
170 #define DTV6 17
171 #define DTV8 18
172 #define DTV7_8 19
173 #define DTV7 20
174 #define FM_Radio_INPUT2 21
175 #define FM_Radio_INPUT1 22
176
177 static struct XC_TV_STANDARD XC5000_Standard[MAX_TV_STANDARD] = {
178 {"M/N-NTSC/PAL-BTSC", 0x0400, 0x8020},
179 {"M/N-NTSC/PAL-A2", 0x0600, 0x8020},
180 {"M/N-NTSC/PAL-EIAJ", 0x0440, 0x8020},
181 {"M/N-NTSC/PAL-Mono", 0x0478, 0x8020},
182 {"B/G-PAL-A2", 0x0A00, 0x8049},
183 {"B/G-PAL-NICAM", 0x0C04, 0x8049},
184 {"B/G-PAL-MONO", 0x0878, 0x8059},
185 {"I-PAL-NICAM", 0x1080, 0x8009},
186 {"I-PAL-NICAM-MONO", 0x0E78, 0x8009},
187 {"D/K-PAL-A2", 0x1600, 0x8009},
188 {"D/K-PAL-NICAM", 0x0E80, 0x8009},
189 {"D/K-PAL-MONO", 0x1478, 0x8009},
190 {"D/K-SECAM-A2 DK1", 0x1200, 0x8009},
191 {"D/K-SECAM-A2 L/DK3", 0x0E00, 0x8009},
192 {"D/K-SECAM-A2 MONO", 0x1478, 0x8009},
193 {"L-SECAM-NICAM", 0x8E82, 0x0009},
194 {"L'-SECAM-NICAM", 0x8E82, 0x4009},
195 {"DTV6", 0x00C0, 0x8002},
196 {"DTV8", 0x00C0, 0x800B},
197 {"DTV7/8", 0x00C0, 0x801B},
198 {"DTV7", 0x00C0, 0x8007},
199 {"FM Radio-INPUT2", 0x9802, 0x9002},
200 {"FM Radio-INPUT1", 0x0208, 0x9002}
201 };
202
203 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe);
204 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe);
205 static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val);
206 static int xc5000_TunerReset(struct dvb_frontend *fe);
207
208 static int xc_send_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
209 {
210 struct i2c_msg msg = { .addr = priv->i2c_props.addr,
211 .flags = 0, .buf = buf, .len = len };
212
213 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
214 printk(KERN_ERR "xc5000: I2C write failed (len=%i)\n", len);
215 return XC_RESULT_I2C_WRITE_FAILURE;
216 }
217 return XC_RESULT_SUCCESS;
218 }
219
220 /* This routine is never used because the only time we read data from the
221 i2c bus is when we read registers, and we want that to be an atomic i2c
222 transaction in case we are on a multi-master bus */
223 static int xc_read_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
224 {
225 struct i2c_msg msg = { .addr = priv->i2c_props.addr,
226 .flags = I2C_M_RD, .buf = buf, .len = len };
227
228 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
229 printk(KERN_ERR "xc5000 I2C read failed (len=%i)\n", len);
230 return -EREMOTEIO;
231 }
232 return 0;
233 }
234
235 static void xc_wait(int wait_ms)
236 {
237 msleep(wait_ms);
238 }
239
240 static int xc5000_TunerReset(struct dvb_frontend *fe)
241 {
242 struct xc5000_priv *priv = fe->tuner_priv;
243 int ret;
244
245 dprintk(1, "%s()\n", __func__);
246
247 if (fe->callback) {
248 ret = fe->callback(((fe->dvb) && (fe->dvb->priv)) ?
249 fe->dvb->priv :
250 priv->i2c_props.adap->algo_data,
251 DVB_FRONTEND_COMPONENT_TUNER,
252 XC5000_TUNER_RESET, 0);
253 if (ret) {
254 printk(KERN_ERR "xc5000: reset failed\n");
255 return XC_RESULT_RESET_FAILURE;
256 }
257 } else {
258 printk(KERN_ERR "xc5000: no tuner reset callback function, fatal\n");
259 return XC_RESULT_RESET_FAILURE;
260 }
261 return XC_RESULT_SUCCESS;
262 }
263
264 static int xc_write_reg(struct xc5000_priv *priv, u16 regAddr, u16 i2cData)
265 {
266 u8 buf[4];
267 int WatchDogTimer = 100;
268 int result;
269
270 buf[0] = (regAddr >> 8) & 0xFF;
271 buf[1] = regAddr & 0xFF;
272 buf[2] = (i2cData >> 8) & 0xFF;
273 buf[3] = i2cData & 0xFF;
274 result = xc_send_i2c_data(priv, buf, 4);
275 if (result == XC_RESULT_SUCCESS) {
276 /* wait for busy flag to clear */
277 while ((WatchDogTimer > 0) && (result == XC_RESULT_SUCCESS)) {
278 buf[0] = 0;
279 buf[1] = XREG_BUSY;
280
281 result = xc_send_i2c_data(priv, buf, 2);
282 if (result == XC_RESULT_SUCCESS) {
283 result = xc_read_i2c_data(priv, buf, 2);
284 if (result == XC_RESULT_SUCCESS) {
285 if ((buf[0] == 0) && (buf[1] == 0)) {
286 /* busy flag cleared */
287 break;
288 } else {
289 xc_wait(5); /* wait 5 ms */
290 WatchDogTimer--;
291 }
292 }
293 }
294 }
295 }
296 if (WatchDogTimer < 0)
297 result = XC_RESULT_I2C_WRITE_FAILURE;
298
299 return result;
300 }
301
302 static int xc_load_i2c_sequence(struct dvb_frontend *fe, const u8 *i2c_sequence)
303 {
304 struct xc5000_priv *priv = fe->tuner_priv;
305
306 int i, nbytes_to_send, result;
307 unsigned int len, pos, index;
308 u8 buf[XC_MAX_I2C_WRITE_LENGTH];
309
310 index = 0;
311 while ((i2c_sequence[index] != 0xFF) ||
312 (i2c_sequence[index + 1] != 0xFF)) {
313 len = i2c_sequence[index] * 256 + i2c_sequence[index+1];
314 if (len == 0x0000) {
315 /* RESET command */
316 result = xc5000_TunerReset(fe);
317 index += 2;
318 if (result != XC_RESULT_SUCCESS)
319 return result;
320 } else if (len & 0x8000) {
321 /* WAIT command */
322 xc_wait(len & 0x7FFF);
323 index += 2;
324 } else {
325 /* Send i2c data whilst ensuring individual transactions
326 * do not exceed XC_MAX_I2C_WRITE_LENGTH bytes.
327 */
328 index += 2;
329 buf[0] = i2c_sequence[index];
330 buf[1] = i2c_sequence[index + 1];
331 pos = 2;
332 while (pos < len) {
333 if ((len - pos) > XC_MAX_I2C_WRITE_LENGTH - 2)
334 nbytes_to_send =
335 XC_MAX_I2C_WRITE_LENGTH;
336 else
337 nbytes_to_send = (len - pos + 2);
338 for (i = 2; i < nbytes_to_send; i++) {
339 buf[i] = i2c_sequence[index + pos +
340 i - 2];
341 }
342 result = xc_send_i2c_data(priv, buf,
343 nbytes_to_send);
344
345 if (result != XC_RESULT_SUCCESS)
346 return result;
347
348 pos += nbytes_to_send - 2;
349 }
350 index += len;
351 }
352 }
353 return XC_RESULT_SUCCESS;
354 }
355
356 static int xc_initialize(struct xc5000_priv *priv)
357 {
358 dprintk(1, "%s()\n", __func__);
359 return xc_write_reg(priv, XREG_INIT, 0);
360 }
361
362 static int xc_SetTVStandard(struct xc5000_priv *priv,
363 u16 VideoMode, u16 AudioMode)
364 {
365 int ret;
366 dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, VideoMode, AudioMode);
367 dprintk(1, "%s() Standard = %s\n",
368 __func__,
369 XC5000_Standard[priv->video_standard].Name);
370
371 ret = xc_write_reg(priv, XREG_VIDEO_MODE, VideoMode);
372 if (ret == XC_RESULT_SUCCESS)
373 ret = xc_write_reg(priv, XREG_AUDIO_MODE, AudioMode);
374
375 return ret;
376 }
377
378 static int xc_SetSignalSource(struct xc5000_priv *priv, u16 rf_mode)
379 {
380 dprintk(1, "%s(%d) Source = %s\n", __func__, rf_mode,
381 rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE");
382
383 if ((rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE)) {
384 rf_mode = XC_RF_MODE_CABLE;
385 printk(KERN_ERR
386 "%s(), Invalid mode, defaulting to CABLE",
387 __func__);
388 }
389 return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode);
390 }
391
392 static const struct dvb_tuner_ops xc5000_tuner_ops;
393
394 static int xc_set_RF_frequency(struct xc5000_priv *priv, u32 freq_hz)
395 {
396 u16 freq_code;
397
398 dprintk(1, "%s(%u)\n", __func__, freq_hz);
399
400 if ((freq_hz > xc5000_tuner_ops.info.frequency_max) ||
401 (freq_hz < xc5000_tuner_ops.info.frequency_min))
402 return XC_RESULT_OUT_OF_RANGE;
403
404 freq_code = (u16)(freq_hz / 15625);
405
406 /* Starting in firmware version 1.1.44, Xceive recommends using the
407 FINERFREQ for all normal tuning (the doc indicates reg 0x03 should
408 only be used for fast scanning for channel lock) */
409 return xc_write_reg(priv, XREG_FINERFREQ, freq_code);
410 }
411
412
413 static int xc_set_IF_frequency(struct xc5000_priv *priv, u32 freq_khz)
414 {
415 u32 freq_code = (freq_khz * 1024)/1000;
416 dprintk(1, "%s(freq_khz = %d) freq_code = 0x%x\n",
417 __func__, freq_khz, freq_code);
418
419 return xc_write_reg(priv, XREG_IF_OUT, freq_code);
420 }
421
422
423 static int xc_get_ADC_Envelope(struct xc5000_priv *priv, u16 *adc_envelope)
424 {
425 return xc5000_readreg(priv, XREG_ADC_ENV, adc_envelope);
426 }
427
428 static int xc_get_frequency_error(struct xc5000_priv *priv, u32 *freq_error_hz)
429 {
430 int result;
431 u16 regData;
432 u32 tmp;
433
434 result = xc5000_readreg(priv, XREG_FREQ_ERROR, &regData);
435 if (result != XC_RESULT_SUCCESS)
436 return result;
437
438 tmp = (u32)regData;
439 (*freq_error_hz) = (tmp * 15625) / 1000;
440 return result;
441 }
442
443 static int xc_get_lock_status(struct xc5000_priv *priv, u16 *lock_status)
444 {
445 return xc5000_readreg(priv, XREG_LOCK, lock_status);
446 }
447
448 static int xc_get_version(struct xc5000_priv *priv,
449 u8 *hw_majorversion, u8 *hw_minorversion,
450 u8 *fw_majorversion, u8 *fw_minorversion)
451 {
452 u16 data;
453 int result;
454
455 result = xc5000_readreg(priv, XREG_VERSION, &data);
456 if (result != XC_RESULT_SUCCESS)
457 return result;
458
459 (*hw_majorversion) = (data >> 12) & 0x0F;
460 (*hw_minorversion) = (data >> 8) & 0x0F;
461 (*fw_majorversion) = (data >> 4) & 0x0F;
462 (*fw_minorversion) = data & 0x0F;
463
464 return 0;
465 }
466
467 static int xc_get_buildversion(struct xc5000_priv *priv, u16 *buildrev)
468 {
469 return xc5000_readreg(priv, XREG_BUILD, buildrev);
470 }
471
472 static int xc_get_hsync_freq(struct xc5000_priv *priv, u32 *hsync_freq_hz)
473 {
474 u16 regData;
475 int result;
476
477 result = xc5000_readreg(priv, XREG_HSYNC_FREQ, &regData);
478 if (result != XC_RESULT_SUCCESS)
479 return result;
480
481 (*hsync_freq_hz) = ((regData & 0x0fff) * 763)/100;
482 return result;
483 }
484
485 static int xc_get_frame_lines(struct xc5000_priv *priv, u16 *frame_lines)
486 {
487 return xc5000_readreg(priv, XREG_FRAME_LINES, frame_lines);
488 }
489
490 static int xc_get_quality(struct xc5000_priv *priv, u16 *quality)
491 {
492 return xc5000_readreg(priv, XREG_QUALITY, quality);
493 }
494
495 static u16 WaitForLock(struct xc5000_priv *priv)
496 {
497 u16 lockState = 0;
498 int watchDogCount = 40;
499
500 while ((lockState == 0) && (watchDogCount > 0)) {
501 xc_get_lock_status(priv, &lockState);
502 if (lockState != 1) {
503 xc_wait(5);
504 watchDogCount--;
505 }
506 }
507 return lockState;
508 }
509
510 #define XC_TUNE_ANALOG 0
511 #define XC_TUNE_DIGITAL 1
512 static int xc_tune_channel(struct xc5000_priv *priv, u32 freq_hz, int mode)
513 {
514 int found = 0;
515
516 dprintk(1, "%s(%u)\n", __func__, freq_hz);
517
518 if (xc_set_RF_frequency(priv, freq_hz) != XC_RESULT_SUCCESS)
519 return 0;
520
521 if (mode == XC_TUNE_ANALOG) {
522 if (WaitForLock(priv) == 1)
523 found = 1;
524 }
525
526 return found;
527 }
528
529 static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val)
530 {
531 u8 buf[2] = { reg >> 8, reg & 0xff };
532 u8 bval[2] = { 0, 0 };
533 struct i2c_msg msg[2] = {
534 { .addr = priv->i2c_props.addr,
535 .flags = 0, .buf = &buf[0], .len = 2 },
536 { .addr = priv->i2c_props.addr,
537 .flags = I2C_M_RD, .buf = &bval[0], .len = 2 },
538 };
539
540 if (i2c_transfer(priv->i2c_props.adap, msg, 2) != 2) {
541 printk(KERN_WARNING "xc5000: I2C read failed\n");
542 return -EREMOTEIO;
543 }
544
545 *val = (bval[0] << 8) | bval[1];
546 return XC_RESULT_SUCCESS;
547 }
548
549 static int xc5000_fwupload(struct dvb_frontend *fe)
550 {
551 struct xc5000_priv *priv = fe->tuner_priv;
552 const struct firmware *fw;
553 int ret;
554
555 /* request the firmware, this will block and timeout */
556 printk(KERN_INFO "xc5000: waiting for firmware upload (%s)...\n",
557 XC5000_DEFAULT_FIRMWARE);
558
559 ret = request_firmware(&fw, XC5000_DEFAULT_FIRMWARE,
560 priv->i2c_props.adap->dev.parent);
561 if (ret) {
562 printk(KERN_ERR "xc5000: Upload failed. (file not found?)\n");
563 ret = XC_RESULT_RESET_FAILURE;
564 goto out;
565 } else {
566 printk(KERN_DEBUG "xc5000: firmware read %Zu bytes.\n",
567 fw->size);
568 ret = XC_RESULT_SUCCESS;
569 }
570
571 if (fw->size != XC5000_DEFAULT_FIRMWARE_SIZE) {
572 printk(KERN_ERR "xc5000: firmware incorrect size\n");
573 ret = XC_RESULT_RESET_FAILURE;
574 } else {
575 printk(KERN_INFO "xc5000: firmware uploading...\n");
576 ret = xc_load_i2c_sequence(fe, fw->data);
577 printk(KERN_INFO "xc5000: firmware upload complete...\n");
578 }
579
580 out:
581 release_firmware(fw);
582 return ret;
583 }
584
585 static void xc_debug_dump(struct xc5000_priv *priv)
586 {
587 u16 adc_envelope;
588 u32 freq_error_hz = 0;
589 u16 lock_status;
590 u32 hsync_freq_hz = 0;
591 u16 frame_lines;
592 u16 quality;
593 u8 hw_majorversion = 0, hw_minorversion = 0;
594 u8 fw_majorversion = 0, fw_minorversion = 0;
595 u16 fw_buildversion = 0;
596
597 /* Wait for stats to stabilize.
598 * Frame Lines needs two frame times after initial lock
599 * before it is valid.
600 */
601 xc_wait(100);
602
603 xc_get_ADC_Envelope(priv, &adc_envelope);
604 dprintk(1, "*** ADC envelope (0-1023) = %d\n", adc_envelope);
605
606 xc_get_frequency_error(priv, &freq_error_hz);
607 dprintk(1, "*** Frequency error = %d Hz\n", freq_error_hz);
608
609 xc_get_lock_status(priv, &lock_status);
610 dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %d\n",
611 lock_status);
612
613 xc_get_version(priv, &hw_majorversion, &hw_minorversion,
614 &fw_majorversion, &fw_minorversion);
615 xc_get_buildversion(priv, &fw_buildversion);
616 dprintk(1, "*** HW: V%02x.%02x, FW: V%02x.%02x.%04x\n",
617 hw_majorversion, hw_minorversion,
618 fw_majorversion, fw_minorversion, fw_buildversion);
619
620 xc_get_hsync_freq(priv, &hsync_freq_hz);
621 dprintk(1, "*** Horizontal sync frequency = %d Hz\n", hsync_freq_hz);
622
623 xc_get_frame_lines(priv, &frame_lines);
624 dprintk(1, "*** Frame lines = %d\n", frame_lines);
625
626 xc_get_quality(priv, &quality);
627 dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %d\n", quality);
628 }
629
630 static int xc5000_set_params(struct dvb_frontend *fe,
631 struct dvb_frontend_parameters *params)
632 {
633 struct xc5000_priv *priv = fe->tuner_priv;
634 int ret;
635
636 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
637 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
638 dprintk(1, "Unable to load firmware and init tuner\n");
639 return -EINVAL;
640 }
641 }
642
643 dprintk(1, "%s() frequency=%d (Hz)\n", __func__, params->frequency);
644
645 if (fe->ops.info.type == FE_ATSC) {
646 dprintk(1, "%s() ATSC\n", __func__);
647 switch (params->u.vsb.modulation) {
648 case VSB_8:
649 case VSB_16:
650 dprintk(1, "%s() VSB modulation\n", __func__);
651 priv->rf_mode = XC_RF_MODE_AIR;
652 priv->freq_hz = params->frequency - 1750000;
653 priv->bandwidth = BANDWIDTH_6_MHZ;
654 priv->video_standard = DTV6;
655 break;
656 case QAM_64:
657 case QAM_256:
658 case QAM_AUTO:
659 dprintk(1, "%s() QAM modulation\n", __func__);
660 priv->rf_mode = XC_RF_MODE_CABLE;
661 priv->freq_hz = params->frequency - 1750000;
662 priv->bandwidth = BANDWIDTH_6_MHZ;
663 priv->video_standard = DTV6;
664 break;
665 default:
666 return -EINVAL;
667 }
668 } else if (fe->ops.info.type == FE_OFDM) {
669 dprintk(1, "%s() OFDM\n", __func__);
670 switch (params->u.ofdm.bandwidth) {
671 case BANDWIDTH_6_MHZ:
672 priv->bandwidth = BANDWIDTH_6_MHZ;
673 priv->video_standard = DTV6;
674 priv->freq_hz = params->frequency - 1750000;
675 break;
676 case BANDWIDTH_7_MHZ:
677 printk(KERN_ERR "xc5000 bandwidth 7MHz not supported\n");
678 return -EINVAL;
679 case BANDWIDTH_8_MHZ:
680 priv->bandwidth = BANDWIDTH_8_MHZ;
681 priv->video_standard = DTV8;
682 priv->freq_hz = params->frequency - 2750000;
683 break;
684 default:
685 printk(KERN_ERR "xc5000 bandwidth not set!\n");
686 return -EINVAL;
687 }
688 priv->rf_mode = XC_RF_MODE_AIR;
689 } else {
690 printk(KERN_ERR "xc5000 modulation type not supported!\n");
691 return -EINVAL;
692 }
693
694 dprintk(1, "%s() frequency=%d (compensated)\n",
695 __func__, priv->freq_hz);
696
697 ret = xc_SetSignalSource(priv, priv->rf_mode);
698 if (ret != XC_RESULT_SUCCESS) {
699 printk(KERN_ERR
700 "xc5000: xc_SetSignalSource(%d) failed\n",
701 priv->rf_mode);
702 return -EREMOTEIO;
703 }
704
705 ret = xc_SetTVStandard(priv,
706 XC5000_Standard[priv->video_standard].VideoMode,
707 XC5000_Standard[priv->video_standard].AudioMode);
708 if (ret != XC_RESULT_SUCCESS) {
709 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
710 return -EREMOTEIO;
711 }
712
713 ret = xc_set_IF_frequency(priv, priv->if_khz);
714 if (ret != XC_RESULT_SUCCESS) {
715 printk(KERN_ERR "xc5000: xc_Set_IF_frequency(%d) failed\n",
716 priv->if_khz);
717 return -EIO;
718 }
719
720 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_DIGITAL);
721
722 if (debug)
723 xc_debug_dump(priv);
724
725 return 0;
726 }
727
728 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe)
729 {
730 struct xc5000_priv *priv = fe->tuner_priv;
731 int ret;
732 u16 id;
733
734 ret = xc5000_readreg(priv, XREG_PRODUCT_ID, &id);
735 if (ret == XC_RESULT_SUCCESS) {
736 if (id == XC_PRODUCT_ID_FW_NOT_LOADED)
737 ret = XC_RESULT_RESET_FAILURE;
738 else
739 ret = XC_RESULT_SUCCESS;
740 }
741
742 dprintk(1, "%s() returns %s id = 0x%x\n", __func__,
743 ret == XC_RESULT_SUCCESS ? "True" : "False", id);
744 return ret;
745 }
746
747 static int xc5000_set_tv_freq(struct dvb_frontend *fe,
748 struct analog_parameters *params)
749 {
750 struct xc5000_priv *priv = fe->tuner_priv;
751 int ret;
752
753 dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
754 __func__, params->frequency);
755
756 /* Fix me: it could be air. */
757 priv->rf_mode = params->mode;
758 if (params->mode > XC_RF_MODE_CABLE)
759 priv->rf_mode = XC_RF_MODE_CABLE;
760
761 /* params->frequency is in units of 62.5khz */
762 priv->freq_hz = params->frequency * 62500;
763
764 /* FIX ME: Some video standards may have several possible audio
765 standards. We simply default to one of them here.
766 */
767 if (params->std & V4L2_STD_MN) {
768 /* default to BTSC audio standard */
769 priv->video_standard = MN_NTSC_PAL_BTSC;
770 goto tune_channel;
771 }
772
773 if (params->std & V4L2_STD_PAL_BG) {
774 /* default to NICAM audio standard */
775 priv->video_standard = BG_PAL_NICAM;
776 goto tune_channel;
777 }
778
779 if (params->std & V4L2_STD_PAL_I) {
780 /* default to NICAM audio standard */
781 priv->video_standard = I_PAL_NICAM;
782 goto tune_channel;
783 }
784
785 if (params->std & V4L2_STD_PAL_DK) {
786 /* default to NICAM audio standard */
787 priv->video_standard = DK_PAL_NICAM;
788 goto tune_channel;
789 }
790
791 if (params->std & V4L2_STD_SECAM_DK) {
792 /* default to A2 DK1 audio standard */
793 priv->video_standard = DK_SECAM_A2DK1;
794 goto tune_channel;
795 }
796
797 if (params->std & V4L2_STD_SECAM_L) {
798 priv->video_standard = L_SECAM_NICAM;
799 goto tune_channel;
800 }
801
802 if (params->std & V4L2_STD_SECAM_LC) {
803 priv->video_standard = LC_SECAM_NICAM;
804 goto tune_channel;
805 }
806
807 tune_channel:
808 ret = xc_SetSignalSource(priv, priv->rf_mode);
809 if (ret != XC_RESULT_SUCCESS) {
810 printk(KERN_ERR
811 "xc5000: xc_SetSignalSource(%d) failed\n",
812 priv->rf_mode);
813 return -EREMOTEIO;
814 }
815
816 ret = xc_SetTVStandard(priv,
817 XC5000_Standard[priv->video_standard].VideoMode,
818 XC5000_Standard[priv->video_standard].AudioMode);
819 if (ret != XC_RESULT_SUCCESS) {
820 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
821 return -EREMOTEIO;
822 }
823
824 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
825
826 if (debug)
827 xc_debug_dump(priv);
828
829 return 0;
830 }
831
832 static int xc5000_set_radio_freq(struct dvb_frontend *fe,
833 struct analog_parameters *params)
834 {
835 struct xc5000_priv *priv = fe->tuner_priv;
836 int ret = -EINVAL;
837 u8 radio_input;
838
839 dprintk(1, "%s() frequency=%d (in units of khz)\n",
840 __func__, params->frequency);
841
842 if (priv->radio_input == XC5000_RADIO_NOT_CONFIGURED) {
843 dprintk(1, "%s() radio input not configured\n", __func__);
844 return -EINVAL;
845 }
846
847 if (priv->radio_input == XC5000_RADIO_FM1)
848 radio_input = FM_Radio_INPUT1;
849 else if (priv->radio_input == XC5000_RADIO_FM2)
850 radio_input = FM_Radio_INPUT2;
851 else {
852 dprintk(1, "%s() unknown radio input %d\n", __func__,
853 priv->radio_input);
854 return -EINVAL;
855 }
856
857 priv->freq_hz = params->frequency * 125 / 2;
858
859 priv->rf_mode = XC_RF_MODE_AIR;
860
861 ret = xc_SetTVStandard(priv, XC5000_Standard[radio_input].VideoMode,
862 XC5000_Standard[radio_input].AudioMode);
863
864 if (ret != XC_RESULT_SUCCESS) {
865 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
866 return -EREMOTEIO;
867 }
868
869 ret = xc_SetSignalSource(priv, priv->rf_mode);
870 if (ret != XC_RESULT_SUCCESS) {
871 printk(KERN_ERR
872 "xc5000: xc_SetSignalSource(%d) failed\n",
873 priv->rf_mode);
874 return -EREMOTEIO;
875 }
876
877 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
878
879 return 0;
880 }
881
882 static int xc5000_set_analog_params(struct dvb_frontend *fe,
883 struct analog_parameters *params)
884 {
885 struct xc5000_priv *priv = fe->tuner_priv;
886 int ret = -EINVAL;
887
888 if (priv->i2c_props.adap == NULL)
889 return -EINVAL;
890
891 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
892 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
893 dprintk(1, "Unable to load firmware and init tuner\n");
894 return -EINVAL;
895 }
896 }
897
898 switch (params->mode) {
899 case V4L2_TUNER_RADIO:
900 ret = xc5000_set_radio_freq(fe, params);
901 break;
902 case V4L2_TUNER_ANALOG_TV:
903 case V4L2_TUNER_DIGITAL_TV:
904 ret = xc5000_set_tv_freq(fe, params);
905 break;
906 }
907
908 return ret;
909 }
910
911
912 static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq)
913 {
914 struct xc5000_priv *priv = fe->tuner_priv;
915 dprintk(1, "%s()\n", __func__);
916 *freq = priv->freq_hz;
917 return 0;
918 }
919
920 static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
921 {
922 struct xc5000_priv *priv = fe->tuner_priv;
923 dprintk(1, "%s()\n", __func__);
924
925 *bw = priv->bandwidth;
926 return 0;
927 }
928
929 static int xc5000_get_status(struct dvb_frontend *fe, u32 *status)
930 {
931 struct xc5000_priv *priv = fe->tuner_priv;
932 u16 lock_status = 0;
933
934 xc_get_lock_status(priv, &lock_status);
935
936 dprintk(1, "%s() lock_status = 0x%08x\n", __func__, lock_status);
937
938 *status = lock_status;
939
940 return 0;
941 }
942
943 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe)
944 {
945 struct xc5000_priv *priv = fe->tuner_priv;
946 int ret = 0;
947
948 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
949 ret = xc5000_fwupload(fe);
950 if (ret != XC_RESULT_SUCCESS)
951 return ret;
952 }
953
954 /* Start the tuner self-calibration process */
955 ret |= xc_initialize(priv);
956
957 /* Wait for calibration to complete.
958 * We could continue but XC5000 will clock stretch subsequent
959 * I2C transactions until calibration is complete. This way we
960 * don't have to rely on clock stretching working.
961 */
962 xc_wait(100);
963
964 /* Default to "CABLE" mode */
965 ret |= xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE);
966
967 return ret;
968 }
969
970 static int xc5000_sleep(struct dvb_frontend *fe)
971 {
972 int ret;
973
974 dprintk(1, "%s()\n", __func__);
975
976 /* Avoid firmware reload on slow devices */
977 if (no_poweroff)
978 return 0;
979
980 /* According to Xceive technical support, the "powerdown" register
981 was removed in newer versions of the firmware. The "supported"
982 way to sleep the tuner is to pull the reset pin low for 10ms */
983 ret = xc5000_TunerReset(fe);
984 if (ret != XC_RESULT_SUCCESS) {
985 printk(KERN_ERR
986 "xc5000: %s() unable to shutdown tuner\n",
987 __func__);
988 return -EREMOTEIO;
989 } else
990 return XC_RESULT_SUCCESS;
991 }
992
993 static int xc5000_init(struct dvb_frontend *fe)
994 {
995 struct xc5000_priv *priv = fe->tuner_priv;
996 dprintk(1, "%s()\n", __func__);
997
998 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
999 printk(KERN_ERR "xc5000: Unable to initialise tuner\n");
1000 return -EREMOTEIO;
1001 }
1002
1003 if (debug)
1004 xc_debug_dump(priv);
1005
1006 return 0;
1007 }
1008
1009 static int xc5000_release(struct dvb_frontend *fe)
1010 {
1011 struct xc5000_priv *priv = fe->tuner_priv;
1012
1013 dprintk(1, "%s()\n", __func__);
1014
1015 mutex_lock(&xc5000_list_mutex);
1016
1017 if (priv)
1018 hybrid_tuner_release_state(priv);
1019
1020 mutex_unlock(&xc5000_list_mutex);
1021
1022 fe->tuner_priv = NULL;
1023
1024 return 0;
1025 }
1026
1027 static const struct dvb_tuner_ops xc5000_tuner_ops = {
1028 .info = {
1029 .name = "Xceive XC5000",
1030 .frequency_min = 1000000,
1031 .frequency_max = 1023000000,
1032 .frequency_step = 50000,
1033 },
1034
1035 .release = xc5000_release,
1036 .init = xc5000_init,
1037 .sleep = xc5000_sleep,
1038
1039 .set_params = xc5000_set_params,
1040 .set_analog_params = xc5000_set_analog_params,
1041 .get_frequency = xc5000_get_frequency,
1042 .get_bandwidth = xc5000_get_bandwidth,
1043 .get_status = xc5000_get_status
1044 };
1045
1046 struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe,
1047 struct i2c_adapter *i2c,
1048 struct xc5000_config *cfg)
1049 {
1050 struct xc5000_priv *priv = NULL;
1051 int instance;
1052 u16 id = 0;
1053
1054 dprintk(1, "%s(%d-%04x)\n", __func__,
1055 i2c ? i2c_adapter_id(i2c) : -1,
1056 cfg ? cfg->i2c_address : -1);
1057
1058 mutex_lock(&xc5000_list_mutex);
1059
1060 instance = hybrid_tuner_request_state(struct xc5000_priv, priv,
1061 hybrid_tuner_instance_list,
1062 i2c, cfg->i2c_address, "xc5000");
1063 switch (instance) {
1064 case 0:
1065 goto fail;
1066 break;
1067 case 1:
1068 /* new tuner instance */
1069 priv->bandwidth = BANDWIDTH_6_MHZ;
1070 fe->tuner_priv = priv;
1071 break;
1072 default:
1073 /* existing tuner instance */
1074 fe->tuner_priv = priv;
1075 break;
1076 }
1077
1078 if (priv->if_khz == 0) {
1079 /* If the IF hasn't been set yet, use the value provided by
1080 the caller (occurs in hybrid devices where the analog
1081 call to xc5000_attach occurs before the digital side) */
1082 priv->if_khz = cfg->if_khz;
1083 }
1084
1085 if (priv->radio_input == 0)
1086 priv->radio_input = cfg->radio_input;
1087
1088 /* Check if firmware has been loaded. It is possible that another
1089 instance of the driver has loaded the firmware.
1090 */
1091 if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != XC_RESULT_SUCCESS)
1092 goto fail;
1093
1094 switch (id) {
1095 case XC_PRODUCT_ID_FW_LOADED:
1096 printk(KERN_INFO
1097 "xc5000: Successfully identified at address 0x%02x\n",
1098 cfg->i2c_address);
1099 printk(KERN_INFO
1100 "xc5000: Firmware has been loaded previously\n");
1101 break;
1102 case XC_PRODUCT_ID_FW_NOT_LOADED:
1103 printk(KERN_INFO
1104 "xc5000: Successfully identified at address 0x%02x\n",
1105 cfg->i2c_address);
1106 printk(KERN_INFO
1107 "xc5000: Firmware has not been loaded previously\n");
1108 break;
1109 default:
1110 printk(KERN_ERR
1111 "xc5000: Device not found at addr 0x%02x (0x%x)\n",
1112 cfg->i2c_address, id);
1113 goto fail;
1114 }
1115
1116 mutex_unlock(&xc5000_list_mutex);
1117
1118 memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops,
1119 sizeof(struct dvb_tuner_ops));
1120
1121 return fe;
1122 fail:
1123 mutex_unlock(&xc5000_list_mutex);
1124
1125 xc5000_release(fe);
1126 return NULL;
1127 }
1128 EXPORT_SYMBOL(xc5000_attach);
1129
1130 MODULE_AUTHOR("Steven Toth");
1131 MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver");
1132 MODULE_LICENSE("GPL");
ubuntu-bionic-kernel mirror