blob: 06f66fedfff3a8f58eeff03588c2bab3009241af [file] [log] [blame]
Steven Tothaacb9d32007-12-18 01:55:51 -03001/*
2 * Driver for Xceive XC5000 "QAM/8VSB single chip tuner"
3 *
4 * Copyright (c) 2007 Xceive Corporation
Steven Toth6d897612008-09-03 17:12:12 -03005 * Copyright (c) 2007 Steven Toth <stoth@linuxtv.org>
Devin Heitmuellere80858e2009-05-14 21:31:11 -03006 * Copyright (c) 2009 Devin Heitmueller <dheitmueller@kernellabs.com>
Steven Tothaacb9d32007-12-18 01:55:51 -03007 *
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>
Steven Toth49170192008-01-15 21:57:14 -030026#include <linux/videodev2.h>
Steven Tothaacb9d32007-12-18 01:55:51 -030027#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"
Michael Krufky89fd2852008-09-06 11:44:53 -030034#include "tuner-i2c.h"
Steven Tothaacb9d32007-12-18 01:55:51 -030035
36static int debug;
37module_param(debug, int, 0644);
38MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
39
Devin Heitmuellerb6bd5eb2009-04-28 13:53:38 -030040static int no_poweroff;
41module_param(no_poweroff, int, 0644);
42MODULE_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
Michael Krufky89fd2852008-09-06 11:44:53 -030046static DEFINE_MUTEX(xc5000_list_mutex);
47static LIST_HEAD(hybrid_tuner_instance_list);
48
Steven Toth8f3cd532008-10-16 20:29:38 -030049#define dprintk(level, fmt, arg...) if (debug >= level) \
Steven Tothaacb9d32007-12-18 01:55:51 -030050 printk(KERN_INFO "%s: " fmt, "xc5000", ## arg)
51
Michael Krufkyffb41232008-09-06 10:52:30 -030052struct xc5000_priv {
Michael Krufky89fd2852008-09-06 11:44:53 -030053 struct tuner_i2c_props i2c_props;
54 struct list_head hybrid_tuner_instance_list;
Michael Krufkyffb41232008-09-06 10:52:30 -030055
Michael Krufky2a6003c2008-09-06 13:54:45 -030056 u32 if_khz;
Michael Krufky409328a2012-04-16 15:21:51 -030057 u16 xtal_khz;
Michael Krufkyffb41232008-09-06 10:52:30 -030058 u32 freq_hz;
59 u32 bandwidth;
60 u8 video_standard;
61 u8 rf_mode;
Devin Heitmueller496e9052009-09-24 13:27:24 -030062 u8 radio_input;
Michael Krufky76efb0ba2012-02-06 19:40:32 -030063
Michael Krufky6fab81d2012-02-08 14:57:39 -030064 int chip_id;
Michael Krufkyffb41232008-09-06 10:52:30 -030065};
66
Steven Tothaacb9d32007-12-18 01:55:51 -030067/* Misc Defines */
Dmitri Belimov724dcbf2011-02-01 05:25:19 -030068#define MAX_TV_STANDARD 24
Steven Tothaacb9d32007-12-18 01:55:51 -030069#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
Steven Toth27c685a2008-01-05 16:50:14 -030082/* Product id */
83#define XC_PRODUCT_ID_FW_NOT_LOADED 0x2000
84#define XC_PRODUCT_ID_FW_LOADED 0x1388
85
Steven Tothaacb9d32007-12-18 01:55:51 -030086/* 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
Devin Heitmueller7f05b532009-04-02 22:02:39 -030094#define XREG_POWER_DOWN 0x0A /* Obsolete */
Dmitri Belimov724dcbf2011-02-01 05:25:19 -030095/* Set the output amplitude - SIF for analog, DTVP/DTVN for digital */
96#define XREG_OUTPUT_AMP 0x0B
Steven Tothaacb9d32007-12-18 01:55:51 -030097#define XREG_SIGNALSOURCE 0x0D /* 0=Air, 1=Cable */
98#define XREG_SMOOTHEDCVBS 0x0E
99#define XREG_XTALFREQ 0x0F
Devin Heitmueller81c4dfe2009-04-02 22:40:29 -0300100#define XREG_FINERFREQ 0x10
Steven Tothaacb9d32007-12-18 01:55:51 -0300101#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
Devin Heitmuellerbae7b7d2009-04-02 22:24:38 -0300113#define XREG_BUILD 0x0D
Devin Heitmueller7c287f12012-08-06 22:46:56 -0300114#define XREG_TOTALGAIN 0x0F
Steven Tothaacb9d32007-12-18 01:55:51 -0300115
116/*
117 Basic firmware description. This will remain with
118 the driver for documentation purposes.
119
120 This represents an I2C firmware file encoded as a
121 string of unsigned char. Format is as follows:
122
123 char[0 ]=len0_MSB -> len = len_MSB * 256 + len_LSB
124 char[1 ]=len0_LSB -> length of first write transaction
125 char[2 ]=data0 -> first byte to be sent
126 char[3 ]=data1
127 char[4 ]=data2
128 char[ ]=...
129 char[M ]=dataN -> last byte to be sent
130 char[M+1]=len1_MSB -> len = len_MSB * 256 + len_LSB
131 char[M+2]=len1_LSB -> length of second write transaction
132 char[M+3]=data0
133 char[M+4]=data1
134 ...
135 etc.
136
137 The [len] value should be interpreted as follows:
138
139 len= len_MSB _ len_LSB
140 len=1111_1111_1111_1111 : End of I2C_SEQUENCE
141 len=0000_0000_0000_0000 : Reset command: Do hardware reset
142 len=0NNN_NNNN_NNNN_NNNN : Normal transaction: number of bytes = {1:32767)
143 len=1WWW_WWWW_WWWW_WWWW : Wait command: wait for {1:32767} ms
144
145 For the RESET and WAIT commands, the two following bytes will contain
146 immediately the length of the following transaction.
147
148*/
Steven Toth8f3cd532008-10-16 20:29:38 -0300149struct XC_TV_STANDARD {
Steven Tothaacb9d32007-12-18 01:55:51 -0300150 char *Name;
Steven Tothe12671c2007-12-20 01:14:43 -0300151 u16 AudioMode;
152 u16 VideoMode;
Steven Toth8f3cd532008-10-16 20:29:38 -0300153};
Steven Tothaacb9d32007-12-18 01:55:51 -0300154
155/* Tuner standards */
Steven Toth27c685a2008-01-05 16:50:14 -0300156#define MN_NTSC_PAL_BTSC 0
157#define MN_NTSC_PAL_A2 1
158#define MN_NTSC_PAL_EIAJ 2
159#define MN_NTSC_PAL_Mono 3
160#define BG_PAL_A2 4
161#define BG_PAL_NICAM 5
162#define BG_PAL_MONO 6
163#define I_PAL_NICAM 7
164#define I_PAL_NICAM_MONO 8
165#define DK_PAL_A2 9
166#define DK_PAL_NICAM 10
167#define DK_PAL_MONO 11
168#define DK_SECAM_A2DK1 12
169#define DK_SECAM_A2LDK3 13
170#define DK_SECAM_A2MONO 14
171#define L_SECAM_NICAM 15
172#define LC_SECAM_NICAM 16
173#define DTV6 17
174#define DTV8 18
175#define DTV7_8 19
176#define DTV7 20
177#define FM_Radio_INPUT2 21
178#define FM_Radio_INPUT1 22
Dmitri Belimov724dcbf2011-02-01 05:25:19 -0300179#define FM_Radio_INPUT1_MONO 23
Steven Tothaacb9d32007-12-18 01:55:51 -0300180
Steven Toth8f3cd532008-10-16 20:29:38 -0300181static struct XC_TV_STANDARD XC5000_Standard[MAX_TV_STANDARD] = {
Steven Tothaacb9d32007-12-18 01:55:51 -0300182 {"M/N-NTSC/PAL-BTSC", 0x0400, 0x8020},
183 {"M/N-NTSC/PAL-A2", 0x0600, 0x8020},
184 {"M/N-NTSC/PAL-EIAJ", 0x0440, 0x8020},
185 {"M/N-NTSC/PAL-Mono", 0x0478, 0x8020},
186 {"B/G-PAL-A2", 0x0A00, 0x8049},
187 {"B/G-PAL-NICAM", 0x0C04, 0x8049},
188 {"B/G-PAL-MONO", 0x0878, 0x8059},
189 {"I-PAL-NICAM", 0x1080, 0x8009},
190 {"I-PAL-NICAM-MONO", 0x0E78, 0x8009},
191 {"D/K-PAL-A2", 0x1600, 0x8009},
192 {"D/K-PAL-NICAM", 0x0E80, 0x8009},
193 {"D/K-PAL-MONO", 0x1478, 0x8009},
194 {"D/K-SECAM-A2 DK1", 0x1200, 0x8009},
Steven Toth8f3cd532008-10-16 20:29:38 -0300195 {"D/K-SECAM-A2 L/DK3", 0x0E00, 0x8009},
Steven Tothaacb9d32007-12-18 01:55:51 -0300196 {"D/K-SECAM-A2 MONO", 0x1478, 0x8009},
197 {"L-SECAM-NICAM", 0x8E82, 0x0009},
198 {"L'-SECAM-NICAM", 0x8E82, 0x4009},
199 {"DTV6", 0x00C0, 0x8002},
200 {"DTV8", 0x00C0, 0x800B},
201 {"DTV7/8", 0x00C0, 0x801B},
202 {"DTV7", 0x00C0, 0x8007},
203 {"FM Radio-INPUT2", 0x9802, 0x9002},
Dmitri Belimov724dcbf2011-02-01 05:25:19 -0300204 {"FM Radio-INPUT1", 0x0208, 0x9002},
205 {"FM Radio-INPUT1_MONO", 0x0278, 0x9002}
Steven Tothaacb9d32007-12-18 01:55:51 -0300206};
207
Michael Krufkyddea4272012-02-07 02:39:36 -0300208
209struct xc5000_fw_cfg {
210 char *name;
211 u16 size;
212};
213
Tim Gardner3422f2a62012-07-25 09:15:19 -0300214#define XC5000A_FIRMWARE "dvb-fe-xc5000-1.6.114.fw"
Michael Krufkya3db60b2012-02-08 15:03:07 -0300215static const struct xc5000_fw_cfg xc5000a_1_6_114 = {
Tim Gardner3422f2a62012-07-25 09:15:19 -0300216 .name = XC5000A_FIRMWARE,
Michael Krufky76efb0ba2012-02-06 19:40:32 -0300217 .size = 12401,
218};
219
Tim Gardner3422f2a62012-07-25 09:15:19 -0300220#define XC5000C_FIRMWARE "dvb-fe-xc5000c-41.024.5.fw"
Michael Krufky7d3d0d82012-04-16 14:59:32 -0300221static const struct xc5000_fw_cfg xc5000c_41_024_5 = {
Tim Gardner3422f2a62012-07-25 09:15:19 -0300222 .name = XC5000C_FIRMWARE,
Michael Krufky7d3d0d82012-04-16 14:59:32 -0300223 .size = 16497,
Michael Krufkyd8398802012-02-07 01:16:27 -0300224};
225
Michael Krufkya3db60b2012-02-08 15:03:07 -0300226static inline const struct xc5000_fw_cfg *xc5000_assign_firmware(int chip_id)
Michael Krufkyddea4272012-02-07 02:39:36 -0300227{
Michael Krufky6fab81d2012-02-08 14:57:39 -0300228 switch (chip_id) {
Michael Krufkyddea4272012-02-07 02:39:36 -0300229 default:
Michael Krufky6fab81d2012-02-08 14:57:39 -0300230 case XC5000A:
Michael Krufkyddea4272012-02-07 02:39:36 -0300231 return &xc5000a_1_6_114;
Michael Krufky6fab81d2012-02-08 14:57:39 -0300232 case XC5000C:
Michael Krufky7d3d0d82012-04-16 14:59:32 -0300233 return &xc5000c_41_024_5;
Michael Krufkyddea4272012-02-07 02:39:36 -0300234 }
235}
236
Devin Heitmueller8e4c6792008-11-16 20:41:07 -0300237static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe);
Devin Heitmueller91bd6252008-11-15 23:29:11 -0300238static int xc5000_is_firmware_loaded(struct dvb_frontend *fe);
Devin Heitmuellerbdd33562008-11-16 20:17:14 -0300239static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val);
Devin Heitmueller91bd6252008-11-15 23:29:11 -0300240static int xc5000_TunerReset(struct dvb_frontend *fe);
Steven Tothaacb9d32007-12-18 01:55:51 -0300241
Steven Tothe12671c2007-12-20 01:14:43 -0300242static int xc_send_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
Steven Tothaacb9d32007-12-18 01:55:51 -0300243{
Devin Heitmuellerd7800d42008-11-16 20:20:06 -0300244 struct i2c_msg msg = { .addr = priv->i2c_props.addr,
245 .flags = 0, .buf = buf, .len = len };
246
247 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
248 printk(KERN_ERR "xc5000: I2C write failed (len=%i)\n", len);
249 return XC_RESULT_I2C_WRITE_FAILURE;
250 }
251 return XC_RESULT_SUCCESS;
Steven Tothaacb9d32007-12-18 01:55:51 -0300252}
253
Mauro Carvalho Chehab1cdffda2010-07-05 18:38:46 -0300254#if 0
Devin Heitmuellerbdd33562008-11-16 20:17:14 -0300255/* This routine is never used because the only time we read data from the
256 i2c bus is when we read registers, and we want that to be an atomic i2c
257 transaction in case we are on a multi-master bus */
Steven Tothe12671c2007-12-20 01:14:43 -0300258static int xc_read_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
Steven Tothaacb9d32007-12-18 01:55:51 -0300259{
Devin Heitmuellerbdd33562008-11-16 20:17:14 -0300260 struct i2c_msg msg = { .addr = priv->i2c_props.addr,
261 .flags = I2C_M_RD, .buf = buf, .len = len };
262
263 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
264 printk(KERN_ERR "xc5000 I2C read failed (len=%i)\n", len);
265 return -EREMOTEIO;
266 }
267 return 0;
Steven Tothaacb9d32007-12-18 01:55:51 -0300268}
Mauro Carvalho Chehab1cdffda2010-07-05 18:38:46 -0300269#endif
Steven Tothaacb9d32007-12-18 01:55:51 -0300270
Dmitri Belimov47433192010-05-18 04:30:11 -0300271static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val)
272{
273 u8 buf[2] = { reg >> 8, reg & 0xff };
274 u8 bval[2] = { 0, 0 };
275 struct i2c_msg msg[2] = {
276 { .addr = priv->i2c_props.addr,
277 .flags = 0, .buf = &buf[0], .len = 2 },
278 { .addr = priv->i2c_props.addr,
279 .flags = I2C_M_RD, .buf = &bval[0], .len = 2 },
280 };
281
282 if (i2c_transfer(priv->i2c_props.adap, msg, 2) != 2) {
283 printk(KERN_WARNING "xc5000: I2C read failed\n");
284 return -EREMOTEIO;
285 }
286
287 *val = (bval[0] << 8) | bval[1];
288 return XC_RESULT_SUCCESS;
289}
290
Steven Tothe12671c2007-12-20 01:14:43 -0300291static void xc_wait(int wait_ms)
Steven Tothaacb9d32007-12-18 01:55:51 -0300292{
Steven Tothe12671c2007-12-20 01:14:43 -0300293 msleep(wait_ms);
Steven Tothaacb9d32007-12-18 01:55:51 -0300294}
295
Devin Heitmueller91bd6252008-11-15 23:29:11 -0300296static int xc5000_TunerReset(struct dvb_frontend *fe)
Steven Tothaacb9d32007-12-18 01:55:51 -0300297{
298 struct xc5000_priv *priv = fe->tuner_priv;
299 int ret;
300
Harvey Harrison271ddbf2008-04-08 23:20:00 -0300301 dprintk(1, "%s()\n", __func__);
Steven Tothaacb9d32007-12-18 01:55:51 -0300302
Michael Krufkyd7cba042008-09-12 13:31:45 -0300303 if (fe->callback) {
304 ret = fe->callback(((fe->dvb) && (fe->dvb->priv)) ?
Michael Krufky30650962008-09-06 14:56:58 -0300305 fe->dvb->priv :
306 priv->i2c_props.adap->algo_data,
Michael Krufkyd7cba042008-09-12 13:31:45 -0300307 DVB_FRONTEND_COMPONENT_TUNER,
Michael Krufky30650962008-09-06 14:56:58 -0300308 XC5000_TUNER_RESET, 0);
Devin Heitmueller91bd6252008-11-15 23:29:11 -0300309 if (ret) {
Steven Tothaacb9d32007-12-18 01:55:51 -0300310 printk(KERN_ERR "xc5000: reset failed\n");
Devin Heitmueller91bd6252008-11-15 23:29:11 -0300311 return XC_RESULT_RESET_FAILURE;
312 }
313 } else {
Steven Toth27c685a2008-01-05 16:50:14 -0300314 printk(KERN_ERR "xc5000: no tuner reset callback function, fatal\n");
Devin Heitmueller91bd6252008-11-15 23:29:11 -0300315 return XC_RESULT_RESET_FAILURE;
316 }
317 return XC_RESULT_SUCCESS;
Steven Tothaacb9d32007-12-18 01:55:51 -0300318}
319
Steven Tothe12671c2007-12-20 01:14:43 -0300320static int xc_write_reg(struct xc5000_priv *priv, u16 regAddr, u16 i2cData)
Steven Tothaacb9d32007-12-18 01:55:51 -0300321{
Steven Tothe12671c2007-12-20 01:14:43 -0300322 u8 buf[4];
Devin Heitmuellera37791c2009-05-04 23:29:17 -0300323 int WatchDogTimer = 100;
Steven Tothaacb9d32007-12-18 01:55:51 -0300324 int result;
325
326 buf[0] = (regAddr >> 8) & 0xFF;
327 buf[1] = regAddr & 0xFF;
328 buf[2] = (i2cData >> 8) & 0xFF;
329 buf[3] = i2cData & 0xFF;
330 result = xc_send_i2c_data(priv, buf, 4);
Steven Tothe12671c2007-12-20 01:14:43 -0300331 if (result == XC_RESULT_SUCCESS) {
Steven Tothaacb9d32007-12-18 01:55:51 -0300332 /* wait for busy flag to clear */
333 while ((WatchDogTimer > 0) && (result == XC_RESULT_SUCCESS)) {
Mauro Carvalho Chehab1cdffda2010-07-05 18:38:46 -0300334 result = xc5000_readreg(priv, XREG_BUSY, (u16 *)buf);
Steven Tothaacb9d32007-12-18 01:55:51 -0300335 if (result == XC_RESULT_SUCCESS) {
Dmitri Belimov47433192010-05-18 04:30:11 -0300336 if ((buf[0] == 0) && (buf[1] == 0)) {
337 /* busy flag cleared */
Steven Tothaacb9d32007-12-18 01:55:51 -0300338 break;
Dmitri Belimov47433192010-05-18 04:30:11 -0300339 } else {
340 xc_wait(5); /* wait 5 ms */
341 WatchDogTimer--;
Steven Tothaacb9d32007-12-18 01:55:51 -0300342 }
343 }
344 }
345 }
Devin Heitmueller0a3dabb2012-08-06 22:46:57 -0300346 if (WatchDogTimer <= 0)
Steven Tothaacb9d32007-12-18 01:55:51 -0300347 result = XC_RESULT_I2C_WRITE_FAILURE;
348
349 return result;
350}
351
David Woodhousec63e87e2008-05-24 00:13:34 +0100352static int xc_load_i2c_sequence(struct dvb_frontend *fe, const u8 *i2c_sequence)
Steven Tothaacb9d32007-12-18 01:55:51 -0300353{
354 struct xc5000_priv *priv = fe->tuner_priv;
355
356 int i, nbytes_to_send, result;
357 unsigned int len, pos, index;
Steven Tothe12671c2007-12-20 01:14:43 -0300358 u8 buf[XC_MAX_I2C_WRITE_LENGTH];
Steven Tothaacb9d32007-12-18 01:55:51 -0300359
Steven Toth8f3cd532008-10-16 20:29:38 -0300360 index = 0;
361 while ((i2c_sequence[index] != 0xFF) ||
362 (i2c_sequence[index + 1] != 0xFF)) {
363 len = i2c_sequence[index] * 256 + i2c_sequence[index+1];
Steven Tothe12671c2007-12-20 01:14:43 -0300364 if (len == 0x0000) {
Steven Tothaacb9d32007-12-18 01:55:51 -0300365 /* RESET command */
Devin Heitmueller91bd6252008-11-15 23:29:11 -0300366 result = xc5000_TunerReset(fe);
Steven Tothaacb9d32007-12-18 01:55:51 -0300367 index += 2;
Steven Tothe12671c2007-12-20 01:14:43 -0300368 if (result != XC_RESULT_SUCCESS)
Steven Tothaacb9d32007-12-18 01:55:51 -0300369 return result;
370 } else if (len & 0x8000) {
371 /* WAIT command */
372 xc_wait(len & 0x7FFF);
373 index += 2;
374 } else {
375 /* Send i2c data whilst ensuring individual transactions
376 * do not exceed XC_MAX_I2C_WRITE_LENGTH bytes.
377 */
378 index += 2;
379 buf[0] = i2c_sequence[index];
380 buf[1] = i2c_sequence[index + 1];
381 pos = 2;
382 while (pos < len) {
Steven Toth8f3cd532008-10-16 20:29:38 -0300383 if ((len - pos) > XC_MAX_I2C_WRITE_LENGTH - 2)
384 nbytes_to_send =
385 XC_MAX_I2C_WRITE_LENGTH;
386 else
Steven Tothaacb9d32007-12-18 01:55:51 -0300387 nbytes_to_send = (len - pos + 2);
Steven Toth8f3cd532008-10-16 20:29:38 -0300388 for (i = 2; i < nbytes_to_send; i++) {
389 buf[i] = i2c_sequence[index + pos +
390 i - 2];
Steven Tothaacb9d32007-12-18 01:55:51 -0300391 }
Steven Toth8f3cd532008-10-16 20:29:38 -0300392 result = xc_send_i2c_data(priv, buf,
393 nbytes_to_send);
Steven Tothaacb9d32007-12-18 01:55:51 -0300394
Steven Tothe12671c2007-12-20 01:14:43 -0300395 if (result != XC_RESULT_SUCCESS)
Steven Tothaacb9d32007-12-18 01:55:51 -0300396 return result;
397
398 pos += nbytes_to_send - 2;
399 }
400 index += len;
401 }
402 }
403 return XC_RESULT_SUCCESS;
404}
405
Steven Tothe12671c2007-12-20 01:14:43 -0300406static int xc_initialize(struct xc5000_priv *priv)
Steven Tothaacb9d32007-12-18 01:55:51 -0300407{
Harvey Harrison271ddbf2008-04-08 23:20:00 -0300408 dprintk(1, "%s()\n", __func__);
Steven Tothaacb9d32007-12-18 01:55:51 -0300409 return xc_write_reg(priv, XREG_INIT, 0);
410}
411
Steven Tothe12671c2007-12-20 01:14:43 -0300412static int xc_SetTVStandard(struct xc5000_priv *priv,
413 u16 VideoMode, u16 AudioMode)
Steven Tothaacb9d32007-12-18 01:55:51 -0300414{
415 int ret;
Harvey Harrison271ddbf2008-04-08 23:20:00 -0300416 dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, VideoMode, AudioMode);
Steven Tothaacb9d32007-12-18 01:55:51 -0300417 dprintk(1, "%s() Standard = %s\n",
Harvey Harrison271ddbf2008-04-08 23:20:00 -0300418 __func__,
Steven Tothaacb9d32007-12-18 01:55:51 -0300419 XC5000_Standard[priv->video_standard].Name);
420
421 ret = xc_write_reg(priv, XREG_VIDEO_MODE, VideoMode);
422 if (ret == XC_RESULT_SUCCESS)
423 ret = xc_write_reg(priv, XREG_AUDIO_MODE, AudioMode);
424
425 return ret;
426}
427
Steven Tothe12671c2007-12-20 01:14:43 -0300428static int xc_SetSignalSource(struct xc5000_priv *priv, u16 rf_mode)
Steven Tothaacb9d32007-12-18 01:55:51 -0300429{
Harvey Harrison271ddbf2008-04-08 23:20:00 -0300430 dprintk(1, "%s(%d) Source = %s\n", __func__, rf_mode,
Steven Tothaacb9d32007-12-18 01:55:51 -0300431 rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE");
432
Steven Toth8f3cd532008-10-16 20:29:38 -0300433 if ((rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE)) {
Steven Tothaacb9d32007-12-18 01:55:51 -0300434 rf_mode = XC_RF_MODE_CABLE;
435 printk(KERN_ERR
436 "%s(), Invalid mode, defaulting to CABLE",
Harvey Harrison271ddbf2008-04-08 23:20:00 -0300437 __func__);
Steven Tothaacb9d32007-12-18 01:55:51 -0300438 }
439 return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode);
440}
441
Steven Tothe12671c2007-12-20 01:14:43 -0300442static const struct dvb_tuner_ops xc5000_tuner_ops;
443
444static int xc_set_RF_frequency(struct xc5000_priv *priv, u32 freq_hz)
Steven Tothaacb9d32007-12-18 01:55:51 -0300445{
Steven Tothe12671c2007-12-20 01:14:43 -0300446 u16 freq_code;
Steven Tothaacb9d32007-12-18 01:55:51 -0300447
Harvey Harrison271ddbf2008-04-08 23:20:00 -0300448 dprintk(1, "%s(%u)\n", __func__, freq_hz);
Steven Tothaacb9d32007-12-18 01:55:51 -0300449
Steven Tothe12671c2007-12-20 01:14:43 -0300450 if ((freq_hz > xc5000_tuner_ops.info.frequency_max) ||
451 (freq_hz < xc5000_tuner_ops.info.frequency_min))
452 return XC_RESULT_OUT_OF_RANGE;
Steven Tothaacb9d32007-12-18 01:55:51 -0300453
Steven Tothe12671c2007-12-20 01:14:43 -0300454 freq_code = (u16)(freq_hz / 15625);
455
Devin Heitmueller81c4dfe2009-04-02 22:40:29 -0300456 /* Starting in firmware version 1.1.44, Xceive recommends using the
457 FINERFREQ for all normal tuning (the doc indicates reg 0x03 should
458 only be used for fast scanning for channel lock) */
459 return xc_write_reg(priv, XREG_FINERFREQ, freq_code);
Steven Tothaacb9d32007-12-18 01:55:51 -0300460}
461
Steven Tothe12671c2007-12-20 01:14:43 -0300462
463static int xc_set_IF_frequency(struct xc5000_priv *priv, u32 freq_khz)
Steven Tothaacb9d32007-12-18 01:55:51 -0300464{
Steven Tothe12671c2007-12-20 01:14:43 -0300465 u32 freq_code = (freq_khz * 1024)/1000;
466 dprintk(1, "%s(freq_khz = %d) freq_code = 0x%x\n",
Harvey Harrison271ddbf2008-04-08 23:20:00 -0300467 __func__, freq_khz, freq_code);
Steven Tothe12671c2007-12-20 01:14:43 -0300468
469 return xc_write_reg(priv, XREG_IF_OUT, freq_code);
Steven Tothaacb9d32007-12-18 01:55:51 -0300470}
471
Steven Tothe12671c2007-12-20 01:14:43 -0300472
473static int xc_get_ADC_Envelope(struct xc5000_priv *priv, u16 *adc_envelope)
Steven Tothaacb9d32007-12-18 01:55:51 -0300474{
Devin Heitmuellerbdd33562008-11-16 20:17:14 -0300475 return xc5000_readreg(priv, XREG_ADC_ENV, adc_envelope);
Steven Tothaacb9d32007-12-18 01:55:51 -0300476}
477
Steven Tothe12671c2007-12-20 01:14:43 -0300478static int xc_get_frequency_error(struct xc5000_priv *priv, u32 *freq_error_hz)
Steven Tothaacb9d32007-12-18 01:55:51 -0300479{
480 int result;
Steven Tothe12671c2007-12-20 01:14:43 -0300481 u16 regData;
Steven Tothaacb9d32007-12-18 01:55:51 -0300482 u32 tmp;
483
Devin Heitmuellerbdd33562008-11-16 20:17:14 -0300484 result = xc5000_readreg(priv, XREG_FREQ_ERROR, &regData);
Devin Heitmueller7988fc22008-11-16 20:23:19 -0300485 if (result != XC_RESULT_SUCCESS)
Steven Tothaacb9d32007-12-18 01:55:51 -0300486 return result;
487
488 tmp = (u32)regData;
Steven Tothe12671c2007-12-20 01:14:43 -0300489 (*freq_error_hz) = (tmp * 15625) / 1000;
Steven Tothaacb9d32007-12-18 01:55:51 -0300490 return result;
491}
492
Steven Tothe12671c2007-12-20 01:14:43 -0300493static int xc_get_lock_status(struct xc5000_priv *priv, u16 *lock_status)
Steven Tothaacb9d32007-12-18 01:55:51 -0300494{
Devin Heitmuellerbdd33562008-11-16 20:17:14 -0300495 return xc5000_readreg(priv, XREG_LOCK, lock_status);
Steven Tothaacb9d32007-12-18 01:55:51 -0300496}
497
Steven Tothe12671c2007-12-20 01:14:43 -0300498static int xc_get_version(struct xc5000_priv *priv,
499 u8 *hw_majorversion, u8 *hw_minorversion,
500 u8 *fw_majorversion, u8 *fw_minorversion)
Steven Tothaacb9d32007-12-18 01:55:51 -0300501{
Steven Tothe12671c2007-12-20 01:14:43 -0300502 u16 data;
Steven Tothaacb9d32007-12-18 01:55:51 -0300503 int result;
504
Devin Heitmuellerbdd33562008-11-16 20:17:14 -0300505 result = xc5000_readreg(priv, XREG_VERSION, &data);
Devin Heitmueller7988fc22008-11-16 20:23:19 -0300506 if (result != XC_RESULT_SUCCESS)
Steven Tothaacb9d32007-12-18 01:55:51 -0300507 return result;
508
Steven Tothe12671c2007-12-20 01:14:43 -0300509 (*hw_majorversion) = (data >> 12) & 0x0F;
510 (*hw_minorversion) = (data >> 8) & 0x0F;
511 (*fw_majorversion) = (data >> 4) & 0x0F;
512 (*fw_minorversion) = data & 0x0F;
Steven Tothaacb9d32007-12-18 01:55:51 -0300513
514 return 0;
515}
516
Devin Heitmuellerbae7b7d2009-04-02 22:24:38 -0300517static int xc_get_buildversion(struct xc5000_priv *priv, u16 *buildrev)
518{
519 return xc5000_readreg(priv, XREG_BUILD, buildrev);
520}
521
Steven Tothe12671c2007-12-20 01:14:43 -0300522static int xc_get_hsync_freq(struct xc5000_priv *priv, u32 *hsync_freq_hz)
Steven Tothaacb9d32007-12-18 01:55:51 -0300523{
Steven Tothe12671c2007-12-20 01:14:43 -0300524 u16 regData;
Steven Tothaacb9d32007-12-18 01:55:51 -0300525 int result;
526
Devin Heitmuellerbdd33562008-11-16 20:17:14 -0300527 result = xc5000_readreg(priv, XREG_HSYNC_FREQ, &regData);
Devin Heitmueller7988fc22008-11-16 20:23:19 -0300528 if (result != XC_RESULT_SUCCESS)
Steven Tothaacb9d32007-12-18 01:55:51 -0300529 return result;
530
531 (*hsync_freq_hz) = ((regData & 0x0fff) * 763)/100;
532 return result;
533}
534
Steven Tothe12671c2007-12-20 01:14:43 -0300535static int xc_get_frame_lines(struct xc5000_priv *priv, u16 *frame_lines)
Steven Tothaacb9d32007-12-18 01:55:51 -0300536{
Devin Heitmuellerbdd33562008-11-16 20:17:14 -0300537 return xc5000_readreg(priv, XREG_FRAME_LINES, frame_lines);
Steven Tothaacb9d32007-12-18 01:55:51 -0300538}
539
Steven Tothe12671c2007-12-20 01:14:43 -0300540static int xc_get_quality(struct xc5000_priv *priv, u16 *quality)
Steven Tothaacb9d32007-12-18 01:55:51 -0300541{
Devin Heitmuellerbdd33562008-11-16 20:17:14 -0300542 return xc5000_readreg(priv, XREG_QUALITY, quality);
Steven Tothaacb9d32007-12-18 01:55:51 -0300543}
544
Devin Heitmueller7c287f12012-08-06 22:46:56 -0300545static int xc_get_analogsnr(struct xc5000_priv *priv, u16 *snr)
546{
547 return xc5000_readreg(priv, XREG_SNR, snr);
548}
549
550static int xc_get_totalgain(struct xc5000_priv *priv, u16 *totalgain)
551{
552 return xc5000_readreg(priv, XREG_TOTALGAIN, totalgain);
553}
554
Steven Tothe12671c2007-12-20 01:14:43 -0300555static u16 WaitForLock(struct xc5000_priv *priv)
Steven Tothaacb9d32007-12-18 01:55:51 -0300556{
Steven Tothe12671c2007-12-20 01:14:43 -0300557 u16 lockState = 0;
Steven Tothaacb9d32007-12-18 01:55:51 -0300558 int watchDogCount = 40;
Steven Tothe12671c2007-12-20 01:14:43 -0300559
560 while ((lockState == 0) && (watchDogCount > 0)) {
Steven Tothaacb9d32007-12-18 01:55:51 -0300561 xc_get_lock_status(priv, &lockState);
Steven Tothe12671c2007-12-20 01:14:43 -0300562 if (lockState != 1) {
Steven Tothaacb9d32007-12-18 01:55:51 -0300563 xc_wait(5);
564 watchDogCount--;
565 }
566 }
567 return lockState;
568}
569
Devin Heitmuellera78baac2008-11-16 20:48:31 -0300570#define XC_TUNE_ANALOG 0
571#define XC_TUNE_DIGITAL 1
572static int xc_tune_channel(struct xc5000_priv *priv, u32 freq_hz, int mode)
Steven Tothaacb9d32007-12-18 01:55:51 -0300573{
574 int found = 0;
575
Harvey Harrison271ddbf2008-04-08 23:20:00 -0300576 dprintk(1, "%s(%u)\n", __func__, freq_hz);
Steven Tothaacb9d32007-12-18 01:55:51 -0300577
Steven Tothe12671c2007-12-20 01:14:43 -0300578 if (xc_set_RF_frequency(priv, freq_hz) != XC_RESULT_SUCCESS)
Steven Tothaacb9d32007-12-18 01:55:51 -0300579 return 0;
580
Devin Heitmuellera78baac2008-11-16 20:48:31 -0300581 if (mode == XC_TUNE_ANALOG) {
582 if (WaitForLock(priv) == 1)
583 found = 1;
584 }
Steven Tothaacb9d32007-12-18 01:55:51 -0300585
586 return found;
587}
588
Michael Krufky7d3d0d82012-04-16 14:59:32 -0300589static int xc_set_xtal(struct dvb_frontend *fe)
590{
591 struct xc5000_priv *priv = fe->tuner_priv;
592 int ret = XC_RESULT_SUCCESS;
593
594 switch (priv->chip_id) {
595 default:
596 case XC5000A:
597 /* 32.000 MHz xtal is default */
598 break;
599 case XC5000C:
600 switch (priv->xtal_khz) {
601 default:
602 case 32000:
603 /* 32.000 MHz xtal is default */
604 break;
605 case 31875:
606 /* 31.875 MHz xtal configuration */
607 ret = xc_write_reg(priv, 0x000f, 0x8081);
608 break;
609 }
610 break;
611 }
612 return ret;
613}
Steven Tothaacb9d32007-12-18 01:55:51 -0300614
Steven Toth8f3cd532008-10-16 20:29:38 -0300615static int xc5000_fwupload(struct dvb_frontend *fe)
Steven Tothaacb9d32007-12-18 01:55:51 -0300616{
617 struct xc5000_priv *priv = fe->tuner_priv;
618 const struct firmware *fw;
619 int ret;
Michael Krufkya3db60b2012-02-08 15:03:07 -0300620 const struct xc5000_fw_cfg *desired_fw =
621 xc5000_assign_firmware(priv->chip_id);
Steven Tothaacb9d32007-12-18 01:55:51 -0300622
Steven Tothe12671c2007-12-20 01:14:43 -0300623 /* request the firmware, this will block and timeout */
624 printk(KERN_INFO "xc5000: waiting for firmware upload (%s)...\n",
Michael Krufky6fab81d2012-02-08 14:57:39 -0300625 desired_fw->name);
Steven Tothe12671c2007-12-20 01:14:43 -0300626
Michael Krufky6fab81d2012-02-08 14:57:39 -0300627 ret = request_firmware(&fw, desired_fw->name,
Jean Delvaree9785252009-04-26 05:43:59 -0300628 priv->i2c_props.adap->dev.parent);
Steven Tothaacb9d32007-12-18 01:55:51 -0300629 if (ret) {
630 printk(KERN_ERR "xc5000: Upload failed. (file not found?)\n");
631 ret = XC_RESULT_RESET_FAILURE;
Steven Toth5ea60532008-01-24 22:29:46 -0300632 goto out;
Steven Tothaacb9d32007-12-18 01:55:51 -0300633 } else {
Devin Heitmueller34a0db92009-04-02 22:45:17 -0300634 printk(KERN_DEBUG "xc5000: firmware read %Zu bytes.\n",
Michael Krufky3f514512007-12-21 16:20:23 -0300635 fw->size);
Steven Tothaacb9d32007-12-18 01:55:51 -0300636 ret = XC_RESULT_SUCCESS;
637 }
638
Michael Krufky6fab81d2012-02-08 14:57:39 -0300639 if (fw->size != desired_fw->size) {
Steven Tothaacb9d32007-12-18 01:55:51 -0300640 printk(KERN_ERR "xc5000: firmware incorrect size\n");
641 ret = XC_RESULT_RESET_FAILURE;
642 } else {
Devin Heitmueller34a0db92009-04-02 22:45:17 -0300643 printk(KERN_INFO "xc5000: firmware uploading...\n");
Steven Toth8f3cd532008-10-16 20:29:38 -0300644 ret = xc_load_i2c_sequence(fe, fw->data);
Michael Krufky7d3d0d82012-04-16 14:59:32 -0300645 if (XC_RESULT_SUCCESS == ret)
646 ret = xc_set_xtal(fe);
Michael Krufky35320672012-04-16 15:06:45 -0300647 if (XC_RESULT_SUCCESS == ret)
648 printk(KERN_INFO "xc5000: firmware upload complete...\n");
649 else
650 printk(KERN_ERR "xc5000: firmware upload failed...\n");
Steven Tothaacb9d32007-12-18 01:55:51 -0300651 }
652
Steven Toth5ea60532008-01-24 22:29:46 -0300653out:
Steven Tothaacb9d32007-12-18 01:55:51 -0300654 release_firmware(fw);
655 return ret;
656}
657
Steven Tothe12671c2007-12-20 01:14:43 -0300658static void xc_debug_dump(struct xc5000_priv *priv)
Steven Tothaacb9d32007-12-18 01:55:51 -0300659{
Steven Tothe12671c2007-12-20 01:14:43 -0300660 u16 adc_envelope;
661 u32 freq_error_hz = 0;
662 u16 lock_status;
663 u32 hsync_freq_hz = 0;
664 u16 frame_lines;
665 u16 quality;
Devin Heitmueller7c287f12012-08-06 22:46:56 -0300666 u16 snr;
667 u16 totalgain;
Steven Tothe12671c2007-12-20 01:14:43 -0300668 u8 hw_majorversion = 0, hw_minorversion = 0;
669 u8 fw_majorversion = 0, fw_minorversion = 0;
Devin Heitmuellerbae7b7d2009-04-02 22:24:38 -0300670 u16 fw_buildversion = 0;
Steven Tothaacb9d32007-12-18 01:55:51 -0300671
672 /* Wait for stats to stabilize.
673 * Frame Lines needs two frame times after initial lock
674 * before it is valid.
675 */
Steven Tothe12671c2007-12-20 01:14:43 -0300676 xc_wait(100);
Steven Tothaacb9d32007-12-18 01:55:51 -0300677
Steven Tothe12671c2007-12-20 01:14:43 -0300678 xc_get_ADC_Envelope(priv, &adc_envelope);
679 dprintk(1, "*** ADC envelope (0-1023) = %d\n", adc_envelope);
Steven Tothaacb9d32007-12-18 01:55:51 -0300680
Steven Tothe12671c2007-12-20 01:14:43 -0300681 xc_get_frequency_error(priv, &freq_error_hz);
682 dprintk(1, "*** Frequency error = %d Hz\n", freq_error_hz);
Steven Tothaacb9d32007-12-18 01:55:51 -0300683
Steven Tothe12671c2007-12-20 01:14:43 -0300684 xc_get_lock_status(priv, &lock_status);
685 dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %d\n",
Steven Tothaacb9d32007-12-18 01:55:51 -0300686 lock_status);
687
688 xc_get_version(priv, &hw_majorversion, &hw_minorversion,
Steven Tothe12671c2007-12-20 01:14:43 -0300689 &fw_majorversion, &fw_minorversion);
Devin Heitmuellerbae7b7d2009-04-02 22:24:38 -0300690 xc_get_buildversion(priv, &fw_buildversion);
691 dprintk(1, "*** HW: V%02x.%02x, FW: V%02x.%02x.%04x\n",
Steven Tothaacb9d32007-12-18 01:55:51 -0300692 hw_majorversion, hw_minorversion,
Devin Heitmuellerbae7b7d2009-04-02 22:24:38 -0300693 fw_majorversion, fw_minorversion, fw_buildversion);
Steven Tothaacb9d32007-12-18 01:55:51 -0300694
Steven Tothe12671c2007-12-20 01:14:43 -0300695 xc_get_hsync_freq(priv, &hsync_freq_hz);
696 dprintk(1, "*** Horizontal sync frequency = %d Hz\n", hsync_freq_hz);
Steven Tothaacb9d32007-12-18 01:55:51 -0300697
Steven Tothe12671c2007-12-20 01:14:43 -0300698 xc_get_frame_lines(priv, &frame_lines);
699 dprintk(1, "*** Frame lines = %d\n", frame_lines);
Steven Tothaacb9d32007-12-18 01:55:51 -0300700
Steven Tothe12671c2007-12-20 01:14:43 -0300701 xc_get_quality(priv, &quality);
Devin Heitmueller1aa9c4872012-08-06 22:46:55 -0300702 dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %d\n", quality & 0x07);
Devin Heitmueller7c287f12012-08-06 22:46:56 -0300703
704 xc_get_analogsnr(priv, &snr);
705 dprintk(1, "*** Unweighted analog SNR = %d dB\n", snr & 0x3f);
706
707 xc_get_totalgain(priv, &totalgain);
708 dprintk(1, "*** Total gain = %d.%d dB\n", totalgain / 256,
709 (totalgain % 256) * 100 / 256);
Steven Tothaacb9d32007-12-18 01:55:51 -0300710}
711
Mauro Carvalho Chehab14d24d12011-12-24 12:24:33 -0300712static int xc5000_set_params(struct dvb_frontend *fe)
Steven Tothaacb9d32007-12-18 01:55:51 -0300713{
Mauro Carvalho Chehabfd66c452011-12-17 20:36:57 -0300714 int ret, b;
Steven Tothaacb9d32007-12-18 01:55:51 -0300715 struct xc5000_priv *priv = fe->tuner_priv;
Mauro Carvalho Chehabfd66c452011-12-17 20:36:57 -0300716 u32 bw = fe->dtv_property_cache.bandwidth_hz;
717 u32 freq = fe->dtv_property_cache.frequency;
718 u32 delsys = fe->dtv_property_cache.delivery_system;
Steven Tothaacb9d32007-12-18 01:55:51 -0300719
Devin Heitmuellerfc7a74b2012-08-06 22:47:01 -0300720 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
721 dprintk(1, "Unable to load firmware and init tuner\n");
722 return -EINVAL;
Devin Heitmueller760c4662009-10-13 23:44:14 -0300723 }
Devin Heitmueller8e4c6792008-11-16 20:41:07 -0300724
Mauro Carvalho Chehabfd66c452011-12-17 20:36:57 -0300725 dprintk(1, "%s() frequency=%d (Hz)\n", __func__, freq);
Steven Tothaacb9d32007-12-18 01:55:51 -0300726
Mauro Carvalho Chehabfd66c452011-12-17 20:36:57 -0300727 switch (delsys) {
728 case SYS_ATSC:
729 dprintk(1, "%s() VSB modulation\n", __func__);
730 priv->rf_mode = XC_RF_MODE_AIR;
731 priv->freq_hz = freq - 1750000;
Mauro Carvalho Chehabfd66c452011-12-17 20:36:57 -0300732 priv->video_standard = DTV6;
733 break;
734 case SYS_DVBC_ANNEX_B:
735 dprintk(1, "%s() QAM modulation\n", __func__);
736 priv->rf_mode = XC_RF_MODE_CABLE;
737 priv->freq_hz = freq - 1750000;
Mauro Carvalho Chehabfd66c452011-12-17 20:36:57 -0300738 priv->video_standard = DTV6;
739 break;
Mauro Carvalho Chehab5cf73ce2012-07-05 14:07:59 -0300740 case SYS_ISDBT:
741 /* All ISDB-T are currently for 6 MHz bw */
742 if (!bw)
743 bw = 6000000;
744 /* fall to OFDM handling */
745 case SYS_DMBTH:
Mauro Carvalho Chehabfd66c452011-12-17 20:36:57 -0300746 case SYS_DVBT:
747 case SYS_DVBT2:
David T.L. Wong6c990802009-05-04 22:59:58 -0300748 dprintk(1, "%s() OFDM\n", __func__);
Mauro Carvalho Chehabfd66c452011-12-17 20:36:57 -0300749 switch (bw) {
750 case 6000000:
David T.L. Wong6c990802009-05-04 22:59:58 -0300751 priv->video_standard = DTV6;
Mauro Carvalho Chehabfd66c452011-12-17 20:36:57 -0300752 priv->freq_hz = freq - 1750000;
David T.L. Wong6c990802009-05-04 22:59:58 -0300753 break;
Mauro Carvalho Chehabfd66c452011-12-17 20:36:57 -0300754 case 7000000:
Mauro Carvalho Chehab0433cd22011-12-09 08:01:01 -0200755 priv->video_standard = DTV7;
Mauro Carvalho Chehabfd66c452011-12-17 20:36:57 -0300756 priv->freq_hz = freq - 2250000;
Mauro Carvalho Chehab0433cd22011-12-09 08:01:01 -0200757 break;
Mauro Carvalho Chehabfd66c452011-12-17 20:36:57 -0300758 case 8000000:
David T.L. Wong6c990802009-05-04 22:59:58 -0300759 priv->video_standard = DTV8;
Mauro Carvalho Chehabfd66c452011-12-17 20:36:57 -0300760 priv->freq_hz = freq - 2750000;
David T.L. Wong6c990802009-05-04 22:59:58 -0300761 break;
762 default:
763 printk(KERN_ERR "xc5000 bandwidth not set!\n");
764 return -EINVAL;
765 }
Steven Tothaacb9d32007-12-18 01:55:51 -0300766 priv->rf_mode = XC_RF_MODE_AIR;
Mauro Carvalho Chehabfd66c452011-12-17 20:36:57 -0300767 case SYS_DVBC_ANNEX_A:
768 case SYS_DVBC_ANNEX_C:
769 dprintk(1, "%s() QAM modulation\n", __func__);
770 priv->rf_mode = XC_RF_MODE_CABLE;
771 if (bw <= 6000000) {
Mauro Carvalho Chehabfd66c452011-12-17 20:36:57 -0300772 priv->video_standard = DTV6;
773 priv->freq_hz = freq - 1750000;
774 b = 6;
775 } else if (bw <= 7000000) {
Mauro Carvalho Chehabfd66c452011-12-17 20:36:57 -0300776 priv->video_standard = DTV7;
777 priv->freq_hz = freq - 2250000;
778 b = 7;
779 } else {
Mauro Carvalho Chehabfd66c452011-12-17 20:36:57 -0300780 priv->video_standard = DTV7_8;
781 priv->freq_hz = freq - 2750000;
782 b = 8;
Igor M. Liplianine80edce2011-01-25 17:03:00 -0300783 }
Mauro Carvalho Chehabfd66c452011-12-17 20:36:57 -0300784 dprintk(1, "%s() Bandwidth %dMHz (%d)\n", __func__,
785 b, bw);
786 break;
787 default:
788 printk(KERN_ERR "xc5000: delivery system is not supported!\n");
Steven Tothaacb9d32007-12-18 01:55:51 -0300789 return -EINVAL;
790 }
791
Mauro Carvalho Chehabfd66c452011-12-17 20:36:57 -0300792 dprintk(1, "%s() frequency=%d (compensated to %d)\n",
793 __func__, freq, priv->freq_hz);
Steven Tothaacb9d32007-12-18 01:55:51 -0300794
Steven Tothe12671c2007-12-20 01:14:43 -0300795 ret = xc_SetSignalSource(priv, priv->rf_mode);
796 if (ret != XC_RESULT_SUCCESS) {
797 printk(KERN_ERR
798 "xc5000: xc_SetSignalSource(%d) failed\n",
799 priv->rf_mode);
800 return -EREMOTEIO;
801 }
Steven Tothaacb9d32007-12-18 01:55:51 -0300802
Steven Tothe12671c2007-12-20 01:14:43 -0300803 ret = xc_SetTVStandard(priv,
Steven Tothaacb9d32007-12-18 01:55:51 -0300804 XC5000_Standard[priv->video_standard].VideoMode,
805 XC5000_Standard[priv->video_standard].AudioMode);
Steven Tothe12671c2007-12-20 01:14:43 -0300806 if (ret != XC_RESULT_SUCCESS) {
807 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
808 return -EREMOTEIO;
809 }
Steven Tothaacb9d32007-12-18 01:55:51 -0300810
Michael Krufky2a6003c2008-09-06 13:54:45 -0300811 ret = xc_set_IF_frequency(priv, priv->if_khz);
Steven Tothe12671c2007-12-20 01:14:43 -0300812 if (ret != XC_RESULT_SUCCESS) {
813 printk(KERN_ERR "xc5000: xc_Set_IF_frequency(%d) failed\n",
Michael Krufky2a6003c2008-09-06 13:54:45 -0300814 priv->if_khz);
Steven Tothe12671c2007-12-20 01:14:43 -0300815 return -EIO;
816 }
817
Dmitri Belimov724dcbf2011-02-01 05:25:19 -0300818 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x8a);
819
Devin Heitmuellera78baac2008-11-16 20:48:31 -0300820 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_DIGITAL);
Steven Tothe12671c2007-12-20 01:14:43 -0300821
822 if (debug)
823 xc_debug_dump(priv);
Steven Tothaacb9d32007-12-18 01:55:51 -0300824
Mauro Carvalho Chehabc6f56e72011-12-26 20:02:28 -0300825 priv->bandwidth = bw;
826
Steven Tothaacb9d32007-12-18 01:55:51 -0300827 return 0;
828}
829
Steven Tothe470d812008-06-21 21:06:02 -0300830static int xc5000_is_firmware_loaded(struct dvb_frontend *fe)
831{
832 struct xc5000_priv *priv = fe->tuner_priv;
833 int ret;
834 u16 id;
835
836 ret = xc5000_readreg(priv, XREG_PRODUCT_ID, &id);
837 if (ret == XC_RESULT_SUCCESS) {
838 if (id == XC_PRODUCT_ID_FW_NOT_LOADED)
839 ret = XC_RESULT_RESET_FAILURE;
840 else
841 ret = XC_RESULT_SUCCESS;
842 }
843
844 dprintk(1, "%s() returns %s id = 0x%x\n", __func__,
845 ret == XC_RESULT_SUCCESS ? "True" : "False", id);
846 return ret;
847}
848
Beholder Intl. Ltd. Dmitry Belimovd7009cd2009-09-24 13:13:28 -0300849static int xc5000_set_tv_freq(struct dvb_frontend *fe,
Steven Toth27c685a2008-01-05 16:50:14 -0300850 struct analog_parameters *params)
851{
852 struct xc5000_priv *priv = fe->tuner_priv;
853 int ret;
854
Steven Toth27c685a2008-01-05 16:50:14 -0300855 dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
Harvey Harrison271ddbf2008-04-08 23:20:00 -0300856 __func__, params->frequency);
Steven Toth27c685a2008-01-05 16:50:14 -0300857
Mauro Carvalho Chehab1fab14e2009-03-03 14:35:41 -0300858 /* Fix me: it could be air. */
859 priv->rf_mode = params->mode;
860 if (params->mode > XC_RF_MODE_CABLE)
861 priv->rf_mode = XC_RF_MODE_CABLE;
Steven Toth27c685a2008-01-05 16:50:14 -0300862
863 /* params->frequency is in units of 62.5khz */
864 priv->freq_hz = params->frequency * 62500;
865
866 /* FIX ME: Some video standards may have several possible audio
867 standards. We simply default to one of them here.
868 */
Steven Toth8f3cd532008-10-16 20:29:38 -0300869 if (params->std & V4L2_STD_MN) {
Steven Toth27c685a2008-01-05 16:50:14 -0300870 /* default to BTSC audio standard */
871 priv->video_standard = MN_NTSC_PAL_BTSC;
872 goto tune_channel;
873 }
874
Steven Toth8f3cd532008-10-16 20:29:38 -0300875 if (params->std & V4L2_STD_PAL_BG) {
Steven Toth27c685a2008-01-05 16:50:14 -0300876 /* default to NICAM audio standard */
877 priv->video_standard = BG_PAL_NICAM;
878 goto tune_channel;
879 }
880
Steven Toth8f3cd532008-10-16 20:29:38 -0300881 if (params->std & V4L2_STD_PAL_I) {
Steven Toth27c685a2008-01-05 16:50:14 -0300882 /* default to NICAM audio standard */
883 priv->video_standard = I_PAL_NICAM;
884 goto tune_channel;
885 }
886
Steven Toth8f3cd532008-10-16 20:29:38 -0300887 if (params->std & V4L2_STD_PAL_DK) {
Steven Toth27c685a2008-01-05 16:50:14 -0300888 /* default to NICAM audio standard */
889 priv->video_standard = DK_PAL_NICAM;
890 goto tune_channel;
891 }
892
Steven Toth8f3cd532008-10-16 20:29:38 -0300893 if (params->std & V4L2_STD_SECAM_DK) {
Steven Toth27c685a2008-01-05 16:50:14 -0300894 /* default to A2 DK1 audio standard */
895 priv->video_standard = DK_SECAM_A2DK1;
896 goto tune_channel;
897 }
898
Steven Toth8f3cd532008-10-16 20:29:38 -0300899 if (params->std & V4L2_STD_SECAM_L) {
Steven Toth27c685a2008-01-05 16:50:14 -0300900 priv->video_standard = L_SECAM_NICAM;
901 goto tune_channel;
902 }
903
Steven Toth8f3cd532008-10-16 20:29:38 -0300904 if (params->std & V4L2_STD_SECAM_LC) {
Steven Toth27c685a2008-01-05 16:50:14 -0300905 priv->video_standard = LC_SECAM_NICAM;
906 goto tune_channel;
907 }
908
909tune_channel:
910 ret = xc_SetSignalSource(priv, priv->rf_mode);
911 if (ret != XC_RESULT_SUCCESS) {
Steven Toth8f3cd532008-10-16 20:29:38 -0300912 printk(KERN_ERR
Steven Toth27c685a2008-01-05 16:50:14 -0300913 "xc5000: xc_SetSignalSource(%d) failed\n",
914 priv->rf_mode);
915 return -EREMOTEIO;
916 }
917
918 ret = xc_SetTVStandard(priv,
919 XC5000_Standard[priv->video_standard].VideoMode,
920 XC5000_Standard[priv->video_standard].AudioMode);
921 if (ret != XC_RESULT_SUCCESS) {
922 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
923 return -EREMOTEIO;
924 }
925
Dmitri Belimov724dcbf2011-02-01 05:25:19 -0300926 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
927
Devin Heitmuellera78baac2008-11-16 20:48:31 -0300928 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
Steven Toth27c685a2008-01-05 16:50:14 -0300929
930 if (debug)
931 xc_debug_dump(priv);
932
933 return 0;
934}
935
Beholder Intl. Ltd. Dmitry Belimovd7009cd2009-09-24 13:13:28 -0300936static int xc5000_set_radio_freq(struct dvb_frontend *fe,
937 struct analog_parameters *params)
938{
939 struct xc5000_priv *priv = fe->tuner_priv;
940 int ret = -EINVAL;
Devin Heitmueller496e9052009-09-24 13:27:24 -0300941 u8 radio_input;
Beholder Intl. Ltd. Dmitry Belimovd7009cd2009-09-24 13:13:28 -0300942
943 dprintk(1, "%s() frequency=%d (in units of khz)\n",
944 __func__, params->frequency);
945
Devin Heitmueller496e9052009-09-24 13:27:24 -0300946 if (priv->radio_input == XC5000_RADIO_NOT_CONFIGURED) {
947 dprintk(1, "%s() radio input not configured\n", __func__);
948 return -EINVAL;
949 }
950
951 if (priv->radio_input == XC5000_RADIO_FM1)
952 radio_input = FM_Radio_INPUT1;
953 else if (priv->radio_input == XC5000_RADIO_FM2)
954 radio_input = FM_Radio_INPUT2;
Dmitri Belimov724dcbf2011-02-01 05:25:19 -0300955 else if (priv->radio_input == XC5000_RADIO_FM1_MONO)
956 radio_input = FM_Radio_INPUT1_MONO;
Devin Heitmueller496e9052009-09-24 13:27:24 -0300957 else {
958 dprintk(1, "%s() unknown radio input %d\n", __func__,
959 priv->radio_input);
960 return -EINVAL;
961 }
962
Beholder Intl. Ltd. Dmitry Belimovd7009cd2009-09-24 13:13:28 -0300963 priv->freq_hz = params->frequency * 125 / 2;
964
965 priv->rf_mode = XC_RF_MODE_AIR;
966
Devin Heitmueller496e9052009-09-24 13:27:24 -0300967 ret = xc_SetTVStandard(priv, XC5000_Standard[radio_input].VideoMode,
968 XC5000_Standard[radio_input].AudioMode);
Beholder Intl. Ltd. Dmitry Belimovd7009cd2009-09-24 13:13:28 -0300969
970 if (ret != XC_RESULT_SUCCESS) {
971 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
972 return -EREMOTEIO;
973 }
974
975 ret = xc_SetSignalSource(priv, priv->rf_mode);
976 if (ret != XC_RESULT_SUCCESS) {
977 printk(KERN_ERR
978 "xc5000: xc_SetSignalSource(%d) failed\n",
979 priv->rf_mode);
980 return -EREMOTEIO;
981 }
982
Dmitri Belimov724dcbf2011-02-01 05:25:19 -0300983 if ((priv->radio_input == XC5000_RADIO_FM1) ||
984 (priv->radio_input == XC5000_RADIO_FM2))
985 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
986 else if (priv->radio_input == XC5000_RADIO_FM1_MONO)
987 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x06);
988
Beholder Intl. Ltd. Dmitry Belimovd7009cd2009-09-24 13:13:28 -0300989 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
990
991 return 0;
992}
993
994static int xc5000_set_analog_params(struct dvb_frontend *fe,
995 struct analog_parameters *params)
996{
997 struct xc5000_priv *priv = fe->tuner_priv;
998 int ret = -EINVAL;
999
1000 if (priv->i2c_props.adap == NULL)
1001 return -EINVAL;
1002
Devin Heitmuellerfc7a74b2012-08-06 22:47:01 -03001003 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
1004 dprintk(1, "Unable to load firmware and init tuner\n");
1005 return -EINVAL;
Devin Heitmueller760c4662009-10-13 23:44:14 -03001006 }
Beholder Intl. Ltd. Dmitry Belimovd7009cd2009-09-24 13:13:28 -03001007
1008 switch (params->mode) {
1009 case V4L2_TUNER_RADIO:
1010 ret = xc5000_set_radio_freq(fe, params);
1011 break;
1012 case V4L2_TUNER_ANALOG_TV:
1013 case V4L2_TUNER_DIGITAL_TV:
1014 ret = xc5000_set_tv_freq(fe, params);
1015 break;
1016 }
1017
1018 return ret;
1019}
1020
1021
Steven Tothaacb9d32007-12-18 01:55:51 -03001022static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq)
1023{
1024 struct xc5000_priv *priv = fe->tuner_priv;
Harvey Harrison271ddbf2008-04-08 23:20:00 -03001025 dprintk(1, "%s()\n", __func__);
Steven Tothe12671c2007-12-20 01:14:43 -03001026 *freq = priv->freq_hz;
Steven Tothaacb9d32007-12-18 01:55:51 -03001027 return 0;
1028}
1029
Mauro Carvalho Chehab35621032011-09-23 13:03:42 -03001030static int xc5000_get_if_frequency(struct dvb_frontend *fe, u32 *freq)
1031{
1032 struct xc5000_priv *priv = fe->tuner_priv;
1033 dprintk(1, "%s()\n", __func__);
1034 *freq = priv->if_khz * 1000;
1035 return 0;
1036}
1037
Steven Tothaacb9d32007-12-18 01:55:51 -03001038static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
1039{
1040 struct xc5000_priv *priv = fe->tuner_priv;
Harvey Harrison271ddbf2008-04-08 23:20:00 -03001041 dprintk(1, "%s()\n", __func__);
Steven Toth27c685a2008-01-05 16:50:14 -03001042
Steven Tothaacb9d32007-12-18 01:55:51 -03001043 *bw = priv->bandwidth;
1044 return 0;
1045}
1046
1047static int xc5000_get_status(struct dvb_frontend *fe, u32 *status)
1048{
1049 struct xc5000_priv *priv = fe->tuner_priv;
Steven Tothe12671c2007-12-20 01:14:43 -03001050 u16 lock_status = 0;
Steven Tothaacb9d32007-12-18 01:55:51 -03001051
1052 xc_get_lock_status(priv, &lock_status);
1053
Harvey Harrison271ddbf2008-04-08 23:20:00 -03001054 dprintk(1, "%s() lock_status = 0x%08x\n", __func__, lock_status);
Steven Tothaacb9d32007-12-18 01:55:51 -03001055
1056 *status = lock_status;
1057
1058 return 0;
1059}
1060
Steven Tothe12671c2007-12-20 01:14:43 -03001061static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe)
Steven Tothaacb9d32007-12-18 01:55:51 -03001062{
1063 struct xc5000_priv *priv = fe->tuner_priv;
Devin Heitmuellerfc7a74b2012-08-06 22:47:01 -03001064 int ret = XC_RESULT_SUCCESS;
Steven Tothaacb9d32007-12-18 01:55:51 -03001065
Steven Tothe470d812008-06-21 21:06:02 -03001066 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
Steven Tothaacb9d32007-12-18 01:55:51 -03001067 ret = xc5000_fwupload(fe);
Steven Tothe12671c2007-12-20 01:14:43 -03001068 if (ret != XC_RESULT_SUCCESS)
1069 return ret;
Devin Heitmuellerfc7a74b2012-08-06 22:47:01 -03001070
1071 /* Start the tuner self-calibration process */
1072 ret |= xc_initialize(priv);
1073
1074 /* Wait for calibration to complete.
1075 * We could continue but XC5000 will clock stretch subsequent
1076 * I2C transactions until calibration is complete. This way we
1077 * don't have to rely on clock stretching working.
1078 */
1079 xc_wait(100);
1080
1081 /* Default to "CABLE" mode */
1082 ret |= xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE);
Steven Tothaacb9d32007-12-18 01:55:51 -03001083 }
1084
Steven Tothaacb9d32007-12-18 01:55:51 -03001085 return ret;
1086}
1087
Steven Tothe12671c2007-12-20 01:14:43 -03001088static int xc5000_sleep(struct dvb_frontend *fe)
1089{
Steven Toth27c685a2008-01-05 16:50:14 -03001090 int ret;
1091
Harvey Harrison271ddbf2008-04-08 23:20:00 -03001092 dprintk(1, "%s()\n", __func__);
Steven Tothe12671c2007-12-20 01:14:43 -03001093
Devin Heitmuellerb6bd5eb2009-04-28 13:53:38 -03001094 /* Avoid firmware reload on slow devices */
1095 if (no_poweroff)
1096 return 0;
1097
Devin Heitmueller7f05b532009-04-02 22:02:39 -03001098 /* According to Xceive technical support, the "powerdown" register
1099 was removed in newer versions of the firmware. The "supported"
1100 way to sleep the tuner is to pull the reset pin low for 10ms */
1101 ret = xc5000_TunerReset(fe);
Steven Toth8f3cd532008-10-16 20:29:38 -03001102 if (ret != XC_RESULT_SUCCESS) {
Steven Toth27c685a2008-01-05 16:50:14 -03001103 printk(KERN_ERR
1104 "xc5000: %s() unable to shutdown tuner\n",
Harvey Harrison271ddbf2008-04-08 23:20:00 -03001105 __func__);
Steven Toth27c685a2008-01-05 16:50:14 -03001106 return -EREMOTEIO;
Steven Toth8f3cd532008-10-16 20:29:38 -03001107 } else
Steven Toth27c685a2008-01-05 16:50:14 -03001108 return XC_RESULT_SUCCESS;
Steven Tothe12671c2007-12-20 01:14:43 -03001109}
1110
Steven Tothaacb9d32007-12-18 01:55:51 -03001111static int xc5000_init(struct dvb_frontend *fe)
1112{
1113 struct xc5000_priv *priv = fe->tuner_priv;
Harvey Harrison271ddbf2008-04-08 23:20:00 -03001114 dprintk(1, "%s()\n", __func__);
Steven Tothaacb9d32007-12-18 01:55:51 -03001115
Steven Tothe12671c2007-12-20 01:14:43 -03001116 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
1117 printk(KERN_ERR "xc5000: Unable to initialise tuner\n");
1118 return -EREMOTEIO;
1119 }
1120
1121 if (debug)
1122 xc_debug_dump(priv);
Steven Tothaacb9d32007-12-18 01:55:51 -03001123
1124 return 0;
1125}
1126
1127static int xc5000_release(struct dvb_frontend *fe)
1128{
Michael Krufky89fd2852008-09-06 11:44:53 -03001129 struct xc5000_priv *priv = fe->tuner_priv;
1130
Harvey Harrison271ddbf2008-04-08 23:20:00 -03001131 dprintk(1, "%s()\n", __func__);
Michael Krufky89fd2852008-09-06 11:44:53 -03001132
1133 mutex_lock(&xc5000_list_mutex);
1134
1135 if (priv)
1136 hybrid_tuner_release_state(priv);
1137
1138 mutex_unlock(&xc5000_list_mutex);
1139
Steven Tothaacb9d32007-12-18 01:55:51 -03001140 fe->tuner_priv = NULL;
Michael Krufky89fd2852008-09-06 11:44:53 -03001141
Steven Tothaacb9d32007-12-18 01:55:51 -03001142 return 0;
1143}
1144
Dmitri Belimov724dcbf2011-02-01 05:25:19 -03001145static int xc5000_set_config(struct dvb_frontend *fe, void *priv_cfg)
1146{
1147 struct xc5000_priv *priv = fe->tuner_priv;
1148 struct xc5000_config *p = priv_cfg;
1149
1150 dprintk(1, "%s()\n", __func__);
1151
1152 if (p->if_khz)
1153 priv->if_khz = p->if_khz;
1154
1155 if (p->radio_input)
1156 priv->radio_input = p->radio_input;
1157
1158 return 0;
1159}
1160
1161
Steven Tothaacb9d32007-12-18 01:55:51 -03001162static const struct dvb_tuner_ops xc5000_tuner_ops = {
1163 .info = {
1164 .name = "Xceive XC5000",
1165 .frequency_min = 1000000,
1166 .frequency_max = 1023000000,
1167 .frequency_step = 50000,
1168 },
1169
Steven Toth27c685a2008-01-05 16:50:14 -03001170 .release = xc5000_release,
1171 .init = xc5000_init,
1172 .sleep = xc5000_sleep,
Steven Tothaacb9d32007-12-18 01:55:51 -03001173
Dmitri Belimov724dcbf2011-02-01 05:25:19 -03001174 .set_config = xc5000_set_config,
Steven Toth27c685a2008-01-05 16:50:14 -03001175 .set_params = xc5000_set_params,
1176 .set_analog_params = xc5000_set_analog_params,
1177 .get_frequency = xc5000_get_frequency,
Mauro Carvalho Chehab35621032011-09-23 13:03:42 -03001178 .get_if_frequency = xc5000_get_if_frequency,
Steven Toth27c685a2008-01-05 16:50:14 -03001179 .get_bandwidth = xc5000_get_bandwidth,
1180 .get_status = xc5000_get_status
Steven Tothaacb9d32007-12-18 01:55:51 -03001181};
1182
Michael Krufky48723542008-05-10 14:34:09 -03001183struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe,
1184 struct i2c_adapter *i2c,
lawrence rust2e4e98e2010-08-25 09:50:20 -03001185 const struct xc5000_config *cfg)
Steven Tothaacb9d32007-12-18 01:55:51 -03001186{
1187 struct xc5000_priv *priv = NULL;
Michael Krufky89fd2852008-09-06 11:44:53 -03001188 int instance;
Steven Tothaacb9d32007-12-18 01:55:51 -03001189 u16 id = 0;
1190
Michael Krufky89fd2852008-09-06 11:44:53 -03001191 dprintk(1, "%s(%d-%04x)\n", __func__,
1192 i2c ? i2c_adapter_id(i2c) : -1,
1193 cfg ? cfg->i2c_address : -1);
Steven Tothaacb9d32007-12-18 01:55:51 -03001194
Michael Krufky89fd2852008-09-06 11:44:53 -03001195 mutex_lock(&xc5000_list_mutex);
Steven Tothaacb9d32007-12-18 01:55:51 -03001196
Michael Krufky89fd2852008-09-06 11:44:53 -03001197 instance = hybrid_tuner_request_state(struct xc5000_priv, priv,
1198 hybrid_tuner_instance_list,
1199 i2c, cfg->i2c_address, "xc5000");
1200 switch (instance) {
1201 case 0:
1202 goto fail;
1203 break;
1204 case 1:
1205 /* new tuner instance */
Mauro Carvalho Chehabc6f56e72011-12-26 20:02:28 -03001206 priv->bandwidth = 6000000;
Michael Krufky89fd2852008-09-06 11:44:53 -03001207 fe->tuner_priv = priv;
1208 break;
1209 default:
1210 /* existing tuner instance */
1211 fe->tuner_priv = priv;
1212 break;
1213 }
Steven Tothaacb9d32007-12-18 01:55:51 -03001214
Devin Heitmuellerea227862009-03-11 02:58:53 -03001215 if (priv->if_khz == 0) {
1216 /* If the IF hasn't been set yet, use the value provided by
1217 the caller (occurs in hybrid devices where the analog
1218 call to xc5000_attach occurs before the digital side) */
1219 priv->if_khz = cfg->if_khz;
1220 }
1221
Michael Krufky7d3d0d82012-04-16 14:59:32 -03001222 if (priv->xtal_khz == 0)
1223 priv->xtal_khz = cfg->xtal_khz;
1224
Devin Heitmueller496e9052009-09-24 13:27:24 -03001225 if (priv->radio_input == 0)
1226 priv->radio_input = cfg->radio_input;
1227
Michael Krufky6fab81d2012-02-08 14:57:39 -03001228 /* don't override chip id if it's already been set
Michael Krufky76efb0ba2012-02-06 19:40:32 -03001229 unless explicitly specified */
Michael Krufky6fab81d2012-02-08 14:57:39 -03001230 if ((priv->chip_id == 0) || (cfg->chip_id))
1231 /* use default chip id if none specified, set to 0 so
1232 it can be overridden if this is a hybrid driver */
1233 priv->chip_id = (cfg->chip_id) ? cfg->chip_id : 0;
Michael Krufky76efb0ba2012-02-06 19:40:32 -03001234
Steven Toth27c685a2008-01-05 16:50:14 -03001235 /* Check if firmware has been loaded. It is possible that another
1236 instance of the driver has loaded the firmware.
1237 */
Devin Heitmueller7988fc22008-11-16 20:23:19 -03001238 if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != XC_RESULT_SUCCESS)
Michael Krufky89fd2852008-09-06 11:44:53 -03001239 goto fail;
Steven Tothaacb9d32007-12-18 01:55:51 -03001240
Steven Toth8f3cd532008-10-16 20:29:38 -03001241 switch (id) {
Steven Toth27c685a2008-01-05 16:50:14 -03001242 case XC_PRODUCT_ID_FW_LOADED:
1243 printk(KERN_INFO
1244 "xc5000: Successfully identified at address 0x%02x\n",
1245 cfg->i2c_address);
1246 printk(KERN_INFO
1247 "xc5000: Firmware has been loaded previously\n");
Steven Toth27c685a2008-01-05 16:50:14 -03001248 break;
1249 case XC_PRODUCT_ID_FW_NOT_LOADED:
1250 printk(KERN_INFO
1251 "xc5000: Successfully identified at address 0x%02x\n",
1252 cfg->i2c_address);
1253 printk(KERN_INFO
1254 "xc5000: Firmware has not been loaded previously\n");
Steven Toth27c685a2008-01-05 16:50:14 -03001255 break;
1256 default:
Steven Tothaacb9d32007-12-18 01:55:51 -03001257 printk(KERN_ERR
1258 "xc5000: Device not found at addr 0x%02x (0x%x)\n",
1259 cfg->i2c_address, id);
Michael Krufky89fd2852008-09-06 11:44:53 -03001260 goto fail;
Steven Tothaacb9d32007-12-18 01:55:51 -03001261 }
1262
Michael Krufky89fd2852008-09-06 11:44:53 -03001263 mutex_unlock(&xc5000_list_mutex);
1264
Steven Tothaacb9d32007-12-18 01:55:51 -03001265 memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops,
1266 sizeof(struct dvb_tuner_ops));
1267
Steven Tothaacb9d32007-12-18 01:55:51 -03001268 return fe;
Michael Krufky89fd2852008-09-06 11:44:53 -03001269fail:
1270 mutex_unlock(&xc5000_list_mutex);
1271
1272 xc5000_release(fe);
1273 return NULL;
Steven Tothaacb9d32007-12-18 01:55:51 -03001274}
1275EXPORT_SYMBOL(xc5000_attach);
1276
1277MODULE_AUTHOR("Steven Toth");
Steven Tothe12671c2007-12-20 01:14:43 -03001278MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver");
Steven Tothaacb9d32007-12-18 01:55:51 -03001279MODULE_LICENSE("GPL");
Tim Gardner3422f2a62012-07-25 09:15:19 -03001280MODULE_FIRMWARE(XC5000A_FIRMWARE);
1281MODULE_FIRMWARE(XC5000C_FIRMWARE);