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