aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/media/dvb-frontends
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/media/dvb-frontends')
-rw-r--r--drivers/media/dvb-frontends/Kconfig18
-rw-r--r--drivers/media/dvb-frontends/Makefile7
-rw-r--r--drivers/media/dvb-frontends/af9013.c1
-rw-r--r--drivers/media/dvb-frontends/au8522_decoder.c180
-rw-r--r--drivers/media/dvb-frontends/au8522_priv.h2
-rw-r--r--drivers/media/dvb-frontends/cxd2820r.h6
-rw-r--r--drivers/media/dvb-frontends/cxd2820r_c.c1
-rw-r--r--drivers/media/dvb-frontends/cxd2820r_t.c1
-rw-r--r--drivers/media/dvb-frontends/cxd2820r_t2.c1
-rw-r--r--drivers/media/dvb-frontends/dib0090.c15
-rw-r--r--drivers/media/dvb-frontends/dib7000m.c5
-rw-r--r--drivers/media/dvb-frontends/dib7000p.c433
-rw-r--r--drivers/media/dvb-frontends/dib7000p.h131
-rw-r--r--drivers/media/dvb-frontends/dib8000.c732
-rw-r--r--drivers/media/dvb-frontends/dib8000.h150
-rw-r--r--drivers/media/dvb-frontends/dib9000.c13
-rw-r--r--drivers/media/dvb-frontends/drx39xyj/drxj.c228
-rw-r--r--drivers/media/dvb-frontends/drxd.h1
-rw-r--r--drivers/media/dvb-frontends/drxd_hard.c3
-rw-r--r--drivers/media/dvb-frontends/m88ds3103.c85
-rw-r--r--drivers/media/dvb-frontends/m88ds3103_priv.h2
-rw-r--r--drivers/media/dvb-frontends/mb86a20s.c35
-rw-r--r--drivers/media/dvb-frontends/rtl2832_sdr.c1551
-rw-r--r--drivers/media/dvb-frontends/rtl2832_sdr.h54
-rw-r--r--drivers/media/dvb-frontends/si2165.c1040
-rw-r--r--drivers/media/dvb-frontends/si2165.h62
-rw-r--r--drivers/media/dvb-frontends/si2165_priv.h23
-rw-r--r--drivers/media/dvb-frontends/si2168.c278
-rw-r--r--drivers/media/dvb-frontends/si2168_priv.h9
-rw-r--r--drivers/media/dvb-frontends/stb6100_cfg.h42
-rw-r--r--drivers/media/dvb-frontends/stb6100_proc.h34
-rw-r--r--drivers/media/dvb-frontends/stv0367.c9
-rw-r--r--drivers/media/dvb-frontends/tda10071.c12
-rw-r--r--drivers/media/dvb-frontends/tda10071_priv.h1
-rw-r--r--drivers/media/dvb-frontends/tda18271c2dd.c2
-rw-r--r--drivers/media/dvb-frontends/tda18271c2dd_maps.h8
-rw-r--r--drivers/media/dvb-frontends/tda8261_cfg.h30
37 files changed, 4116 insertions, 1089 deletions
diff --git a/drivers/media/dvb-frontends/Kconfig b/drivers/media/dvb-frontends/Kconfig
index 1469d44acb22..fe0ddcca192c 100644
--- a/drivers/media/dvb-frontends/Kconfig
+++ b/drivers/media/dvb-frontends/Kconfig
@@ -63,6 +63,15 @@ config DVB_TDA18271C2DD
63 63
64 Say Y when you want to support this tuner. 64 Say Y when you want to support this tuner.
65 65
66config DVB_SI2165
67 tristate "Silicon Labs si2165 based"
68 depends on DVB_CORE && I2C
69 default m if !MEDIA_SUBDRV_AUTOSELECT
70 help
71 A DVB-C/T demodulator.
72
73 Say Y when you want to support this frontend.
74
66comment "DVB-S (satellite) frontends" 75comment "DVB-S (satellite) frontends"
67 depends on DVB_CORE 76 depends on DVB_CORE
68 77
@@ -446,6 +455,15 @@ config DVB_RTL2832
446 help 455 help
447 Say Y when you want to support this frontend. 456 Say Y when you want to support this frontend.
448 457
458config DVB_RTL2832_SDR
459 tristate "Realtek RTL2832 SDR"
460 depends on DVB_CORE && I2C && I2C_MUX && VIDEO_V4L2 && MEDIA_SDR_SUPPORT && USB
461 select DVB_RTL2832
462 select VIDEOBUF2_VMALLOC
463 default m if !MEDIA_SUBDRV_AUTOSELECT
464 help
465 Say Y when you want to support this SDR module.
466
449config DVB_SI2168 467config DVB_SI2168
450 tristate "Silicon Labs Si2168" 468 tristate "Silicon Labs Si2168"
451 depends on DVB_CORE && I2C && I2C_MUX 469 depends on DVB_CORE && I2C && I2C_MUX
diff --git a/drivers/media/dvb-frontends/Makefile b/drivers/media/dvb-frontends/Makefile
index dda0bee36f29..edf103d45920 100644
--- a/drivers/media/dvb-frontends/Makefile
+++ b/drivers/media/dvb-frontends/Makefile
@@ -5,6 +5,11 @@
5ccflags-y += -I$(srctree)/drivers/media/dvb-core/ 5ccflags-y += -I$(srctree)/drivers/media/dvb-core/
6ccflags-y += -I$(srctree)/drivers/media/tuners/ 6ccflags-y += -I$(srctree)/drivers/media/tuners/
7 7
8# FIXME: RTL2832 SDR driver uses power management directly from USB IF driver
9ifdef CONFIG_DVB_RTL2832_SDR
10 ccflags-y += -I$(srctree)/drivers/media/usb/dvb-usb-v2
11endif
12
8stb0899-objs := stb0899_drv.o stb0899_algo.o 13stb0899-objs := stb0899_drv.o stb0899_algo.o
9stv0900-objs := stv0900_core.o stv0900_sw.o 14stv0900-objs := stv0900_core.o stv0900_sw.o
10drxd-objs := drxd_firm.o drxd_hard.o 15drxd-objs := drxd_firm.o drxd_hard.o
@@ -100,10 +105,12 @@ obj-$(CONFIG_DVB_STV0367) += stv0367.o
100obj-$(CONFIG_DVB_CXD2820R) += cxd2820r.o 105obj-$(CONFIG_DVB_CXD2820R) += cxd2820r.o
101obj-$(CONFIG_DVB_DRXK) += drxk.o 106obj-$(CONFIG_DVB_DRXK) += drxk.o
102obj-$(CONFIG_DVB_TDA18271C2DD) += tda18271c2dd.o 107obj-$(CONFIG_DVB_TDA18271C2DD) += tda18271c2dd.o
108obj-$(CONFIG_DVB_SI2165) += si2165.o
103obj-$(CONFIG_DVB_A8293) += a8293.o 109obj-$(CONFIG_DVB_A8293) += a8293.o
104obj-$(CONFIG_DVB_TDA10071) += tda10071.o 110obj-$(CONFIG_DVB_TDA10071) += tda10071.o
105obj-$(CONFIG_DVB_RTL2830) += rtl2830.o 111obj-$(CONFIG_DVB_RTL2830) += rtl2830.o
106obj-$(CONFIG_DVB_RTL2832) += rtl2832.o 112obj-$(CONFIG_DVB_RTL2832) += rtl2832.o
113obj-$(CONFIG_DVB_RTL2832_SDR) += rtl2832_sdr.o
107obj-$(CONFIG_DVB_M88RS2000) += m88rs2000.o 114obj-$(CONFIG_DVB_M88RS2000) += m88rs2000.o
108obj-$(CONFIG_DVB_AF9033) += af9033.o 115obj-$(CONFIG_DVB_AF9033) += af9033.o
109 116
diff --git a/drivers/media/dvb-frontends/af9013.c b/drivers/media/dvb-frontends/af9013.c
index fb504f1e9125..ecf6388d2200 100644
--- a/drivers/media/dvb-frontends/af9013.c
+++ b/drivers/media/dvb-frontends/af9013.c
@@ -470,7 +470,6 @@ static int af9013_statistics_snr_result(struct dvb_frontend *fe)
470 break; 470 break;
471 default: 471 default:
472 goto err; 472 goto err;
473 break;
474 } 473 }
475 474
476 for (i = 0; i < len; i++) { 475 for (i = 0; i < len; i++) {
diff --git a/drivers/media/dvb-frontends/au8522_decoder.c b/drivers/media/dvb-frontends/au8522_decoder.c
index 23a0d05ba426..33aa9410b624 100644
--- a/drivers/media/dvb-frontends/au8522_decoder.c
+++ b/drivers/media/dvb-frontends/au8522_decoder.c
@@ -220,7 +220,7 @@ static void setup_vbi(struct au8522_state *state, int aud_input)
220 220
221} 221}
222 222
223static void setup_decoder_defaults(struct au8522_state *state, u8 input_mode) 223static void setup_decoder_defaults(struct au8522_state *state, bool is_svideo)
224{ 224{
225 int i; 225 int i;
226 int filter_coef_type; 226 int filter_coef_type;
@@ -237,13 +237,10 @@ static void setup_decoder_defaults(struct au8522_state *state, u8 input_mode)
237 /* Other decoder registers */ 237 /* Other decoder registers */
238 au8522_writereg(state, AU8522_TVDEC_INT_MASK_REG010H, 0x00); 238 au8522_writereg(state, AU8522_TVDEC_INT_MASK_REG010H, 0x00);
239 239
240 if (input_mode == 0x23) { 240 if (is_svideo)
241 /* S-Video input mapping */
242 au8522_writereg(state, AU8522_VIDEO_MODE_REG011H, 0x04); 241 au8522_writereg(state, AU8522_VIDEO_MODE_REG011H, 0x04);
243 } else { 242 else
244 /* All other modes (CVBS/ATVRF etc.) */
245 au8522_writereg(state, AU8522_VIDEO_MODE_REG011H, 0x00); 243 au8522_writereg(state, AU8522_VIDEO_MODE_REG011H, 0x00);
246 }
247 244
248 au8522_writereg(state, AU8522_TVDEC_PGA_REG012H, 245 au8522_writereg(state, AU8522_TVDEC_PGA_REG012H,
249 AU8522_TVDEC_PGA_REG012H_CVBS); 246 AU8522_TVDEC_PGA_REG012H_CVBS);
@@ -251,12 +248,23 @@ static void setup_decoder_defaults(struct au8522_state *state, u8 input_mode)
251 AU8522_TVDEC_COMB_MODE_REG015H_CVBS); 248 AU8522_TVDEC_COMB_MODE_REG015H_CVBS);
252 au8522_writereg(state, AU8522_TVDED_DBG_MODE_REG060H, 249 au8522_writereg(state, AU8522_TVDED_DBG_MODE_REG060H,
253 AU8522_TVDED_DBG_MODE_REG060H_CVBS); 250 AU8522_TVDED_DBG_MODE_REG060H_CVBS);
254 au8522_writereg(state, AU8522_TVDEC_FORMAT_CTRL1_REG061H, 251
255 AU8522_TVDEC_FORMAT_CTRL1_REG061H_FIELD_LEN_525 | 252 if (state->std == V4L2_STD_PAL_M) {
256 AU8522_TVDEC_FORMAT_CTRL1_REG061H_LINE_LEN_63_492 | 253 au8522_writereg(state, AU8522_TVDEC_FORMAT_CTRL1_REG061H,
257 AU8522_TVDEC_FORMAT_CTRL1_REG061H_SUBCARRIER_NTSC_MN); 254 AU8522_TVDEC_FORMAT_CTRL1_REG061H_FIELD_LEN_525 |
258 au8522_writereg(state, AU8522_TVDEC_FORMAT_CTRL2_REG062H, 255 AU8522_TVDEC_FORMAT_CTRL1_REG061H_LINE_LEN_63_492 |
259 AU8522_TVDEC_FORMAT_CTRL2_REG062H_STD_NTSC); 256 AU8522_TVDEC_FORMAT_CTRL1_REG061H_SUBCARRIER_NTSC_AUTO);
257 au8522_writereg(state, AU8522_TVDEC_FORMAT_CTRL2_REG062H,
258 AU8522_TVDEC_FORMAT_CTRL2_REG062H_STD_PAL_M);
259 } else {
260 /* NTSC */
261 au8522_writereg(state, AU8522_TVDEC_FORMAT_CTRL1_REG061H,
262 AU8522_TVDEC_FORMAT_CTRL1_REG061H_FIELD_LEN_525 |
263 AU8522_TVDEC_FORMAT_CTRL1_REG061H_LINE_LEN_63_492 |
264 AU8522_TVDEC_FORMAT_CTRL1_REG061H_SUBCARRIER_NTSC_MN);
265 au8522_writereg(state, AU8522_TVDEC_FORMAT_CTRL2_REG062H,
266 AU8522_TVDEC_FORMAT_CTRL2_REG062H_STD_NTSC);
267 }
260 au8522_writereg(state, AU8522_TVDEC_VCR_DET_LLIM_REG063H, 268 au8522_writereg(state, AU8522_TVDEC_VCR_DET_LLIM_REG063H,
261 AU8522_TVDEC_VCR_DET_LLIM_REG063H_CVBS); 269 AU8522_TVDEC_VCR_DET_LLIM_REG063H_CVBS);
262 au8522_writereg(state, AU8522_TVDEC_VCR_DET_HLIM_REG064H, 270 au8522_writereg(state, AU8522_TVDEC_VCR_DET_HLIM_REG064H,
@@ -275,8 +283,7 @@ static void setup_decoder_defaults(struct au8522_state *state, u8 input_mode)
275 AU8522_TVDEC_COMB_HDIF_THR2_REG06AH_CVBS); 283 AU8522_TVDEC_COMB_HDIF_THR2_REG06AH_CVBS);
276 au8522_writereg(state, AU8522_TVDEC_COMB_HDIF_THR3_REG06BH, 284 au8522_writereg(state, AU8522_TVDEC_COMB_HDIF_THR3_REG06BH,
277 AU8522_TVDEC_COMB_HDIF_THR3_REG06BH_CVBS); 285 AU8522_TVDEC_COMB_HDIF_THR3_REG06BH_CVBS);
278 if (input_mode == AU8522_INPUT_CONTROL_REG081H_SVIDEO_CH13 || 286 if (is_svideo) {
279 input_mode == AU8522_INPUT_CONTROL_REG081H_SVIDEO_CH24) {
280 au8522_writereg(state, AU8522_TVDEC_COMB_DCDIF_THR1_REG06CH, 287 au8522_writereg(state, AU8522_TVDEC_COMB_DCDIF_THR1_REG06CH,
281 AU8522_TVDEC_COMB_DCDIF_THR1_REG06CH_SVIDEO); 288 AU8522_TVDEC_COMB_DCDIF_THR1_REG06CH_SVIDEO);
282 au8522_writereg(state, AU8522_TVDEC_COMB_DCDIF_THR2_REG06DH, 289 au8522_writereg(state, AU8522_TVDEC_COMB_DCDIF_THR2_REG06DH,
@@ -317,8 +324,7 @@ static void setup_decoder_defaults(struct au8522_state *state, u8 input_mode)
317 324
318 setup_vbi(state, 0); 325 setup_vbi(state, 0);
319 326
320 if (input_mode == AU8522_INPUT_CONTROL_REG081H_SVIDEO_CH13 || 327 if (is_svideo) {
321 input_mode == AU8522_INPUT_CONTROL_REG081H_SVIDEO_CH24) {
322 /* Despite what the table says, for the HVR-950q we still need 328 /* Despite what the table says, for the HVR-950q we still need
323 to be in CVBS mode for the S-Video input (reason unknown). */ 329 to be in CVBS mode for the S-Video input (reason unknown). */
324 /* filter_coef_type = 3; */ 330 /* filter_coef_type = 3; */
@@ -346,7 +352,7 @@ static void setup_decoder_defaults(struct au8522_state *state, u8 input_mode)
346 au8522_writereg(state, AU8522_REG436H, 0x3c); 352 au8522_writereg(state, AU8522_REG436H, 0x3c);
347} 353}
348 354
349static void au8522_setup_cvbs_mode(struct au8522_state *state) 355static void au8522_setup_cvbs_mode(struct au8522_state *state, u8 input_mode)
350{ 356{
351 /* here we're going to try the pre-programmed route */ 357 /* here we're going to try the pre-programmed route */
352 au8522_writereg(state, AU8522_MODULE_CLOCK_CONTROL_REG0A3H, 358 au8522_writereg(state, AU8522_MODULE_CLOCK_CONTROL_REG0A3H,
@@ -358,16 +364,16 @@ static void au8522_setup_cvbs_mode(struct au8522_state *state)
358 /* Enable clamping control */ 364 /* Enable clamping control */
359 au8522_writereg(state, AU8522_CLAMPING_CONTROL_REG083H, 0x00); 365 au8522_writereg(state, AU8522_CLAMPING_CONTROL_REG083H, 0x00);
360 366
361 au8522_writereg(state, AU8522_INPUT_CONTROL_REG081H, 367 au8522_writereg(state, AU8522_INPUT_CONTROL_REG081H, input_mode);
362 AU8522_INPUT_CONTROL_REG081H_CVBS_CH1);
363 368
364 setup_decoder_defaults(state, AU8522_INPUT_CONTROL_REG081H_CVBS_CH1); 369 setup_decoder_defaults(state, false);
365 370
366 au8522_writereg(state, AU8522_SYSTEM_MODULE_CONTROL_0_REG0A4H, 371 au8522_writereg(state, AU8522_SYSTEM_MODULE_CONTROL_0_REG0A4H,
367 AU8522_SYSTEM_MODULE_CONTROL_0_REG0A4H_CVBS); 372 AU8522_SYSTEM_MODULE_CONTROL_0_REG0A4H_CVBS);
368} 373}
369 374
370static void au8522_setup_cvbs_tuner_mode(struct au8522_state *state) 375static void au8522_setup_cvbs_tuner_mode(struct au8522_state *state,
376 u8 input_mode)
371{ 377{
372 /* here we're going to try the pre-programmed route */ 378 /* here we're going to try the pre-programmed route */
373 au8522_writereg(state, AU8522_MODULE_CLOCK_CONTROL_REG0A3H, 379 au8522_writereg(state, AU8522_MODULE_CLOCK_CONTROL_REG0A3H,
@@ -384,24 +390,22 @@ static void au8522_setup_cvbs_tuner_mode(struct au8522_state *state)
384 au8522_writereg(state, AU8522_PGA_CONTROL_REG082H, 0x10); 390 au8522_writereg(state, AU8522_PGA_CONTROL_REG082H, 0x10);
385 391
386 /* Set input mode to CVBS on channel 4 with SIF audio input enabled */ 392 /* Set input mode to CVBS on channel 4 with SIF audio input enabled */
387 au8522_writereg(state, AU8522_INPUT_CONTROL_REG081H, 393 au8522_writereg(state, AU8522_INPUT_CONTROL_REG081H, input_mode);
388 AU8522_INPUT_CONTROL_REG081H_CVBS_CH4_SIF);
389 394
390 setup_decoder_defaults(state, 395 setup_decoder_defaults(state, false);
391 AU8522_INPUT_CONTROL_REG081H_CVBS_CH4_SIF);
392 396
393 au8522_writereg(state, AU8522_SYSTEM_MODULE_CONTROL_0_REG0A4H, 397 au8522_writereg(state, AU8522_SYSTEM_MODULE_CONTROL_0_REG0A4H,
394 AU8522_SYSTEM_MODULE_CONTROL_0_REG0A4H_CVBS); 398 AU8522_SYSTEM_MODULE_CONTROL_0_REG0A4H_CVBS);
395} 399}
396 400
397static void au8522_setup_svideo_mode(struct au8522_state *state) 401static void au8522_setup_svideo_mode(struct au8522_state *state,
402 u8 input_mode)
398{ 403{
399 au8522_writereg(state, AU8522_MODULE_CLOCK_CONTROL_REG0A3H, 404 au8522_writereg(state, AU8522_MODULE_CLOCK_CONTROL_REG0A3H,
400 AU8522_MODULE_CLOCK_CONTROL_REG0A3H_SVIDEO); 405 AU8522_MODULE_CLOCK_CONTROL_REG0A3H_SVIDEO);
401 406
402 /* Set input to Y on Channe1, C on Channel 3 */ 407 /* Set input to Y on Channe1, C on Channel 3 */
403 au8522_writereg(state, AU8522_INPUT_CONTROL_REG081H, 408 au8522_writereg(state, AU8522_INPUT_CONTROL_REG081H, input_mode);
404 AU8522_INPUT_CONTROL_REG081H_SVIDEO_CH13);
405 409
406 /* PGA in automatic mode */ 410 /* PGA in automatic mode */
407 au8522_writereg(state, AU8522_PGA_CONTROL_REG082H, 0x00); 411 au8522_writereg(state, AU8522_PGA_CONTROL_REG082H, 0x00);
@@ -409,8 +413,7 @@ static void au8522_setup_svideo_mode(struct au8522_state *state)
409 /* Enable clamping control */ 413 /* Enable clamping control */
410 au8522_writereg(state, AU8522_CLAMPING_CONTROL_REG083H, 0x00); 414 au8522_writereg(state, AU8522_CLAMPING_CONTROL_REG083H, 0x00);
411 415
412 setup_decoder_defaults(state, 416 setup_decoder_defaults(state, true);
413 AU8522_INPUT_CONTROL_REG081H_SVIDEO_CH13);
414 417
415 au8522_writereg(state, AU8522_SYSTEM_MODULE_CONTROL_0_REG0A4H, 418 au8522_writereg(state, AU8522_SYSTEM_MODULE_CONTROL_0_REG0A4H,
416 AU8522_SYSTEM_MODULE_CONTROL_0_REG0A4H_CVBS); 419 AU8522_SYSTEM_MODULE_CONTROL_0_REG0A4H_CVBS);
@@ -432,8 +435,9 @@ static void disable_audio_input(struct au8522_state *state)
432} 435}
433 436
434/* 0=disable, 1=SIF */ 437/* 0=disable, 1=SIF */
435static void set_audio_input(struct au8522_state *state, int aud_input) 438static void set_audio_input(struct au8522_state *state)
436{ 439{
440 int aud_input = state->aud_input;
437 int i; 441 int i;
438 442
439 /* Note that this function needs to be used in conjunction with setting 443 /* Note that this function needs to be used in conjunction with setting
@@ -465,8 +469,9 @@ static void set_audio_input(struct au8522_state *state, int aud_input)
465 au8522_writereg(state, AU8522_I2C_CONTROL_REG0_REG090H, 0x84); 469 au8522_writereg(state, AU8522_I2C_CONTROL_REG0_REG090H, 0x84);
466 msleep(150); 470 msleep(150);
467 au8522_writereg(state, AU8522_SYSTEM_MODULE_CONTROL_0_REG0A4H, 0x00); 471 au8522_writereg(state, AU8522_SYSTEM_MODULE_CONTROL_0_REG0A4H, 0x00);
468 msleep(1); 472 msleep(10);
469 au8522_writereg(state, AU8522_SYSTEM_MODULE_CONTROL_0_REG0A4H, 0x9d); 473 au8522_writereg(state, AU8522_SYSTEM_MODULE_CONTROL_0_REG0A4H,
474 AU8522_SYSTEM_MODULE_CONTROL_0_REG0A4H_CVBS);
470 msleep(50); 475 msleep(50);
471 au8522_writereg(state, AU8522_AUDIO_VOLUME_L_REG0F2H, 0x7F); 476 au8522_writereg(state, AU8522_AUDIO_VOLUME_L_REG0F2H, 0x7F);
472 au8522_writereg(state, AU8522_AUDIO_VOLUME_R_REG0F3H, 0x7F); 477 au8522_writereg(state, AU8522_AUDIO_VOLUME_R_REG0F3H, 0x7F);
@@ -539,58 +544,109 @@ static int au8522_s_register(struct v4l2_subdev *sd,
539} 544}
540#endif 545#endif
541 546
547static void au8522_video_set(struct au8522_state *state)
548{
549 u8 input_mode;
550
551 au8522_writereg(state, 0xa4, 1 << 5);
552
553 switch (state->vid_input) {
554 case AU8522_COMPOSITE_CH1:
555 input_mode = AU8522_INPUT_CONTROL_REG081H_CVBS_CH1;
556 au8522_setup_cvbs_mode(state, input_mode);
557 break;
558 case AU8522_COMPOSITE_CH2:
559 input_mode = AU8522_INPUT_CONTROL_REG081H_CVBS_CH2;
560 au8522_setup_cvbs_mode(state, input_mode);
561 break;
562 case AU8522_COMPOSITE_CH3:
563 input_mode = AU8522_INPUT_CONTROL_REG081H_CVBS_CH3;
564 au8522_setup_cvbs_mode(state, input_mode);
565 break;
566 case AU8522_COMPOSITE_CH4:
567 input_mode = AU8522_INPUT_CONTROL_REG081H_CVBS_CH4;
568 au8522_setup_cvbs_mode(state, input_mode);
569 break;
570 case AU8522_SVIDEO_CH13:
571 input_mode = AU8522_INPUT_CONTROL_REG081H_SVIDEO_CH13;
572 au8522_setup_svideo_mode(state, input_mode);
573 break;
574 case AU8522_SVIDEO_CH24:
575 input_mode = AU8522_INPUT_CONTROL_REG081H_SVIDEO_CH24;
576 au8522_setup_svideo_mode(state, input_mode);
577 break;
578 default:
579 case AU8522_COMPOSITE_CH4_SIF:
580 input_mode = AU8522_INPUT_CONTROL_REG081H_CVBS_CH4_SIF;
581 au8522_setup_cvbs_tuner_mode(state, input_mode);
582 break;
583 }
584}
585
542static int au8522_s_stream(struct v4l2_subdev *sd, int enable) 586static int au8522_s_stream(struct v4l2_subdev *sd, int enable)
543{ 587{
544 struct au8522_state *state = to_state(sd); 588 struct au8522_state *state = to_state(sd);
545 589
546 if (enable) { 590 if (enable) {
591 /*
592 * Clear out any state associated with the digital side of the
593 * chip, so that when it gets powered back up it won't think
594 * that it is already tuned
595 */
596 state->current_frequency = 0;
597
547 au8522_writereg(state, AU8522_SYSTEM_MODULE_CONTROL_0_REG0A4H, 598 au8522_writereg(state, AU8522_SYSTEM_MODULE_CONTROL_0_REG0A4H,
548 0x01); 599 0x01);
549 msleep(1); 600 msleep(10);
550 au8522_writereg(state, AU8522_SYSTEM_MODULE_CONTROL_0_REG0A4H, 601
551 AU8522_SYSTEM_MODULE_CONTROL_0_REG0A4H_CVBS); 602 au8522_video_set(state);
603 set_audio_input(state);
604
605 state->operational_mode = AU8522_ANALOG_MODE;
552 } else { 606 } else {
553 /* This does not completely power down the device 607 /* This does not completely power down the device
554 (it only reduces it from around 140ma to 80ma) */ 608 (it only reduces it from around 140ma to 80ma) */
555 au8522_writereg(state, AU8522_SYSTEM_MODULE_CONTROL_0_REG0A4H, 609 au8522_writereg(state, AU8522_SYSTEM_MODULE_CONTROL_0_REG0A4H,
556 1 << 5); 610 1 << 5);
611 state->operational_mode = AU8522_SUSPEND_MODE;
557 } 612 }
558 return 0; 613 return 0;
559} 614}
560 615
561static int au8522_reset(struct v4l2_subdev *sd, u32 val) 616static int au8522_s_video_routing(struct v4l2_subdev *sd,
617 u32 input, u32 output, u32 config)
562{ 618{
563 struct au8522_state *state = to_state(sd); 619 struct au8522_state *state = to_state(sd);
564 620
565 state->operational_mode = AU8522_ANALOG_MODE; 621 switch(input) {
566 622 case AU8522_COMPOSITE_CH1:
567 /* Clear out any state associated with the digital side of the 623 case AU8522_SVIDEO_CH13:
568 chip, so that when it gets powered back up it won't think 624 case AU8522_COMPOSITE_CH4_SIF:
569 that it is already tuned */ 625 state->vid_input = input;
570 state->current_frequency = 0; 626 break;
627 default:
628 printk(KERN_ERR "au8522 mode not currently supported\n");
629 return -EINVAL;
630 }
571 631
572 au8522_writereg(state, 0xa4, 1 << 5); 632 if (state->operational_mode == AU8522_ANALOG_MODE)
633 au8522_video_set(state);
573 634
574 return 0; 635 return 0;
575} 636}
576 637
577static int au8522_s_video_routing(struct v4l2_subdev *sd, 638static int au8522_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
578 u32 input, u32 output, u32 config)
579{ 639{
580 struct au8522_state *state = to_state(sd); 640 struct au8522_state *state = to_state(sd);
581 641
582 au8522_reset(sd, 0); 642 if ((std & (V4L2_STD_PAL_M | V4L2_STD_NTSC_M)) == 0)
583
584 if (input == AU8522_COMPOSITE_CH1) {
585 au8522_setup_cvbs_mode(state);
586 } else if (input == AU8522_SVIDEO_CH13) {
587 au8522_setup_svideo_mode(state);
588 } else if (input == AU8522_COMPOSITE_CH4_SIF) {
589 au8522_setup_cvbs_tuner_mode(state);
590 } else {
591 printk(KERN_ERR "au8522 mode not currently supported\n");
592 return -EINVAL; 643 return -EINVAL;
593 } 644
645 state->std = std;
646
647 if (state->operational_mode == AU8522_ANALOG_MODE)
648 au8522_video_set(state);
649
594 return 0; 650 return 0;
595} 651}
596 652
@@ -598,7 +654,12 @@ static int au8522_s_audio_routing(struct v4l2_subdev *sd,
598 u32 input, u32 output, u32 config) 654 u32 input, u32 output, u32 config)
599{ 655{
600 struct au8522_state *state = to_state(sd); 656 struct au8522_state *state = to_state(sd);
601 set_audio_input(state, input); 657
658 state->aud_input = input;
659
660 if (state->operational_mode == AU8522_ANALOG_MODE)
661 set_audio_input(state);
662
602 return 0; 663 return 0;
603} 664}
604 665
@@ -629,7 +690,6 @@ static int au8522_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
629 690
630static const struct v4l2_subdev_core_ops au8522_core_ops = { 691static const struct v4l2_subdev_core_ops au8522_core_ops = {
631 .log_status = v4l2_ctrl_subdev_log_status, 692 .log_status = v4l2_ctrl_subdev_log_status,
632 .reset = au8522_reset,
633#ifdef CONFIG_VIDEO_ADV_DEBUG 693#ifdef CONFIG_VIDEO_ADV_DEBUG
634 .g_register = au8522_g_register, 694 .g_register = au8522_g_register,
635 .s_register = au8522_s_register, 695 .s_register = au8522_s_register,
@@ -647,6 +707,7 @@ static const struct v4l2_subdev_audio_ops au8522_audio_ops = {
647static const struct v4l2_subdev_video_ops au8522_video_ops = { 707static const struct v4l2_subdev_video_ops au8522_video_ops = {
648 .s_routing = au8522_s_video_routing, 708 .s_routing = au8522_s_video_routing,
649 .s_stream = au8522_s_stream, 709 .s_stream = au8522_s_stream,
710 .s_std = au8522_s_std,
650}; 711};
651 712
652static const struct v4l2_subdev_ops au8522_ops = { 713static const struct v4l2_subdev_ops au8522_ops = {
@@ -729,6 +790,7 @@ static int au8522_probe(struct i2c_client *client,
729 } 790 }
730 791
731 state->c = client; 792 state->c = client;
793 state->std = V4L2_STD_NTSC_M;
732 state->vid_input = AU8522_COMPOSITE_CH1; 794 state->vid_input = AU8522_COMPOSITE_CH1;
733 state->aud_input = AU8522_AUDIO_NONE; 795 state->aud_input = AU8522_AUDIO_NONE;
734 state->id = 8522; 796 state->id = 8522;
diff --git a/drivers/media/dvb-frontends/au8522_priv.h b/drivers/media/dvb-frontends/au8522_priv.h
index aa0f16d6b610..b8aca1c84786 100644
--- a/drivers/media/dvb-frontends/au8522_priv.h
+++ b/drivers/media/dvb-frontends/au8522_priv.h
@@ -37,6 +37,7 @@
37 37
38#define AU8522_ANALOG_MODE 0 38#define AU8522_ANALOG_MODE 0
39#define AU8522_DIGITAL_MODE 1 39#define AU8522_DIGITAL_MODE 1
40#define AU8522_SUSPEND_MODE 2
40 41
41struct au8522_state { 42struct au8522_state {
42 struct i2c_client *c; 43 struct i2c_client *c;
@@ -347,6 +348,7 @@ int au8522_led_ctrl(struct au8522_state *state, int led);
347/* Format control 2 */ 348/* Format control 2 */
348#define AU8522_TVDEC_FORMAT_CTRL2_REG062H_STD_AUTODETECT 0x00 349#define AU8522_TVDEC_FORMAT_CTRL2_REG062H_STD_AUTODETECT 0x00
349#define AU8522_TVDEC_FORMAT_CTRL2_REG062H_STD_NTSC 0x01 350#define AU8522_TVDEC_FORMAT_CTRL2_REG062H_STD_NTSC 0x01
351#define AU8522_TVDEC_FORMAT_CTRL2_REG062H_STD_PAL_M 0x02
350 352
351 353
352#define AU8522_INPUT_CONTROL_REG081H_ATSC 0xC4 354#define AU8522_INPUT_CONTROL_REG081H_ATSC 0xC4
diff --git a/drivers/media/dvb-frontends/cxd2820r.h b/drivers/media/dvb-frontends/cxd2820r.h
index 82b3d93718f8..6095dbcf7850 100644
--- a/drivers/media/dvb-frontends/cxd2820r.h
+++ b/drivers/media/dvb-frontends/cxd2820r.h
@@ -52,6 +52,12 @@ struct cxd2820r_config {
52 */ 52 */
53 u8 ts_mode; 53 u8 ts_mode;
54 54
55 /* TS clock inverted.
56 * Default: 0
57 * Values: 0, 1
58 */
59 bool ts_clock_inv;
60
55 /* IF AGC polarity. 61 /* IF AGC polarity.
56 * Default: 0 62 * Default: 0
57 * Values: 0, 1 63 * Values: 0, 1
diff --git a/drivers/media/dvb-frontends/cxd2820r_c.c b/drivers/media/dvb-frontends/cxd2820r_c.c
index 5c6ab4921bf1..0f4657e01cde 100644
--- a/drivers/media/dvb-frontends/cxd2820r_c.c
+++ b/drivers/media/dvb-frontends/cxd2820r_c.c
@@ -45,6 +45,7 @@ int cxd2820r_set_frontend_c(struct dvb_frontend *fe)
45 { 0x1008b, 0x07, 0xff }, 45 { 0x1008b, 0x07, 0xff },
46 { 0x1001f, priv->cfg.if_agc_polarity << 7, 0x80 }, 46 { 0x1001f, priv->cfg.if_agc_polarity << 7, 0x80 },
47 { 0x10070, priv->cfg.ts_mode, 0xff }, 47 { 0x10070, priv->cfg.ts_mode, 0xff },
48 { 0x10071, !priv->cfg.ts_clock_inv << 4, 0x10 },
48 }; 49 };
49 50
50 dev_dbg(&priv->i2c->dev, "%s: frequency=%d symbol_rate=%d\n", __func__, 51 dev_dbg(&priv->i2c->dev, "%s: frequency=%d symbol_rate=%d\n", __func__,
diff --git a/drivers/media/dvb-frontends/cxd2820r_t.c b/drivers/media/dvb-frontends/cxd2820r_t.c
index fa184ca2dd68..9b5a45b907bc 100644
--- a/drivers/media/dvb-frontends/cxd2820r_t.c
+++ b/drivers/media/dvb-frontends/cxd2820r_t.c
@@ -46,6 +46,7 @@ int cxd2820r_set_frontend_t(struct dvb_frontend *fe)
46 { 0x00088, 0x01, 0xff }, 46 { 0x00088, 0x01, 0xff },
47 47
48 { 0x00070, priv->cfg.ts_mode, 0xff }, 48 { 0x00070, priv->cfg.ts_mode, 0xff },
49 { 0x00071, !priv->cfg.ts_clock_inv << 4, 0x10 },
49 { 0x000cb, priv->cfg.if_agc_polarity << 6, 0x40 }, 50 { 0x000cb, priv->cfg.if_agc_polarity << 6, 0x40 },
50 { 0x000a5, 0x00, 0x01 }, 51 { 0x000a5, 0x00, 0x01 },
51 { 0x00082, 0x20, 0x60 }, 52 { 0x00082, 0x20, 0x60 },
diff --git a/drivers/media/dvb-frontends/cxd2820r_t2.c b/drivers/media/dvb-frontends/cxd2820r_t2.c
index 2ba130e245b6..9c0c4f42175c 100644
--- a/drivers/media/dvb-frontends/cxd2820r_t2.c
+++ b/drivers/media/dvb-frontends/cxd2820r_t2.c
@@ -47,6 +47,7 @@ int cxd2820r_set_frontend_t2(struct dvb_frontend *fe)
47 { 0x02083, 0x0a, 0xff }, 47 { 0x02083, 0x0a, 0xff },
48 { 0x020cb, priv->cfg.if_agc_polarity << 6, 0x40 }, 48 { 0x020cb, priv->cfg.if_agc_polarity << 6, 0x40 },
49 { 0x02070, priv->cfg.ts_mode, 0xff }, 49 { 0x02070, priv->cfg.ts_mode, 0xff },
50 { 0x02071, !priv->cfg.ts_clock_inv << 6, 0x40 },
50 { 0x020b5, priv->cfg.spec_inv << 4, 0x10 }, 51 { 0x020b5, priv->cfg.spec_inv << 4, 0x10 },
51 { 0x02567, 0x07, 0x0f }, 52 { 0x02567, 0x07, 0x0f },
52 { 0x02569, 0x03, 0x03 }, 53 { 0x02569, 0x03, 0x03 },
diff --git a/drivers/media/dvb-frontends/dib0090.c b/drivers/media/dvb-frontends/dib0090.c
index 3ee22ff76315..68e2af2650d3 100644
--- a/drivers/media/dvb-frontends/dib0090.c
+++ b/drivers/media/dvb-frontends/dib0090.c
@@ -2557,10 +2557,19 @@ static int dib0090_set_params(struct dvb_frontend *fe)
2557 2557
2558 do { 2558 do {
2559 ret = dib0090_tune(fe); 2559 ret = dib0090_tune(fe);
2560 if (ret != FE_CALLBACK_TIME_NEVER) 2560 if (ret == FE_CALLBACK_TIME_NEVER)
2561 msleep(ret / 10);
2562 else
2563 break; 2561 break;
2562
2563 /*
2564 * Despite dib0090_tune returns time at a 0.1 ms range,
2565 * the actual sleep time depends on CONFIG_HZ. The worse case
2566 * is when CONFIG_HZ=100. In such case, the minimum granularity
2567 * is 10ms. On some real field tests, the tuner sometimes don't
2568 * lock when this timer is lower than 10ms. So, enforce a 10ms
2569 * granularity and use usleep_range() instead of msleep().
2570 */
2571 ret = 10 * (ret + 99)/100;
2572 usleep_range(ret * 1000, (ret + 1) * 1000);
2564 } while (state->tune_state != CT_TUNER_STOP); 2573 } while (state->tune_state != CT_TUNER_STOP);
2565 2574
2566 return 0; 2575 return 0;
diff --git a/drivers/media/dvb-frontends/dib7000m.c b/drivers/media/dvb-frontends/dib7000m.c
index 148bf79236fb..dcb9a15ef0c2 100644
--- a/drivers/media/dvb-frontends/dib7000m.c
+++ b/drivers/media/dvb-frontends/dib7000m.c
@@ -1041,10 +1041,7 @@ static int dib7000m_tune(struct dvb_frontend *demod)
1041 u16 value; 1041 u16 value;
1042 1042
1043 // we are already tuned - just resuming from suspend 1043 // we are already tuned - just resuming from suspend
1044 if (ch != NULL) 1044 dib7000m_set_channel(state, ch, 0);
1045 dib7000m_set_channel(state, ch, 0);
1046 else
1047 return -EINVAL;
1048 1045
1049 // restart demod 1046 // restart demod
1050 ret |= dib7000m_write_word(state, 898, 0x4000); 1047 ret |= dib7000m_write_word(state, 898, 0x4000);
diff --git a/drivers/media/dvb-frontends/dib7000p.c b/drivers/media/dvb-frontends/dib7000p.c
index effb87f773b0..661760d60232 100644
--- a/drivers/media/dvb-frontends/dib7000p.c
+++ b/drivers/media/dvb-frontends/dib7000p.c
@@ -11,6 +11,7 @@
11#include <linux/slab.h> 11#include <linux/slab.h>
12#include <linux/i2c.h> 12#include <linux/i2c.h>
13#include <linux/mutex.h> 13#include <linux/mutex.h>
14#include <asm/div64.h>
14 15
15#include "dvb_math.h" 16#include "dvb_math.h"
16#include "dvb_frontend.h" 17#include "dvb_frontend.h"
@@ -72,6 +73,12 @@ struct dib7000p_state {
72 struct mutex i2c_buffer_lock; 73 struct mutex i2c_buffer_lock;
73 74
74 u8 input_mode_mpeg; 75 u8 input_mode_mpeg;
76
77 /* for DVBv5 stats */
78 s64 old_ucb;
79 unsigned long per_jiffies_stats;
80 unsigned long ber_jiffies_stats;
81 unsigned long get_stats_time;
75}; 82};
76 83
77enum dib7000p_power_mode { 84enum dib7000p_power_mode {
@@ -401,7 +408,7 @@ static int dib7000p_sad_calib(struct dib7000p_state *state)
401 return 0; 408 return 0;
402} 409}
403 410
404int dib7000p_set_wbd_ref(struct dvb_frontend *demod, u16 value) 411static int dib7000p_set_wbd_ref(struct dvb_frontend *demod, u16 value)
405{ 412{
406 struct dib7000p_state *state = demod->demodulator_priv; 413 struct dib7000p_state *state = demod->demodulator_priv;
407 if (value > 4095) 414 if (value > 4095)
@@ -409,9 +416,8 @@ int dib7000p_set_wbd_ref(struct dvb_frontend *demod, u16 value)
409 state->wbd_ref = value; 416 state->wbd_ref = value;
410 return dib7000p_write_word(state, 105, (dib7000p_read_word(state, 105) & 0xf000) | value); 417 return dib7000p_write_word(state, 105, (dib7000p_read_word(state, 105) & 0xf000) | value);
411} 418}
412EXPORT_SYMBOL(dib7000p_set_wbd_ref);
413 419
414int dib7000p_get_agc_values(struct dvb_frontend *fe, 420static int dib7000p_get_agc_values(struct dvb_frontend *fe,
415 u16 *agc_global, u16 *agc1, u16 *agc2, u16 *wbd) 421 u16 *agc_global, u16 *agc1, u16 *agc2, u16 *wbd)
416{ 422{
417 struct dib7000p_state *state = fe->demodulator_priv; 423 struct dib7000p_state *state = fe->demodulator_priv;
@@ -427,14 +433,12 @@ int dib7000p_get_agc_values(struct dvb_frontend *fe,
427 433
428 return 0; 434 return 0;
429} 435}
430EXPORT_SYMBOL(dib7000p_get_agc_values);
431 436
432int dib7000p_set_agc1_min(struct dvb_frontend *fe, u16 v) 437static int dib7000p_set_agc1_min(struct dvb_frontend *fe, u16 v)
433{ 438{
434 struct dib7000p_state *state = fe->demodulator_priv; 439 struct dib7000p_state *state = fe->demodulator_priv;
435 return dib7000p_write_word(state, 108, v); 440 return dib7000p_write_word(state, 108, v);
436} 441}
437EXPORT_SYMBOL(dib7000p_set_agc1_min);
438 442
439static void dib7000p_reset_pll(struct dib7000p_state *state) 443static void dib7000p_reset_pll(struct dib7000p_state *state)
440{ 444{
@@ -478,7 +482,7 @@ static u32 dib7000p_get_internal_freq(struct dib7000p_state *state)
478 return internal; 482 return internal;
479} 483}
480 484
481int dib7000p_update_pll(struct dvb_frontend *fe, struct dibx000_bandwidth_config *bw) 485static int dib7000p_update_pll(struct dvb_frontend *fe, struct dibx000_bandwidth_config *bw)
482{ 486{
483 struct dib7000p_state *state = fe->demodulator_priv; 487 struct dib7000p_state *state = fe->demodulator_priv;
484 u16 reg_1857, reg_1856 = dib7000p_read_word(state, 1856); 488 u16 reg_1857, reg_1856 = dib7000p_read_word(state, 1856);
@@ -513,7 +517,6 @@ int dib7000p_update_pll(struct dvb_frontend *fe, struct dibx000_bandwidth_config
513 } 517 }
514 return -EIO; 518 return -EIO;
515} 519}
516EXPORT_SYMBOL(dib7000p_update_pll);
517 520
518static int dib7000p_reset_gpio(struct dib7000p_state *st) 521static int dib7000p_reset_gpio(struct dib7000p_state *st)
519{ 522{
@@ -546,12 +549,11 @@ static int dib7000p_cfg_gpio(struct dib7000p_state *st, u8 num, u8 dir, u8 val)
546 return 0; 549 return 0;
547} 550}
548 551
549int dib7000p_set_gpio(struct dvb_frontend *demod, u8 num, u8 dir, u8 val) 552static int dib7000p_set_gpio(struct dvb_frontend *demod, u8 num, u8 dir, u8 val)
550{ 553{
551 struct dib7000p_state *state = demod->demodulator_priv; 554 struct dib7000p_state *state = demod->demodulator_priv;
552 return dib7000p_cfg_gpio(state, num, dir, val); 555 return dib7000p_cfg_gpio(state, num, dir, val);
553} 556}
554EXPORT_SYMBOL(dib7000p_set_gpio);
555 557
556static u16 dib7000p_defaults[] = { 558static u16 dib7000p_defaults[] = {
557 // auto search configuration 559 // auto search configuration
@@ -636,6 +638,8 @@ static u16 dib7000p_defaults[] = {
636 0, 638 0,
637}; 639};
638 640
641static void dib7000p_reset_stats(struct dvb_frontend *fe);
642
639static int dib7000p_demod_reset(struct dib7000p_state *state) 643static int dib7000p_demod_reset(struct dib7000p_state *state)
640{ 644{
641 dib7000p_set_power_mode(state, DIB7000P_POWER_ALL); 645 dib7000p_set_power_mode(state, DIB7000P_POWER_ALL);
@@ -934,7 +938,7 @@ static void dib7000p_update_timf(struct dib7000p_state *state)
934 938
935} 939}
936 940
937u32 dib7000p_ctrl_timf(struct dvb_frontend *fe, u8 op, u32 timf) 941static u32 dib7000p_ctrl_timf(struct dvb_frontend *fe, u8 op, u32 timf)
938{ 942{
939 struct dib7000p_state *state = fe->demodulator_priv; 943 struct dib7000p_state *state = fe->demodulator_priv;
940 switch (op) { 944 switch (op) {
@@ -950,7 +954,6 @@ u32 dib7000p_ctrl_timf(struct dvb_frontend *fe, u8 op, u32 timf)
950 dib7000p_set_bandwidth(state, state->current_bandwidth); 954 dib7000p_set_bandwidth(state, state->current_bandwidth);
951 return state->timf; 955 return state->timf;
952} 956}
953EXPORT_SYMBOL(dib7000p_ctrl_timf);
954 957
955static void dib7000p_set_channel(struct dib7000p_state *state, 958static void dib7000p_set_channel(struct dib7000p_state *state,
956 struct dtv_frontend_properties *ch, u8 seq) 959 struct dtv_frontend_properties *ch, u8 seq)
@@ -1360,6 +1363,9 @@ static int dib7000p_tune(struct dvb_frontend *demod)
1360 dib7000p_spur_protect(state, ch->frequency / 1000, BANDWIDTH_TO_KHZ(ch->bandwidth_hz)); 1363 dib7000p_spur_protect(state, ch->frequency / 1000, BANDWIDTH_TO_KHZ(ch->bandwidth_hz));
1361 1364
1362 dib7000p_set_bandwidth(state, BANDWIDTH_TO_KHZ(ch->bandwidth_hz)); 1365 dib7000p_set_bandwidth(state, BANDWIDTH_TO_KHZ(ch->bandwidth_hz));
1366
1367 dib7000p_reset_stats(demod);
1368
1363 return 0; 1369 return 0;
1364} 1370}
1365 1371
@@ -1552,6 +1558,8 @@ static int dib7000p_set_frontend(struct dvb_frontend *fe)
1552 return ret; 1558 return ret;
1553} 1559}
1554 1560
1561static int dib7000p_get_stats(struct dvb_frontend *fe, fe_status_t stat);
1562
1555static int dib7000p_read_status(struct dvb_frontend *fe, fe_status_t * stat) 1563static int dib7000p_read_status(struct dvb_frontend *fe, fe_status_t * stat)
1556{ 1564{
1557 struct dib7000p_state *state = fe->demodulator_priv; 1565 struct dib7000p_state *state = fe->demodulator_priv;
@@ -1570,6 +1578,8 @@ static int dib7000p_read_status(struct dvb_frontend *fe, fe_status_t * stat)
1570 if ((lock & 0x0038) == 0x38) 1578 if ((lock & 0x0038) == 0x38)
1571 *stat |= FE_HAS_LOCK; 1579 *stat |= FE_HAS_LOCK;
1572 1580
1581 dib7000p_get_stats(fe, *stat);
1582
1573 return 0; 1583 return 0;
1574} 1584}
1575 1585
@@ -1595,7 +1605,7 @@ static int dib7000p_read_signal_strength(struct dvb_frontend *fe, u16 * strength
1595 return 0; 1605 return 0;
1596} 1606}
1597 1607
1598static int dib7000p_read_snr(struct dvb_frontend *fe, u16 * snr) 1608static u32 dib7000p_get_snr(struct dvb_frontend *fe)
1599{ 1609{
1600 struct dib7000p_state *state = fe->demodulator_priv; 1610 struct dib7000p_state *state = fe->demodulator_priv;
1601 u16 val; 1611 u16 val;
@@ -1625,10 +1635,351 @@ static int dib7000p_read_snr(struct dvb_frontend *fe, u16 * snr)
1625 else 1635 else
1626 result -= intlog10(2) * 10 * noise_exp - 100; 1636 result -= intlog10(2) * 10 * noise_exp - 100;
1627 1637
1638 return result;
1639}
1640
1641static int dib7000p_read_snr(struct dvb_frontend *fe, u16 *snr)
1642{
1643 u32 result;
1644
1645 result = dib7000p_get_snr(fe);
1646
1628 *snr = result / ((1 << 24) / 10); 1647 *snr = result / ((1 << 24) / 10);
1629 return 0; 1648 return 0;
1630} 1649}
1631 1650
1651static void dib7000p_reset_stats(struct dvb_frontend *demod)
1652{
1653 struct dib7000p_state *state = demod->demodulator_priv;
1654 struct dtv_frontend_properties *c = &demod->dtv_property_cache;
1655 u32 ucb;
1656
1657 memset(&c->strength, 0, sizeof(c->strength));
1658 memset(&c->cnr, 0, sizeof(c->cnr));
1659 memset(&c->post_bit_error, 0, sizeof(c->post_bit_error));
1660 memset(&c->post_bit_count, 0, sizeof(c->post_bit_count));
1661 memset(&c->block_error, 0, sizeof(c->block_error));
1662
1663 c->strength.len = 1;
1664 c->cnr.len = 1;
1665 c->block_error.len = 1;
1666 c->block_count.len = 1;
1667 c->post_bit_error.len = 1;
1668 c->post_bit_count.len = 1;
1669
1670 c->strength.stat[0].scale = FE_SCALE_DECIBEL;
1671 c->strength.stat[0].uvalue = 0;
1672
1673 c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1674 c->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1675 c->block_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1676 c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1677 c->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1678
1679 dib7000p_read_unc_blocks(demod, &ucb);
1680
1681 state->old_ucb = ucb;
1682 state->ber_jiffies_stats = 0;
1683 state->per_jiffies_stats = 0;
1684}
1685
1686struct linear_segments {
1687 unsigned x;
1688 signed y;
1689};
1690
1691/*
1692 * Table to estimate signal strength in dBm.
1693 * This table should be empirically determinated by measuring the signal
1694 * strength generated by a RF generator directly connected into
1695 * a device.
1696 * This table was determinated by measuring the signal strength generated
1697 * by a DTA-2111 RF generator directly connected into a dib7000p device
1698 * (a Hauppauge Nova-TD stick), using a good quality 3 meters length
1699 * RC6 cable and good RC6 connectors, connected directly to antenna 1.
1700 * As the minimum output power of DTA-2111 is -31dBm, a 16 dBm attenuator
1701 * were used, for the lower power values.
1702 * The real value can actually be on other devices, or even at the
1703 * second antena input, depending on several factors, like if LNA
1704 * is enabled or not, if diversity is enabled, type of connectors, etc.
1705 * Yet, it is better to use this measure in dB than a random non-linear
1706 * percentage value, especially for antenna adjustments.
1707 * On my tests, the precision of the measure using this table is about
1708 * 0.5 dB, with sounds reasonable enough to adjust antennas.
1709 */
1710#define DB_OFFSET 131000
1711
1712static struct linear_segments strength_to_db_table[] = {
1713 { 63630, DB_OFFSET - 20500},
1714 { 62273, DB_OFFSET - 21000},
1715 { 60162, DB_OFFSET - 22000},
1716 { 58730, DB_OFFSET - 23000},
1717 { 58294, DB_OFFSET - 24000},
1718 { 57778, DB_OFFSET - 25000},
1719 { 57320, DB_OFFSET - 26000},
1720 { 56779, DB_OFFSET - 27000},
1721 { 56293, DB_OFFSET - 28000},
1722 { 55724, DB_OFFSET - 29000},
1723 { 55145, DB_OFFSET - 30000},
1724 { 54680, DB_OFFSET - 31000},
1725 { 54293, DB_OFFSET - 32000},
1726 { 53813, DB_OFFSET - 33000},
1727 { 53427, DB_OFFSET - 34000},
1728 { 52981, DB_OFFSET - 35000},
1729
1730 { 52636, DB_OFFSET - 36000},
1731 { 52014, DB_OFFSET - 37000},
1732 { 51674, DB_OFFSET - 38000},
1733 { 50692, DB_OFFSET - 39000},
1734 { 49824, DB_OFFSET - 40000},
1735 { 49052, DB_OFFSET - 41000},
1736 { 48436, DB_OFFSET - 42000},
1737 { 47836, DB_OFFSET - 43000},
1738 { 47368, DB_OFFSET - 44000},
1739 { 46468, DB_OFFSET - 45000},
1740 { 45597, DB_OFFSET - 46000},
1741 { 44586, DB_OFFSET - 47000},
1742 { 43667, DB_OFFSET - 48000},
1743 { 42673, DB_OFFSET - 49000},
1744 { 41816, DB_OFFSET - 50000},
1745 { 40876, DB_OFFSET - 51000},
1746 { 0, 0},
1747};
1748
1749static u32 interpolate_value(u32 value, struct linear_segments *segments,
1750 unsigned len)
1751{
1752 u64 tmp64;
1753 u32 dx;
1754 s32 dy;
1755 int i, ret;
1756
1757 if (value >= segments[0].x)
1758 return segments[0].y;
1759 if (value < segments[len-1].x)
1760 return segments[len-1].y;
1761
1762 for (i = 1; i < len - 1; i++) {
1763 /* If value is identical, no need to interpolate */
1764 if (value == segments[i].x)
1765 return segments[i].y;
1766 if (value > segments[i].x)
1767 break;
1768 }
1769
1770 /* Linear interpolation between the two (x,y) points */
1771 dy = segments[i - 1].y - segments[i].y;
1772 dx = segments[i - 1].x - segments[i].x;
1773
1774 tmp64 = value - segments[i].x;
1775 tmp64 *= dy;
1776 do_div(tmp64, dx);
1777 ret = segments[i].y + tmp64;
1778
1779 return ret;
1780}
1781
1782/* FIXME: may require changes - this one was borrowed from dib8000 */
1783static u32 dib7000p_get_time_us(struct dvb_frontend *demod, int layer)
1784{
1785 struct dtv_frontend_properties *c = &demod->dtv_property_cache;
1786 u64 time_us, tmp64;
1787 u32 tmp, denom;
1788 int guard, rate_num, rate_denum = 1, bits_per_symbol;
1789 int interleaving = 0, fft_div;
1790
1791 switch (c->guard_interval) {
1792 case GUARD_INTERVAL_1_4:
1793 guard = 4;
1794 break;
1795 case GUARD_INTERVAL_1_8:
1796 guard = 8;
1797 break;
1798 case GUARD_INTERVAL_1_16:
1799 guard = 16;
1800 break;
1801 default:
1802 case GUARD_INTERVAL_1_32:
1803 guard = 32;
1804 break;
1805 }
1806
1807 switch (c->transmission_mode) {
1808 case TRANSMISSION_MODE_2K:
1809 fft_div = 4;
1810 break;
1811 case TRANSMISSION_MODE_4K:
1812 fft_div = 2;
1813 break;
1814 default:
1815 case TRANSMISSION_MODE_8K:
1816 fft_div = 1;
1817 break;
1818 }
1819
1820 switch (c->modulation) {
1821 case DQPSK:
1822 case QPSK:
1823 bits_per_symbol = 2;
1824 break;
1825 case QAM_16:
1826 bits_per_symbol = 4;
1827 break;
1828 default:
1829 case QAM_64:
1830 bits_per_symbol = 6;
1831 break;
1832 }
1833
1834 switch ((c->hierarchy == 0 || 1 == 1) ? c->code_rate_HP : c->code_rate_LP) {
1835 case FEC_1_2:
1836 rate_num = 1;
1837 rate_denum = 2;
1838 break;
1839 case FEC_2_3:
1840 rate_num = 2;
1841 rate_denum = 3;
1842 break;
1843 case FEC_3_4:
1844 rate_num = 3;
1845 rate_denum = 4;
1846 break;
1847 case FEC_5_6:
1848 rate_num = 5;
1849 rate_denum = 6;
1850 break;
1851 default:
1852 case FEC_7_8:
1853 rate_num = 7;
1854 rate_denum = 8;
1855 break;
1856 }
1857
1858 interleaving = interleaving;
1859
1860 denom = bits_per_symbol * rate_num * fft_div * 384;
1861
1862 /* If calculus gets wrong, wait for 1s for the next stats */
1863 if (!denom)
1864 return 0;
1865
1866 /* Estimate the period for the total bit rate */
1867 time_us = rate_denum * (1008 * 1562500L);
1868 tmp64 = time_us;
1869 do_div(tmp64, guard);
1870 time_us = time_us + tmp64;
1871 time_us += denom / 2;
1872 do_div(time_us, denom);
1873
1874 tmp = 1008 * 96 * interleaving;
1875 time_us += tmp + tmp / guard;
1876
1877 return time_us;
1878}
1879
1880static int dib7000p_get_stats(struct dvb_frontend *demod, fe_status_t stat)
1881{
1882 struct dib7000p_state *state = demod->demodulator_priv;
1883 struct dtv_frontend_properties *c = &demod->dtv_property_cache;
1884 int i;
1885 int show_per_stats = 0;
1886 u32 time_us = 0, val, snr;
1887 u64 blocks, ucb;
1888 s32 db;
1889 u16 strength;
1890
1891 /* Get Signal strength */
1892 dib7000p_read_signal_strength(demod, &strength);
1893 val = strength;
1894 db = interpolate_value(val,
1895 strength_to_db_table,
1896 ARRAY_SIZE(strength_to_db_table)) - DB_OFFSET;
1897 c->strength.stat[0].svalue = db;
1898
1899 /* UCB/BER/CNR measures require lock */
1900 if (!(stat & FE_HAS_LOCK)) {
1901 c->cnr.len = 1;
1902 c->block_count.len = 1;
1903 c->block_error.len = 1;
1904 c->post_bit_error.len = 1;
1905 c->post_bit_count.len = 1;
1906 c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1907 c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1908 c->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1909 c->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1910 c->block_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1911 return 0;
1912 }
1913
1914 /* Check if time for stats was elapsed */
1915 if (time_after(jiffies, state->per_jiffies_stats)) {
1916 state->per_jiffies_stats = jiffies + msecs_to_jiffies(1000);
1917
1918 /* Get SNR */
1919 snr = dib7000p_get_snr(demod);
1920 if (snr)
1921 snr = (1000L * snr) >> 24;
1922 else
1923 snr = 0;
1924 c->cnr.stat[0].svalue = snr;
1925 c->cnr.stat[0].scale = FE_SCALE_DECIBEL;
1926
1927 /* Get UCB measures */
1928 dib7000p_read_unc_blocks(demod, &val);
1929 ucb = val - state->old_ucb;
1930 if (val < state->old_ucb)
1931 ucb += 0x100000000LL;
1932
1933 c->block_error.stat[0].scale = FE_SCALE_COUNTER;
1934 c->block_error.stat[0].uvalue = ucb;
1935
1936 /* Estimate the number of packets based on bitrate */
1937 if (!time_us)
1938 time_us = dib7000p_get_time_us(demod, -1);
1939
1940 if (time_us) {
1941 blocks = 1250000ULL * 1000000ULL;
1942 do_div(blocks, time_us * 8 * 204);
1943 c->block_count.stat[0].scale = FE_SCALE_COUNTER;
1944 c->block_count.stat[0].uvalue += blocks;
1945 }
1946
1947 show_per_stats = 1;
1948 }
1949
1950 /* Get post-BER measures */
1951 if (time_after(jiffies, state->ber_jiffies_stats)) {
1952 time_us = dib7000p_get_time_us(demod, -1);
1953 state->ber_jiffies_stats = jiffies + msecs_to_jiffies((time_us + 500) / 1000);
1954
1955 dprintk("Next all layers stats available in %u us.", time_us);
1956
1957 dib7000p_read_ber(demod, &val);
1958 c->post_bit_error.stat[0].scale = FE_SCALE_COUNTER;
1959 c->post_bit_error.stat[0].uvalue += val;
1960
1961 c->post_bit_count.stat[0].scale = FE_SCALE_COUNTER;
1962 c->post_bit_count.stat[0].uvalue += 100000000;
1963 }
1964
1965 /* Get PER measures */
1966 if (show_per_stats) {
1967 dib7000p_read_unc_blocks(demod, &val);
1968
1969 c->block_error.stat[0].scale = FE_SCALE_COUNTER;
1970 c->block_error.stat[0].uvalue += val;
1971
1972 time_us = dib7000p_get_time_us(demod, i);
1973 if (time_us) {
1974 blocks = 1250000ULL * 1000000ULL;
1975 do_div(blocks, time_us * 8 * 204);
1976 c->block_count.stat[0].scale = FE_SCALE_COUNTER;
1977 c->block_count.stat[0].uvalue += blocks;
1978 }
1979 }
1980 return 0;
1981}
1982
1632static int dib7000p_fe_get_tune_settings(struct dvb_frontend *fe, struct dvb_frontend_tune_settings *tune) 1983static int dib7000p_fe_get_tune_settings(struct dvb_frontend *fe, struct dvb_frontend_tune_settings *tune)
1633{ 1984{
1634 tune->min_delay_ms = 1000; 1985 tune->min_delay_ms = 1000;
@@ -1643,7 +1994,7 @@ static void dib7000p_release(struct dvb_frontend *demod)
1643 kfree(st); 1994 kfree(st);
1644} 1995}
1645 1996
1646int dib7000pc_detection(struct i2c_adapter *i2c_adap) 1997static int dib7000pc_detection(struct i2c_adapter *i2c_adap)
1647{ 1998{
1648 u8 *tx, *rx; 1999 u8 *tx, *rx;
1649 struct i2c_msg msg[2] = { 2000 struct i2c_msg msg[2] = {
@@ -1688,16 +2039,14 @@ rx_memory_error:
1688 kfree(tx); 2039 kfree(tx);
1689 return ret; 2040 return ret;
1690} 2041}
1691EXPORT_SYMBOL(dib7000pc_detection);
1692 2042
1693struct i2c_adapter *dib7000p_get_i2c_master(struct dvb_frontend *demod, enum dibx000_i2c_interface intf, int gating) 2043static struct i2c_adapter *dib7000p_get_i2c_master(struct dvb_frontend *demod, enum dibx000_i2c_interface intf, int gating)
1694{ 2044{
1695 struct dib7000p_state *st = demod->demodulator_priv; 2045 struct dib7000p_state *st = demod->demodulator_priv;
1696 return dibx000_get_i2c_adapter(&st->i2c_master, intf, gating); 2046 return dibx000_get_i2c_adapter(&st->i2c_master, intf, gating);
1697} 2047}
1698EXPORT_SYMBOL(dib7000p_get_i2c_master);
1699 2048
1700int dib7000p_pid_filter_ctrl(struct dvb_frontend *fe, u8 onoff) 2049static int dib7000p_pid_filter_ctrl(struct dvb_frontend *fe, u8 onoff)
1701{ 2050{
1702 struct dib7000p_state *state = fe->demodulator_priv; 2051 struct dib7000p_state *state = fe->demodulator_priv;
1703 u16 val = dib7000p_read_word(state, 235) & 0xffef; 2052 u16 val = dib7000p_read_word(state, 235) & 0xffef;
@@ -1705,17 +2054,15 @@ int dib7000p_pid_filter_ctrl(struct dvb_frontend *fe, u8 onoff)
1705 dprintk("PID filter enabled %d", onoff); 2054 dprintk("PID filter enabled %d", onoff);
1706 return dib7000p_write_word(state, 235, val); 2055 return dib7000p_write_word(state, 235, val);
1707} 2056}
1708EXPORT_SYMBOL(dib7000p_pid_filter_ctrl);
1709 2057
1710int dib7000p_pid_filter(struct dvb_frontend *fe, u8 id, u16 pid, u8 onoff) 2058static int dib7000p_pid_filter(struct dvb_frontend *fe, u8 id, u16 pid, u8 onoff)
1711{ 2059{
1712 struct dib7000p_state *state = fe->demodulator_priv; 2060 struct dib7000p_state *state = fe->demodulator_priv;
1713 dprintk("PID filter: index %x, PID %d, OnOff %d", id, pid, onoff); 2061 dprintk("PID filter: index %x, PID %d, OnOff %d", id, pid, onoff);
1714 return dib7000p_write_word(state, 241 + id, onoff ? (1 << 13) | pid : 0); 2062 return dib7000p_write_word(state, 241 + id, onoff ? (1 << 13) | pid : 0);
1715} 2063}
1716EXPORT_SYMBOL(dib7000p_pid_filter);
1717 2064
1718int dib7000p_i2c_enumeration(struct i2c_adapter *i2c, int no_of_demods, u8 default_addr, struct dib7000p_config cfg[]) 2065static int dib7000p_i2c_enumeration(struct i2c_adapter *i2c, int no_of_demods, u8 default_addr, struct dib7000p_config cfg[])
1719{ 2066{
1720 struct dib7000p_state *dpst; 2067 struct dib7000p_state *dpst;
1721 int k = 0; 2068 int k = 0;
@@ -1774,7 +2121,6 @@ int dib7000p_i2c_enumeration(struct i2c_adapter *i2c, int no_of_demods, u8 defau
1774 kfree(dpst); 2121 kfree(dpst);
1775 return 0; 2122 return 0;
1776} 2123}
1777EXPORT_SYMBOL(dib7000p_i2c_enumeration);
1778 2124
1779static const s32 lut_1000ln_mant[] = { 2125static const s32 lut_1000ln_mant[] = {
1780 6908, 6956, 7003, 7047, 7090, 7131, 7170, 7208, 7244, 7279, 7313, 7346, 7377, 7408, 7438, 7467, 7495, 7523, 7549, 7575, 7600 2126 6908, 6956, 7003, 7047, 7090, 7131, 7170, 7208, 7244, 7279, 7313, 7346, 7377, 7408, 7438, 7467, 7495, 7523, 7549, 7575, 7600
@@ -2032,12 +2378,11 @@ static struct i2c_algorithm dib7090_tuner_xfer_algo = {
2032 .functionality = dib7000p_i2c_func, 2378 .functionality = dib7000p_i2c_func,
2033}; 2379};
2034 2380
2035struct i2c_adapter *dib7090_get_i2c_tuner(struct dvb_frontend *fe) 2381static struct i2c_adapter *dib7090_get_i2c_tuner(struct dvb_frontend *fe)
2036{ 2382{
2037 struct dib7000p_state *st = fe->demodulator_priv; 2383 struct dib7000p_state *st = fe->demodulator_priv;
2038 return &st->dib7090_tuner_adap; 2384 return &st->dib7090_tuner_adap;
2039} 2385}
2040EXPORT_SYMBOL(dib7090_get_i2c_tuner);
2041 2386
2042static int dib7090_host_bus_drive(struct dib7000p_state *state, u8 drive) 2387static int dib7090_host_bus_drive(struct dib7000p_state *state, u8 drive)
2043{ 2388{
@@ -2329,7 +2674,7 @@ static int dib7090_set_output_mode(struct dvb_frontend *fe, int mode)
2329 return ret; 2674 return ret;
2330} 2675}
2331 2676
2332int dib7090_tuner_sleep(struct dvb_frontend *fe, int onoff) 2677static int dib7090_tuner_sleep(struct dvb_frontend *fe, int onoff)
2333{ 2678{
2334 struct dib7000p_state *state = fe->demodulator_priv; 2679 struct dib7000p_state *state = fe->demodulator_priv;
2335 u16 en_cur_state; 2680 u16 en_cur_state;
@@ -2352,15 +2697,13 @@ int dib7090_tuner_sleep(struct dvb_frontend *fe, int onoff)
2352 2697
2353 return 0; 2698 return 0;
2354} 2699}
2355EXPORT_SYMBOL(dib7090_tuner_sleep);
2356 2700
2357int dib7090_get_adc_power(struct dvb_frontend *fe) 2701static int dib7090_get_adc_power(struct dvb_frontend *fe)
2358{ 2702{
2359 return dib7000p_get_adc_power(fe); 2703 return dib7000p_get_adc_power(fe);
2360} 2704}
2361EXPORT_SYMBOL(dib7090_get_adc_power);
2362 2705
2363int dib7090_slave_reset(struct dvb_frontend *fe) 2706static int dib7090_slave_reset(struct dvb_frontend *fe)
2364{ 2707{
2365 struct dib7000p_state *state = fe->demodulator_priv; 2708 struct dib7000p_state *state = fe->demodulator_priv;
2366 u16 reg; 2709 u16 reg;
@@ -2371,10 +2714,9 @@ int dib7090_slave_reset(struct dvb_frontend *fe)
2371 dib7000p_write_word(state, 1032, 0xffff); 2714 dib7000p_write_word(state, 1032, 0xffff);
2372 return 0; 2715 return 0;
2373} 2716}
2374EXPORT_SYMBOL(dib7090_slave_reset);
2375 2717
2376static struct dvb_frontend_ops dib7000p_ops; 2718static struct dvb_frontend_ops dib7000p_ops;
2377struct dvb_frontend *dib7000p_attach(struct i2c_adapter *i2c_adap, u8 i2c_addr, struct dib7000p_config *cfg) 2719static struct dvb_frontend *dib7000p_init(struct i2c_adapter *i2c_adap, u8 i2c_addr, struct dib7000p_config *cfg)
2378{ 2720{
2379 struct dvb_frontend *demod; 2721 struct dvb_frontend *demod;
2380 struct dib7000p_state *st; 2722 struct dib7000p_state *st;
@@ -2423,6 +2765,8 @@ struct dvb_frontend *dib7000p_attach(struct i2c_adapter *i2c_adap, u8 i2c_addr,
2423 2765
2424 dib7000p_demod_reset(st); 2766 dib7000p_demod_reset(st);
2425 2767
2768 dib7000p_reset_stats(demod);
2769
2426 if (st->version == SOC7090) { 2770 if (st->version == SOC7090) {
2427 dib7090_set_output_mode(demod, st->cfg.output_mode); 2771 dib7090_set_output_mode(demod, st->cfg.output_mode);
2428 dib7090_set_diversity_in(demod, 0); 2772 dib7090_set_diversity_in(demod, 0);
@@ -2434,6 +2778,31 @@ error:
2434 kfree(st); 2778 kfree(st);
2435 return NULL; 2779 return NULL;
2436} 2780}
2781
2782void *dib7000p_attach(struct dib7000p_ops *ops)
2783{
2784 if (!ops)
2785 return NULL;
2786
2787 ops->slave_reset = dib7090_slave_reset;
2788 ops->get_adc_power = dib7090_get_adc_power;
2789 ops->dib7000pc_detection = dib7000pc_detection;
2790 ops->get_i2c_tuner = dib7090_get_i2c_tuner;
2791 ops->tuner_sleep = dib7090_tuner_sleep;
2792 ops->init = dib7000p_init;
2793 ops->set_agc1_min = dib7000p_set_agc1_min;
2794 ops->set_gpio = dib7000p_set_gpio;
2795 ops->i2c_enumeration = dib7000p_i2c_enumeration;
2796 ops->pid_filter = dib7000p_pid_filter;
2797 ops->pid_filter_ctrl = dib7000p_pid_filter_ctrl;
2798 ops->get_i2c_master = dib7000p_get_i2c_master;
2799 ops->update_pll = dib7000p_update_pll;
2800 ops->ctrl_timf = dib7000p_ctrl_timf;
2801 ops->get_agc_values = dib7000p_get_agc_values;
2802 ops->set_wbd_ref = dib7000p_set_wbd_ref;
2803
2804 return ops;
2805}
2437EXPORT_SYMBOL(dib7000p_attach); 2806EXPORT_SYMBOL(dib7000p_attach);
2438 2807
2439static struct dvb_frontend_ops dib7000p_ops = { 2808static struct dvb_frontend_ops dib7000p_ops = {
diff --git a/drivers/media/dvb-frontends/dib7000p.h b/drivers/media/dvb-frontends/dib7000p.h
index d08cdff59bdf..1fea0e972654 100644
--- a/drivers/media/dvb-frontends/dib7000p.h
+++ b/drivers/media/dvb-frontends/dib7000p.h
@@ -46,121 +46,34 @@ struct dib7000p_config {
46 46
47#define DEFAULT_DIB7000P_I2C_ADDRESS 18 47#define DEFAULT_DIB7000P_I2C_ADDRESS 18
48 48
49#if IS_ENABLED(CONFIG_DVB_DIB7000P) 49struct dib7000p_ops {
50extern struct dvb_frontend *dib7000p_attach(struct i2c_adapter *i2c_adap, u8 i2c_addr, struct dib7000p_config *cfg); 50 int (*set_wbd_ref)(struct dvb_frontend *demod, u16 value);
51extern struct i2c_adapter *dib7000p_get_i2c_master(struct dvb_frontend *, enum dibx000_i2c_interface, int); 51 int (*get_agc_values)(struct dvb_frontend *fe,
52extern int dib7000p_i2c_enumeration(struct i2c_adapter *i2c, int no_of_demods, u8 default_addr, struct dib7000p_config cfg[]);
53extern int dib7000p_set_gpio(struct dvb_frontend *, u8 num, u8 dir, u8 val);
54extern int dib7000p_set_wbd_ref(struct dvb_frontend *, u16 value);
55extern int dib7000pc_detection(struct i2c_adapter *i2c_adap);
56extern int dib7000p_pid_filter(struct dvb_frontend *, u8 id, u16 pid, u8 onoff);
57extern int dib7000p_pid_filter_ctrl(struct dvb_frontend *fe, u8 onoff);
58extern int dib7000p_update_pll(struct dvb_frontend *fe, struct dibx000_bandwidth_config *bw);
59extern u32 dib7000p_ctrl_timf(struct dvb_frontend *fe, u8 op, u32 timf);
60extern int dib7090_tuner_sleep(struct dvb_frontend *fe, int onoff);
61extern int dib7090_get_adc_power(struct dvb_frontend *fe);
62extern struct i2c_adapter *dib7090_get_i2c_tuner(struct dvb_frontend *fe);
63extern int dib7090_slave_reset(struct dvb_frontend *fe);
64extern int dib7000p_get_agc_values(struct dvb_frontend *fe,
65 u16 *agc_global, u16 *agc1, u16 *agc2, u16 *wbd); 52 u16 *agc_global, u16 *agc1, u16 *agc2, u16 *wbd);
66extern int dib7000p_set_agc1_min(struct dvb_frontend *fe, u16 v); 53 int (*set_agc1_min)(struct dvb_frontend *fe, u16 v);
67#else 54 int (*update_pll)(struct dvb_frontend *fe, struct dibx000_bandwidth_config *bw);
68static inline struct dvb_frontend *dib7000p_attach(struct i2c_adapter *i2c_adap, u8 i2c_addr, struct dib7000p_config *cfg) 55 int (*set_gpio)(struct dvb_frontend *demod, u8 num, u8 dir, u8 val);
69{ 56 u32 (*ctrl_timf)(struct dvb_frontend *fe, u8 op, u32 timf);
70 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__); 57 int (*dib7000pc_detection)(struct i2c_adapter *i2c_adap);
71 return NULL; 58 struct i2c_adapter *(*get_i2c_master)(struct dvb_frontend *demod, enum dibx000_i2c_interface intf, int gating);
72} 59 int (*pid_filter_ctrl)(struct dvb_frontend *fe, u8 onoff);
73 60 int (*pid_filter)(struct dvb_frontend *fe, u8 id, u16 pid, u8 onoff);
74static inline struct i2c_adapter *dib7000p_get_i2c_master(struct dvb_frontend *fe, enum dibx000_i2c_interface i, int x) 61 int (*i2c_enumeration)(struct i2c_adapter *i2c, int no_of_demods, u8 default_addr, struct dib7000p_config cfg[]);
75{ 62 struct i2c_adapter *(*get_i2c_tuner)(struct dvb_frontend *fe);
76 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__); 63 int (*tuner_sleep)(struct dvb_frontend *fe, int onoff);
77 return NULL; 64 int (*get_adc_power)(struct dvb_frontend *fe);
78} 65 int (*slave_reset)(struct dvb_frontend *fe);
79 66 struct dvb_frontend *(*init)(struct i2c_adapter *i2c_adap, u8 i2c_addr, struct dib7000p_config *cfg);
80static inline int dib7000p_i2c_enumeration(struct i2c_adapter *i2c, int no_of_demods, u8 default_addr, struct dib7000p_config cfg[]) 67};
81{
82 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
83 return -ENODEV;
84}
85
86static inline int dib7000p_set_gpio(struct dvb_frontend *fe, u8 num, u8 dir, u8 val)
87{
88 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
89 return -ENODEV;
90}
91
92static inline int dib7000p_set_wbd_ref(struct dvb_frontend *fe, u16 value)
93{
94 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
95 return -ENODEV;
96}
97
98static inline int dib7000pc_detection(struct i2c_adapter *i2c_adap)
99{
100 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
101 return -ENODEV;
102}
103
104static inline int dib7000p_pid_filter(struct dvb_frontend *fe, u8 id, u16 pid, u8 onoff)
105{
106 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
107 return -ENODEV;
108}
109
110static inline int dib7000p_pid_filter_ctrl(struct dvb_frontend *fe, uint8_t onoff)
111{
112 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
113 return -ENODEV;
114}
115
116static inline int dib7000p_update_pll(struct dvb_frontend *fe, struct dibx000_bandwidth_config *bw)
117{
118 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
119 return -ENODEV;
120}
121
122static inline u32 dib7000p_ctrl_timf(struct dvb_frontend *fe, u8 op, u32 timf)
123{
124 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
125 return 0;
126}
127
128static inline int dib7090_tuner_sleep(struct dvb_frontend *fe, int onoff)
129{
130 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
131 return -ENODEV;
132}
133
134static inline int dib7090_get_adc_power(struct dvb_frontend *fe)
135{
136 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
137 return -ENODEV;
138}
139 68
140static inline struct i2c_adapter *dib7090_get_i2c_tuner(struct dvb_frontend *fe) 69#if IS_ENABLED(CONFIG_DVB_DIB7000P)
70void *dib7000p_attach(struct dib7000p_ops *ops);
71#else
72static inline void *dib7000p_attach(struct dib7000p_ops *ops)
141{ 73{
142 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__); 74 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
143 return NULL; 75 return NULL;
144} 76}
145
146static inline int dib7090_slave_reset(struct dvb_frontend *fe)
147{
148 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
149 return -ENODEV;
150}
151
152static inline int dib7000p_get_agc_values(struct dvb_frontend *fe,
153 u16 *agc_global, u16 *agc1, u16 *agc2, u16 *wbd)
154{
155 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
156 return -ENODEV;
157}
158
159static inline int dib7000p_set_agc1_min(struct dvb_frontend *fe, u16 v)
160{
161 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
162 return -ENODEV;
163}
164#endif 77#endif
165 78
166#endif 79#endif
diff --git a/drivers/media/dvb-frontends/dib8000.c b/drivers/media/dvb-frontends/dib8000.c
index 1632d78a5479..61e31f2d2f71 100644
--- a/drivers/media/dvb-frontends/dib8000.c
+++ b/drivers/media/dvb-frontends/dib8000.c
@@ -115,7 +115,7 @@ struct dib8000_state {
115 u16 found_guard; 115 u16 found_guard;
116 u8 subchannel; 116 u8 subchannel;
117 u8 symbol_duration; 117 u8 symbol_duration;
118 u32 timeout; 118 unsigned long timeout;
119 u8 longest_intlv_layer; 119 u8 longest_intlv_layer;
120 u16 output_mode; 120 u16 output_mode;
121 121
@@ -588,8 +588,8 @@ static int dib8000_set_adc_state(struct dib8000_state *state, enum dibx000_adc_s
588 break; 588 break;
589 589
590 case DIBX000_ADC_OFF: // leave the VBG voltage on 590 case DIBX000_ADC_OFF: // leave the VBG voltage on
591 reg_907 |= (1 << 14) | (1 << 13) | (1 << 12); 591 reg_907 = (1 << 13) | (1 << 12);
592 reg_908 |= (1 << 5) | (1 << 4) | (1 << 3) | (1 << 2); 592 reg_908 = (1 << 6) | (1 << 5) | (1 << 4) | (1 << 3) | (1 << 1);
593 break; 593 break;
594 594
595 case DIBX000_VBG_ENABLE: 595 case DIBX000_VBG_ENABLE:
@@ -656,7 +656,7 @@ static int dib8000_sad_calib(struct dib8000_state *state)
656 return 0; 656 return 0;
657} 657}
658 658
659int dib8000_set_wbd_ref(struct dvb_frontend *fe, u16 value) 659static int dib8000_set_wbd_ref(struct dvb_frontend *fe, u16 value)
660{ 660{
661 struct dib8000_state *state = fe->demodulator_priv; 661 struct dib8000_state *state = fe->demodulator_priv;
662 if (value > 4095) 662 if (value > 4095)
@@ -664,7 +664,6 @@ int dib8000_set_wbd_ref(struct dvb_frontend *fe, u16 value)
664 state->wbd_ref = value; 664 state->wbd_ref = value;
665 return dib8000_write_word(state, 106, value); 665 return dib8000_write_word(state, 106, value);
666} 666}
667EXPORT_SYMBOL(dib8000_set_wbd_ref);
668 667
669static void dib8000_reset_pll_common(struct dib8000_state *state, const struct dibx000_bandwidth_config *bw) 668static void dib8000_reset_pll_common(struct dib8000_state *state, const struct dibx000_bandwidth_config *bw)
670{ 669{
@@ -739,7 +738,7 @@ static void dib8000_reset_pll(struct dib8000_state *state)
739 dib8000_reset_pll_common(state, pll); 738 dib8000_reset_pll_common(state, pll);
740} 739}
741 740
742int dib8000_update_pll(struct dvb_frontend *fe, 741static int dib8000_update_pll(struct dvb_frontend *fe,
743 struct dibx000_bandwidth_config *pll, u32 bw, u8 ratio) 742 struct dibx000_bandwidth_config *pll, u32 bw, u8 ratio)
744{ 743{
745 struct dib8000_state *state = fe->demodulator_priv; 744 struct dib8000_state *state = fe->demodulator_priv;
@@ -815,8 +814,6 @@ int dib8000_update_pll(struct dvb_frontend *fe,
815 814
816 return 0; 815 return 0;
817} 816}
818EXPORT_SYMBOL(dib8000_update_pll);
819
820 817
821static int dib8000_reset_gpio(struct dib8000_state *st) 818static int dib8000_reset_gpio(struct dib8000_state *st)
822{ 819{
@@ -849,13 +846,12 @@ static int dib8000_cfg_gpio(struct dib8000_state *st, u8 num, u8 dir, u8 val)
849 return 0; 846 return 0;
850} 847}
851 848
852int dib8000_set_gpio(struct dvb_frontend *fe, u8 num, u8 dir, u8 val) 849static int dib8000_set_gpio(struct dvb_frontend *fe, u8 num, u8 dir, u8 val)
853{ 850{
854 struct dib8000_state *state = fe->demodulator_priv; 851 struct dib8000_state *state = fe->demodulator_priv;
855 return dib8000_cfg_gpio(state, num, dir, val); 852 return dib8000_cfg_gpio(state, num, dir, val);
856} 853}
857 854
858EXPORT_SYMBOL(dib8000_set_gpio);
859static const u16 dib8000_defaults[] = { 855static const u16 dib8000_defaults[] = {
860 /* auto search configuration - lock0 by default waiting 856 /* auto search configuration - lock0 by default waiting
861 * for cpil_lock; lock1 cpil_lock; lock2 tmcc_sync_lock */ 857 * for cpil_lock; lock1 cpil_lock; lock2 tmcc_sync_lock */
@@ -1054,6 +1050,7 @@ static int dib8000_reset(struct dvb_frontend *fe)
1054 dib8000_write_word(state, 770, 0xffff); 1050 dib8000_write_word(state, 770, 0xffff);
1055 dib8000_write_word(state, 771, 0xffff); 1051 dib8000_write_word(state, 771, 0xffff);
1056 dib8000_write_word(state, 772, 0xfffc); 1052 dib8000_write_word(state, 772, 0xfffc);
1053 dib8000_write_word(state, 898, 0x000c); /* restart sad */
1057 if (state->revision == 0x8090) 1054 if (state->revision == 0x8090)
1058 dib8000_write_word(state, 1280, 0x0045); 1055 dib8000_write_word(state, 1280, 0x0045);
1059 else 1056 else
@@ -1228,20 +1225,19 @@ static int dib8000_set_agc_config(struct dib8000_state *state, u8 band)
1228 return 0; 1225 return 0;
1229} 1226}
1230 1227
1231void dib8000_pwm_agc_reset(struct dvb_frontend *fe) 1228static void dib8000_pwm_agc_reset(struct dvb_frontend *fe)
1232{ 1229{
1233 struct dib8000_state *state = fe->demodulator_priv; 1230 struct dib8000_state *state = fe->demodulator_priv;
1234 dib8000_set_adc_state(state, DIBX000_ADC_ON); 1231 dib8000_set_adc_state(state, DIBX000_ADC_ON);
1235 dib8000_set_agc_config(state, (unsigned char)(BAND_OF_FREQUENCY(fe->dtv_property_cache.frequency / 1000))); 1232 dib8000_set_agc_config(state, (unsigned char)(BAND_OF_FREQUENCY(fe->dtv_property_cache.frequency / 1000)));
1236} 1233}
1237EXPORT_SYMBOL(dib8000_pwm_agc_reset);
1238 1234
1239static int dib8000_agc_soft_split(struct dib8000_state *state) 1235static int dib8000_agc_soft_split(struct dib8000_state *state)
1240{ 1236{
1241 u16 agc, split_offset; 1237 u16 agc, split_offset;
1242 1238
1243 if (!state->current_agc || !state->current_agc->perform_agc_softsplit || state->current_agc->split.max == 0) 1239 if (!state->current_agc || !state->current_agc->perform_agc_softsplit || state->current_agc->split.max == 0)
1244 return FE_CALLBACK_TIME_NEVER; 1240 return 0;
1245 1241
1246 // n_agc_global 1242 // n_agc_global
1247 agc = dib8000_read_word(state, 390); 1243 agc = dib8000_read_word(state, 390);
@@ -1881,14 +1877,13 @@ static struct i2c_algorithm dib8096p_tuner_xfer_algo = {
1881 .functionality = dib8096p_i2c_func, 1877 .functionality = dib8096p_i2c_func,
1882}; 1878};
1883 1879
1884struct i2c_adapter *dib8096p_get_i2c_tuner(struct dvb_frontend *fe) 1880static struct i2c_adapter *dib8096p_get_i2c_tuner(struct dvb_frontend *fe)
1885{ 1881{
1886 struct dib8000_state *st = fe->demodulator_priv; 1882 struct dib8000_state *st = fe->demodulator_priv;
1887 return &st->dib8096p_tuner_adap; 1883 return &st->dib8096p_tuner_adap;
1888} 1884}
1889EXPORT_SYMBOL(dib8096p_get_i2c_tuner);
1890 1885
1891int dib8096p_tuner_sleep(struct dvb_frontend *fe, int onoff) 1886static int dib8096p_tuner_sleep(struct dvb_frontend *fe, int onoff)
1892{ 1887{
1893 struct dib8000_state *state = fe->demodulator_priv; 1888 struct dib8000_state *state = fe->demodulator_priv;
1894 u16 en_cur_state; 1889 u16 en_cur_state;
@@ -1912,14 +1907,13 @@ int dib8096p_tuner_sleep(struct dvb_frontend *fe, int onoff)
1912 1907
1913 return 0; 1908 return 0;
1914} 1909}
1915EXPORT_SYMBOL(dib8096p_tuner_sleep);
1916 1910
1917static const s32 lut_1000ln_mant[] = 1911static const s32 lut_1000ln_mant[] =
1918{ 1912{
1919 908, 7003, 7090, 7170, 7244, 7313, 7377, 7438, 7495, 7549, 7600 1913 908, 7003, 7090, 7170, 7244, 7313, 7377, 7438, 7495, 7549, 7600
1920}; 1914};
1921 1915
1922s32 dib8000_get_adc_power(struct dvb_frontend *fe, u8 mode) 1916static s32 dib8000_get_adc_power(struct dvb_frontend *fe, u8 mode)
1923{ 1917{
1924 struct dib8000_state *state = fe->demodulator_priv; 1918 struct dib8000_state *state = fe->demodulator_priv;
1925 u32 ix = 0, tmp_val = 0, exp = 0, mant = 0; 1919 u32 ix = 0, tmp_val = 0, exp = 0, mant = 0;
@@ -1937,9 +1931,8 @@ s32 dib8000_get_adc_power(struct dvb_frontend *fe, u8 mode)
1937 } 1931 }
1938 return val; 1932 return val;
1939} 1933}
1940EXPORT_SYMBOL(dib8000_get_adc_power);
1941 1934
1942int dib8090p_get_dc_power(struct dvb_frontend *fe, u8 IQ) 1935static int dib8090p_get_dc_power(struct dvb_frontend *fe, u8 IQ)
1943{ 1936{
1944 struct dib8000_state *state = fe->demodulator_priv; 1937 struct dib8000_state *state = fe->demodulator_priv;
1945 int val = 0; 1938 int val = 0;
@@ -1957,7 +1950,6 @@ int dib8090p_get_dc_power(struct dvb_frontend *fe, u8 IQ)
1957 1950
1958 return val; 1951 return val;
1959} 1952}
1960EXPORT_SYMBOL(dib8090p_get_dc_power);
1961 1953
1962static void dib8000_update_timf(struct dib8000_state *state) 1954static void dib8000_update_timf(struct dib8000_state *state)
1963{ 1955{
@@ -1968,7 +1960,7 @@ static void dib8000_update_timf(struct dib8000_state *state)
1968 dprintk("Updated timing frequency: %d (default: %d)", state->timf, state->timf_default); 1960 dprintk("Updated timing frequency: %d (default: %d)", state->timf, state->timf_default);
1969} 1961}
1970 1962
1971u32 dib8000_ctrl_timf(struct dvb_frontend *fe, uint8_t op, uint32_t timf) 1963static u32 dib8000_ctrl_timf(struct dvb_frontend *fe, uint8_t op, uint32_t timf)
1972{ 1964{
1973 struct dib8000_state *state = fe->demodulator_priv; 1965 struct dib8000_state *state = fe->demodulator_priv;
1974 1966
@@ -1986,21 +1978,11 @@ u32 dib8000_ctrl_timf(struct dvb_frontend *fe, uint8_t op, uint32_t timf)
1986 1978
1987 return state->timf; 1979 return state->timf;
1988} 1980}
1989EXPORT_SYMBOL(dib8000_ctrl_timf);
1990 1981
1991static const u16 adc_target_16dB[11] = { 1982static const u16 adc_target_16dB[11] = {
1992 (1 << 13) - 825 - 117, 1983 7250, 7238, 7264, 7309, 7338, 7382, 7427, 7456, 7500, 7544, 7574
1993 (1 << 13) - 837 - 117,
1994 (1 << 13) - 811 - 117,
1995 (1 << 13) - 766 - 117,
1996 (1 << 13) - 737 - 117,
1997 (1 << 13) - 693 - 117,
1998 (1 << 13) - 648 - 117,
1999 (1 << 13) - 619 - 117,
2000 (1 << 13) - 575 - 117,
2001 (1 << 13) - 531 - 117,
2002 (1 << 13) - 501 - 117
2003}; 1984};
1985
2004static const u8 permu_seg[] = { 6, 5, 7, 4, 8, 3, 9, 2, 10, 1, 11, 0, 12 }; 1986static const u8 permu_seg[] = { 6, 5, 7, 4, 8, 3, 9, 2, 10, 1, 11, 0, 12 };
2005 1987
2006static u16 dib8000_set_layer(struct dib8000_state *state, u8 layer_index, u16 max_constellation) 1988static u16 dib8000_set_layer(struct dib8000_state *state, u8 layer_index, u16 max_constellation)
@@ -2043,9 +2025,8 @@ static u16 dib8000_set_layer(struct dib8000_state *state, u8 layer_index, u16 ma
2043 break; 2025 break;
2044 } 2026 }
2045 2027
2046 if ((c->layer[layer_index].interleaving > 0) && ((c->layer[layer_index].interleaving <= 3) || (c->layer[layer_index].interleaving == 4 && c->isdbt_sb_mode == 1))) 2028 time_intlv = fls(c->layer[layer_index].interleaving);
2047 time_intlv = c->layer[layer_index].interleaving; 2029 if (time_intlv > 3 && !(time_intlv == 4 && c->isdbt_sb_mode == 1))
2048 else
2049 time_intlv = 0; 2030 time_intlv = 0;
2050 2031
2051 dib8000_write_word(state, 2 + layer_index, (constellation << 10) | ((c->layer[layer_index].segment_count & 0xf) << 6) | (cr << 3) | time_intlv); 2032 dib8000_write_word(state, 2 + layer_index, (constellation << 10) | ((c->layer[layer_index].segment_count & 0xf) << 6) | (cr << 3) | time_intlv);
@@ -2362,6 +2343,9 @@ static void dib8000_set_isdbt_common_channel(struct dib8000_state *state, u8 seq
2362 int init_prbs; 2343 int init_prbs;
2363 struct dtv_frontend_properties *c = &state->fe[0]->dtv_property_cache; 2344 struct dtv_frontend_properties *c = &state->fe[0]->dtv_property_cache;
2364 2345
2346 if (autosearching)
2347 c->isdbt_partial_reception = 1;
2348
2365 /* P_mode */ 2349 /* P_mode */
2366 dib8000_write_word(state, 10, (seq << 4)); 2350 dib8000_write_word(state, 10, (seq << 4));
2367 2351
@@ -2856,12 +2840,12 @@ static void dib8000_set_sync_wait(struct dib8000_state *state)
2856 dib8000_write_word(state, 273, (dib8000_read_word(state, 273) & 0x000f) | (sync_wait << 4)); 2840 dib8000_write_word(state, 273, (dib8000_read_word(state, 273) & 0x000f) | (sync_wait << 4));
2857} 2841}
2858 2842
2859static u32 dib8000_get_timeout(struct dib8000_state *state, u32 delay, enum timeout_mode mode) 2843static unsigned long dib8000_get_timeout(struct dib8000_state *state, u32 delay, enum timeout_mode mode)
2860{ 2844{
2861 if (mode == SYMBOL_DEPENDENT_ON) 2845 if (mode == SYMBOL_DEPENDENT_ON)
2862 return systime() + (delay * state->symbol_duration); 2846 delay *= state->symbol_duration;
2863 else 2847
2864 return systime() + delay; 2848 return jiffies + usecs_to_jiffies(delay * 100);
2865} 2849}
2866 2850
2867static s32 dib8000_get_status(struct dvb_frontend *fe) 2851static s32 dib8000_get_status(struct dvb_frontend *fe)
@@ -2870,21 +2854,19 @@ static s32 dib8000_get_status(struct dvb_frontend *fe)
2870 return state->status; 2854 return state->status;
2871} 2855}
2872 2856
2873enum frontend_tune_state dib8000_get_tune_state(struct dvb_frontend *fe) 2857static enum frontend_tune_state dib8000_get_tune_state(struct dvb_frontend *fe)
2874{ 2858{
2875 struct dib8000_state *state = fe->demodulator_priv; 2859 struct dib8000_state *state = fe->demodulator_priv;
2876 return state->tune_state; 2860 return state->tune_state;
2877} 2861}
2878EXPORT_SYMBOL(dib8000_get_tune_state);
2879 2862
2880int dib8000_set_tune_state(struct dvb_frontend *fe, enum frontend_tune_state tune_state) 2863static int dib8000_set_tune_state(struct dvb_frontend *fe, enum frontend_tune_state tune_state)
2881{ 2864{
2882 struct dib8000_state *state = fe->demodulator_priv; 2865 struct dib8000_state *state = fe->demodulator_priv;
2883 2866
2884 state->tune_state = tune_state; 2867 state->tune_state = tune_state;
2885 return 0; 2868 return 0;
2886} 2869}
2887EXPORT_SYMBOL(dib8000_set_tune_state);
2888 2870
2889static int dib8000_tune_restart_from_demod(struct dvb_frontend *fe) 2871static int dib8000_tune_restart_from_demod(struct dvb_frontend *fe)
2890{ 2872{
@@ -3015,8 +2997,8 @@ static int dib8000_tune(struct dvb_frontend *fe)
3015 u16 locks, deeper_interleaver = 0, i; 2997 u16 locks, deeper_interleaver = 0, i;
3016 int ret = 1; /* 1 symbol duration (in 100us unit) delay most of the time */ 2998 int ret = 1; /* 1 symbol duration (in 100us unit) delay most of the time */
3017 2999
3018 u32 *timeout = &state->timeout; 3000 unsigned long *timeout = &state->timeout;
3019 u32 now = systime(); 3001 unsigned long now = jiffies;
3020#ifdef DIB8000_AGC_FREEZE 3002#ifdef DIB8000_AGC_FREEZE
3021 u16 agc1, agc2; 3003 u16 agc1, agc2;
3022#endif 3004#endif
@@ -3026,318 +3008,327 @@ static int dib8000_tune(struct dvb_frontend *fe)
3026 3008
3027#if 0 3009#if 0
3028 if (*tune_state < CT_DEMOD_STOP) 3010 if (*tune_state < CT_DEMOD_STOP)
3029 dprintk("IN: context status = %d, TUNE_STATE %d autosearch step = %u systime = %u", state->channel_parameters_set, *tune_state, state->autosearch_state, now); 3011 dprintk("IN: context status = %d, TUNE_STATE %d autosearch step = %u jiffies = %lu",
3012 state->channel_parameters_set, *tune_state, state->autosearch_state, now);
3030#endif 3013#endif
3031 3014
3032 switch (*tune_state) { 3015 switch (*tune_state) {
3033 case CT_DEMOD_START: /* 30 */ 3016 case CT_DEMOD_START: /* 30 */
3034 dib8000_reset_stats(fe); 3017 dib8000_reset_stats(fe);
3035 3018
3036 if (state->revision == 0x8090) 3019 if (state->revision == 0x8090)
3037 dib8090p_init_sdram(state); 3020 dib8090p_init_sdram(state);
3038 state->status = FE_STATUS_TUNE_PENDING; 3021 state->status = FE_STATUS_TUNE_PENDING;
3039 state->channel_parameters_set = is_manual_mode(c); 3022 state->channel_parameters_set = is_manual_mode(c);
3040 3023
3041 dprintk("Tuning channel on %s search mode", 3024 dprintk("Tuning channel on %s search mode",
3042 state->channel_parameters_set ? "manual" : "auto"); 3025 state->channel_parameters_set ? "manual" : "auto");
3043 3026
3044 dib8000_viterbi_state(state, 0); /* force chan dec in restart */ 3027 dib8000_viterbi_state(state, 0); /* force chan dec in restart */
3045 3028
3046 /* Layer monitor */ 3029 /* Layer monitor */
3047 dib8000_write_word(state, 285, dib8000_read_word(state, 285) & 0x60); 3030 dib8000_write_word(state, 285, dib8000_read_word(state, 285) & 0x60);
3048 3031
3049 dib8000_set_frequency_offset(state); 3032 dib8000_set_frequency_offset(state);
3050 dib8000_set_bandwidth(fe, c->bandwidth_hz / 1000); 3033 dib8000_set_bandwidth(fe, c->bandwidth_hz / 1000);
3051 3034
3052 if (state->channel_parameters_set == 0) { /* The channel struct is unknown, search it ! */ 3035 if (state->channel_parameters_set == 0) { /* The channel struct is unknown, search it ! */
3053#ifdef DIB8000_AGC_FREEZE 3036#ifdef DIB8000_AGC_FREEZE
3054 if (state->revision != 0x8090) { 3037 if (state->revision != 0x8090) {
3055 state->agc1_max = dib8000_read_word(state, 108); 3038 state->agc1_max = dib8000_read_word(state, 108);
3056 state->agc1_min = dib8000_read_word(state, 109); 3039 state->agc1_min = dib8000_read_word(state, 109);
3057 state->agc2_max = dib8000_read_word(state, 110); 3040 state->agc2_max = dib8000_read_word(state, 110);
3058 state->agc2_min = dib8000_read_word(state, 111); 3041 state->agc2_min = dib8000_read_word(state, 111);
3059 agc1 = dib8000_read_word(state, 388); 3042 agc1 = dib8000_read_word(state, 388);
3060 agc2 = dib8000_read_word(state, 389); 3043 agc2 = dib8000_read_word(state, 389);
3061 dib8000_write_word(state, 108, agc1); 3044 dib8000_write_word(state, 108, agc1);
3062 dib8000_write_word(state, 109, agc1); 3045 dib8000_write_word(state, 109, agc1);
3063 dib8000_write_word(state, 110, agc2); 3046 dib8000_write_word(state, 110, agc2);
3064 dib8000_write_word(state, 111, agc2); 3047 dib8000_write_word(state, 111, agc2);
3065 }
3066#endif
3067 state->autosearch_state = AS_SEARCHING_FFT;
3068 state->found_nfft = TRANSMISSION_MODE_AUTO;
3069 state->found_guard = GUARD_INTERVAL_AUTO;
3070 *tune_state = CT_DEMOD_SEARCH_NEXT;
3071 } else { /* we already know the channel struct so TUNE only ! */
3072 state->autosearch_state = AS_DONE;
3073 *tune_state = CT_DEMOD_STEP_3;
3074 } 3048 }
3075 state->symbol_duration = dib8000_get_symbol_duration(state); 3049#endif
3076 break; 3050 state->autosearch_state = AS_SEARCHING_FFT;
3051 state->found_nfft = TRANSMISSION_MODE_AUTO;
3052 state->found_guard = GUARD_INTERVAL_AUTO;
3053 *tune_state = CT_DEMOD_SEARCH_NEXT;
3054 } else { /* we already know the channel struct so TUNE only ! */
3055 state->autosearch_state = AS_DONE;
3056 *tune_state = CT_DEMOD_STEP_3;
3057 }
3058 state->symbol_duration = dib8000_get_symbol_duration(state);
3059 break;
3077 3060
3078 case CT_DEMOD_SEARCH_NEXT: /* 51 */ 3061 case CT_DEMOD_SEARCH_NEXT: /* 51 */
3079 dib8000_autosearch_start(fe); 3062 dib8000_autosearch_start(fe);
3080 if (state->revision == 0x8090) 3063 if (state->revision == 0x8090)
3081 ret = 50; 3064 ret = 50;
3082 else 3065 else
3083 ret = 15; 3066 ret = 15;
3084 *tune_state = CT_DEMOD_STEP_1; 3067 *tune_state = CT_DEMOD_STEP_1;
3085 break; 3068 break;
3086 3069
3087 case CT_DEMOD_STEP_1: /* 31 */ 3070 case CT_DEMOD_STEP_1: /* 31 */
3088 switch (dib8000_autosearch_irq(fe)) { 3071 switch (dib8000_autosearch_irq(fe)) {
3089 case 1: /* fail */ 3072 case 1: /* fail */
3090 state->status = FE_STATUS_TUNE_FAILED; 3073 state->status = FE_STATUS_TUNE_FAILED;
3091 state->autosearch_state = AS_DONE; 3074 state->autosearch_state = AS_DONE;
3092 *tune_state = CT_DEMOD_STOP; /* else we are done here */ 3075 *tune_state = CT_DEMOD_STOP; /* else we are done here */
3093 break; 3076 break;
3094 case 2: /* Succes */ 3077 case 2: /* Succes */
3095 state->status = FE_STATUS_FFT_SUCCESS; /* signal to the upper layer, that there was a channel found and the parameters can be read */ 3078 state->status = FE_STATUS_FFT_SUCCESS; /* signal to the upper layer, that there was a channel found and the parameters can be read */
3096 *tune_state = CT_DEMOD_STEP_3; 3079 *tune_state = CT_DEMOD_STEP_3;
3097 if (state->autosearch_state == AS_SEARCHING_GUARD) 3080 if (state->autosearch_state == AS_SEARCHING_GUARD)
3098 *tune_state = CT_DEMOD_STEP_2; 3081 *tune_state = CT_DEMOD_STEP_2;
3099 else 3082 else
3100 state->autosearch_state = AS_DONE; 3083 state->autosearch_state = AS_DONE;
3101 break;
3102 case 3: /* Autosearch FFT max correlation endded */
3103 *tune_state = CT_DEMOD_STEP_2;
3104 break;
3105 }
3106 break; 3084 break;
3085 case 3: /* Autosearch FFT max correlation endded */
3086 *tune_state = CT_DEMOD_STEP_2;
3087 break;
3088 }
3089 break;
3107 3090
3108 case CT_DEMOD_STEP_2: 3091 case CT_DEMOD_STEP_2:
3109 switch (state->autosearch_state) { 3092 switch (state->autosearch_state) {
3110 case AS_SEARCHING_FFT: 3093 case AS_SEARCHING_FFT:
3111 /* searching for the correct FFT */ 3094 /* searching for the correct FFT */
3112 if (state->revision == 0x8090) { 3095 if (state->revision == 0x8090) {
3113 corm[2] = (dib8000_read_word(state, 596) << 16) | (dib8000_read_word(state, 597)); 3096 corm[2] = (dib8000_read_word(state, 596) << 16) | (dib8000_read_word(state, 597));
3114 corm[1] = (dib8000_read_word(state, 598) << 16) | (dib8000_read_word(state, 599)); 3097 corm[1] = (dib8000_read_word(state, 598) << 16) | (dib8000_read_word(state, 599));
3115 corm[0] = (dib8000_read_word(state, 600) << 16) | (dib8000_read_word(state, 601)); 3098 corm[0] = (dib8000_read_word(state, 600) << 16) | (dib8000_read_word(state, 601));
3116 } else { 3099 } else {
3117 corm[2] = (dib8000_read_word(state, 594) << 16) | (dib8000_read_word(state, 595)); 3100 corm[2] = (dib8000_read_word(state, 594) << 16) | (dib8000_read_word(state, 595));
3118 corm[1] = (dib8000_read_word(state, 596) << 16) | (dib8000_read_word(state, 597)); 3101 corm[1] = (dib8000_read_word(state, 596) << 16) | (dib8000_read_word(state, 597));
3119 corm[0] = (dib8000_read_word(state, 598) << 16) | (dib8000_read_word(state, 599)); 3102 corm[0] = (dib8000_read_word(state, 598) << 16) | (dib8000_read_word(state, 599));
3120 } 3103 }
3121 /* dprintk("corm fft: %u %u %u", corm[0], corm[1], corm[2]); */ 3104 /* dprintk("corm fft: %u %u %u", corm[0], corm[1], corm[2]); */
3122 3105
3123 max_value = 0; 3106 max_value = 0;
3124 for (find_index = 1 ; find_index < 3 ; find_index++) { 3107 for (find_index = 1 ; find_index < 3 ; find_index++) {
3125 if (corm[max_value] < corm[find_index]) 3108 if (corm[max_value] < corm[find_index])
3126 max_value = find_index ; 3109 max_value = find_index ;
3127 } 3110 }
3128 3111
3129 switch (max_value) { 3112 switch (max_value) {
3130 case 0: 3113 case 0:
3131 state->found_nfft = TRANSMISSION_MODE_2K; 3114 state->found_nfft = TRANSMISSION_MODE_2K;
3132 break; 3115 break;
3133 case 1: 3116 case 1:
3134 state->found_nfft = TRANSMISSION_MODE_4K; 3117 state->found_nfft = TRANSMISSION_MODE_4K;
3135 break; 3118 break;
3136 case 2: 3119 case 2:
3137 default:
3138 state->found_nfft = TRANSMISSION_MODE_8K;
3139 break;
3140 }
3141 /* dprintk("Autosearch FFT has found Mode %d", max_value + 1); */
3142
3143 *tune_state = CT_DEMOD_SEARCH_NEXT;
3144 state->autosearch_state = AS_SEARCHING_GUARD;
3145 if (state->revision == 0x8090)
3146 ret = 50;
3147 else
3148 ret = 10;
3149 break;
3150 case AS_SEARCHING_GUARD:
3151 /* searching for the correct guard interval */
3152 if (state->revision == 0x8090)
3153 state->found_guard = dib8000_read_word(state, 572) & 0x3;
3154 else
3155 state->found_guard = dib8000_read_word(state, 570) & 0x3;
3156 /* dprintk("guard interval found=%i", state->found_guard); */
3157
3158 *tune_state = CT_DEMOD_STEP_3;
3159 break;
3160 default: 3120 default:
3161 /* the demod should never be in this state */ 3121 state->found_nfft = TRANSMISSION_MODE_8K;
3162 state->status = FE_STATUS_TUNE_FAILED; 3122 break;
3163 state->autosearch_state = AS_DONE;
3164 *tune_state = CT_DEMOD_STOP; /* else we are done here */
3165 break;
3166 } 3123 }
3124 /* dprintk("Autosearch FFT has found Mode %d", max_value + 1); */
3125
3126 *tune_state = CT_DEMOD_SEARCH_NEXT;
3127 state->autosearch_state = AS_SEARCHING_GUARD;
3128 if (state->revision == 0x8090)
3129 ret = 50;
3130 else
3131 ret = 10;
3167 break; 3132 break;
3133 case AS_SEARCHING_GUARD:
3134 /* searching for the correct guard interval */
3135 if (state->revision == 0x8090)
3136 state->found_guard = dib8000_read_word(state, 572) & 0x3;
3137 else
3138 state->found_guard = dib8000_read_word(state, 570) & 0x3;
3139 /* dprintk("guard interval found=%i", state->found_guard); */
3168 3140
3169 case CT_DEMOD_STEP_3: /* 33 */ 3141 *tune_state = CT_DEMOD_STEP_3;
3170 state->symbol_duration = dib8000_get_symbol_duration(state);
3171 dib8000_set_isdbt_loop_params(state, LOOP_TUNE_1);
3172 dib8000_set_isdbt_common_channel(state, 0, 0);/* setting the known channel parameters here */
3173 *tune_state = CT_DEMOD_STEP_4;
3174 break; 3142 break;
3143 default:
3144 /* the demod should never be in this state */
3145 state->status = FE_STATUS_TUNE_FAILED;
3146 state->autosearch_state = AS_DONE;
3147 *tune_state = CT_DEMOD_STOP; /* else we are done here */
3148 break;
3149 }
3150 break;
3151
3152 case CT_DEMOD_STEP_3: /* 33 */
3153 dib8000_set_isdbt_loop_params(state, LOOP_TUNE_1);
3154 dib8000_set_isdbt_common_channel(state, 0, 0);/* setting the known channel parameters here */
3155 *tune_state = CT_DEMOD_STEP_4;
3156 break;
3175 3157
3176 case CT_DEMOD_STEP_4: /* (34) */ 3158 case CT_DEMOD_STEP_4: /* (34) */
3177 dib8000_demod_restart(state); 3159 dib8000_demod_restart(state);
3178 3160
3179 dib8000_set_sync_wait(state); 3161 dib8000_set_sync_wait(state);
3180 dib8000_set_diversity_in(state->fe[0], state->diversity_onoff); 3162 dib8000_set_diversity_in(state->fe[0], state->diversity_onoff);
3181 3163
3182 locks = (dib8000_read_word(state, 180) >> 6) & 0x3f; /* P_coff_winlen ? */ 3164 locks = (dib8000_read_word(state, 180) >> 6) & 0x3f; /* P_coff_winlen ? */
3183 /* coff should lock over P_coff_winlen ofdm symbols : give 3 times this length to lock */ 3165 /* coff should lock over P_coff_winlen ofdm symbols : give 3 times this length to lock */
3184 *timeout = dib8000_get_timeout(state, 2 * locks, SYMBOL_DEPENDENT_ON); 3166 *timeout = dib8000_get_timeout(state, 2 * locks, SYMBOL_DEPENDENT_ON);
3185 *tune_state = CT_DEMOD_STEP_5; 3167 *tune_state = CT_DEMOD_STEP_5;
3186 break; 3168 break;
3187 3169
3188 case CT_DEMOD_STEP_5: /* (35) */ 3170 case CT_DEMOD_STEP_5: /* (35) */
3189 locks = dib8000_read_lock(fe); 3171 locks = dib8000_read_lock(fe);
3190 if (locks & (0x3 << 11)) { /* coff-lock and off_cpil_lock achieved */ 3172 if (locks & (0x3 << 11)) { /* coff-lock and off_cpil_lock achieved */
3191 dib8000_update_timf(state); /* we achieved a coff_cpil_lock - it's time to update the timf */ 3173 dib8000_update_timf(state); /* we achieved a coff_cpil_lock - it's time to update the timf */
3192 if (!state->differential_constellation) { 3174 if (!state->differential_constellation) {
3193 /* 2 times lmod4_win_len + 10 symbols (pipe delay after coff + nb to compute a 1st correlation) */ 3175 /* 2 times lmod4_win_len + 10 symbols (pipe delay after coff + nb to compute a 1st correlation) */
3194 *timeout = dib8000_get_timeout(state, (20 * ((dib8000_read_word(state, 188)>>5)&0x1f)), SYMBOL_DEPENDENT_ON); 3176 *timeout = dib8000_get_timeout(state, (20 * ((dib8000_read_word(state, 188)>>5)&0x1f)), SYMBOL_DEPENDENT_ON);
3195 *tune_state = CT_DEMOD_STEP_7; 3177 *tune_state = CT_DEMOD_STEP_7;
3196 } else { 3178 } else {
3197 *tune_state = CT_DEMOD_STEP_8; 3179 *tune_state = CT_DEMOD_STEP_8;
3198 }
3199 } else if (now > *timeout) {
3200 *tune_state = CT_DEMOD_STEP_6; /* goto check for diversity input connection */
3201 } 3180 }
3202 break; 3181 } else if (time_after(now, *timeout)) {
3182 *tune_state = CT_DEMOD_STEP_6; /* goto check for diversity input connection */
3183 }
3184 break;
3203 3185
3204 case CT_DEMOD_STEP_6: /* (36) if there is an input (diversity) */ 3186 case CT_DEMOD_STEP_6: /* (36) if there is an input (diversity) */
3205 if ((state->fe[1] != NULL) && (state->output_mode != OUTMODE_DIVERSITY)) { 3187 if ((state->fe[1] != NULL) && (state->output_mode != OUTMODE_DIVERSITY)) {
3206 /* if there is a diversity fe in input and this fe is has not already failled : wait here until this this fe has succedeed or failled */ 3188 /* if there is a diversity fe in input and this fe is has not already failled : wait here until this this fe has succedeed or failled */
3207 if (dib8000_get_status(state->fe[1]) <= FE_STATUS_STD_SUCCESS) /* Something is locked on the input fe */ 3189 if (dib8000_get_status(state->fe[1]) <= FE_STATUS_STD_SUCCESS) /* Something is locked on the input fe */
3208 *tune_state = CT_DEMOD_STEP_8; /* go for mpeg */ 3190 *tune_state = CT_DEMOD_STEP_8; /* go for mpeg */
3209 else if (dib8000_get_status(state->fe[1]) >= FE_STATUS_TUNE_TIME_TOO_SHORT) { /* fe in input failled also, break the current one */ 3191 else if (dib8000_get_status(state->fe[1]) >= FE_STATUS_TUNE_TIME_TOO_SHORT) { /* fe in input failled also, break the current one */
3210 *tune_state = CT_DEMOD_STOP; /* else we are done here ; step 8 will close the loops and exit */ 3192 *tune_state = CT_DEMOD_STOP; /* else we are done here ; step 8 will close the loops and exit */
3211 dib8000_viterbi_state(state, 1); /* start viterbi chandec */
3212 dib8000_set_isdbt_loop_params(state, LOOP_TUNE_2);
3213 state->status = FE_STATUS_TUNE_FAILED;
3214 }
3215 } else {
3216 dib8000_viterbi_state(state, 1); /* start viterbi chandec */ 3193 dib8000_viterbi_state(state, 1); /* start viterbi chandec */
3217 dib8000_set_isdbt_loop_params(state, LOOP_TUNE_2); 3194 dib8000_set_isdbt_loop_params(state, LOOP_TUNE_2);
3218 *tune_state = CT_DEMOD_STOP; /* else we are done here ; step 8 will close the loops and exit */
3219 state->status = FE_STATUS_TUNE_FAILED; 3195 state->status = FE_STATUS_TUNE_FAILED;
3220 } 3196 }
3221 break; 3197 } else {
3198 dib8000_viterbi_state(state, 1); /* start viterbi chandec */
3199 dib8000_set_isdbt_loop_params(state, LOOP_TUNE_2);
3200 *tune_state = CT_DEMOD_STOP; /* else we are done here ; step 8 will close the loops and exit */
3201 state->status = FE_STATUS_TUNE_FAILED;
3202 }
3203 break;
3222 3204
3223 case CT_DEMOD_STEP_7: /* 37 */ 3205 case CT_DEMOD_STEP_7: /* 37 */
3224 locks = dib8000_read_lock(fe); 3206 locks = dib8000_read_lock(fe);
3225 if (locks & (1<<10)) { /* lmod4_lock */ 3207 if (locks & (1<<10)) { /* lmod4_lock */
3226 ret = 14; /* wait for 14 symbols */ 3208 ret = 14; /* wait for 14 symbols */
3227 *tune_state = CT_DEMOD_STEP_8; 3209 *tune_state = CT_DEMOD_STEP_8;
3228 } else if (now > *timeout) 3210 } else if (time_after(now, *timeout))
3229 *tune_state = CT_DEMOD_STEP_6; /* goto check for diversity input connection */ 3211 *tune_state = CT_DEMOD_STEP_6; /* goto check for diversity input connection */
3230 break; 3212 break;
3231 3213
3232 case CT_DEMOD_STEP_8: /* 38 */ 3214 case CT_DEMOD_STEP_8: /* 38 */
3233 dib8000_viterbi_state(state, 1); /* start viterbi chandec */ 3215 dib8000_viterbi_state(state, 1); /* start viterbi chandec */
3234 dib8000_set_isdbt_loop_params(state, LOOP_TUNE_2); 3216 dib8000_set_isdbt_loop_params(state, LOOP_TUNE_2);
3235 3217
3236 /* mpeg will never lock on this condition because init_prbs is not set : search for it !*/ 3218 /* mpeg will never lock on this condition because init_prbs is not set : search for it !*/
3237 if (c->isdbt_sb_mode 3219 if (c->isdbt_sb_mode
3238 && c->isdbt_sb_subchannel < 14 3220 && c->isdbt_sb_subchannel < 14
3239 && !state->differential_constellation) { 3221 && !state->differential_constellation) {
3240 state->subchannel = 0; 3222 state->subchannel = 0;
3241 *tune_state = CT_DEMOD_STEP_11; 3223 *tune_state = CT_DEMOD_STEP_11;
3242 } else { 3224 } else {
3243 *tune_state = CT_DEMOD_STEP_9; 3225 *tune_state = CT_DEMOD_STEP_9;
3244 state->status = FE_STATUS_LOCKED; 3226 state->status = FE_STATUS_LOCKED;
3245 } 3227 }
3246 break; 3228 break;
3247 3229
3248 case CT_DEMOD_STEP_9: /* 39 */ 3230 case CT_DEMOD_STEP_9: /* 39 */
3249 if ((state->revision == 0x8090) || ((dib8000_read_word(state, 1291) >> 9) & 0x1)) { /* fe capable of deinterleaving : esram */ 3231 if ((state->revision == 0x8090) || ((dib8000_read_word(state, 1291) >> 9) & 0x1)) { /* fe capable of deinterleaving : esram */
3250 /* defines timeout for mpeg lock depending on interleaver length of longest layer */ 3232 /* defines timeout for mpeg lock depending on interleaver length of longest layer */
3251 for (i = 0; i < 3; i++) { 3233 for (i = 0; i < 3; i++) {
3252 if (c->layer[i].interleaving >= deeper_interleaver) { 3234 if (c->layer[i].interleaving >= deeper_interleaver) {
3253 dprintk("layer%i: time interleaver = %d ", i, c->layer[i].interleaving); 3235 dprintk("layer%i: time interleaver = %d ", i, c->layer[i].interleaving);
3254 if (c->layer[i].segment_count > 0) { /* valid layer */ 3236 if (c->layer[i].segment_count > 0) { /* valid layer */
3255 deeper_interleaver = c->layer[0].interleaving; 3237 deeper_interleaver = c->layer[0].interleaving;
3256 state->longest_intlv_layer = i; 3238 state->longest_intlv_layer = i;
3257 }
3258 } 3239 }
3259 } 3240 }
3241 }
3260 3242
3261 if (deeper_interleaver == 0) 3243 if (deeper_interleaver == 0)
3262 locks = 2; /* locks is the tmp local variable name */ 3244 locks = 2; /* locks is the tmp local variable name */
3263 else if (deeper_interleaver == 3) 3245 else if (deeper_interleaver == 3)
3264 locks = 8; 3246 locks = 8;
3265 else 3247 else
3266 locks = 2 * deeper_interleaver; 3248 locks = 2 * deeper_interleaver;
3267 3249
3268 if (state->diversity_onoff != 0) /* because of diversity sync */ 3250 if (state->diversity_onoff != 0) /* because of diversity sync */
3269 locks *= 2; 3251 locks *= 2;
3270 3252
3271 *timeout = now + (2000 * locks); /* give the mpeg lock 800ms if sram is present */ 3253 *timeout = now + msecs_to_jiffies(200 * locks); /* give the mpeg lock 800ms if sram is present */
3272 dprintk("Deeper interleaver mode = %d on layer %d : timeout mult factor = %d => will use timeout = %d", deeper_interleaver, state->longest_intlv_layer, locks, *timeout); 3254 dprintk("Deeper interleaver mode = %d on layer %d : timeout mult factor = %d => will use timeout = %ld",
3255 deeper_interleaver, state->longest_intlv_layer, locks, *timeout);
3273 3256
3274 *tune_state = CT_DEMOD_STEP_10; 3257 *tune_state = CT_DEMOD_STEP_10;
3275 } else 3258 } else
3276 *tune_state = CT_DEMOD_STOP; 3259 *tune_state = CT_DEMOD_STOP;
3277 break; 3260 break;
3278 3261
3279 case CT_DEMOD_STEP_10: /* 40 */ 3262 case CT_DEMOD_STEP_10: /* 40 */
3280 locks = dib8000_read_lock(fe); 3263 locks = dib8000_read_lock(fe);
3281 if (locks&(1<<(7-state->longest_intlv_layer))) { /* mpeg lock : check the longest one */ 3264 if (locks&(1<<(7-state->longest_intlv_layer))) { /* mpeg lock : check the longest one */
3282 dprintk("Mpeg locks [ L0 : %d | L1 : %d | L2 : %d ]", (locks>>7)&0x1, (locks>>6)&0x1, (locks>>5)&0x1); 3265 dprintk("ISDB-T layer locks: Layer A %s, Layer B %s, Layer C %s",
3283 if (c->isdbt_sb_mode 3266 c->layer[0].segment_count ? (locks >> 7) & 0x1 ? "locked" : "NOT LOCKED" : "not enabled",
3284 && c->isdbt_sb_subchannel < 14 3267 c->layer[1].segment_count ? (locks >> 6) & 0x1 ? "locked" : "NOT LOCKED" : "not enabled",
3285 && !state->differential_constellation) 3268 c->layer[2].segment_count ? (locks >> 5) & 0x1 ? "locked" : "NOT LOCKED" : "not enabled");
3286 /* signal to the upper layer, that there was a channel found and the parameters can be read */ 3269 if (c->isdbt_sb_mode
3287 state->status = FE_STATUS_DEMOD_SUCCESS; 3270 && c->isdbt_sb_subchannel < 14
3288 else 3271 && !state->differential_constellation)
3272 /* signal to the upper layer, that there was a channel found and the parameters can be read */
3273 state->status = FE_STATUS_DEMOD_SUCCESS;
3274 else
3275 state->status = FE_STATUS_DATA_LOCKED;
3276 *tune_state = CT_DEMOD_STOP;
3277 } else if (time_after(now, *timeout)) {
3278 if (c->isdbt_sb_mode
3279 && c->isdbt_sb_subchannel < 14
3280 && !state->differential_constellation) { /* continue to try init prbs autosearch */
3281 state->subchannel += 3;
3282 *tune_state = CT_DEMOD_STEP_11;
3283 } else { /* we are done mpeg of the longest interleaver xas not locking but let's try if an other layer has locked in the same time */
3284 if (locks & (0x7 << 5)) {
3285 dprintk("Not all ISDB-T layers locked in %d ms: Layer A %s, Layer B %s, Layer C %s",
3286 jiffies_to_msecs(now - *timeout),
3287 c->layer[0].segment_count ? (locks >> 7) & 0x1 ? "locked" : "NOT LOCKED" : "not enabled",
3288 c->layer[1].segment_count ? (locks >> 6) & 0x1 ? "locked" : "NOT LOCKED" : "not enabled",
3289 c->layer[2].segment_count ? (locks >> 5) & 0x1 ? "locked" : "NOT LOCKED" : "not enabled");
3290
3289 state->status = FE_STATUS_DATA_LOCKED; 3291 state->status = FE_STATUS_DATA_LOCKED;
3292 } else
3293 state->status = FE_STATUS_TUNE_FAILED;
3290 *tune_state = CT_DEMOD_STOP; 3294 *tune_state = CT_DEMOD_STOP;
3291 } else if (now > *timeout) {
3292 if (c->isdbt_sb_mode
3293 && c->isdbt_sb_subchannel < 14
3294 && !state->differential_constellation) { /* continue to try init prbs autosearch */
3295 state->subchannel += 3;
3296 *tune_state = CT_DEMOD_STEP_11;
3297 } else { /* we are done mpeg of the longest interleaver xas not locking but let's try if an other layer has locked in the same time */
3298 if (locks & (0x7<<5)) {
3299 dprintk("Mpeg locks [ L0 : %d | L1 : %d | L2 : %d ]", (locks>>7)&0x1, (locks>>6)&0x1, (locks>>5)&0x1);
3300 state->status = FE_STATUS_DATA_LOCKED;
3301 } else
3302 state->status = FE_STATUS_TUNE_FAILED;
3303 *tune_state = CT_DEMOD_STOP;
3304 }
3305 } 3295 }
3306 break; 3296 }
3297 break;
3307 3298
3308 case CT_DEMOD_STEP_11: /* 41 : init prbs autosearch */ 3299 case CT_DEMOD_STEP_11: /* 41 : init prbs autosearch */
3309 if (state->subchannel <= 41) { 3300 if (state->subchannel <= 41) {
3310 dib8000_set_subchannel_prbs(state, dib8000_get_init_prbs(state, state->subchannel)); 3301 dib8000_set_subchannel_prbs(state, dib8000_get_init_prbs(state, state->subchannel));
3311 *tune_state = CT_DEMOD_STEP_9; 3302 *tune_state = CT_DEMOD_STEP_9;
3312 } else { 3303 } else {
3313 *tune_state = CT_DEMOD_STOP; 3304 *tune_state = CT_DEMOD_STOP;
3314 state->status = FE_STATUS_TUNE_FAILED; 3305 state->status = FE_STATUS_TUNE_FAILED;
3315 } 3306 }
3316 break; 3307 break;
3317 3308
3318 default: 3309 default:
3319 break; 3310 break;
3320 } 3311 }
3321 3312
3322 /* tuning is finished - cleanup the demod */ 3313 /* tuning is finished - cleanup the demod */
3323 switch (*tune_state) { 3314 switch (*tune_state) {
3324 case CT_DEMOD_STOP: /* (42) */ 3315 case CT_DEMOD_STOP: /* (42) */
3325#ifdef DIB8000_AGC_FREEZE 3316#ifdef DIB8000_AGC_FREEZE
3326 if ((state->revision != 0x8090) && (state->agc1_max != 0)) { 3317 if ((state->revision != 0x8090) && (state->agc1_max != 0)) {
3327 dib8000_write_word(state, 108, state->agc1_max); 3318 dib8000_write_word(state, 108, state->agc1_max);
3328 dib8000_write_word(state, 109, state->agc1_min); 3319 dib8000_write_word(state, 109, state->agc1_min);
3329 dib8000_write_word(state, 110, state->agc2_max); 3320 dib8000_write_word(state, 110, state->agc2_max);
3330 dib8000_write_word(state, 111, state->agc2_min); 3321 dib8000_write_word(state, 111, state->agc2_min);
3331 state->agc1_max = 0; 3322 state->agc1_max = 0;
3332 state->agc1_min = 0; 3323 state->agc1_min = 0;
3333 state->agc2_max = 0; 3324 state->agc2_max = 0;
3334 state->agc2_min = 0; 3325 state->agc2_min = 0;
3335 } 3326 }
3336#endif 3327#endif
3337 ret = FE_CALLBACK_TIME_NEVER; 3328 ret = 0;
3338 break; 3329 break;
3339 default: 3330 default:
3340 break; 3331 break;
3341 } 3332 }
3342 3333
3343 if ((ret > 0) && (*tune_state > CT_DEMOD_STEP_3)) 3334 if ((ret > 0) && (*tune_state > CT_DEMOD_STEP_3))
@@ -3408,7 +3399,7 @@ static int dib8000_get_frontend(struct dvb_frontend *fe)
3408 if (!(stat & FE_HAS_SYNC)) 3399 if (!(stat & FE_HAS_SYNC))
3409 return 0; 3400 return 0;
3410 3401
3411 dprintk("TMCC lock"); 3402 dprintk("dib8000_get_frontend: TMCC lock");
3412 for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) { 3403 for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
3413 state->fe[index_frontend]->ops.read_status(state->fe[index_frontend], &stat); 3404 state->fe[index_frontend]->ops.read_status(state->fe[index_frontend], &stat);
3414 if (stat&FE_HAS_SYNC) { 3405 if (stat&FE_HAS_SYNC) {
@@ -3444,91 +3435,117 @@ static int dib8000_get_frontend(struct dvb_frontend *fe)
3444 switch ((val & 0x30) >> 4) { 3435 switch ((val & 0x30) >> 4) {
3445 case 1: 3436 case 1:
3446 fe->dtv_property_cache.transmission_mode = TRANSMISSION_MODE_2K; 3437 fe->dtv_property_cache.transmission_mode = TRANSMISSION_MODE_2K;
3438 dprintk("dib8000_get_frontend: transmission mode 2K");
3439 break;
3440 case 2:
3441 fe->dtv_property_cache.transmission_mode = TRANSMISSION_MODE_4K;
3442 dprintk("dib8000_get_frontend: transmission mode 4K");
3447 break; 3443 break;
3448 case 3: 3444 case 3:
3449 default: 3445 default:
3450 fe->dtv_property_cache.transmission_mode = TRANSMISSION_MODE_8K; 3446 fe->dtv_property_cache.transmission_mode = TRANSMISSION_MODE_8K;
3447 dprintk("dib8000_get_frontend: transmission mode 8K");
3451 break; 3448 break;
3452 } 3449 }
3453 3450
3454 switch (val & 0x3) { 3451 switch (val & 0x3) {
3455 case 0: 3452 case 0:
3456 fe->dtv_property_cache.guard_interval = GUARD_INTERVAL_1_32; 3453 fe->dtv_property_cache.guard_interval = GUARD_INTERVAL_1_32;
3457 dprintk("dib8000_get_frontend GI = 1/32 "); 3454 dprintk("dib8000_get_frontend: Guard Interval = 1/32 ");
3458 break; 3455 break;
3459 case 1: 3456 case 1:
3460 fe->dtv_property_cache.guard_interval = GUARD_INTERVAL_1_16; 3457 fe->dtv_property_cache.guard_interval = GUARD_INTERVAL_1_16;
3461 dprintk("dib8000_get_frontend GI = 1/16 "); 3458 dprintk("dib8000_get_frontend: Guard Interval = 1/16 ");
3462 break; 3459 break;
3463 case 2: 3460 case 2:
3464 dprintk("dib8000_get_frontend GI = 1/8 "); 3461 dprintk("dib8000_get_frontend: Guard Interval = 1/8 ");
3465 fe->dtv_property_cache.guard_interval = GUARD_INTERVAL_1_8; 3462 fe->dtv_property_cache.guard_interval = GUARD_INTERVAL_1_8;
3466 break; 3463 break;
3467 case 3: 3464 case 3:
3468 dprintk("dib8000_get_frontend GI = 1/4 "); 3465 dprintk("dib8000_get_frontend: Guard Interval = 1/4 ");
3469 fe->dtv_property_cache.guard_interval = GUARD_INTERVAL_1_4; 3466 fe->dtv_property_cache.guard_interval = GUARD_INTERVAL_1_4;
3470 break; 3467 break;
3471 } 3468 }
3472 3469
3473 val = dib8000_read_word(state, 505); 3470 val = dib8000_read_word(state, 505);
3474 fe->dtv_property_cache.isdbt_partial_reception = val & 1; 3471 fe->dtv_property_cache.isdbt_partial_reception = val & 1;
3475 dprintk("dib8000_get_frontend : partial_reception = %d ", fe->dtv_property_cache.isdbt_partial_reception); 3472 dprintk("dib8000_get_frontend: partial_reception = %d ", fe->dtv_property_cache.isdbt_partial_reception);
3476 3473
3477 for (i = 0; i < 3; i++) { 3474 for (i = 0; i < 3; i++) {
3478 val = dib8000_read_word(state, 493 + i); 3475 int show;
3479 fe->dtv_property_cache.layer[i].segment_count = val & 0x0F; 3476
3480 dprintk("dib8000_get_frontend : Layer %d segments = %d ", i, fe->dtv_property_cache.layer[i].segment_count); 3477 val = dib8000_read_word(state, 493 + i) & 0x0f;
3478 fe->dtv_property_cache.layer[i].segment_count = val;
3479
3480 if (val == 0 || val > 13)
3481 show = 0;
3482 else
3483 show = 1;
3484
3485 if (show)
3486 dprintk("dib8000_get_frontend: Layer %d segments = %d ",
3487 i, fe->dtv_property_cache.layer[i].segment_count);
3481 3488
3482 val = dib8000_read_word(state, 499 + i) & 0x3; 3489 val = dib8000_read_word(state, 499 + i) & 0x3;
3483 /* Interleaving can be 0, 1, 2 or 4 */ 3490 /* Interleaving can be 0, 1, 2 or 4 */
3484 if (val == 3) 3491 if (val == 3)
3485 val = 4; 3492 val = 4;
3486 fe->dtv_property_cache.layer[i].interleaving = val; 3493 fe->dtv_property_cache.layer[i].interleaving = val;
3487 dprintk("dib8000_get_frontend : Layer %d time_intlv = %d ", 3494 if (show)
3488 i, fe->dtv_property_cache.layer[i].interleaving); 3495 dprintk("dib8000_get_frontend: Layer %d time_intlv = %d ",
3496 i, fe->dtv_property_cache.layer[i].interleaving);
3489 3497
3490 val = dib8000_read_word(state, 481 + i); 3498 val = dib8000_read_word(state, 481 + i);
3491 switch (val & 0x7) { 3499 switch (val & 0x7) {
3492 case 1: 3500 case 1:
3493 fe->dtv_property_cache.layer[i].fec = FEC_1_2; 3501 fe->dtv_property_cache.layer[i].fec = FEC_1_2;
3494 dprintk("dib8000_get_frontend : Layer %d Code Rate = 1/2 ", i); 3502 if (show)
3503 dprintk("dib8000_get_frontend: Layer %d Code Rate = 1/2 ", i);
3495 break; 3504 break;
3496 case 2: 3505 case 2:
3497 fe->dtv_property_cache.layer[i].fec = FEC_2_3; 3506 fe->dtv_property_cache.layer[i].fec = FEC_2_3;
3498 dprintk("dib8000_get_frontend : Layer %d Code Rate = 2/3 ", i); 3507 if (show)
3508 dprintk("dib8000_get_frontend: Layer %d Code Rate = 2/3 ", i);
3499 break; 3509 break;
3500 case 3: 3510 case 3:
3501 fe->dtv_property_cache.layer[i].fec = FEC_3_4; 3511 fe->dtv_property_cache.layer[i].fec = FEC_3_4;
3502 dprintk("dib8000_get_frontend : Layer %d Code Rate = 3/4 ", i); 3512 if (show)
3513 dprintk("dib8000_get_frontend: Layer %d Code Rate = 3/4 ", i);
3503 break; 3514 break;
3504 case 5: 3515 case 5:
3505 fe->dtv_property_cache.layer[i].fec = FEC_5_6; 3516 fe->dtv_property_cache.layer[i].fec = FEC_5_6;
3506 dprintk("dib8000_get_frontend : Layer %d Code Rate = 5/6 ", i); 3517 if (show)
3518 dprintk("dib8000_get_frontend: Layer %d Code Rate = 5/6 ", i);
3507 break; 3519 break;
3508 default: 3520 default:
3509 fe->dtv_property_cache.layer[i].fec = FEC_7_8; 3521 fe->dtv_property_cache.layer[i].fec = FEC_7_8;
3510 dprintk("dib8000_get_frontend : Layer %d Code Rate = 7/8 ", i); 3522 if (show)
3523 dprintk("dib8000_get_frontend: Layer %d Code Rate = 7/8 ", i);
3511 break; 3524 break;
3512 } 3525 }
3513 3526
3514 val = dib8000_read_word(state, 487 + i); 3527 val = dib8000_read_word(state, 487 + i);
3515 switch (val & 0x3) { 3528 switch (val & 0x3) {
3516 case 0: 3529 case 0:
3517 dprintk("dib8000_get_frontend : Layer %d DQPSK ", i);
3518 fe->dtv_property_cache.layer[i].modulation = DQPSK; 3530 fe->dtv_property_cache.layer[i].modulation = DQPSK;
3531 if (show)
3532 dprintk("dib8000_get_frontend: Layer %d DQPSK ", i);
3519 break; 3533 break;
3520 case 1: 3534 case 1:
3521 fe->dtv_property_cache.layer[i].modulation = QPSK; 3535 fe->dtv_property_cache.layer[i].modulation = QPSK;
3522 dprintk("dib8000_get_frontend : Layer %d QPSK ", i); 3536 if (show)
3537 dprintk("dib8000_get_frontend: Layer %d QPSK ", i);
3523 break; 3538 break;
3524 case 2: 3539 case 2:
3525 fe->dtv_property_cache.layer[i].modulation = QAM_16; 3540 fe->dtv_property_cache.layer[i].modulation = QAM_16;
3526 dprintk("dib8000_get_frontend : Layer %d QAM16 ", i); 3541 if (show)
3542 dprintk("dib8000_get_frontend: Layer %d QAM16 ", i);
3527 break; 3543 break;
3528 case 3: 3544 case 3:
3529 default: 3545 default:
3530 dprintk("dib8000_get_frontend : Layer %d QAM64 ", i);
3531 fe->dtv_property_cache.layer[i].modulation = QAM_64; 3546 fe->dtv_property_cache.layer[i].modulation = QAM_64;
3547 if (show)
3548 dprintk("dib8000_get_frontend: Layer %d QAM64 ", i);
3532 break; 3549 break;
3533 } 3550 }
3534 } 3551 }
@@ -3554,9 +3571,9 @@ static int dib8000_set_frontend(struct dvb_frontend *fe)
3554{ 3571{
3555 struct dib8000_state *state = fe->demodulator_priv; 3572 struct dib8000_state *state = fe->demodulator_priv;
3556 struct dtv_frontend_properties *c = &state->fe[0]->dtv_property_cache; 3573 struct dtv_frontend_properties *c = &state->fe[0]->dtv_property_cache;
3557 int l, i, active, time, time_slave = FE_CALLBACK_TIME_NEVER; 3574 int l, i, active, time, time_slave = 0;
3558 u8 exit_condition, index_frontend; 3575 u8 exit_condition, index_frontend;
3559 u32 delay, callback_time; 3576 unsigned long delay, callback_time;
3560 3577
3561 if (c->frequency == 0) { 3578 if (c->frequency == 0) {
3562 dprintk("dib8000: must at least specify frequency "); 3579 dprintk("dib8000: must at least specify frequency ");
@@ -3608,15 +3625,24 @@ static int dib8000_set_frontend(struct dvb_frontend *fe)
3608 time = dib8000_agc_startup(state->fe[0]); 3625 time = dib8000_agc_startup(state->fe[0]);
3609 for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) { 3626 for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
3610 time_slave = dib8000_agc_startup(state->fe[index_frontend]); 3627 time_slave = dib8000_agc_startup(state->fe[index_frontend]);
3611 if (time == FE_CALLBACK_TIME_NEVER) 3628 if (time == 0)
3612 time = time_slave; 3629 time = time_slave;
3613 else if ((time_slave != FE_CALLBACK_TIME_NEVER) && (time_slave > time)) 3630 else if ((time_slave != 0) && (time_slave > time))
3614 time = time_slave; 3631 time = time_slave;
3615 } 3632 }
3616 if (time != FE_CALLBACK_TIME_NEVER) 3633 if (time == 0)
3617 msleep(time / 10);
3618 else
3619 break; 3634 break;
3635
3636 /*
3637 * Despite dib8000_agc_startup returns time at a 0.1 ms range,
3638 * the actual sleep time depends on CONFIG_HZ. The worse case
3639 * is when CONFIG_HZ=100. In such case, the minimum granularity
3640 * is 10ms. On some real field tests, the tuner sometimes don't
3641 * lock when this timer is lower than 10ms. So, enforce a 10ms
3642 * granularity.
3643 */
3644 time = 10 * (time + 99)/100;
3645 usleep_range(time * 1000, (time + 1) * 1000);
3620 exit_condition = 1; 3646 exit_condition = 1;
3621 for (index_frontend = 0; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) { 3647 for (index_frontend = 0; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
3622 if (dib8000_get_tune_state(state->fe[index_frontend]) != CT_AGC_STOP) { 3648 if (dib8000_get_tune_state(state->fe[index_frontend]) != CT_AGC_STOP) {
@@ -3631,11 +3657,14 @@ static int dib8000_set_frontend(struct dvb_frontend *fe)
3631 3657
3632 active = 1; 3658 active = 1;
3633 do { 3659 do {
3634 callback_time = FE_CALLBACK_TIME_NEVER; 3660 callback_time = 0;
3635 for (index_frontend = 0; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) { 3661 for (index_frontend = 0; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
3636 delay = dib8000_tune(state->fe[index_frontend]); 3662 delay = dib8000_tune(state->fe[index_frontend]);
3637 if (delay != FE_CALLBACK_TIME_NEVER) 3663 if (delay != 0) {
3638 delay += systime(); 3664 delay = jiffies + usecs_to_jiffies(100 * delay);
3665 if (!callback_time || delay < callback_time)
3666 callback_time = delay;
3667 }
3639 3668
3640 /* we are in autosearch */ 3669 /* we are in autosearch */
3641 if (state->channel_parameters_set == 0) { /* searching */ 3670 if (state->channel_parameters_set == 0) { /* searching */
@@ -3646,6 +3675,7 @@ static int dib8000_set_frontend(struct dvb_frontend *fe)
3646 3675
3647 for (l = 0; (l < MAX_NUMBER_OF_FRONTENDS) && (state->fe[l] != NULL); l++) { 3676 for (l = 0; (l < MAX_NUMBER_OF_FRONTENDS) && (state->fe[l] != NULL); l++) {
3648 if (l != index_frontend) { /* and for all frontend except the successful one */ 3677 if (l != index_frontend) { /* and for all frontend except the successful one */
3678 dprintk("Restarting frontend %d\n", l);
3649 dib8000_tune_restart_from_demod(state->fe[l]); 3679 dib8000_tune_restart_from_demod(state->fe[l]);
3650 3680
3651 state->fe[l]->dtv_property_cache.isdbt_sb_mode = state->fe[index_frontend]->dtv_property_cache.isdbt_sb_mode; 3681 state->fe[l]->dtv_property_cache.isdbt_sb_mode = state->fe[index_frontend]->dtv_property_cache.isdbt_sb_mode;
@@ -3664,8 +3694,6 @@ static int dib8000_set_frontend(struct dvb_frontend *fe)
3664 } 3694 }
3665 } 3695 }
3666 } 3696 }
3667 if (delay < callback_time)
3668 callback_time = delay;
3669 } 3697 }
3670 /* tuning is done when the master frontend is done (failed or success) */ 3698 /* tuning is done when the master frontend is done (failed or success) */
3671 if (dib8000_get_status(state->fe[0]) == FE_STATUS_TUNE_FAILED || 3699 if (dib8000_get_status(state->fe[0]) == FE_STATUS_TUNE_FAILED ||
@@ -3681,12 +3709,12 @@ static int dib8000_set_frontend(struct dvb_frontend *fe)
3681 dprintk("tuning done with status %d", dib8000_get_status(state->fe[0])); 3709 dprintk("tuning done with status %d", dib8000_get_status(state->fe[0]));
3682 } 3710 }
3683 3711
3684 if ((active == 1) && (callback_time == FE_CALLBACK_TIME_NEVER)) { 3712 if ((active == 1) && (callback_time == 0)) {
3685 dprintk("strange callback time something went wrong"); 3713 dprintk("strange callback time something went wrong");
3686 active = 0; 3714 active = 0;
3687 } 3715 }
3688 3716
3689 while ((active == 1) && (systime() < callback_time)) 3717 while ((active == 1) && (time_before(jiffies, callback_time)))
3690 msleep(100); 3718 msleep(100);
3691 } while (active); 3719 } while (active);
3692 3720
@@ -4201,7 +4229,7 @@ static int dib8000_get_stats(struct dvb_frontend *fe, fe_status_t stat)
4201 return 0; 4229 return 0;
4202} 4230}
4203 4231
4204int dib8000_set_slave_frontend(struct dvb_frontend *fe, struct dvb_frontend *fe_slave) 4232static int dib8000_set_slave_frontend(struct dvb_frontend *fe, struct dvb_frontend *fe_slave)
4205{ 4233{
4206 struct dib8000_state *state = fe->demodulator_priv; 4234 struct dib8000_state *state = fe->demodulator_priv;
4207 u8 index_frontend = 1; 4235 u8 index_frontend = 1;
@@ -4217,9 +4245,8 @@ int dib8000_set_slave_frontend(struct dvb_frontend *fe, struct dvb_frontend *fe_
4217 dprintk("too many slave frontend"); 4245 dprintk("too many slave frontend");
4218 return -ENOMEM; 4246 return -ENOMEM;
4219} 4247}
4220EXPORT_SYMBOL(dib8000_set_slave_frontend);
4221 4248
4222int dib8000_remove_slave_frontend(struct dvb_frontend *fe) 4249static int dib8000_remove_slave_frontend(struct dvb_frontend *fe)
4223{ 4250{
4224 struct dib8000_state *state = fe->demodulator_priv; 4251 struct dib8000_state *state = fe->demodulator_priv;
4225 u8 index_frontend = 1; 4252 u8 index_frontend = 1;
@@ -4235,9 +4262,8 @@ int dib8000_remove_slave_frontend(struct dvb_frontend *fe)
4235 dprintk("no frontend to be removed"); 4262 dprintk("no frontend to be removed");
4236 return -ENODEV; 4263 return -ENODEV;
4237} 4264}
4238EXPORT_SYMBOL(dib8000_remove_slave_frontend);
4239 4265
4240struct dvb_frontend *dib8000_get_slave_frontend(struct dvb_frontend *fe, int slave_index) 4266static struct dvb_frontend *dib8000_get_slave_frontend(struct dvb_frontend *fe, int slave_index)
4241{ 4267{
4242 struct dib8000_state *state = fe->demodulator_priv; 4268 struct dib8000_state *state = fe->demodulator_priv;
4243 4269
@@ -4245,10 +4271,8 @@ struct dvb_frontend *dib8000_get_slave_frontend(struct dvb_frontend *fe, int sla
4245 return NULL; 4271 return NULL;
4246 return state->fe[slave_index]; 4272 return state->fe[slave_index];
4247} 4273}
4248EXPORT_SYMBOL(dib8000_get_slave_frontend);
4249 4274
4250 4275static int dib8000_i2c_enumeration(struct i2c_adapter *host, int no_of_demods,
4251int dib8000_i2c_enumeration(struct i2c_adapter *host, int no_of_demods,
4252 u8 default_addr, u8 first_addr, u8 is_dib8096p) 4276 u8 default_addr, u8 first_addr, u8 is_dib8096p)
4253{ 4277{
4254 int k = 0, ret = 0; 4278 int k = 0, ret = 0;
@@ -4325,7 +4349,6 @@ error_memory_read:
4325 return ret; 4349 return ret;
4326} 4350}
4327 4351
4328EXPORT_SYMBOL(dib8000_i2c_enumeration);
4329static int dib8000_fe_get_tune_settings(struct dvb_frontend *fe, struct dvb_frontend_tune_settings *tune) 4352static int dib8000_fe_get_tune_settings(struct dvb_frontend *fe, struct dvb_frontend_tune_settings *tune)
4330{ 4353{
4331 tune->min_delay_ms = 1000; 4354 tune->min_delay_ms = 1000;
@@ -4348,15 +4371,13 @@ static void dib8000_release(struct dvb_frontend *fe)
4348 kfree(st); 4371 kfree(st);
4349} 4372}
4350 4373
4351struct i2c_adapter *dib8000_get_i2c_master(struct dvb_frontend *fe, enum dibx000_i2c_interface intf, int gating) 4374static struct i2c_adapter *dib8000_get_i2c_master(struct dvb_frontend *fe, enum dibx000_i2c_interface intf, int gating)
4352{ 4375{
4353 struct dib8000_state *st = fe->demodulator_priv; 4376 struct dib8000_state *st = fe->demodulator_priv;
4354 return dibx000_get_i2c_adapter(&st->i2c_master, intf, gating); 4377 return dibx000_get_i2c_adapter(&st->i2c_master, intf, gating);
4355} 4378}
4356 4379
4357EXPORT_SYMBOL(dib8000_get_i2c_master); 4380static int dib8000_pid_filter_ctrl(struct dvb_frontend *fe, u8 onoff)
4358
4359int dib8000_pid_filter_ctrl(struct dvb_frontend *fe, u8 onoff)
4360{ 4381{
4361 struct dib8000_state *st = fe->demodulator_priv; 4382 struct dib8000_state *st = fe->demodulator_priv;
4362 u16 val = dib8000_read_word(st, 299) & 0xffef; 4383 u16 val = dib8000_read_word(st, 299) & 0xffef;
@@ -4365,15 +4386,13 @@ int dib8000_pid_filter_ctrl(struct dvb_frontend *fe, u8 onoff)
4365 dprintk("pid filter enabled %d", onoff); 4386 dprintk("pid filter enabled %d", onoff);
4366 return dib8000_write_word(st, 299, val); 4387 return dib8000_write_word(st, 299, val);
4367} 4388}
4368EXPORT_SYMBOL(dib8000_pid_filter_ctrl);
4369 4389
4370int dib8000_pid_filter(struct dvb_frontend *fe, u8 id, u16 pid, u8 onoff) 4390static int dib8000_pid_filter(struct dvb_frontend *fe, u8 id, u16 pid, u8 onoff)
4371{ 4391{
4372 struct dib8000_state *st = fe->demodulator_priv; 4392 struct dib8000_state *st = fe->demodulator_priv;
4373 dprintk("Index %x, PID %d, OnOff %d", id, pid, onoff); 4393 dprintk("Index %x, PID %d, OnOff %d", id, pid, onoff);
4374 return dib8000_write_word(st, 305 + id, onoff ? (1 << 13) | pid : 0); 4394 return dib8000_write_word(st, 305 + id, onoff ? (1 << 13) | pid : 0);
4375} 4395}
4376EXPORT_SYMBOL(dib8000_pid_filter);
4377 4396
4378static const struct dvb_frontend_ops dib8000_ops = { 4397static const struct dvb_frontend_ops dib8000_ops = {
4379 .delsys = { SYS_ISDBT }, 4398 .delsys = { SYS_ISDBT },
@@ -4405,12 +4424,12 @@ static const struct dvb_frontend_ops dib8000_ops = {
4405 .read_ucblocks = dib8000_read_unc_blocks, 4424 .read_ucblocks = dib8000_read_unc_blocks,
4406}; 4425};
4407 4426
4408struct dvb_frontend *dib8000_attach(struct i2c_adapter *i2c_adap, u8 i2c_addr, struct dib8000_config *cfg) 4427static struct dvb_frontend *dib8000_init(struct i2c_adapter *i2c_adap, u8 i2c_addr, struct dib8000_config *cfg)
4409{ 4428{
4410 struct dvb_frontend *fe; 4429 struct dvb_frontend *fe;
4411 struct dib8000_state *state; 4430 struct dib8000_state *state;
4412 4431
4413 dprintk("dib8000_attach"); 4432 dprintk("dib8000_init");
4414 4433
4415 state = kzalloc(sizeof(struct dib8000_state), GFP_KERNEL); 4434 state = kzalloc(sizeof(struct dib8000_state), GFP_KERNEL);
4416 if (state == NULL) 4435 if (state == NULL)
@@ -4467,6 +4486,33 @@ error:
4467 return NULL; 4486 return NULL;
4468} 4487}
4469 4488
4489void *dib8000_attach(struct dib8000_ops *ops)
4490{
4491 if (!ops)
4492 return NULL;
4493
4494 ops->pwm_agc_reset = dib8000_pwm_agc_reset;
4495 ops->get_dc_power = dib8090p_get_dc_power;
4496 ops->set_gpio = dib8000_set_gpio;
4497 ops->get_slave_frontend = dib8000_get_slave_frontend;
4498 ops->set_tune_state = dib8000_set_tune_state;
4499 ops->pid_filter_ctrl = dib8000_pid_filter_ctrl;
4500 ops->remove_slave_frontend = dib8000_remove_slave_frontend;
4501 ops->get_adc_power = dib8000_get_adc_power;
4502 ops->update_pll = dib8000_update_pll;
4503 ops->tuner_sleep = dib8096p_tuner_sleep;
4504 ops->get_tune_state = dib8000_get_tune_state;
4505 ops->get_i2c_tuner = dib8096p_get_i2c_tuner;
4506 ops->set_slave_frontend = dib8000_set_slave_frontend;
4507 ops->pid_filter = dib8000_pid_filter;
4508 ops->ctrl_timf = dib8000_ctrl_timf;
4509 ops->init = dib8000_init;
4510 ops->get_i2c_master = dib8000_get_i2c_master;
4511 ops->i2c_enumeration = dib8000_i2c_enumeration;
4512 ops->set_wbd_ref = dib8000_set_wbd_ref;
4513
4514 return ops;
4515}
4470EXPORT_SYMBOL(dib8000_attach); 4516EXPORT_SYMBOL(dib8000_attach);
4471 4517
4472MODULE_AUTHOR("Olivier Grenie <Olivier.Grenie@dibcom.fr, " "Patrick Boettcher <pboettcher@dibcom.fr>"); 4518MODULE_AUTHOR("Olivier Grenie <Olivier.Grenie@dibcom.fr, " "Patrick Boettcher <pboettcher@dibcom.fr>");
diff --git a/drivers/media/dvb-frontends/dib8000.h b/drivers/media/dvb-frontends/dib8000.h
index b8c11e52c512..84cc10383dcd 100644
--- a/drivers/media/dvb-frontends/dib8000.h
+++ b/drivers/media/dvb-frontends/dib8000.h
@@ -39,134 +39,34 @@ struct dib8000_config {
39 39
40#define DEFAULT_DIB8000_I2C_ADDRESS 18 40#define DEFAULT_DIB8000_I2C_ADDRESS 18
41 41
42#if IS_ENABLED(CONFIG_DVB_DIB8000) 42struct dib8000_ops {
43extern struct dvb_frontend *dib8000_attach(struct i2c_adapter *i2c_adap, u8 i2c_addr, struct dib8000_config *cfg); 43 int (*set_wbd_ref)(struct dvb_frontend *fe, u16 value);
44extern struct i2c_adapter *dib8000_get_i2c_master(struct dvb_frontend *, enum dibx000_i2c_interface, int); 44 int (*update_pll)(struct dvb_frontend *fe,
45 45 struct dibx000_bandwidth_config *pll, u32 bw, u8 ratio);
46extern int dib8000_i2c_enumeration(struct i2c_adapter *host, int no_of_demods, 46 int (*set_gpio)(struct dvb_frontend *fe, u8 num, u8 dir, u8 val);
47 void (*pwm_agc_reset)(struct dvb_frontend *fe);
48 struct i2c_adapter *(*get_i2c_tuner)(struct dvb_frontend *fe);
49 int (*tuner_sleep)(struct dvb_frontend *fe, int onoff);
50 s32 (*get_adc_power)(struct dvb_frontend *fe, u8 mode);
51 int (*get_dc_power)(struct dvb_frontend *fe, u8 IQ);
52 u32 (*ctrl_timf)(struct dvb_frontend *fe, uint8_t op, uint32_t timf);
53 enum frontend_tune_state (*get_tune_state)(struct dvb_frontend *fe);
54 int (*set_tune_state)(struct dvb_frontend *fe, enum frontend_tune_state tune_state);
55 int (*set_slave_frontend)(struct dvb_frontend *fe, struct dvb_frontend *fe_slave);
56 int (*remove_slave_frontend)(struct dvb_frontend *fe);
57 struct dvb_frontend *(*get_slave_frontend)(struct dvb_frontend *fe, int slave_index);
58 int (*i2c_enumeration)(struct i2c_adapter *host, int no_of_demods,
47 u8 default_addr, u8 first_addr, u8 is_dib8096p); 59 u8 default_addr, u8 first_addr, u8 is_dib8096p);
60 struct i2c_adapter *(*get_i2c_master)(struct dvb_frontend *fe, enum dibx000_i2c_interface intf, int gating);
61 int (*pid_filter_ctrl)(struct dvb_frontend *fe, u8 onoff);
62 int (*pid_filter)(struct dvb_frontend *fe, u8 id, u16 pid, u8 onoff);
63 struct dvb_frontend *(*init)(struct i2c_adapter *i2c_adap, u8 i2c_addr, struct dib8000_config *cfg);
64};
48 65
49extern int dib8000_set_gpio(struct dvb_frontend *, u8 num, u8 dir, u8 val); 66#if IS_ENABLED(CONFIG_DVB_DIB8000)
50extern int dib8000_set_wbd_ref(struct dvb_frontend *, u16 value); 67void *dib8000_attach(struct dib8000_ops *ops);
51extern int dib8000_pid_filter_ctrl(struct dvb_frontend *, u8 onoff);
52extern int dib8000_pid_filter(struct dvb_frontend *, u8 id, u16 pid, u8 onoff);
53extern int dib8000_set_tune_state(struct dvb_frontend *fe, enum frontend_tune_state tune_state);
54extern enum frontend_tune_state dib8000_get_tune_state(struct dvb_frontend *fe);
55extern void dib8000_pwm_agc_reset(struct dvb_frontend *fe);
56extern s32 dib8000_get_adc_power(struct dvb_frontend *fe, u8 mode);
57extern struct i2c_adapter *dib8096p_get_i2c_tuner(struct dvb_frontend *fe);
58extern int dib8096p_tuner_sleep(struct dvb_frontend *fe, int onoff);
59extern int dib8090p_get_dc_power(struct dvb_frontend *fe, u8 IQ);
60extern u32 dib8000_ctrl_timf(struct dvb_frontend *fe,
61 uint8_t op, uint32_t timf);
62extern int dib8000_update_pll(struct dvb_frontend *fe,
63 struct dibx000_bandwidth_config *pll, u32 bw, u8 ratio);
64extern int dib8000_set_slave_frontend(struct dvb_frontend *fe, struct dvb_frontend *fe_slave);
65extern int dib8000_remove_slave_frontend(struct dvb_frontend *fe);
66extern struct dvb_frontend *dib8000_get_slave_frontend(struct dvb_frontend *fe, int slave_index);
67#else 68#else
68static inline struct dvb_frontend *dib8000_attach(struct i2c_adapter *i2c_adap, u8 i2c_addr, struct dib8000_config *cfg) 69static inline int dib8000_attach(struct dib8000_ops *ops)
69{
70 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
71 return NULL;
72}
73
74static inline struct i2c_adapter *dib8000_get_i2c_master(struct dvb_frontend *fe, enum dibx000_i2c_interface i, int x)
75{
76 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
77 return NULL;
78}
79
80static inline int dib8000_i2c_enumeration(struct i2c_adapter *host,
81 int no_of_demods, u8 default_addr, u8 first_addr,
82 u8 is_dib8096p)
83{
84 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
85 return -ENODEV;
86}
87
88static inline int dib8000_set_gpio(struct dvb_frontend *fe, u8 num, u8 dir, u8 val)
89{
90 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
91 return -ENODEV;
92}
93
94static inline int dib8000_set_wbd_ref(struct dvb_frontend *fe, u16 value)
95{
96 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
97 return -ENODEV;
98}
99
100static inline int dib8000_pid_filter_ctrl(struct dvb_frontend *fe, u8 onoff)
101{
102 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
103 return -ENODEV;
104}
105
106static inline int dib8000_pid_filter(struct dvb_frontend *fe, u8 id, u16 pid, u8 onoff)
107{
108 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
109 return -ENODEV;
110}
111static inline int dib8000_set_tune_state(struct dvb_frontend *fe, enum frontend_tune_state tune_state)
112{
113 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
114 return -ENODEV;
115}
116static inline enum frontend_tune_state dib8000_get_tune_state(struct dvb_frontend *fe)
117{
118 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
119 return CT_SHUTDOWN;
120}
121static inline void dib8000_pwm_agc_reset(struct dvb_frontend *fe)
122{
123 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
124}
125static inline struct i2c_adapter *dib8096p_get_i2c_tuner(struct dvb_frontend *fe)
126{
127 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
128 return NULL;
129}
130static inline int dib8096p_tuner_sleep(struct dvb_frontend *fe, int onoff)
131{
132 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
133 return 0;
134}
135static inline s32 dib8000_get_adc_power(struct dvb_frontend *fe, u8 mode)
136{
137 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
138 return 0;
139}
140static inline int dib8090p_get_dc_power(struct dvb_frontend *fe, u8 IQ)
141{
142 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
143 return 0;
144}
145static inline u32 dib8000_ctrl_timf(struct dvb_frontend *fe,
146 uint8_t op, uint32_t timf)
147{
148 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
149 return 0;
150}
151static inline int dib8000_update_pll(struct dvb_frontend *fe,
152 struct dibx000_bandwidth_config *pll, u32 bw, u8 ratio)
153{
154 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
155 return -ENODEV;
156}
157static inline int dib8000_set_slave_frontend(struct dvb_frontend *fe, struct dvb_frontend *fe_slave)
158{
159 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
160 return -ENODEV;
161}
162
163int dib8000_remove_slave_frontend(struct dvb_frontend *fe)
164{
165 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
166 return -ENODEV;
167}
168
169static inline struct dvb_frontend *dib8000_get_slave_frontend(struct dvb_frontend *fe, int slave_index)
170{ 70{
171 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__); 71 printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
172 return NULL; 72 return NULL;
diff --git a/drivers/media/dvb-frontends/dib9000.c b/drivers/media/dvb-frontends/dib9000.c
index e540cfb13bac..f75dec443783 100644
--- a/drivers/media/dvb-frontends/dib9000.c
+++ b/drivers/media/dvb-frontends/dib9000.c
@@ -1040,13 +1040,18 @@ static int dib9000_risc_apb_access_write(struct dib9000_state *state, u32 addres
1040 if (address >= 1024 || !state->platform.risc.fw_is_running) 1040 if (address >= 1024 || !state->platform.risc.fw_is_running)
1041 return -EINVAL; 1041 return -EINVAL;
1042 1042
1043 if (len > 18)
1044 return -EINVAL;
1045
1043 /* dprintk( "APB access thru wr fw %d %x", address, attribute); */ 1046 /* dprintk( "APB access thru wr fw %d %x", address, attribute); */
1044 1047
1045 mb[0] = (unsigned short)address; 1048 mb[0] = (u16)address;
1046 for (i = 0; i < len && i < 20; i += 2) 1049 for (i = 0; i + 1 < len; i += 2)
1047 mb[1 + (i / 2)] = (b[i] << 8 | b[i + 1]); 1050 mb[1 + i / 2] = b[i] << 8 | b[i + 1];
1051 if (len & 1)
1052 mb[1 + len / 2] = b[len - 1] << 8;
1048 1053
1049 dib9000_mbx_send_attr(state, OUT_MSG_BRIDGE_APB_W, mb, 1 + len / 2, attribute); 1054 dib9000_mbx_send_attr(state, OUT_MSG_BRIDGE_APB_W, mb, (3 + len) / 2, attribute);
1050 return dib9000_mbx_get_message_attr(state, IN_MSG_END_BRIDGE_APB_RW, mb, &s, attribute) == 1 ? 0 : -EINVAL; 1055 return dib9000_mbx_get_message_attr(state, IN_MSG_END_BRIDGE_APB_RW, mb, &s, attribute) == 1 ? 0 : -EINVAL;
1051} 1056}
1052 1057
diff --git a/drivers/media/dvb-frontends/drx39xyj/drxj.c b/drivers/media/dvb-frontends/drx39xyj/drxj.c
index 9482954fd453..7ca7a21df183 100644
--- a/drivers/media/dvb-frontends/drx39xyj/drxj.c
+++ b/drivers/media/dvb-frontends/drx39xyj/drxj.c
@@ -2159,7 +2159,7 @@ int drxj_dap_atomic_read_write_block(struct i2c_device_addr *dev_addr,
2159 return 0; 2159 return 0;
2160 2160
2161rw_error: 2161rw_error:
2162 return -EIO; 2162 return rc;
2163 2163
2164} 2164}
2165 2165
@@ -2252,7 +2252,7 @@ static int hi_cfg_command(const struct drx_demod_instance *demod)
2252 return 0; 2252 return 0;
2253 2253
2254rw_error: 2254rw_error:
2255 return -EIO; 2255 return rc;
2256} 2256}
2257 2257
2258/** 2258/**
@@ -2363,7 +2363,7 @@ hi_command(struct i2c_device_addr *dev_addr, const struct drxj_hi_cmd *cmd, u16
2363 /* if ( powerdown_cmd == true ) */ 2363 /* if ( powerdown_cmd == true ) */
2364 return 0; 2364 return 0;
2365rw_error: 2365rw_error:
2366 return -EIO; 2366 return rc;
2367} 2367}
2368 2368
2369/** 2369/**
@@ -2434,7 +2434,7 @@ static int init_hi(const struct drx_demod_instance *demod)
2434 return 0; 2434 return 0;
2435 2435
2436rw_error: 2436rw_error:
2437 return -EIO; 2437 return rc;
2438} 2438}
2439 2439
2440/*============================================================================*/ 2440/*============================================================================*/
@@ -2650,7 +2650,7 @@ static int get_device_capabilities(struct drx_demod_instance *demod)
2650 2650
2651 return 0; 2651 return 0;
2652rw_error: 2652rw_error:
2653 return -EIO; 2653 return rc;
2654} 2654}
2655 2655
2656/** 2656/**
@@ -3338,7 +3338,7 @@ ctrl_set_cfg_mpeg_output(struct drx_demod_instance *demod, struct drx_cfg_mpeg_o
3338 3338
3339 return 0; 3339 return 0;
3340rw_error: 3340rw_error:
3341 return -EIO; 3341 return rc;
3342} 3342}
3343 3343
3344/*----------------------------------------------------------------------------*/ 3344/*----------------------------------------------------------------------------*/
@@ -3421,7 +3421,7 @@ static int set_mpegtei_handling(struct drx_demod_instance *demod)
3421 3421
3422 return 0; 3422 return 0;
3423rw_error: 3423rw_error:
3424 return -EIO; 3424 return rc;
3425} 3425}
3426 3426
3427/*----------------------------------------------------------------------------*/ 3427/*----------------------------------------------------------------------------*/
@@ -3464,7 +3464,7 @@ static int bit_reverse_mpeg_output(struct drx_demod_instance *demod)
3464 3464
3465 return 0; 3465 return 0;
3466rw_error: 3466rw_error:
3467 return -EIO; 3467 return rc;
3468} 3468}
3469 3469
3470/*----------------------------------------------------------------------------*/ 3470/*----------------------------------------------------------------------------*/
@@ -3508,7 +3508,7 @@ static int set_mpeg_start_width(struct drx_demod_instance *demod)
3508 3508
3509 return 0; 3509 return 0;
3510rw_error: 3510rw_error:
3511 return -EIO; 3511 return rc;
3512} 3512}
3513 3513
3514/*----------------------------------------------------------------------------*/ 3514/*----------------------------------------------------------------------------*/
@@ -3652,7 +3652,7 @@ static int ctrl_set_uio_cfg(struct drx_demod_instance *demod, struct drxuio_cfg
3652 3652
3653 return 0; 3653 return 0;
3654rw_error: 3654rw_error:
3655 return -EIO; 3655 return rc;
3656} 3656}
3657 3657
3658/** 3658/**
@@ -3854,7 +3854,7 @@ ctrl_uio_write(struct drx_demod_instance *demod, struct drxuio_data *uio_data)
3854 3854
3855 return 0; 3855 return 0;
3856rw_error: 3856rw_error:
3857 return -EIO; 3857 return rc;
3858} 3858}
3859 3859
3860/*---------------------------------------------------------------------------*/ 3860/*---------------------------------------------------------------------------*/
@@ -3969,7 +3969,7 @@ static int smart_ant_init(struct drx_demod_instance *demod)
3969 3969
3970 return 0; 3970 return 0;
3971rw_error: 3971rw_error:
3972 return -EIO; 3972 return rc;
3973} 3973}
3974 3974
3975static int scu_command(struct i2c_device_addr *dev_addr, struct drxjscu_cmd *cmd) 3975static int scu_command(struct i2c_device_addr *dev_addr, struct drxjscu_cmd *cmd)
@@ -4109,7 +4109,7 @@ static int scu_command(struct i2c_device_addr *dev_addr, struct drxjscu_cmd *cmd
4109 return 0; 4109 return 0;
4110 4110
4111rw_error: 4111rw_error:
4112 return -EIO; 4112 return rc;
4113} 4113}
4114 4114
4115/** 4115/**
@@ -4178,7 +4178,7 @@ int drxj_dap_scu_atomic_read_write_block(struct i2c_device_addr *dev_addr, u32 a
4178 return 0; 4178 return 0;
4179 4179
4180rw_error: 4180rw_error:
4181 return -EIO; 4181 return rc;
4182 4182
4183} 4183}
4184 4184
@@ -4290,7 +4290,7 @@ static int adc_sync_measurement(struct drx_demod_instance *demod, u16 *count)
4290 4290
4291 return 0; 4291 return 0;
4292rw_error: 4292rw_error:
4293 return -EIO; 4293 return rc;
4294} 4294}
4295 4295
4296/** 4296/**
@@ -4349,7 +4349,7 @@ static int adc_synchronization(struct drx_demod_instance *demod)
4349 4349
4350 return 0; 4350 return 0;
4351rw_error: 4351rw_error:
4352 return -EIO; 4352 return rc;
4353} 4353}
4354 4354
4355/*============================================================================*/ 4355/*============================================================================*/
@@ -4734,7 +4734,7 @@ static int init_agc(struct drx_demod_instance *demod)
4734 4734
4735 return 0; 4735 return 0;
4736rw_error: 4736rw_error:
4737 return -EIO; 4737 return rc;
4738} 4738}
4739 4739
4740/** 4740/**
@@ -4831,7 +4831,7 @@ set_frequency(struct drx_demod_instance *demod,
4831 4831
4832 return 0; 4832 return 0;
4833rw_error: 4833rw_error:
4834 return -EIO; 4834 return rc;
4835} 4835}
4836 4836
4837/** 4837/**
@@ -4879,7 +4879,7 @@ static int get_acc_pkt_err(struct drx_demod_instance *demod, u16 *packet_err)
4879 4879
4880 return 0; 4880 return 0;
4881rw_error: 4881rw_error:
4882 return -EIO; 4882 return rc;
4883} 4883}
4884#endif 4884#endif
4885 4885
@@ -5097,7 +5097,7 @@ set_agc_rf(struct drx_demod_instance *demod, struct drxj_cfg_agc *agc_settings,
5097 5097
5098 return 0; 5098 return 0;
5099rw_error: 5099rw_error:
5100 return -EIO; 5100 return rc;
5101} 5101}
5102 5102
5103/** 5103/**
@@ -5326,7 +5326,7 @@ set_agc_if(struct drx_demod_instance *demod, struct drxj_cfg_agc *agc_settings,
5326 5326
5327 return 0; 5327 return 0;
5328rw_error: 5328rw_error:
5329 return -EIO; 5329 return rc;
5330} 5330}
5331 5331
5332/** 5332/**
@@ -5362,7 +5362,7 @@ static int set_iqm_af(struct drx_demod_instance *demod, bool active)
5362 5362
5363 return 0; 5363 return 0;
5364rw_error: 5364rw_error:
5365 return -EIO; 5365 return rc;
5366} 5366}
5367 5367
5368/*============================================================================*/ 5368/*============================================================================*/
@@ -5470,7 +5470,7 @@ static int power_down_vsb(struct drx_demod_instance *demod, bool primary)
5470 5470
5471 return 0; 5471 return 0;
5472rw_error: 5472rw_error:
5473 return -EIO; 5473 return rc;
5474} 5474}
5475 5475
5476/** 5476/**
@@ -5686,7 +5686,7 @@ static int set_vsb_leak_n_gain(struct drx_demod_instance *demod)
5686 5686
5687 return 0; 5687 return 0;
5688rw_error: 5688rw_error:
5689 return -EIO; 5689 return rc;
5690} 5690}
5691 5691
5692/** 5692/**
@@ -6192,7 +6192,7 @@ static int set_vsb(struct drx_demod_instance *demod)
6192 6192
6193 return 0; 6193 return 0;
6194rw_error: 6194rw_error:
6195 return -EIO; 6195 return rc;
6196} 6196}
6197 6197
6198/** 6198/**
@@ -6231,7 +6231,7 @@ static int get_vsb_post_rs_pck_err(struct i2c_device_addr *dev_addr,
6231 6231
6232 return 0; 6232 return 0;
6233rw_error: 6233rw_error:
6234 return -EIO; 6234 return rc;
6235} 6235}
6236 6236
6237/** 6237/**
@@ -6276,7 +6276,7 @@ static int get_vs_bpost_viterbi_ber(struct i2c_device_addr *dev_addr,
6276 6276
6277 return 0; 6277 return 0;
6278rw_error: 6278rw_error:
6279 return -EIO; 6279 return rc;
6280} 6280}
6281 6281
6282/** 6282/**
@@ -6321,7 +6321,7 @@ static int get_vsbmer(struct i2c_device_addr *dev_addr, u16 *mer)
6321 6321
6322 return 0; 6322 return 0;
6323rw_error: 6323rw_error:
6324 return -EIO; 6324 return rc;
6325} 6325}
6326 6326
6327 6327
@@ -6434,7 +6434,7 @@ static int power_down_qam(struct drx_demod_instance *demod, bool primary)
6434 6434
6435 return 0; 6435 return 0;
6436rw_error: 6436rw_error:
6437 return -EIO; 6437 return rc;
6438} 6438}
6439 6439
6440/*============================================================================*/ 6440/*============================================================================*/
@@ -6646,7 +6646,7 @@ set_qam_measurement(struct drx_demod_instance *demod,
6646 6646
6647 return 0; 6647 return 0;
6648rw_error: 6648rw_error:
6649 return -EIO; 6649 return rc;
6650} 6650}
6651 6651
6652/*============================================================================*/ 6652/*============================================================================*/
@@ -6881,7 +6881,7 @@ static int set_qam16(struct drx_demod_instance *demod)
6881 6881
6882 return 0; 6882 return 0;
6883rw_error: 6883rw_error:
6884 return -EIO; 6884 return rc;
6885} 6885}
6886 6886
6887/*============================================================================*/ 6887/*============================================================================*/
@@ -7116,7 +7116,7 @@ static int set_qam32(struct drx_demod_instance *demod)
7116 7116
7117 return 0; 7117 return 0;
7118rw_error: 7118rw_error:
7119 return -EIO; 7119 return rc;
7120} 7120}
7121 7121
7122/*============================================================================*/ 7122/*============================================================================*/
@@ -7351,7 +7351,7 @@ static int set_qam64(struct drx_demod_instance *demod)
7351 7351
7352 return 0; 7352 return 0;
7353rw_error: 7353rw_error:
7354 return -EIO; 7354 return rc;
7355} 7355}
7356 7356
7357/*============================================================================*/ 7357/*============================================================================*/
@@ -7586,7 +7586,7 @@ static int set_qam128(struct drx_demod_instance *demod)
7586 7586
7587 return 0; 7587 return 0;
7588rw_error: 7588rw_error:
7589 return -EIO; 7589 return rc;
7590} 7590}
7591 7591
7592/*============================================================================*/ 7592/*============================================================================*/
@@ -7821,7 +7821,7 @@ static int set_qam256(struct drx_demod_instance *demod)
7821 7821
7822 return 0; 7822 return 0;
7823rw_error: 7823rw_error:
7824 return -EIO; 7824 return rc;
7825} 7825}
7826 7826
7827/*============================================================================*/ 7827/*============================================================================*/
@@ -8650,7 +8650,7 @@ set_qam(struct drx_demod_instance *demod,
8650 8650
8651 return 0; 8651 return 0;
8652rw_error: 8652rw_error:
8653 return -EIO; 8653 return rc;
8654} 8654}
8655 8655
8656/*============================================================================*/ 8656/*============================================================================*/
@@ -8831,7 +8831,7 @@ static int qam_flip_spec(struct drx_demod_instance *demod, struct drx_channel *c
8831 8831
8832 return 0; 8832 return 0;
8833rw_error: 8833rw_error:
8834 return -EIO; 8834 return rc;
8835 8835
8836} 8836}
8837 8837
@@ -8984,7 +8984,7 @@ qam64auto(struct drx_demod_instance *demod,
8984 8984
8985 return 0; 8985 return 0;
8986rw_error: 8986rw_error:
8987 return -EIO; 8987 return rc;
8988} 8988}
8989 8989
8990/** 8990/**
@@ -9068,7 +9068,7 @@ qam256auto(struct drx_demod_instance *demod,
9068 9068
9069 return 0; 9069 return 0;
9070rw_error: 9070rw_error:
9071 return -EIO; 9071 return rc;
9072} 9072}
9073 9073
9074/** 9074/**
@@ -9273,7 +9273,7 @@ rw_error:
9273 /* restore starting value */ 9273 /* restore starting value */
9274 if (auto_flag) 9274 if (auto_flag)
9275 channel->constellation = DRX_CONSTELLATION_AUTO; 9275 channel->constellation = DRX_CONSTELLATION_AUTO;
9276 return -EIO; 9276 return rc;
9277} 9277}
9278 9278
9279/*============================================================================*/ 9279/*============================================================================*/
@@ -9344,7 +9344,7 @@ get_qamrs_err_count(struct i2c_device_addr *dev_addr,
9344 9344
9345 return 0; 9345 return 0;
9346rw_error: 9346rw_error:
9347 return -EIO; 9347 return rc;
9348} 9348}
9349 9349
9350/*============================================================================*/ 9350/*============================================================================*/
@@ -9425,8 +9425,8 @@ static int get_sig_strength(struct drx_demod_instance *demod, u16 *sig_strength)
9425 *sig_strength = 0; 9425 *sig_strength = 0;
9426 9426
9427 return 0; 9427 return 0;
9428 rw_error: 9428rw_error:
9429 return -EIO; 9429 return rc;
9430} 9430}
9431 9431
9432/** 9432/**
@@ -9643,7 +9643,7 @@ rw_error:
9643 p->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 9643 p->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
9644 p->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 9644 p->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
9645 9645
9646 return -EIO; 9646 return rc;
9647} 9647}
9648 9648
9649#endif /* #ifndef DRXJ_VSB_ONLY */ 9649#endif /* #ifndef DRXJ_VSB_ONLY */
@@ -9810,7 +9810,7 @@ power_down_atv(struct drx_demod_instance *demod, enum drx_standard standard, boo
9810 9810
9811 return 0; 9811 return 0;
9812rw_error: 9812rw_error:
9813 return -EIO; 9813 return rc;
9814} 9814}
9815 9815
9816/*============================================================================*/ 9816/*============================================================================*/
@@ -9840,7 +9840,7 @@ static int power_down_aud(struct drx_demod_instance *demod)
9840 9840
9841 return 0; 9841 return 0;
9842rw_error: 9842rw_error:
9843 return -EIO; 9843 return rc;
9844} 9844}
9845 9845
9846/** 9846/**
@@ -9874,7 +9874,7 @@ static int set_orx_nsu_aox(struct drx_demod_instance *demod, bool active)
9874 9874
9875 return 0; 9875 return 0;
9876rw_error: 9876rw_error:
9877 return -EIO; 9877 return rc;
9878} 9878}
9879 9879
9880/** 9880/**
@@ -10398,7 +10398,7 @@ static int ctrl_set_oob(struct drx_demod_instance *demod, struct drxoob *oob_par
10398 10398
10399 return 0; 10399 return 0;
10400rw_error: 10400rw_error:
10401 return -EIO; 10401 return rc;
10402} 10402}
10403 10403
10404/*============================================================================*/ 10404/*============================================================================*/
@@ -10638,7 +10638,7 @@ ctrl_set_channel(struct drx_demod_instance *demod, struct drx_channel *channel)
10638 10638
10639 return 0; 10639 return 0;
10640rw_error: 10640rw_error:
10641 return -EIO; 10641 return rc;
10642} 10642}
10643 10643
10644/*============================================================================= 10644/*=============================================================================
@@ -10756,7 +10756,7 @@ ctrl_sig_quality(struct drx_demod_instance *demod,
10756 10756
10757 return 0; 10757 return 0;
10758rw_error: 10758rw_error:
10759 return -EIO; 10759 return rc;
10760} 10760}
10761 10761
10762/*============================================================================*/ 10762/*============================================================================*/
@@ -10844,7 +10844,7 @@ ctrl_lock_status(struct drx_demod_instance *demod, enum drx_lock_status *lock_st
10844 10844
10845 return 0; 10845 return 0;
10846rw_error: 10846rw_error:
10847 return -EIO; 10847 return rc;
10848} 10848}
10849 10849
10850/*============================================================================*/ 10850/*============================================================================*/
@@ -10941,7 +10941,7 @@ ctrl_set_standard(struct drx_demod_instance *demod, enum drx_standard *standard)
10941rw_error: 10941rw_error:
10942 /* Don't know what the standard is now ... try again */ 10942 /* Don't know what the standard is now ... try again */
10943 ext_attr->standard = DRX_STANDARD_UNKNOWN; 10943 ext_attr->standard = DRX_STANDARD_UNKNOWN;
10944 return -EIO; 10944 return rc;
10945} 10945}
10946 10946
10947/*============================================================================*/ 10947/*============================================================================*/
@@ -11222,7 +11222,7 @@ ctrl_set_cfg_pre_saw(struct drx_demod_instance *demod, struct drxj_cfg_pre_saw *
11222 11222
11223 return 0; 11223 return 0;
11224rw_error: 11224rw_error:
11225 return -EIO; 11225 return rc;
11226} 11226}
11227 11227
11228/*============================================================================*/ 11228/*============================================================================*/
@@ -11303,7 +11303,7 @@ ctrl_set_cfg_afe_gain(struct drx_demod_instance *demod, struct drxj_cfg_afe_gain
11303 11303
11304 return 0; 11304 return 0;
11305rw_error: 11305rw_error:
11306 return -EIO; 11306 return rc;
11307} 11307}
11308 11308
11309/*============================================================================*/ 11309/*============================================================================*/
@@ -11315,6 +11315,7 @@ rw_error:
11315static int drx_ctrl_u_code(struct drx_demod_instance *demod, 11315static int drx_ctrl_u_code(struct drx_demod_instance *demod,
11316 struct drxu_code_info *mc_info, 11316 struct drxu_code_info *mc_info,
11317 enum drxu_code_action action); 11317 enum drxu_code_action action);
11318static int drxj_set_lna_state(struct drx_demod_instance *demod, bool state);
11318 11319
11319/** 11320/**
11320* \fn drxj_open() 11321* \fn drxj_open()
@@ -11527,10 +11528,11 @@ static int drxj_open(struct drx_demod_instance *demod)
11527 ext_attr->aud_data = drxj_default_aud_data_g; 11528 ext_attr->aud_data = drxj_default_aud_data_g;
11528 11529
11529 demod->my_common_attr->is_opened = true; 11530 demod->my_common_attr->is_opened = true;
11531 drxj_set_lna_state(demod, false);
11530 return 0; 11532 return 0;
11531rw_error: 11533rw_error:
11532 common_attr->is_opened = false; 11534 common_attr->is_opened = false;
11533 return -EIO; 11535 return rc;
11534} 11536}
11535 11537
11536/*============================================================================*/ 11538/*============================================================================*/
@@ -11578,7 +11580,7 @@ static int drxj_close(struct drx_demod_instance *demod)
11578rw_error: 11580rw_error:
11579 DRX_ATTR_ISOPENED(demod) = false; 11581 DRX_ATTR_ISOPENED(demod) = false;
11580 11582
11581 return -EIO; 11583 return rc;
11582} 11584}
11583 11585
11584/* 11586/*
@@ -11890,6 +11892,33 @@ release:
11890 return rc; 11892 return rc;
11891} 11893}
11892 11894
11895/* caller is expeced to check if lna is supported before enabling */
11896static int drxj_set_lna_state(struct drx_demod_instance *demod, bool state)
11897{
11898 struct drxuio_cfg uio_cfg;
11899 struct drxuio_data uio_data;
11900 int result;
11901
11902 uio_cfg.uio = DRX_UIO1;
11903 uio_cfg.mode = DRX_UIO_MODE_READWRITE;
11904 /* Configure user-I/O #3: enable read/write */
11905 result = ctrl_set_uio_cfg(demod, &uio_cfg);
11906 if (result) {
11907 pr_err("Failed to setup LNA GPIO!\n");
11908 return result;
11909 }
11910
11911 uio_data.uio = DRX_UIO1;
11912 uio_data.value = state;
11913 result = ctrl_uio_write(demod, &uio_data);
11914 if (result != 0) {
11915 pr_err("Failed to %sable LNA!\n",
11916 state ? "en" : "dis");
11917 return result;
11918 }
11919 return 0;
11920}
11921
11893/* 11922/*
11894 * The Linux DVB Driver for Micronas DRX39xx family (drx3933j) 11923 * The Linux DVB Driver for Micronas DRX39xx family (drx3933j)
11895 * 11924 *
@@ -12040,7 +12069,6 @@ static int drx39xxj_set_frontend(struct dvb_frontend *fe)
12040 enum drx_standard standard = DRX_STANDARD_8VSB; 12069 enum drx_standard standard = DRX_STANDARD_8VSB;
12041 struct drx_channel channel; 12070 struct drx_channel channel;
12042 int result; 12071 int result;
12043 struct drxuio_data uio_data;
12044 static const struct drx_channel def_channel = { 12072 static const struct drx_channel def_channel = {
12045 /* frequency */ 0, 12073 /* frequency */ 0,
12046 /* bandwidth */ DRX_BANDWIDTH_6MHZ, 12074 /* bandwidth */ DRX_BANDWIDTH_6MHZ,
@@ -12125,13 +12153,7 @@ static int drx39xxj_set_frontend(struct dvb_frontend *fe)
12125 return -EINVAL; 12153 return -EINVAL;
12126 } 12154 }
12127 /* Just for giggles, let's shut off the LNA again.... */ 12155 /* Just for giggles, let's shut off the LNA again.... */
12128 uio_data.uio = DRX_UIO1; 12156 drxj_set_lna_state(demod, false);
12129 uio_data.value = false;
12130 result = ctrl_uio_write(demod, &uio_data);
12131 if (result != 0) {
12132 pr_err("Failed to disable LNA!\n");
12133 return 0;
12134 }
12135 12157
12136 /* After set_frontend, except for strength, stats aren't available */ 12158 /* After set_frontend, except for strength, stats aren't available */
12137 p->strength.stat[0].scale = FE_SCALE_RELATIVE; 12159 p->strength.stat[0].scale = FE_SCALE_RELATIVE;
@@ -12180,21 +12202,28 @@ static int drx39xxj_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
12180 12202
12181static int drx39xxj_init(struct dvb_frontend *fe) 12203static int drx39xxj_init(struct dvb_frontend *fe)
12182{ 12204{
12183 /* Bring the demod out of sleep */ 12205 struct drx39xxj_state *state = fe->demodulator_priv;
12184 drx39xxj_set_powerstate(fe, 1); 12206 struct drx_demod_instance *demod = state->demod;
12207 int rc = 0;
12185 12208
12186 return 0; 12209 if (fe->exit == DVB_FE_DEVICE_RESUME) {
12210 /* so drxj_open() does what it needs to do */
12211 demod->my_common_attr->is_opened = false;
12212 rc = drxj_open(demod);
12213 if (rc != 0)
12214 pr_err("drx39xxj_init(): DRX open failed rc=%d!\n", rc);
12215 } else
12216 drx39xxj_set_powerstate(fe, 1);
12217
12218 return rc;
12187} 12219}
12188 12220
12189static int drx39xxj_set_lna(struct dvb_frontend *fe) 12221static int drx39xxj_set_lna(struct dvb_frontend *fe)
12190{ 12222{
12191 int result;
12192 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 12223 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
12193 struct drx39xxj_state *state = fe->demodulator_priv; 12224 struct drx39xxj_state *state = fe->demodulator_priv;
12194 struct drx_demod_instance *demod = state->demod; 12225 struct drx_demod_instance *demod = state->demod;
12195 struct drxj_data *ext_attr = demod->my_ext_attr; 12226 struct drxj_data *ext_attr = demod->my_ext_attr;
12196 struct drxuio_cfg uio_cfg;
12197 struct drxuio_data uio_data;
12198 12227
12199 if (c->lna) { 12228 if (c->lna) {
12200 if (!ext_attr->has_lna) { 12229 if (!ext_attr->has_lna) {
@@ -12204,26 +12233,7 @@ static int drx39xxj_set_lna(struct dvb_frontend *fe)
12204 } 12233 }
12205 } 12234 }
12206 12235
12207 /* Turn off the LNA */ 12236 return drxj_set_lna_state(demod, c->lna);
12208 uio_cfg.uio = DRX_UIO1;
12209 uio_cfg.mode = DRX_UIO_MODE_READWRITE;
12210 /* Configure user-I/O #3: enable read/write */
12211 result = ctrl_set_uio_cfg(demod, &uio_cfg);
12212 if (result) {
12213 pr_err("Failed to setup LNA GPIO!\n");
12214 return result;
12215 }
12216
12217 uio_data.uio = DRX_UIO1;
12218 uio_data.value = c->lna;
12219 result = ctrl_uio_write(demod, &uio_data);
12220 if (result != 0) {
12221 pr_err("Failed to %sable LNA!\n",
12222 c->lna ? "en" : "dis");
12223 return result;
12224 }
12225
12226 return 0;
12227} 12237}
12228 12238
12229static int drx39xxj_get_tune_settings(struct dvb_frontend *fe, 12239static int drx39xxj_get_tune_settings(struct dvb_frontend *fe,
@@ -12238,7 +12248,9 @@ static void drx39xxj_release(struct dvb_frontend *fe)
12238 struct drx39xxj_state *state = fe->demodulator_priv; 12248 struct drx39xxj_state *state = fe->demodulator_priv;
12239 struct drx_demod_instance *demod = state->demod; 12249 struct drx_demod_instance *demod = state->demod;
12240 12250
12241 drxj_close(demod); 12251 /* if device is removed don't access it */
12252 if (fe->exit != DVB_FE_DEVICE_REMOVED)
12253 drxj_close(demod);
12242 12254
12243 kfree(demod->my_ext_attr); 12255 kfree(demod->my_ext_attr);
12244 kfree(demod->my_common_attr); 12256 kfree(demod->my_common_attr);
@@ -12259,8 +12271,6 @@ struct dvb_frontend *drx39xxj_attach(struct i2c_adapter *i2c)
12259 struct drxj_data *demod_ext_attr = NULL; 12271 struct drxj_data *demod_ext_attr = NULL;
12260 struct drx_demod_instance *demod = NULL; 12272 struct drx_demod_instance *demod = NULL;
12261 struct dtv_frontend_properties *p; 12273 struct dtv_frontend_properties *p;
12262 struct drxuio_cfg uio_cfg;
12263 struct drxuio_data uio_data;
12264 int result; 12274 int result;
12265 12275
12266 /* allocate memory for the internal state */ 12276 /* allocate memory for the internal state */
@@ -12272,22 +12282,20 @@ struct dvb_frontend *drx39xxj_attach(struct i2c_adapter *i2c)
12272 if (demod == NULL) 12282 if (demod == NULL)
12273 goto error; 12283 goto error;
12274 12284
12275 demod_addr = kmalloc(sizeof(struct i2c_device_addr), GFP_KERNEL); 12285 demod_addr = kmemdup(&drxj_default_addr_g,
12286 sizeof(struct i2c_device_addr), GFP_KERNEL);
12276 if (demod_addr == NULL) 12287 if (demod_addr == NULL)
12277 goto error; 12288 goto error;
12278 memcpy(demod_addr, &drxj_default_addr_g,
12279 sizeof(struct i2c_device_addr));
12280 12289
12281 demod_comm_attr = kmalloc(sizeof(struct drx_common_attr), GFP_KERNEL); 12290 demod_comm_attr = kmemdup(&drxj_default_comm_attr_g,
12291 sizeof(struct drx_common_attr), GFP_KERNEL);
12282 if (demod_comm_attr == NULL) 12292 if (demod_comm_attr == NULL)
12283 goto error; 12293 goto error;
12284 memcpy(demod_comm_attr, &drxj_default_comm_attr_g,
12285 sizeof(struct drx_common_attr));
12286 12294
12287 demod_ext_attr = kmalloc(sizeof(struct drxj_data), GFP_KERNEL); 12295 demod_ext_attr = kmemdup(&drxj_data_g, sizeof(struct drxj_data),
12296 GFP_KERNEL);
12288 if (demod_ext_attr == NULL) 12297 if (demod_ext_attr == NULL)
12289 goto error; 12298 goto error;
12290 memcpy(demod_ext_attr, &drxj_data_g, sizeof(struct drxj_data));
12291 12299
12292 /* setup the state */ 12300 /* setup the state */
12293 state->i2c = i2c; 12301 state->i2c = i2c;
@@ -12313,24 +12321,6 @@ struct dvb_frontend *drx39xxj_attach(struct i2c_adapter *i2c)
12313 goto error; 12321 goto error;
12314 } 12322 }
12315 12323
12316 /* Turn off the LNA */
12317 uio_cfg.uio = DRX_UIO1;
12318 uio_cfg.mode = DRX_UIO_MODE_READWRITE;
12319 /* Configure user-I/O #3: enable read/write */
12320 result = ctrl_set_uio_cfg(demod, &uio_cfg);
12321 if (result) {
12322 pr_err("Failed to setup LNA GPIO!\n");
12323 goto error;
12324 }
12325
12326 uio_data.uio = DRX_UIO1;
12327 uio_data.value = false;
12328 result = ctrl_uio_write(demod, &uio_data);
12329 if (result != 0) {
12330 pr_err("Failed to disable LNA!\n");
12331 goto error;
12332 }
12333
12334 /* create dvb_frontend */ 12324 /* create dvb_frontend */
12335 memcpy(&state->frontend.ops, &drx39xxj_ops, 12325 memcpy(&state->frontend.ops, &drx39xxj_ops,
12336 sizeof(struct dvb_frontend_ops)); 12326 sizeof(struct dvb_frontend_ops));
diff --git a/drivers/media/dvb-frontends/drxd.h b/drivers/media/dvb-frontends/drxd.h
index 5f1d6b5f1685..d998e4d5a7fc 100644
--- a/drivers/media/dvb-frontends/drxd.h
+++ b/drivers/media/dvb-frontends/drxd.h
@@ -69,5 +69,4 @@ struct dvb_frontend *drxd_attach(const struct drxd_config *config,
69} 69}
70#endif 70#endif
71 71
72extern int drxd_config_i2c(struct dvb_frontend *, int);
73#endif 72#endif
diff --git a/drivers/media/dvb-frontends/drxd_hard.c b/drivers/media/dvb-frontends/drxd_hard.c
index 5b87ece69414..ae2276db77bc 100644
--- a/drivers/media/dvb-frontends/drxd_hard.c
+++ b/drivers/media/dvb-frontends/drxd_hard.c
@@ -2840,7 +2840,7 @@ static int drxd_init(struct dvb_frontend *fe)
2840 return err; 2840 return err;
2841} 2841}
2842 2842
2843int drxd_config_i2c(struct dvb_frontend *fe, int onoff) 2843static int drxd_config_i2c(struct dvb_frontend *fe, int onoff)
2844{ 2844{
2845 struct drxd_state *state = fe->demodulator_priv; 2845 struct drxd_state *state = fe->demodulator_priv;
2846 2846
@@ -2849,7 +2849,6 @@ int drxd_config_i2c(struct dvb_frontend *fe, int onoff)
2849 2849
2850 return DRX_ConfigureI2CBridge(state, onoff); 2850 return DRX_ConfigureI2CBridge(state, onoff);
2851} 2851}
2852EXPORT_SYMBOL(drxd_config_i2c);
2853 2852
2854static int drxd_get_tune_settings(struct dvb_frontend *fe, 2853static int drxd_get_tune_settings(struct dvb_frontend *fe,
2855 struct dvb_frontend_tune_settings *sets) 2854 struct dvb_frontend_tune_settings *sets)
diff --git a/drivers/media/dvb-frontends/m88ds3103.c b/drivers/media/dvb-frontends/m88ds3103.c
index 2ef8ce13fb60..dfe0c2f7f1ef 100644
--- a/drivers/media/dvb-frontends/m88ds3103.c
+++ b/drivers/media/dvb-frontends/m88ds3103.c
@@ -879,7 +879,7 @@ static int m88ds3103_read_snr(struct dvb_frontend *fe, u16 *snr)
879 /* SNR(X) dB = 10 * ln(X) / ln(10) dB */ 879 /* SNR(X) dB = 10 * ln(X) / ln(10) dB */
880 tmp = DIV_ROUND_CLOSEST(tmp, 8 * M88DS3103_SNR_ITERATIONS); 880 tmp = DIV_ROUND_CLOSEST(tmp, 8 * M88DS3103_SNR_ITERATIONS);
881 if (tmp) 881 if (tmp)
882 *snr = 100ul * intlog2(tmp) / intlog2(10); 882 *snr = div_u64((u64) 100 * intlog2(tmp), intlog2(10));
883 else 883 else
884 *snr = 0; 884 *snr = 0;
885 break; 885 break;
@@ -908,7 +908,7 @@ static int m88ds3103_read_snr(struct dvb_frontend *fe, u16 *snr)
908 /* SNR(X) dB = 10 * log10(X) dB */ 908 /* SNR(X) dB = 10 * log10(X) dB */
909 if (signal > noise) { 909 if (signal > noise) {
910 tmp = signal / noise; 910 tmp = signal / noise;
911 *snr = 100ul * intlog10(tmp) / (1 << 24); 911 *snr = div_u64((u64) 100 * intlog10(tmp), (1 << 24));
912 } else { 912 } else {
913 *snr = 0; 913 *snr = 0;
914 } 914 }
@@ -926,6 +926,86 @@ err:
926 return ret; 926 return ret;
927} 927}
928 928
929static int m88ds3103_read_ber(struct dvb_frontend *fe, u32 *ber)
930{
931 struct m88ds3103_priv *priv = fe->demodulator_priv;
932 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
933 int ret;
934 unsigned int utmp;
935 u8 buf[3], u8tmp;
936 dev_dbg(&priv->i2c->dev, "%s:\n", __func__);
937
938 switch (c->delivery_system) {
939 case SYS_DVBS:
940 ret = m88ds3103_wr_reg(priv, 0xf9, 0x04);
941 if (ret)
942 goto err;
943
944 ret = m88ds3103_rd_reg(priv, 0xf8, &u8tmp);
945 if (ret)
946 goto err;
947
948 if (!(u8tmp & 0x10)) {
949 u8tmp |= 0x10;
950
951 ret = m88ds3103_rd_regs(priv, 0xf6, buf, 2);
952 if (ret)
953 goto err;
954
955 priv->ber = (buf[1] << 8) | (buf[0] << 0);
956
957 /* restart counters */
958 ret = m88ds3103_wr_reg(priv, 0xf8, u8tmp);
959 if (ret)
960 goto err;
961 }
962 break;
963 case SYS_DVBS2:
964 ret = m88ds3103_rd_regs(priv, 0xd5, buf, 3);
965 if (ret)
966 goto err;
967
968 utmp = (buf[2] << 16) | (buf[1] << 8) | (buf[0] << 0);
969
970 if (utmp > 3000) {
971 ret = m88ds3103_rd_regs(priv, 0xf7, buf, 2);
972 if (ret)
973 goto err;
974
975 priv->ber = (buf[1] << 8) | (buf[0] << 0);
976
977 /* restart counters */
978 ret = m88ds3103_wr_reg(priv, 0xd1, 0x01);
979 if (ret)
980 goto err;
981
982 ret = m88ds3103_wr_reg(priv, 0xf9, 0x01);
983 if (ret)
984 goto err;
985
986 ret = m88ds3103_wr_reg(priv, 0xf9, 0x00);
987 if (ret)
988 goto err;
989
990 ret = m88ds3103_wr_reg(priv, 0xd1, 0x00);
991 if (ret)
992 goto err;
993 }
994 break;
995 default:
996 dev_dbg(&priv->i2c->dev, "%s: invalid delivery_system\n",
997 __func__);
998 ret = -EINVAL;
999 goto err;
1000 }
1001
1002 *ber = priv->ber;
1003
1004 return 0;
1005err:
1006 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
1007 return ret;
1008}
929 1009
930static int m88ds3103_set_tone(struct dvb_frontend *fe, 1010static int m88ds3103_set_tone(struct dvb_frontend *fe,
931 fe_sec_tone_mode_t fe_sec_tone_mode) 1011 fe_sec_tone_mode_t fe_sec_tone_mode)
@@ -1284,6 +1364,7 @@ static struct dvb_frontend_ops m88ds3103_ops = {
1284 1364
1285 .read_status = m88ds3103_read_status, 1365 .read_status = m88ds3103_read_status,
1286 .read_snr = m88ds3103_read_snr, 1366 .read_snr = m88ds3103_read_snr,
1367 .read_ber = m88ds3103_read_ber,
1287 1368
1288 .diseqc_send_master_cmd = m88ds3103_diseqc_send_master_cmd, 1369 .diseqc_send_master_cmd = m88ds3103_diseqc_send_master_cmd,
1289 .diseqc_send_burst = m88ds3103_diseqc_send_burst, 1370 .diseqc_send_burst = m88ds3103_diseqc_send_burst,
diff --git a/drivers/media/dvb-frontends/m88ds3103_priv.h b/drivers/media/dvb-frontends/m88ds3103_priv.h
index 84c3c06df622..9169fdd143cf 100644
--- a/drivers/media/dvb-frontends/m88ds3103_priv.h
+++ b/drivers/media/dvb-frontends/m88ds3103_priv.h
@@ -22,6 +22,7 @@
22#include "dvb_math.h" 22#include "dvb_math.h"
23#include <linux/firmware.h> 23#include <linux/firmware.h>
24#include <linux/i2c-mux.h> 24#include <linux/i2c-mux.h>
25#include <linux/math64.h>
25 26
26#define M88DS3103_FIRMWARE "dvb-demod-m88ds3103.fw" 27#define M88DS3103_FIRMWARE "dvb-demod-m88ds3103.fw"
27#define M88DS3103_MCLK_KHZ 96000 28#define M88DS3103_MCLK_KHZ 96000
@@ -34,6 +35,7 @@ struct m88ds3103_priv {
34 struct dvb_frontend fe; 35 struct dvb_frontend fe;
35 fe_delivery_system_t delivery_system; 36 fe_delivery_system_t delivery_system;
36 fe_status_t fe_status; 37 fe_status_t fe_status;
38 u32 ber;
37 bool warm; /* FW running */ 39 bool warm; /* FW running */
38 struct i2c_adapter *i2c_adapter; 40 struct i2c_adapter *i2c_adapter;
39}; 41};
diff --git a/drivers/media/dvb-frontends/mb86a20s.c b/drivers/media/dvb-frontends/mb86a20s.c
index 2f458bb188c7..b931179c70a4 100644
--- a/drivers/media/dvb-frontends/mb86a20s.c
+++ b/drivers/media/dvb-frontends/mb86a20s.c
@@ -459,6 +459,9 @@ static int mb86a20s_get_interleaving(struct mb86a20s_state *state,
459 unsigned layer) 459 unsigned layer)
460{ 460{
461 int rc; 461 int rc;
462 int interleaving[] = {
463 0, 1, 2, 4, 8
464 };
462 465
463 static unsigned char reg[] = { 466 static unsigned char reg[] = {
464 [0] = 0x88, /* Layer A */ 467 [0] = 0x88, /* Layer A */
@@ -475,20 +478,7 @@ static int mb86a20s_get_interleaving(struct mb86a20s_state *state,
475 if (rc < 0) 478 if (rc < 0)
476 return rc; 479 return rc;
477 480
478 switch ((rc >> 4) & 0x07) { 481 return interleaving[(rc >> 4) & 0x07];
479 case 1:
480 return GUARD_INTERVAL_1_4;
481 case 2:
482 return GUARD_INTERVAL_1_8;
483 case 3:
484 return GUARD_INTERVAL_1_16;
485 case 4:
486 return GUARD_INTERVAL_1_32;
487
488 default:
489 case 0:
490 return GUARD_INTERVAL_AUTO;
491 }
492} 482}
493 483
494static int mb86a20s_get_segment_count(struct mb86a20s_state *state, 484static int mb86a20s_get_segment_count(struct mb86a20s_state *state,
@@ -566,7 +556,7 @@ static u32 isdbt_rate[3][5][4] = {
566 556
567static void mb86a20s_layer_bitrate(struct dvb_frontend *fe, u32 layer, 557static void mb86a20s_layer_bitrate(struct dvb_frontend *fe, u32 layer,
568 u32 modulation, u32 forward_error_correction, 558 u32 modulation, u32 forward_error_correction,
569 u32 interleaving, 559 u32 guard_interval,
570 u32 segment) 560 u32 segment)
571{ 561{
572 struct mb86a20s_state *state = fe->demodulator_priv; 562 struct mb86a20s_state *state = fe->demodulator_priv;
@@ -574,7 +564,7 @@ static void mb86a20s_layer_bitrate(struct dvb_frontend *fe, u32 layer,
574 int mod, fec, guard; 564 int mod, fec, guard;
575 565
576 /* 566 /*
577 * If modulation/fec/interleaving is not detected, the default is 567 * If modulation/fec/guard is not detected, the default is
578 * to consider the lowest bit rate, to avoid taking too long time 568 * to consider the lowest bit rate, to avoid taking too long time
579 * to get BER. 569 * to get BER.
580 */ 570 */
@@ -612,7 +602,7 @@ static void mb86a20s_layer_bitrate(struct dvb_frontend *fe, u32 layer,
612 break; 602 break;
613 } 603 }
614 604
615 switch (interleaving) { 605 switch (guard_interval) {
616 default: 606 default:
617 case GUARD_INTERVAL_1_4: 607 case GUARD_INTERVAL_1_4:
618 guard = 0; 608 guard = 0;
@@ -703,7 +693,7 @@ static int mb86a20s_get_frontend(struct dvb_frontend *fe)
703 c->layer[layer].interleaving = rc; 693 c->layer[layer].interleaving = rc;
704 mb86a20s_layer_bitrate(fe, layer, c->layer[layer].modulation, 694 mb86a20s_layer_bitrate(fe, layer, c->layer[layer].modulation,
705 c->layer[layer].fec, 695 c->layer[layer].fec,
706 c->layer[layer].interleaving, 696 c->guard_interval,
707 c->layer[layer].segment_count); 697 c->layer[layer].segment_count);
708 } 698 }
709 699
@@ -721,11 +711,10 @@ static int mb86a20s_get_frontend(struct dvb_frontend *fe)
721 rc = mb86a20s_readreg(state, 0x07); 711 rc = mb86a20s_readreg(state, 0x07);
722 if (rc < 0) 712 if (rc < 0)
723 return rc; 713 return rc;
714 c->transmission_mode = TRANSMISSION_MODE_AUTO;
724 if ((rc & 0x60) == 0x20) { 715 if ((rc & 0x60) == 0x20) {
725 switch (rc & 0x0c >> 2) { 716 /* Only modes 2 and 3 are supported */
726 case 0: 717 switch ((rc >> 2) & 0x03) {
727 c->transmission_mode = TRANSMISSION_MODE_2K;
728 break;
729 case 1: 718 case 1:
730 c->transmission_mode = TRANSMISSION_MODE_4K; 719 c->transmission_mode = TRANSMISSION_MODE_4K;
731 break; 720 break;
@@ -734,7 +723,9 @@ static int mb86a20s_get_frontend(struct dvb_frontend *fe)
734 break; 723 break;
735 } 724 }
736 } 725 }
726 c->guard_interval = GUARD_INTERVAL_AUTO;
737 if (!(rc & 0x10)) { 727 if (!(rc & 0x10)) {
728 /* Guard interval 1/32 is not supported */
738 switch (rc & 0x3) { 729 switch (rc & 0x3) {
739 case 0: 730 case 0:
740 c->guard_interval = GUARD_INTERVAL_1_4; 731 c->guard_interval = GUARD_INTERVAL_1_4;
diff --git a/drivers/media/dvb-frontends/rtl2832_sdr.c b/drivers/media/dvb-frontends/rtl2832_sdr.c
new file mode 100644
index 000000000000..023e0f49c786
--- /dev/null
+++ b/drivers/media/dvb-frontends/rtl2832_sdr.c
@@ -0,0 +1,1551 @@
1/*
2 * Realtek RTL2832U SDR driver
3 *
4 * Copyright (C) 2013 Antti Palosaari <crope@iki.fi>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License along
17 * with this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * GNU Radio plugin "gr-kernel" for device usage will be on:
21 * http://git.linuxtv.org/anttip/gr-kernel.git
22 *
23 */
24
25#include "dvb_frontend.h"
26#include "rtl2832_sdr.h"
27#include "dvb_usb.h"
28
29#include <media/v4l2-device.h>
30#include <media/v4l2-ioctl.h>
31#include <media/v4l2-ctrls.h>
32#include <media/v4l2-event.h>
33#include <media/videobuf2-vmalloc.h>
34
35#include <linux/jiffies.h>
36#include <linux/math64.h>
37
38static bool rtl2832_sdr_emulated_fmt;
39module_param_named(emulated_formats, rtl2832_sdr_emulated_fmt, bool, 0644);
40MODULE_PARM_DESC(emulated_formats, "enable emulated formats (disappears in future)");
41
42#define MAX_BULK_BUFS (10)
43#define BULK_BUFFER_SIZE (128 * 512)
44
45static const struct v4l2_frequency_band bands_adc[] = {
46 {
47 .tuner = 0,
48 .type = V4L2_TUNER_ADC,
49 .index = 0,
50 .capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS,
51 .rangelow = 300000,
52 .rangehigh = 300000,
53 },
54 {
55 .tuner = 0,
56 .type = V4L2_TUNER_ADC,
57 .index = 1,
58 .capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS,
59 .rangelow = 900001,
60 .rangehigh = 2800000,
61 },
62 {
63 .tuner = 0,
64 .type = V4L2_TUNER_ADC,
65 .index = 2,
66 .capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS,
67 .rangelow = 3200000,
68 .rangehigh = 3200000,
69 },
70};
71
72static const struct v4l2_frequency_band bands_fm[] = {
73 {
74 .tuner = 1,
75 .type = V4L2_TUNER_RF,
76 .index = 0,
77 .capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS,
78 .rangelow = 50000000,
79 .rangehigh = 2000000000,
80 },
81};
82
83/* stream formats */
84struct rtl2832_sdr_format {
85 char *name;
86 u32 pixelformat;
87 u32 buffersize;
88};
89
90static struct rtl2832_sdr_format formats[] = {
91 {
92 .name = "Complex U8",
93 .pixelformat = V4L2_SDR_FMT_CU8,
94 .buffersize = BULK_BUFFER_SIZE,
95 }, {
96 .name = "Complex U16LE (emulated)",
97 .pixelformat = V4L2_SDR_FMT_CU16LE,
98 .buffersize = BULK_BUFFER_SIZE * 2,
99 },
100};
101
102static const unsigned int NUM_FORMATS = ARRAY_SIZE(formats);
103
104/* intermediate buffers with raw data from the USB device */
105struct rtl2832_sdr_frame_buf {
106 struct vb2_buffer vb; /* common v4l buffer stuff -- must be first */
107 struct list_head list;
108};
109
110struct rtl2832_sdr_state {
111#define POWER_ON (1 << 1)
112#define URB_BUF (1 << 2)
113 unsigned long flags;
114
115 const struct rtl2832_config *cfg;
116 struct dvb_frontend *fe;
117 struct dvb_usb_device *d;
118 struct i2c_adapter *i2c;
119 u8 bank;
120
121 struct video_device vdev;
122 struct v4l2_device v4l2_dev;
123
124 /* videobuf2 queue and queued buffers list */
125 struct vb2_queue vb_queue;
126 struct list_head queued_bufs;
127 spinlock_t queued_bufs_lock; /* Protects queued_bufs */
128 unsigned sequence; /* buffer sequence counter */
129
130 /* Note if taking both locks v4l2_lock must always be locked first! */
131 struct mutex v4l2_lock; /* Protects everything else */
132 struct mutex vb_queue_lock; /* Protects vb_queue and capt_file */
133
134 /* Pointer to our usb_device, will be NULL after unplug */
135 struct usb_device *udev; /* Both mutexes most be hold when setting! */
136
137 unsigned int vb_full; /* vb is full and packets dropped */
138
139 struct urb *urb_list[MAX_BULK_BUFS];
140 int buf_num;
141 unsigned long buf_size;
142 u8 *buf_list[MAX_BULK_BUFS];
143 dma_addr_t dma_addr[MAX_BULK_BUFS];
144 int urbs_initialized;
145 int urbs_submitted;
146
147 unsigned int f_adc, f_tuner;
148 u32 pixelformat;
149 u32 buffersize;
150 unsigned int num_formats;
151
152 /* Controls */
153 struct v4l2_ctrl_handler hdl;
154 struct v4l2_ctrl *bandwidth_auto;
155 struct v4l2_ctrl *bandwidth;
156
157 /* for sample rate calc */
158 unsigned int sample;
159 unsigned int sample_measured;
160 unsigned long jiffies_next;
161};
162
163/* write multiple hardware registers */
164static int rtl2832_sdr_wr(struct rtl2832_sdr_state *s, u8 reg, const u8 *val,
165 int len)
166{
167 int ret;
168#define MAX_WR_LEN 24
169#define MAX_WR_XFER_LEN (MAX_WR_LEN + 1)
170 u8 buf[MAX_WR_XFER_LEN];
171 struct i2c_msg msg[1] = {
172 {
173 .addr = s->cfg->i2c_addr,
174 .flags = 0,
175 .len = 1 + len,
176 .buf = buf,
177 }
178 };
179
180 if (WARN_ON(len > MAX_WR_LEN))
181 return -EINVAL;
182
183 buf[0] = reg;
184 memcpy(&buf[1], val, len);
185
186 ret = i2c_transfer(s->i2c, msg, 1);
187 if (ret == 1) {
188 ret = 0;
189 } else {
190 dev_err(&s->i2c->dev,
191 "%s: I2C wr failed=%d reg=%02x len=%d\n",
192 KBUILD_MODNAME, ret, reg, len);
193 ret = -EREMOTEIO;
194 }
195 return ret;
196}
197
198/* read multiple hardware registers */
199static int rtl2832_sdr_rd(struct rtl2832_sdr_state *s, u8 reg, u8 *val, int len)
200{
201 int ret;
202 struct i2c_msg msg[2] = {
203 {
204 .addr = s->cfg->i2c_addr,
205 .flags = 0,
206 .len = 1,
207 .buf = &reg,
208 }, {
209 .addr = s->cfg->i2c_addr,
210 .flags = I2C_M_RD,
211 .len = len,
212 .buf = val,
213 }
214 };
215
216 ret = i2c_transfer(s->i2c, msg, 2);
217 if (ret == 2) {
218 ret = 0;
219 } else {
220 dev_err(&s->i2c->dev,
221 "%s: I2C rd failed=%d reg=%02x len=%d\n",
222 KBUILD_MODNAME, ret, reg, len);
223 ret = -EREMOTEIO;
224 }
225 return ret;
226}
227
228/* write multiple registers */
229static int rtl2832_sdr_wr_regs(struct rtl2832_sdr_state *s, u16 reg,
230 const u8 *val, int len)
231{
232 int ret;
233 u8 reg2 = (reg >> 0) & 0xff;
234 u8 bank = (reg >> 8) & 0xff;
235
236 /* switch bank if needed */
237 if (bank != s->bank) {
238 ret = rtl2832_sdr_wr(s, 0x00, &bank, 1);
239 if (ret)
240 return ret;
241
242 s->bank = bank;
243 }
244
245 return rtl2832_sdr_wr(s, reg2, val, len);
246}
247
248/* read multiple registers */
249static int rtl2832_sdr_rd_regs(struct rtl2832_sdr_state *s, u16 reg, u8 *val,
250 int len)
251{
252 int ret;
253 u8 reg2 = (reg >> 0) & 0xff;
254 u8 bank = (reg >> 8) & 0xff;
255
256 /* switch bank if needed */
257 if (bank != s->bank) {
258 ret = rtl2832_sdr_wr(s, 0x00, &bank, 1);
259 if (ret)
260 return ret;
261
262 s->bank = bank;
263 }
264
265 return rtl2832_sdr_rd(s, reg2, val, len);
266}
267
268/* write single register */
269static int rtl2832_sdr_wr_reg(struct rtl2832_sdr_state *s, u16 reg, u8 val)
270{
271 return rtl2832_sdr_wr_regs(s, reg, &val, 1);
272}
273
274#if 0
275/* read single register */
276static int rtl2832_sdr_rd_reg(struct rtl2832_sdr_state *s, u16 reg, u8 *val)
277{
278 return rtl2832_sdr_rd_regs(s, reg, val, 1);
279}
280#endif
281
282/* write single register with mask */
283static int rtl2832_sdr_wr_reg_mask(struct rtl2832_sdr_state *s, u16 reg,
284 u8 val, u8 mask)
285{
286 int ret;
287 u8 tmp;
288
289 /* no need for read if whole reg is written */
290 if (mask != 0xff) {
291 ret = rtl2832_sdr_rd_regs(s, reg, &tmp, 1);
292 if (ret)
293 return ret;
294
295 val &= mask;
296 tmp &= ~mask;
297 val |= tmp;
298 }
299
300 return rtl2832_sdr_wr_regs(s, reg, &val, 1);
301}
302
303#if 0
304/* read single register with mask */
305static int rtl2832_sdr_rd_reg_mask(struct rtl2832_sdr_state *s, u16 reg,
306 u8 *val, u8 mask)
307{
308 int ret, i;
309 u8 tmp;
310
311 ret = rtl2832_sdr_rd_regs(s, reg, &tmp, 1);
312 if (ret)
313 return ret;
314
315 tmp &= mask;
316
317 /* find position of the first bit */
318 for (i = 0; i < 8; i++) {
319 if ((mask >> i) & 0x01)
320 break;
321 }
322 *val = tmp >> i;
323
324 return 0;
325}
326#endif
327
328/* Private functions */
329static struct rtl2832_sdr_frame_buf *rtl2832_sdr_get_next_fill_buf(
330 struct rtl2832_sdr_state *s)
331{
332 unsigned long flags = 0;
333 struct rtl2832_sdr_frame_buf *buf = NULL;
334
335 spin_lock_irqsave(&s->queued_bufs_lock, flags);
336 if (list_empty(&s->queued_bufs))
337 goto leave;
338
339 buf = list_entry(s->queued_bufs.next,
340 struct rtl2832_sdr_frame_buf, list);
341 list_del(&buf->list);
342leave:
343 spin_unlock_irqrestore(&s->queued_bufs_lock, flags);
344 return buf;
345}
346
347static unsigned int rtl2832_sdr_convert_stream(struct rtl2832_sdr_state *s,
348 void *dst, const u8 *src, unsigned int src_len)
349{
350 unsigned int dst_len;
351
352 if (s->pixelformat == V4L2_SDR_FMT_CU8) {
353 /* native stream, no need to convert */
354 memcpy(dst, src, src_len);
355 dst_len = src_len;
356 } else if (s->pixelformat == V4L2_SDR_FMT_CU16LE) {
357 /* convert u8 to u16 */
358 unsigned int i;
359 u16 *u16dst = dst;
360
361 for (i = 0; i < src_len; i++)
362 *u16dst++ = (src[i] << 8) | (src[i] >> 0);
363 dst_len = 2 * src_len;
364 } else {
365 dst_len = 0;
366 }
367
368 /* calculate samping rate and output it in 10 seconds intervals */
369 if (unlikely(time_is_before_jiffies(s->jiffies_next))) {
370#define MSECS 10000UL
371 unsigned int samples = s->sample - s->sample_measured;
372
373 s->jiffies_next = jiffies + msecs_to_jiffies(MSECS);
374 s->sample_measured = s->sample;
375 dev_dbg(&s->udev->dev,
376 "slen=%d samples=%u msecs=%lu sampling rate=%lu\n",
377 src_len, samples, MSECS,
378 samples * 1000UL / MSECS);
379 }
380
381 /* total number of I+Q pairs */
382 s->sample += src_len / 2;
383
384 return dst_len;
385}
386
387/*
388 * This gets called for the bulk stream pipe. This is done in interrupt
389 * time, so it has to be fast, not crash, and not stall. Neat.
390 */
391static void rtl2832_sdr_urb_complete(struct urb *urb)
392{
393 struct rtl2832_sdr_state *s = urb->context;
394 struct rtl2832_sdr_frame_buf *fbuf;
395
396 dev_dbg_ratelimited(&s->udev->dev,
397 "%s: status=%d length=%d/%d errors=%d\n",
398 __func__, urb->status, urb->actual_length,
399 urb->transfer_buffer_length, urb->error_count);
400
401 switch (urb->status) {
402 case 0: /* success */
403 case -ETIMEDOUT: /* NAK */
404 break;
405 case -ECONNRESET: /* kill */
406 case -ENOENT:
407 case -ESHUTDOWN:
408 return;
409 default: /* error */
410 dev_err_ratelimited(&s->udev->dev, "urb failed=%d\n",
411 urb->status);
412 break;
413 }
414
415 if (likely(urb->actual_length > 0)) {
416 void *ptr;
417 unsigned int len;
418 /* get free framebuffer */
419 fbuf = rtl2832_sdr_get_next_fill_buf(s);
420 if (unlikely(fbuf == NULL)) {
421 s->vb_full++;
422 dev_notice_ratelimited(&s->udev->dev,
423 "videobuf is full, %d packets dropped\n",
424 s->vb_full);
425 goto skip;
426 }
427
428 /* fill framebuffer */
429 ptr = vb2_plane_vaddr(&fbuf->vb, 0);
430 len = rtl2832_sdr_convert_stream(s, ptr, urb->transfer_buffer,
431 urb->actual_length);
432 vb2_set_plane_payload(&fbuf->vb, 0, len);
433 v4l2_get_timestamp(&fbuf->vb.v4l2_buf.timestamp);
434 fbuf->vb.v4l2_buf.sequence = s->sequence++;
435 vb2_buffer_done(&fbuf->vb, VB2_BUF_STATE_DONE);
436 }
437skip:
438 usb_submit_urb(urb, GFP_ATOMIC);
439}
440
441static int rtl2832_sdr_kill_urbs(struct rtl2832_sdr_state *s)
442{
443 int i;
444
445 for (i = s->urbs_submitted - 1; i >= 0; i--) {
446 dev_dbg(&s->udev->dev, "%s: kill urb=%d\n", __func__, i);
447 /* stop the URB */
448 usb_kill_urb(s->urb_list[i]);
449 }
450 s->urbs_submitted = 0;
451
452 return 0;
453}
454
455static int rtl2832_sdr_submit_urbs(struct rtl2832_sdr_state *s)
456{
457 int i, ret;
458
459 for (i = 0; i < s->urbs_initialized; i++) {
460 dev_dbg(&s->udev->dev, "%s: submit urb=%d\n", __func__, i);
461 ret = usb_submit_urb(s->urb_list[i], GFP_ATOMIC);
462 if (ret) {
463 dev_err(&s->udev->dev,
464 "Could not submit urb no. %d - get them all back\n",
465 i);
466 rtl2832_sdr_kill_urbs(s);
467 return ret;
468 }
469 s->urbs_submitted++;
470 }
471
472 return 0;
473}
474
475static int rtl2832_sdr_free_stream_bufs(struct rtl2832_sdr_state *s)
476{
477 if (s->flags & USB_STATE_URB_BUF) {
478 while (s->buf_num) {
479 s->buf_num--;
480 dev_dbg(&s->udev->dev, "%s: free buf=%d\n",
481 __func__, s->buf_num);
482 usb_free_coherent(s->udev, s->buf_size,
483 s->buf_list[s->buf_num],
484 s->dma_addr[s->buf_num]);
485 }
486 }
487 s->flags &= ~USB_STATE_URB_BUF;
488
489 return 0;
490}
491
492static int rtl2832_sdr_alloc_stream_bufs(struct rtl2832_sdr_state *s)
493{
494 s->buf_num = 0;
495 s->buf_size = BULK_BUFFER_SIZE;
496
497 dev_dbg(&s->udev->dev,
498 "%s: all in all I will use %u bytes for streaming\n",
499 __func__, MAX_BULK_BUFS * BULK_BUFFER_SIZE);
500
501 for (s->buf_num = 0; s->buf_num < MAX_BULK_BUFS; s->buf_num++) {
502 s->buf_list[s->buf_num] = usb_alloc_coherent(s->udev,
503 BULK_BUFFER_SIZE, GFP_ATOMIC,
504 &s->dma_addr[s->buf_num]);
505 if (!s->buf_list[s->buf_num]) {
506 dev_dbg(&s->udev->dev, "%s: alloc buf=%d failed\n",
507 __func__, s->buf_num);
508 rtl2832_sdr_free_stream_bufs(s);
509 return -ENOMEM;
510 }
511
512 dev_dbg(&s->udev->dev, "%s: alloc buf=%d %p (dma %llu)\n",
513 __func__, s->buf_num,
514 s->buf_list[s->buf_num],
515 (long long)s->dma_addr[s->buf_num]);
516 s->flags |= USB_STATE_URB_BUF;
517 }
518
519 return 0;
520}
521
522static int rtl2832_sdr_free_urbs(struct rtl2832_sdr_state *s)
523{
524 int i;
525
526 rtl2832_sdr_kill_urbs(s);
527
528 for (i = s->urbs_initialized - 1; i >= 0; i--) {
529 if (s->urb_list[i]) {
530 dev_dbg(&s->udev->dev, "%s: free urb=%d\n",
531 __func__, i);
532 /* free the URBs */
533 usb_free_urb(s->urb_list[i]);
534 }
535 }
536 s->urbs_initialized = 0;
537
538 return 0;
539}
540
541static int rtl2832_sdr_alloc_urbs(struct rtl2832_sdr_state *s)
542{
543 int i, j;
544
545 /* allocate the URBs */
546 for (i = 0; i < MAX_BULK_BUFS; i++) {
547 dev_dbg(&s->udev->dev, "%s: alloc urb=%d\n", __func__, i);
548 s->urb_list[i] = usb_alloc_urb(0, GFP_ATOMIC);
549 if (!s->urb_list[i]) {
550 dev_dbg(&s->udev->dev, "%s: failed\n", __func__);
551 for (j = 0; j < i; j++)
552 usb_free_urb(s->urb_list[j]);
553 return -ENOMEM;
554 }
555 usb_fill_bulk_urb(s->urb_list[i],
556 s->udev,
557 usb_rcvbulkpipe(s->udev, 0x81),
558 s->buf_list[i],
559 BULK_BUFFER_SIZE,
560 rtl2832_sdr_urb_complete, s);
561
562 s->urb_list[i]->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
563 s->urb_list[i]->transfer_dma = s->dma_addr[i];
564 s->urbs_initialized++;
565 }
566
567 return 0;
568}
569
570/* Must be called with vb_queue_lock hold */
571static void rtl2832_sdr_cleanup_queued_bufs(struct rtl2832_sdr_state *s)
572{
573 unsigned long flags = 0;
574
575 dev_dbg(&s->udev->dev, "%s:\n", __func__);
576
577 spin_lock_irqsave(&s->queued_bufs_lock, flags);
578 while (!list_empty(&s->queued_bufs)) {
579 struct rtl2832_sdr_frame_buf *buf;
580
581 buf = list_entry(s->queued_bufs.next,
582 struct rtl2832_sdr_frame_buf, list);
583 list_del(&buf->list);
584 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
585 }
586 spin_unlock_irqrestore(&s->queued_bufs_lock, flags);
587}
588
589/* The user yanked out the cable... */
590static void rtl2832_sdr_release_sec(struct dvb_frontend *fe)
591{
592 struct rtl2832_sdr_state *s = fe->sec_priv;
593
594 dev_dbg(&s->udev->dev, "%s:\n", __func__);
595
596 mutex_lock(&s->vb_queue_lock);
597 mutex_lock(&s->v4l2_lock);
598 /* No need to keep the urbs around after disconnection */
599 s->udev = NULL;
600
601 v4l2_device_disconnect(&s->v4l2_dev);
602 video_unregister_device(&s->vdev);
603 mutex_unlock(&s->v4l2_lock);
604 mutex_unlock(&s->vb_queue_lock);
605
606 v4l2_device_put(&s->v4l2_dev);
607
608 fe->sec_priv = NULL;
609}
610
611static int rtl2832_sdr_querycap(struct file *file, void *fh,
612 struct v4l2_capability *cap)
613{
614 struct rtl2832_sdr_state *s = video_drvdata(file);
615
616 dev_dbg(&s->udev->dev, "%s:\n", __func__);
617
618 strlcpy(cap->driver, KBUILD_MODNAME, sizeof(cap->driver));
619 strlcpy(cap->card, s->vdev.name, sizeof(cap->card));
620 usb_make_path(s->udev, cap->bus_info, sizeof(cap->bus_info));
621 cap->device_caps = V4L2_CAP_SDR_CAPTURE | V4L2_CAP_STREAMING |
622 V4L2_CAP_READWRITE | V4L2_CAP_TUNER;
623 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
624 return 0;
625}
626
627/* Videobuf2 operations */
628static int rtl2832_sdr_queue_setup(struct vb2_queue *vq,
629 const struct v4l2_format *fmt, unsigned int *nbuffers,
630 unsigned int *nplanes, unsigned int sizes[], void *alloc_ctxs[])
631{
632 struct rtl2832_sdr_state *s = vb2_get_drv_priv(vq);
633
634 dev_dbg(&s->udev->dev, "%s: *nbuffers=%d\n", __func__, *nbuffers);
635
636 /* Need at least 8 buffers */
637 if (vq->num_buffers + *nbuffers < 8)
638 *nbuffers = 8 - vq->num_buffers;
639 *nplanes = 1;
640 sizes[0] = PAGE_ALIGN(s->buffersize);
641 dev_dbg(&s->udev->dev, "%s: nbuffers=%d sizes[0]=%d\n",
642 __func__, *nbuffers, sizes[0]);
643 return 0;
644}
645
646static int rtl2832_sdr_buf_prepare(struct vb2_buffer *vb)
647{
648 struct rtl2832_sdr_state *s = vb2_get_drv_priv(vb->vb2_queue);
649
650 /* Don't allow queing new buffers after device disconnection */
651 if (!s->udev)
652 return -ENODEV;
653
654 return 0;
655}
656
657static void rtl2832_sdr_buf_queue(struct vb2_buffer *vb)
658{
659 struct rtl2832_sdr_state *s = vb2_get_drv_priv(vb->vb2_queue);
660 struct rtl2832_sdr_frame_buf *buf =
661 container_of(vb, struct rtl2832_sdr_frame_buf, vb);
662 unsigned long flags = 0;
663
664 /* Check the device has not disconnected between prep and queuing */
665 if (!s->udev) {
666 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
667 return;
668 }
669
670 spin_lock_irqsave(&s->queued_bufs_lock, flags);
671 list_add_tail(&buf->list, &s->queued_bufs);
672 spin_unlock_irqrestore(&s->queued_bufs_lock, flags);
673}
674
675static int rtl2832_sdr_set_adc(struct rtl2832_sdr_state *s)
676{
677 struct dvb_frontend *fe = s->fe;
678 int ret;
679 unsigned int f_sr, f_if;
680 u8 buf[4], u8tmp1, u8tmp2;
681 u64 u64tmp;
682 u32 u32tmp;
683
684 dev_dbg(&s->udev->dev, "%s: f_adc=%u\n", __func__, s->f_adc);
685
686 if (!test_bit(POWER_ON, &s->flags))
687 return 0;
688
689 if (s->f_adc == 0)
690 return 0;
691
692 f_sr = s->f_adc;
693
694 ret = rtl2832_sdr_wr_regs(s, 0x13e, "\x00\x00", 2);
695 if (ret)
696 goto err;
697
698 ret = rtl2832_sdr_wr_regs(s, 0x115, "\x00\x00\x00\x00", 4);
699 if (ret)
700 goto err;
701
702 /* get IF from tuner */
703 if (fe->ops.tuner_ops.get_if_frequency)
704 ret = fe->ops.tuner_ops.get_if_frequency(fe, &f_if);
705 else
706 ret = -EINVAL;
707
708 if (ret)
709 goto err;
710
711 /* program IF */
712 u64tmp = f_if % s->cfg->xtal;
713 u64tmp *= 0x400000;
714 u64tmp = div_u64(u64tmp, s->cfg->xtal);
715 u64tmp = -u64tmp;
716 u32tmp = u64tmp & 0x3fffff;
717
718 dev_dbg(&s->udev->dev, "%s: f_if=%u if_ctl=%08x\n",
719 __func__, f_if, u32tmp);
720
721 buf[0] = (u32tmp >> 16) & 0xff;
722 buf[1] = (u32tmp >> 8) & 0xff;
723 buf[2] = (u32tmp >> 0) & 0xff;
724
725 ret = rtl2832_sdr_wr_regs(s, 0x119, buf, 3);
726 if (ret)
727 goto err;
728
729 /* BB / IF mode */
730 /* POR: 0x1b1=0x1f, 0x008=0x0d, 0x006=0x80 */
731 if (f_if) {
732 u8tmp1 = 0x1a; /* disable Zero-IF */
733 u8tmp2 = 0x8d; /* enable ADC I */
734 } else {
735 u8tmp1 = 0x1b; /* enable Zero-IF, DC, IQ */
736 u8tmp2 = 0xcd; /* enable ADC I, ADC Q */
737 }
738
739 ret = rtl2832_sdr_wr_reg(s, 0x1b1, u8tmp1);
740 if (ret)
741 goto err;
742
743 ret = rtl2832_sdr_wr_reg(s, 0x008, u8tmp2);
744 if (ret)
745 goto err;
746
747 ret = rtl2832_sdr_wr_reg(s, 0x006, 0x80);
748 if (ret)
749 goto err;
750
751 /* program sampling rate (resampling down) */
752 u32tmp = div_u64(s->cfg->xtal * 0x400000ULL, f_sr * 4U);
753 u32tmp <<= 2;
754 buf[0] = (u32tmp >> 24) & 0xff;
755 buf[1] = (u32tmp >> 16) & 0xff;
756 buf[2] = (u32tmp >> 8) & 0xff;
757 buf[3] = (u32tmp >> 0) & 0xff;
758 ret = rtl2832_sdr_wr_regs(s, 0x19f, buf, 4);
759 if (ret)
760 goto err;
761
762 /* low-pass filter */
763 ret = rtl2832_sdr_wr_regs(s, 0x11c,
764 "\xca\xdc\xd7\xd8\xe0\xf2\x0e\x35\x06\x50\x9c\x0d\x71\x11\x14\x71\x74\x19\x41\xa5",
765 20);
766 if (ret)
767 goto err;
768
769 ret = rtl2832_sdr_wr_regs(s, 0x017, "\x11\x10", 2);
770 if (ret)
771 goto err;
772
773 /* mode */
774 ret = rtl2832_sdr_wr_regs(s, 0x019, "\x05", 1);
775 if (ret)
776 goto err;
777
778 ret = rtl2832_sdr_wr_regs(s, 0x01a, "\x1b\x16\x0d\x06\x01\xff", 6);
779 if (ret)
780 goto err;
781
782 /* FSM */
783 ret = rtl2832_sdr_wr_regs(s, 0x192, "\x00\xf0\x0f", 3);
784 if (ret)
785 goto err;
786
787 /* PID filter */
788 ret = rtl2832_sdr_wr_regs(s, 0x061, "\x60", 1);
789 if (ret)
790 goto err;
791
792 /* used RF tuner based settings */
793 switch (s->cfg->tuner) {
794 case RTL2832_TUNER_E4000:
795 ret = rtl2832_sdr_wr_regs(s, 0x112, "\x5a", 1);
796 ret = rtl2832_sdr_wr_regs(s, 0x102, "\x40", 1);
797 ret = rtl2832_sdr_wr_regs(s, 0x103, "\x5a", 1);
798 ret = rtl2832_sdr_wr_regs(s, 0x1c7, "\x30", 1);
799 ret = rtl2832_sdr_wr_regs(s, 0x104, "\xd0", 1);
800 ret = rtl2832_sdr_wr_regs(s, 0x105, "\xbe", 1);
801 ret = rtl2832_sdr_wr_regs(s, 0x1c8, "\x18", 1);
802 ret = rtl2832_sdr_wr_regs(s, 0x106, "\x35", 1);
803 ret = rtl2832_sdr_wr_regs(s, 0x1c9, "\x21", 1);
804 ret = rtl2832_sdr_wr_regs(s, 0x1ca, "\x21", 1);
805 ret = rtl2832_sdr_wr_regs(s, 0x1cb, "\x00", 1);
806 ret = rtl2832_sdr_wr_regs(s, 0x107, "\x40", 1);
807 ret = rtl2832_sdr_wr_regs(s, 0x1cd, "\x10", 1);
808 ret = rtl2832_sdr_wr_regs(s, 0x1ce, "\x10", 1);
809 ret = rtl2832_sdr_wr_regs(s, 0x108, "\x80", 1);
810 ret = rtl2832_sdr_wr_regs(s, 0x109, "\x7f", 1);
811 ret = rtl2832_sdr_wr_regs(s, 0x10a, "\x80", 1);
812 ret = rtl2832_sdr_wr_regs(s, 0x10b, "\x7f", 1);
813 ret = rtl2832_sdr_wr_regs(s, 0x00e, "\xfc", 1);
814 ret = rtl2832_sdr_wr_regs(s, 0x00e, "\xfc", 1);
815 ret = rtl2832_sdr_wr_regs(s, 0x011, "\xd4", 1);
816 ret = rtl2832_sdr_wr_regs(s, 0x1e5, "\xf0", 1);
817 ret = rtl2832_sdr_wr_regs(s, 0x1d9, "\x00", 1);
818 ret = rtl2832_sdr_wr_regs(s, 0x1db, "\x00", 1);
819 ret = rtl2832_sdr_wr_regs(s, 0x1dd, "\x14", 1);
820 ret = rtl2832_sdr_wr_regs(s, 0x1de, "\xec", 1);
821 ret = rtl2832_sdr_wr_regs(s, 0x1d8, "\x0c", 1);
822 ret = rtl2832_sdr_wr_regs(s, 0x1e6, "\x02", 1);
823 ret = rtl2832_sdr_wr_regs(s, 0x1d7, "\x09", 1);
824 ret = rtl2832_sdr_wr_regs(s, 0x00d, "\x83", 1);
825 ret = rtl2832_sdr_wr_regs(s, 0x010, "\x49", 1);
826 ret = rtl2832_sdr_wr_regs(s, 0x00d, "\x87", 1);
827 ret = rtl2832_sdr_wr_regs(s, 0x00d, "\x85", 1);
828 ret = rtl2832_sdr_wr_regs(s, 0x013, "\x02", 1);
829 break;
830 case RTL2832_TUNER_FC0012:
831 case RTL2832_TUNER_FC0013:
832 ret = rtl2832_sdr_wr_regs(s, 0x112, "\x5a", 1);
833 ret = rtl2832_sdr_wr_regs(s, 0x102, "\x40", 1);
834 ret = rtl2832_sdr_wr_regs(s, 0x103, "\x5a", 1);
835 ret = rtl2832_sdr_wr_regs(s, 0x1c7, "\x2c", 1);
836 ret = rtl2832_sdr_wr_regs(s, 0x104, "\xcc", 1);
837 ret = rtl2832_sdr_wr_regs(s, 0x105, "\xbe", 1);
838 ret = rtl2832_sdr_wr_regs(s, 0x1c8, "\x16", 1);
839 ret = rtl2832_sdr_wr_regs(s, 0x106, "\x35", 1);
840 ret = rtl2832_sdr_wr_regs(s, 0x1c9, "\x21", 1);
841 ret = rtl2832_sdr_wr_regs(s, 0x1ca, "\x21", 1);
842 ret = rtl2832_sdr_wr_regs(s, 0x1cb, "\x00", 1);
843 ret = rtl2832_sdr_wr_regs(s, 0x107, "\x40", 1);
844 ret = rtl2832_sdr_wr_regs(s, 0x1cd, "\x10", 1);
845 ret = rtl2832_sdr_wr_regs(s, 0x1ce, "\x10", 1);
846 ret = rtl2832_sdr_wr_regs(s, 0x108, "\x80", 1);
847 ret = rtl2832_sdr_wr_regs(s, 0x109, "\x7f", 1);
848 ret = rtl2832_sdr_wr_regs(s, 0x10a, "\x80", 1);
849 ret = rtl2832_sdr_wr_regs(s, 0x10b, "\x7f", 1);
850 ret = rtl2832_sdr_wr_regs(s, 0x00e, "\xfc", 1);
851 ret = rtl2832_sdr_wr_regs(s, 0x00e, "\xfc", 1);
852 ret = rtl2832_sdr_wr_regs(s, 0x011, "\xe9\xbf", 2);
853 ret = rtl2832_sdr_wr_regs(s, 0x1e5, "\xf0", 1);
854 ret = rtl2832_sdr_wr_regs(s, 0x1d9, "\x00", 1);
855 ret = rtl2832_sdr_wr_regs(s, 0x1db, "\x00", 1);
856 ret = rtl2832_sdr_wr_regs(s, 0x1dd, "\x11", 1);
857 ret = rtl2832_sdr_wr_regs(s, 0x1de, "\xef", 1);
858 ret = rtl2832_sdr_wr_regs(s, 0x1d8, "\x0c", 1);
859 ret = rtl2832_sdr_wr_regs(s, 0x1e6, "\x02", 1);
860 ret = rtl2832_sdr_wr_regs(s, 0x1d7, "\x09", 1);
861 break;
862 case RTL2832_TUNER_R820T:
863 ret = rtl2832_sdr_wr_regs(s, 0x112, "\x5a", 1);
864 ret = rtl2832_sdr_wr_regs(s, 0x102, "\x40", 1);
865 ret = rtl2832_sdr_wr_regs(s, 0x115, "\x01", 1);
866 ret = rtl2832_sdr_wr_regs(s, 0x103, "\x80", 1);
867 ret = rtl2832_sdr_wr_regs(s, 0x1c7, "\x24", 1);
868 ret = rtl2832_sdr_wr_regs(s, 0x104, "\xcc", 1);
869 ret = rtl2832_sdr_wr_regs(s, 0x105, "\xbe", 1);
870 ret = rtl2832_sdr_wr_regs(s, 0x1c8, "\x14", 1);
871 ret = rtl2832_sdr_wr_regs(s, 0x106, "\x35", 1);
872 ret = rtl2832_sdr_wr_regs(s, 0x1c9, "\x21", 1);
873 ret = rtl2832_sdr_wr_regs(s, 0x1ca, "\x21", 1);
874 ret = rtl2832_sdr_wr_regs(s, 0x1cb, "\x00", 1);
875 ret = rtl2832_sdr_wr_regs(s, 0x107, "\x40", 1);
876 ret = rtl2832_sdr_wr_regs(s, 0x1cd, "\x10", 1);
877 ret = rtl2832_sdr_wr_regs(s, 0x1ce, "\x10", 1);
878 ret = rtl2832_sdr_wr_regs(s, 0x108, "\x80", 1);
879 ret = rtl2832_sdr_wr_regs(s, 0x109, "\x7f", 1);
880 ret = rtl2832_sdr_wr_regs(s, 0x10a, "\x80", 1);
881 ret = rtl2832_sdr_wr_regs(s, 0x10b, "\x7f", 1);
882 ret = rtl2832_sdr_wr_regs(s, 0x00e, "\xfc", 1);
883 ret = rtl2832_sdr_wr_regs(s, 0x00e, "\xfc", 1);
884 ret = rtl2832_sdr_wr_regs(s, 0x011, "\xf4", 1);
885 break;
886 default:
887 dev_notice(&s->udev->dev, "Unsupported tuner\n");
888 }
889
890 /* software reset */
891 ret = rtl2832_sdr_wr_reg_mask(s, 0x101, 0x04, 0x04);
892 if (ret)
893 goto err;
894
895 ret = rtl2832_sdr_wr_reg_mask(s, 0x101, 0x00, 0x04);
896 if (ret)
897 goto err;
898err:
899 return ret;
900};
901
902static void rtl2832_sdr_unset_adc(struct rtl2832_sdr_state *s)
903{
904 int ret;
905
906 dev_dbg(&s->udev->dev, "%s:\n", __func__);
907
908 /* PID filter */
909 ret = rtl2832_sdr_wr_regs(s, 0x061, "\xe0", 1);
910 if (ret)
911 goto err;
912
913 /* mode */
914 ret = rtl2832_sdr_wr_regs(s, 0x019, "\x20", 1);
915 if (ret)
916 goto err;
917
918 ret = rtl2832_sdr_wr_regs(s, 0x017, "\x11\x10", 2);
919 if (ret)
920 goto err;
921
922 /* FSM */
923 ret = rtl2832_sdr_wr_regs(s, 0x192, "\x00\x0f\xff", 3);
924 if (ret)
925 goto err;
926
927 ret = rtl2832_sdr_wr_regs(s, 0x13e, "\x40\x00", 2);
928 if (ret)
929 goto err;
930
931 ret = rtl2832_sdr_wr_regs(s, 0x115, "\x06\x3f\xce\xcc", 4);
932 if (ret)
933 goto err;
934err:
935 return;
936};
937
938static int rtl2832_sdr_set_tuner_freq(struct rtl2832_sdr_state *s)
939{
940 struct dvb_frontend *fe = s->fe;
941 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
942 struct v4l2_ctrl *bandwidth_auto;
943 struct v4l2_ctrl *bandwidth;
944
945 /*
946 * tuner RF (Hz)
947 */
948 if (s->f_tuner == 0)
949 return 0;
950
951 /*
952 * bandwidth (Hz)
953 */
954 bandwidth_auto = v4l2_ctrl_find(&s->hdl,
955 V4L2_CID_RF_TUNER_BANDWIDTH_AUTO);
956 bandwidth = v4l2_ctrl_find(&s->hdl, V4L2_CID_RF_TUNER_BANDWIDTH);
957 if (v4l2_ctrl_g_ctrl(bandwidth_auto)) {
958 c->bandwidth_hz = s->f_adc;
959 v4l2_ctrl_s_ctrl(bandwidth, s->f_adc);
960 } else {
961 c->bandwidth_hz = v4l2_ctrl_g_ctrl(bandwidth);
962 }
963
964 c->frequency = s->f_tuner;
965 c->delivery_system = SYS_DVBT;
966
967 dev_dbg(&s->udev->dev, "%s: frequency=%u bandwidth=%d\n",
968 __func__, c->frequency, c->bandwidth_hz);
969
970 if (!test_bit(POWER_ON, &s->flags))
971 return 0;
972
973 if (fe->ops.tuner_ops.set_params)
974 fe->ops.tuner_ops.set_params(fe);
975
976 return 0;
977};
978
979static int rtl2832_sdr_set_tuner(struct rtl2832_sdr_state *s)
980{
981 struct dvb_frontend *fe = s->fe;
982
983 dev_dbg(&s->udev->dev, "%s:\n", __func__);
984
985 if (fe->ops.tuner_ops.init)
986 fe->ops.tuner_ops.init(fe);
987
988 return 0;
989};
990
991static void rtl2832_sdr_unset_tuner(struct rtl2832_sdr_state *s)
992{
993 struct dvb_frontend *fe = s->fe;
994
995 dev_dbg(&s->udev->dev, "%s:\n", __func__);
996
997 if (fe->ops.tuner_ops.sleep)
998 fe->ops.tuner_ops.sleep(fe);
999
1000 return;
1001};
1002
1003static int rtl2832_sdr_start_streaming(struct vb2_queue *vq, unsigned int count)
1004{
1005 struct rtl2832_sdr_state *s = vb2_get_drv_priv(vq);
1006 int ret;
1007
1008 dev_dbg(&s->udev->dev, "%s:\n", __func__);
1009
1010 if (!s->udev)
1011 return -ENODEV;
1012
1013 if (mutex_lock_interruptible(&s->v4l2_lock))
1014 return -ERESTARTSYS;
1015
1016 if (s->d->props->power_ctrl)
1017 s->d->props->power_ctrl(s->d, 1);
1018
1019 set_bit(POWER_ON, &s->flags);
1020
1021 ret = rtl2832_sdr_set_tuner(s);
1022 if (ret)
1023 goto err;
1024
1025 ret = rtl2832_sdr_set_tuner_freq(s);
1026 if (ret)
1027 goto err;
1028
1029 ret = rtl2832_sdr_set_adc(s);
1030 if (ret)
1031 goto err;
1032
1033 ret = rtl2832_sdr_alloc_stream_bufs(s);
1034 if (ret)
1035 goto err;
1036
1037 ret = rtl2832_sdr_alloc_urbs(s);
1038 if (ret)
1039 goto err;
1040
1041 s->sequence = 0;
1042
1043 ret = rtl2832_sdr_submit_urbs(s);
1044 if (ret)
1045 goto err;
1046
1047err:
1048 mutex_unlock(&s->v4l2_lock);
1049
1050 return ret;
1051}
1052
1053static void rtl2832_sdr_stop_streaming(struct vb2_queue *vq)
1054{
1055 struct rtl2832_sdr_state *s = vb2_get_drv_priv(vq);
1056
1057 dev_dbg(&s->udev->dev, "%s:\n", __func__);
1058
1059 mutex_lock(&s->v4l2_lock);
1060
1061 rtl2832_sdr_kill_urbs(s);
1062 rtl2832_sdr_free_urbs(s);
1063 rtl2832_sdr_free_stream_bufs(s);
1064 rtl2832_sdr_cleanup_queued_bufs(s);
1065 rtl2832_sdr_unset_adc(s);
1066 rtl2832_sdr_unset_tuner(s);
1067
1068 clear_bit(POWER_ON, &s->flags);
1069
1070 if (s->d->props->power_ctrl)
1071 s->d->props->power_ctrl(s->d, 0);
1072
1073 mutex_unlock(&s->v4l2_lock);
1074}
1075
1076static struct vb2_ops rtl2832_sdr_vb2_ops = {
1077 .queue_setup = rtl2832_sdr_queue_setup,
1078 .buf_prepare = rtl2832_sdr_buf_prepare,
1079 .buf_queue = rtl2832_sdr_buf_queue,
1080 .start_streaming = rtl2832_sdr_start_streaming,
1081 .stop_streaming = rtl2832_sdr_stop_streaming,
1082 .wait_prepare = vb2_ops_wait_prepare,
1083 .wait_finish = vb2_ops_wait_finish,
1084};
1085
1086static int rtl2832_sdr_g_tuner(struct file *file, void *priv,
1087 struct v4l2_tuner *v)
1088{
1089 struct rtl2832_sdr_state *s = video_drvdata(file);
1090
1091 dev_dbg(&s->udev->dev, "%s: index=%d type=%d\n",
1092 __func__, v->index, v->type);
1093
1094 if (v->index == 0) {
1095 strlcpy(v->name, "ADC: Realtek RTL2832", sizeof(v->name));
1096 v->type = V4L2_TUNER_ADC;
1097 v->capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS;
1098 v->rangelow = 300000;
1099 v->rangehigh = 3200000;
1100 } else if (v->index == 1) {
1101 strlcpy(v->name, "RF: <unknown>", sizeof(v->name));
1102 v->type = V4L2_TUNER_RF;
1103 v->capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS;
1104 v->rangelow = 50000000;
1105 v->rangehigh = 2000000000;
1106 } else {
1107 return -EINVAL;
1108 }
1109
1110 return 0;
1111}
1112
1113static int rtl2832_sdr_s_tuner(struct file *file, void *priv,
1114 const struct v4l2_tuner *v)
1115{
1116 struct rtl2832_sdr_state *s = video_drvdata(file);
1117
1118 dev_dbg(&s->udev->dev, "%s:\n", __func__);
1119
1120 if (v->index > 1)
1121 return -EINVAL;
1122 return 0;
1123}
1124
1125static int rtl2832_sdr_enum_freq_bands(struct file *file, void *priv,
1126 struct v4l2_frequency_band *band)
1127{
1128 struct rtl2832_sdr_state *s = video_drvdata(file);
1129
1130 dev_dbg(&s->udev->dev, "%s: tuner=%d type=%d index=%d\n",
1131 __func__, band->tuner, band->type, band->index);
1132
1133 if (band->tuner == 0) {
1134 if (band->index >= ARRAY_SIZE(bands_adc))
1135 return -EINVAL;
1136
1137 *band = bands_adc[band->index];
1138 } else if (band->tuner == 1) {
1139 if (band->index >= ARRAY_SIZE(bands_fm))
1140 return -EINVAL;
1141
1142 *band = bands_fm[band->index];
1143 } else {
1144 return -EINVAL;
1145 }
1146
1147 return 0;
1148}
1149
1150static int rtl2832_sdr_g_frequency(struct file *file, void *priv,
1151 struct v4l2_frequency *f)
1152{
1153 struct rtl2832_sdr_state *s = video_drvdata(file);
1154 int ret = 0;
1155
1156 dev_dbg(&s->udev->dev, "%s: tuner=%d type=%d\n",
1157 __func__, f->tuner, f->type);
1158
1159 if (f->tuner == 0) {
1160 f->frequency = s->f_adc;
1161 f->type = V4L2_TUNER_ADC;
1162 } else if (f->tuner == 1) {
1163 f->frequency = s->f_tuner;
1164 f->type = V4L2_TUNER_RF;
1165 } else {
1166 return -EINVAL;
1167 }
1168
1169 return ret;
1170}
1171
1172static int rtl2832_sdr_s_frequency(struct file *file, void *priv,
1173 const struct v4l2_frequency *f)
1174{
1175 struct rtl2832_sdr_state *s = video_drvdata(file);
1176 int ret, band;
1177
1178 dev_dbg(&s->udev->dev, "%s: tuner=%d type=%d frequency=%u\n",
1179 __func__, f->tuner, f->type, f->frequency);
1180
1181 /* ADC band midpoints */
1182 #define BAND_ADC_0 ((bands_adc[0].rangehigh + bands_adc[1].rangelow) / 2)
1183 #define BAND_ADC_1 ((bands_adc[1].rangehigh + bands_adc[2].rangelow) / 2)
1184
1185 if (f->tuner == 0 && f->type == V4L2_TUNER_ADC) {
1186 if (f->frequency < BAND_ADC_0)
1187 band = 0;
1188 else if (f->frequency < BAND_ADC_1)
1189 band = 1;
1190 else
1191 band = 2;
1192
1193 s->f_adc = clamp_t(unsigned int, f->frequency,
1194 bands_adc[band].rangelow,
1195 bands_adc[band].rangehigh);
1196
1197 dev_dbg(&s->udev->dev, "%s: ADC frequency=%u Hz\n",
1198 __func__, s->f_adc);
1199 ret = rtl2832_sdr_set_adc(s);
1200 } else if (f->tuner == 1) {
1201 s->f_tuner = clamp_t(unsigned int, f->frequency,
1202 bands_fm[0].rangelow,
1203 bands_fm[0].rangehigh);
1204 dev_dbg(&s->udev->dev, "%s: RF frequency=%u Hz\n",
1205 __func__, f->frequency);
1206
1207 ret = rtl2832_sdr_set_tuner_freq(s);
1208 } else {
1209 ret = -EINVAL;
1210 }
1211
1212 return ret;
1213}
1214
1215static int rtl2832_sdr_enum_fmt_sdr_cap(struct file *file, void *priv,
1216 struct v4l2_fmtdesc *f)
1217{
1218 struct rtl2832_sdr_state *s = video_drvdata(file);
1219
1220 dev_dbg(&s->udev->dev, "%s:\n", __func__);
1221
1222 if (f->index >= s->num_formats)
1223 return -EINVAL;
1224
1225 strlcpy(f->description, formats[f->index].name, sizeof(f->description));
1226 f->pixelformat = formats[f->index].pixelformat;
1227
1228 return 0;
1229}
1230
1231static int rtl2832_sdr_g_fmt_sdr_cap(struct file *file, void *priv,
1232 struct v4l2_format *f)
1233{
1234 struct rtl2832_sdr_state *s = video_drvdata(file);
1235
1236 dev_dbg(&s->udev->dev, "%s:\n", __func__);
1237
1238 f->fmt.sdr.pixelformat = s->pixelformat;
1239 f->fmt.sdr.buffersize = s->buffersize;
1240
1241 memset(f->fmt.sdr.reserved, 0, sizeof(f->fmt.sdr.reserved));
1242
1243 return 0;
1244}
1245
1246static int rtl2832_sdr_s_fmt_sdr_cap(struct file *file, void *priv,
1247 struct v4l2_format *f)
1248{
1249 struct rtl2832_sdr_state *s = video_drvdata(file);
1250 struct vb2_queue *q = &s->vb_queue;
1251 int i;
1252
1253 dev_dbg(&s->udev->dev, "%s: pixelformat fourcc %4.4s\n", __func__,
1254 (char *)&f->fmt.sdr.pixelformat);
1255
1256 if (vb2_is_busy(q))
1257 return -EBUSY;
1258
1259 memset(f->fmt.sdr.reserved, 0, sizeof(f->fmt.sdr.reserved));
1260 for (i = 0; i < s->num_formats; i++) {
1261 if (formats[i].pixelformat == f->fmt.sdr.pixelformat) {
1262 s->pixelformat = formats[i].pixelformat;
1263 s->buffersize = formats[i].buffersize;
1264 f->fmt.sdr.buffersize = formats[i].buffersize;
1265 return 0;
1266 }
1267 }
1268
1269 s->pixelformat = formats[0].pixelformat;
1270 s->buffersize = formats[0].buffersize;
1271 f->fmt.sdr.pixelformat = formats[0].pixelformat;
1272 f->fmt.sdr.buffersize = formats[0].buffersize;
1273
1274 return 0;
1275}
1276
1277static int rtl2832_sdr_try_fmt_sdr_cap(struct file *file, void *priv,
1278 struct v4l2_format *f)
1279{
1280 struct rtl2832_sdr_state *s = video_drvdata(file);
1281 int i;
1282
1283 dev_dbg(&s->udev->dev, "%s: pixelformat fourcc %4.4s\n", __func__,
1284 (char *)&f->fmt.sdr.pixelformat);
1285
1286 memset(f->fmt.sdr.reserved, 0, sizeof(f->fmt.sdr.reserved));
1287 for (i = 0; i < s->num_formats; i++) {
1288 if (formats[i].pixelformat == f->fmt.sdr.pixelformat) {
1289 f->fmt.sdr.buffersize = formats[i].buffersize;
1290 return 0;
1291 }
1292 }
1293
1294 f->fmt.sdr.pixelformat = formats[0].pixelformat;
1295 f->fmt.sdr.buffersize = formats[0].buffersize;
1296
1297 return 0;
1298}
1299
1300static const struct v4l2_ioctl_ops rtl2832_sdr_ioctl_ops = {
1301 .vidioc_querycap = rtl2832_sdr_querycap,
1302
1303 .vidioc_enum_fmt_sdr_cap = rtl2832_sdr_enum_fmt_sdr_cap,
1304 .vidioc_g_fmt_sdr_cap = rtl2832_sdr_g_fmt_sdr_cap,
1305 .vidioc_s_fmt_sdr_cap = rtl2832_sdr_s_fmt_sdr_cap,
1306 .vidioc_try_fmt_sdr_cap = rtl2832_sdr_try_fmt_sdr_cap,
1307
1308 .vidioc_reqbufs = vb2_ioctl_reqbufs,
1309 .vidioc_create_bufs = vb2_ioctl_create_bufs,
1310 .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
1311 .vidioc_querybuf = vb2_ioctl_querybuf,
1312 .vidioc_qbuf = vb2_ioctl_qbuf,
1313 .vidioc_dqbuf = vb2_ioctl_dqbuf,
1314
1315 .vidioc_streamon = vb2_ioctl_streamon,
1316 .vidioc_streamoff = vb2_ioctl_streamoff,
1317
1318 .vidioc_g_tuner = rtl2832_sdr_g_tuner,
1319 .vidioc_s_tuner = rtl2832_sdr_s_tuner,
1320
1321 .vidioc_enum_freq_bands = rtl2832_sdr_enum_freq_bands,
1322 .vidioc_g_frequency = rtl2832_sdr_g_frequency,
1323 .vidioc_s_frequency = rtl2832_sdr_s_frequency,
1324
1325 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1326 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1327 .vidioc_log_status = v4l2_ctrl_log_status,
1328};
1329
1330static const struct v4l2_file_operations rtl2832_sdr_fops = {
1331 .owner = THIS_MODULE,
1332 .open = v4l2_fh_open,
1333 .release = vb2_fop_release,
1334 .read = vb2_fop_read,
1335 .poll = vb2_fop_poll,
1336 .mmap = vb2_fop_mmap,
1337 .unlocked_ioctl = video_ioctl2,
1338};
1339
1340static struct video_device rtl2832_sdr_template = {
1341 .name = "Realtek RTL2832 SDR",
1342 .release = video_device_release_empty,
1343 .fops = &rtl2832_sdr_fops,
1344 .ioctl_ops = &rtl2832_sdr_ioctl_ops,
1345};
1346
1347static int rtl2832_sdr_s_ctrl(struct v4l2_ctrl *ctrl)
1348{
1349 struct rtl2832_sdr_state *s =
1350 container_of(ctrl->handler, struct rtl2832_sdr_state,
1351 hdl);
1352 struct dvb_frontend *fe = s->fe;
1353 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
1354 int ret;
1355
1356 dev_dbg(&s->udev->dev,
1357 "%s: id=%d name=%s val=%d min=%lld max=%lld step=%lld\n",
1358 __func__, ctrl->id, ctrl->name, ctrl->val,
1359 ctrl->minimum, ctrl->maximum, ctrl->step);
1360
1361 switch (ctrl->id) {
1362 case V4L2_CID_RF_TUNER_BANDWIDTH_AUTO:
1363 case V4L2_CID_RF_TUNER_BANDWIDTH:
1364 /* TODO: these controls should be moved to tuner drivers */
1365 if (s->bandwidth_auto->val) {
1366 /* Round towards the closest legal value */
1367 s32 val = s->f_adc + div_u64(s->bandwidth->step, 2);
1368 u32 offset;
1369
1370 val = clamp_t(s32, val, s->bandwidth->minimum,
1371 s->bandwidth->maximum);
1372 offset = val - s->bandwidth->minimum;
1373 offset = s->bandwidth->step *
1374 div_u64(offset, s->bandwidth->step);
1375 s->bandwidth->val = s->bandwidth->minimum + offset;
1376 }
1377 c->bandwidth_hz = s->bandwidth->val;
1378
1379 if (!test_bit(POWER_ON, &s->flags))
1380 return 0;
1381
1382 if (fe->ops.tuner_ops.set_params)
1383 ret = fe->ops.tuner_ops.set_params(fe);
1384 else
1385 ret = 0;
1386 break;
1387 default:
1388 ret = -EINVAL;
1389 }
1390
1391 return ret;
1392}
1393
1394static const struct v4l2_ctrl_ops rtl2832_sdr_ctrl_ops = {
1395 .s_ctrl = rtl2832_sdr_s_ctrl,
1396};
1397
1398static void rtl2832_sdr_video_release(struct v4l2_device *v)
1399{
1400 struct rtl2832_sdr_state *s =
1401 container_of(v, struct rtl2832_sdr_state, v4l2_dev);
1402
1403 v4l2_ctrl_handler_free(&s->hdl);
1404 v4l2_device_unregister(&s->v4l2_dev);
1405 kfree(s);
1406}
1407
1408struct dvb_frontend *rtl2832_sdr_attach(struct dvb_frontend *fe,
1409 struct i2c_adapter *i2c, const struct rtl2832_config *cfg,
1410 struct v4l2_subdev *sd)
1411{
1412 int ret;
1413 struct rtl2832_sdr_state *s;
1414 const struct v4l2_ctrl_ops *ops = &rtl2832_sdr_ctrl_ops;
1415 struct dvb_usb_device *d = i2c_get_adapdata(i2c);
1416
1417 s = kzalloc(sizeof(struct rtl2832_sdr_state), GFP_KERNEL);
1418 if (s == NULL) {
1419 dev_err(&d->udev->dev,
1420 "Could not allocate memory for rtl2832_sdr_state\n");
1421 return NULL;
1422 }
1423
1424 /* setup the state */
1425 s->fe = fe;
1426 s->d = d;
1427 s->udev = d->udev;
1428 s->i2c = i2c;
1429 s->cfg = cfg;
1430 s->f_adc = bands_adc[0].rangelow;
1431 s->f_tuner = bands_fm[0].rangelow;
1432 s->pixelformat = formats[0].pixelformat;
1433 s->buffersize = formats[0].buffersize;
1434 s->num_formats = NUM_FORMATS;
1435 if (rtl2832_sdr_emulated_fmt == false)
1436 s->num_formats -= 1;
1437
1438 mutex_init(&s->v4l2_lock);
1439 mutex_init(&s->vb_queue_lock);
1440 spin_lock_init(&s->queued_bufs_lock);
1441 INIT_LIST_HEAD(&s->queued_bufs);
1442
1443 /* Init videobuf2 queue structure */
1444 s->vb_queue.type = V4L2_BUF_TYPE_SDR_CAPTURE;
1445 s->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1446 s->vb_queue.drv_priv = s;
1447 s->vb_queue.buf_struct_size = sizeof(struct rtl2832_sdr_frame_buf);
1448 s->vb_queue.ops = &rtl2832_sdr_vb2_ops;
1449 s->vb_queue.mem_ops = &vb2_vmalloc_memops;
1450 s->vb_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1451 ret = vb2_queue_init(&s->vb_queue);
1452 if (ret) {
1453 dev_err(&s->udev->dev, "Could not initialize vb2 queue\n");
1454 goto err_free_mem;
1455 }
1456
1457 /* Register controls */
1458 switch (s->cfg->tuner) {
1459 case RTL2832_TUNER_E4000:
1460 v4l2_ctrl_handler_init(&s->hdl, 9);
1461 if (sd)
1462 v4l2_ctrl_add_handler(&s->hdl, sd->ctrl_handler, NULL);
1463 break;
1464 case RTL2832_TUNER_R820T:
1465 v4l2_ctrl_handler_init(&s->hdl, 2);
1466 s->bandwidth_auto = v4l2_ctrl_new_std(&s->hdl, ops,
1467 V4L2_CID_RF_TUNER_BANDWIDTH_AUTO,
1468 0, 1, 1, 1);
1469 s->bandwidth = v4l2_ctrl_new_std(&s->hdl, ops,
1470 V4L2_CID_RF_TUNER_BANDWIDTH,
1471 0, 8000000, 100000, 0);
1472 v4l2_ctrl_auto_cluster(2, &s->bandwidth_auto, 0, false);
1473 break;
1474 case RTL2832_TUNER_FC0012:
1475 case RTL2832_TUNER_FC0013:
1476 v4l2_ctrl_handler_init(&s->hdl, 2);
1477 s->bandwidth_auto = v4l2_ctrl_new_std(&s->hdl, ops,
1478 V4L2_CID_RF_TUNER_BANDWIDTH_AUTO,
1479 0, 1, 1, 1);
1480 s->bandwidth = v4l2_ctrl_new_std(&s->hdl, ops,
1481 V4L2_CID_RF_TUNER_BANDWIDTH,
1482 6000000, 8000000, 1000000,
1483 6000000);
1484 v4l2_ctrl_auto_cluster(2, &s->bandwidth_auto, 0, false);
1485 break;
1486 default:
1487 v4l2_ctrl_handler_init(&s->hdl, 0);
1488 dev_notice(&s->udev->dev, "%s: Unsupported tuner\n",
1489 KBUILD_MODNAME);
1490 goto err_free_controls;
1491 }
1492
1493 if (s->hdl.error) {
1494 ret = s->hdl.error;
1495 dev_err(&s->udev->dev, "Could not initialize controls\n");
1496 goto err_free_controls;
1497 }
1498
1499 /* Init video_device structure */
1500 s->vdev = rtl2832_sdr_template;
1501 s->vdev.queue = &s->vb_queue;
1502 s->vdev.queue->lock = &s->vb_queue_lock;
1503 video_set_drvdata(&s->vdev, s);
1504
1505 /* Register the v4l2_device structure */
1506 s->v4l2_dev.release = rtl2832_sdr_video_release;
1507 ret = v4l2_device_register(&s->udev->dev, &s->v4l2_dev);
1508 if (ret) {
1509 dev_err(&s->udev->dev,
1510 "Failed to register v4l2-device (%d)\n", ret);
1511 goto err_free_controls;
1512 }
1513
1514 s->v4l2_dev.ctrl_handler = &s->hdl;
1515 s->vdev.v4l2_dev = &s->v4l2_dev;
1516 s->vdev.lock = &s->v4l2_lock;
1517 s->vdev.vfl_dir = VFL_DIR_RX;
1518
1519 ret = video_register_device(&s->vdev, VFL_TYPE_SDR, -1);
1520 if (ret) {
1521 dev_err(&s->udev->dev,
1522 "Failed to register as video device (%d)\n",
1523 ret);
1524 goto err_unregister_v4l2_dev;
1525 }
1526 dev_info(&s->udev->dev, "Registered as %s\n",
1527 video_device_node_name(&s->vdev));
1528
1529 fe->sec_priv = s;
1530 fe->ops.release_sec = rtl2832_sdr_release_sec;
1531
1532 dev_info(&s->i2c->dev, "%s: Realtek RTL2832 SDR attached\n",
1533 KBUILD_MODNAME);
1534 dev_notice(&s->udev->dev,
1535 "%s: SDR API is still slightly experimental and functionality changes may follow\n",
1536 KBUILD_MODNAME);
1537 return fe;
1538
1539err_unregister_v4l2_dev:
1540 v4l2_device_unregister(&s->v4l2_dev);
1541err_free_controls:
1542 v4l2_ctrl_handler_free(&s->hdl);
1543err_free_mem:
1544 kfree(s);
1545 return NULL;
1546}
1547EXPORT_SYMBOL(rtl2832_sdr_attach);
1548
1549MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1550MODULE_DESCRIPTION("Realtek RTL2832 SDR driver");
1551MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb-frontends/rtl2832_sdr.h b/drivers/media/dvb-frontends/rtl2832_sdr.h
new file mode 100644
index 000000000000..b865fadf184f
--- /dev/null
+++ b/drivers/media/dvb-frontends/rtl2832_sdr.h
@@ -0,0 +1,54 @@
1/*
2 * Realtek RTL2832U SDR driver
3 *
4 * Copyright (C) 2013 Antti Palosaari <crope@iki.fi>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License along
17 * with this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * GNU Radio plugin "gr-kernel" for device usage will be on:
21 * http://git.linuxtv.org/anttip/gr-kernel.git
22 *
23 * TODO:
24 * Help is very highly welcome for these + all the others you could imagine:
25 * - move controls to V4L2 API
26 * - use libv4l2 for stream format conversions
27 * - gr-kernel: switch to v4l2_mmap (current read eats a lot of cpu)
28 * - SDRSharp support
29 */
30
31#ifndef RTL2832_SDR_H
32#define RTL2832_SDR_H
33
34#include <linux/kconfig.h>
35#include <media/v4l2-subdev.h>
36
37/* for config struct */
38#include "rtl2832.h"
39
40#if IS_ENABLED(CONFIG_DVB_RTL2832_SDR)
41extern struct dvb_frontend *rtl2832_sdr_attach(struct dvb_frontend *fe,
42 struct i2c_adapter *i2c, const struct rtl2832_config *cfg,
43 struct v4l2_subdev *sd);
44#else
45static inline struct dvb_frontend *rtl2832_sdr_attach(struct dvb_frontend *fe,
46 struct i2c_adapter *i2c, const struct rtl2832_config *cfg,
47 struct v4l2_subdev *sd)
48{
49 dev_warn(&i2c->dev, "%s: driver disabled by Kconfig\n", __func__);
50 return NULL;
51}
52#endif
53
54#endif /* RTL2832_SDR_H */
diff --git a/drivers/media/dvb-frontends/si2165.c b/drivers/media/dvb-frontends/si2165.c
new file mode 100644
index 000000000000..3a2d6c5aded6
--- /dev/null
+++ b/drivers/media/dvb-frontends/si2165.c
@@ -0,0 +1,1040 @@
1/*
2 Driver for Silicon Labs SI2165 DVB-C/-T Demodulator
3
4 Copyright (C) 2013-2014 Matthias Schwarzott <zzam@gentoo.org>
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 References:
17 http://www.silabs.com/Support%20Documents/TechnicalDocs/Si2165-short.pdf
18*/
19
20#include <linux/delay.h>
21#include <linux/errno.h>
22#include <linux/init.h>
23#include <linux/kernel.h>
24#include <linux/module.h>
25#include <linux/string.h>
26#include <linux/slab.h>
27#include <linux/firmware.h>
28
29#include "dvb_frontend.h"
30#include "dvb_math.h"
31#include "si2165_priv.h"
32#include "si2165.h"
33
34/* Hauppauge WinTV-HVR-930C-HD B130 / PCTV QuatroStick 521e 1113xx
35 * uses 16 MHz xtal */
36
37/* Hauppauge WinTV-HVR-930C-HD B131 / PCTV QuatroStick 522e 1114xx
38 * uses 24 MHz clock provided by tuner */
39
40struct si2165_state {
41 struct i2c_adapter *i2c;
42
43 struct dvb_frontend frontend;
44
45 struct si2165_config config;
46
47 /* chip revision */
48 u8 revcode;
49 /* chip type */
50 u8 chip_type;
51
52 /* calculated by xtal and div settings */
53 u32 fvco_hz;
54 u32 sys_clk;
55 u32 adc_clk;
56
57 bool has_dvbc;
58 bool has_dvbt;
59 bool firmware_loaded;
60};
61
62#define DEBUG_OTHER 0x01
63#define DEBUG_I2C_WRITE 0x02
64#define DEBUG_I2C_READ 0x04
65#define DEBUG_REG_READ 0x08
66#define DEBUG_REG_WRITE 0x10
67#define DEBUG_FW_LOAD 0x20
68
69static int debug = 0x00;
70
71#define dprintk(args...) \
72 do { \
73 if (debug & DEBUG_OTHER) \
74 printk(KERN_DEBUG "si2165: " args); \
75 } while (0)
76
77#define deb_i2c_write(args...) \
78 do { \
79 if (debug & DEBUG_I2C_WRITE) \
80 printk(KERN_DEBUG "si2165: i2c write: " args); \
81 } while (0)
82
83#define deb_i2c_read(args...) \
84 do { \
85 if (debug & DEBUG_I2C_READ) \
86 printk(KERN_DEBUG "si2165: i2c read: " args); \
87 } while (0)
88
89#define deb_readreg(args...) \
90 do { \
91 if (debug & DEBUG_REG_READ) \
92 printk(KERN_DEBUG "si2165: reg read: " args); \
93 } while (0)
94
95#define deb_writereg(args...) \
96 do { \
97 if (debug & DEBUG_REG_WRITE) \
98 printk(KERN_DEBUG "si2165: reg write: " args); \
99 } while (0)
100
101#define deb_fw_load(args...) \
102 do { \
103 if (debug & DEBUG_FW_LOAD) \
104 printk(KERN_DEBUG "si2165: fw load: " args); \
105 } while (0)
106
107static int si2165_write(struct si2165_state *state, const u16 reg,
108 const u8 *src, const int count)
109{
110 int ret;
111 struct i2c_msg msg;
112 u8 buf[2 + 4]; /* write a maximum of 4 bytes of data */
113
114 if (count + 2 > sizeof(buf)) {
115 dev_warn(&state->i2c->dev,
116 "%s: i2c wr reg=%04x: count=%d is too big!\n",
117 KBUILD_MODNAME, reg, count);
118 return -EINVAL;
119 }
120 buf[0] = reg >> 8;
121 buf[1] = reg & 0xff;
122 memcpy(buf + 2, src, count);
123
124 msg.addr = state->config.i2c_addr;
125 msg.flags = 0;
126 msg.buf = buf;
127 msg.len = count + 2;
128
129 if (debug & DEBUG_I2C_WRITE)
130 deb_i2c_write("reg: 0x%04x, data: %*ph\n", reg, count, src);
131
132 ret = i2c_transfer(state->i2c, &msg, 1);
133
134 if (ret != 1) {
135 dev_err(&state->i2c->dev, "%s: ret == %d\n", __func__, ret);
136 if (ret < 0)
137 return ret;
138 else
139 return -EREMOTEIO;
140 }
141
142 return 0;
143}
144
145static int si2165_read(struct si2165_state *state,
146 const u16 reg, u8 *val, const int count)
147{
148 int ret;
149 u8 reg_buf[] = { reg >> 8, reg & 0xff };
150 struct i2c_msg msg[] = {
151 { .addr = state->config.i2c_addr,
152 .flags = 0, .buf = reg_buf, .len = 2 },
153 { .addr = state->config.i2c_addr,
154 .flags = I2C_M_RD, .buf = val, .len = count },
155 };
156
157 ret = i2c_transfer(state->i2c, msg, 2);
158
159 if (ret != 2) {
160 dev_err(&state->i2c->dev, "%s: error (addr %02x reg %04x error (ret == %i)\n",
161 __func__, state->config.i2c_addr, reg, ret);
162 if (ret < 0)
163 return ret;
164 else
165 return -EREMOTEIO;
166 }
167
168 if (debug & DEBUG_I2C_READ)
169 deb_i2c_read("reg: 0x%04x, data: %*ph\n", reg, count, val);
170
171 return 0;
172}
173
174static int si2165_readreg8(struct si2165_state *state,
175 const u16 reg, u8 *val)
176{
177 int ret;
178
179 ret = si2165_read(state, reg, val, 1);
180 deb_readreg("R(0x%04x)=0x%02x\n", reg, *val);
181 return ret;
182}
183
184static int si2165_readreg16(struct si2165_state *state,
185 const u16 reg, u16 *val)
186{
187 u8 buf[2];
188
189 int ret = si2165_read(state, reg, buf, 2);
190 *val = buf[0] | buf[1] << 8;
191 deb_readreg("R(0x%04x)=0x%04x\n", reg, *val);
192 return ret;
193}
194
195static int si2165_writereg8(struct si2165_state *state, const u16 reg, u8 val)
196{
197 return si2165_write(state, reg, &val, 1);
198}
199
200static int si2165_writereg16(struct si2165_state *state, const u16 reg, u16 val)
201{
202 u8 buf[2] = { val & 0xff, (val >> 8) & 0xff };
203
204 return si2165_write(state, reg, buf, 2);
205}
206
207static int si2165_writereg24(struct si2165_state *state, const u16 reg, u32 val)
208{
209 u8 buf[3] = { val & 0xff, (val >> 8) & 0xff, (val >> 16) & 0xff };
210
211 return si2165_write(state, reg, buf, 3);
212}
213
214static int si2165_writereg32(struct si2165_state *state, const u16 reg, u32 val)
215{
216 u8 buf[4] = {
217 val & 0xff,
218 (val >> 8) & 0xff,
219 (val >> 16) & 0xff,
220 (val >> 24) & 0xff
221 };
222 return si2165_write(state, reg, buf, 4);
223}
224
225static int si2165_writereg_mask8(struct si2165_state *state, const u16 reg,
226 u8 val, u8 mask)
227{
228 int ret;
229 u8 tmp;
230
231 if (mask != 0xff) {
232 ret = si2165_readreg8(state, reg, &tmp);
233 if (ret < 0)
234 goto err;
235
236 val &= mask;
237 tmp &= ~mask;
238 val |= tmp;
239 }
240
241 ret = si2165_writereg8(state, reg, val);
242err:
243 return ret;
244}
245
246static int si2165_get_tune_settings(struct dvb_frontend *fe,
247 struct dvb_frontend_tune_settings *s)
248{
249 s->min_delay_ms = 1000;
250 return 0;
251}
252
253static int si2165_init_pll(struct si2165_state *state)
254{
255 u32 ref_freq_Hz = state->config.ref_freq_Hz;
256 u8 divr = 1; /* 1..7 */
257 u8 divp = 1; /* only 1 or 4 */
258 u8 divn = 56; /* 1..63 */
259 u8 divm = 8;
260 u8 divl = 12;
261 u8 buf[4];
262
263 /* hardcoded values can be deleted if calculation is verified
264 * or it yields the same values as the windows driver */
265 switch (ref_freq_Hz) {
266 case 16000000u:
267 divn = 56;
268 break;
269 case 24000000u:
270 divr = 2;
271 divp = 4;
272 divn = 19;
273 break;
274 default:
275 /* ref_freq / divr must be between 4 and 16 MHz */
276 if (ref_freq_Hz > 16000000u)
277 divr = 2;
278
279 /* now select divn and divp such that
280 * fvco is in 1624..1824 MHz */
281 if (1624000000u * divr > ref_freq_Hz * 2u * 63u)
282 divp = 4;
283
284 /* is this already correct regarding rounding? */
285 divn = 1624000000u * divr / (ref_freq_Hz * 2u * divp);
286 break;
287 }
288
289 /* adc_clk and sys_clk depend on xtal and pll settings */
290 state->fvco_hz = ref_freq_Hz / divr
291 * 2u * divn * divp;
292 state->adc_clk = state->fvco_hz / (divm * 4u);
293 state->sys_clk = state->fvco_hz / (divl * 2u);
294
295 /* write pll registers 0x00a0..0x00a3 at once */
296 buf[0] = divl;
297 buf[1] = divm;
298 buf[2] = (divn & 0x3f) | ((divp == 1) ? 0x40 : 0x00) | 0x80;
299 buf[3] = divr;
300 return si2165_write(state, 0x00a0, buf, 4);
301}
302
303static int si2165_adjust_pll_divl(struct si2165_state *state, u8 divl)
304{
305 state->sys_clk = state->fvco_hz / (divl * 2u);
306 return si2165_writereg8(state, 0x00a0, divl); /* pll_divl */
307}
308
309static u32 si2165_get_fe_clk(struct si2165_state *state)
310{
311 /* assume Oversampling mode Ovr4 is used */
312 return state->adc_clk;
313}
314
315static bool si2165_wait_init_done(struct si2165_state *state)
316{
317 int ret = -EINVAL;
318 u8 val = 0;
319 int i;
320
321 for (i = 0; i < 3; ++i) {
322 si2165_readreg8(state, 0x0054, &val);
323 if (val == 0x01)
324 return 0;
325 usleep_range(1000, 50000);
326 }
327 dev_err(&state->i2c->dev, "%s: init_done was not set\n",
328 KBUILD_MODNAME);
329 return ret;
330}
331
332static int si2165_upload_firmware_block(struct si2165_state *state,
333 const u8 *data, u32 len, u32 *poffset, u32 block_count)
334{
335 int ret;
336 u8 buf_ctrl[4] = { 0x00, 0x00, 0x00, 0xc0 };
337 u8 wordcount;
338 u32 cur_block = 0;
339 u32 offset = poffset ? *poffset : 0;
340
341 if (len < 4)
342 return -EINVAL;
343 if (len % 4 != 0)
344 return -EINVAL;
345
346 deb_fw_load("si2165_upload_firmware_block called with len=0x%x offset=0x%x blockcount=0x%x\n",
347 len, offset, block_count);
348 while (offset+12 <= len && cur_block < block_count) {
349 deb_fw_load("si2165_upload_firmware_block in while len=0x%x offset=0x%x cur_block=0x%x blockcount=0x%x\n",
350 len, offset, cur_block, block_count);
351 wordcount = data[offset];
352 if (wordcount < 1 || data[offset+1] ||
353 data[offset+2] || data[offset+3]) {
354 dev_warn(&state->i2c->dev,
355 "%s: bad fw data[0..3] = %*ph\n",
356 KBUILD_MODNAME, 4, data);
357 return -EINVAL;
358 }
359
360 if (offset + 8 + wordcount * 4 > len) {
361 dev_warn(&state->i2c->dev,
362 "%s: len is too small for block len=%d, wordcount=%d\n",
363 KBUILD_MODNAME, len, wordcount);
364 return -EINVAL;
365 }
366
367 buf_ctrl[0] = wordcount - 1;
368
369 ret = si2165_write(state, 0x0364, buf_ctrl, 4);
370 if (ret < 0)
371 goto error;
372 ret = si2165_write(state, 0x0368, data+offset+4, 4);
373 if (ret < 0)
374 goto error;
375
376 offset += 8;
377
378 while (wordcount > 0) {
379 ret = si2165_write(state, 0x36c, data+offset, 4);
380 if (ret < 0)
381 goto error;
382 wordcount--;
383 offset += 4;
384 }
385 cur_block++;
386 }
387
388 deb_fw_load("si2165_upload_firmware_block after while len=0x%x offset=0x%x cur_block=0x%x blockcount=0x%x\n",
389 len, offset, cur_block, block_count);
390
391 if (poffset)
392 *poffset = offset;
393
394 deb_fw_load("si2165_upload_firmware_block returned offset=0x%x\n",
395 offset);
396
397 return 0;
398error:
399 return ret;
400}
401
402static int si2165_upload_firmware(struct si2165_state *state)
403{
404 /* int ret; */
405 u8 val[3];
406 u16 val16;
407 int ret;
408
409 const struct firmware *fw = NULL;
410 u8 *fw_file = SI2165_FIRMWARE;
411 const u8 *data;
412 u32 len;
413 u32 offset;
414 u8 patch_version;
415 u8 block_count;
416 u16 crc_expected;
417
418 /* request the firmware, this will block and timeout */
419 ret = request_firmware(&fw, fw_file, state->i2c->dev.parent);
420 if (ret) {
421 dev_warn(&state->i2c->dev, "%s: firmare file '%s' not found\n",
422 KBUILD_MODNAME, fw_file);
423 goto error;
424 }
425
426 data = fw->data;
427 len = fw->size;
428
429 dev_info(&state->i2c->dev, "%s: downloading firmware from file '%s' size=%d\n",
430 KBUILD_MODNAME, fw_file, len);
431
432 if (len % 4 != 0) {
433 dev_warn(&state->i2c->dev, "%s: firmware size is not multiple of 4\n",
434 KBUILD_MODNAME);
435 ret = -EINVAL;
436 goto error;
437 }
438
439 /* check header (8 bytes) */
440 if (len < 8) {
441 dev_warn(&state->i2c->dev, "%s: firmware header is missing\n",
442 KBUILD_MODNAME);
443 ret = -EINVAL;
444 goto error;
445 }
446
447 if (data[0] != 1 || data[1] != 0) {
448 dev_warn(&state->i2c->dev, "%s: firmware file version is wrong\n",
449 KBUILD_MODNAME);
450 ret = -EINVAL;
451 goto error;
452 }
453
454 patch_version = data[2];
455 block_count = data[4];
456 crc_expected = data[7] << 8 | data[6];
457
458 /* start uploading fw */
459 /* boot/wdog status */
460 ret = si2165_writereg8(state, 0x0341, 0x00);
461 if (ret < 0)
462 goto error;
463 /* reset */
464 ret = si2165_writereg8(state, 0x00c0, 0x00);
465 if (ret < 0)
466 goto error;
467 /* boot/wdog status */
468 ret = si2165_readreg8(state, 0x0341, val);
469 if (ret < 0)
470 goto error;
471
472 /* enable reset on error */
473 ret = si2165_readreg8(state, 0x035c, val);
474 if (ret < 0)
475 goto error;
476 ret = si2165_readreg8(state, 0x035c, val);
477 if (ret < 0)
478 goto error;
479 ret = si2165_writereg8(state, 0x035c, 0x02);
480 if (ret < 0)
481 goto error;
482
483 /* start right after the header */
484 offset = 8;
485
486 dev_info(&state->i2c->dev, "%s: si2165_upload_firmware extracted patch_version=0x%02x, block_count=0x%02x, crc_expected=0x%04x\n",
487 KBUILD_MODNAME, patch_version, block_count, crc_expected);
488
489 ret = si2165_upload_firmware_block(state, data, len, &offset, 1);
490 if (ret < 0)
491 goto error;
492
493 ret = si2165_writereg8(state, 0x0344, patch_version);
494 if (ret < 0)
495 goto error;
496
497 /* reset crc */
498 ret = si2165_writereg8(state, 0x0379, 0x01);
499 if (ret)
500 return ret;
501
502 ret = si2165_upload_firmware_block(state, data, len,
503 &offset, block_count);
504 if (ret < 0) {
505 dev_err(&state->i2c->dev,
506 "%s: firmare could not be uploaded\n",
507 KBUILD_MODNAME);
508 goto error;
509 }
510
511 /* read crc */
512 ret = si2165_readreg16(state, 0x037a, &val16);
513 if (ret)
514 goto error;
515
516 if (val16 != crc_expected) {
517 dev_err(&state->i2c->dev,
518 "%s: firmware crc mismatch %04x != %04x\n",
519 KBUILD_MODNAME, val16, crc_expected);
520 ret = -EINVAL;
521 goto error;
522 }
523
524 ret = si2165_upload_firmware_block(state, data, len, &offset, 5);
525 if (ret)
526 goto error;
527
528 if (len != offset) {
529 dev_err(&state->i2c->dev,
530 "%s: firmare len mismatch %04x != %04x\n",
531 KBUILD_MODNAME, len, offset);
532 ret = -EINVAL;
533 goto error;
534 }
535
536 /* reset watchdog error register */
537 ret = si2165_writereg_mask8(state, 0x0341, 0x02, 0x02);
538 if (ret < 0)
539 goto error;
540
541 /* enable reset on error */
542 ret = si2165_writereg_mask8(state, 0x035c, 0x01, 0x01);
543 if (ret < 0)
544 goto error;
545
546 dev_info(&state->i2c->dev, "%s: fw load finished\n", KBUILD_MODNAME);
547
548 ret = 0;
549 state->firmware_loaded = true;
550error:
551 if (fw) {
552 release_firmware(fw);
553 fw = NULL;
554 }
555
556 return ret;
557}
558
559static int si2165_init(struct dvb_frontend *fe)
560{
561 int ret = 0;
562 struct si2165_state *state = fe->demodulator_priv;
563 u8 val;
564 u8 patch_version = 0x00;
565
566 dprintk("%s: called\n", __func__);
567
568 /* powerup */
569 ret = si2165_writereg8(state, 0x0000, state->config.chip_mode);
570 if (ret < 0)
571 goto error;
572 /* dsp_clock_enable */
573 ret = si2165_writereg8(state, 0x0104, 0x01);
574 if (ret < 0)
575 goto error;
576 ret = si2165_readreg8(state, 0x0000, &val); /* verify chip_mode */
577 if (ret < 0)
578 goto error;
579 if (val != state->config.chip_mode) {
580 dev_err(&state->i2c->dev, "%s: could not set chip_mode\n",
581 KBUILD_MODNAME);
582 return -EINVAL;
583 }
584
585 /* agc */
586 ret = si2165_writereg8(state, 0x018b, 0x00);
587 if (ret < 0)
588 goto error;
589 ret = si2165_writereg8(state, 0x0190, 0x01);
590 if (ret < 0)
591 goto error;
592 ret = si2165_writereg8(state, 0x0170, 0x00);
593 if (ret < 0)
594 goto error;
595 ret = si2165_writereg8(state, 0x0171, 0x07);
596 if (ret < 0)
597 goto error;
598 /* rssi pad */
599 ret = si2165_writereg8(state, 0x0646, 0x00);
600 if (ret < 0)
601 goto error;
602 ret = si2165_writereg8(state, 0x0641, 0x00);
603 if (ret < 0)
604 goto error;
605
606 ret = si2165_init_pll(state);
607 if (ret < 0)
608 goto error;
609
610 /* enable chip_init */
611 ret = si2165_writereg8(state, 0x0050, 0x01);
612 if (ret < 0)
613 goto error;
614 /* set start_init */
615 ret = si2165_writereg8(state, 0x0096, 0x01);
616 if (ret < 0)
617 goto error;
618 ret = si2165_wait_init_done(state);
619 if (ret < 0)
620 goto error;
621
622 /* disable chip_init */
623 ret = si2165_writereg8(state, 0x0050, 0x00);
624 if (ret < 0)
625 goto error;
626
627 /* ber_pkt */
628 ret = si2165_writereg16(state, 0x0470 , 0x7530);
629 if (ret < 0)
630 goto error;
631
632 ret = si2165_readreg8(state, 0x0344, &patch_version);
633 if (ret < 0)
634 goto error;
635
636 ret = si2165_writereg8(state, 0x00cb, 0x00);
637 if (ret < 0)
638 goto error;
639
640 /* dsp_addr_jump */
641 ret = si2165_writereg32(state, 0x0348, 0xf4000000);
642 if (ret < 0)
643 goto error;
644 /* boot/wdog status */
645 ret = si2165_readreg8(state, 0x0341, &val);
646 if (ret < 0)
647 goto error;
648
649 if (patch_version == 0x00) {
650 ret = si2165_upload_firmware(state);
651 if (ret < 0)
652 goto error;
653 }
654
655 /* write adc values after each reset*/
656 ret = si2165_writereg8(state, 0x012a, 0x46);
657 if (ret < 0)
658 goto error;
659 ret = si2165_writereg8(state, 0x012c, 0x00);
660 if (ret < 0)
661 goto error;
662 ret = si2165_writereg8(state, 0x012e, 0x0a);
663 if (ret < 0)
664 goto error;
665 ret = si2165_writereg8(state, 0x012f, 0xff);
666 if (ret < 0)
667 goto error;
668 ret = si2165_writereg8(state, 0x0123, 0x70);
669 if (ret < 0)
670 goto error;
671
672 return 0;
673error:
674 return ret;
675}
676
677static int si2165_sleep(struct dvb_frontend *fe)
678{
679 int ret;
680 struct si2165_state *state = fe->demodulator_priv;
681
682 /* dsp clock disable */
683 ret = si2165_writereg8(state, 0x0104, 0x00);
684 if (ret < 0)
685 return ret;
686 /* chip mode */
687 ret = si2165_writereg8(state, 0x0000, SI2165_MODE_OFF);
688 if (ret < 0)
689 return ret;
690 return 0;
691}
692
693static int si2165_read_status(struct dvb_frontend *fe, fe_status_t *status)
694{
695 int ret;
696 u8 fec_lock = 0;
697 struct si2165_state *state = fe->demodulator_priv;
698
699 if (!state->has_dvbt)
700 return -EINVAL;
701
702 /* check fec_lock */
703 ret = si2165_readreg8(state, 0x4e0, &fec_lock);
704 if (ret < 0)
705 return ret;
706 *status = 0;
707 if (fec_lock & 0x01) {
708 *status |= FE_HAS_SIGNAL;
709 *status |= FE_HAS_CARRIER;
710 *status |= FE_HAS_VITERBI;
711 *status |= FE_HAS_SYNC;
712 *status |= FE_HAS_LOCK;
713 }
714
715 return 0;
716}
717
718static int si2165_set_oversamp(struct si2165_state *state, u32 dvb_rate)
719{
720 u64 oversamp;
721 u32 reg_value;
722
723 oversamp = si2165_get_fe_clk(state);
724 oversamp <<= 23;
725 do_div(oversamp, dvb_rate);
726 reg_value = oversamp & 0x3fffffff;
727
728 /* oversamp, usbdump contained 0x03100000; */
729 return si2165_writereg32(state, 0x00e4, reg_value);
730}
731
732static int si2165_set_if_freq_shift(struct si2165_state *state, u32 IF)
733{
734 u64 if_freq_shift;
735 s32 reg_value = 0;
736 u32 fe_clk = si2165_get_fe_clk(state);
737
738 if_freq_shift = IF;
739 if_freq_shift <<= 29;
740
741 do_div(if_freq_shift, fe_clk);
742 reg_value = (s32)if_freq_shift;
743
744 if (state->config.inversion)
745 reg_value = -reg_value;
746
747 reg_value = reg_value & 0x1fffffff;
748
749 /* if_freq_shift, usbdump contained 0x023ee08f; */
750 return si2165_writereg32(state, 0x00e8, reg_value);
751}
752
753static int si2165_set_parameters(struct dvb_frontend *fe)
754{
755 int ret;
756 struct dtv_frontend_properties *p = &fe->dtv_property_cache;
757 struct si2165_state *state = fe->demodulator_priv;
758 u8 val[3];
759 u32 IF;
760 u32 dvb_rate = 0;
761 u16 bw10k;
762
763 dprintk("%s: called\n", __func__);
764
765 if (!fe->ops.tuner_ops.get_if_frequency) {
766 dev_err(&state->i2c->dev,
767 "%s: Error: get_if_frequency() not defined at tuner. Can't work without it!\n",
768 KBUILD_MODNAME);
769 return -EINVAL;
770 }
771
772 if (!state->has_dvbt)
773 return -EINVAL;
774
775 if (p->bandwidth_hz > 0) {
776 dvb_rate = p->bandwidth_hz * 8 / 7;
777 bw10k = p->bandwidth_hz / 10000;
778 } else {
779 dvb_rate = 8 * 8 / 7;
780 bw10k = 800;
781 }
782
783 /* standard = DVB-T */
784 ret = si2165_writereg8(state, 0x00ec, 0x01);
785 if (ret < 0)
786 return ret;
787 ret = si2165_adjust_pll_divl(state, 12);
788 if (ret < 0)
789 return ret;
790
791 fe->ops.tuner_ops.get_if_frequency(fe, &IF);
792 ret = si2165_set_if_freq_shift(state, IF);
793 if (ret < 0)
794 return ret;
795 ret = si2165_writereg8(state, 0x08f8, 0x00);
796 if (ret < 0)
797 return ret;
798 /* ts output config */
799 ret = si2165_writereg8(state, 0x04e4, 0x20);
800 if (ret < 0)
801 return ret;
802 ret = si2165_writereg16(state, 0x04ef, 0x00fe);
803 if (ret < 0)
804 return ret;
805 ret = si2165_writereg24(state, 0x04f4, 0x555555);
806 if (ret < 0)
807 return ret;
808 ret = si2165_writereg8(state, 0x04e5, 0x01);
809 if (ret < 0)
810 return ret;
811 /* bandwidth in 10KHz steps */
812 ret = si2165_writereg16(state, 0x0308, bw10k);
813 if (ret < 0)
814 return ret;
815 ret = si2165_set_oversamp(state, dvb_rate);
816 if (ret < 0)
817 return ret;
818 /* impulsive_noise_remover */
819 ret = si2165_writereg8(state, 0x031c, 0x01);
820 if (ret < 0)
821 return ret;
822 ret = si2165_writereg8(state, 0x00cb, 0x00);
823 if (ret < 0)
824 return ret;
825 /* agc2 */
826 ret = si2165_writereg8(state, 0x016e, 0x41);
827 if (ret < 0)
828 return ret;
829 ret = si2165_writereg8(state, 0x016c, 0x0e);
830 if (ret < 0)
831 return ret;
832 ret = si2165_writereg8(state, 0x016d, 0x10);
833 if (ret < 0)
834 return ret;
835 /* agc */
836 ret = si2165_writereg8(state, 0x015b, 0x03);
837 if (ret < 0)
838 return ret;
839 ret = si2165_writereg8(state, 0x0150, 0x78);
840 if (ret < 0)
841 return ret;
842 /* agc */
843 ret = si2165_writereg8(state, 0x01a0, 0x78);
844 if (ret < 0)
845 return ret;
846 ret = si2165_writereg8(state, 0x01c8, 0x68);
847 if (ret < 0)
848 return ret;
849 /* freq_sync_range */
850 ret = si2165_writereg16(state, 0x030c, 0x0064);
851 if (ret < 0)
852 return ret;
853 /* gp_reg0 */
854 ret = si2165_readreg8(state, 0x0387, val);
855 if (ret < 0)
856 return ret;
857 ret = si2165_writereg8(state, 0x0387, 0x00);
858 if (ret < 0)
859 return ret;
860 /* dsp_addr_jump */
861 ret = si2165_writereg32(state, 0x0348, 0xf4000000);
862 if (ret < 0)
863 return ret;
864
865 if (fe->ops.tuner_ops.set_params)
866 fe->ops.tuner_ops.set_params(fe);
867
868 /* recalc if_freq_shift if IF might has changed */
869 fe->ops.tuner_ops.get_if_frequency(fe, &IF);
870 ret = si2165_set_if_freq_shift(state, IF);
871 if (ret < 0)
872 return ret;
873
874 /* boot/wdog status */
875 ret = si2165_readreg8(state, 0x0341, val);
876 if (ret < 0)
877 return ret;
878 ret = si2165_writereg8(state, 0x0341, 0x00);
879 if (ret < 0)
880 return ret;
881 /* reset all */
882 ret = si2165_writereg8(state, 0x00c0, 0x00);
883 if (ret < 0)
884 return ret;
885 /* gp_reg0 */
886 ret = si2165_writereg32(state, 0x0384, 0x00000000);
887 if (ret < 0)
888 return ret;
889 /* start_synchro */
890 ret = si2165_writereg8(state, 0x02e0, 0x01);
891 if (ret < 0)
892 return ret;
893 /* boot/wdog status */
894 ret = si2165_readreg8(state, 0x0341, val);
895 if (ret < 0)
896 return ret;
897
898 return 0;
899}
900
901static void si2165_release(struct dvb_frontend *fe)
902{
903 struct si2165_state *state = fe->demodulator_priv;
904
905 dprintk("%s: called\n", __func__);
906 kfree(state);
907}
908
909static struct dvb_frontend_ops si2165_ops = {
910 .info = {
911 .name = "Silicon Labs Si2165",
912 .caps = FE_CAN_FEC_1_2 |
913 FE_CAN_FEC_2_3 |
914 FE_CAN_FEC_3_4 |
915 FE_CAN_FEC_5_6 |
916 FE_CAN_FEC_7_8 |
917 FE_CAN_FEC_AUTO |
918 FE_CAN_QPSK |
919 FE_CAN_QAM_16 |
920 FE_CAN_QAM_32 |
921 FE_CAN_QAM_64 |
922 FE_CAN_QAM_128 |
923 FE_CAN_QAM_256 |
924 FE_CAN_QAM_AUTO |
925 FE_CAN_TRANSMISSION_MODE_AUTO |
926 FE_CAN_GUARD_INTERVAL_AUTO |
927 FE_CAN_HIERARCHY_AUTO |
928 FE_CAN_MUTE_TS |
929 FE_CAN_TRANSMISSION_MODE_AUTO |
930 FE_CAN_RECOVER
931 },
932
933 .get_tune_settings = si2165_get_tune_settings,
934
935 .init = si2165_init,
936 .sleep = si2165_sleep,
937
938 .set_frontend = si2165_set_parameters,
939 .read_status = si2165_read_status,
940
941 .release = si2165_release,
942};
943
944struct dvb_frontend *si2165_attach(const struct si2165_config *config,
945 struct i2c_adapter *i2c)
946{
947 struct si2165_state *state = NULL;
948 int n;
949 int io_ret;
950 u8 val;
951
952 if (config == NULL || i2c == NULL)
953 goto error;
954
955 /* allocate memory for the internal state */
956 state = kzalloc(sizeof(struct si2165_state), GFP_KERNEL);
957 if (state == NULL)
958 goto error;
959
960 /* setup the state */
961 state->i2c = i2c;
962 state->config = *config;
963
964 if (state->config.ref_freq_Hz < 4000000
965 || state->config.ref_freq_Hz > 27000000) {
966 dev_err(&state->i2c->dev, "%s: ref_freq of %d Hz not supported by this driver\n",
967 KBUILD_MODNAME, state->config.ref_freq_Hz);
968 goto error;
969 }
970
971 /* create dvb_frontend */
972 memcpy(&state->frontend.ops, &si2165_ops,
973 sizeof(struct dvb_frontend_ops));
974 state->frontend.demodulator_priv = state;
975
976 /* powerup */
977 io_ret = si2165_writereg8(state, 0x0000, state->config.chip_mode);
978 if (io_ret < 0)
979 goto error;
980
981 io_ret = si2165_readreg8(state, 0x0000, &val);
982 if (io_ret < 0)
983 goto error;
984 if (val != state->config.chip_mode)
985 goto error;
986
987 io_ret = si2165_readreg8(state, 0x0023 , &state->revcode);
988 if (io_ret < 0)
989 goto error;
990
991 io_ret = si2165_readreg8(state, 0x0118, &state->chip_type);
992 if (io_ret < 0)
993 goto error;
994
995 /* powerdown */
996 io_ret = si2165_writereg8(state, 0x0000, SI2165_MODE_OFF);
997 if (io_ret < 0)
998 goto error;
999
1000 dev_info(&state->i2c->dev, "%s: hardware revision 0x%02x, chip type 0x%02x\n",
1001 KBUILD_MODNAME, state->revcode, state->chip_type);
1002
1003 /* It is a guess that register 0x0118 (chip type?) can be used to
1004 * differ between si2161, si2163 and si2165
1005 * Only si2165 has been tested.
1006 */
1007 if (state->revcode == 0x03 && state->chip_type == 0x07) {
1008 state->has_dvbt = true;
1009 state->has_dvbc = true;
1010 } else {
1011 dev_err(&state->i2c->dev, "%s: Unsupported chip.\n",
1012 KBUILD_MODNAME);
1013 goto error;
1014 }
1015
1016 n = 0;
1017 if (state->has_dvbt) {
1018 state->frontend.ops.delsys[n++] = SYS_DVBT;
1019 strlcat(state->frontend.ops.info.name, " DVB-T",
1020 sizeof(state->frontend.ops.info.name));
1021 }
1022 if (state->has_dvbc)
1023 dev_warn(&state->i2c->dev, "%s: DVB-C is not yet supported.\n",
1024 KBUILD_MODNAME);
1025
1026 return &state->frontend;
1027
1028error:
1029 kfree(state);
1030 return NULL;
1031}
1032EXPORT_SYMBOL(si2165_attach);
1033
1034module_param(debug, int, 0644);
1035MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
1036
1037MODULE_DESCRIPTION("Silicon Labs Si2165 DVB-C/-T Demodulator driver");
1038MODULE_AUTHOR("Matthias Schwarzott <zzam@gentoo.org>");
1039MODULE_LICENSE("GPL");
1040MODULE_FIRMWARE(SI2165_FIRMWARE);
diff --git a/drivers/media/dvb-frontends/si2165.h b/drivers/media/dvb-frontends/si2165.h
new file mode 100644
index 000000000000..efaa08123b92
--- /dev/null
+++ b/drivers/media/dvb-frontends/si2165.h
@@ -0,0 +1,62 @@
1/*
2 Driver for Silicon Labs SI2165 DVB-C/-T Demodulator
3
4 Copyright (C) 2013-2014 Matthias Schwarzott <zzam@gentoo.org>
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 References:
17 http://www.silabs.com/Support%20Documents/TechnicalDocs/Si2165-short.pdf
18*/
19
20#ifndef _DVB_SI2165_H
21#define _DVB_SI2165_H
22
23#include <linux/dvb/frontend.h>
24
25enum {
26 SI2165_MODE_OFF = 0x00,
27 SI2165_MODE_PLL_EXT = 0x20,
28 SI2165_MODE_PLL_XTAL = 0x21
29};
30
31struct si2165_config {
32 /* i2c addr
33 * possible values: 0x64,0x65,0x66,0x67 */
34 u8 i2c_addr;
35
36 /* external clock or XTAL */
37 u8 chip_mode;
38
39 /* frequency of external clock or xtal in Hz
40 * possible values: 4000000, 16000000, 20000000, 240000000, 27000000
41 */
42 u32 ref_freq_Hz;
43
44 /* invert the spectrum */
45 bool inversion;
46};
47
48#if IS_ENABLED(CONFIG_DVB_SI2165)
49struct dvb_frontend *si2165_attach(
50 const struct si2165_config *config,
51 struct i2c_adapter *i2c);
52#else
53static inline struct dvb_frontend *si2165_attach(
54 const struct si2165_config *config,
55 struct i2c_adapter *i2c)
56{
57 pr_warn("%s: driver disabled by Kconfig\n", __func__);
58 return NULL;
59}
60#endif /* CONFIG_DVB_SI2165 */
61
62#endif /* _DVB_SI2165_H */
diff --git a/drivers/media/dvb-frontends/si2165_priv.h b/drivers/media/dvb-frontends/si2165_priv.h
new file mode 100644
index 000000000000..d4cc93fe1096
--- /dev/null
+++ b/drivers/media/dvb-frontends/si2165_priv.h
@@ -0,0 +1,23 @@
1/*
2 Driver for Silicon Labs SI2165 DVB-C/-T Demodulator
3
4 Copyright (C) 2013-2014 Matthias Schwarzott <zzam@gentoo.org>
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16*/
17
18#ifndef _DVB_SI2165_PRIV
19#define _DVB_SI2165_PRIV
20
21#define SI2165_FIRMWARE "dvb-demod-si2165.fw"
22
23#endif /* _DVB_SI2165_PRIV */
diff --git a/drivers/media/dvb-frontends/si2168.c b/drivers/media/dvb-frontends/si2168.c
index 8637d2ed7623..8f81d979de30 100644
--- a/drivers/media/dvb-frontends/si2168.c
+++ b/drivers/media/dvb-frontends/si2168.c
@@ -60,7 +60,7 @@ static int si2168_cmd_execute(struct si2168 *s, struct si2168_cmd *cmd)
60 jiffies_to_msecs(jiffies) - 60 jiffies_to_msecs(jiffies) -
61 (jiffies_to_msecs(timeout) - TIMEOUT)); 61 (jiffies_to_msecs(timeout) - TIMEOUT));
62 62
63 if (!(cmd->args[0] >> 7) & 0x01) { 63 if (!((cmd->args[0] >> 7) & 0x01)) {
64 ret = -ETIMEDOUT; 64 ret = -ETIMEDOUT;
65 goto err_mutex_unlock; 65 goto err_mutex_unlock;
66 } 66 }
@@ -95,20 +95,17 @@ static int si2168_read_status(struct dvb_frontend *fe, fe_status_t *status)
95 95
96 switch (c->delivery_system) { 96 switch (c->delivery_system) {
97 case SYS_DVBT: 97 case SYS_DVBT:
98 cmd.args[0] = 0xa0; 98 memcpy(cmd.args, "\xa0\x01", 2);
99 cmd.args[1] = 0x01;
100 cmd.wlen = 2; 99 cmd.wlen = 2;
101 cmd.rlen = 13; 100 cmd.rlen = 13;
102 break; 101 break;
103 case SYS_DVBC_ANNEX_A: 102 case SYS_DVBC_ANNEX_A:
104 cmd.args[0] = 0x90; 103 memcpy(cmd.args, "\x90\x01", 2);
105 cmd.args[1] = 0x01;
106 cmd.wlen = 2; 104 cmd.wlen = 2;
107 cmd.rlen = 9; 105 cmd.rlen = 9;
108 break; 106 break;
109 case SYS_DVBT2: 107 case SYS_DVBT2:
110 cmd.args[0] = 0x50; 108 memcpy(cmd.args, "\x50\x01", 2);
111 cmd.args[1] = 0x01;
112 cmd.wlen = 2; 109 cmd.wlen = 2;
113 cmd.rlen = 14; 110 cmd.rlen = 14;
114 break; 111 break;
@@ -144,6 +141,15 @@ static int si2168_read_status(struct dvb_frontend *fe, fe_status_t *status)
144 141
145 s->fe_status = *status; 142 s->fe_status = *status;
146 143
144 if (*status & FE_HAS_LOCK) {
145 c->cnr.len = 1;
146 c->cnr.stat[0].scale = FE_SCALE_DECIBEL;
147 c->cnr.stat[0].svalue = cmd.args[3] * 1000 / 4;
148 } else {
149 c->cnr.len = 1;
150 c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
151 }
152
147 dev_dbg(&s->client->dev, "%s: status=%02x args=%*ph\n", 153 dev_dbg(&s->client->dev, "%s: status=%02x args=%*ph\n",
148 __func__, *status, cmd.rlen, cmd.args); 154 __func__, *status, cmd.rlen, cmd.args);
149 155
@@ -243,51 +249,23 @@ static int si2168_set_frontend(struct dvb_frontend *fe)
243 if (ret) 249 if (ret)
244 goto err; 250 goto err;
245 251
246 memcpy(cmd.args, "\x14\x00\x01\x04\x00\x00", 6);
247 cmd.wlen = 6;
248 cmd.rlen = 1;
249 ret = si2168_cmd_execute(s, &cmd);
250 if (ret)
251 goto err;
252
253 memcpy(cmd.args, "\x14\x00\x03\x10\x17\x00", 6);
254 cmd.wlen = 6;
255 cmd.rlen = 1;
256 ret = si2168_cmd_execute(s, &cmd);
257 if (ret)
258 goto err;
259
260 memcpy(cmd.args, "\x14\x00\x02\x10\x15\x00", 6);
261 cmd.wlen = 6;
262 cmd.rlen = 1;
263 ret = si2168_cmd_execute(s, &cmd);
264 if (ret)
265 goto err;
266
267 memcpy(cmd.args, "\x14\x00\x0c\x10\x12\x00", 6); 252 memcpy(cmd.args, "\x14\x00\x0c\x10\x12\x00", 6);
268 cmd.wlen = 6; 253 cmd.wlen = 6;
269 cmd.rlen = 1; 254 cmd.rlen = 4;
270 ret = si2168_cmd_execute(s, &cmd); 255 ret = si2168_cmd_execute(s, &cmd);
271 if (ret) 256 if (ret)
272 goto err; 257 goto err;
273 258
274 memcpy(cmd.args, "\x14\x00\x06\x10\x24\x00", 6); 259 memcpy(cmd.args, "\x14\x00\x06\x10\x24\x00", 6);
275 cmd.wlen = 6; 260 cmd.wlen = 6;
276 cmd.rlen = 1; 261 cmd.rlen = 4;
277 ret = si2168_cmd_execute(s, &cmd);
278 if (ret)
279 goto err;
280
281 memcpy(cmd.args, "\x14\x00\x0b\x10\x88\x13", 6);
282 cmd.wlen = 6;
283 cmd.rlen = 1;
284 ret = si2168_cmd_execute(s, &cmd); 262 ret = si2168_cmd_execute(s, &cmd);
285 if (ret) 263 if (ret)
286 goto err; 264 goto err;
287 265
288 memcpy(cmd.args, "\x14\x00\x07\x10\x00\x24", 6); 266 memcpy(cmd.args, "\x14\x00\x07\x10\x00\x24", 6);
289 cmd.wlen = 6; 267 cmd.wlen = 6;
290 cmd.rlen = 1; 268 cmd.rlen = 4;
291 ret = si2168_cmd_execute(s, &cmd); 269 ret = si2168_cmd_execute(s, &cmd);
292 if (ret) 270 if (ret)
293 goto err; 271 goto err;
@@ -295,124 +273,66 @@ static int si2168_set_frontend(struct dvb_frontend *fe)
295 memcpy(cmd.args, "\x14\x00\x0a\x10\x00\x00", 6); 273 memcpy(cmd.args, "\x14\x00\x0a\x10\x00\x00", 6);
296 cmd.args[4] = delivery_system | bandwidth; 274 cmd.args[4] = delivery_system | bandwidth;
297 cmd.wlen = 6; 275 cmd.wlen = 6;
298 cmd.rlen = 1; 276 cmd.rlen = 4;
299 ret = si2168_cmd_execute(s, &cmd);
300 if (ret)
301 goto err;
302
303 memcpy(cmd.args, "\x14\x00\x04\x10\x15\x00", 6);
304 cmd.wlen = 6;
305 cmd.rlen = 1;
306 ret = si2168_cmd_execute(s, &cmd); 277 ret = si2168_cmd_execute(s, &cmd);
307 if (ret) 278 if (ret)
308 goto err; 279 goto err;
309 280
310 memcpy(cmd.args, "\x14\x00\x05\x10\xa1\x00", 6); 281 /* set DVB-C symbol rate */
311 cmd.wlen = 6; 282 if (c->delivery_system == SYS_DVBC_ANNEX_A) {
312 cmd.rlen = 1; 283 memcpy(cmd.args, "\x14\x00\x02\x11", 4);
313 ret = si2168_cmd_execute(s, &cmd); 284 cmd.args[4] = (c->symbol_rate / 1000) & 0xff;
314 if (ret) 285 cmd.args[5] = ((c->symbol_rate / 1000) >> 8) & 0xff;
315 goto err; 286 cmd.wlen = 6;
287 cmd.rlen = 4;
288 ret = si2168_cmd_execute(s, &cmd);
289 if (ret)
290 goto err;
291 }
316 292
317 memcpy(cmd.args, "\x14\x00\x0f\x10\x10\x00", 6); 293 memcpy(cmd.args, "\x14\x00\x0f\x10\x10\x00", 6);
318 cmd.wlen = 6; 294 cmd.wlen = 6;
319 cmd.rlen = 1; 295 cmd.rlen = 4;
320 ret = si2168_cmd_execute(s, &cmd); 296 ret = si2168_cmd_execute(s, &cmd);
321 if (ret) 297 if (ret)
322 goto err; 298 goto err;
323 299
324 memcpy(cmd.args, "\x14\x00\x0d\x10\xd0\x02", 6); 300 memcpy(cmd.args, "\x14\x00\x01\x10\x16\x00", 6);
325 cmd.wlen = 6;
326 cmd.rlen = 1;
327 ret = si2168_cmd_execute(s, &cmd);
328 if (ret)
329 goto err;
330
331 memcpy(cmd.args, "\x14\x00\x01\x10\x00\x00", 6);
332 cmd.wlen = 6; 301 cmd.wlen = 6;
333 cmd.rlen = 1; 302 cmd.rlen = 4;
334 ret = si2168_cmd_execute(s, &cmd); 303 ret = si2168_cmd_execute(s, &cmd);
335 if (ret) 304 if (ret)
336 goto err; 305 goto err;
337 306
338 memcpy(cmd.args, "\x14\x00\x09\x10\xe3\x18", 6); 307 memcpy(cmd.args, "\x14\x00\x09\x10\xe3\x18", 6);
339 cmd.wlen = 6; 308 cmd.wlen = 6;
340 cmd.rlen = 1; 309 cmd.rlen = 4;
341 ret = si2168_cmd_execute(s, &cmd); 310 ret = si2168_cmd_execute(s, &cmd);
342 if (ret) 311 if (ret)
343 goto err; 312 goto err;
344 313
345 memcpy(cmd.args, "\x14\x00\x08\x10\xd7\x15", 6); 314 memcpy(cmd.args, "\x14\x00\x08\x10\xd7\x15", 6);
346 cmd.wlen = 6; 315 cmd.wlen = 6;
347 cmd.rlen = 1; 316 cmd.rlen = 4;
348 ret = si2168_cmd_execute(s, &cmd);
349 if (ret)
350 goto err;
351
352 memcpy(cmd.args, "\x14\x00\x04\x03\x00\x00", 6);
353 cmd.wlen = 6;
354 cmd.rlen = 1;
355 ret = si2168_cmd_execute(s, &cmd);
356 if (ret)
357 goto err;
358
359 memcpy(cmd.args, "\x14\x00\x03\x03\x00\x00", 6);
360 cmd.wlen = 6;
361 cmd.rlen = 1;
362 ret = si2168_cmd_execute(s, &cmd);
363 if (ret)
364 goto err;
365
366 memcpy(cmd.args, "\x14\x00\x08\x03\x00\x00", 6);
367 cmd.wlen = 6;
368 cmd.rlen = 1;
369 ret = si2168_cmd_execute(s, &cmd);
370 if (ret)
371 goto err;
372
373 memcpy(cmd.args, "\x14\x00\x07\x03\x01\x02", 6);
374 cmd.wlen = 6;
375 cmd.rlen = 1;
376 ret = si2168_cmd_execute(s, &cmd); 317 ret = si2168_cmd_execute(s, &cmd);
377 if (ret) 318 if (ret)
378 goto err; 319 goto err;
379 320
380 memcpy(cmd.args, "\x14\x00\x06\x03\x00\x00", 6); 321 memcpy(cmd.args, "\x14\x00\x01\x12\x00\x00", 6);
381 cmd.wlen = 6;
382 cmd.rlen = 1;
383 ret = si2168_cmd_execute(s, &cmd);
384 if (ret)
385 goto err;
386
387 memcpy(cmd.args, "\x14\x00\x05\x03\x00\x00", 6);
388 cmd.wlen = 6;
389 cmd.rlen = 1;
390 ret = si2168_cmd_execute(s, &cmd);
391 if (ret)
392 goto err;
393
394 memcpy(cmd.args, "\x14\x00\x01\x03\x0c\x40", 6);
395 cmd.wlen = 6;
396 cmd.rlen = 1;
397 ret = si2168_cmd_execute(s, &cmd);
398 if (ret)
399 goto err;
400
401 memcpy(cmd.args, "\x14\x00\x01\x10\x16\x00", 6);
402 cmd.wlen = 6; 322 cmd.wlen = 6;
403 cmd.rlen = 1; 323 cmd.rlen = 4;
404 ret = si2168_cmd_execute(s, &cmd); 324 ret = si2168_cmd_execute(s, &cmd);
405 if (ret) 325 if (ret)
406 goto err; 326 goto err;
407 327
408 memcpy(cmd.args, "\x14\x00\x01\x12\x00\x00", 6); 328 memcpy(cmd.args, "\x14\x00\x01\x03\x0c\x00", 6);
409 cmd.wlen = 6; 329 cmd.wlen = 6;
410 cmd.rlen = 1; 330 cmd.rlen = 4;
411 ret = si2168_cmd_execute(s, &cmd); 331 ret = si2168_cmd_execute(s, &cmd);
412 if (ret) 332 if (ret)
413 goto err; 333 goto err;
414 334
415 cmd.args[0] = 0x85; 335 memcpy(cmd.args, "\x85", 1);
416 cmd.wlen = 1; 336 cmd.wlen = 1;
417 cmd.rlen = 1; 337 cmd.rlen = 1;
418 ret = si2168_cmd_execute(s, &cmd); 338 ret = si2168_cmd_execute(s, &cmd);
@@ -432,72 +352,60 @@ static int si2168_init(struct dvb_frontend *fe)
432 struct si2168 *s = fe->demodulator_priv; 352 struct si2168 *s = fe->demodulator_priv;
433 int ret, len, remaining; 353 int ret, len, remaining;
434 const struct firmware *fw = NULL; 354 const struct firmware *fw = NULL;
435 u8 *fw_file = SI2168_FIRMWARE; 355 u8 *fw_file;
436 const unsigned int i2c_wr_max = 8; 356 const unsigned int i2c_wr_max = 8;
437 struct si2168_cmd cmd; 357 struct si2168_cmd cmd;
358 unsigned int chip_id;
438 359
439 dev_dbg(&s->client->dev, "%s:\n", __func__); 360 dev_dbg(&s->client->dev, "%s:\n", __func__);
440 361
441 cmd.args[0] = 0x13; 362 memcpy(cmd.args, "\xc0\x12\x00\x0c\x00\x0d\x16\x00\x00\x00\x00\x00\x00", 13);
442 cmd.wlen = 1;
443 cmd.rlen = 0;
444 ret = si2168_cmd_execute(s, &cmd);
445 if (ret)
446 goto err;
447
448 cmd.args[0] = 0xc0;
449 cmd.args[1] = 0x12;
450 cmd.args[2] = 0x00;
451 cmd.args[3] = 0x0c;
452 cmd.args[4] = 0x00;
453 cmd.args[5] = 0x0d;
454 cmd.args[6] = 0x16;
455 cmd.args[7] = 0x00;
456 cmd.args[8] = 0x00;
457 cmd.args[9] = 0x00;
458 cmd.args[10] = 0x00;
459 cmd.args[11] = 0x00;
460 cmd.args[12] = 0x00;
461 cmd.wlen = 13; 363 cmd.wlen = 13;
462 cmd.rlen = 0; 364 cmd.rlen = 0;
463 ret = si2168_cmd_execute(s, &cmd); 365 ret = si2168_cmd_execute(s, &cmd);
464 if (ret) 366 if (ret)
465 goto err; 367 goto err;
466 368
467 cmd.args[0] = 0xc0; 369 memcpy(cmd.args, "\xc0\x06\x01\x0f\x00\x20\x20\x01", 8);
468 cmd.args[1] = 0x06;
469 cmd.args[2] = 0x01;
470 cmd.args[3] = 0x0f;
471 cmd.args[4] = 0x00;
472 cmd.args[5] = 0x20;
473 cmd.args[6] = 0x20;
474 cmd.args[7] = 0x01;
475 cmd.wlen = 8; 370 cmd.wlen = 8;
476 cmd.rlen = 1; 371 cmd.rlen = 1;
477 ret = si2168_cmd_execute(s, &cmd); 372 ret = si2168_cmd_execute(s, &cmd);
478 if (ret) 373 if (ret)
479 goto err; 374 goto err;
480 375
481 cmd.args[0] = 0x02; 376 /* query chip revision */
377 memcpy(cmd.args, "\x02", 1);
482 cmd.wlen = 1; 378 cmd.wlen = 1;
483 cmd.rlen = 13; 379 cmd.rlen = 13;
484 ret = si2168_cmd_execute(s, &cmd); 380 ret = si2168_cmd_execute(s, &cmd);
485 if (ret) 381 if (ret)
486 goto err; 382 goto err;
487 383
488 cmd.args[0] = 0x05; 384 chip_id = cmd.args[1] << 24 | cmd.args[2] << 16 | cmd.args[3] << 8 |
489 cmd.args[1] = 0x00; 385 cmd.args[4] << 0;
490 cmd.args[2] = 0xaa; 386
491 cmd.args[3] = 0x4d; 387 #define SI2168_A20 ('A' << 24 | 68 << 16 | '2' << 8 | '0' << 0)
492 cmd.args[4] = 0x56; 388 #define SI2168_A30 ('A' << 24 | 68 << 16 | '3' << 8 | '0' << 0)
493 cmd.args[5] = 0x40; 389 #define SI2168_B40 ('B' << 24 | 68 << 16 | '4' << 8 | '0' << 0)
494 cmd.args[6] = 0x00; 390
495 cmd.args[7] = 0x00; 391 switch (chip_id) {
496 cmd.wlen = 8; 392 case SI2168_A20:
497 cmd.rlen = 1; 393 fw_file = SI2168_A20_FIRMWARE;
498 ret = si2168_cmd_execute(s, &cmd); 394 break;
499 if (ret) 395 case SI2168_A30:
396 fw_file = SI2168_A30_FIRMWARE;
397 break;
398 case SI2168_B40:
399 fw_file = SI2168_B40_FIRMWARE;
400 break;
401 default:
402 dev_err(&s->client->dev,
403 "%s: unkown chip version Si21%d-%c%c%c\n",
404 KBUILD_MODNAME, cmd.args[2], cmd.args[1],
405 cmd.args[3], cmd.args[4]);
406 ret = -EINVAL;
500 goto err; 407 goto err;
408 }
501 409
502 /* cold state - try to download firmware */ 410 /* cold state - try to download firmware */
503 dev_info(&s->client->dev, "%s: found a '%s' in cold state\n", 411 dev_info(&s->client->dev, "%s: found a '%s' in cold state\n",
@@ -506,9 +414,22 @@ static int si2168_init(struct dvb_frontend *fe)
506 /* request the firmware, this will block and timeout */ 414 /* request the firmware, this will block and timeout */
507 ret = request_firmware(&fw, fw_file, &s->client->dev); 415 ret = request_firmware(&fw, fw_file, &s->client->dev);
508 if (ret) { 416 if (ret) {
509 dev_err(&s->client->dev, "%s: firmare file '%s' not found\n", 417 /* fallback mechanism to handle old name for Si2168 B40 fw */
510 KBUILD_MODNAME, fw_file); 418 if (chip_id == SI2168_B40) {
511 goto err; 419 fw_file = SI2168_B40_FIRMWARE_FALLBACK;
420 ret = request_firmware(&fw, fw_file, &s->client->dev);
421 }
422
423 if (ret == 0) {
424 dev_notice(&s->client->dev,
425 "%s: please install firmware file '%s'\n",
426 KBUILD_MODNAME, SI2168_B40_FIRMWARE);
427 } else {
428 dev_err(&s->client->dev,
429 "%s: firmware file '%s' not found\n",
430 KBUILD_MODNAME, fw_file);
431 goto err;
432 }
512 } 433 }
513 434
514 dev_info(&s->client->dev, "%s: downloading firmware from file '%s'\n", 435 dev_info(&s->client->dev, "%s: downloading firmware from file '%s'\n",
@@ -534,8 +455,7 @@ static int si2168_init(struct dvb_frontend *fe)
534 release_firmware(fw); 455 release_firmware(fw);
535 fw = NULL; 456 fw = NULL;
536 457
537 cmd.args[0] = 0x01; 458 memcpy(cmd.args, "\x01\x01", 2);
538 cmd.args[1] = 0x01;
539 cmd.wlen = 2; 459 cmd.wlen = 2;
540 cmd.rlen = 1; 460 cmd.rlen = 1;
541 ret = si2168_cmd_execute(s, &cmd); 461 ret = si2168_cmd_execute(s, &cmd);
@@ -559,12 +479,24 @@ err:
559static int si2168_sleep(struct dvb_frontend *fe) 479static int si2168_sleep(struct dvb_frontend *fe)
560{ 480{
561 struct si2168 *s = fe->demodulator_priv; 481 struct si2168 *s = fe->demodulator_priv;
482 int ret;
483 struct si2168_cmd cmd;
562 484
563 dev_dbg(&s->client->dev, "%s:\n", __func__); 485 dev_dbg(&s->client->dev, "%s:\n", __func__);
564 486
565 s->active = false; 487 s->active = false;
566 488
489 memcpy(cmd.args, "\x13", 1);
490 cmd.wlen = 1;
491 cmd.rlen = 0;
492 ret = si2168_cmd_execute(s, &cmd);
493 if (ret)
494 goto err;
495
567 return 0; 496 return 0;
497err:
498 dev_dbg(&s->client->dev, "%s: failed=%d\n", __func__, ret);
499 return ret;
568} 500}
569 501
570static int si2168_get_tune_settings(struct dvb_frontend *fe, 502static int si2168_get_tune_settings(struct dvb_frontend *fe,
@@ -674,7 +606,6 @@ static int si2168_probe(struct i2c_client *client,
674 struct si2168_config *config = client->dev.platform_data; 606 struct si2168_config *config = client->dev.platform_data;
675 struct si2168 *s; 607 struct si2168 *s;
676 int ret; 608 int ret;
677 struct si2168_cmd cmd;
678 609
679 dev_dbg(&client->dev, "%s:\n", __func__); 610 dev_dbg(&client->dev, "%s:\n", __func__);
680 611
@@ -688,18 +619,13 @@ static int si2168_probe(struct i2c_client *client,
688 s->client = client; 619 s->client = client;
689 mutex_init(&s->i2c_mutex); 620 mutex_init(&s->i2c_mutex);
690 621
691 /* check if the demod is there */
692 cmd.wlen = 0;
693 cmd.rlen = 1;
694 ret = si2168_cmd_execute(s, &cmd);
695 if (ret)
696 goto err;
697
698 /* create mux i2c adapter for tuner */ 622 /* create mux i2c adapter for tuner */
699 s->adapter = i2c_add_mux_adapter(client->adapter, &client->dev, s, 623 s->adapter = i2c_add_mux_adapter(client->adapter, &client->dev, s,
700 0, 0, 0, si2168_select, si2168_deselect); 624 0, 0, 0, si2168_select, si2168_deselect);
701 if (s->adapter == NULL) 625 if (s->adapter == NULL) {
626 ret = -ENODEV;
702 goto err; 627 goto err;
628 }
703 629
704 /* create dvb_frontend */ 630 /* create dvb_frontend */
705 memcpy(&s->fe.ops, &si2168_ops, sizeof(struct dvb_frontend_ops)); 631 memcpy(&s->fe.ops, &si2168_ops, sizeof(struct dvb_frontend_ops));
@@ -757,4 +683,6 @@ module_i2c_driver(si2168_driver);
757MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>"); 683MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
758MODULE_DESCRIPTION("Silicon Labs Si2168 DVB-T/T2/C demodulator driver"); 684MODULE_DESCRIPTION("Silicon Labs Si2168 DVB-T/T2/C demodulator driver");
759MODULE_LICENSE("GPL"); 685MODULE_LICENSE("GPL");
760MODULE_FIRMWARE(SI2168_FIRMWARE); 686MODULE_FIRMWARE(SI2168_A20_FIRMWARE);
687MODULE_FIRMWARE(SI2168_A30_FIRMWARE);
688MODULE_FIRMWARE(SI2168_B40_FIRMWARE);
diff --git a/drivers/media/dvb-frontends/si2168_priv.h b/drivers/media/dvb-frontends/si2168_priv.h
index 2a343e896f40..ebbf502ec313 100644
--- a/drivers/media/dvb-frontends/si2168_priv.h
+++ b/drivers/media/dvb-frontends/si2168_priv.h
@@ -22,7 +22,10 @@
22#include <linux/firmware.h> 22#include <linux/firmware.h>
23#include <linux/i2c-mux.h> 23#include <linux/i2c-mux.h>
24 24
25#define SI2168_FIRMWARE "dvb-demod-si2168-01.fw" 25#define SI2168_A20_FIRMWARE "dvb-demod-si2168-a20-01.fw"
26#define SI2168_A30_FIRMWARE "dvb-demod-si2168-a30-01.fw"
27#define SI2168_B40_FIRMWARE "dvb-demod-si2168-b40-01.fw"
28#define SI2168_B40_FIRMWARE_FALLBACK "dvb-demod-si2168-02.fw"
26 29
27/* state struct */ 30/* state struct */
28struct si2168 { 31struct si2168 {
@@ -36,9 +39,9 @@ struct si2168 {
36}; 39};
37 40
38/* firmare command struct */ 41/* firmare command struct */
39#define SI2157_ARGLEN 30 42#define SI2168_ARGLEN 30
40struct si2168_cmd { 43struct si2168_cmd {
41 u8 args[SI2157_ARGLEN]; 44 u8 args[SI2168_ARGLEN];
42 unsigned wlen; 45 unsigned wlen;
43 unsigned rlen; 46 unsigned rlen;
44}; 47};
diff --git a/drivers/media/dvb-frontends/stb6100_cfg.h b/drivers/media/dvb-frontends/stb6100_cfg.h
index 6314d18c797a..6edc15365847 100644
--- a/drivers/media/dvb-frontends/stb6100_cfg.h
+++ b/drivers/media/dvb-frontends/stb6100_cfg.h
@@ -21,17 +21,14 @@
21 21
22static int stb6100_get_frequency(struct dvb_frontend *fe, u32 *frequency) 22static int stb6100_get_frequency(struct dvb_frontend *fe, u32 *frequency)
23{ 23{
24 struct dvb_frontend_ops *frontend_ops = NULL; 24 struct dvb_frontend_ops *frontend_ops = &fe->ops;
25 struct dvb_tuner_ops *tuner_ops = NULL; 25 struct dvb_tuner_ops *tuner_ops = &frontend_ops->tuner_ops;
26 struct tuner_state t_state; 26 struct tuner_state t_state;
27 int err = 0; 27 int err = 0;
28 28
29 if (&fe->ops)
30 frontend_ops = &fe->ops;
31 if (&frontend_ops->tuner_ops)
32 tuner_ops = &frontend_ops->tuner_ops;
33 if (tuner_ops->get_state) { 29 if (tuner_ops->get_state) {
34 if ((err = tuner_ops->get_state(fe, DVBFE_TUNER_FREQUENCY, &t_state)) < 0) { 30 err = tuner_ops->get_state(fe, DVBFE_TUNER_FREQUENCY, &t_state);
31 if (err < 0) {
35 printk("%s: Invalid parameter\n", __func__); 32 printk("%s: Invalid parameter\n", __func__);
36 return err; 33 return err;
37 } 34 }
@@ -42,18 +39,16 @@ static int stb6100_get_frequency(struct dvb_frontend *fe, u32 *frequency)
42 39
43static int stb6100_set_frequency(struct dvb_frontend *fe, u32 frequency) 40static int stb6100_set_frequency(struct dvb_frontend *fe, u32 frequency)
44{ 41{
45 struct dvb_frontend_ops *frontend_ops = NULL; 42 struct dvb_frontend_ops *frontend_ops = &fe->ops;
46 struct dvb_tuner_ops *tuner_ops = NULL; 43 struct dvb_tuner_ops *tuner_ops = &frontend_ops->tuner_ops;
47 struct tuner_state t_state; 44 struct tuner_state t_state;
48 int err = 0; 45 int err = 0;
49 46
50 t_state.frequency = frequency; 47 t_state.frequency = frequency;
51 if (&fe->ops) 48
52 frontend_ops = &fe->ops;
53 if (&frontend_ops->tuner_ops)
54 tuner_ops = &frontend_ops->tuner_ops;
55 if (tuner_ops->set_state) { 49 if (tuner_ops->set_state) {
56 if ((err = tuner_ops->set_state(fe, DVBFE_TUNER_FREQUENCY, &t_state)) < 0) { 50 err = tuner_ops->set_state(fe, DVBFE_TUNER_FREQUENCY, &t_state);
51 if (err < 0) {
57 printk("%s: Invalid parameter\n", __func__); 52 printk("%s: Invalid parameter\n", __func__);
58 return err; 53 return err;
59 } 54 }
@@ -68,12 +63,9 @@ static int stb6100_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth)
68 struct tuner_state t_state; 63 struct tuner_state t_state;
69 int err = 0; 64 int err = 0;
70 65
71 if (&fe->ops)
72 frontend_ops = &fe->ops;
73 if (&frontend_ops->tuner_ops)
74 tuner_ops = &frontend_ops->tuner_ops;
75 if (tuner_ops->get_state) { 66 if (tuner_ops->get_state) {
76 if ((err = tuner_ops->get_state(fe, DVBFE_TUNER_BANDWIDTH, &t_state)) < 0) { 67 err = tuner_ops->get_state(fe, DVBFE_TUNER_BANDWIDTH, &t_state);
68 if (err < 0) {
77 printk("%s: Invalid parameter\n", __func__); 69 printk("%s: Invalid parameter\n", __func__);
78 return err; 70 return err;
79 } 71 }
@@ -84,18 +76,16 @@ static int stb6100_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth)
84 76
85static int stb6100_set_bandwidth(struct dvb_frontend *fe, u32 bandwidth) 77static int stb6100_set_bandwidth(struct dvb_frontend *fe, u32 bandwidth)
86{ 78{
87 struct dvb_frontend_ops *frontend_ops = NULL; 79 struct dvb_frontend_ops *frontend_ops = &fe->ops;
88 struct dvb_tuner_ops *tuner_ops = NULL; 80 struct dvb_tuner_ops *tuner_ops = &frontend_ops->tuner_ops;
89 struct tuner_state t_state; 81 struct tuner_state t_state;
90 int err = 0; 82 int err = 0;
91 83
92 t_state.bandwidth = bandwidth; 84 t_state.bandwidth = bandwidth;
93 if (&fe->ops) 85
94 frontend_ops = &fe->ops;
95 if (&frontend_ops->tuner_ops)
96 tuner_ops = &frontend_ops->tuner_ops;
97 if (tuner_ops->set_state) { 86 if (tuner_ops->set_state) {
98 if ((err = tuner_ops->set_state(fe, DVBFE_TUNER_BANDWIDTH, &t_state)) < 0) { 87 err = tuner_ops->set_state(fe, DVBFE_TUNER_BANDWIDTH, &t_state);
88 if (err < 0) {
99 printk("%s: Invalid parameter\n", __func__); 89 printk("%s: Invalid parameter\n", __func__);
100 return err; 90 return err;
101 } 91 }
diff --git a/drivers/media/dvb-frontends/stb6100_proc.h b/drivers/media/dvb-frontends/stb6100_proc.h
index 112163a48622..bd8a0ec9e2cc 100644
--- a/drivers/media/dvb-frontends/stb6100_proc.h
+++ b/drivers/media/dvb-frontends/stb6100_proc.h
@@ -19,15 +19,11 @@
19 19
20static int stb6100_get_freq(struct dvb_frontend *fe, u32 *frequency) 20static int stb6100_get_freq(struct dvb_frontend *fe, u32 *frequency)
21{ 21{
22 struct dvb_frontend_ops *frontend_ops = NULL; 22 struct dvb_frontend_ops *frontend_ops = &fe->ops;
23 struct dvb_tuner_ops *tuner_ops = NULL; 23 struct dvb_tuner_ops *tuner_ops = &frontend_ops->tuner_ops;
24 struct tuner_state state; 24 struct tuner_state state;
25 int err = 0; 25 int err = 0;
26 26
27 if (&fe->ops)
28 frontend_ops = &fe->ops;
29 if (&frontend_ops->tuner_ops)
30 tuner_ops = &frontend_ops->tuner_ops;
31 if (tuner_ops->get_state) { 27 if (tuner_ops->get_state) {
32 if (frontend_ops->i2c_gate_ctrl) 28 if (frontend_ops->i2c_gate_ctrl)
33 frontend_ops->i2c_gate_ctrl(fe, 1); 29 frontend_ops->i2c_gate_ctrl(fe, 1);
@@ -49,16 +45,13 @@ static int stb6100_get_freq(struct dvb_frontend *fe, u32 *frequency)
49 45
50static int stb6100_set_freq(struct dvb_frontend *fe, u32 frequency) 46static int stb6100_set_freq(struct dvb_frontend *fe, u32 frequency)
51{ 47{
52 struct dvb_frontend_ops *frontend_ops = NULL; 48 struct dvb_frontend_ops *frontend_ops = &fe->ops;
53 struct dvb_tuner_ops *tuner_ops = NULL; 49 struct dvb_tuner_ops *tuner_ops = &frontend_ops->tuner_ops;
54 struct tuner_state state; 50 struct tuner_state state;
55 int err = 0; 51 int err = 0;
56 52
57 state.frequency = frequency; 53 state.frequency = frequency;
58 if (&fe->ops) 54
59 frontend_ops = &fe->ops;
60 if (&frontend_ops->tuner_ops)
61 tuner_ops = &frontend_ops->tuner_ops;
62 if (tuner_ops->set_state) { 55 if (tuner_ops->set_state) {
63 if (frontend_ops->i2c_gate_ctrl) 56 if (frontend_ops->i2c_gate_ctrl)
64 frontend_ops->i2c_gate_ctrl(fe, 1); 57 frontend_ops->i2c_gate_ctrl(fe, 1);
@@ -79,15 +72,11 @@ static int stb6100_set_freq(struct dvb_frontend *fe, u32 frequency)
79 72
80static int stb6100_get_bandw(struct dvb_frontend *fe, u32 *bandwidth) 73static int stb6100_get_bandw(struct dvb_frontend *fe, u32 *bandwidth)
81{ 74{
82 struct dvb_frontend_ops *frontend_ops = NULL; 75 struct dvb_frontend_ops *frontend_ops = &fe->ops;
83 struct dvb_tuner_ops *tuner_ops = NULL; 76 struct dvb_tuner_ops *tuner_ops = &frontend_ops->tuner_ops;
84 struct tuner_state state; 77 struct tuner_state state;
85 int err = 0; 78 int err = 0;
86 79
87 if (&fe->ops)
88 frontend_ops = &fe->ops;
89 if (&frontend_ops->tuner_ops)
90 tuner_ops = &frontend_ops->tuner_ops;
91 if (tuner_ops->get_state) { 80 if (tuner_ops->get_state) {
92 if (frontend_ops->i2c_gate_ctrl) 81 if (frontend_ops->i2c_gate_ctrl)
93 frontend_ops->i2c_gate_ctrl(fe, 1); 82 frontend_ops->i2c_gate_ctrl(fe, 1);
@@ -109,16 +98,13 @@ static int stb6100_get_bandw(struct dvb_frontend *fe, u32 *bandwidth)
109 98
110static int stb6100_set_bandw(struct dvb_frontend *fe, u32 bandwidth) 99static int stb6100_set_bandw(struct dvb_frontend *fe, u32 bandwidth)
111{ 100{
112 struct dvb_frontend_ops *frontend_ops = NULL; 101 struct dvb_frontend_ops *frontend_ops = &fe->ops;
113 struct dvb_tuner_ops *tuner_ops = NULL; 102 struct dvb_tuner_ops *tuner_ops = &frontend_ops->tuner_ops;
114 struct tuner_state state; 103 struct tuner_state state;
115 int err = 0; 104 int err = 0;
116 105
117 state.bandwidth = bandwidth; 106 state.bandwidth = bandwidth;
118 if (&fe->ops) 107
119 frontend_ops = &fe->ops;
120 if (&frontend_ops->tuner_ops)
121 tuner_ops = &frontend_ops->tuner_ops;
122 if (tuner_ops->set_state) { 108 if (tuner_ops->set_state) {
123 if (frontend_ops->i2c_gate_ctrl) 109 if (frontend_ops->i2c_gate_ctrl)
124 frontend_ops->i2c_gate_ctrl(fe, 1); 110 frontend_ops->i2c_gate_ctrl(fe, 1);
diff --git a/drivers/media/dvb-frontends/stv0367.c b/drivers/media/dvb-frontends/stv0367.c
index 458772739423..59b6e661acc0 100644
--- a/drivers/media/dvb-frontends/stv0367.c
+++ b/drivers/media/dvb-frontends/stv0367.c
@@ -922,18 +922,13 @@ static int stv0367ter_gate_ctrl(struct dvb_frontend *fe, int enable)
922 922
923static u32 stv0367_get_tuner_freq(struct dvb_frontend *fe) 923static u32 stv0367_get_tuner_freq(struct dvb_frontend *fe)
924{ 924{
925 struct dvb_frontend_ops *frontend_ops = NULL; 925 struct dvb_frontend_ops *frontend_ops = &fe->ops;
926 struct dvb_tuner_ops *tuner_ops = NULL; 926 struct dvb_tuner_ops *tuner_ops = &frontend_ops->tuner_ops;
927 u32 freq = 0; 927 u32 freq = 0;
928 int err = 0; 928 int err = 0;
929 929
930 dprintk("%s:\n", __func__); 930 dprintk("%s:\n", __func__);
931 931
932
933 if (&fe->ops)
934 frontend_ops = &fe->ops;
935 if (&frontend_ops->tuner_ops)
936 tuner_ops = &frontend_ops->tuner_ops;
937 if (tuner_ops->get_frequency) { 932 if (tuner_ops->get_frequency) {
938 err = tuner_ops->get_frequency(fe, &freq); 933 err = tuner_ops->get_frequency(fe, &freq);
939 if (err < 0) { 934 if (err < 0) {
diff --git a/drivers/media/dvb-frontends/tda10071.c b/drivers/media/dvb-frontends/tda10071.c
index 522fe00f5eee..9619be5d4827 100644
--- a/drivers/media/dvb-frontends/tda10071.c
+++ b/drivers/media/dvb-frontends/tda10071.c
@@ -668,6 +668,7 @@ static int tda10071_set_frontend(struct dvb_frontend *fe)
668 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 668 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
669 int ret, i; 669 int ret, i;
670 u8 mode, rolloff, pilot, inversion, div; 670 u8 mode, rolloff, pilot, inversion, div;
671 fe_modulation_t modulation;
671 672
672 dev_dbg(&priv->i2c->dev, 673 dev_dbg(&priv->i2c->dev,
673 "%s: delivery_system=%d modulation=%d frequency=%d symbol_rate=%d inversion=%d pilot=%d rolloff=%d\n", 674 "%s: delivery_system=%d modulation=%d frequency=%d symbol_rate=%d inversion=%d pilot=%d rolloff=%d\n",
@@ -702,10 +703,13 @@ static int tda10071_set_frontend(struct dvb_frontend *fe)
702 703
703 switch (c->delivery_system) { 704 switch (c->delivery_system) {
704 case SYS_DVBS: 705 case SYS_DVBS:
706 modulation = QPSK;
705 rolloff = 0; 707 rolloff = 0;
706 pilot = 2; 708 pilot = 2;
707 break; 709 break;
708 case SYS_DVBS2: 710 case SYS_DVBS2:
711 modulation = c->modulation;
712
709 switch (c->rolloff) { 713 switch (c->rolloff) {
710 case ROLLOFF_20: 714 case ROLLOFF_20:
711 rolloff = 2; 715 rolloff = 2;
@@ -750,7 +754,7 @@ static int tda10071_set_frontend(struct dvb_frontend *fe)
750 754
751 for (i = 0, mode = 0xff; i < ARRAY_SIZE(TDA10071_MODCOD); i++) { 755 for (i = 0, mode = 0xff; i < ARRAY_SIZE(TDA10071_MODCOD); i++) {
752 if (c->delivery_system == TDA10071_MODCOD[i].delivery_system && 756 if (c->delivery_system == TDA10071_MODCOD[i].delivery_system &&
753 c->modulation == TDA10071_MODCOD[i].modulation && 757 modulation == TDA10071_MODCOD[i].modulation &&
754 c->fec_inner == TDA10071_MODCOD[i].fec) { 758 c->fec_inner == TDA10071_MODCOD[i].fec) {
755 mode = TDA10071_MODCOD[i].val; 759 mode = TDA10071_MODCOD[i].val;
756 dev_dbg(&priv->i2c->dev, "%s: mode found=%02x\n", 760 dev_dbg(&priv->i2c->dev, "%s: mode found=%02x\n",
@@ -834,10 +838,10 @@ static int tda10071_get_frontend(struct dvb_frontend *fe)
834 838
835 switch ((buf[1] >> 0) & 0x01) { 839 switch ((buf[1] >> 0) & 0x01) {
836 case 0: 840 case 0:
837 c->inversion = INVERSION_OFF; 841 c->inversion = INVERSION_ON;
838 break; 842 break;
839 case 1: 843 case 1:
840 c->inversion = INVERSION_ON; 844 c->inversion = INVERSION_OFF;
841 break; 845 break;
842 } 846 }
843 847
@@ -856,7 +860,7 @@ static int tda10071_get_frontend(struct dvb_frontend *fe)
856 if (ret) 860 if (ret)
857 goto error; 861 goto error;
858 862
859 c->symbol_rate = (buf[0] << 16) | (buf[1] << 8) | (buf[2] << 0); 863 c->symbol_rate = ((buf[0] << 16) | (buf[1] << 8) | (buf[2] << 0)) * 1000;
860 864
861 return ret; 865 return ret;
862error: 866error:
diff --git a/drivers/media/dvb-frontends/tda10071_priv.h b/drivers/media/dvb-frontends/tda10071_priv.h
index 4baf14bfb65a..420486192736 100644
--- a/drivers/media/dvb-frontends/tda10071_priv.h
+++ b/drivers/media/dvb-frontends/tda10071_priv.h
@@ -55,6 +55,7 @@ static struct tda10071_modcod {
55 { SYS_DVBS2, QPSK, FEC_8_9, 0x0a }, 55 { SYS_DVBS2, QPSK, FEC_8_9, 0x0a },
56 { SYS_DVBS2, QPSK, FEC_9_10, 0x0b }, 56 { SYS_DVBS2, QPSK, FEC_9_10, 0x0b },
57 /* 8PSK */ 57 /* 8PSK */
58 { SYS_DVBS2, PSK_8, FEC_AUTO, 0x00 },
58 { SYS_DVBS2, PSK_8, FEC_3_5, 0x0c }, 59 { SYS_DVBS2, PSK_8, FEC_3_5, 0x0c },
59 { SYS_DVBS2, PSK_8, FEC_2_3, 0x0d }, 60 { SYS_DVBS2, PSK_8, FEC_2_3, 0x0d },
60 { SYS_DVBS2, PSK_8, FEC_3_4, 0x0e }, 61 { SYS_DVBS2, PSK_8, FEC_3_4, 0x0e },
diff --git a/drivers/media/dvb-frontends/tda18271c2dd.c b/drivers/media/dvb-frontends/tda18271c2dd.c
index 2c54586ac07f..de0a1c110972 100644
--- a/drivers/media/dvb-frontends/tda18271c2dd.c
+++ b/drivers/media/dvb-frontends/tda18271c2dd.c
@@ -1030,7 +1030,7 @@ static int ChannelConfiguration(struct tda_state *state,
1030 state->m_Regs[EP4] = state->m_EP4 | state->m_IFLevelDigital; 1030 state->m_Regs[EP4] = state->m_EP4 | state->m_IFLevelDigital;
1031 1031
1032 if ((Standard == HF_FM_Radio) && state->m_bFMInput) 1032 if ((Standard == HF_FM_Radio) && state->m_bFMInput)
1033 state->m_Regs[EP4] |= 80; 1033 state->m_Regs[EP4] |= 0x80;
1034 1034
1035 state->m_Regs[MPD] &= ~0x80; 1035 state->m_Regs[MPD] &= ~0x80;
1036 if (Standard > HF_AnalogMax) 1036 if (Standard > HF_AnalogMax)
diff --git a/drivers/media/dvb-frontends/tda18271c2dd_maps.h b/drivers/media/dvb-frontends/tda18271c2dd_maps.h
index b87661b9df14..f3bca5c237d7 100644
--- a/drivers/media/dvb-frontends/tda18271c2dd_maps.h
+++ b/drivers/media/dvb-frontends/tda18271c2dd_maps.h
@@ -5,7 +5,7 @@ enum HF_S {
5 HF_DVBC_8MHZ, HF_DVBC 5 HF_DVBC_8MHZ, HF_DVBC
6}; 6};
7 7
8struct SStandardParam m_StandardTable[] = { 8static struct SStandardParam m_StandardTable[] = {
9 { 0, 0, 0x00, 0x00 }, /* HF_None */ 9 { 0, 0, 0x00, 0x00 }, /* HF_None */
10 { 6000000, 7000000, 0x1D, 0x2C }, /* HF_B, */ 10 { 6000000, 7000000, 0x1D, 0x2C }, /* HF_B, */
11 { 6900000, 8000000, 0x1E, 0x2C }, /* HF_DK, */ 11 { 6900000, 8000000, 0x1E, 0x2C }, /* HF_DK, */
@@ -27,7 +27,7 @@ struct SStandardParam m_StandardTable[] = {
27 { 0, 0, 0x00, 0x00 }, /* HF_DVBC (Unused) */ 27 { 0, 0, 0x00, 0x00 }, /* HF_DVBC (Unused) */
28}; 28};
29 29
30struct SMap m_BP_Filter_Map[] = { 30static struct SMap m_BP_Filter_Map[] = {
31 { 62000000, 0x00 }, 31 { 62000000, 0x00 },
32 { 84000000, 0x01 }, 32 { 84000000, 0x01 },
33 { 100000000, 0x02 }, 33 { 100000000, 0x02 },
@@ -799,14 +799,14 @@ static struct SRFBandMap m_RF_Band_Map[7] = {
799 { 865000000, 489500000, 697500000, 842000000}, 799 { 865000000, 489500000, 697500000, 842000000},
800}; 800};
801 801
802u8 m_Thermometer_Map_1[16] = { 802static u8 m_Thermometer_Map_1[16] = {
803 60, 62, 66, 64, 803 60, 62, 66, 64,
804 74, 72, 68, 70, 804 74, 72, 68, 70,
805 90, 88, 84, 86, 805 90, 88, 84, 86,
806 76, 78, 82, 80, 806 76, 78, 82, 80,
807}; 807};
808 808
809u8 m_Thermometer_Map_2[16] = { 809static u8 m_Thermometer_Map_2[16] = {
810 92, 94, 98, 96, 810 92, 94, 98, 96,
811 106, 104, 100, 102, 811 106, 104, 100, 102,
812 122, 120, 116, 118, 812 122, 120, 116, 118,
diff --git a/drivers/media/dvb-frontends/tda8261_cfg.h b/drivers/media/dvb-frontends/tda8261_cfg.h
index 46710744173b..04a19e14ee5a 100644
--- a/drivers/media/dvb-frontends/tda8261_cfg.h
+++ b/drivers/media/dvb-frontends/tda8261_cfg.h
@@ -19,17 +19,14 @@
19 19
20static int tda8261_get_frequency(struct dvb_frontend *fe, u32 *frequency) 20static int tda8261_get_frequency(struct dvb_frontend *fe, u32 *frequency)
21{ 21{
22 struct dvb_frontend_ops *frontend_ops = NULL; 22 struct dvb_frontend_ops *frontend_ops = &fe->ops;
23 struct dvb_tuner_ops *tuner_ops = NULL; 23 struct dvb_tuner_ops *tuner_ops = &frontend_ops->tuner_ops;
24 struct tuner_state t_state; 24 struct tuner_state t_state;
25 int err = 0; 25 int err = 0;
26 26
27 if (&fe->ops)
28 frontend_ops = &fe->ops;
29 if (&frontend_ops->tuner_ops)
30 tuner_ops = &frontend_ops->tuner_ops;
31 if (tuner_ops->get_state) { 27 if (tuner_ops->get_state) {
32 if ((err = tuner_ops->get_state(fe, DVBFE_TUNER_FREQUENCY, &t_state)) < 0) { 28 err = tuner_ops->get_state(fe, DVBFE_TUNER_FREQUENCY, &t_state);
29 if (err < 0) {
33 printk("%s: Invalid parameter\n", __func__); 30 printk("%s: Invalid parameter\n", __func__);
34 return err; 31 return err;
35 } 32 }
@@ -41,18 +38,16 @@ static int tda8261_get_frequency(struct dvb_frontend *fe, u32 *frequency)
41 38
42static int tda8261_set_frequency(struct dvb_frontend *fe, u32 frequency) 39static int tda8261_set_frequency(struct dvb_frontend *fe, u32 frequency)
43{ 40{
44 struct dvb_frontend_ops *frontend_ops = NULL; 41 struct dvb_frontend_ops *frontend_ops = &fe->ops;
45 struct dvb_tuner_ops *tuner_ops = NULL; 42 struct dvb_tuner_ops *tuner_ops = &frontend_ops->tuner_ops;
46 struct tuner_state t_state; 43 struct tuner_state t_state;
47 int err = 0; 44 int err = 0;
48 45
49 t_state.frequency = frequency; 46 t_state.frequency = frequency;
50 if (&fe->ops) 47
51 frontend_ops = &fe->ops;
52 if (&frontend_ops->tuner_ops)
53 tuner_ops = &frontend_ops->tuner_ops;
54 if (tuner_ops->set_state) { 48 if (tuner_ops->set_state) {
55 if ((err = tuner_ops->set_state(fe, DVBFE_TUNER_FREQUENCY, &t_state)) < 0) { 49 err = tuner_ops->set_state(fe, DVBFE_TUNER_FREQUENCY, &t_state);
50 if (err < 0) {
56 printk("%s: Invalid parameter\n", __func__); 51 printk("%s: Invalid parameter\n", __func__);
57 return err; 52 return err;
58 } 53 }
@@ -68,12 +63,9 @@ static int tda8261_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth)
68 struct tuner_state t_state; 63 struct tuner_state t_state;
69 int err = 0; 64 int err = 0;
70 65
71 if (&fe->ops)
72 frontend_ops = &fe->ops;
73 if (&frontend_ops->tuner_ops)
74 tuner_ops = &frontend_ops->tuner_ops;
75 if (tuner_ops->get_state) { 66 if (tuner_ops->get_state) {
76 if ((err = tuner_ops->get_state(fe, DVBFE_TUNER_BANDWIDTH, &t_state)) < 0) { 67 err = tuner_ops->get_state(fe, DVBFE_TUNER_BANDWIDTH, &t_state);
68 if (err < 0) {
77 printk("%s: Invalid parameter\n", __func__); 69 printk("%s: Invalid parameter\n", __func__);
78 return err; 70 return err;
79 } 71 }
generated by cgit v1.2.2 (git 2.25.0) at 2026-04-28 23:16:42 -0400