?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[media] xc4000: added firmware_name parameter
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / media / common / tuners / xc4000.c
blob229a2155b2e89d0e46e5daa3902e2f15296729c3
1 /*
2 * Driver for Xceive XC4000 "QAM/8VSB single chip tuner"
3 *
4 * Copyright (c) 2007 Xceive Corporation
5 * Copyright (c) 2007 Steven Toth <stoth@linuxtv.org>
6 * Copyright (c) 2009 Devin Heitmueller <dheitmueller@kernellabs.com>
7 * Copyright (c) 2009 Davide Ferri <d.ferri@zero11.it>
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 *
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 */
24
25 #include <linux/module.h>
26 #include <linux/moduleparam.h>
27 #include <linux/videodev2.h>
28 #include <linux/delay.h>
29 #include <linux/dvb/frontend.h>
30 #include <linux/i2c.h>
31 #include <linux/mutex.h>
32 #include <asm/unaligned.h>
33
34 #include "dvb_frontend.h"
35
36 #include "xc4000.h"
37 #include "tuner-i2c.h"
38 #include "tuner-xc2028-types.h"
39
40 static int debug;
41 module_param(debug, int, 0644);
42 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
43
44 static int no_poweroff;
45 module_param(no_poweroff, int, 0644);
46 MODULE_PARM_DESC(no_poweroff, "0 (default) powers device off when not used.\n"
47 "\t\t1 keep device energized and with tuner ready all the times.\n"
48 "\t\tFaster, but consumes more power and keeps the device hotter");
49
50 #define XC4000_DEFAULT_FIRMWARE "xc4000.fw"
51
52 static char firmware_name[30];
53 module_param_string(firmware_name, firmware_name, sizeof(firmware_name), 0);
54 MODULE_PARM_DESC(firmware_name, "\n\t\tFirmware file name. Allows overriding "
55 "the default firmware\n"
56 "\t\tname.");
57
58 static DEFINE_MUTEX(xc4000_list_mutex);
59 static LIST_HEAD(hybrid_tuner_instance_list);
60
61 #define dprintk(level, fmt, arg...) if (debug >= level) \
62 printk(KERN_INFO "%s: " fmt, "xc4000", ## arg)
63
64 /* struct for storing firmware table */
65 struct firmware_description {
66 unsigned int type;
67 v4l2_std_id id;
68 __u16 int_freq;
69 unsigned char *ptr;
70 unsigned int size;
71 };
72
73 struct firmware_properties {
74 unsigned int type;
75 v4l2_std_id id;
76 v4l2_std_id std_req;
77 __u16 int_freq;
78 unsigned int scode_table;
79 int scode_nr;
80 };
81
82 struct xc4000_priv {
83 struct tuner_i2c_props i2c_props;
84 struct list_head hybrid_tuner_instance_list;
85 struct firmware_description *firm;
86 int firm_size;
87 __u16 firm_version;
88 u32 if_khz;
89 u32 freq_hz;
90 u32 bandwidth;
91 u8 video_standard;
92 u8 rf_mode;
93 u8 ignore_i2c_write_errors;
94 /* struct xc2028_ctrl ctrl; */
95 struct firmware_properties cur_fw;
96 __u16 hwmodel;
97 __u16 hwvers;
98 struct mutex lock;
99 };
100
101 /* Misc Defines */
102 #define MAX_TV_STANDARD 24
103 #define XC_MAX_I2C_WRITE_LENGTH 64
104
105 /* Signal Types */
106 #define XC_RF_MODE_AIR 0
107 #define XC_RF_MODE_CABLE 1
108
109 /* Result codes */
110 #define XC_RESULT_SUCCESS 0
111 #define XC_RESULT_RESET_FAILURE 1
112 #define XC_RESULT_I2C_WRITE_FAILURE 2
113 #define XC_RESULT_I2C_READ_FAILURE 3
114 #define XC_RESULT_OUT_OF_RANGE 5
115
116 /* Product id */
117 #define XC_PRODUCT_ID_FW_NOT_LOADED 0x2000
118 #define XC_PRODUCT_ID_FW_LOADED 0x0FA0
119
120 /* Registers (Write-only) */
121 #define XREG_INIT 0x00
122 #define XREG_VIDEO_MODE 0x01
123 #define XREG_AUDIO_MODE 0x02
124 #define XREG_RF_FREQ 0x03
125 #define XREG_D_CODE 0x04
126 #define XREG_DIRECTSITTING_MODE 0x05
127 #define XREG_SEEK_MODE 0x06
128 #define XREG_POWER_DOWN 0x08
129 #define XREG_SIGNALSOURCE 0x0A
130 #define XREG_AMPLITUDE 0x10
131
132 /* Registers (Read-only) */
133 #define XREG_ADC_ENV 0x00
134 #define XREG_QUALITY 0x01
135 #define XREG_FRAME_LINES 0x02
136 #define XREG_HSYNC_FREQ 0x03
137 #define XREG_LOCK 0x04
138 #define XREG_FREQ_ERROR 0x05
139 #define XREG_SNR 0x06
140 #define XREG_VERSION 0x07
141 #define XREG_PRODUCT_ID 0x08
142
143 /*
144 Basic firmware description. This will remain with
145 the driver for documentation purposes.
146
147 This represents an I2C firmware file encoded as a
148 string of unsigned char. Format is as follows:
149
150 char[0 ]=len0_MSB -> len = len_MSB * 256 + len_LSB
151 char[1 ]=len0_LSB -> length of first write transaction
152 char[2 ]=data0 -> first byte to be sent
153 char[3 ]=data1
154 char[4 ]=data2
155 char[ ]=...
156 char[M ]=dataN -> last byte to be sent
157 char[M+1]=len1_MSB -> len = len_MSB * 256 + len_LSB
158 char[M+2]=len1_LSB -> length of second write transaction
159 char[M+3]=data0
160 char[M+4]=data1
161 ...
162 etc.
163
164 The [len] value should be interpreted as follows:
165
166 len= len_MSB _ len_LSB
167 len=1111_1111_1111_1111 : End of I2C_SEQUENCE
168 len=0000_0000_0000_0000 : Reset command: Do hardware reset
169 len=0NNN_NNNN_NNNN_NNNN : Normal transaction: number of bytes = {1:32767)
170 len=1WWW_WWWW_WWWW_WWWW : Wait command: wait for {1:32767} ms
171
172 For the RESET and WAIT commands, the two following bytes will contain
173 immediately the length of the following transaction.
174 */
175
176 struct XC_TV_STANDARD {
177 const char *Name;
178 u16 AudioMode;
179 u16 VideoMode;
180 u16 int_freq;
181 };
182
183 /* Tuner standards */
184 #define XC4000_MN_NTSC_PAL_BTSC 0
185 #define XC4000_MN_NTSC_PAL_A2 1
186 #define XC4000_MN_NTSC_PAL_EIAJ 2
187 #define XC4000_MN_NTSC_PAL_Mono 3
188 #define XC4000_BG_PAL_A2 4
189 #define XC4000_BG_PAL_NICAM 5
190 #define XC4000_BG_PAL_MONO 6
191 #define XC4000_I_PAL_NICAM 7
192 #define XC4000_I_PAL_NICAM_MONO 8
193 #define XC4000_DK_PAL_A2 9
194 #define XC4000_DK_PAL_NICAM 10
195 #define XC4000_DK_PAL_MONO 11
196 #define XC4000_DK_SECAM_A2DK1 12
197 #define XC4000_DK_SECAM_A2LDK3 13
198 #define XC4000_DK_SECAM_A2MONO 14
199 #define XC4000_DK_SECAM_NICAM 15
200 #define XC4000_L_SECAM_NICAM 16
201 #define XC4000_LC_SECAM_NICAM 17
202 #define XC4000_DTV6 18
203 #define XC4000_DTV8 19
204 #define XC4000_DTV7_8 20
205 #define XC4000_DTV7 21
206 #define XC4000_FM_Radio_INPUT2 22
207 #define XC4000_FM_Radio_INPUT1 23
208
209 static struct XC_TV_STANDARD XC4000_Standard[MAX_TV_STANDARD] = {
210 {"M/N-NTSC/PAL-BTSC", 0x0000, 0x80A0, 4500},
211 {"M/N-NTSC/PAL-A2", 0x0000, 0x80A0, 4600},
212 {"M/N-NTSC/PAL-EIAJ", 0x0040, 0x80A0, 4500},
213 {"M/N-NTSC/PAL-Mono", 0x0078, 0x80A0, 4500},
214 {"B/G-PAL-A2", 0x0000, 0x8159, 5640},
215 {"B/G-PAL-NICAM", 0x0004, 0x8159, 5740},
216 {"B/G-PAL-MONO", 0x0078, 0x8159, 5500},
217 {"I-PAL-NICAM", 0x0080, 0x8049, 6240},
218 {"I-PAL-NICAM-MONO", 0x0078, 0x8049, 6000},
219 {"D/K-PAL-A2", 0x0000, 0x8049, 6380},
220 {"D/K-PAL-NICAM", 0x0080, 0x8049, 6200},
221 {"D/K-PAL-MONO", 0x0078, 0x8049, 6500},
222 {"D/K-SECAM-A2 DK1", 0x0000, 0x8049, 6340},
223 {"D/K-SECAM-A2 L/DK3", 0x0000, 0x8049, 6000},
224 {"D/K-SECAM-A2 MONO", 0x0078, 0x8049, 6500},
225 {"D/K-SECAM-NICAM", 0x0080, 0x8049, 6200},
226 {"L-SECAM-NICAM", 0x8080, 0x0009, 6200},
227 {"L'-SECAM-NICAM", 0x8080, 0x4009, 6200},
228 {"DTV6", 0x00C0, 0x8002, 0},
229 {"DTV8", 0x00C0, 0x800B, 0},
230 {"DTV7/8", 0x00C0, 0x801B, 0},
231 {"DTV7", 0x00C0, 0x8007, 0},
232 {"FM Radio-INPUT2", 0x0008, 0x9800,10700},
233 {"FM Radio-INPUT1", 0x0008, 0x9000,10700}
234 };
235
236 static int xc4000_readreg(struct xc4000_priv *priv, u16 reg, u16 *val);
237 static int xc4000_TunerReset(struct dvb_frontend *fe);
238
239 static int xc_send_i2c_data(struct xc4000_priv *priv, u8 *buf, int len)
240 {
241 struct i2c_msg msg = { .addr = priv->i2c_props.addr,
242 .flags = 0, .buf = buf, .len = len };
243 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
244 if (priv->ignore_i2c_write_errors == 0) {
245 printk(KERN_ERR "xc4000: I2C write failed (len=%i)\n",
246 len);
247 if (len == 4) {
248 printk("bytes %02x %02x %02x %02x\n", buf[0],
249 buf[1], buf[2], buf[3]);
250 }
251 return XC_RESULT_I2C_WRITE_FAILURE;
252 }
253 }
254 return XC_RESULT_SUCCESS;
255 }
256
257 static void xc_wait(int wait_ms)
258 {
259 msleep(wait_ms);
260 }
261
262 static int xc4000_TunerReset(struct dvb_frontend *fe)
263 {
264 struct xc4000_priv *priv = fe->tuner_priv;
265 int ret;
266
267 dprintk(1, "%s()\n", __func__);
268
269 if (fe->callback) {
270 ret = fe->callback(((fe->dvb) && (fe->dvb->priv)) ?
271 fe->dvb->priv :
272 priv->i2c_props.adap->algo_data,
273 DVB_FRONTEND_COMPONENT_TUNER,
274 XC4000_TUNER_RESET, 0);
275 if (ret) {
276 printk(KERN_ERR "xc4000: reset failed\n");
277 return XC_RESULT_RESET_FAILURE;
278 }
279 } else {
280 printk(KERN_ERR "xc4000: no tuner reset callback function, fatal\n");
281 return XC_RESULT_RESET_FAILURE;
282 }
283 return XC_RESULT_SUCCESS;
284 }
285
286 static int xc_write_reg(struct xc4000_priv *priv, u16 regAddr, u16 i2cData)
287 {
288 u8 buf[4];
289 int result;
290
291 buf[0] = (regAddr >> 8) & 0xFF;
292 buf[1] = regAddr & 0xFF;
293 buf[2] = (i2cData >> 8) & 0xFF;
294 buf[3] = i2cData & 0xFF;
295 result = xc_send_i2c_data(priv, buf, 4);
296
297 return result;
298 }
299
300 static int xc_load_i2c_sequence(struct dvb_frontend *fe, const u8 *i2c_sequence)
301 {
302 struct xc4000_priv *priv = fe->tuner_priv;
303
304 int i, nbytes_to_send, result;
305 unsigned int len, pos, index;
306 u8 buf[XC_MAX_I2C_WRITE_LENGTH];
307
308 index = 0;
309 while ((i2c_sequence[index] != 0xFF) ||
310 (i2c_sequence[index + 1] != 0xFF)) {
311 len = i2c_sequence[index] * 256 + i2c_sequence[index+1];
312 if (len == 0x0000) {
313 /* RESET command */
314 result = xc4000_TunerReset(fe);
315 index += 2;
316 if (result != XC_RESULT_SUCCESS)
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 =
333 XC_MAX_I2C_WRITE_LENGTH;
334 else
335 nbytes_to_send = (len - pos + 2);
336 for (i = 2; i < nbytes_to_send; i++) {
337 buf[i] = i2c_sequence[index + pos +
338 i - 2];
339 }
340 result = xc_send_i2c_data(priv, buf,
341 nbytes_to_send);
342
343 if (result != XC_RESULT_SUCCESS)
344 return result;
345
346 pos += nbytes_to_send - 2;
347 }
348 index += len;
349 }
350 }
351 return XC_RESULT_SUCCESS;
352 }
353
354 static int xc_SetTVStandard(struct xc4000_priv *priv,
355 u16 VideoMode, u16 AudioMode)
356 {
357 int ret;
358 dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, VideoMode, AudioMode);
359 dprintk(1, "%s() Standard = %s\n",
360 __func__,
361 XC4000_Standard[priv->video_standard].Name);
362
363 /* Don't complain when the request fails because of i2c stretching */
364 priv->ignore_i2c_write_errors = 1;
365
366 ret = xc_write_reg(priv, XREG_VIDEO_MODE, VideoMode);
367 if (ret == XC_RESULT_SUCCESS)
368 ret = xc_write_reg(priv, XREG_AUDIO_MODE, AudioMode);
369
370 priv->ignore_i2c_write_errors = 0;
371
372 return ret;
373 }
374
375 static int xc_SetSignalSource(struct xc4000_priv *priv, u16 rf_mode)
376 {
377 dprintk(1, "%s(%d) Source = %s\n", __func__, rf_mode,
378 rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE");
379
380 if ((rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE)) {
381 rf_mode = XC_RF_MODE_CABLE;
382 printk(KERN_ERR
383 "%s(), Invalid mode, defaulting to CABLE",
384 __func__);
385 }
386 return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode);
387 }
388
389 static const struct dvb_tuner_ops xc4000_tuner_ops;
390
391 static int xc_set_RF_frequency(struct xc4000_priv *priv, u32 freq_hz)
392 {
393 u16 freq_code;
394
395 dprintk(1, "%s(%u)\n", __func__, freq_hz);
396
397 if ((freq_hz > xc4000_tuner_ops.info.frequency_max) ||
398 (freq_hz < xc4000_tuner_ops.info.frequency_min))
399 return XC_RESULT_OUT_OF_RANGE;
400
401 freq_code = (u16)(freq_hz / 15625);
402
403 /* WAS: Starting in firmware version 1.1.44, Xceive recommends using the
404 FINERFREQ for all normal tuning (the doc indicates reg 0x03 should
405 only be used for fast scanning for channel lock) */
406 return xc_write_reg(priv, XREG_RF_FREQ, freq_code); /* WAS: XREG_FINERFREQ */
407 }
408
409 static int xc_get_ADC_Envelope(struct xc4000_priv *priv, u16 *adc_envelope)
410 {
411 return xc4000_readreg(priv, XREG_ADC_ENV, adc_envelope);
412 }
413
414 static int xc_get_frequency_error(struct xc4000_priv *priv, u32 *freq_error_hz)
415 {
416 int result;
417 u16 regData;
418 u32 tmp;
419
420 result = xc4000_readreg(priv, XREG_FREQ_ERROR, &regData);
421 if (result != XC_RESULT_SUCCESS)
422 return result;
423
424 tmp = (u32)regData & 0xFFFFU;
425 tmp = (tmp < 0x8000U ? tmp : 0x10000U - tmp);
426 (*freq_error_hz) = tmp * 15625;
427 return result;
428 }
429
430 static int xc_get_lock_status(struct xc4000_priv *priv, u16 *lock_status)
431 {
432 return xc4000_readreg(priv, XREG_LOCK, lock_status);
433 }
434
435 static int xc_get_version(struct xc4000_priv *priv,
436 u8 *hw_majorversion, u8 *hw_minorversion,
437 u8 *fw_majorversion, u8 *fw_minorversion)
438 {
439 u16 data;
440 int result;
441
442 result = xc4000_readreg(priv, XREG_VERSION, &data);
443 if (result != XC_RESULT_SUCCESS)
444 return result;
445
446 (*hw_majorversion) = (data >> 12) & 0x0F;
447 (*hw_minorversion) = (data >> 8) & 0x0F;
448 (*fw_majorversion) = (data >> 4) & 0x0F;
449 (*fw_minorversion) = data & 0x0F;
450
451 return 0;
452 }
453
454 static int xc_get_hsync_freq(struct xc4000_priv *priv, u32 *hsync_freq_hz)
455 {
456 u16 regData;
457 int result;
458
459 result = xc4000_readreg(priv, XREG_HSYNC_FREQ, &regData);
460 if (result != XC_RESULT_SUCCESS)
461 return result;
462
463 (*hsync_freq_hz) = ((regData & 0x0fff) * 763)/100;
464 return result;
465 }
466
467 static int xc_get_frame_lines(struct xc4000_priv *priv, u16 *frame_lines)
468 {
469 return xc4000_readreg(priv, XREG_FRAME_LINES, frame_lines);
470 }
471
472 static int xc_get_quality(struct xc4000_priv *priv, u16 *quality)
473 {
474 return xc4000_readreg(priv, XREG_QUALITY, quality);
475 }
476
477 static u16 WaitForLock(struct xc4000_priv *priv)
478 {
479 u16 lockState = 0;
480 int watchDogCount = 40;
481
482 while ((lockState == 0) && (watchDogCount > 0)) {
483 xc_get_lock_status(priv, &lockState);
484 if (lockState != 1) {
485 xc_wait(5);
486 watchDogCount--;
487 }
488 }
489 return lockState;
490 }
491
492 #define XC_TUNE_ANALOG 0
493 #define XC_TUNE_DIGITAL 1
494 static int xc_tune_channel(struct xc4000_priv *priv, u32 freq_hz, int mode)
495 {
496 int found = 0;
497 int result = 0;
498
499 dprintk(1, "%s(%u)\n", __func__, freq_hz);
500
501 /* Don't complain when the request fails because of i2c stretching */
502 priv->ignore_i2c_write_errors = 1;
503 result = xc_set_RF_frequency(priv, freq_hz);
504 priv->ignore_i2c_write_errors = 0;
505
506 if (result != XC_RESULT_SUCCESS)
507 return 0;
508
509 if (mode == XC_TUNE_ANALOG) {
510 if (WaitForLock(priv) == 1)
511 found = 1;
512 }
513
514 return found;
515 }
516
517 static int xc4000_readreg(struct xc4000_priv *priv, u16 reg, u16 *val)
518 {
519 u8 buf[2] = { reg >> 8, reg & 0xff };
520 u8 bval[2] = { 0, 0 };
521 struct i2c_msg msg[2] = {
522 { .addr = priv->i2c_props.addr,
523 .flags = 0, .buf = &buf[0], .len = 2 },
524 { .addr = priv->i2c_props.addr,
525 .flags = I2C_M_RD, .buf = &bval[0], .len = 2 },
526 };
527
528 if (i2c_transfer(priv->i2c_props.adap, msg, 2) != 2) {
529 printk(KERN_WARNING "xc4000: I2C read failed\n");
530 return -EREMOTEIO;
531 }
532
533 *val = (bval[0] << 8) | bval[1];
534 return XC_RESULT_SUCCESS;
535 }
536
537 #define dump_firm_type(t) dump_firm_type_and_int_freq(t, 0)
538 static void dump_firm_type_and_int_freq(unsigned int type, u16 int_freq)
539 {
540 if (type & BASE)
541 printk("BASE ");
542 if (type & INIT1)
543 printk("INIT1 ");
544 if (type & F8MHZ)
545 printk("F8MHZ ");
546 if (type & MTS)
547 printk("MTS ");
548 if (type & D2620)
549 printk("D2620 ");
550 if (type & D2633)
551 printk("D2633 ");
552 if (type & DTV6)
553 printk("DTV6 ");
554 if (type & QAM)
555 printk("QAM ");
556 if (type & DTV7)
557 printk("DTV7 ");
558 if (type & DTV78)
559 printk("DTV78 ");
560 if (type & DTV8)
561 printk("DTV8 ");
562 if (type & FM)
563 printk("FM ");
564 if (type & INPUT1)
565 printk("INPUT1 ");
566 if (type & LCD)
567 printk("LCD ");
568 if (type & NOGD)
569 printk("NOGD ");
570 if (type & MONO)
571 printk("MONO ");
572 if (type & ATSC)
573 printk("ATSC ");
574 if (type & IF)
575 printk("IF ");
576 if (type & LG60)
577 printk("LG60 ");
578 if (type & ATI638)
579 printk("ATI638 ");
580 if (type & OREN538)
581 printk("OREN538 ");
582 if (type & OREN36)
583 printk("OREN36 ");
584 if (type & TOYOTA388)
585 printk("TOYOTA388 ");
586 if (type & TOYOTA794)
587 printk("TOYOTA794 ");
588 if (type & DIBCOM52)
589 printk("DIBCOM52 ");
590 if (type & ZARLINK456)
591 printk("ZARLINK456 ");
592 if (type & CHINA)
593 printk("CHINA ");
594 if (type & F6MHZ)
595 printk("F6MHZ ");
596 if (type & INPUT2)
597 printk("INPUT2 ");
598 if (type & SCODE)
599 printk("SCODE ");
600 if (type & HAS_IF)
601 printk("HAS_IF_%d ", int_freq);
602 }
603
604 static int seek_firmware(struct dvb_frontend *fe, unsigned int type,
605 v4l2_std_id *id)
606 {
607 struct xc4000_priv *priv = fe->tuner_priv;
608 int i, best_i = -1, best_nr_matches = 0;
609 unsigned int type_mask = 0;
610
611 if (!priv->firm) {
612 printk("Error! firmware not loaded\n");
613 return -EINVAL;
614 }
615
616 if (((type & ~SCODE) == 0) && (*id == 0))
617 *id = V4L2_STD_PAL;
618
619 if (type & BASE)
620 type_mask = BASE_TYPES;
621 else if (type & SCODE) {
622 type &= SCODE_TYPES;
623 type_mask = SCODE_TYPES & ~HAS_IF;
624 } else if (type & DTV_TYPES)
625 type_mask = DTV_TYPES;
626 else if (type & STD_SPECIFIC_TYPES)
627 type_mask = STD_SPECIFIC_TYPES;
628
629 type &= type_mask;
630
631 if (!(type & SCODE))
632 type_mask = ~0;
633
634 /* Seek for exact match */
635 for (i = 0; i < priv->firm_size; i++) {
636 if ((type == (priv->firm[i].type & type_mask)) &&
637 (*id == priv->firm[i].id))
638 goto found;
639 }
640
641 /* Seek for generic video standard match */
642 for (i = 0; i < priv->firm_size; i++) {
643 v4l2_std_id match_mask;
644 int nr_matches;
645
646 if (type != (priv->firm[i].type & type_mask))
647 continue;
648
649 match_mask = *id & priv->firm[i].id;
650 if (!match_mask)
651 continue;
652
653 if ((*id & match_mask) == *id)
654 goto found; /* Supports all the requested standards */
655
656 nr_matches = hweight64(match_mask);
657 if (nr_matches > best_nr_matches) {
658 best_nr_matches = nr_matches;
659 best_i = i;
660 }
661 }
662
663 if (best_nr_matches > 0) {
664 printk("Selecting best matching firmware (%d bits) for "
665 "type=", best_nr_matches);
666 printk("(%x), id %016llx:\n", type, (unsigned long long)*id);
667 i = best_i;
668 goto found;
669 }
670
671 /*FIXME: Would make sense to seek for type "hint" match ? */
672
673 i = -ENOENT;
674 goto ret;
675
676 found:
677 *id = priv->firm[i].id;
678
679 ret:
680 if (debug) {
681 printk("%s firmware for type=", (i < 0) ? "Can't find" :
682 "Found");
683 dump_firm_type(type);
684 printk("(%x), id %016llx.\n", type, (unsigned long long)*id);
685 }
686 return i;
687 }
688
689 static int load_firmware(struct dvb_frontend *fe, unsigned int type,
690 v4l2_std_id *id)
691 {
692 struct xc4000_priv *priv = fe->tuner_priv;
693 int pos, rc;
694 unsigned char *p;
695
696 pos = seek_firmware(fe, type, id);
697 if (pos < 0)
698 return pos;
699
700 p = priv->firm[pos].ptr;
701
702 /* Don't complain when the request fails because of i2c stretching */
703 priv->ignore_i2c_write_errors = 1;
704
705 rc = xc_load_i2c_sequence(fe, p);
706
707 priv->ignore_i2c_write_errors = 0;
708
709 return rc;
710 }
711
712 static int xc4000_fwupload(struct dvb_frontend *fe)
713 {
714 struct xc4000_priv *priv = fe->tuner_priv;
715 const struct firmware *fw = NULL;
716 const unsigned char *p, *endp;
717 int rc = 0;
718 int n, n_array;
719 char name[33];
720 const char *fname;
721
722 if (firmware_name[0] != '\0')
723 fname = firmware_name;
724 else
725 fname = XC4000_DEFAULT_FIRMWARE;
726
727 printk("Reading firmware %s\n", fname);
728 rc = request_firmware(&fw, fname, priv->i2c_props.adap->dev.parent);
729 if (rc < 0) {
730 if (rc == -ENOENT)
731 printk("Error: firmware %s not found.\n",
732 fname);
733 else
734 printk("Error %d while requesting firmware %s \n",
735 rc, fname);
736
737 return rc;
738 }
739 p = fw->data;
740 endp = p + fw->size;
741
742 if (fw->size < sizeof(name) - 1 + 2 + 2) {
743 printk("Error: firmware file %s has invalid size!\n",
744 fname);
745 goto corrupt;
746 }
747
748 memcpy(name, p, sizeof(name) - 1);
749 name[sizeof(name) - 1] = 0;
750 p += sizeof(name) - 1;
751
752 priv->firm_version = get_unaligned_le16(p);
753 p += 2;
754
755 n_array = get_unaligned_le16(p);
756 p += 2;
757
758 dprintk(1, "Loading %d firmware images from %s, type: %s, ver %d.%d\n",
759 n_array, fname, name,
760 priv->firm_version >> 8, priv->firm_version & 0xff);
761
762 priv->firm = kzalloc(sizeof(*priv->firm) * n_array, GFP_KERNEL);
763 if (priv->firm == NULL) {
764 printk("Not enough memory to load firmware file.\n");
765 rc = -ENOMEM;
766 goto err;
767 }
768 priv->firm_size = n_array;
769
770 n = -1;
771 while (p < endp) {
772 __u32 type, size;
773 v4l2_std_id id;
774 __u16 int_freq = 0;
775
776 n++;
777 if (n >= n_array) {
778 printk("More firmware images in file than "
779 "were expected!\n");
780 goto corrupt;
781 }
782
783 /* Checks if there's enough bytes to read */
784 if (endp - p < sizeof(type) + sizeof(id) + sizeof(size))
785 goto header;
786
787 type = get_unaligned_le32(p);
788 p += sizeof(type);
789
790 id = get_unaligned_le64(p);
791 p += sizeof(id);
792
793 if (type & HAS_IF) {
794 int_freq = get_unaligned_le16(p);
795 p += sizeof(int_freq);
796 if (endp - p < sizeof(size))
797 goto header;
798 }
799
800 size = get_unaligned_le32(p);
801 p += sizeof(size);
802
803 if (!size || size > endp - p) {
804 printk("Firmware type ");
805 printk("(%x), id %llx is corrupted "
806 "(size=%d, expected %d)\n",
807 type, (unsigned long long)id,
808 (unsigned)(endp - p), size);
809 goto corrupt;
810 }
811
812 priv->firm[n].ptr = kzalloc(size, GFP_KERNEL);
813 if (priv->firm[n].ptr == NULL) {
814 printk("Not enough memory to load firmware file.\n");
815 rc = -ENOMEM;
816 goto err;
817 }
818
819 if (debug) {
820 printk("Reading firmware type ");
821 dump_firm_type_and_int_freq(type, int_freq);
822 printk("(%x), id %llx, size=%d.\n",
823 type, (unsigned long long)id, size);
824 }
825
826 memcpy(priv->firm[n].ptr, p, size);
827 priv->firm[n].type = type;
828 priv->firm[n].id = id;
829 priv->firm[n].size = size;
830 priv->firm[n].int_freq = int_freq;
831
832 p += size;
833 }
834
835 if (n + 1 != priv->firm_size) {
836 printk("Firmware file is incomplete!\n");
837 goto corrupt;
838 }
839
840 goto done;
841
842 header:
843 printk("Firmware header is incomplete!\n");
844 corrupt:
845 rc = -EINVAL;
846 printk("Error: firmware file is corrupted!\n");
847
848 err:
849 printk("Releasing partially loaded firmware file.\n");
850
851 done:
852 release_firmware(fw);
853 if (rc == 0)
854 dprintk(1, "Firmware files loaded.\n");
855
856 return rc;
857 }
858
859 static int load_scode(struct dvb_frontend *fe, unsigned int type,
860 v4l2_std_id *id, __u16 int_freq, int scode)
861 {
862 struct xc4000_priv *priv = fe->tuner_priv;
863 int pos, rc;
864 unsigned char *p;
865 u8 scode_buf[13];
866 u8 indirect_mode[5];
867
868 dprintk(1, "%s called int_freq=%d\n", __func__, int_freq);
869
870 if (!int_freq) {
871 pos = seek_firmware(fe, type, id);
872 if (pos < 0)
873 return pos;
874 } else {
875 for (pos = 0; pos < priv->firm_size; pos++) {
876 if ((priv->firm[pos].int_freq == int_freq) &&
877 (priv->firm[pos].type & HAS_IF))
878 break;
879 }
880 if (pos == priv->firm_size)
881 return -ENOENT;
882 }
883
884 p = priv->firm[pos].ptr;
885
886 if (priv->firm[pos].type & HAS_IF) {
887 if (priv->firm[pos].size != 12 * 16 || scode >= 16)
888 return -EINVAL;
889 p += 12 * scode;
890 } else {
891 /* 16 SCODE entries per file; each SCODE entry is 12 bytes and
892 * has a 2-byte size header in the firmware format. */
893 if (priv->firm[pos].size != 14 * 16 || scode >= 16 ||
894 le16_to_cpu(*(__u16 *)(p + 14 * scode)) != 12)
895 return -EINVAL;
896 p += 14 * scode + 2;
897 }
898
899 tuner_info("Loading SCODE for type=");
900 dump_firm_type_and_int_freq(priv->firm[pos].type,
901 priv->firm[pos].int_freq);
902 printk("(%x), id %016llx.\n", priv->firm[pos].type,
903 (unsigned long long)*id);
904
905 scode_buf[0] = 0x00;
906 memcpy(&scode_buf[1], p, 12);
907
908 /* Enter direct-mode */
909 rc = xc_write_reg(priv, XREG_DIRECTSITTING_MODE, 0);
910 if (rc < 0) {
911 printk("failed to put device into direct mode!\n");
912 return -EIO;
913 }
914
915 rc = xc_send_i2c_data(priv, scode_buf, 13);
916 if (rc != XC_RESULT_SUCCESS) {
917 /* Even if the send failed, make sure we set back to indirect
918 mode */
919 printk("Failed to set scode %d\n", rc);
920 }
921
922 /* Switch back to indirect-mode */
923 memset(indirect_mode, 0, sizeof(indirect_mode));
924 indirect_mode[4] = 0x88;
925 xc_send_i2c_data(priv, indirect_mode, sizeof(indirect_mode));
926 msleep(10);
927
928 return 0;
929 }
930
931 static int check_firmware(struct dvb_frontend *fe, unsigned int type,
932 v4l2_std_id std, __u16 int_freq)
933 {
934 struct xc4000_priv *priv = fe->tuner_priv;
935 struct firmware_properties new_fw;
936 int rc = 0, is_retry = 0;
937 u16 version, hwmodel;
938 v4l2_std_id std0;
939 u8 hw_major, hw_minor, fw_major, fw_minor;
940
941 dprintk(1, "%s called\n", __func__);
942
943 if (!priv->firm) {
944 rc = xc4000_fwupload(fe);
945 if (rc < 0)
946 return rc;
947 }
948
949 #ifdef DJH_DEBUG
950 if (priv->ctrl.mts && !(type & FM))
951 type |= MTS;
952 #endif
953
954 retry:
955 new_fw.type = type;
956 new_fw.id = std;
957 new_fw.std_req = std;
958 new_fw.scode_table = SCODE /* | priv->ctrl.scode_table */;
959 new_fw.scode_nr = 0;
960 new_fw.int_freq = int_freq;
961
962 dprintk(1, "checking firmware, user requested type=");
963 if (debug) {
964 dump_firm_type(new_fw.type);
965 printk("(%x), id %016llx, ", new_fw.type,
966 (unsigned long long)new_fw.std_req);
967 if (!int_freq) {
968 printk("scode_tbl ");
969 #ifdef DJH_DEBUG
970 dump_firm_type(priv->ctrl.scode_table);
971 printk("(%x), ", priv->ctrl.scode_table);
972 #endif
973 } else
974 printk("int_freq %d, ", new_fw.int_freq);
975 printk("scode_nr %d\n", new_fw.scode_nr);
976 }
977
978 /* No need to reload base firmware if it matches */
979 if (((BASE | new_fw.type) & BASE_TYPES) ==
980 (priv->cur_fw.type & BASE_TYPES)) {
981 dprintk(1, "BASE firmware not changed.\n");
982 goto skip_base;
983 }
984
985 /* Updating BASE - forget about all currently loaded firmware */
986 memset(&priv->cur_fw, 0, sizeof(priv->cur_fw));
987
988 /* Reset is needed before loading firmware */
989 rc = xc4000_TunerReset(fe);
990 if (rc < 0)
991 goto fail;
992
993 /* BASE firmwares are all std0 */
994 std0 = 0;
995 rc = load_firmware(fe, BASE | new_fw.type, &std0);
996 if (rc < 0) {
997 printk("Error %d while loading base firmware\n", rc);
998 goto fail;
999 }
1000
1001 /* Load INIT1, if needed */
1002 dprintk(1, "Load init1 firmware, if exists\n");
1003
1004 rc = load_firmware(fe, BASE | INIT1 | new_fw.type, &std0);
1005 if (rc == -ENOENT)
1006 rc = load_firmware(fe, (BASE | INIT1 | new_fw.type) & ~F8MHZ,
1007 &std0);
1008 if (rc < 0 && rc != -ENOENT) {
1009 tuner_err("Error %d while loading init1 firmware\n",
1010 rc);
1011 goto fail;
1012 }
1013
1014 skip_base:
1015 /*
1016 * No need to reload standard specific firmware if base firmware
1017 * was not reloaded and requested video standards have not changed.
1018 */
1019 if (priv->cur_fw.type == (BASE | new_fw.type) &&
1020 priv->cur_fw.std_req == std) {
1021 dprintk(1, "Std-specific firmware already loaded.\n");
1022 goto skip_std_specific;
1023 }
1024
1025 /* Reloading std-specific firmware forces a SCODE update */
1026 priv->cur_fw.scode_table = 0;
1027
1028 /* Load the standard firmware */
1029 rc = load_firmware(fe, new_fw.type, &new_fw.id);
1030
1031 if (rc < 0)
1032 goto fail;
1033
1034 skip_std_specific:
1035 if (priv->cur_fw.scode_table == new_fw.scode_table &&
1036 priv->cur_fw.scode_nr == new_fw.scode_nr) {
1037 dprintk(1, "SCODE firmware already loaded.\n");
1038 goto check_device;
1039 }
1040
1041 if (new_fw.type & FM)
1042 goto check_device;
1043
1044 /* Load SCODE firmware, if exists */
1045 rc = load_scode(fe, new_fw.type | new_fw.scode_table, &new_fw.id,
1046 new_fw.int_freq, new_fw.scode_nr);
1047 if (rc != XC_RESULT_SUCCESS)
1048 dprintk(1, "load scode failed %d\n", rc);
1049
1050 check_device:
1051 rc = xc4000_readreg(priv, XREG_PRODUCT_ID, &hwmodel);
1052
1053 if (xc_get_version(priv, &hw_major, &hw_minor, &fw_major,
1054 &fw_minor) != XC_RESULT_SUCCESS) {
1055 printk("Unable to read tuner registers.\n");
1056 goto fail;
1057 }
1058
1059 dprintk(1, "Device is Xceive %d version %d.%d, "
1060 "firmware version %d.%d\n",
1061 hwmodel, hw_major, hw_minor, fw_major, fw_minor);
1062
1063 /* Check firmware version against what we downloaded. */
1064 #ifdef DJH_DEBUG
1065 if (priv->firm_version != ((version & 0xf0) << 4 | (version & 0x0f))) {
1066 printk("Incorrect readback of firmware version %x.\n",
1067 (version & 0xff));
1068 goto fail;
1069 }
1070 #endif
1071
1072 /* Check that the tuner hardware model remains consistent over time. */
1073 if (priv->hwmodel == 0 && hwmodel == 4000) {
1074 priv->hwmodel = hwmodel;
1075 priv->hwvers = version & 0xff00;
1076 } else if (priv->hwmodel == 0 || priv->hwmodel != hwmodel ||
1077 priv->hwvers != (version & 0xff00)) {
1078 printk("Read invalid device hardware information - tuner "
1079 "hung?\n");
1080 goto fail;
1081 }
1082
1083 memcpy(&priv->cur_fw, &new_fw, sizeof(priv->cur_fw));
1084
1085 /*
1086 * By setting BASE in cur_fw.type only after successfully loading all
1087 * firmwares, we can:
1088 * 1. Identify that BASE firmware with type=0 has been loaded;
1089 * 2. Tell whether BASE firmware was just changed the next time through.
1090 */
1091 priv->cur_fw.type |= BASE;
1092
1093 return 0;
1094
1095 fail:
1096 memset(&priv->cur_fw, 0, sizeof(priv->cur_fw));
1097 if (!is_retry) {
1098 msleep(50);
1099 is_retry = 1;
1100 dprintk(1, "Retrying firmware load\n");
1101 goto retry;
1102 }
1103
1104 if (rc == -ENOENT)
1105 rc = -EINVAL;
1106 return rc;
1107 }
1108
1109 static void xc_debug_dump(struct xc4000_priv *priv)
1110 {
1111 u16 adc_envelope;
1112 u32 freq_error_hz = 0;
1113 u16 lock_status;
1114 u32 hsync_freq_hz = 0;
1115 u16 frame_lines;
1116 u16 quality;
1117 u8 hw_majorversion = 0, hw_minorversion = 0;
1118 u8 fw_majorversion = 0, fw_minorversion = 0;
1119
1120 /* Wait for stats to stabilize.
1121 * Frame Lines needs two frame times after initial lock
1122 * before it is valid.
1123 */
1124 xc_wait(100);
1125
1126 xc_get_ADC_Envelope(priv, &adc_envelope);
1127 dprintk(1, "*** ADC envelope (0-1023) = %d\n", adc_envelope);
1128
1129 xc_get_frequency_error(priv, &freq_error_hz);
1130 dprintk(1, "*** Frequency error = %d Hz\n", freq_error_hz);
1131
1132 xc_get_lock_status(priv, &lock_status);
1133 dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %d\n",
1134 lock_status);
1135
1136 xc_get_version(priv, &hw_majorversion, &hw_minorversion,
1137 &fw_majorversion, &fw_minorversion);
1138
1139 dprintk(1, "*** HW: V%02x.%02x, FW: V%02x.%02x\n",
1140 hw_majorversion, hw_minorversion,
1141 fw_majorversion, fw_minorversion);
1142
1143 xc_get_hsync_freq(priv, &hsync_freq_hz);
1144 dprintk(1, "*** Horizontal sync frequency = %d Hz\n", hsync_freq_hz);
1145
1146 xc_get_frame_lines(priv, &frame_lines);
1147 dprintk(1, "*** Frame lines = %d\n", frame_lines);
1148
1149 xc_get_quality(priv, &quality);
1150 dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %d\n", quality);
1151 }
1152
1153 static int xc4000_set_params(struct dvb_frontend *fe,
1154 struct dvb_frontend_parameters *params)
1155 {
1156 struct xc4000_priv *priv = fe->tuner_priv;
1157 unsigned int type;
1158 int ret = -EREMOTEIO;
1159
1160 dprintk(1, "%s() frequency=%d (Hz)\n", __func__, params->frequency);
1161
1162 mutex_lock(&priv->lock);
1163
1164 if (fe->ops.info.type == FE_ATSC) {
1165 dprintk(1, "%s() ATSC\n", __func__);
1166 switch (params->u.vsb.modulation) {
1167 case VSB_8:
1168 case VSB_16:
1169 dprintk(1, "%s() VSB modulation\n", __func__);
1170 priv->rf_mode = XC_RF_MODE_AIR;
1171 priv->freq_hz = params->frequency - 1750000;
1172 priv->bandwidth = BANDWIDTH_6_MHZ;
1173 priv->video_standard = XC4000_DTV6;
1174 type = DTV6;
1175 break;
1176 case QAM_64:
1177 case QAM_256:
1178 case QAM_AUTO:
1179 dprintk(1, "%s() QAM modulation\n", __func__);
1180 priv->rf_mode = XC_RF_MODE_CABLE;
1181 priv->freq_hz = params->frequency - 1750000;
1182 priv->bandwidth = BANDWIDTH_6_MHZ;
1183 priv->video_standard = XC4000_DTV6;
1184 type = DTV6;
1185 break;
1186 default:
1187 ret = -EINVAL;
1188 goto fail;
1189 }
1190 } else if (fe->ops.info.type == FE_OFDM) {
1191 dprintk(1, "%s() OFDM\n", __func__);
1192 switch (params->u.ofdm.bandwidth) {
1193 case BANDWIDTH_6_MHZ:
1194 priv->bandwidth = BANDWIDTH_6_MHZ;
1195 priv->video_standard = XC4000_DTV6;
1196 priv->freq_hz = params->frequency - 1750000;
1197 type = DTV6;
1198 break;
1199 case BANDWIDTH_7_MHZ:
1200 priv->bandwidth = BANDWIDTH_7_MHZ;
1201 priv->video_standard = XC4000_DTV7;
1202 priv->freq_hz = params->frequency - 2250000;
1203 type = DTV7;
1204 break;
1205 case BANDWIDTH_8_MHZ:
1206 priv->bandwidth = BANDWIDTH_8_MHZ;
1207 priv->video_standard = XC4000_DTV8;
1208 priv->freq_hz = params->frequency - 2750000;
1209 type = DTV8;
1210 break;
1211 case BANDWIDTH_AUTO:
1212 if (params->frequency < 400000000) {
1213 priv->bandwidth = BANDWIDTH_7_MHZ;
1214 priv->freq_hz = params->frequency - 2250000;
1215 } else {
1216 priv->bandwidth = BANDWIDTH_8_MHZ;
1217 priv->freq_hz = params->frequency - 2750000;
1218 }
1219 priv->video_standard = XC4000_DTV7_8;
1220 type = DTV78;
1221 break;
1222 default:
1223 printk(KERN_ERR "xc4000 bandwidth not set!\n");
1224 ret = -EINVAL;
1225 goto fail;
1226 }
1227 priv->rf_mode = XC_RF_MODE_AIR;
1228 } else {
1229 printk(KERN_ERR "xc4000 modulation type not supported!\n");
1230 ret = -EINVAL;
1231 goto fail;
1232 }
1233
1234 dprintk(1, "%s() frequency=%d (compensated)\n",
1235 __func__, priv->freq_hz);
1236
1237 /* Make sure the correct firmware type is loaded */
1238 if (check_firmware(fe, type, 0, priv->if_khz) != XC_RESULT_SUCCESS)
1239 goto fail;
1240
1241 ret = xc_SetSignalSource(priv, priv->rf_mode);
1242 if (ret != XC_RESULT_SUCCESS) {
1243 printk(KERN_ERR
1244 "xc4000: xc_SetSignalSource(%d) failed\n",
1245 priv->rf_mode);
1246 goto fail;
1247 }
1248
1249 ret = xc_SetTVStandard(priv,
1250 XC4000_Standard[priv->video_standard].VideoMode,
1251 XC4000_Standard[priv->video_standard].AudioMode);
1252 if (ret != XC_RESULT_SUCCESS) {
1253 printk(KERN_ERR "xc4000: xc_SetTVStandard failed\n");
1254 goto fail;
1255 }
1256 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_DIGITAL);
1257
1258 if (debug)
1259 xc_debug_dump(priv);
1260
1261 ret = 0;
1262
1263 fail:
1264 mutex_unlock(&priv->lock);
1265
1266 return ret;
1267 }
1268
1269 static int xc4000_set_analog_params(struct dvb_frontend *fe,
1270 struct analog_parameters *params)
1271 {
1272 struct xc4000_priv *priv = fe->tuner_priv;
1273 int ret = -EREMOTEIO;
1274
1275 dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
1276 __func__, params->frequency);
1277
1278 mutex_lock(&priv->lock);
1279
1280 /* Fix me: it could be air. */
1281 priv->rf_mode = params->mode;
1282 if (params->mode > XC_RF_MODE_CABLE)
1283 priv->rf_mode = XC_RF_MODE_CABLE;
1284
1285 /* params->frequency is in units of 62.5khz */
1286 priv->freq_hz = params->frequency * 62500;
1287
1288 /* FIX ME: Some video standards may have several possible audio
1289 standards. We simply default to one of them here.
1290 */
1291 if (params->std & V4L2_STD_MN) {
1292 /* default to BTSC audio standard */
1293 priv->video_standard = XC4000_MN_NTSC_PAL_BTSC;
1294 goto tune_channel;
1295 }
1296
1297 if (params->std & V4L2_STD_PAL_BG) {
1298 /* default to NICAM audio standard */
1299 priv->video_standard = XC4000_BG_PAL_NICAM;
1300 goto tune_channel;
1301 }
1302
1303 if (params->std & V4L2_STD_PAL_I) {
1304 /* default to NICAM audio standard */
1305 priv->video_standard = XC4000_I_PAL_NICAM;
1306 goto tune_channel;
1307 }
1308
1309 if (params->std & V4L2_STD_PAL_DK) {
1310 /* default to NICAM audio standard */
1311 priv->video_standard = XC4000_DK_PAL_NICAM;
1312 goto tune_channel;
1313 }
1314
1315 if (params->std & V4L2_STD_SECAM_DK) {
1316 /* default to A2 DK1 audio standard */
1317 priv->video_standard = XC4000_DK_SECAM_A2DK1;
1318 goto tune_channel;
1319 }
1320
1321 if (params->std & V4L2_STD_SECAM_L) {
1322 priv->video_standard = XC4000_L_SECAM_NICAM;
1323 goto tune_channel;
1324 }
1325
1326 if (params->std & V4L2_STD_SECAM_LC) {
1327 priv->video_standard = XC4000_LC_SECAM_NICAM;
1328 goto tune_channel;
1329 }
1330
1331 tune_channel:
1332
1333 /* FIXME - firmware type not being set properly */
1334 if (check_firmware(fe, DTV8, 0, priv->if_khz) != XC_RESULT_SUCCESS)
1335 goto fail;
1336
1337 ret = xc_SetSignalSource(priv, priv->rf_mode);
1338 if (ret != XC_RESULT_SUCCESS) {
1339 printk(KERN_ERR
1340 "xc4000: xc_SetSignalSource(%d) failed\n",
1341 priv->rf_mode);
1342 goto fail;
1343 }
1344
1345 ret = xc_SetTVStandard(priv,
1346 XC4000_Standard[priv->video_standard].VideoMode,
1347 XC4000_Standard[priv->video_standard].AudioMode);
1348 if (ret != XC_RESULT_SUCCESS) {
1349 printk(KERN_ERR "xc4000: xc_SetTVStandard failed\n");
1350 goto fail;
1351 }
1352
1353 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
1354
1355 if (debug)
1356 xc_debug_dump(priv);
1357
1358 ret = 0;
1359
1360 fail:
1361 mutex_unlock(&priv->lock);
1362
1363 return ret;
1364 }
1365
1366 static int xc4000_get_frequency(struct dvb_frontend *fe, u32 *freq)
1367 {
1368 struct xc4000_priv *priv = fe->tuner_priv;
1369 dprintk(1, "%s()\n", __func__);
1370 *freq = priv->freq_hz;
1371 return 0;
1372 }
1373
1374 static int xc4000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
1375 {
1376 struct xc4000_priv *priv = fe->tuner_priv;
1377 dprintk(1, "%s()\n", __func__);
1378
1379 *bw = priv->bandwidth;
1380 return 0;
1381 }
1382
1383 static int xc4000_get_status(struct dvb_frontend *fe, u32 *status)
1384 {
1385 struct xc4000_priv *priv = fe->tuner_priv;
1386 u16 lock_status = 0;
1387
1388 mutex_lock(&priv->lock);
1389
1390 xc_get_lock_status(priv, &lock_status);
1391
1392 mutex_unlock(&priv->lock);
1393
1394 dprintk(1, "%s() lock_status = 0x%08x\n", __func__, lock_status);
1395
1396 *status = lock_status;
1397
1398 return 0;
1399 }
1400
1401 static int xc4000_sleep(struct dvb_frontend *fe)
1402 {
1403 /* FIXME: djh disable this for now... */
1404 return XC_RESULT_SUCCESS;
1405 }
1406
1407 static int xc4000_init(struct dvb_frontend *fe)
1408 {
1409 struct xc4000_priv *priv = fe->tuner_priv;
1410 int ret;
1411 dprintk(1, "%s()\n", __func__);
1412
1413 mutex_lock(&priv->lock);
1414 ret = check_firmware(fe, DTV8, 0, priv->if_khz);
1415 mutex_unlock(&priv->lock);
1416 if (ret != XC_RESULT_SUCCESS) {
1417 printk(KERN_ERR "xc4000: Unable to initialise tuner\n");
1418 return -EREMOTEIO;
1419 }
1420
1421 if (debug)
1422 xc_debug_dump(priv);
1423
1424 return 0;
1425 }
1426
1427 static int xc4000_release(struct dvb_frontend *fe)
1428 {
1429 struct xc4000_priv *priv = fe->tuner_priv;
1430
1431 dprintk(1, "%s()\n", __func__);
1432
1433 mutex_lock(&xc4000_list_mutex);
1434
1435 if (priv)
1436 hybrid_tuner_release_state(priv);
1437
1438 mutex_unlock(&xc4000_list_mutex);
1439
1440 fe->tuner_priv = NULL;
1441
1442 return 0;
1443 }
1444
1445 static const struct dvb_tuner_ops xc4000_tuner_ops = {
1446 .info = {
1447 .name = "Xceive XC4000",
1448 .frequency_min = 1000000,
1449 .frequency_max = 1023000000,
1450 .frequency_step = 50000,
1451 },
1452
1453 .release = xc4000_release,
1454 .init = xc4000_init,
1455 .sleep = xc4000_sleep,
1456
1457 .set_params = xc4000_set_params,
1458 .set_analog_params = xc4000_set_analog_params,
1459 .get_frequency = xc4000_get_frequency,
1460 .get_bandwidth = xc4000_get_bandwidth,
1461 .get_status = xc4000_get_status
1462 };
1463
1464 struct dvb_frontend *xc4000_attach(struct dvb_frontend *fe,
1465 struct i2c_adapter *i2c,
1466 struct xc4000_config *cfg)
1467 {
1468 struct xc4000_priv *priv = NULL;
1469 int instance;
1470 u16 id = 0;
1471
1472 dprintk(1, "%s(%d-%04x)\n", __func__,
1473 i2c ? i2c_adapter_id(i2c) : -1,
1474 cfg ? cfg->i2c_address : -1);
1475
1476 mutex_lock(&xc4000_list_mutex);
1477
1478 instance = hybrid_tuner_request_state(struct xc4000_priv, priv,
1479 hybrid_tuner_instance_list,
1480 i2c, cfg->i2c_address, "xc4000");
1481 switch (instance) {
1482 case 0:
1483 goto fail;
1484 break;
1485 case 1:
1486 /* new tuner instance */
1487 priv->bandwidth = BANDWIDTH_6_MHZ;
1488 mutex_init(&priv->lock);
1489 fe->tuner_priv = priv;
1490 break;
1491 default:
1492 /* existing tuner instance */
1493 fe->tuner_priv = priv;
1494 break;
1495 }
1496
1497 if (priv->if_khz == 0) {
1498 /* If the IF hasn't been set yet, use the value provided by
1499 the caller (occurs in hybrid devices where the analog
1500 call to xc4000_attach occurs before the digital side) */
1501 priv->if_khz = cfg->if_khz;
1502 }
1503
1504 /* Check if firmware has been loaded. It is possible that another
1505 instance of the driver has loaded the firmware.
1506 */
1507
1508 if (xc4000_readreg(priv, XREG_PRODUCT_ID, &id) != XC_RESULT_SUCCESS)
1509 goto fail;
1510
1511 switch (id) {
1512 case XC_PRODUCT_ID_FW_LOADED:
1513 printk(KERN_INFO
1514 "xc4000: Successfully identified at address 0x%02x\n",
1515 cfg->i2c_address);
1516 printk(KERN_INFO
1517 "xc4000: Firmware has been loaded previously\n");
1518 break;
1519 case XC_PRODUCT_ID_FW_NOT_LOADED:
1520 printk(KERN_INFO
1521 "xc4000: Successfully identified at address 0x%02x\n",
1522 cfg->i2c_address);
1523 printk(KERN_INFO
1524 "xc4000: Firmware has not been loaded previously\n");
1525 break;
1526 default:
1527 printk(KERN_ERR
1528 "xc4000: Device not found at addr 0x%02x (0x%x)\n",
1529 cfg->i2c_address, id);
1530 goto fail;
1531 }
1532
1533 mutex_unlock(&xc4000_list_mutex);
1534
1535 memcpy(&fe->ops.tuner_ops, &xc4000_tuner_ops,
1536 sizeof(struct dvb_tuner_ops));
1537
1538 /* FIXME: For now, load the firmware at startup. We will remove this
1539 before the code goes to production... */
1540 mutex_lock(&priv->lock);
1541 check_firmware(fe, DTV8, 0, priv->if_khz);
1542 mutex_unlock(&priv->lock);
1543
1544 return fe;
1545 fail:
1546 mutex_unlock(&xc4000_list_mutex);
1547
1548 xc4000_release(fe);
1549 return NULL;
1550 }
1551 EXPORT_SYMBOL(xc4000_attach);
1552
1553 MODULE_AUTHOR("Steven Toth, Davide Ferri");
1554 MODULE_DESCRIPTION("Xceive xc4000 silicon tuner driver");
1555 MODULE_LICENSE("GPL");
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree