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