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