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