]> git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blame - drivers/media/dvb/frontends/xc5000.c
projects / mirror_ubuntu-hirsute-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
V4L/DVB (6885): Add support for the Hauppauge HVR1500Q
[mirror_ubuntu-hirsute-kernel.git] / drivers / media / dvb / frontends / xc5000.c
CommitLineData
aacb9d31
ST		 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/delay.h>
26#include <linux/dvb/frontend.h>
27#include <linux/i2c.h>
28
29#include "dvb_frontend.h"
30
31#include "xc5000.h"
32#include "xc5000_priv.h"
33
34static int debug;
35module_param(debug, int, 0644);
36MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
37
38#define dprintk(level,fmt, arg...) if (debug >= level) \
39 printk(KERN_INFO "%s: " fmt, "xc5000", ## arg)
40
41#define XC5000_DEFAULT_FIRMWARE "dvb-fe-xc5000-1.1.fw"
42#define XC5000_DEFAULT_FIRMWARE_SIZE 12400
43
44/* Misc Defines */
45#define MAX_TV_STANDARD 23
46#define XC_MAX_I2C_WRITE_LENGTH 64
47
48/* Signal Types */
49#define XC_RF_MODE_AIR 0
50#define XC_RF_MODE_CABLE 1
51
52/* Result codes */
53#define XC_RESULT_SUCCESS 0
54#define XC_RESULT_RESET_FAILURE 1
55#define XC_RESULT_I2C_WRITE_FAILURE 2
56#define XC_RESULT_I2C_READ_FAILURE 3
57#define XC_RESULT_OUT_OF_RANGE 5
58
59/* Registers */
60#define XREG_INIT 0x00
61#define XREG_VIDEO_MODE 0x01
62#define XREG_AUDIO_MODE 0x02
63#define XREG_RF_FREQ 0x03
64#define XREG_D_CODE 0x04
65#define XREG_IF_OUT 0x05
66#define XREG_SEEK_MODE 0x07
67#define XREG_POWER_DOWN 0x0A
68#define XREG_SIGNALSOURCE 0x0D /* 0=Air, 1=Cable */
69#define XREG_SMOOTHEDCVBS 0x0E
70#define XREG_XTALFREQ 0x0F
71#define XREG_FINERFFREQ 0x10
72#define XREG_DDIMODE 0x11
73
74#define XREG_ADC_ENV 0x00
75#define XREG_QUALITY 0x01
76#define XREG_FRAME_LINES 0x02
77#define XREG_HSYNC_FREQ 0x03
78#define XREG_LOCK 0x04
79#define XREG_FREQ_ERROR 0x05
80#define XREG_SNR 0x06
81#define XREG_VERSION 0x07
82#define XREG_PRODUCT_ID 0x08
83#define XREG_BUSY 0x09
84
85/*
86 Basic firmware description. This will remain with
87 the driver for documentation purposes.
88
89 This represents an I2C firmware file encoded as a
90 string of unsigned char. Format is as follows:
91
92 char[0 ]=len0_MSB -> len = len_MSB * 256 + len_LSB
93 char[1 ]=len0_LSB -> length of first write transaction
94 char[2 ]=data0 -> first byte to be sent
95 char[3 ]=data1
96 char[4 ]=data2
97 char[ ]=...
98 char[M ]=dataN -> last byte to be sent
99 char[M+1]=len1_MSB -> len = len_MSB * 256 + len_LSB
100 char[M+2]=len1_LSB -> length of second write transaction
101 char[M+3]=data0
102 char[M+4]=data1
103 ...
104 etc.
105
106 The [len] value should be interpreted as follows:
107
108 len= len_MSB _ len_LSB
109 len=1111_1111_1111_1111 : End of I2C_SEQUENCE
110 len=0000_0000_0000_0000 : Reset command: Do hardware reset
111 len=0NNN_NNNN_NNNN_NNNN : Normal transaction: number of bytes = {1:32767)
112 len=1WWW_WWWW_WWWW_WWWW : Wait command: wait for {1:32767} ms
113
114 For the RESET and WAIT commands, the two following bytes will contain
115 immediately the length of the following transaction.
116
117*/
118typedef struct {
119 char *Name;
120 unsigned short AudioMode;
121 unsigned short VideoMode;
122} XC_TV_STANDARD;
123
124/* Tuner standards */
125#define DTV6 17
126
127XC_TV_STANDARD XC5000_Standard[MAX_TV_STANDARD] = {
128 {"M/N-NTSC/PAL-BTSC", 0x0400, 0x8020},
129 {"M/N-NTSC/PAL-A2", 0x0600, 0x8020},
130 {"M/N-NTSC/PAL-EIAJ", 0x0440, 0x8020},
131 {"M/N-NTSC/PAL-Mono", 0x0478, 0x8020},
132 {"B/G-PAL-A2", 0x0A00, 0x8049},
133 {"B/G-PAL-NICAM", 0x0C04, 0x8049},
134 {"B/G-PAL-MONO", 0x0878, 0x8059},
135 {"I-PAL-NICAM", 0x1080, 0x8009},
136 {"I-PAL-NICAM-MONO", 0x0E78, 0x8009},
137 {"D/K-PAL-A2", 0x1600, 0x8009},
138 {"D/K-PAL-NICAM", 0x0E80, 0x8009},
139 {"D/K-PAL-MONO", 0x1478, 0x8009},
140 {"D/K-SECAM-A2 DK1", 0x1200, 0x8009},
141 {"D/K-SECAM-A2 L/DK3",0x0E00, 0x8009},
142 {"D/K-SECAM-A2 MONO", 0x1478, 0x8009},
143 {"L-SECAM-NICAM", 0x8E82, 0x0009},
144 {"L'-SECAM-NICAM", 0x8E82, 0x4009},
145 {"DTV6", 0x00C0, 0x8002},
146 {"DTV8", 0x00C0, 0x800B},
147 {"DTV7/8", 0x00C0, 0x801B},
148 {"DTV7", 0x00C0, 0x8007},
149 {"FM Radio-INPUT2", 0x9802, 0x9002},
150 {"FM Radio-INPUT1", 0x0208, 0x9002}
151};
152
153static int xc5000_writeregs(struct xc5000_priv *priv, u8 *buf, u8 len);
154static int xc5000_readregs(struct xc5000_priv *priv, u8 *buf, u8 len);
155static void xc5000_TunerReset(struct dvb_frontend *fe);
156
157int xc_send_i2c_data(struct xc5000_priv *priv,
158 unsigned char *bytes_to_send, int nb_bytes_to_send)
159{
160 return xc5000_writeregs(priv, bytes_to_send, nb_bytes_to_send)
161 ? XC_RESULT_I2C_WRITE_FAILURE : XC_RESULT_SUCCESS;
162}
163
164int xc_read_i2c_data(struct xc5000_priv *priv, unsigned char *bytes_received,
165 int nb_bytes_to_receive)
166{
167 return xc5000_readregs(priv, bytes_received, nb_bytes_to_receive)
168 ? XC_RESULT_I2C_READ_FAILURE : XC_RESULT_SUCCESS;
169}
170
171int xc_reset(struct dvb_frontend *fe)
172{
173 xc5000_TunerReset(fe);
174 return XC_RESULT_SUCCESS;
175}
176
177void xc_wait(int wait_ms)
178{
179 msleep( wait_ms );
180}
181
182static void xc5000_TunerReset(struct dvb_frontend *fe)
183{
184 struct xc5000_priv *priv = fe->tuner_priv;
185 int ret;
186
187 dprintk(1, "%s()\n", __FUNCTION__);
188
189 if(priv->cfg->tuner_reset) {
190 ret = priv->cfg->tuner_reset(fe);
191 if (ret)
192 printk(KERN_ERR "xc5000: reset failed\n");
193 } else
194 printk(KERN_ERR "xc5000: no tuner reset function, fatal\n");
195}
196
197int xc_write_reg(struct xc5000_priv *priv, unsigned short int regAddr,
198 unsigned short int i2cData)
199{
200 unsigned char buf[4];
201 int WatchDogTimer = 5;
202 int result;
203
204 buf[0] = (regAddr >> 8) & 0xFF;
205 buf[1] = regAddr & 0xFF;
206 buf[2] = (i2cData >> 8) & 0xFF;
207 buf[3] = i2cData & 0xFF;
208 result = xc_send_i2c_data(priv, buf, 4);
209 if ( result == XC_RESULT_SUCCESS) {
210 /* wait for busy flag to clear */
211 while ((WatchDogTimer > 0) && (result == XC_RESULT_SUCCESS)) {
212 buf[0] = 0;
213 buf[1] = XREG_BUSY;
214
215 result = xc_send_i2c_data(priv, buf, 2);
216 if (result == XC_RESULT_SUCCESS) {
217 result = xc_read_i2c_data(priv, buf, 2);
218 if (result == XC_RESULT_SUCCESS) {
219 if ((buf[0] == 0) && (buf[1] == 0)) {
220 /* busy flag cleared */
221 break;
222 } else {
223 xc_wait(100); /* wait 5 ms */
224 WatchDogTimer--;
225 }
226 }
227 }
228 }
229 }
230 if (WatchDogTimer < 0)
231 result = XC_RESULT_I2C_WRITE_FAILURE;
232
233 return result;
234}
235
236int xc_read_reg(struct xc5000_priv *priv, unsigned short int regAddr,
237 unsigned short int *i2cData)
238{
239 unsigned char buf[2];
240 int result;
241
242 buf[0] = (regAddr >> 8) & 0xFF;
243 buf[1] = regAddr & 0xFF;
244 result = xc_send_i2c_data(priv, buf, 2);
245 if (result!=XC_RESULT_SUCCESS)
246 return result;
247
248 result = xc_read_i2c_data(priv, buf, 2);
249 if (result!=XC_RESULT_SUCCESS)
250 return result;
251
252 *i2cData = buf[0] * 256 + buf[1];
253 return result;
254}
255
256int xc_load_i2c_sequence(struct dvb_frontend *fe, unsigned char i2c_sequence[])
257{
258 struct xc5000_priv *priv = fe->tuner_priv;
259
260 int i, nbytes_to_send, result;
261 unsigned int len, pos, index;
262 unsigned char buf[XC_MAX_I2C_WRITE_LENGTH];
263
264 index=0;
265 while ((i2c_sequence[index]!=0xFF) || (i2c_sequence[index+1]!=0xFF)) {
266
267 len = i2c_sequence[index]* 256 + i2c_sequence[index+1];
268 if (len==0x0000) {
269 /* RESET command */
270 result = xc_reset(fe);
271 index += 2;
272 if (result!=XC_RESULT_SUCCESS)
273 return result;
274 } else if (len & 0x8000) {
275 /* WAIT command */
276 xc_wait(len & 0x7FFF);
277 index += 2;
278 } else {
279 /* Send i2c data whilst ensuring individual transactions
280 * do not exceed XC_MAX_I2C_WRITE_LENGTH bytes.
281 */
282 index += 2;
283 buf[0] = i2c_sequence[index];
284 buf[1] = i2c_sequence[index + 1];
285 pos = 2;
286 while (pos < len) {
287 if ((len - pos) > XC_MAX_I2C_WRITE_LENGTH - 2) {
288 nbytes_to_send = XC_MAX_I2C_WRITE_LENGTH;
289 } else {
290 nbytes_to_send = (len - pos + 2);
291 }
292 for (i=2; i<nbytes_to_send; i++) {
293 buf[i] = i2c_sequence[index + pos + i - 2];
294 }
295 result = xc_send_i2c_data(priv, buf, nbytes_to_send);
296
297 if (result!=XC_RESULT_SUCCESS)
298 return result;
299
300 pos += nbytes_to_send - 2;
301 }
302 index += len;
303 }
304 }
305 return XC_RESULT_SUCCESS;
306}
307
308int xc_initialize(struct xc5000_priv *priv)
309{
310 dprintk(1, "%s()\n", __FUNCTION__);
311 return xc_write_reg(priv, XREG_INIT, 0);
312}
313
314int xc_SetTVStandard(struct xc5000_priv *priv, unsigned short int VideoMode,
315 unsigned short int AudioMode)
316{
317 int ret;
318 dprintk(1, "%s(%d,%d)\n", __FUNCTION__, VideoMode, AudioMode);
319 dprintk(1, "%s() Standard = %s\n",
320 __FUNCTION__,
321 XC5000_Standard[priv->video_standard].Name);
322
323 ret = xc_write_reg(priv, XREG_VIDEO_MODE, VideoMode);
324 if (ret == XC_RESULT_SUCCESS)
325 ret = xc_write_reg(priv, XREG_AUDIO_MODE, AudioMode);
326
327 return ret;
328}
329
330int xc_shutdown(struct xc5000_priv *priv)
331{
332 return xc_write_reg(priv, XREG_POWER_DOWN, 0);
333}
334
335int xc_SetSignalSource(struct xc5000_priv *priv, unsigned short int rf_mode)
336{
337 dprintk(1, "%s(%d) Source = %s\n", __FUNCTION__, rf_mode,
338 rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE");
339
340 if( (rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE) )
341 {
342 rf_mode = XC_RF_MODE_CABLE;
343 printk(KERN_ERR
344 "%s(), Invalid mode, defaulting to CABLE",
345 __FUNCTION__);
346 }
347 return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode);
348}
349
350int xc_set_RF_frequency(struct xc5000_priv *priv, long frequency_in_hz)
351{
352 unsigned int frequency_code = (unsigned int)(frequency_in_hz / 15625);
353
354 if ((frequency_in_hz>1023000000) || (frequency_in_hz<1000000))
355 return XC_RESULT_OUT_OF_RANGE;
356
357 return xc_write_reg(priv, XREG_RF_FREQ ,frequency_code);
358}
359
360int xc_FineTune_RF_frequency(struct xc5000_priv *priv, long frequency_in_hz)
361{
362 unsigned int frequency_code = (unsigned int)(frequency_in_hz / 15625);
363 if ((frequency_in_hz>1023000000) || (frequency_in_hz<1000000))
364 return XC_RESULT_OUT_OF_RANGE;
365
366 return xc_write_reg(priv, XREG_FINERFFREQ ,frequency_code);
367}
368
369int xc_set_IF_frequency(struct xc5000_priv *priv, u32 freq_hz)
370{
371 u32 freq_code = (freq_hz * 1024)/1000000;
372 dprintk(1, "%s(%d)\n", __FUNCTION__, freq_hz);
373
374 printk(KERN_ERR "FIXME - Hardcoded IF, FIXME\n");
375 freq_code = 0x1585;
376
377 return xc_write_reg(priv, XREG_IF_OUT ,freq_code);
378}
379
380int xc_set_Xtal_frequency(struct xc5000_priv *priv, long xtalFreqInKHz)
381{
382 unsigned int xtalRatio = (32000 * 0x8000)/xtalFreqInKHz;
383 return xc_write_reg(priv, XREG_XTALFREQ ,xtalRatio);
384}
385
386int xc_get_ADC_Envelope(struct xc5000_priv *priv,
387 unsigned short int *adc_envelope)
388{
389 return xc_read_reg(priv, XREG_ADC_ENV, adc_envelope);
390}
391
392int xc_get_frequency_error(struct xc5000_priv *priv, u32 *frequency_error_hz)
393{
394 int result;
395 unsigned short int regData;
396 u32 tmp;
397
398 result = xc_read_reg(priv, XREG_FREQ_ERROR, &regData);
399 if (result)
400 return result;
401
402 tmp = (u32)regData;
403 (*frequency_error_hz) = (tmp * 15625) / 1000;
404 return result;
405}
406
407int xc_get_lock_status(struct xc5000_priv *priv,
408 unsigned short int *lock_status)
409{
410 return xc_read_reg(priv, XREG_LOCK, lock_status);
411}
412
413int xc_get_version(struct xc5000_priv *priv,
414 unsigned char* hw_majorversion,
415 unsigned char* hw_minorversion,
416 unsigned char* fw_majorversion,
417 unsigned char* fw_minorversion)
418{
419 unsigned short int data;
420 int result;
421
422 result = xc_read_reg(priv, XREG_VERSION, &data);
423 if (result)
424 return result;
425
426 (*hw_majorversion) = (data>>12) & 0x0F;
427 (*hw_minorversion) = (data>>8) & 0x0F;
428 (*fw_majorversion) = (data>>4) & 0x0F;
429 (*fw_minorversion) = (data) & 0x0F;
430
431 return 0;
432}
433
434int xc_get_product_id(struct xc5000_priv *priv, unsigned short int *product_id)
435{
436 return xc_read_reg(priv, XREG_PRODUCT_ID, product_id);
437}
438
439int xc_get_hsync_freq(struct xc5000_priv *priv, int *hsync_freq_hz)
440{
441 unsigned short int regData;
442 int result;
443
444 result = xc_read_reg(priv, XREG_HSYNC_FREQ, &regData);
445 if (result)
446 return result;
447
448 (*hsync_freq_hz) = ((regData & 0x0fff) * 763)/100;
449 return result;
450}
451
452int xc_get_frame_lines(struct xc5000_priv *priv,
453 unsigned short int *frame_lines)
454{
455 return xc_read_reg(priv, XREG_FRAME_LINES, frame_lines);
456}
457
458int xc_get_quality(struct xc5000_priv *priv, unsigned short int *quality)
459{
460 return xc_read_reg(priv, XREG_QUALITY, quality);
461}
462
463unsigned short int WaitForLock(struct xc5000_priv *priv)
464{
465 unsigned short int lockState = 0;
466 int watchDogCount = 40;
467 while ((lockState == 0) && (watchDogCount > 0))
468 {
469 xc_get_lock_status(priv, &lockState);
470 if (lockState != 1)
471 {
472 xc_wait(5);
473 watchDogCount--;
474 }
475 }
476 return lockState;
477}
478
479int xc_tune_channel(struct xc5000_priv *priv, u32 freq)
480{
481 int found = 0;
482
483 dprintk(1, "%s(%d)\n", __FUNCTION__, freq);
484
485 if (xc_set_RF_frequency(priv, freq) != XC_RESULT_SUCCESS)
486 return 0;
487
488 if (WaitForLock(priv)== 1)
489 found = 1;
490
491 return found;
492}
493
494static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val)
495{
496 u8 buf[2] = { reg >> 8, reg & 0xff };
497 u8 bval[2] = { 0, 0 };
498 struct i2c_msg msg[2] = {
499 { .addr = priv->cfg->i2c_address,
500 .flags = 0, .buf = &buf[0], .len = 2 },
501 { .addr = priv->cfg->i2c_address,
502 .flags = I2C_M_RD, .buf = &bval[0], .len = 2 },
503 };
504
505 if (i2c_transfer(priv->i2c, msg, 2) != 2) {
506 printk(KERN_WARNING "xc5000 I2C read failed\n");
507 return -EREMOTEIO;
508 }
509
510 *val = (bval[0] << 8) | bval[1];
511 return 0;
512}
513
514static int xc5000_writeregs(struct xc5000_priv *priv, u8 *buf, u8 len)
515{
516 struct i2c_msg msg = { .addr = priv->cfg->i2c_address,
517 .flags = 0, .buf = buf, .len = len };
518
519 if (i2c_transfer(priv->i2c, &msg, 1) != 1) {
520 printk(KERN_ERR "xc5000 I2C write failed (len=%i)\n",
521 (int)len);
522 return -EREMOTEIO;
523 }
524 return 0;
525}
526
527static int xc5000_readregs(struct xc5000_priv *priv, u8 *buf, u8 len)
528{
529 struct i2c_msg msg = { .addr = priv->cfg->i2c_address,
530 .flags = I2C_M_RD, .buf = buf, .len = len };
531
532 if (i2c_transfer(priv->i2c, &msg, 1) != 1) {
533 printk(KERN_ERR "xc5000 I2C read failed (len=%i)\n",(int)len);
534 return -EREMOTEIO;
535 }
536 return 0;
537}
538
539static int xc5000_fwupload(struct dvb_frontend* fe)
540{
541 struct xc5000_priv *priv = fe->tuner_priv;
542 const struct firmware *fw;
543 int ret;
544
545 /* request the firmware, this will block until someone uploads it */
546 printk(KERN_INFO "xc5000: waiting for firmware upload (%s)...\n",
547 XC5000_DEFAULT_FIRMWARE);
548
549 if(!priv->cfg->request_firmware) {
550 printk(KERN_ERR "xc5000: no firmware callback, fatal\n");
551 return -EIO;
552 }
553
554 ret = priv->cfg->request_firmware(fe, &fw, XC5000_DEFAULT_FIRMWARE);
555 if (ret) {
556 printk(KERN_ERR "xc5000: Upload failed. (file not found?)\n");
557 ret = XC_RESULT_RESET_FAILURE;
558 } else {
559 printk(KERN_INFO "xc5000: firmware read %d bytes.\n", fw->size);
560 ret = XC_RESULT_SUCCESS;
561 }
562
563 if(fw->size != XC5000_DEFAULT_FIRMWARE_SIZE) {
564 printk(KERN_ERR "xc5000: firmware incorrect size\n");
565 ret = XC_RESULT_RESET_FAILURE;
566 } else {
567 printk(KERN_INFO "xc5000: firmware upload\n");
568 ret = xc_load_i2c_sequence(fe, fw->data );
569 }
570
571 release_firmware(fw);
572 return ret;
573}
574
575void xc_debug_dump(struct xc5000_priv *priv)
576{
577 unsigned short adc_envelope;
578 u32 frequency_error_hz;
579 unsigned short lock_status;
580 unsigned char hw_majorversion, hw_minorversion = 0;
581 unsigned char fw_majorversion, fw_minorversion = 0;
582 int hsync_freq_hz;
583 unsigned short frame_lines;
584 unsigned short quality;
585
586 /* Wait for stats to stabilize.
587 * Frame Lines needs two frame times after initial lock
588 * before it is valid.
589 */
590 xc_wait( 100 );
591
592 xc_get_ADC_Envelope(priv, &adc_envelope );
593 dprintk(1, "*** ADC envelope (0-1023) = %u\n", adc_envelope);
594
595 xc_get_frequency_error(priv, &frequency_error_hz );
596 dprintk(1, "*** Frequency error = %d Hz\n", frequency_error_hz);
597
598 xc_get_lock_status(priv, &lock_status );
599 dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %u\n",
600 lock_status);
601
602 xc_get_version(priv, &hw_majorversion, &hw_minorversion,
603 &fw_majorversion, &fw_minorversion );
604 dprintk(1, "*** HW: V%02x.%02x, FW: V%02x.%02x\n",
605 hw_majorversion, hw_minorversion,
606 fw_majorversion, fw_minorversion);
607
608 xc_get_hsync_freq(priv, &hsync_freq_hz );
609 dprintk(1, "*** Horizontal sync frequency = %u Hz\n", hsync_freq_hz);
610
611 xc_get_frame_lines(priv, &frame_lines );
612 dprintk(1, "*** Frame lines = %u\n", frame_lines);
613
614 xc_get_quality(priv, &quality );
615 dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %u\n", quality);
616}
617
618static int xc5000_set_params(struct dvb_frontend *fe,
619 struct dvb_frontend_parameters *params)
620{
621 struct xc5000_priv *priv = fe->tuner_priv;
622
623 dprintk(1, "%s() frequency=%d\n", __FUNCTION__, params->frequency);
624
625 priv->frequency = params->frequency - 1750000;
626 priv->bandwidth = 6;
627 priv->video_standard = DTV6;
628
629 switch(params->u.vsb.modulation) {
630 case VSB_8:
631 case VSB_16:
632 dprintk(1, "%s() VSB modulation\n", __FUNCTION__);
633 priv->rf_mode = XC_RF_MODE_AIR;
634 break;
635 case QAM_64:
636 case QAM_256:
637 case QAM_AUTO:
638 dprintk(1, "%s() QAM modulation\n", __FUNCTION__);
639 priv->rf_mode = XC_RF_MODE_CABLE;
640 break;
641 default:
642 return -EINVAL;
643 }
644
645 dprintk(1, "%s() frequency=%d (compensated)\n",
646 __FUNCTION__, priv->frequency);
647
648 /* FIXME: check result codes */
649 xc_SetSignalSource(priv, priv->rf_mode);
650
651 xc_SetTVStandard(priv,
652 XC5000_Standard[priv->video_standard].VideoMode,
653 XC5000_Standard[priv->video_standard].AudioMode);
654
655 xc_set_IF_frequency(priv, priv->cfg->if_frequency);
656 xc_tune_channel(priv, priv->frequency);
657 xc_debug_dump(priv);
658
659 return 0;
660}
661
662static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq)
663{
664 struct xc5000_priv *priv = fe->tuner_priv;
665 dprintk(1, "%s()\n", __FUNCTION__);
666 *freq = priv->frequency;
667 return 0;
668}
669
670static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
671{
672 struct xc5000_priv *priv = fe->tuner_priv;
673 dprintk(1, "%s()\n", __FUNCTION__);
674 *bw = priv->bandwidth;
675 return 0;
676}
677
678static int xc5000_get_status(struct dvb_frontend *fe, u32 *status)
679{
680 struct xc5000_priv *priv = fe->tuner_priv;
681 unsigned short int lock_status = 0;
682
683 xc_get_lock_status(priv, &lock_status);
684
685 dprintk(1, "%s() lock_status = 0x%08x\n", __FUNCTION__, lock_status);
686
687 *status = lock_status;
688
689 return 0;
690}
691
692int xc_load_fw_and_init_tuner(struct dvb_frontend *fe)
693{
694 struct xc5000_priv *priv = fe->tuner_priv;
695 int ret;
696
697 if(priv->fwloaded == 0) {
698 ret = xc5000_fwupload(fe);
699 if( ret != XC_RESULT_SUCCESS )
700 return -EREMOTEIO;
701
702 priv->fwloaded = 1;
703 }
704
705 /* Start the tuner self-calibration process */
706 ret |= xc_initialize(priv);
707
708 /* Wait for calibration to complete.
709 * We could continue but XC5000 will clock stretch subsequent
710 * I2C transactions until calibration is complete. This way we
711 * don't have to rely on clock stretching working.
712 */
713 xc_wait( 100 );
714
715 /* Default to "CABLE" mode */
716 ret |= xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE);
717
718 return ret;
719}
720
721static int xc5000_init(struct dvb_frontend *fe)
722{
723 struct xc5000_priv *priv = fe->tuner_priv;
724 dprintk(1, "%s()\n", __FUNCTION__);
725
726 xc_load_fw_and_init_tuner(fe);
727 xc_debug_dump(priv);
728
729 return 0;
730}
731
732static int xc5000_release(struct dvb_frontend *fe)
733{
734 dprintk(1, "%s()\n", __FUNCTION__);
735 kfree(fe->tuner_priv);
736 fe->tuner_priv = NULL;
737 return 0;
738}
739
740static const struct dvb_tuner_ops xc5000_tuner_ops = {
741 .info = {
742 .name = "Xceive XC5000",
743 .frequency_min = 1000000,
744 .frequency_max = 1023000000,
745 .frequency_step = 50000,
746 },
747
748 .release = xc5000_release,
749 .init = xc5000_init,
750
751 .set_params = xc5000_set_params,
752 .get_frequency = xc5000_get_frequency,
753 .get_bandwidth = xc5000_get_bandwidth,
754 .get_status = xc5000_get_status
755};
756
757struct dvb_frontend * xc5000_attach(struct dvb_frontend *fe,
758 struct i2c_adapter *i2c,
759 struct xc5000_config *cfg)
760{
761 struct xc5000_priv *priv = NULL;
762 u16 id = 0;
763
764 dprintk(1, "%s()\n", __FUNCTION__);
765
766 priv = kzalloc(sizeof(struct xc5000_priv), GFP_KERNEL);
767 if (priv == NULL)
768 return NULL;
769
770 priv->cfg = cfg;
771 priv->bandwidth = 6000000; /* 6MHz */
772 priv->i2c = i2c;
773 priv->fwloaded = 0;
774
775 if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != 0) {
776 kfree(priv);
777 return NULL;
778 }
779
780 if ( (id != 0x2000) && (id != 0x1388) ) {
781 printk(KERN_ERR
782 "xc5000: Device not found at addr 0x%02x (0x%x)\n",
783 cfg->i2c_address, id);
784 kfree(priv);
785 return NULL;
786 }
787
788 printk(KERN_INFO "xc5000: successfully identified at address 0x%02x\n",
789 cfg->i2c_address);
790
791 memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops,
792 sizeof(struct dvb_tuner_ops));
793
794 fe->tuner_priv = priv;
795
796 return fe;
797}
798EXPORT_SYMBOL(xc5000_attach);
799
800MODULE_AUTHOR("Steven Toth");
801MODULE_DESCRIPTION("Xceive XC5000 silicon tuner driver");
802MODULE_LICENSE("GPL");
Ubuntu Hirsute Linux kernel mirror