Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
xc4000.c
Go to the documentation of this file.
1 /*
2  * Driver for Xceive XC4000 "QAM/8VSB single chip tuner"
3  *
4  * Copyright (c) 2007 Xceive Corporation
5  * Copyright (c) 2007 Steven Toth <[email protected]>
6  * Copyright (c) 2009 Devin Heitmueller <[email protected]>
7  * Copyright (c) 2009 Davide Ferri <[email protected]>
8  * Copyright (c) 2010 Istvan Varga <[email protected]>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
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, "Debugging level (0 to 2, default: 0 (off)).");
43 
44 static int no_poweroff;
45 module_param(no_poweroff, int, 0644);
46 MODULE_PARM_DESC(no_poweroff, "Power management (1: disabled, 2: enabled, "
47  "0 (default): use device-specific default mode).");
48 
49 static int audio_std;
50 module_param(audio_std, int, 0644);
51 MODULE_PARM_DESC(audio_std, "Audio standard. XC4000 audio decoder explicitly "
52  "needs to know what audio standard is needed for some video standards "
53  "with audio A2 or NICAM. The valid settings are a sum of:\n"
54  " 1: use NICAM/B or A2/B instead of NICAM/A or A2/A\n"
55  " 2: use A2 instead of NICAM or BTSC\n"
56  " 4: use SECAM/K3 instead of K1\n"
57  " 8: use PAL-D/K audio for SECAM-D/K\n"
58  "16: use FM radio input 1 instead of input 2\n"
59  "32: use mono audio (the lower three bits are ignored)");
60 
61 static char firmware_name[30];
62 module_param_string(firmware_name, firmware_name, sizeof(firmware_name), 0);
63 MODULE_PARM_DESC(firmware_name, "Firmware file name. Allows overriding the "
64  "default firmware name.");
65 
66 static DEFINE_MUTEX(xc4000_list_mutex);
67 static LIST_HEAD(hybrid_tuner_instance_list);
68 
69 #define dprintk(level, fmt, arg...) if (debug >= level) \
70  printk(KERN_INFO "%s: " fmt, "xc4000", ## arg)
71 
72 /* struct for storing firmware table */
73 struct firmware_description {
74  unsigned int type;
77  unsigned char *ptr;
78  unsigned int size;
79 };
80 
81 struct firmware_properties {
82  unsigned int type;
86  unsigned int scode_table;
87  int scode_nr;
88 };
89 
90 struct xc4000_priv {
94  int firm_size;
108  struct mutex lock;
109 };
110 
111 #define XC4000_AUDIO_STD_B 1
112 #define XC4000_AUDIO_STD_A2 2
113 #define XC4000_AUDIO_STD_K3 4
114 #define XC4000_AUDIO_STD_L 8
115 #define XC4000_AUDIO_STD_INPUT1 16
116 #define XC4000_AUDIO_STD_MONO 32
117 
118 #define XC4000_DEFAULT_FIRMWARE "dvb-fe-xc4000-1.4.fw"
119 
120 /* Misc Defines */
121 #define MAX_TV_STANDARD 24
122 #define XC_MAX_I2C_WRITE_LENGTH 64
123 #define XC_POWERED_DOWN 0x80000000U
124 
125 /* Signal Types */
126 #define XC_RF_MODE_AIR 0
127 #define XC_RF_MODE_CABLE 1
128 
129 /* Product id */
130 #define XC_PRODUCT_ID_FW_NOT_LOADED 0x2000
131 #define XC_PRODUCT_ID_XC4000 0x0FA0
132 #define XC_PRODUCT_ID_XC4100 0x1004
133 
134 /* Registers (Write-only) */
135 #define XREG_INIT 0x00
136 #define XREG_VIDEO_MODE 0x01
137 #define XREG_AUDIO_MODE 0x02
138 #define XREG_RF_FREQ 0x03
139 #define XREG_D_CODE 0x04
140 #define XREG_DIRECTSITTING_MODE 0x05
141 #define XREG_SEEK_MODE 0x06
142 #define XREG_POWER_DOWN 0x08
143 #define XREG_SIGNALSOURCE 0x0A
144 #define XREG_SMOOTHEDCVBS 0x0E
145 #define XREG_AMPLITUDE 0x10
146 
147 /* Registers (Read-only) */
148 #define XREG_ADC_ENV 0x00
149 #define XREG_QUALITY 0x01
150 #define XREG_FRAME_LINES 0x02
151 #define XREG_HSYNC_FREQ 0x03
152 #define XREG_LOCK 0x04
153 #define XREG_FREQ_ERROR 0x05
154 #define XREG_SNR 0x06
155 #define XREG_VERSION 0x07
156 #define XREG_PRODUCT_ID 0x08
157 #define XREG_SIGNAL_LEVEL 0x0A
158 #define XREG_NOISE_LEVEL 0x0B
159 
160 /*
161  Basic firmware description. This will remain with
162  the driver for documentation purposes.
163 
164  This represents an I2C firmware file encoded as a
165  string of unsigned char. Format is as follows:
166 
167  char[0 ]=len0_MSB -> len = len_MSB * 256 + len_LSB
168  char[1 ]=len0_LSB -> length of first write transaction
169  char[2 ]=data0 -> first byte to be sent
170  char[3 ]=data1
171  char[4 ]=data2
172  char[ ]=...
173  char[M ]=dataN -> last byte to be sent
174  char[M+1]=len1_MSB -> len = len_MSB * 256 + len_LSB
175  char[M+2]=len1_LSB -> length of second write transaction
176  char[M+3]=data0
177  char[M+4]=data1
178  ...
179  etc.
180 
181  The [len] value should be interpreted as follows:
182 
183  len= len_MSB _ len_LSB
184  len=1111_1111_1111_1111 : End of I2C_SEQUENCE
185  len=0000_0000_0000_0000 : Reset command: Do hardware reset
186  len=0NNN_NNNN_NNNN_NNNN : Normal transaction: number of bytes = {1:32767)
187  len=1WWW_WWWW_WWWW_WWWW : Wait command: wait for {1:32767} ms
188 
189  For the RESET and WAIT commands, the two following bytes will contain
190  immediately the length of the following transaction.
191 */
192 
194  const char *Name;
198 };
199 
200 /* Tuner standards */
201 #define XC4000_MN_NTSC_PAL_BTSC 0
202 #define XC4000_MN_NTSC_PAL_A2 1
203 #define XC4000_MN_NTSC_PAL_EIAJ 2
204 #define XC4000_MN_NTSC_PAL_Mono 3
205 #define XC4000_BG_PAL_A2 4
206 #define XC4000_BG_PAL_NICAM 5
207 #define XC4000_BG_PAL_MONO 6
208 #define XC4000_I_PAL_NICAM 7
209 #define XC4000_I_PAL_NICAM_MONO 8
210 #define XC4000_DK_PAL_A2 9
211 #define XC4000_DK_PAL_NICAM 10
212 #define XC4000_DK_PAL_MONO 11
213 #define XC4000_DK_SECAM_A2DK1 12
214 #define XC4000_DK_SECAM_A2LDK3 13
215 #define XC4000_DK_SECAM_A2MONO 14
216 #define XC4000_DK_SECAM_NICAM 15
217 #define XC4000_L_SECAM_NICAM 16
218 #define XC4000_LC_SECAM_NICAM 17
219 #define XC4000_DTV6 18
220 #define XC4000_DTV8 19
221 #define XC4000_DTV7_8 20
222 #define XC4000_DTV7 21
223 #define XC4000_FM_Radio_INPUT2 22
224 #define XC4000_FM_Radio_INPUT1 23
225 
226 static struct XC_TV_STANDARD xc4000_standard[MAX_TV_STANDARD] = {
227  {"M/N-NTSC/PAL-BTSC", 0x0000, 0x80A0, 4500},
228  {"M/N-NTSC/PAL-A2", 0x0000, 0x80A0, 4600},
229  {"M/N-NTSC/PAL-EIAJ", 0x0040, 0x80A0, 4500},
230  {"M/N-NTSC/PAL-Mono", 0x0078, 0x80A0, 4500},
231  {"B/G-PAL-A2", 0x0000, 0x8159, 5640},
232  {"B/G-PAL-NICAM", 0x0004, 0x8159, 5740},
233  {"B/G-PAL-MONO", 0x0078, 0x8159, 5500},
234  {"I-PAL-NICAM", 0x0080, 0x8049, 6240},
235  {"I-PAL-NICAM-MONO", 0x0078, 0x8049, 6000},
236  {"D/K-PAL-A2", 0x0000, 0x8049, 6380},
237  {"D/K-PAL-NICAM", 0x0080, 0x8049, 6200},
238  {"D/K-PAL-MONO", 0x0078, 0x8049, 6500},
239  {"D/K-SECAM-A2 DK1", 0x0000, 0x8049, 6340},
240  {"D/K-SECAM-A2 L/DK3", 0x0000, 0x8049, 6000},
241  {"D/K-SECAM-A2 MONO", 0x0078, 0x8049, 6500},
242  {"D/K-SECAM-NICAM", 0x0080, 0x8049, 6200},
243  {"L-SECAM-NICAM", 0x8080, 0x0009, 6200},
244  {"L'-SECAM-NICAM", 0x8080, 0x4009, 6200},
245  {"DTV6", 0x00C0, 0x8002, 0},
246  {"DTV8", 0x00C0, 0x800B, 0},
247  {"DTV7/8", 0x00C0, 0x801B, 0},
248  {"DTV7", 0x00C0, 0x8007, 0},
249  {"FM Radio-INPUT2", 0x0008, 0x9800, 10700},
250  {"FM Radio-INPUT1", 0x0008, 0x9000, 10700}
251 };
252 
253 static int xc4000_readreg(struct xc4000_priv *priv, u16 reg, u16 *val);
254 static int xc4000_tuner_reset(struct dvb_frontend *fe);
255 static void xc_debug_dump(struct xc4000_priv *priv);
256 
257 static int xc_send_i2c_data(struct xc4000_priv *priv, u8 *buf, int len)
258 {
259  struct i2c_msg msg = { .addr = priv->i2c_props.addr,
260  .flags = 0, .buf = buf, .len = len };
261  if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
262  if (priv->ignore_i2c_write_errors == 0) {
263  printk(KERN_ERR "xc4000: I2C write failed (len=%i)\n",
264  len);
265  if (len == 4) {
266  printk(KERN_ERR "bytes %*ph\n", 4, buf);
267  }
268  return -EREMOTEIO;
269  }
270  }
271  return 0;
272 }
273 
274 static int xc4000_tuner_reset(struct dvb_frontend *fe)
275 {
276  struct xc4000_priv *priv = fe->tuner_priv;
277  int ret;
278 
279  dprintk(1, "%s()\n", __func__);
280 
281  if (fe->callback) {
282  ret = fe->callback(((fe->dvb) && (fe->dvb->priv)) ?
283  fe->dvb->priv :
284  priv->i2c_props.adap->algo_data,
286  XC4000_TUNER_RESET, 0);
287  if (ret) {
288  printk(KERN_ERR "xc4000: reset failed\n");
289  return -EREMOTEIO;
290  }
291  } else {
292  printk(KERN_ERR "xc4000: no tuner reset callback function, "
293  "fatal\n");
294  return -EINVAL;
295  }
296  return 0;
297 }
298 
299 static int xc_write_reg(struct xc4000_priv *priv, u16 regAddr, u16 i2cData)
300 {
301  u8 buf[4];
302  int result;
303 
304  buf[0] = (regAddr >> 8) & 0xFF;
305  buf[1] = regAddr & 0xFF;
306  buf[2] = (i2cData >> 8) & 0xFF;
307  buf[3] = i2cData & 0xFF;
308  result = xc_send_i2c_data(priv, buf, 4);
309 
310  return result;
311 }
312 
313 static int xc_load_i2c_sequence(struct dvb_frontend *fe, const u8 *i2c_sequence)
314 {
315  struct xc4000_priv *priv = fe->tuner_priv;
316 
317  int i, nbytes_to_send, result;
318  unsigned int len, pos, index;
320 
321  index = 0;
322  while ((i2c_sequence[index] != 0xFF) ||
323  (i2c_sequence[index + 1] != 0xFF)) {
324  len = i2c_sequence[index] * 256 + i2c_sequence[index+1];
325  if (len == 0x0000) {
326  /* RESET command */
327  /* NOTE: this is ignored, as the reset callback was */
328  /* already called by check_firmware() */
329  index += 2;
330  } else if (len & 0x8000) {
331  /* WAIT command */
332  msleep(len & 0x7FFF);
333  index += 2;
334  } else {
335  /* Send i2c data whilst ensuring individual transactions
336  * do not exceed XC_MAX_I2C_WRITE_LENGTH bytes.
337  */
338  index += 2;
339  buf[0] = i2c_sequence[index];
340  buf[1] = i2c_sequence[index + 1];
341  pos = 2;
342  while (pos < len) {
343  if ((len - pos) > XC_MAX_I2C_WRITE_LENGTH - 2)
344  nbytes_to_send =
346  else
347  nbytes_to_send = (len - pos + 2);
348  for (i = 2; i < nbytes_to_send; i++) {
349  buf[i] = i2c_sequence[index + pos +
350  i - 2];
351  }
352  result = xc_send_i2c_data(priv, buf,
353  nbytes_to_send);
354 
355  if (result != 0)
356  return result;
357 
358  pos += nbytes_to_send - 2;
359  }
360  index += len;
361  }
362  }
363  return 0;
364 }
365 
366 static int xc_set_tv_standard(struct xc4000_priv *priv,
368 {
369  int ret;
370  dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, video_mode, audio_mode);
371  dprintk(1, "%s() Standard = %s\n",
372  __func__,
373  xc4000_standard[priv->video_standard].Name);
374 
375  /* Don't complain when the request fails because of i2c stretching */
376  priv->ignore_i2c_write_errors = 1;
377 
378  ret = xc_write_reg(priv, XREG_VIDEO_MODE, video_mode);
379  if (ret == 0)
380  ret = xc_write_reg(priv, XREG_AUDIO_MODE, audio_mode);
381 
382  priv->ignore_i2c_write_errors = 0;
383 
384  return ret;
385 }
386 
387 static int xc_set_signal_source(struct xc4000_priv *priv, u16 rf_mode)
388 {
389  dprintk(1, "%s(%d) Source = %s\n", __func__, rf_mode,
390  rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE");
391 
392  if ((rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE)) {
393  rf_mode = XC_RF_MODE_CABLE;
395  "%s(), Invalid mode, defaulting to CABLE",
396  __func__);
397  }
398  return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode);
399 }
400 
401 static const struct dvb_tuner_ops xc4000_tuner_ops;
402 
403 static int xc_set_rf_frequency(struct xc4000_priv *priv, u32 freq_hz)
404 {
405  u16 freq_code;
406 
407  dprintk(1, "%s(%u)\n", __func__, freq_hz);
408 
409  if ((freq_hz > xc4000_tuner_ops.info.frequency_max) ||
410  (freq_hz < xc4000_tuner_ops.info.frequency_min))
411  return -EINVAL;
412 
413  freq_code = (u16)(freq_hz / 15625);
414 
415  /* WAS: Starting in firmware version 1.1.44, Xceive recommends using the
416  FINERFREQ for all normal tuning (the doc indicates reg 0x03 should
417  only be used for fast scanning for channel lock) */
418  /* WAS: XREG_FINERFREQ */
419  return xc_write_reg(priv, XREG_RF_FREQ, freq_code);
420 }
421 
422 static int xc_get_adc_envelope(struct xc4000_priv *priv, u16 *adc_envelope)
423 {
424  return xc4000_readreg(priv, XREG_ADC_ENV, adc_envelope);
425 }
426 
427 static int xc_get_frequency_error(struct xc4000_priv *priv, u32 *freq_error_hz)
428 {
429  int result;
430  u16 regData;
431  u32 tmp;
432 
433  result = xc4000_readreg(priv, XREG_FREQ_ERROR, &regData);
434  if (result != 0)
435  return result;
436 
437  tmp = (u32)regData & 0xFFFFU;
438  tmp = (tmp < 0x8000U ? tmp : 0x10000U - tmp);
439  (*freq_error_hz) = tmp * 15625;
440  return result;
441 }
442 
443 static int xc_get_lock_status(struct xc4000_priv *priv, u16 *lock_status)
444 {
445  return xc4000_readreg(priv, XREG_LOCK, lock_status);
446 }
447 
448 static int xc_get_version(struct xc4000_priv *priv,
449  u8 *hw_majorversion, u8 *hw_minorversion,
450  u8 *fw_majorversion, u8 *fw_minorversion)
451 {
452  u16 data;
453  int result;
454 
455  result = xc4000_readreg(priv, XREG_VERSION, &data);
456  if (result != 0)
457  return result;
458 
459  (*hw_majorversion) = (data >> 12) & 0x0F;
460  (*hw_minorversion) = (data >> 8) & 0x0F;
461  (*fw_majorversion) = (data >> 4) & 0x0F;
462  (*fw_minorversion) = data & 0x0F;
463 
464  return 0;
465 }
466 
467 static int xc_get_hsync_freq(struct xc4000_priv *priv, u32 *hsync_freq_hz)
468 {
469  u16 regData;
470  int result;
471 
472  result = xc4000_readreg(priv, XREG_HSYNC_FREQ, &regData);
473  if (result != 0)
474  return result;
475 
476  (*hsync_freq_hz) = ((regData & 0x0fff) * 763)/100;
477  return result;
478 }
479 
480 static int xc_get_frame_lines(struct xc4000_priv *priv, u16 *frame_lines)
481 {
482  return xc4000_readreg(priv, XREG_FRAME_LINES, frame_lines);
483 }
484 
485 static int xc_get_quality(struct xc4000_priv *priv, u16 *quality)
486 {
487  return xc4000_readreg(priv, XREG_QUALITY, quality);
488 }
489 
490 static int xc_get_signal_level(struct xc4000_priv *priv, u16 *signal)
491 {
492  return xc4000_readreg(priv, XREG_SIGNAL_LEVEL, signal);
493 }
494 
495 static int xc_get_noise_level(struct xc4000_priv *priv, u16 *noise)
496 {
497  return xc4000_readreg(priv, XREG_NOISE_LEVEL, noise);
498 }
499 
500 static u16 xc_wait_for_lock(struct xc4000_priv *priv)
501 {
502  u16 lock_state = 0;
503  int watchdog_count = 40;
504 
505  while ((lock_state == 0) && (watchdog_count > 0)) {
506  xc_get_lock_status(priv, &lock_state);
507  if (lock_state != 1) {
508  msleep(5);
509  watchdog_count--;
510  }
511  }
512  return lock_state;
513 }
514 
515 static int xc_tune_channel(struct xc4000_priv *priv, u32 freq_hz)
516 {
517  int found = 1;
518  int result;
519 
520  dprintk(1, "%s(%u)\n", __func__, freq_hz);
521 
522  /* Don't complain when the request fails because of i2c stretching */
523  priv->ignore_i2c_write_errors = 1;
524  result = xc_set_rf_frequency(priv, freq_hz);
525  priv->ignore_i2c_write_errors = 0;
526 
527  if (result != 0)
528  return 0;
529 
530  /* wait for lock only in analog TV mode */
531  if ((priv->cur_fw.type & (FM | DTV6 | DTV7 | DTV78 | DTV8)) == 0) {
532  if (xc_wait_for_lock(priv) != 1)
533  found = 0;
534  }
535 
536  /* Wait for stats to stabilize.
537  * Frame Lines needs two frame times after initial lock
538  * before it is valid.
539  */
540  msleep(debug ? 100 : 10);
541 
542  if (debug)
543  xc_debug_dump(priv);
544 
545  return found;
546 }
547 
548 static int xc4000_readreg(struct xc4000_priv *priv, u16 reg, u16 *val)
549 {
550  u8 buf[2] = { reg >> 8, reg & 0xff };
551  u8 bval[2] = { 0, 0 };
552  struct i2c_msg msg[2] = {
553  { .addr = priv->i2c_props.addr,
554  .flags = 0, .buf = &buf[0], .len = 2 },
555  { .addr = priv->i2c_props.addr,
556  .flags = I2C_M_RD, .buf = &bval[0], .len = 2 },
557  };
558 
559  if (i2c_transfer(priv->i2c_props.adap, msg, 2) != 2) {
560  printk(KERN_ERR "xc4000: I2C read failed\n");
561  return -EREMOTEIO;
562  }
563 
564  *val = (bval[0] << 8) | bval[1];
565  return 0;
566 }
567 
568 #define dump_firm_type(t) dump_firm_type_and_int_freq(t, 0)
569 static void dump_firm_type_and_int_freq(unsigned int type, u16 int_freq)
570 {
571  if (type & BASE)
572  printk(KERN_CONT "BASE ");
573  if (type & INIT1)
574  printk(KERN_CONT "INIT1 ");
575  if (type & F8MHZ)
576  printk(KERN_CONT "F8MHZ ");
577  if (type & MTS)
578  printk(KERN_CONT "MTS ");
579  if (type & D2620)
580  printk(KERN_CONT "D2620 ");
581  if (type & D2633)
582  printk(KERN_CONT "D2633 ");
583  if (type & DTV6)
584  printk(KERN_CONT "DTV6 ");
585  if (type & QAM)
586  printk(KERN_CONT "QAM ");
587  if (type & DTV7)
588  printk(KERN_CONT "DTV7 ");
589  if (type & DTV78)
590  printk(KERN_CONT "DTV78 ");
591  if (type & DTV8)
592  printk(KERN_CONT "DTV8 ");
593  if (type & FM)
594  printk(KERN_CONT "FM ");
595  if (type & INPUT1)
596  printk(KERN_CONT "INPUT1 ");
597  if (type & LCD)
598  printk(KERN_CONT "LCD ");
599  if (type & NOGD)
600  printk(KERN_CONT "NOGD ");
601  if (type & MONO)
602  printk(KERN_CONT "MONO ");
603  if (type & ATSC)
604  printk(KERN_CONT "ATSC ");
605  if (type & IF)
606  printk(KERN_CONT "IF ");
607  if (type & LG60)
608  printk(KERN_CONT "LG60 ");
609  if (type & ATI638)
610  printk(KERN_CONT "ATI638 ");
611  if (type & OREN538)
612  printk(KERN_CONT "OREN538 ");
613  if (type & OREN36)
614  printk(KERN_CONT "OREN36 ");
615  if (type & TOYOTA388)
616  printk(KERN_CONT "TOYOTA388 ");
617  if (type & TOYOTA794)
618  printk(KERN_CONT "TOYOTA794 ");
619  if (type & DIBCOM52)
620  printk(KERN_CONT "DIBCOM52 ");
621  if (type & ZARLINK456)
622  printk(KERN_CONT "ZARLINK456 ");
623  if (type & CHINA)
624  printk(KERN_CONT "CHINA ");
625  if (type & F6MHZ)
626  printk(KERN_CONT "F6MHZ ");
627  if (type & INPUT2)
628  printk(KERN_CONT "INPUT2 ");
629  if (type & SCODE)
630  printk(KERN_CONT "SCODE ");
631  if (type & HAS_IF)
632  printk(KERN_CONT "HAS_IF_%d ", int_freq);
633 }
634 
635 static int seek_firmware(struct dvb_frontend *fe, unsigned int type,
636  v4l2_std_id *id)
637 {
638  struct xc4000_priv *priv = fe->tuner_priv;
639  int i, best_i = -1;
640  unsigned int best_nr_diffs = 255U;
641 
642  if (!priv->firm) {
643  printk(KERN_ERR "Error! firmware not loaded\n");
644  return -EINVAL;
645  }
646 
647  if (((type & ~SCODE) == 0) && (*id == 0))
648  *id = V4L2_STD_PAL;
649 
650  /* Seek for generic video standard match */
651  for (i = 0; i < priv->firm_size; i++) {
652  v4l2_std_id id_diff_mask =
653  (priv->firm[i].id ^ (*id)) & (*id);
654  unsigned int type_diff_mask =
655  (priv->firm[i].type ^ type)
656  & (BASE_TYPES | DTV_TYPES | LCD | NOGD | MONO | SCODE);
657  unsigned int nr_diffs;
658 
659  if (type_diff_mask
660  & (BASE | INIT1 | FM | DTV6 | DTV7 | DTV78 | DTV8 | SCODE))
661  continue;
662 
663  nr_diffs = hweight64(id_diff_mask) + hweight32(type_diff_mask);
664  if (!nr_diffs) /* Supports all the requested standards */
665  goto found;
666 
667  if (nr_diffs < best_nr_diffs) {
668  best_nr_diffs = nr_diffs;
669  best_i = i;
670  }
671  }
672 
673  /* FIXME: Would make sense to seek for type "hint" match ? */
674  if (best_i < 0) {
675  i = -ENOENT;
676  goto ret;
677  }
678 
679  if (best_nr_diffs > 0U) {
681  "Selecting best matching firmware (%u bits differ) for "
682  "type=(%x), id %016llx:\n",
683  best_nr_diffs, type, (unsigned long long)*id);
684  i = best_i;
685  }
686 
687 found:
688  *id = priv->firm[i].id;
689 
690 ret:
691  if (debug) {
692  printk(KERN_DEBUG "%s firmware for type=",
693  (i < 0) ? "Can't find" : "Found");
694  dump_firm_type(type);
695  printk(KERN_DEBUG "(%x), id %016llx.\n", type, (unsigned long long)*id);
696  }
697  return i;
698 }
699 
700 static int load_firmware(struct dvb_frontend *fe, unsigned int type,
701  v4l2_std_id *id)
702 {
703  struct xc4000_priv *priv = fe->tuner_priv;
704  int pos, rc;
705  unsigned char *p;
706 
707  pos = seek_firmware(fe, type, id);
708  if (pos < 0)
709  return pos;
710 
711  p = priv->firm[pos].ptr;
712 
713  /* Don't complain when the request fails because of i2c stretching */
714  priv->ignore_i2c_write_errors = 1;
715 
716  rc = xc_load_i2c_sequence(fe, p);
717 
718  priv->ignore_i2c_write_errors = 0;
719 
720  return rc;
721 }
722 
723 static int xc4000_fwupload(struct dvb_frontend *fe)
724 {
725  struct xc4000_priv *priv = fe->tuner_priv;
726  const struct firmware *fw = NULL;
727  const unsigned char *p, *endp;
728  int rc = 0;
729  int n, n_array;
730  char name[33];
731  const char *fname;
732 
733  if (firmware_name[0] != '\0')
734  fname = firmware_name;
735  else
736  fname = XC4000_DEFAULT_FIRMWARE;
737 
738  dprintk(1, "Reading firmware %s\n", fname);
739  rc = request_firmware(&fw, fname, priv->i2c_props.adap->dev.parent);
740  if (rc < 0) {
741  if (rc == -ENOENT)
742  printk(KERN_ERR "Error: firmware %s not found.\n", fname);
743  else
744  printk(KERN_ERR "Error %d while requesting firmware %s\n",
745  rc, fname);
746 
747  return rc;
748  }
749  p = fw->data;
750  endp = p + fw->size;
751 
752  if (fw->size < sizeof(name) - 1 + 2 + 2) {
753  printk(KERN_ERR "Error: firmware file %s has invalid size!\n",
754  fname);
755  goto corrupt;
756  }
757 
758  memcpy(name, p, sizeof(name) - 1);
759  name[sizeof(name) - 1] = '\0';
760  p += sizeof(name) - 1;
761 
762  priv->firm_version = get_unaligned_le16(p);
763  p += 2;
764 
765  n_array = get_unaligned_le16(p);
766  p += 2;
767 
768  dprintk(1, "Loading %d firmware images from %s, type: %s, ver %d.%d\n",
769  n_array, fname, name,
770  priv->firm_version >> 8, priv->firm_version & 0xff);
771 
772  priv->firm = kcalloc(n_array, sizeof(*priv->firm), GFP_KERNEL);
773  if (priv->firm == NULL) {
774  printk(KERN_ERR "Not enough memory to load firmware file.\n");
775  rc = -ENOMEM;
776  goto done;
777  }
778  priv->firm_size = n_array;
779 
780  n = -1;
781  while (p < endp) {
782  __u32 type, size;
783  v4l2_std_id id;
784  __u16 int_freq = 0;
785 
786  n++;
787  if (n >= n_array) {
788  printk(KERN_ERR "More firmware images in file than "
789  "were expected!\n");
790  goto corrupt;
791  }
792 
793  /* Checks if there's enough bytes to read */
794  if (endp - p < sizeof(type) + sizeof(id) + sizeof(size))
795  goto header;
796 
797  type = get_unaligned_le32(p);
798  p += sizeof(type);
799 
800  id = get_unaligned_le64(p);
801  p += sizeof(id);
802 
803  if (type & HAS_IF) {
804  int_freq = get_unaligned_le16(p);
805  p += sizeof(int_freq);
806  if (endp - p < sizeof(size))
807  goto header;
808  }
809 
810  size = get_unaligned_le32(p);
811  p += sizeof(size);
812 
813  if (!size || size > endp - p) {
814  printk(KERN_ERR "Firmware type (%x), id %llx is corrupted (size=%d, expected %d)\n",
815  type, (unsigned long long)id,
816  (unsigned)(endp - p), size);
817  goto corrupt;
818  }
819 
820  priv->firm[n].ptr = kzalloc(size, GFP_KERNEL);
821  if (priv->firm[n].ptr == NULL) {
822  printk(KERN_ERR "Not enough memory to load firmware file.\n");
823  rc = -ENOMEM;
824  goto done;
825  }
826 
827  if (debug) {
828  printk(KERN_DEBUG "Reading firmware type ");
829  dump_firm_type_and_int_freq(type, int_freq);
830  printk(KERN_DEBUG "(%x), id %llx, size=%d.\n",
831  type, (unsigned long long)id, size);
832  }
833 
834  memcpy(priv->firm[n].ptr, p, size);
835  priv->firm[n].type = type;
836  priv->firm[n].id = id;
837  priv->firm[n].size = size;
838  priv->firm[n].int_freq = int_freq;
839 
840  p += size;
841  }
842 
843  if (n + 1 != priv->firm_size) {
844  printk(KERN_ERR "Firmware file is incomplete!\n");
845  goto corrupt;
846  }
847 
848  goto done;
849 
850 header:
851  printk(KERN_ERR "Firmware header is incomplete!\n");
852 corrupt:
853  rc = -EINVAL;
854  printk(KERN_ERR "Error: firmware file is corrupted!\n");
855 
856 done:
857  release_firmware(fw);
858  if (rc == 0)
859  dprintk(1, "Firmware files loaded.\n");
860 
861  return rc;
862 }
863 
864 static int load_scode(struct dvb_frontend *fe, unsigned int type,
865  v4l2_std_id *id, __u16 int_freq, int scode)
866 {
867  struct xc4000_priv *priv = fe->tuner_priv;
868  int pos, rc;
869  unsigned char *p;
870  u8 scode_buf[13];
871  u8 indirect_mode[5];
872 
873  dprintk(1, "%s called int_freq=%d\n", __func__, int_freq);
874 
875  if (!int_freq) {
876  pos = seek_firmware(fe, type, id);
877  if (pos < 0)
878  return pos;
879  } else {
880  for (pos = 0; pos < priv->firm_size; pos++) {
881  if ((priv->firm[pos].int_freq == int_freq) &&
882  (priv->firm[pos].type & HAS_IF))
883  break;
884  }
885  if (pos == priv->firm_size)
886  return -ENOENT;
887  }
888 
889  p = priv->firm[pos].ptr;
890 
891  if (priv->firm[pos].size != 12 * 16 || scode >= 16)
892  return -EINVAL;
893  p += 12 * scode;
894 
895  if (debug) {
896  tuner_info("Loading SCODE for type=");
897  dump_firm_type_and_int_freq(priv->firm[pos].type,
898  priv->firm[pos].int_freq);
899  printk(KERN_CONT "(%x), id %016llx.\n", priv->firm[pos].type,
900  (unsigned long long)*id);
901  }
902 
903  scode_buf[0] = 0x00;
904  memcpy(&scode_buf[1], p, 12);
905 
906  /* Enter direct-mode */
907  rc = xc_write_reg(priv, XREG_DIRECTSITTING_MODE, 0);
908  if (rc < 0) {
909  printk(KERN_ERR "failed to put device into direct mode!\n");
910  return -EIO;
911  }
912 
913  rc = xc_send_i2c_data(priv, scode_buf, 13);
914  if (rc != 0) {
915  /* Even if the send failed, make sure we set back to indirect
916  mode */
917  printk(KERN_ERR "Failed to set scode %d\n", rc);
918  }
919 
920  /* Switch back to indirect-mode */
921  memset(indirect_mode, 0, sizeof(indirect_mode));
922  indirect_mode[4] = 0x88;
923  xc_send_i2c_data(priv, indirect_mode, sizeof(indirect_mode));
924  msleep(10);
925 
926  return 0;
927 }
928 
929 static int check_firmware(struct dvb_frontend *fe, unsigned int type,
930  v4l2_std_id std, __u16 int_freq)
931 {
932  struct xc4000_priv *priv = fe->tuner_priv;
933  struct firmware_properties new_fw;
934  int rc = 0, is_retry = 0;
935  u16 hwmodel;
936  v4l2_std_id std0;
937  u8 hw_major, hw_minor, fw_major, fw_minor;
938 
939  dprintk(1, "%s called\n", __func__);
940 
941  if (!priv->firm) {
942  rc = xc4000_fwupload(fe);
943  if (rc < 0)
944  return rc;
945  }
946 
947 retry:
948  new_fw.type = type;
949  new_fw.id = std;
950  new_fw.std_req = std;
951  new_fw.scode_table = SCODE;
952  new_fw.scode_nr = 0;
953  new_fw.int_freq = int_freq;
954 
955  dprintk(1, "checking firmware, user requested type=");
956  if (debug) {
957  dump_firm_type(new_fw.type);
958  printk(KERN_CONT "(%x), id %016llx, ", new_fw.type,
959  (unsigned long long)new_fw.std_req);
960  if (!int_freq)
961  printk(KERN_CONT "scode_tbl ");
962  else
963  printk(KERN_CONT "int_freq %d, ", new_fw.int_freq);
964  printk(KERN_CONT "scode_nr %d\n", new_fw.scode_nr);
965  }
966 
967  /* No need to reload base firmware if it matches */
968  if (priv->cur_fw.type & BASE) {
969  dprintk(1, "BASE firmware not changed.\n");
970  goto skip_base;
971  }
972 
973  /* Updating BASE - forget about all currently loaded firmware */
974  memset(&priv->cur_fw, 0, sizeof(priv->cur_fw));
975 
976  /* Reset is needed before loading firmware */
977  rc = xc4000_tuner_reset(fe);
978  if (rc < 0)
979  goto fail;
980 
981  /* BASE firmwares are all std0 */
982  std0 = 0;
983  rc = load_firmware(fe, BASE, &std0);
984  if (rc < 0) {
985  printk(KERN_ERR "Error %d while loading base firmware\n", rc);
986  goto fail;
987  }
988 
989  /* Load INIT1, if needed */
990  dprintk(1, "Load init1 firmware, if exists\n");
991 
992  rc = load_firmware(fe, BASE | INIT1, &std0);
993  if (rc == -ENOENT)
994  rc = load_firmware(fe, BASE | INIT1, &std0);
995  if (rc < 0 && rc != -ENOENT) {
996  tuner_err("Error %d while loading init1 firmware\n",
997  rc);
998  goto fail;
999  }
1000 
1001 skip_base:
1002  /*
1003  * No need to reload standard specific firmware if base firmware
1004  * was not reloaded and requested video standards have not changed.
1005  */
1006  if (priv->cur_fw.type == (BASE | new_fw.type) &&
1007  priv->cur_fw.std_req == std) {
1008  dprintk(1, "Std-specific firmware already loaded.\n");
1009  goto skip_std_specific;
1010  }
1011 
1012  /* Reloading std-specific firmware forces a SCODE update */
1013  priv->cur_fw.scode_table = 0;
1014 
1015  /* Load the standard firmware */
1016  rc = load_firmware(fe, new_fw.type, &new_fw.id);
1017 
1018  if (rc < 0)
1019  goto fail;
1020 
1021 skip_std_specific:
1022  if (priv->cur_fw.scode_table == new_fw.scode_table &&
1023  priv->cur_fw.scode_nr == new_fw.scode_nr) {
1024  dprintk(1, "SCODE firmware already loaded.\n");
1025  goto check_device;
1026  }
1027 
1028  /* Load SCODE firmware, if exists */
1029  rc = load_scode(fe, new_fw.type | new_fw.scode_table, &new_fw.id,
1030  new_fw.int_freq, new_fw.scode_nr);
1031  if (rc != 0)
1032  dprintk(1, "load scode failed %d\n", rc);
1033 
1034 check_device:
1035  rc = xc4000_readreg(priv, XREG_PRODUCT_ID, &hwmodel);
1036 
1037  if (xc_get_version(priv, &hw_major, &hw_minor, &fw_major,
1038  &fw_minor) != 0) {
1039  printk(KERN_ERR "Unable to read tuner registers.\n");
1040  goto fail;
1041  }
1042 
1043  dprintk(1, "Device is Xceive %d version %d.%d, "
1044  "firmware version %d.%d\n",
1045  hwmodel, hw_major, hw_minor, fw_major, fw_minor);
1046 
1047  /* Check firmware version against what we downloaded. */
1048  if (priv->firm_version != ((fw_major << 8) | fw_minor)) {
1050  "Incorrect readback of firmware version %d.%d.\n",
1051  fw_major, fw_minor);
1052  goto fail;
1053  }
1054 
1055  /* Check that the tuner hardware model remains consistent over time. */
1056  if (priv->hwmodel == 0 &&
1057  (hwmodel == XC_PRODUCT_ID_XC4000 ||
1058  hwmodel == XC_PRODUCT_ID_XC4100)) {
1059  priv->hwmodel = hwmodel;
1060  priv->hwvers = (hw_major << 8) | hw_minor;
1061  } else if (priv->hwmodel == 0 || priv->hwmodel != hwmodel ||
1062  priv->hwvers != ((hw_major << 8) | hw_minor)) {
1064  "Read invalid device hardware information - tuner "
1065  "hung?\n");
1066  goto fail;
1067  }
1068 
1069  memcpy(&priv->cur_fw, &new_fw, sizeof(priv->cur_fw));
1070 
1071  /*
1072  * By setting BASE in cur_fw.type only after successfully loading all
1073  * firmwares, we can:
1074  * 1. Identify that BASE firmware with type=0 has been loaded;
1075  * 2. Tell whether BASE firmware was just changed the next time through.
1076  */
1077  priv->cur_fw.type |= BASE;
1078 
1079  return 0;
1080 
1081 fail:
1082  memset(&priv->cur_fw, 0, sizeof(priv->cur_fw));
1083  if (!is_retry) {
1084  msleep(50);
1085  is_retry = 1;
1086  dprintk(1, "Retrying firmware load\n");
1087  goto retry;
1088  }
1089 
1090  if (rc == -ENOENT)
1091  rc = -EINVAL;
1092  return rc;
1093 }
1094 
1095 static void xc_debug_dump(struct xc4000_priv *priv)
1096 {
1097  u16 adc_envelope;
1098  u32 freq_error_hz = 0;
1099  u16 lock_status;
1100  u32 hsync_freq_hz = 0;
1101  u16 frame_lines;
1102  u16 quality;
1103  u16 signal = 0;
1104  u16 noise = 0;
1105  u8 hw_majorversion = 0, hw_minorversion = 0;
1106  u8 fw_majorversion = 0, fw_minorversion = 0;
1107 
1108  xc_get_adc_envelope(priv, &adc_envelope);
1109  dprintk(1, "*** ADC envelope (0-1023) = %d\n", adc_envelope);
1110 
1111  xc_get_frequency_error(priv, &freq_error_hz);
1112  dprintk(1, "*** Frequency error = %d Hz\n", freq_error_hz);
1113 
1114  xc_get_lock_status(priv, &lock_status);
1115  dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %d\n",
1116  lock_status);
1117 
1118  xc_get_version(priv, &hw_majorversion, &hw_minorversion,
1119  &fw_majorversion, &fw_minorversion);
1120  dprintk(1, "*** HW: V%02x.%02x, FW: V%02x.%02x\n",
1121  hw_majorversion, hw_minorversion,
1122  fw_majorversion, fw_minorversion);
1123 
1124  if (priv->video_standard < XC4000_DTV6) {
1125  xc_get_hsync_freq(priv, &hsync_freq_hz);
1126  dprintk(1, "*** Horizontal sync frequency = %d Hz\n",
1127  hsync_freq_hz);
1128 
1129  xc_get_frame_lines(priv, &frame_lines);
1130  dprintk(1, "*** Frame lines = %d\n", frame_lines);
1131  }
1132 
1133  xc_get_quality(priv, &quality);
1134  dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %d\n", quality);
1135 
1136  xc_get_signal_level(priv, &signal);
1137  dprintk(1, "*** Signal level = -%ddB (%d)\n", signal >> 8, signal);
1138 
1139  xc_get_noise_level(priv, &noise);
1140  dprintk(1, "*** Noise level = %ddB (%d)\n", noise >> 8, noise);
1141 }
1142 
1143 static int xc4000_set_params(struct dvb_frontend *fe)
1144 {
1146  u32 delsys = c->delivery_system;
1147  u32 bw = c->bandwidth_hz;
1148  struct xc4000_priv *priv = fe->tuner_priv;
1149  unsigned int type;
1150  int ret = -EREMOTEIO;
1151 
1152  dprintk(1, "%s() frequency=%d (Hz)\n", __func__, c->frequency);
1153 
1154  mutex_lock(&priv->lock);
1155 
1156  switch (delsys) {
1157  case SYS_ATSC:
1158  dprintk(1, "%s() VSB modulation\n", __func__);
1159  priv->rf_mode = XC_RF_MODE_AIR;
1160  priv->freq_hz = c->frequency - 1750000;
1161  priv->video_standard = XC4000_DTV6;
1162  type = DTV6;
1163  break;
1164  case SYS_DVBC_ANNEX_B:
1165  dprintk(1, "%s() QAM modulation\n", __func__);
1166  priv->rf_mode = XC_RF_MODE_CABLE;
1167  priv->freq_hz = c->frequency - 1750000;
1168  priv->video_standard = XC4000_DTV6;
1169  type = DTV6;
1170  break;
1171  case SYS_DVBT:
1172  case SYS_DVBT2:
1173  dprintk(1, "%s() OFDM\n", __func__);
1174  if (bw == 0) {
1175  if (c->frequency < 400000000) {
1176  priv->freq_hz = c->frequency - 2250000;
1177  } else {
1178  priv->freq_hz = c->frequency - 2750000;
1179  }
1180  priv->video_standard = XC4000_DTV7_8;
1181  type = DTV78;
1182  } else if (bw <= 6000000) {
1183  priv->video_standard = XC4000_DTV6;
1184  priv->freq_hz = c->frequency - 1750000;
1185  type = DTV6;
1186  } else if (bw <= 7000000) {
1187  priv->video_standard = XC4000_DTV7;
1188  priv->freq_hz = c->frequency - 2250000;
1189  type = DTV7;
1190  } else {
1191  priv->video_standard = XC4000_DTV8;
1192  priv->freq_hz = c->frequency - 2750000;
1193  type = DTV8;
1194  }
1195  priv->rf_mode = XC_RF_MODE_AIR;
1196  break;
1197  default:
1198  printk(KERN_ERR "xc4000 delivery system not supported!\n");
1199  ret = -EINVAL;
1200  goto fail;
1201  }
1202 
1203  dprintk(1, "%s() frequency=%d (compensated)\n",
1204  __func__, priv->freq_hz);
1205 
1206  /* Make sure the correct firmware type is loaded */
1207  if (check_firmware(fe, type, 0, priv->if_khz) != 0)
1208  goto fail;
1209 
1210  priv->bandwidth = c->bandwidth_hz;
1211 
1212  ret = xc_set_signal_source(priv, priv->rf_mode);
1213  if (ret != 0) {
1214  printk(KERN_ERR "xc4000: xc_set_signal_source(%d) failed\n",
1215  priv->rf_mode);
1216  goto fail;
1217  } else {
1219  video_mode = xc4000_standard[priv->video_standard].video_mode;
1220  audio_mode = xc4000_standard[priv->video_standard].audio_mode;
1221  if (type == DTV6 && priv->firm_version != 0x0102)
1222  video_mode |= 0x0001;
1223  ret = xc_set_tv_standard(priv, video_mode, audio_mode);
1224  if (ret != 0) {
1225  printk(KERN_ERR "xc4000: xc_set_tv_standard failed\n");
1226  /* DJH - do not return when it fails... */
1227  /* goto fail; */
1228  }
1229  }
1230 
1231  if (xc_write_reg(priv, XREG_D_CODE, 0) == 0)
1232  ret = 0;
1233  if (priv->dvb_amplitude != 0) {
1234  if (xc_write_reg(priv, XREG_AMPLITUDE,
1235  (priv->firm_version != 0x0102 ||
1236  priv->dvb_amplitude != 134 ?
1237  priv->dvb_amplitude : 132)) != 0)
1238  ret = -EREMOTEIO;
1239  }
1240  if (priv->set_smoothedcvbs != 0) {
1241  if (xc_write_reg(priv, XREG_SMOOTHEDCVBS, 1) != 0)
1242  ret = -EREMOTEIO;
1243  }
1244  if (ret != 0) {
1245  printk(KERN_ERR "xc4000: setting registers failed\n");
1246  /* goto fail; */
1247  }
1248 
1249  xc_tune_channel(priv, priv->freq_hz);
1250 
1251  ret = 0;
1252 
1253 fail:
1254  mutex_unlock(&priv->lock);
1255 
1256  return ret;
1257 }
1258 
1259 static int xc4000_set_analog_params(struct dvb_frontend *fe,
1260  struct analog_parameters *params)
1261 {
1262  struct xc4000_priv *priv = fe->tuner_priv;
1263  unsigned int type = 0;
1264  int ret = -EREMOTEIO;
1265 
1266  if (params->mode == V4L2_TUNER_RADIO) {
1267  dprintk(1, "%s() frequency=%d (in units of 62.5Hz)\n",
1268  __func__, params->frequency);
1269 
1270  mutex_lock(&priv->lock);
1271 
1272  params->std = 0;
1273  priv->freq_hz = params->frequency * 125L / 2;
1274 
1275  if (audio_std & XC4000_AUDIO_STD_INPUT1) {
1277  type = FM | INPUT1;
1278  } else {
1280  type = FM | INPUT2;
1281  }
1282 
1283  goto tune_channel;
1284  }
1285 
1286  dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
1287  __func__, params->frequency);
1288 
1289  mutex_lock(&priv->lock);
1290 
1291  /* params->frequency is in units of 62.5khz */
1292  priv->freq_hz = params->frequency * 62500;
1293 
1294  params->std &= V4L2_STD_ALL;
1295  /* if std is not defined, choose one */
1296  if (!params->std)
1297  params->std = V4L2_STD_PAL_BG;
1298 
1299  if (audio_std & XC4000_AUDIO_STD_MONO)
1300  type = MONO;
1301 
1302  if (params->std & V4L2_STD_MN) {
1303  params->std = V4L2_STD_MN;
1304  if (audio_std & XC4000_AUDIO_STD_MONO) {
1306  } else if (audio_std & XC4000_AUDIO_STD_A2) {
1307  params->std |= V4L2_STD_A2;
1309  } else {
1310  params->std |= V4L2_STD_BTSC;
1312  }
1313  goto tune_channel;
1314  }
1315 
1316  if (params->std & V4L2_STD_PAL_BG) {
1317  params->std = V4L2_STD_PAL_BG;
1318  if (audio_std & XC4000_AUDIO_STD_MONO) {
1320  } else if (!(audio_std & XC4000_AUDIO_STD_A2)) {
1321  if (!(audio_std & XC4000_AUDIO_STD_B)) {
1322  params->std |= V4L2_STD_NICAM_A;
1324  } else {
1325  params->std |= V4L2_STD_NICAM_B;
1327  }
1328  } else {
1329  if (!(audio_std & XC4000_AUDIO_STD_B)) {
1330  params->std |= V4L2_STD_A2_A;
1332  } else {
1333  params->std |= V4L2_STD_A2_B;
1335  }
1336  }
1337  goto tune_channel;
1338  }
1339 
1340  if (params->std & V4L2_STD_PAL_I) {
1341  /* default to NICAM audio standard */
1342  params->std = V4L2_STD_PAL_I | V4L2_STD_NICAM;
1343  if (audio_std & XC4000_AUDIO_STD_MONO)
1345  else
1347  goto tune_channel;
1348  }
1349 
1350  if (params->std & V4L2_STD_PAL_DK) {
1351  params->std = V4L2_STD_PAL_DK;
1352  if (audio_std & XC4000_AUDIO_STD_MONO) {
1354  } else if (audio_std & XC4000_AUDIO_STD_A2) {
1355  params->std |= V4L2_STD_A2;
1357  } else {
1358  params->std |= V4L2_STD_NICAM;
1360  }
1361  goto tune_channel;
1362  }
1363 
1364  if (params->std & V4L2_STD_SECAM_DK) {
1365  /* default to A2 audio standard */
1366  params->std = V4L2_STD_SECAM_DK | V4L2_STD_A2;
1367  if (audio_std & XC4000_AUDIO_STD_L) {
1368  type = 0;
1370  } else if (audio_std & XC4000_AUDIO_STD_MONO) {
1372  } else if (audio_std & XC4000_AUDIO_STD_K3) {
1373  params->std |= V4L2_STD_SECAM_K3;
1375  } else {
1377  }
1378  goto tune_channel;
1379  }
1380 
1381  if (params->std & V4L2_STD_SECAM_L) {
1382  /* default to NICAM audio standard */
1383  type = 0;
1384  params->std = V4L2_STD_SECAM_L | V4L2_STD_NICAM;
1386  goto tune_channel;
1387  }
1388 
1389  if (params->std & V4L2_STD_SECAM_LC) {
1390  /* default to NICAM audio standard */
1391  type = 0;
1392  params->std = V4L2_STD_SECAM_LC | V4L2_STD_NICAM;
1394  goto tune_channel;
1395  }
1396 
1397 tune_channel:
1398  /* FIXME: it could be air. */
1399  priv->rf_mode = XC_RF_MODE_CABLE;
1400 
1401  if (check_firmware(fe, type, params->std,
1402  xc4000_standard[priv->video_standard].int_freq) != 0)
1403  goto fail;
1404 
1405  ret = xc_set_signal_source(priv, priv->rf_mode);
1406  if (ret != 0) {
1408  "xc4000: xc_set_signal_source(%d) failed\n",
1409  priv->rf_mode);
1410  goto fail;
1411  } else {
1413  video_mode = xc4000_standard[priv->video_standard].video_mode;
1414  audio_mode = xc4000_standard[priv->video_standard].audio_mode;
1415  if (priv->video_standard < XC4000_BG_PAL_A2) {
1416  if (type & NOGD)
1417  video_mode &= 0xFF7F;
1418  } else if (priv->video_standard < XC4000_I_PAL_NICAM) {
1419  if (priv->firm_version == 0x0102)
1420  video_mode &= 0xFEFF;
1421  if (audio_std & XC4000_AUDIO_STD_B)
1422  video_mode |= 0x0080;
1423  }
1424  ret = xc_set_tv_standard(priv, video_mode, audio_mode);
1425  if (ret != 0) {
1426  printk(KERN_ERR "xc4000: xc_set_tv_standard failed\n");
1427  goto fail;
1428  }
1429  }
1430 
1431  if (xc_write_reg(priv, XREG_D_CODE, 0) == 0)
1432  ret = 0;
1433  if (xc_write_reg(priv, XREG_AMPLITUDE, 1) != 0)
1434  ret = -EREMOTEIO;
1435  if (priv->set_smoothedcvbs != 0) {
1436  if (xc_write_reg(priv, XREG_SMOOTHEDCVBS, 1) != 0)
1437  ret = -EREMOTEIO;
1438  }
1439  if (ret != 0) {
1440  printk(KERN_ERR "xc4000: setting registers failed\n");
1441  goto fail;
1442  }
1443 
1444  xc_tune_channel(priv, priv->freq_hz);
1445 
1446  ret = 0;
1447 
1448 fail:
1449  mutex_unlock(&priv->lock);
1450 
1451  return ret;
1452 }
1453 
1454 static int xc4000_get_signal(struct dvb_frontend *fe, u16 *strength)
1455 {
1456  struct xc4000_priv *priv = fe->tuner_priv;
1457  u16 value = 0;
1458  int rc;
1459 
1460  mutex_lock(&priv->lock);
1461  rc = xc4000_readreg(priv, XREG_SIGNAL_LEVEL, &value);
1462  mutex_unlock(&priv->lock);
1463 
1464  if (rc < 0)
1465  goto ret;
1466 
1467  /* Informations from real testing of DVB-T and radio part,
1468  coeficient for one dB is 0xff.
1469  */
1470  tuner_dbg("Signal strength: -%ddB (%05d)\n", value >> 8, value);
1471 
1472  /* all known digital modes */
1473  if ((priv->video_standard == XC4000_DTV6) ||
1474  (priv->video_standard == XC4000_DTV7) ||
1475  (priv->video_standard == XC4000_DTV7_8) ||
1476  (priv->video_standard == XC4000_DTV8))
1477  goto digital;
1478 
1479  /* Analog mode has NOISE LEVEL important, signal
1480  depends only on gain of antenna and amplifiers,
1481  but it doesn't tell anything about real quality
1482  of reception.
1483  */
1484  mutex_lock(&priv->lock);
1485  rc = xc4000_readreg(priv, XREG_NOISE_LEVEL, &value);
1486  mutex_unlock(&priv->lock);
1487 
1488  tuner_dbg("Noise level: %ddB (%05d)\n", value >> 8, value);
1489 
1490  /* highest noise level: 32dB */
1491  if (value >= 0x2000) {
1492  value = 0;
1493  } else {
1494  value = ~value << 3;
1495  }
1496 
1497  goto ret;
1498 
1499  /* Digital mode has SIGNAL LEVEL important and real
1500  noise level is stored in demodulator registers.
1501  */
1502 digital:
1503  /* best signal: -50dB */
1504  if (value <= 0x3200) {
1505  value = 0xffff;
1506  /* minimum: -114dB - should be 0x7200 but real zero is 0x713A */
1507  } else if (value >= 0x713A) {
1508  value = 0;
1509  } else {
1510  value = ~(value - 0x3200) << 2;
1511  }
1512 
1513 ret:
1514  *strength = value;
1515 
1516  return rc;
1517 }
1518 
1519 static int xc4000_get_frequency(struct dvb_frontend *fe, u32 *freq)
1520 {
1521  struct xc4000_priv *priv = fe->tuner_priv;
1522 
1523  *freq = priv->freq_hz;
1524 
1525  if (debug) {
1526  mutex_lock(&priv->lock);
1527  if ((priv->cur_fw.type
1528  & (BASE | FM | DTV6 | DTV7 | DTV78 | DTV8)) == BASE) {
1529  u16 snr = 0;
1530  if (xc4000_readreg(priv, XREG_SNR, &snr) == 0) {
1531  mutex_unlock(&priv->lock);
1532  dprintk(1, "%s() freq = %u, SNR = %d\n",
1533  __func__, *freq, snr);
1534  return 0;
1535  }
1536  }
1537  mutex_unlock(&priv->lock);
1538  }
1539 
1540  dprintk(1, "%s()\n", __func__);
1541 
1542  return 0;
1543 }
1544 
1545 static int xc4000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
1546 {
1547  struct xc4000_priv *priv = fe->tuner_priv;
1548  dprintk(1, "%s()\n", __func__);
1549 
1550  *bw = priv->bandwidth;
1551  return 0;
1552 }
1553 
1554 static int xc4000_get_status(struct dvb_frontend *fe, u32 *status)
1555 {
1556  struct xc4000_priv *priv = fe->tuner_priv;
1557  u16 lock_status = 0;
1558 
1559  mutex_lock(&priv->lock);
1560 
1561  if (priv->cur_fw.type & BASE)
1562  xc_get_lock_status(priv, &lock_status);
1563 
1564  *status = (lock_status == 1 ?
1566  if (priv->cur_fw.type & (DTV6 | DTV7 | DTV78 | DTV8))
1567  *status &= (~TUNER_STATUS_STEREO);
1568 
1569  mutex_unlock(&priv->lock);
1570 
1571  dprintk(2, "%s() lock_status = %d\n", __func__, lock_status);
1572 
1573  return 0;
1574 }
1575 
1576 static int xc4000_sleep(struct dvb_frontend *fe)
1577 {
1578  struct xc4000_priv *priv = fe->tuner_priv;
1579  int ret = 0;
1580 
1581  dprintk(1, "%s()\n", __func__);
1582 
1583  mutex_lock(&priv->lock);
1584 
1585  /* Avoid firmware reload on slow devices */
1586  if ((no_poweroff == 2 ||
1587  (no_poweroff == 0 && priv->default_pm != 0)) &&
1588  (priv->cur_fw.type & BASE) != 0) {
1589  /* force reset and firmware reload */
1590  priv->cur_fw.type = XC_POWERED_DOWN;
1591 
1592  if (xc_write_reg(priv, XREG_POWER_DOWN, 0) != 0) {
1594  "xc4000: %s() unable to shutdown tuner\n",
1595  __func__);
1596  ret = -EREMOTEIO;
1597  }
1598  msleep(20);
1599  }
1600 
1601  mutex_unlock(&priv->lock);
1602 
1603  return ret;
1604 }
1605 
1606 static int xc4000_init(struct dvb_frontend *fe)
1607 {
1608  dprintk(1, "%s()\n", __func__);
1609 
1610  return 0;
1611 }
1612 
1613 static int xc4000_release(struct dvb_frontend *fe)
1614 {
1615  struct xc4000_priv *priv = fe->tuner_priv;
1616 
1617  dprintk(1, "%s()\n", __func__);
1618 
1619  mutex_lock(&xc4000_list_mutex);
1620 
1621  if (priv)
1623 
1624  mutex_unlock(&xc4000_list_mutex);
1625 
1626  fe->tuner_priv = NULL;
1627 
1628  return 0;
1629 }
1630 
1631 static const struct dvb_tuner_ops xc4000_tuner_ops = {
1632  .info = {
1633  .name = "Xceive XC4000",
1634  .frequency_min = 1000000,
1635  .frequency_max = 1023000000,
1636  .frequency_step = 50000,
1637  },
1638 
1639  .release = xc4000_release,
1640  .init = xc4000_init,
1641  .sleep = xc4000_sleep,
1642 
1643  .set_params = xc4000_set_params,
1644  .set_analog_params = xc4000_set_analog_params,
1645  .get_frequency = xc4000_get_frequency,
1646  .get_rf_strength = xc4000_get_signal,
1647  .get_bandwidth = xc4000_get_bandwidth,
1648  .get_status = xc4000_get_status
1649 };
1650 
1652  struct i2c_adapter *i2c,
1653  struct xc4000_config *cfg)
1654 {
1655  struct xc4000_priv *priv = NULL;
1656  int instance;
1657  u16 id = 0;
1658 
1659  dprintk(1, "%s(%d-%04x)\n", __func__,
1660  i2c ? i2c_adapter_id(i2c) : -1,
1661  cfg ? cfg->i2c_address : -1);
1662 
1663  mutex_lock(&xc4000_list_mutex);
1664 
1665  instance = hybrid_tuner_request_state(struct xc4000_priv, priv,
1667  i2c, cfg->i2c_address, "xc4000");
1668  switch (instance) {
1669  case 0:
1670  goto fail;
1671  break;
1672  case 1:
1673  /* new tuner instance */
1674  priv->bandwidth = 6000000;
1675  /* set default configuration */
1676  priv->if_khz = 4560;
1677  priv->default_pm = 0;
1678  priv->dvb_amplitude = 134;
1679  priv->set_smoothedcvbs = 1;
1680  mutex_init(&priv->lock);
1681  fe->tuner_priv = priv;
1682  break;
1683  default:
1684  /* existing tuner instance */
1685  fe->tuner_priv = priv;
1686  break;
1687  }
1688 
1689  if (cfg->if_khz != 0) {
1690  /* copy configuration if provided by the caller */
1691  priv->if_khz = cfg->if_khz;
1692  priv->default_pm = cfg->default_pm;
1693  priv->dvb_amplitude = cfg->dvb_amplitude;
1694  priv->set_smoothedcvbs = cfg->set_smoothedcvbs;
1695  }
1696 
1697  /* Check if firmware has been loaded. It is possible that another
1698  instance of the driver has loaded the firmware.
1699  */
1700 
1701  if (instance == 1) {
1702  if (xc4000_readreg(priv, XREG_PRODUCT_ID, &id) != 0)
1703  goto fail;
1704  } else {
1705  id = ((priv->cur_fw.type & BASE) != 0 ?
1707  }
1708 
1709  switch (id) {
1710  case XC_PRODUCT_ID_XC4000:
1711  case XC_PRODUCT_ID_XC4100:
1713  "xc4000: Successfully identified at address 0x%02x\n",
1714  cfg->i2c_address);
1716  "xc4000: Firmware has been loaded previously\n");
1717  break;
1720  "xc4000: Successfully identified at address 0x%02x\n",
1721  cfg->i2c_address);
1723  "xc4000: Firmware has not been loaded previously\n");
1724  break;
1725  default:
1727  "xc4000: Device not found at addr 0x%02x (0x%x)\n",
1728  cfg->i2c_address, id);
1729  goto fail;
1730  }
1731 
1732  mutex_unlock(&xc4000_list_mutex);
1733 
1734  memcpy(&fe->ops.tuner_ops, &xc4000_tuner_ops,
1735  sizeof(struct dvb_tuner_ops));
1736 
1737  if (instance == 1) {
1738  int ret;
1739  mutex_lock(&priv->lock);
1740  ret = xc4000_fwupload(fe);
1741  mutex_unlock(&priv->lock);
1742  if (ret != 0)
1743  goto fail2;
1744  }
1745 
1746  return fe;
1747 fail:
1748  mutex_unlock(&xc4000_list_mutex);
1749 fail2:
1750  xc4000_release(fe);
1751  return NULL;
1752 }
1754 
1755 MODULE_AUTHOR("Steven Toth, Davide Ferri");
1756 MODULE_DESCRIPTION("Xceive xc4000 silicon tuner driver");
1757 MODULE_LICENSE("GPL");