2 cx231xx_avcore.c - driver for Conexant Cx23100/101/102
3 USB video capture devices
5 Copyright (C) 2008 <srinivasa.deevi at conexant dot com>
7 This program contains the specific code to control the avdecoder chip and
8 other related usb control functions for cx231xx based chipset.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 #include <linux/init.h>
26 #include <linux/list.h>
27 #include <linux/module.h>
28 #include <linux/kernel.h>
29 #include <linux/bitmap.h>
30 #include <linux/usb.h>
31 #include <linux/i2c.h>
33 #include <linux/mutex.h>
34 #include <media/tuner.h>
36 #include <media/v4l2-common.h>
37 #include <media/v4l2-ioctl.h>
38 #include <media/v4l2-chip-ident.h>
41 #include "cx231xx-dif.h"
43 #define TUNER_MODE_FM_RADIO 0
44 /******************************************************************************
45 -: BLOCK ARRANGEMENT :-
46 I2S block ----------------------|
49 Analog Front End --> Direct IF -|-> Cx25840 --> Audio
50 [video & audio] | [Audio]
55 *******************************************************************************/
56 /******************************************************************************
59 ******************************************************************************/
60 static int verve_write_byte(struct cx231xx
*dev
, u8 saddr
, u8 data
)
62 return cx231xx_write_i2c_data(dev
, VERVE_I2C_ADDRESS
,
66 static int verve_read_byte(struct cx231xx
*dev
, u8 saddr
, u8
*data
)
71 status
= cx231xx_read_i2c_data(dev
, VERVE_I2C_ADDRESS
,
76 void initGPIO(struct cx231xx
*dev
)
78 u32 _gpio_direction
= 0;
82 _gpio_direction
= _gpio_direction
& 0xFC0003FF;
83 _gpio_direction
= _gpio_direction
| 0x03FDFC00;
84 cx231xx_send_gpio_cmd(dev
, _gpio_direction
, (u8
*)&value
, 4, 0, 0);
86 verve_read_byte(dev
, 0x07, &val
);
87 cx231xx_info(" verve_read_byte address0x07=0x%x\n", val
);
88 verve_write_byte(dev
, 0x07, 0xF4);
89 verve_read_byte(dev
, 0x07, &val
);
90 cx231xx_info(" verve_read_byte address0x07=0x%x\n", val
);
92 cx231xx_capture_start(dev
, 1, 2);
94 cx231xx_mode_register(dev
, EP_MODE_SET
, 0x0500FE00);
95 cx231xx_mode_register(dev
, GBULK_BIT_EN
, 0xFFFDFFFF);
98 void uninitGPIO(struct cx231xx
*dev
)
100 u8 value
[4] = { 0, 0, 0, 0 };
102 cx231xx_capture_start(dev
, 0, 2);
103 verve_write_byte(dev
, 0x07, 0x14);
104 cx231xx_write_ctrl_reg(dev
, VRT_SET_REGISTER
,
108 /******************************************************************************
109 * A F E - B L O C K C O N T R O L functions *
110 * [ANALOG FRONT END] *
111 ******************************************************************************/
112 static int afe_write_byte(struct cx231xx
*dev
, u16 saddr
, u8 data
)
114 return cx231xx_write_i2c_data(dev
, AFE_DEVICE_ADDRESS
,
118 static int afe_read_byte(struct cx231xx
*dev
, u16 saddr
, u8
*data
)
123 status
= cx231xx_read_i2c_data(dev
, AFE_DEVICE_ADDRESS
,
129 int cx231xx_afe_init_super_block(struct cx231xx
*dev
, u32 ref_count
)
133 u8 afe_power_status
= 0;
136 /* super block initialize */
137 temp
= (u8
) (ref_count
& 0xff);
138 status
= afe_write_byte(dev
, SUP_BLK_TUNE2
, temp
);
142 status
= afe_read_byte(dev
, SUP_BLK_TUNE2
, &afe_power_status
);
146 temp
= (u8
) ((ref_count
& 0x300) >> 8);
148 status
= afe_write_byte(dev
, SUP_BLK_TUNE1
, temp
);
152 status
= afe_write_byte(dev
, SUP_BLK_PLL2
, 0x0f);
157 while (afe_power_status
!= 0x18) {
158 status
= afe_write_byte(dev
, SUP_BLK_PWRDN
, 0x18);
161 ": Init Super Block failed in send cmd\n");
165 status
= afe_read_byte(dev
, SUP_BLK_PWRDN
, &afe_power_status
);
166 afe_power_status
&= 0xff;
169 ": Init Super Block failed in receive cmd\n");
175 ": Init Super Block force break in loop !!!!\n");
184 /* start tuning filter */
185 status
= afe_write_byte(dev
, SUP_BLK_TUNE3
, 0x40);
192 status
= afe_write_byte(dev
, SUP_BLK_TUNE3
, 0x00);
197 int cx231xx_afe_init_channels(struct cx231xx
*dev
)
201 /* power up all 3 channels, clear pd_buffer */
202 status
= afe_write_byte(dev
, ADC_PWRDN_CLAMP_CH1
, 0x00);
203 status
= afe_write_byte(dev
, ADC_PWRDN_CLAMP_CH2
, 0x00);
204 status
= afe_write_byte(dev
, ADC_PWRDN_CLAMP_CH3
, 0x00);
206 /* Enable quantizer calibration */
207 status
= afe_write_byte(dev
, ADC_COM_QUANT
, 0x02);
209 /* channel initialize, force modulator (fb) reset */
210 status
= afe_write_byte(dev
, ADC_FB_FRCRST_CH1
, 0x17);
211 status
= afe_write_byte(dev
, ADC_FB_FRCRST_CH2
, 0x17);
212 status
= afe_write_byte(dev
, ADC_FB_FRCRST_CH3
, 0x17);
214 /* start quantilizer calibration */
215 status
= afe_write_byte(dev
, ADC_CAL_ATEST_CH1
, 0x10);
216 status
= afe_write_byte(dev
, ADC_CAL_ATEST_CH2
, 0x10);
217 status
= afe_write_byte(dev
, ADC_CAL_ATEST_CH3
, 0x10);
220 /* exit modulator (fb) reset */
221 status
= afe_write_byte(dev
, ADC_FB_FRCRST_CH1
, 0x07);
222 status
= afe_write_byte(dev
, ADC_FB_FRCRST_CH2
, 0x07);
223 status
= afe_write_byte(dev
, ADC_FB_FRCRST_CH3
, 0x07);
225 /* enable the pre_clamp in each channel for single-ended input */
226 status
= afe_write_byte(dev
, ADC_NTF_PRECLMP_EN_CH1
, 0xf0);
227 status
= afe_write_byte(dev
, ADC_NTF_PRECLMP_EN_CH2
, 0xf0);
228 status
= afe_write_byte(dev
, ADC_NTF_PRECLMP_EN_CH3
, 0xf0);
230 /* use diode instead of resistor, so set term_en to 0, res_en to 0 */
231 status
= cx231xx_reg_mask_write(dev
, AFE_DEVICE_ADDRESS
, 8,
232 ADC_QGAIN_RES_TRM_CH1
, 3, 7, 0x00);
233 status
= cx231xx_reg_mask_write(dev
, AFE_DEVICE_ADDRESS
, 8,
234 ADC_QGAIN_RES_TRM_CH2
, 3, 7, 0x00);
235 status
= cx231xx_reg_mask_write(dev
, AFE_DEVICE_ADDRESS
, 8,
236 ADC_QGAIN_RES_TRM_CH3
, 3, 7, 0x00);
238 /* dynamic element matching off */
239 status
= afe_write_byte(dev
, ADC_DCSERVO_DEM_CH1
, 0x03);
240 status
= afe_write_byte(dev
, ADC_DCSERVO_DEM_CH2
, 0x03);
241 status
= afe_write_byte(dev
, ADC_DCSERVO_DEM_CH3
, 0x03);
246 int cx231xx_afe_setup_AFE_for_baseband(struct cx231xx
*dev
)
251 status
= afe_read_byte(dev
, ADC_PWRDN_CLAMP_CH2
, &c_value
);
252 c_value
&= (~(0x50));
253 status
= afe_write_byte(dev
, ADC_PWRDN_CLAMP_CH2
, c_value
);
259 The Analog Front End in Cx231xx has 3 channels. These
260 channels are used to share between different inputs
261 like tuner, s-video and composite inputs.
263 channel 1 ----- pin 1 to pin4(in reg is 1-4)
264 channel 2 ----- pin 5 to pin8(in reg is 5-8)
265 channel 3 ----- pin 9 to pin 12(in reg is 9-11)
267 int cx231xx_afe_set_input_mux(struct cx231xx
*dev
, u32 input_mux
)
269 u8 ch1_setting
= (u8
) input_mux
;
270 u8 ch2_setting
= (u8
) (input_mux
>> 8);
271 u8 ch3_setting
= (u8
) (input_mux
>> 16);
275 if (ch1_setting
!= 0) {
276 status
= afe_read_byte(dev
, ADC_INPUT_CH1
, &value
);
277 value
&= (!INPUT_SEL_MASK
);
278 value
|= (ch1_setting
- 1) << 4;
280 status
= afe_write_byte(dev
, ADC_INPUT_CH1
, value
);
283 if (ch2_setting
!= 0) {
284 status
= afe_read_byte(dev
, ADC_INPUT_CH2
, &value
);
285 value
&= (!INPUT_SEL_MASK
);
286 value
|= (ch2_setting
- 1) << 4;
288 status
= afe_write_byte(dev
, ADC_INPUT_CH2
, value
);
291 /* For ch3_setting, the value to put in the register is
292 7 less than the input number */
293 if (ch3_setting
!= 0) {
294 status
= afe_read_byte(dev
, ADC_INPUT_CH3
, &value
);
295 value
&= (!INPUT_SEL_MASK
);
296 value
|= (ch3_setting
- 1) << 4;
298 status
= afe_write_byte(dev
, ADC_INPUT_CH3
, value
);
304 int cx231xx_afe_set_mode(struct cx231xx
*dev
, enum AFE_MODE mode
)
309 * FIXME: We need to implement the AFE code for LOW IF and for HI IF.
310 * Currently, only baseband works.
314 case AFE_MODE_LOW_IF
:
315 cx231xx_Setup_AFE_for_LowIF(dev
);
317 case AFE_MODE_BASEBAND
:
318 status
= cx231xx_afe_setup_AFE_for_baseband(dev
);
320 case AFE_MODE_EU_HI_IF
:
321 /* SetupAFEforEuHiIF(); */
323 case AFE_MODE_US_HI_IF
:
324 /* SetupAFEforUsHiIF(); */
326 case AFE_MODE_JAPAN_HI_IF
:
327 /* SetupAFEforJapanHiIF(); */
331 if ((mode
!= dev
->afe_mode
) &&
332 (dev
->video_input
== CX231XX_VMUX_TELEVISION
))
333 status
= cx231xx_afe_adjust_ref_count(dev
,
334 CX231XX_VMUX_TELEVISION
);
336 dev
->afe_mode
= mode
;
341 int cx231xx_afe_update_power_control(struct cx231xx
*dev
,
344 u8 afe_power_status
= 0;
347 switch (dev
->model
) {
348 case CX231XX_BOARD_CNXT_CARRAERA
:
349 case CX231XX_BOARD_CNXT_RDE_250
:
350 case CX231XX_BOARD_CNXT_SHELBY
:
351 case CX231XX_BOARD_CNXT_RDU_250
:
352 case CX231XX_BOARD_CNXT_RDE_253S
:
353 case CX231XX_BOARD_CNXT_RDU_253S
:
354 case CX231XX_BOARD_CNXT_VIDEO_GRABBER
:
355 case CX231XX_BOARD_HAUPPAUGE_EXETER
:
356 if (avmode
== POLARIS_AVMODE_ANALOGT_TV
) {
357 while (afe_power_status
!= (FLD_PWRDN_TUNING_BIAS
|
358 FLD_PWRDN_ENABLE_PLL
)) {
359 status
= afe_write_byte(dev
, SUP_BLK_PWRDN
,
360 FLD_PWRDN_TUNING_BIAS
|
361 FLD_PWRDN_ENABLE_PLL
);
362 status
|= afe_read_byte(dev
, SUP_BLK_PWRDN
,
368 status
= afe_write_byte(dev
, ADC_PWRDN_CLAMP_CH1
,
370 status
|= afe_write_byte(dev
, ADC_PWRDN_CLAMP_CH2
,
372 status
|= afe_write_byte(dev
, ADC_PWRDN_CLAMP_CH3
,
374 } else if (avmode
== POLARIS_AVMODE_DIGITAL
) {
375 status
= afe_write_byte(dev
, ADC_PWRDN_CLAMP_CH1
,
377 status
|= afe_write_byte(dev
, ADC_PWRDN_CLAMP_CH2
,
379 status
|= afe_write_byte(dev
, ADC_PWRDN_CLAMP_CH3
,
382 status
|= afe_read_byte(dev
, SUP_BLK_PWRDN
,
384 afe_power_status
|= FLD_PWRDN_PD_BANDGAP
|
387 status
|= afe_write_byte(dev
, SUP_BLK_PWRDN
,
389 } else if (avmode
== POLARIS_AVMODE_ENXTERNAL_AV
) {
390 while (afe_power_status
!= (FLD_PWRDN_TUNING_BIAS
|
391 FLD_PWRDN_ENABLE_PLL
)) {
392 status
= afe_write_byte(dev
, SUP_BLK_PWRDN
,
393 FLD_PWRDN_TUNING_BIAS
|
394 FLD_PWRDN_ENABLE_PLL
);
395 status
|= afe_read_byte(dev
, SUP_BLK_PWRDN
,
401 status
|= afe_write_byte(dev
, ADC_PWRDN_CLAMP_CH1
,
403 status
|= afe_write_byte(dev
, ADC_PWRDN_CLAMP_CH2
,
405 status
|= afe_write_byte(dev
, ADC_PWRDN_CLAMP_CH3
,
408 cx231xx_info("Invalid AV mode input\n");
413 if (avmode
== POLARIS_AVMODE_ANALOGT_TV
) {
414 while (afe_power_status
!= (FLD_PWRDN_TUNING_BIAS
|
415 FLD_PWRDN_ENABLE_PLL
)) {
416 status
= afe_write_byte(dev
, SUP_BLK_PWRDN
,
417 FLD_PWRDN_TUNING_BIAS
|
418 FLD_PWRDN_ENABLE_PLL
);
419 status
|= afe_read_byte(dev
, SUP_BLK_PWRDN
,
425 status
|= afe_write_byte(dev
, ADC_PWRDN_CLAMP_CH1
,
427 status
|= afe_write_byte(dev
, ADC_PWRDN_CLAMP_CH2
,
429 status
|= afe_write_byte(dev
, ADC_PWRDN_CLAMP_CH3
,
431 } else if (avmode
== POLARIS_AVMODE_DIGITAL
) {
432 status
= afe_write_byte(dev
, ADC_PWRDN_CLAMP_CH1
,
434 status
|= afe_write_byte(dev
, ADC_PWRDN_CLAMP_CH2
,
436 status
|= afe_write_byte(dev
, ADC_PWRDN_CLAMP_CH3
,
439 status
|= afe_read_byte(dev
, SUP_BLK_PWRDN
,
441 afe_power_status
|= FLD_PWRDN_PD_BANDGAP
|
444 status
|= afe_write_byte(dev
, SUP_BLK_PWRDN
,
446 } else if (avmode
== POLARIS_AVMODE_ENXTERNAL_AV
) {
447 while (afe_power_status
!= (FLD_PWRDN_TUNING_BIAS
|
448 FLD_PWRDN_ENABLE_PLL
)) {
449 status
= afe_write_byte(dev
, SUP_BLK_PWRDN
,
450 FLD_PWRDN_TUNING_BIAS
|
451 FLD_PWRDN_ENABLE_PLL
);
452 status
|= afe_read_byte(dev
, SUP_BLK_PWRDN
,
458 status
|= afe_write_byte(dev
, ADC_PWRDN_CLAMP_CH1
,
460 status
|= afe_write_byte(dev
, ADC_PWRDN_CLAMP_CH2
,
462 status
|= afe_write_byte(dev
, ADC_PWRDN_CLAMP_CH3
,
465 cx231xx_info("Invalid AV mode input\n");
473 int cx231xx_afe_adjust_ref_count(struct cx231xx
*dev
, u32 video_input
)
479 dev
->video_input
= video_input
;
481 if (video_input
== CX231XX_VMUX_TELEVISION
) {
482 status
= afe_read_byte(dev
, ADC_INPUT_CH3
, &input_mode
);
483 status
= afe_read_byte(dev
, ADC_NTF_PRECLMP_EN_CH3
,
486 status
= afe_read_byte(dev
, ADC_INPUT_CH1
, &input_mode
);
487 status
= afe_read_byte(dev
, ADC_NTF_PRECLMP_EN_CH1
,
491 input_mode
= (ntf_mode
& 0x3) | ((input_mode
& 0x6) << 1);
493 switch (input_mode
) {
495 dev
->afe_ref_count
= 0x23C;
498 dev
->afe_ref_count
= 0x24C;
501 dev
->afe_ref_count
= 0x258;
504 dev
->afe_ref_count
= 0x260;
510 status
= cx231xx_afe_init_super_block(dev
, dev
->afe_ref_count
);
515 /******************************************************************************
516 * V I D E O / A U D I O D E C O D E R C O N T R O L functions *
517 ******************************************************************************/
518 static int vid_blk_write_byte(struct cx231xx
*dev
, u16 saddr
, u8 data
)
520 return cx231xx_write_i2c_data(dev
, VID_BLK_I2C_ADDRESS
,
524 static int vid_blk_read_byte(struct cx231xx
*dev
, u16 saddr
, u8
*data
)
529 status
= cx231xx_read_i2c_data(dev
, VID_BLK_I2C_ADDRESS
,
535 static int vid_blk_write_word(struct cx231xx
*dev
, u16 saddr
, u32 data
)
537 return cx231xx_write_i2c_data(dev
, VID_BLK_I2C_ADDRESS
,
541 static int vid_blk_read_word(struct cx231xx
*dev
, u16 saddr
, u32
*data
)
543 return cx231xx_read_i2c_data(dev
, VID_BLK_I2C_ADDRESS
,
546 int cx231xx_check_fw(struct cx231xx
*dev
)
550 status
= vid_blk_read_byte(dev
, DL_CTL_ADDRESS_LOW
, &temp
);
558 int cx231xx_set_video_input_mux(struct cx231xx
*dev
, u8 input
)
562 switch (INPUT(input
)->type
) {
563 case CX231XX_VMUX_COMPOSITE1
:
564 case CX231XX_VMUX_SVIDEO
:
565 if ((dev
->current_pcb_config
.type
== USB_BUS_POWER
) &&
566 (dev
->power_mode
!= POLARIS_AVMODE_ENXTERNAL_AV
)) {
568 status
= cx231xx_set_power_mode(dev
,
569 POLARIS_AVMODE_ENXTERNAL_AV
);
571 cx231xx_errdev("%s: set_power_mode : Failed to"
572 " set Power - errCode [%d]!\n",
577 status
= cx231xx_set_decoder_video_input(dev
,
581 case CX231XX_VMUX_TELEVISION
:
582 case CX231XX_VMUX_CABLE
:
583 if ((dev
->current_pcb_config
.type
== USB_BUS_POWER
) &&
584 (dev
->power_mode
!= POLARIS_AVMODE_ANALOGT_TV
)) {
586 status
= cx231xx_set_power_mode(dev
,
587 POLARIS_AVMODE_ANALOGT_TV
);
589 cx231xx_errdev("%s: set_power_mode:Failed"
590 " to set Power - errCode [%d]!\n",
595 if (dev
->tuner_type
== TUNER_NXP_TDA18271
)
596 status
= cx231xx_set_decoder_video_input(dev
,
597 CX231XX_VMUX_TELEVISION
,
600 status
= cx231xx_set_decoder_video_input(dev
,
601 CX231XX_VMUX_COMPOSITE1
,
606 cx231xx_errdev("%s: set_power_mode : Unknown Input %d !\n",
607 __func__
, INPUT(input
)->type
);
611 /* save the selection */
612 dev
->video_input
= input
;
617 int cx231xx_set_decoder_video_input(struct cx231xx
*dev
,
618 u8 pin_type
, u8 input
)
623 if (pin_type
!= dev
->video_input
) {
624 status
= cx231xx_afe_adjust_ref_count(dev
, pin_type
);
626 cx231xx_errdev("%s: adjust_ref_count :Failed to set"
627 "AFE input mux - errCode [%d]!\n",
633 /* call afe block to set video inputs */
634 status
= cx231xx_afe_set_input_mux(dev
, input
);
636 cx231xx_errdev("%s: set_input_mux :Failed to set"
637 " AFE input mux - errCode [%d]!\n",
643 case CX231XX_VMUX_COMPOSITE1
:
644 status
= vid_blk_read_word(dev
, AFE_CTRL
, &value
);
645 value
|= (0 << 13) | (1 << 4);
648 /* set [24:23] [22:15] to 0 */
649 value
&= (~(0x1ff8000));
650 /* set FUNC_MODE[24:23] = 2 IF_MOD[22:15] = 0 */
652 status
= vid_blk_write_word(dev
, AFE_CTRL
, value
);
654 status
= vid_blk_read_word(dev
, OUT_CTRL1
, &value
);
656 status
= vid_blk_write_word(dev
, OUT_CTRL1
, value
);
658 /* Set vip 1.1 output mode */
659 status
= cx231xx_read_modify_write_i2c_dword(dev
,
665 /* Tell DIF object to go to baseband mode */
666 status
= cx231xx_dif_set_standard(dev
, DIF_USE_BASEBAND
);
668 cx231xx_errdev("%s: cx231xx_dif set to By pass"
669 " mode- errCode [%d]!\n",
674 /* Read the DFE_CTRL1 register */
675 status
= vid_blk_read_word(dev
, DFE_CTRL1
, &value
);
677 /* enable the VBI_GATE_EN */
678 value
|= FLD_VBI_GATE_EN
;
680 /* Enable the auto-VGA enable */
681 value
|= FLD_VGA_AUTO_EN
;
684 status
= vid_blk_write_word(dev
, DFE_CTRL1
, value
);
686 /* Disable auto config of registers */
687 status
= cx231xx_read_modify_write_i2c_dword(dev
,
689 MODE_CTRL
, FLD_ACFG_DIS
,
690 cx231xx_set_field(FLD_ACFG_DIS
, 1));
692 /* Set CVBS input mode */
693 status
= cx231xx_read_modify_write_i2c_dword(dev
,
695 MODE_CTRL
, FLD_INPUT_MODE
,
696 cx231xx_set_field(FLD_INPUT_MODE
, INPUT_MODE_CVBS_0
));
698 case CX231XX_VMUX_SVIDEO
:
699 /* Disable the use of DIF */
701 status
= vid_blk_read_word(dev
, AFE_CTRL
, &value
);
703 /* set [24:23] [22:15] to 0 */
704 value
&= (~(0x1ff8000));
705 /* set FUNC_MODE[24:23] = 2
706 IF_MOD[22:15] = 0 DCR_BYP_CH2[4:4] = 1; */
708 status
= vid_blk_write_word(dev
, AFE_CTRL
, value
);
710 /* Tell DIF object to go to baseband mode */
711 status
= cx231xx_dif_set_standard(dev
, DIF_USE_BASEBAND
);
713 cx231xx_errdev("%s: cx231xx_dif set to By pass"
714 " mode- errCode [%d]!\n",
719 /* Read the DFE_CTRL1 register */
720 status
= vid_blk_read_word(dev
, DFE_CTRL1
, &value
);
722 /* enable the VBI_GATE_EN */
723 value
|= FLD_VBI_GATE_EN
;
725 /* Enable the auto-VGA enable */
726 value
|= FLD_VGA_AUTO_EN
;
729 status
= vid_blk_write_word(dev
, DFE_CTRL1
, value
);
731 /* Disable auto config of registers */
732 status
= cx231xx_read_modify_write_i2c_dword(dev
,
734 MODE_CTRL
, FLD_ACFG_DIS
,
735 cx231xx_set_field(FLD_ACFG_DIS
, 1));
737 /* Set YC input mode */
738 status
= cx231xx_read_modify_write_i2c_dword(dev
,
742 cx231xx_set_field(FLD_INPUT_MODE
, INPUT_MODE_YC_1
));
745 status
= vid_blk_read_word(dev
, AFE_CTRL
, &value
);
746 value
|= FLD_CHROMA_IN_SEL
; /* set the chroma in select */
748 /* Clear VGA_SEL_CH2 and VGA_SEL_CH3 (bits 7 and 8)
749 This sets them to use video
750 rather than audio. Only one of the two will be in use. */
751 value
&= ~(FLD_VGA_SEL_CH2
| FLD_VGA_SEL_CH3
);
753 status
= vid_blk_write_word(dev
, AFE_CTRL
, value
);
755 status
= cx231xx_afe_set_mode(dev
, AFE_MODE_BASEBAND
);
757 case CX231XX_VMUX_TELEVISION
:
758 case CX231XX_VMUX_CABLE
:
760 switch (dev
->model
) {
761 case CX231XX_BOARD_CNXT_CARRAERA
:
762 case CX231XX_BOARD_CNXT_RDE_250
:
763 case CX231XX_BOARD_CNXT_SHELBY
:
764 case CX231XX_BOARD_CNXT_RDU_250
:
765 /* Disable the use of DIF */
767 status
= vid_blk_read_word(dev
, AFE_CTRL
, &value
);
768 value
|= (0 << 13) | (1 << 4);
771 /* set [24:23] [22:15] to 0 */
772 value
&= (~(0x1FF8000));
773 /* set FUNC_MODE[24:23] = 2 IF_MOD[22:15] = 0 */
775 status
= vid_blk_write_word(dev
, AFE_CTRL
, value
);
777 status
= vid_blk_read_word(dev
, OUT_CTRL1
, &value
);
779 status
= vid_blk_write_word(dev
, OUT_CTRL1
, value
);
781 /* Set vip 1.1 output mode */
782 status
= cx231xx_read_modify_write_i2c_dword(dev
,
784 OUT_CTRL1
, FLD_OUT_MODE
,
787 /* Tell DIF object to go to baseband mode */
788 status
= cx231xx_dif_set_standard(dev
,
791 cx231xx_errdev("%s: cx231xx_dif set to By pass"
792 " mode- errCode [%d]!\n",
797 /* Read the DFE_CTRL1 register */
798 status
= vid_blk_read_word(dev
, DFE_CTRL1
, &value
);
800 /* enable the VBI_GATE_EN */
801 value
|= FLD_VBI_GATE_EN
;
803 /* Enable the auto-VGA enable */
804 value
|= FLD_VGA_AUTO_EN
;
807 status
= vid_blk_write_word(dev
, DFE_CTRL1
, value
);
809 /* Disable auto config of registers */
810 status
= cx231xx_read_modify_write_i2c_dword(dev
,
812 MODE_CTRL
, FLD_ACFG_DIS
,
813 cx231xx_set_field(FLD_ACFG_DIS
, 1));
815 /* Set CVBS input mode */
816 status
= cx231xx_read_modify_write_i2c_dword(dev
,
818 MODE_CTRL
, FLD_INPUT_MODE
,
819 cx231xx_set_field(FLD_INPUT_MODE
,
823 /* Enable the DIF for the tuner */
825 /* Reinitialize the DIF */
826 status
= cx231xx_dif_set_standard(dev
, dev
->norm
);
828 cx231xx_errdev("%s: cx231xx_dif set to By pass"
829 " mode- errCode [%d]!\n",
834 /* Make sure bypass is cleared */
835 status
= vid_blk_read_word(dev
, DIF_MISC_CTRL
, &value
);
837 /* Clear the bypass bit */
838 value
&= ~FLD_DIF_DIF_BYPASS
;
840 /* Enable the use of the DIF block */
841 status
= vid_blk_write_word(dev
, DIF_MISC_CTRL
, value
);
843 /* Read the DFE_CTRL1 register */
844 status
= vid_blk_read_word(dev
, DFE_CTRL1
, &value
);
846 /* Disable the VBI_GATE_EN */
847 value
&= ~FLD_VBI_GATE_EN
;
849 /* Enable the auto-VGA enable, AGC, and
850 set the skip count to 2 */
851 value
|= FLD_VGA_AUTO_EN
| FLD_AGC_AUTO_EN
| 0x00200000;
854 status
= vid_blk_write_word(dev
, DFE_CTRL1
, value
);
856 /* Wait until AGC locks up */
859 /* Disable the auto-VGA enable AGC */
860 value
&= ~(FLD_VGA_AUTO_EN
);
863 status
= vid_blk_write_word(dev
, DFE_CTRL1
, value
);
865 /* Enable Polaris B0 AGC output */
866 status
= vid_blk_read_word(dev
, PIN_CTRL
, &value
);
867 value
|= (FLD_OEF_AGC_RF
) |
868 (FLD_OEF_AGC_IFVGA
) |
870 status
= vid_blk_write_word(dev
, PIN_CTRL
, value
);
872 /* Set vip 1.1 output mode */
873 status
= cx231xx_read_modify_write_i2c_dword(dev
,
875 OUT_CTRL1
, FLD_OUT_MODE
,
878 /* Disable auto config of registers */
879 status
= cx231xx_read_modify_write_i2c_dword(dev
,
881 MODE_CTRL
, FLD_ACFG_DIS
,
882 cx231xx_set_field(FLD_ACFG_DIS
, 1));
884 /* Set CVBS input mode */
885 status
= cx231xx_read_modify_write_i2c_dword(dev
,
887 MODE_CTRL
, FLD_INPUT_MODE
,
888 cx231xx_set_field(FLD_INPUT_MODE
,
891 /* Set some bits in AFE_CTRL so that channel 2 or 3
892 * is ready to receive audio */
893 /* Clear clamp for channels 2 and 3 (bit 16-17) */
894 /* Clear droop comp (bit 19-20) */
895 /* Set VGA_SEL (for audio control) (bit 7-8) */
896 status
= vid_blk_read_word(dev
, AFE_CTRL
, &value
);
898 /*Set Func mode:01-DIF 10-baseband 11-YUV*/
899 value
&= (~(FLD_FUNC_MODE
));
902 value
|= FLD_VGA_SEL_CH3
| FLD_VGA_SEL_CH2
;
904 status
= vid_blk_write_word(dev
, AFE_CTRL
, value
);
906 if (dev
->tuner_type
== TUNER_NXP_TDA18271
) {
907 status
= vid_blk_read_word(dev
, PIN_CTRL
,
909 status
= vid_blk_write_word(dev
, PIN_CTRL
,
910 (value
& 0xFFFFFFEF));
919 /* Set raw VBI mode */
920 status
= cx231xx_read_modify_write_i2c_dword(dev
,
922 OUT_CTRL1
, FLD_VBIHACTRAW_EN
,
923 cx231xx_set_field(FLD_VBIHACTRAW_EN
, 1));
925 status
= vid_blk_read_word(dev
, OUT_CTRL1
, &value
);
928 status
= vid_blk_write_word(dev
, OUT_CTRL1
, value
);
934 void cx231xx_enable656(struct cx231xx
*dev
)
938 /*enable TS1 data[0:7] as output to export 656*/
940 status
= vid_blk_write_byte(dev
, TS1_PIN_CTL0
, 0xFF);
942 /*enable TS1 clock as output to export 656*/
944 status
= vid_blk_read_byte(dev
, TS1_PIN_CTL1
, &temp
);
947 status
= vid_blk_write_byte(dev
, TS1_PIN_CTL1
, temp
);
950 EXPORT_SYMBOL_GPL(cx231xx_enable656
);
952 void cx231xx_disable656(struct cx231xx
*dev
)
958 status
= vid_blk_write_byte(dev
, TS1_PIN_CTL0
, 0x00);
960 status
= vid_blk_read_byte(dev
, TS1_PIN_CTL1
, &temp
);
963 status
= vid_blk_write_byte(dev
, TS1_PIN_CTL1
, temp
);
965 EXPORT_SYMBOL_GPL(cx231xx_disable656
);
968 * Handle any video-mode specific overrides that are different
969 * on a per video standards basis after touching the MODE_CTRL
970 * register which resets many values for autodetect
972 int cx231xx_do_mode_ctrl_overrides(struct cx231xx
*dev
)
976 cx231xx_info("do_mode_ctrl_overrides : 0x%x\n",
977 (unsigned int)dev
->norm
);
979 /* Change the DFE_CTRL3 bp_percent to fix flagging */
980 status
= vid_blk_write_word(dev
, DFE_CTRL3
, 0xCD3F0280);
982 if (dev
->norm
& (V4L2_STD_NTSC
| V4L2_STD_PAL_M
)) {
983 cx231xx_info("do_mode_ctrl_overrides NTSC\n");
985 /* Move the close caption lines out of active video,
986 adjust the active video start point */
987 status
= cx231xx_read_modify_write_i2c_dword(dev
,
990 FLD_VBLANK_CNT
, 0x18);
991 status
= cx231xx_read_modify_write_i2c_dword(dev
,
996 status
= cx231xx_read_modify_write_i2c_dword(dev
,
1002 status
= cx231xx_read_modify_write_i2c_dword(dev
,
1003 VID_BLK_I2C_ADDRESS
,
1007 (FLD_HBLANK_CNT
, 0x79));
1009 } else if (dev
->norm
& V4L2_STD_SECAM
) {
1010 cx231xx_info("do_mode_ctrl_overrides SECAM\n");
1011 status
= cx231xx_read_modify_write_i2c_dword(dev
,
1012 VID_BLK_I2C_ADDRESS
,
1014 FLD_VBLANK_CNT
, 0x24);
1015 status
= cx231xx_read_modify_write_i2c_dword(dev
,
1016 VID_BLK_I2C_ADDRESS
,
1022 /* Adjust the active video horizontal start point */
1023 status
= cx231xx_read_modify_write_i2c_dword(dev
,
1024 VID_BLK_I2C_ADDRESS
,
1028 (FLD_HBLANK_CNT
, 0x85));
1030 cx231xx_info("do_mode_ctrl_overrides PAL\n");
1031 status
= cx231xx_read_modify_write_i2c_dword(dev
,
1032 VID_BLK_I2C_ADDRESS
,
1034 FLD_VBLANK_CNT
, 0x24);
1035 status
= cx231xx_read_modify_write_i2c_dword(dev
,
1036 VID_BLK_I2C_ADDRESS
,
1042 /* Adjust the active video horizontal start point */
1043 status
= cx231xx_read_modify_write_i2c_dword(dev
,
1044 VID_BLK_I2C_ADDRESS
,
1048 (FLD_HBLANK_CNT
, 0x85));
1055 int cx231xx_unmute_audio(struct cx231xx
*dev
)
1057 return vid_blk_write_byte(dev
, PATH1_VOL_CTL
, 0x24);
1059 EXPORT_SYMBOL_GPL(cx231xx_unmute_audio
);
1061 int stopAudioFirmware(struct cx231xx
*dev
)
1063 return vid_blk_write_byte(dev
, DL_CTL_CONTROL
, 0x03);
1066 int restartAudioFirmware(struct cx231xx
*dev
)
1068 return vid_blk_write_byte(dev
, DL_CTL_CONTROL
, 0x13);
1071 int cx231xx_set_audio_input(struct cx231xx
*dev
, u8 input
)
1074 enum AUDIO_INPUT ainput
= AUDIO_INPUT_LINE
;
1076 switch (INPUT(input
)->amux
) {
1077 case CX231XX_AMUX_VIDEO
:
1078 ainput
= AUDIO_INPUT_TUNER_TV
;
1080 case CX231XX_AMUX_LINE_IN
:
1081 status
= cx231xx_i2s_blk_set_audio_input(dev
, input
);
1082 ainput
= AUDIO_INPUT_LINE
;
1088 status
= cx231xx_set_audio_decoder_input(dev
, ainput
);
1093 int cx231xx_set_audio_decoder_input(struct cx231xx
*dev
,
1094 enum AUDIO_INPUT audio_input
)
1101 /* Put it in soft reset */
1102 status
= vid_blk_read_byte(dev
, GENERAL_CTL
, &gen_ctrl
);
1104 status
= vid_blk_write_byte(dev
, GENERAL_CTL
, gen_ctrl
);
1106 switch (audio_input
) {
1107 case AUDIO_INPUT_LINE
:
1108 /* setup AUD_IO control from Merlin paralle output */
1109 value
= cx231xx_set_field(FLD_AUD_CHAN1_SRC
,
1110 AUD_CHAN_SRC_PARALLEL
);
1111 status
= vid_blk_write_word(dev
, AUD_IO_CTRL
, value
);
1113 /* setup input to Merlin, SRC2 connect to AC97
1114 bypass upsample-by-2, slave mode, sony mode, left justify
1115 adr 091c, dat 01000000 */
1116 status
= vid_blk_read_word(dev
, AC97_CTL
, &dwval
);
1118 status
= vid_blk_write_word(dev
, AC97_CTL
,
1119 (dwval
| FLD_AC97_UP2X_BYPASS
));
1121 /* select the parallel1 and SRC3 */
1122 status
= vid_blk_write_word(dev
, BAND_OUT_SEL
,
1123 cx231xx_set_field(FLD_SRC3_IN_SEL
, 0x0) |
1124 cx231xx_set_field(FLD_SRC3_CLK_SEL
, 0x0) |
1125 cx231xx_set_field(FLD_PARALLEL1_SRC_SEL
, 0x0));
1127 /* unmute all, AC97 in, independence mode
1128 adr 08d0, data 0x00063073 */
1129 status
= vid_blk_write_word(dev
, DL_CTL
, 0x3000001);
1130 status
= vid_blk_write_word(dev
, PATH1_CTL1
, 0x00063073);
1132 /* set AVC maximum threshold, adr 08d4, dat ffff0024 */
1133 status
= vid_blk_read_word(dev
, PATH1_VOL_CTL
, &dwval
);
1134 status
= vid_blk_write_word(dev
, PATH1_VOL_CTL
,
1135 (dwval
| FLD_PATH1_AVC_THRESHOLD
));
1137 /* set SC maximum threshold, adr 08ec, dat ffffb3a3 */
1138 status
= vid_blk_read_word(dev
, PATH1_SC_CTL
, &dwval
);
1139 status
= vid_blk_write_word(dev
, PATH1_SC_CTL
,
1140 (dwval
| FLD_PATH1_SC_THRESHOLD
));
1143 case AUDIO_INPUT_TUNER_TV
:
1145 status
= stopAudioFirmware(dev
);
1146 /* Setup SRC sources and clocks */
1147 status
= vid_blk_write_word(dev
, BAND_OUT_SEL
,
1148 cx231xx_set_field(FLD_SRC6_IN_SEL
, 0x00) |
1149 cx231xx_set_field(FLD_SRC6_CLK_SEL
, 0x01) |
1150 cx231xx_set_field(FLD_SRC5_IN_SEL
, 0x00) |
1151 cx231xx_set_field(FLD_SRC5_CLK_SEL
, 0x02) |
1152 cx231xx_set_field(FLD_SRC4_IN_SEL
, 0x02) |
1153 cx231xx_set_field(FLD_SRC4_CLK_SEL
, 0x03) |
1154 cx231xx_set_field(FLD_SRC3_IN_SEL
, 0x00) |
1155 cx231xx_set_field(FLD_SRC3_CLK_SEL
, 0x00) |
1156 cx231xx_set_field(FLD_BASEBAND_BYPASS_CTL
, 0x00) |
1157 cx231xx_set_field(FLD_AC97_SRC_SEL
, 0x03) |
1158 cx231xx_set_field(FLD_I2S_SRC_SEL
, 0x00) |
1159 cx231xx_set_field(FLD_PARALLEL2_SRC_SEL
, 0x02) |
1160 cx231xx_set_field(FLD_PARALLEL1_SRC_SEL
, 0x01));
1162 /* Setup the AUD_IO control */
1163 status
= vid_blk_write_word(dev
, AUD_IO_CTRL
,
1164 cx231xx_set_field(FLD_I2S_PORT_DIR
, 0x00) |
1165 cx231xx_set_field(FLD_I2S_OUT_SRC
, 0x00) |
1166 cx231xx_set_field(FLD_AUD_CHAN3_SRC
, 0x00) |
1167 cx231xx_set_field(FLD_AUD_CHAN2_SRC
, 0x00) |
1168 cx231xx_set_field(FLD_AUD_CHAN1_SRC
, 0x03));
1170 status
= vid_blk_write_word(dev
, PATH1_CTL1
, 0x1F063870);
1172 /* setAudioStandard(_audio_standard); */
1173 status
= vid_blk_write_word(dev
, PATH1_CTL1
, 0x00063870);
1175 status
= restartAudioFirmware(dev
);
1177 switch (dev
->model
) {
1178 case CX231XX_BOARD_CNXT_CARRAERA
:
1179 case CX231XX_BOARD_CNXT_RDE_250
:
1180 case CX231XX_BOARD_CNXT_SHELBY
:
1181 case CX231XX_BOARD_CNXT_RDU_250
:
1182 case CX231XX_BOARD_CNXT_VIDEO_GRABBER
:
1183 status
= cx231xx_read_modify_write_i2c_dword(dev
,
1184 VID_BLK_I2C_ADDRESS
,
1187 cx231xx_set_field(FLD_SIF_EN
, 1));
1189 case CX231XX_BOARD_CNXT_RDE_253S
:
1190 case CX231XX_BOARD_CNXT_RDU_253S
:
1191 case CX231XX_BOARD_HAUPPAUGE_EXETER
:
1192 status
= cx231xx_read_modify_write_i2c_dword(dev
,
1193 VID_BLK_I2C_ADDRESS
,
1196 cx231xx_set_field(FLD_SIF_EN
, 0));
1203 case AUDIO_INPUT_TUNER_FM
:
1204 /* use SIF for FM radio
1206 setAudioStandard(_audio_standard);
1210 case AUDIO_INPUT_MUTE
:
1211 status
= vid_blk_write_word(dev
, PATH1_CTL1
, 0x1F011012);
1215 /* Take it out of soft reset */
1216 status
= vid_blk_read_byte(dev
, GENERAL_CTL
, &gen_ctrl
);
1218 status
= vid_blk_write_byte(dev
, GENERAL_CTL
, gen_ctrl
);
1223 /* Set resolution of the video */
1224 int cx231xx_resolution_set(struct cx231xx
*dev
)
1226 /* set horzontal scale */
1227 int status
= vid_blk_write_word(dev
, HSCALE_CTRL
, dev
->hscale
);
1231 /* set vertical scale */
1232 status
= vid_blk_write_word(dev
, VSCALE_CTRL
, dev
->vscale
);
1237 /******************************************************************************
1238 * C H I P Specific C O N T R O L functions *
1239 ******************************************************************************/
1240 int cx231xx_init_ctrl_pin_status(struct cx231xx
*dev
)
1245 status
= vid_blk_read_word(dev
, PIN_CTRL
, &value
);
1246 value
|= (~dev
->board
.ctl_pin_status_mask
);
1247 status
= vid_blk_write_word(dev
, PIN_CTRL
, value
);
1252 int cx231xx_set_agc_analog_digital_mux_select(struct cx231xx
*dev
,
1253 u8 analog_or_digital
)
1257 /* first set the direction to output */
1258 status
= cx231xx_set_gpio_direction(dev
,
1260 agc_analog_digital_select_gpio
, 1);
1262 /* 0 - demod ; 1 - Analog mode */
1263 status
= cx231xx_set_gpio_value(dev
,
1264 dev
->board
.agc_analog_digital_select_gpio
,
1270 int cx231xx_enable_i2c_for_tuner(struct cx231xx
*dev
, u8 I2CIndex
)
1272 u8 value
[4] = { 0, 0, 0, 0 };
1275 cx231xx_info("Changing the i2c port for tuner to %d\n", I2CIndex
);
1277 status
= cx231xx_read_ctrl_reg(dev
, VRT_GET_REGISTER
,
1278 PWR_CTL_EN
, value
, 4);
1282 if (I2CIndex
== I2C_1
) {
1283 if (value
[0] & I2C_DEMOD_EN
) {
1284 value
[0] &= ~I2C_DEMOD_EN
;
1285 status
= cx231xx_write_ctrl_reg(dev
, VRT_SET_REGISTER
,
1286 PWR_CTL_EN
, value
, 4);
1289 if (!(value
[0] & I2C_DEMOD_EN
)) {
1290 value
[0] |= I2C_DEMOD_EN
;
1291 status
= cx231xx_write_ctrl_reg(dev
, VRT_SET_REGISTER
,
1292 PWR_CTL_EN
, value
, 4);
1299 EXPORT_SYMBOL_GPL(cx231xx_enable_i2c_for_tuner
);
1300 void update_HH_register_after_set_DIF(struct cx231xx
*dev
)
1306 vid_blk_write_word(dev, PIN_CTRL, 0xA0FFF82F);
1307 vid_blk_write_word(dev, DIF_MISC_CTRL, 0x0A203F11);
1308 vid_blk_write_word(dev, DIF_SRC_PHASE_INC, 0x1BEFBF06);
1310 status = vid_blk_read_word(dev, AFE_CTRL_C2HH_SRC_CTRL, &value);
1311 vid_blk_write_word(dev, AFE_CTRL_C2HH_SRC_CTRL, 0x4485D390);
1312 status = vid_blk_read_word(dev, AFE_CTRL_C2HH_SRC_CTRL, &value);
1316 void cx231xx_dump_HH_reg(struct cx231xx
*dev
)
1323 status
= vid_blk_write_word(dev
, 0x104, value
);
1325 for (i
= 0x100; i
< 0x140; i
++) {
1326 status
= vid_blk_read_word(dev
, i
, &value
);
1327 cx231xx_info("reg0x%x=0x%x\n", i
, value
);
1331 for (i
= 0x300; i
< 0x400; i
++) {
1332 status
= vid_blk_read_word(dev
, i
, &value
);
1333 cx231xx_info("reg0x%x=0x%x\n", i
, value
);
1337 for (i
= 0x400; i
< 0x440; i
++) {
1338 status
= vid_blk_read_word(dev
, i
, &value
);
1339 cx231xx_info("reg0x%x=0x%x\n", i
, value
);
1343 status
= vid_blk_read_word(dev
, AFE_CTRL_C2HH_SRC_CTRL
, &value
);
1344 cx231xx_info("AFE_CTRL_C2HH_SRC_CTRL=0x%x\n", value
);
1345 vid_blk_write_word(dev
, AFE_CTRL_C2HH_SRC_CTRL
, 0x4485D390);
1346 status
= vid_blk_read_word(dev
, AFE_CTRL_C2HH_SRC_CTRL
, &value
);
1347 cx231xx_info("AFE_CTRL_C2HH_SRC_CTRL=0x%x\n", value
);
1350 void cx231xx_dump_SC_reg(struct cx231xx
*dev
)
1352 u8 value
[4] = { 0, 0, 0, 0 };
1354 cx231xx_info("cx231xx_dump_SC_reg %s!\n", __TIME__
);
1356 status
= cx231xx_read_ctrl_reg(dev
, VRT_GET_REGISTER
, BOARD_CFG_STAT
,
1358 cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", BOARD_CFG_STAT
, value
[0],
1359 value
[1], value
[2], value
[3]);
1360 status
= cx231xx_read_ctrl_reg(dev
, VRT_GET_REGISTER
, TS_MODE_REG
,
1362 cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", TS_MODE_REG
, value
[0],
1363 value
[1], value
[2], value
[3]);
1364 status
= cx231xx_read_ctrl_reg(dev
, VRT_GET_REGISTER
, TS1_CFG_REG
,
1366 cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", TS1_CFG_REG
, value
[0],
1367 value
[1], value
[2], value
[3]);
1368 status
= cx231xx_read_ctrl_reg(dev
, VRT_GET_REGISTER
, TS1_LENGTH_REG
,
1370 cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", TS1_LENGTH_REG
, value
[0],
1371 value
[1], value
[2], value
[3]);
1373 status
= cx231xx_read_ctrl_reg(dev
, VRT_GET_REGISTER
, TS2_CFG_REG
,
1375 cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", TS2_CFG_REG
, value
[0],
1376 value
[1], value
[2], value
[3]);
1377 status
= cx231xx_read_ctrl_reg(dev
, VRT_GET_REGISTER
, TS2_LENGTH_REG
,
1379 cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", TS2_LENGTH_REG
, value
[0],
1380 value
[1], value
[2], value
[3]);
1381 status
= cx231xx_read_ctrl_reg(dev
, VRT_GET_REGISTER
, EP_MODE_SET
,
1383 cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", EP_MODE_SET
, value
[0],
1384 value
[1], value
[2], value
[3]);
1385 status
= cx231xx_read_ctrl_reg(dev
, VRT_GET_REGISTER
, CIR_PWR_PTN1
,
1387 cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", CIR_PWR_PTN1
, value
[0],
1388 value
[1], value
[2], value
[3]);
1390 status
= cx231xx_read_ctrl_reg(dev
, VRT_GET_REGISTER
, CIR_PWR_PTN2
,
1392 cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", CIR_PWR_PTN2
, value
[0],
1393 value
[1], value
[2], value
[3]);
1394 status
= cx231xx_read_ctrl_reg(dev
, VRT_GET_REGISTER
, CIR_PWR_PTN3
,
1396 cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", CIR_PWR_PTN3
, value
[0],
1397 value
[1], value
[2], value
[3]);
1398 status
= cx231xx_read_ctrl_reg(dev
, VRT_GET_REGISTER
, CIR_PWR_MASK0
,
1400 cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", CIR_PWR_MASK0
, value
[0],
1401 value
[1], value
[2], value
[3]);
1402 status
= cx231xx_read_ctrl_reg(dev
, VRT_GET_REGISTER
, CIR_PWR_MASK1
,
1404 cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", CIR_PWR_MASK1
, value
[0],
1405 value
[1], value
[2], value
[3]);
1407 status
= cx231xx_read_ctrl_reg(dev
, VRT_GET_REGISTER
, CIR_PWR_MASK2
,
1409 cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", CIR_PWR_MASK2
, value
[0],
1410 value
[1], value
[2], value
[3]);
1411 status
= cx231xx_read_ctrl_reg(dev
, VRT_GET_REGISTER
, CIR_GAIN
,
1413 cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", CIR_GAIN
, value
[0],
1414 value
[1], value
[2], value
[3]);
1415 status
= cx231xx_read_ctrl_reg(dev
, VRT_GET_REGISTER
, CIR_CAR_REG
,
1417 cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", CIR_CAR_REG
, value
[0],
1418 value
[1], value
[2], value
[3]);
1419 status
= cx231xx_read_ctrl_reg(dev
, VRT_GET_REGISTER
, CIR_OT_CFG1
,
1421 cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", CIR_OT_CFG1
, value
[0],
1422 value
[1], value
[2], value
[3]);
1424 status
= cx231xx_read_ctrl_reg(dev
, VRT_GET_REGISTER
, CIR_OT_CFG2
,
1426 cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", CIR_OT_CFG2
, value
[0],
1427 value
[1], value
[2], value
[3]);
1428 status
= cx231xx_read_ctrl_reg(dev
, VRT_GET_REGISTER
, PWR_CTL_EN
,
1430 cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", PWR_CTL_EN
, value
[0],
1431 value
[1], value
[2], value
[3]);
1436 void cx231xx_Setup_AFE_for_LowIF(struct cx231xx
*dev
)
1444 status
= afe_read_byte(dev
, ADC_STATUS2_CH3
, &value
);
1445 value
= (value
& 0xFE)|0x01;
1446 status
= afe_write_byte(dev
, ADC_STATUS2_CH3
, value
);
1448 status
= afe_read_byte(dev
, ADC_STATUS2_CH3
, &value
);
1449 value
= (value
& 0xFE)|0x00;
1450 status
= afe_write_byte(dev
, ADC_STATUS2_CH3
, value
);
1454 config colibri to lo-if mode
1456 FIXME: ntf_mode = 2'b00 by default. But set 0x1 would reduce
1457 the diff IF input by half,
1459 for low-if agc defect
1462 status
= afe_read_byte(dev
, ADC_NTF_PRECLMP_EN_CH3
, &value
);
1463 value
= (value
& 0xFC)|0x00;
1464 status
= afe_write_byte(dev
, ADC_NTF_PRECLMP_EN_CH3
, value
);
1466 status
= afe_read_byte(dev
, ADC_INPUT_CH3
, &value
);
1467 value
= (value
& 0xF9)|0x02;
1468 status
= afe_write_byte(dev
, ADC_INPUT_CH3
, value
);
1470 status
= afe_read_byte(dev
, ADC_FB_FRCRST_CH3
, &value
);
1471 value
= (value
& 0xFB)|0x04;
1472 status
= afe_write_byte(dev
, ADC_FB_FRCRST_CH3
, value
);
1474 status
= afe_read_byte(dev
, ADC_DCSERVO_DEM_CH3
, &value
);
1475 value
= (value
& 0xFC)|0x03;
1476 status
= afe_write_byte(dev
, ADC_DCSERVO_DEM_CH3
, value
);
1478 status
= afe_read_byte(dev
, ADC_CTRL_DAC1_CH3
, &value
);
1479 value
= (value
& 0xFB)|0x04;
1480 status
= afe_write_byte(dev
, ADC_CTRL_DAC1_CH3
, value
);
1482 status
= afe_read_byte(dev
, ADC_CTRL_DAC23_CH3
, &value
);
1483 value
= (value
& 0xF8)|0x06;
1484 status
= afe_write_byte(dev
, ADC_CTRL_DAC23_CH3
, value
);
1486 status
= afe_read_byte(dev
, ADC_CTRL_DAC23_CH3
, &value
);
1487 value
= (value
& 0x8F)|0x40;
1488 status
= afe_write_byte(dev
, ADC_CTRL_DAC23_CH3
, value
);
1490 status
= afe_read_byte(dev
, ADC_PWRDN_CLAMP_CH3
, &value
);
1491 value
= (value
& 0xDF)|0x20;
1492 status
= afe_write_byte(dev
, ADC_PWRDN_CLAMP_CH3
, value
);
1495 void cx231xx_set_Colibri_For_LowIF(struct cx231xx
*dev
, u32 if_freq
,
1496 u8 spectral_invert
, u32 mode
)
1499 u32 colibri_carrier_offset
= 0;
1503 u8 value
[4] = { 0, 0, 0, 0 };
1505 switch (dev
->model
) {
1506 case CX231XX_BOARD_CNXT_CARRAERA
:
1507 case CX231XX_BOARD_CNXT_RDE_250
:
1508 case CX231XX_BOARD_CNXT_SHELBY
:
1509 case CX231XX_BOARD_CNXT_RDU_250
:
1510 case CX231XX_BOARD_CNXT_VIDEO_GRABBER
:
1513 case CX231XX_BOARD_CNXT_RDE_253S
:
1514 case CX231XX_BOARD_CNXT_RDU_253S
:
1522 cx231xx_info("Enter cx231xx_set_Colibri_For_LowIF()\n");
1523 value
[0] = (u8
) 0x6F;
1524 value
[1] = (u8
) 0x6F;
1525 value
[2] = (u8
) 0x6F;
1526 value
[3] = (u8
) 0x6F;
1527 status
= cx231xx_write_ctrl_reg(dev
, VRT_SET_REGISTER
,
1528 PWR_CTL_EN
, value
, 4);
1531 /*Set colibri for low IF*/
1532 status
= cx231xx_afe_set_mode(dev
, AFE_MODE_LOW_IF
);
1535 /* Set C2HH for low IF operation.*/
1536 standard
= dev
->norm
;
1537 status
= cx231xx_dif_configure_C2HH_for_low_IF(dev
, dev
->active_mode
,
1538 func_mode
, standard
);
1541 /* Get colibri offsets.*/
1542 colibri_carrier_offset
= cx231xx_Get_Colibri_CarrierOffset(mode
,
1545 cx231xx_info("colibri_carrier_offset=%d, standard=0x%x\n",
1546 colibri_carrier_offset
, standard
);
1548 /* Set the band Pass filter for DIF*/
1549 cx231xx_set_DIF_bandpass(dev
, (if_freq
+colibri_carrier_offset
)
1550 , spectral_invert
, mode
);
1554 u32
cx231xx_Get_Colibri_CarrierOffset(u32 mode
, u32 standerd
)
1556 u32 colibri_carrier_offset
= 0;
1559 if (mode
== TUNER_MODE_FM_RADIO
) {
1560 colibri_carrier_offset
= 1100000;
1561 } else if (standerd
& (V4L2_STD_NTSC
| V4L2_STD_NTSC_M_JP
)) {
1562 colibri_carrier_offset
= 4832000; /*4.83MHz */
1563 } else if (standerd
& (V4L2_STD_PAL_B
| V4L2_STD_PAL_G
)) {
1564 colibri_carrier_offset
= 2700000; /*2.70MHz */
1565 } else if (standerd
& (V4L2_STD_PAL_D
| V4L2_STD_PAL_I
1566 | V4L2_STD_SECAM
)) {
1567 colibri_carrier_offset
= 2100000; /*2.10MHz */
1571 return colibri_carrier_offset
;
1574 void cx231xx_set_DIF_bandpass(struct cx231xx
*dev
, u32 if_freq
,
1575 u8 spectral_invert
, u32 mode
)
1578 unsigned long pll_freq_word
;
1580 u32 dif_misc_ctrl_value
= 0;
1581 u64 pll_freq_u64
= 0;
1585 cx231xx_info("if_freq=%d;spectral_invert=0x%x;mode=0x%x\n",
1586 if_freq
, spectral_invert
, mode
);
1589 if (mode
== TUNER_MODE_FM_RADIO
) {
1590 pll_freq_word
= 0x905A1CAC;
1591 status
= vid_blk_write_word(dev
, DIF_PLL_FREQ_WORD
, pll_freq_word
);
1593 } else /*KSPROPERTY_TUNER_MODE_TV*/{
1594 /* Calculate the PLL frequency word based on the adjusted if_freq*/
1595 pll_freq_word
= if_freq
;
1596 pll_freq_u64
= (u64
)pll_freq_word
<< 28L;
1597 do_div(pll_freq_u64
, 50000000);
1598 pll_freq_word
= (u32
)pll_freq_u64
;
1599 /*pll_freq_word = 0x3463497;*/
1600 status
= vid_blk_write_word(dev
, DIF_PLL_FREQ_WORD
, pll_freq_word
);
1602 if (spectral_invert
) {
1604 /* Enable Spectral Invert*/
1605 status
= vid_blk_read_word(dev
, DIF_MISC_CTRL
,
1606 &dif_misc_ctrl_value
);
1607 dif_misc_ctrl_value
= dif_misc_ctrl_value
| 0x00200000;
1608 status
= vid_blk_write_word(dev
, DIF_MISC_CTRL
,
1609 dif_misc_ctrl_value
);
1612 /* Disable Spectral Invert*/
1613 status
= vid_blk_read_word(dev
, DIF_MISC_CTRL
,
1614 &dif_misc_ctrl_value
);
1615 dif_misc_ctrl_value
= dif_misc_ctrl_value
& 0xFFDFFFFF;
1616 status
= vid_blk_write_word(dev
, DIF_MISC_CTRL
,
1617 dif_misc_ctrl_value
);
1620 if_freq
= (if_freq
/100000)*100000;
1622 if (if_freq
< 3000000)
1625 if (if_freq
> 16000000)
1629 cx231xx_info("Enter IF=%d\n",
1630 sizeof(Dif_set_array
)/sizeof(struct dif_settings
));
1631 for (i
= 0; i
< sizeof(Dif_set_array
)/sizeof(struct dif_settings
); i
++) {
1632 if (Dif_set_array
[i
].if_freq
== if_freq
) {
1633 status
= vid_blk_write_word(dev
,
1634 Dif_set_array
[i
].register_address
, Dif_set_array
[i
].value
);
1640 /******************************************************************************
1641 * D I F - B L O C K C O N T R O L functions *
1642 ******************************************************************************/
1643 int cx231xx_dif_configure_C2HH_for_low_IF(struct cx231xx
*dev
, u32 mode
,
1644 u32 function_mode
, u32 standard
)
1649 if (mode
== V4L2_TUNER_RADIO
) {
1651 /* lo if big signal */
1652 status
= cx231xx_reg_mask_write(dev
,
1653 VID_BLK_I2C_ADDRESS
, 32,
1654 AFE_CTRL_C2HH_SRC_CTRL
, 30, 31, 0x1);
1655 /* FUNC_MODE = DIF */
1656 status
= cx231xx_reg_mask_write(dev
,
1657 VID_BLK_I2C_ADDRESS
, 32,
1658 AFE_CTRL_C2HH_SRC_CTRL
, 23, 24, function_mode
);
1660 status
= cx231xx_reg_mask_write(dev
,
1661 VID_BLK_I2C_ADDRESS
, 32,
1662 AFE_CTRL_C2HH_SRC_CTRL
, 15, 22, 0xFF);
1664 status
= cx231xx_reg_mask_write(dev
,
1665 VID_BLK_I2C_ADDRESS
, 32,
1666 AFE_CTRL_C2HH_SRC_CTRL
, 9, 9, 0x1);
1667 } else if (standard
!= DIF_USE_BASEBAND
) {
1668 if (standard
& V4L2_STD_MN
) {
1669 /* lo if big signal */
1670 status
= cx231xx_reg_mask_write(dev
,
1671 VID_BLK_I2C_ADDRESS
, 32,
1672 AFE_CTRL_C2HH_SRC_CTRL
, 30, 31, 0x1);
1673 /* FUNC_MODE = DIF */
1674 status
= cx231xx_reg_mask_write(dev
,
1675 VID_BLK_I2C_ADDRESS
, 32,
1676 AFE_CTRL_C2HH_SRC_CTRL
, 23, 24,
1679 status
= cx231xx_reg_mask_write(dev
,
1680 VID_BLK_I2C_ADDRESS
, 32,
1681 AFE_CTRL_C2HH_SRC_CTRL
, 15, 22, 0xb);
1683 status
= cx231xx_reg_mask_write(dev
,
1684 VID_BLK_I2C_ADDRESS
, 32,
1685 AFE_CTRL_C2HH_SRC_CTRL
, 9, 9, 0x1);
1686 /* 0x124, AUD_CHAN1_SRC = 0x3 */
1687 status
= cx231xx_reg_mask_write(dev
,
1688 VID_BLK_I2C_ADDRESS
, 32,
1689 AUD_IO_CTRL
, 0, 31, 0x00000003);
1690 } else if ((standard
== V4L2_STD_PAL_I
) |
1691 (standard
& V4L2_STD_PAL_D
) |
1692 (standard
& V4L2_STD_SECAM
)) {
1694 /* lo if big signal */
1695 status
= cx231xx_reg_mask_write(dev
,
1696 VID_BLK_I2C_ADDRESS
, 32,
1697 AFE_CTRL_C2HH_SRC_CTRL
, 30, 31, 0x1);
1698 /* FUNC_MODE = DIF */
1699 status
= cx231xx_reg_mask_write(dev
,
1700 VID_BLK_I2C_ADDRESS
, 32,
1701 AFE_CTRL_C2HH_SRC_CTRL
, 23, 24,
1704 status
= cx231xx_reg_mask_write(dev
,
1705 VID_BLK_I2C_ADDRESS
, 32,
1706 AFE_CTRL_C2HH_SRC_CTRL
, 15, 22, 0xF);
1708 status
= cx231xx_reg_mask_write(dev
,
1709 VID_BLK_I2C_ADDRESS
, 32,
1710 AFE_CTRL_C2HH_SRC_CTRL
, 9, 9, 0x1);
1712 /* default PAL BG */
1714 /* lo if big signal */
1715 status
= cx231xx_reg_mask_write(dev
,
1716 VID_BLK_I2C_ADDRESS
, 32,
1717 AFE_CTRL_C2HH_SRC_CTRL
, 30, 31, 0x1);
1718 /* FUNC_MODE = DIF */
1719 status
= cx231xx_reg_mask_write(dev
,
1720 VID_BLK_I2C_ADDRESS
, 32,
1721 AFE_CTRL_C2HH_SRC_CTRL
, 23, 24,
1724 status
= cx231xx_reg_mask_write(dev
,
1725 VID_BLK_I2C_ADDRESS
, 32,
1726 AFE_CTRL_C2HH_SRC_CTRL
, 15, 22, 0xE);
1728 status
= cx231xx_reg_mask_write(dev
,
1729 VID_BLK_I2C_ADDRESS
, 32,
1730 AFE_CTRL_C2HH_SRC_CTRL
, 9, 9, 0x1);
1737 int cx231xx_dif_set_standard(struct cx231xx
*dev
, u32 standard
)
1740 u32 dif_misc_ctrl_value
= 0;
1743 cx231xx_info("%s: setStandard to %x\n", __func__
, standard
);
1745 status
= vid_blk_read_word(dev
, DIF_MISC_CTRL
, &dif_misc_ctrl_value
);
1746 if (standard
!= DIF_USE_BASEBAND
)
1747 dev
->norm
= standard
;
1749 switch (dev
->model
) {
1750 case CX231XX_BOARD_CNXT_CARRAERA
:
1751 case CX231XX_BOARD_CNXT_RDE_250
:
1752 case CX231XX_BOARD_CNXT_SHELBY
:
1753 case CX231XX_BOARD_CNXT_RDU_250
:
1754 case CX231XX_BOARD_CNXT_VIDEO_GRABBER
:
1755 case CX231XX_BOARD_HAUPPAUGE_EXETER
:
1758 case CX231XX_BOARD_CNXT_RDE_253S
:
1759 case CX231XX_BOARD_CNXT_RDU_253S
:
1766 status
= cx231xx_dif_configure_C2HH_for_low_IF(dev
, dev
->active_mode
,
1767 func_mode
, standard
);
1769 if (standard
== DIF_USE_BASEBAND
) { /* base band */
1770 /* There is a different SRC_PHASE_INC value
1771 for baseband vs. DIF */
1772 status
= vid_blk_write_word(dev
, DIF_SRC_PHASE_INC
, 0xDF7DF83);
1773 status
= vid_blk_read_word(dev
, DIF_MISC_CTRL
,
1774 &dif_misc_ctrl_value
);
1775 dif_misc_ctrl_value
|= FLD_DIF_DIF_BYPASS
;
1776 status
= vid_blk_write_word(dev
, DIF_MISC_CTRL
,
1777 dif_misc_ctrl_value
);
1778 } else if (standard
& V4L2_STD_PAL_D
) {
1779 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1780 DIF_PLL_CTRL
, 0, 31, 0x6503bc0c);
1781 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1782 DIF_PLL_CTRL1
, 0, 31, 0xbd038c85);
1783 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1784 DIF_PLL_CTRL2
, 0, 31, 0x1db4640a);
1785 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1786 DIF_PLL_CTRL3
, 0, 31, 0x00008800);
1787 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1788 DIF_AGC_IF_REF
, 0, 31, 0x444C1380);
1789 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1790 DIF_AGC_CTRL_IF
, 0, 31, 0xDA302600);
1791 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1792 DIF_AGC_CTRL_INT
, 0, 31, 0xDA261700);
1793 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1794 DIF_AGC_CTRL_RF
, 0, 31, 0xDA262600);
1795 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1796 DIF_AGC_IF_INT_CURRENT
, 0, 31,
1798 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1799 DIF_AGC_RF_CURRENT
, 0, 31,
1801 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1802 DIF_VIDEO_AGC_CTRL
, 0, 31,
1804 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1805 DIF_VID_AUD_OVERRIDE
, 0, 31,
1807 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1808 DIF_AV_SEP_CTRL
, 0, 31, 0x3F3934EA);
1809 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1810 DIF_COMP_FLT_CTRL
, 0, 31,
1812 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1813 DIF_SRC_PHASE_INC
, 0, 31,
1815 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1816 DIF_SRC_GAIN_CONTROL
, 0, 31,
1818 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1819 DIF_RPT_VARIANCE
, 0, 31, 0x00000000);
1820 /* Save the Spec Inversion value */
1821 dif_misc_ctrl_value
&= FLD_DIF_SPEC_INV
;
1822 dif_misc_ctrl_value
|= 0x3a023F11;
1823 } else if (standard
& V4L2_STD_PAL_I
) {
1824 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1825 DIF_PLL_CTRL
, 0, 31, 0x6503bc0c);
1826 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1827 DIF_PLL_CTRL1
, 0, 31, 0xbd038c85);
1828 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1829 DIF_PLL_CTRL2
, 0, 31, 0x1db4640a);
1830 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1831 DIF_PLL_CTRL3
, 0, 31, 0x00008800);
1832 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1833 DIF_AGC_IF_REF
, 0, 31, 0x444C1380);
1834 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1835 DIF_AGC_CTRL_IF
, 0, 31, 0xDA302600);
1836 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1837 DIF_AGC_CTRL_INT
, 0, 31, 0xDA261700);
1838 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1839 DIF_AGC_CTRL_RF
, 0, 31, 0xDA262600);
1840 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1841 DIF_AGC_IF_INT_CURRENT
, 0, 31,
1843 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1844 DIF_AGC_RF_CURRENT
, 0, 31,
1846 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1847 DIF_VIDEO_AGC_CTRL
, 0, 31,
1849 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1850 DIF_VID_AUD_OVERRIDE
, 0, 31,
1852 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1853 DIF_AV_SEP_CTRL
, 0, 31, 0x5F39A934);
1854 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1855 DIF_COMP_FLT_CTRL
, 0, 31,
1857 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1858 DIF_SRC_PHASE_INC
, 0, 31,
1860 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1861 DIF_SRC_GAIN_CONTROL
, 0, 31,
1863 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1864 DIF_RPT_VARIANCE
, 0, 31, 0x00000000);
1865 /* Save the Spec Inversion value */
1866 dif_misc_ctrl_value
&= FLD_DIF_SPEC_INV
;
1867 dif_misc_ctrl_value
|= 0x3a033F11;
1868 } else if (standard
& V4L2_STD_PAL_M
) {
1869 /* improved Low Frequency Phase Noise */
1870 status
= vid_blk_write_word(dev
, DIF_PLL_CTRL
, 0xFF01FF0C);
1871 status
= vid_blk_write_word(dev
, DIF_PLL_CTRL1
, 0xbd038c85);
1872 status
= vid_blk_write_word(dev
, DIF_PLL_CTRL2
, 0x1db4640a);
1873 status
= vid_blk_write_word(dev
, DIF_PLL_CTRL3
, 0x00008800);
1874 status
= vid_blk_write_word(dev
, DIF_AGC_IF_REF
, 0x444C1380);
1875 status
= vid_blk_write_word(dev
, DIF_AGC_IF_INT_CURRENT
,
1877 status
= vid_blk_write_word(dev
, DIF_AGC_RF_CURRENT
,
1879 status
= vid_blk_write_word(dev
, DIF_VIDEO_AGC_CTRL
,
1881 status
= vid_blk_write_word(dev
, DIF_VID_AUD_OVERRIDE
,
1883 status
= vid_blk_write_word(dev
, DIF_AV_SEP_CTRL
, 0x012c405d);
1884 status
= vid_blk_write_word(dev
, DIF_COMP_FLT_CTRL
,
1886 status
= vid_blk_write_word(dev
, DIF_SRC_PHASE_INC
,
1888 status
= vid_blk_write_word(dev
, DIF_SRC_GAIN_CONTROL
,
1890 status
= vid_blk_write_word(dev
, DIF_SOFT_RST_CTRL_REVB
,
1892 /* Save the Spec Inversion value */
1893 dif_misc_ctrl_value
&= FLD_DIF_SPEC_INV
;
1894 dif_misc_ctrl_value
|= 0x3A0A3F10;
1895 } else if (standard
& (V4L2_STD_PAL_N
| V4L2_STD_PAL_Nc
)) {
1896 /* improved Low Frequency Phase Noise */
1897 status
= vid_blk_write_word(dev
, DIF_PLL_CTRL
, 0xFF01FF0C);
1898 status
= vid_blk_write_word(dev
, DIF_PLL_CTRL1
, 0xbd038c85);
1899 status
= vid_blk_write_word(dev
, DIF_PLL_CTRL2
, 0x1db4640a);
1900 status
= vid_blk_write_word(dev
, DIF_PLL_CTRL3
, 0x00008800);
1901 status
= vid_blk_write_word(dev
, DIF_AGC_IF_REF
, 0x444C1380);
1902 status
= vid_blk_write_word(dev
, DIF_AGC_IF_INT_CURRENT
,
1904 status
= vid_blk_write_word(dev
, DIF_AGC_RF_CURRENT
,
1906 status
= vid_blk_write_word(dev
, DIF_VIDEO_AGC_CTRL
,
1908 status
= vid_blk_write_word(dev
, DIF_VID_AUD_OVERRIDE
,
1910 status
= vid_blk_write_word(dev
, DIF_AV_SEP_CTRL
,
1912 status
= vid_blk_write_word(dev
, DIF_COMP_FLT_CTRL
,
1914 status
= vid_blk_write_word(dev
, DIF_SRC_PHASE_INC
,
1916 status
= vid_blk_write_word(dev
, DIF_SRC_GAIN_CONTROL
,
1918 status
= vid_blk_write_word(dev
, DIF_SOFT_RST_CTRL_REVB
,
1920 /* Save the Spec Inversion value */
1921 dif_misc_ctrl_value
&= FLD_DIF_SPEC_INV
;
1922 dif_misc_ctrl_value
= 0x3A093F10;
1923 } else if (standard
&
1924 (V4L2_STD_SECAM_B
| V4L2_STD_SECAM_D
| V4L2_STD_SECAM_G
|
1925 V4L2_STD_SECAM_K
| V4L2_STD_SECAM_K1
)) {
1927 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1928 DIF_PLL_CTRL
, 0, 31, 0x6503bc0c);
1929 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1930 DIF_PLL_CTRL1
, 0, 31, 0xbd038c85);
1931 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1932 DIF_PLL_CTRL2
, 0, 31, 0x1db4640a);
1933 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1934 DIF_PLL_CTRL3
, 0, 31, 0x00008800);
1935 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1936 DIF_AGC_IF_REF
, 0, 31, 0x888C0380);
1937 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1938 DIF_AGC_CTRL_IF
, 0, 31, 0xe0262600);
1939 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1940 DIF_AGC_CTRL_INT
, 0, 31, 0xc2171700);
1941 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1942 DIF_AGC_CTRL_RF
, 0, 31, 0xc2262600);
1943 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1944 DIF_AGC_IF_INT_CURRENT
, 0, 31,
1946 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1947 DIF_AGC_RF_CURRENT
, 0, 31,
1949 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1950 DIF_VID_AUD_OVERRIDE
, 0, 31,
1952 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1953 DIF_AV_SEP_CTRL
, 0, 31, 0x3F3530ec);
1954 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1955 DIF_COMP_FLT_CTRL
, 0, 31,
1957 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1958 DIF_SRC_PHASE_INC
, 0, 31,
1960 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1961 DIF_SRC_GAIN_CONTROL
, 0, 31,
1963 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1964 DIF_RPT_VARIANCE
, 0, 31, 0x00000000);
1965 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1966 DIF_VIDEO_AGC_CTRL
, 0, 31,
1969 /* Save the Spec Inversion value */
1970 dif_misc_ctrl_value
&= FLD_DIF_SPEC_INV
;
1971 dif_misc_ctrl_value
|= 0x3a023F11;
1972 } else if (standard
& (V4L2_STD_SECAM_L
| V4L2_STD_SECAM_LC
)) {
1973 /* Is it SECAM_L1? */
1974 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1975 DIF_PLL_CTRL
, 0, 31, 0x6503bc0c);
1976 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1977 DIF_PLL_CTRL1
, 0, 31, 0xbd038c85);
1978 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1979 DIF_PLL_CTRL2
, 0, 31, 0x1db4640a);
1980 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1981 DIF_PLL_CTRL3
, 0, 31, 0x00008800);
1982 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1983 DIF_AGC_IF_REF
, 0, 31, 0x888C0380);
1984 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1985 DIF_AGC_CTRL_IF
, 0, 31, 0xe0262600);
1986 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1987 DIF_AGC_CTRL_INT
, 0, 31, 0xc2171700);
1988 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1989 DIF_AGC_CTRL_RF
, 0, 31, 0xc2262600);
1990 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1991 DIF_AGC_IF_INT_CURRENT
, 0, 31,
1993 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1994 DIF_AGC_RF_CURRENT
, 0, 31,
1996 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
1997 DIF_VID_AUD_OVERRIDE
, 0, 31,
1999 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
2000 DIF_AV_SEP_CTRL
, 0, 31, 0x3F3530ec);
2001 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
2002 DIF_COMP_FLT_CTRL
, 0, 31,
2004 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
2005 DIF_SRC_PHASE_INC
, 0, 31,
2007 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
2008 DIF_SRC_GAIN_CONTROL
, 0, 31,
2010 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
2011 DIF_RPT_VARIANCE
, 0, 31, 0x00000000);
2012 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
2013 DIF_VIDEO_AGC_CTRL
, 0, 31,
2016 /* Save the Spec Inversion value */
2017 dif_misc_ctrl_value
&= FLD_DIF_SPEC_INV
;
2018 dif_misc_ctrl_value
|= 0x3a023F11;
2020 } else if (standard
& V4L2_STD_NTSC_M
) {
2021 /* V4L2_STD_NTSC_M (75 IRE Setup) Or
2022 V4L2_STD_NTSC_M_JP (Japan, 0 IRE Setup) */
2024 /* For NTSC the centre frequency of video coming out of
2025 sidewinder is around 7.1MHz or 3.6MHz depending on the
2026 spectral inversion. so for a non spectrally inverted channel
2027 the pll freq word is 0x03420c49
2030 status
= vid_blk_write_word(dev
, DIF_PLL_CTRL
, 0x6503BC0C);
2031 status
= vid_blk_write_word(dev
, DIF_PLL_CTRL1
, 0xBD038C85);
2032 status
= vid_blk_write_word(dev
, DIF_PLL_CTRL2
, 0x1DB4640A);
2033 status
= vid_blk_write_word(dev
, DIF_PLL_CTRL3
, 0x00008800);
2034 status
= vid_blk_write_word(dev
, DIF_AGC_IF_REF
, 0x444C0380);
2035 status
= vid_blk_write_word(dev
, DIF_AGC_IF_INT_CURRENT
,
2037 status
= vid_blk_write_word(dev
, DIF_AGC_RF_CURRENT
,
2039 status
= vid_blk_write_word(dev
, DIF_VIDEO_AGC_CTRL
,
2041 status
= vid_blk_write_word(dev
, DIF_VID_AUD_OVERRIDE
,
2043 status
= vid_blk_write_word(dev
, DIF_AV_SEP_CTRL
, 0x01296e1f);
2045 status
= vid_blk_write_word(dev
, DIF_COMP_FLT_CTRL
,
2047 status
= vid_blk_write_word(dev
, DIF_SRC_PHASE_INC
,
2049 status
= vid_blk_write_word(dev
, DIF_SRC_GAIN_CONTROL
,
2052 status
= vid_blk_write_word(dev
, DIF_AGC_CTRL_IF
, 0xC2262600);
2053 status
= vid_blk_write_word(dev
, DIF_AGC_CTRL_INT
,
2055 status
= vid_blk_write_word(dev
, DIF_AGC_CTRL_RF
, 0xC2262600);
2057 /* Save the Spec Inversion value */
2058 dif_misc_ctrl_value
&= FLD_DIF_SPEC_INV
;
2059 dif_misc_ctrl_value
|= 0x3a003F10;
2061 /* default PAL BG */
2062 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
2063 DIF_PLL_CTRL
, 0, 31, 0x6503bc0c);
2064 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
2065 DIF_PLL_CTRL1
, 0, 31, 0xbd038c85);
2066 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
2067 DIF_PLL_CTRL2
, 0, 31, 0x1db4640a);
2068 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
2069 DIF_PLL_CTRL3
, 0, 31, 0x00008800);
2070 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
2071 DIF_AGC_IF_REF
, 0, 31, 0x444C1380);
2072 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
2073 DIF_AGC_CTRL_IF
, 0, 31, 0xDA302600);
2074 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
2075 DIF_AGC_CTRL_INT
, 0, 31, 0xDA261700);
2076 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
2077 DIF_AGC_CTRL_RF
, 0, 31, 0xDA262600);
2078 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
2079 DIF_AGC_IF_INT_CURRENT
, 0, 31,
2081 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
2082 DIF_AGC_RF_CURRENT
, 0, 31,
2084 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
2085 DIF_VIDEO_AGC_CTRL
, 0, 31,
2087 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
2088 DIF_VID_AUD_OVERRIDE
, 0, 31,
2090 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
2091 DIF_AV_SEP_CTRL
, 0, 31, 0x3F3530EC);
2092 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
2093 DIF_COMP_FLT_CTRL
, 0, 31,
2095 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
2096 DIF_SRC_PHASE_INC
, 0, 31,
2098 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
2099 DIF_SRC_GAIN_CONTROL
, 0, 31,
2101 status
= cx231xx_reg_mask_write(dev
, VID_BLK_I2C_ADDRESS
, 32,
2102 DIF_RPT_VARIANCE
, 0, 31, 0x00000000);
2103 /* Save the Spec Inversion value */
2104 dif_misc_ctrl_value
&= FLD_DIF_SPEC_INV
;
2105 dif_misc_ctrl_value
|= 0x3a013F11;
2108 /* The AGC values should be the same for all standards,
2109 AUD_SRC_SEL[19] should always be disabled */
2110 dif_misc_ctrl_value
&= ~FLD_DIF_AUD_SRC_SEL
;
2112 /* It is still possible to get Set Standard calls even when we
2114 This is done to override the value for FM. */
2115 if (dev
->active_mode
== V4L2_TUNER_RADIO
)
2116 dif_misc_ctrl_value
= 0x7a080000;
2118 /* Write the calculated value for misc ontrol register */
2119 status
= vid_blk_write_word(dev
, DIF_MISC_CTRL
, dif_misc_ctrl_value
);
2124 int cx231xx_tuner_pre_channel_change(struct cx231xx
*dev
)
2129 /* Set the RF and IF k_agc values to 3 */
2130 status
= vid_blk_read_word(dev
, DIF_AGC_IF_REF
, &dwval
);
2131 dwval
&= ~(FLD_DIF_K_AGC_RF
| FLD_DIF_K_AGC_IF
);
2132 dwval
|= 0x33000000;
2134 status
= vid_blk_write_word(dev
, DIF_AGC_IF_REF
, dwval
);
2139 int cx231xx_tuner_post_channel_change(struct cx231xx
*dev
)
2143 cx231xx_info("cx231xx_tuner_post_channel_change dev->tuner_type =0%d\n",
2145 /* Set the RF and IF k_agc values to 4 for PAL/NTSC and 8 for
2146 * SECAM L/B/D standards */
2147 status
= vid_blk_read_word(dev
, DIF_AGC_IF_REF
, &dwval
);
2148 dwval
&= ~(FLD_DIF_K_AGC_RF
| FLD_DIF_K_AGC_IF
);
2150 if (dev
->norm
& (V4L2_STD_SECAM_L
| V4L2_STD_SECAM_B
|
2151 V4L2_STD_SECAM_D
)) {
2152 if (dev
->tuner_type
== TUNER_NXP_TDA18271
) {
2153 dwval
&= ~FLD_DIF_IF_REF
;
2154 dwval
|= 0x88000300;
2156 dwval
|= 0x88000000;
2158 if (dev
->tuner_type
== TUNER_NXP_TDA18271
) {
2159 dwval
&= ~FLD_DIF_IF_REF
;
2160 dwval
|= 0xCC000300;
2162 dwval
|= 0x44000000;
2165 status
= vid_blk_write_word(dev
, DIF_AGC_IF_REF
, dwval
);
2170 /******************************************************************************
2171 * I 2 S - B L O C K C O N T R O L functions *
2172 ******************************************************************************/
2173 int cx231xx_i2s_blk_initialize(struct cx231xx
*dev
)
2178 status
= cx231xx_read_i2c_data(dev
, I2S_BLK_DEVICE_ADDRESS
,
2179 CH_PWR_CTRL1
, 1, &value
, 1);
2180 /* enables clock to delta-sigma and decimation filter */
2182 status
= cx231xx_write_i2c_data(dev
, I2S_BLK_DEVICE_ADDRESS
,
2183 CH_PWR_CTRL1
, 1, value
, 1);
2184 /* power up all channel */
2185 status
= cx231xx_write_i2c_data(dev
, I2S_BLK_DEVICE_ADDRESS
,
2186 CH_PWR_CTRL2
, 1, 0x00, 1);
2191 int cx231xx_i2s_blk_update_power_control(struct cx231xx
*dev
,
2192 enum AV_MODE avmode
)
2197 if (avmode
!= POLARIS_AVMODE_ENXTERNAL_AV
) {
2198 status
= cx231xx_read_i2c_data(dev
, I2S_BLK_DEVICE_ADDRESS
,
2199 CH_PWR_CTRL2
, 1, &value
, 1);
2201 status
= cx231xx_write_i2c_data(dev
, I2S_BLK_DEVICE_ADDRESS
,
2202 CH_PWR_CTRL2
, 1, value
, 1);
2204 status
= cx231xx_write_i2c_data(dev
, I2S_BLK_DEVICE_ADDRESS
,
2205 CH_PWR_CTRL2
, 1, 0x00, 1);
2211 /* set i2s_blk for audio input types */
2212 int cx231xx_i2s_blk_set_audio_input(struct cx231xx
*dev
, u8 audio_input
)
2216 switch (audio_input
) {
2217 case CX231XX_AMUX_LINE_IN
:
2218 status
= cx231xx_write_i2c_data(dev
, I2S_BLK_DEVICE_ADDRESS
,
2219 CH_PWR_CTRL2
, 1, 0x00, 1);
2220 status
= cx231xx_write_i2c_data(dev
, I2S_BLK_DEVICE_ADDRESS
,
2221 CH_PWR_CTRL1
, 1, 0x80, 1);
2223 case CX231XX_AMUX_VIDEO
:
2228 dev
->ctl_ainput
= audio_input
;
2233 /******************************************************************************
2234 * P O W E R C O N T R O L functions *
2235 ******************************************************************************/
2236 int cx231xx_set_power_mode(struct cx231xx
*dev
, enum AV_MODE mode
)
2238 u8 value
[4] = { 0, 0, 0, 0 };
2242 if (dev
->power_mode
!= mode
)
2243 dev
->power_mode
= mode
;
2245 cx231xx_info(" setPowerMode::mode = %d, No Change req.\n",
2250 status
= cx231xx_read_ctrl_reg(dev
, VRT_GET_REGISTER
, PWR_CTL_EN
, value
,
2255 tmp
= *((u32
*) value
);
2258 case POLARIS_AVMODE_ENXTERNAL_AV
:
2260 tmp
&= (~PWR_MODE_MASK
);
2263 value
[0] = (u8
) tmp
;
2264 value
[1] = (u8
) (tmp
>> 8);
2265 value
[2] = (u8
) (tmp
>> 16);
2266 value
[3] = (u8
) (tmp
>> 24);
2267 status
= cx231xx_write_ctrl_reg(dev
, VRT_SET_REGISTER
,
2268 PWR_CTL_EN
, value
, 4);
2269 msleep(PWR_SLEEP_INTERVAL
);
2272 value
[0] = (u8
) tmp
;
2273 value
[1] = (u8
) (tmp
>> 8);
2274 value
[2] = (u8
) (tmp
>> 16);
2275 value
[3] = (u8
) (tmp
>> 24);
2277 cx231xx_write_ctrl_reg(dev
, VRT_SET_REGISTER
, PWR_CTL_EN
,
2279 msleep(PWR_SLEEP_INTERVAL
);
2281 tmp
|= POLARIS_AVMODE_ENXTERNAL_AV
;
2282 value
[0] = (u8
) tmp
;
2283 value
[1] = (u8
) (tmp
>> 8);
2284 value
[2] = (u8
) (tmp
>> 16);
2285 value
[3] = (u8
) (tmp
>> 24);
2286 status
= cx231xx_write_ctrl_reg(dev
, VRT_SET_REGISTER
,
2287 PWR_CTL_EN
, value
, 4);
2289 /* reset state of xceive tuner */
2290 dev
->xc_fw_load_done
= 0;
2293 case POLARIS_AVMODE_ANALOGT_TV
:
2295 tmp
|= PWR_DEMOD_EN
;
2296 tmp
|= (I2C_DEMOD_EN
);
2297 value
[0] = (u8
) tmp
;
2298 value
[1] = (u8
) (tmp
>> 8);
2299 value
[2] = (u8
) (tmp
>> 16);
2300 value
[3] = (u8
) (tmp
>> 24);
2301 status
= cx231xx_write_ctrl_reg(dev
, VRT_SET_REGISTER
,
2302 PWR_CTL_EN
, value
, 4);
2303 msleep(PWR_SLEEP_INTERVAL
);
2305 if (!(tmp
& PWR_TUNER_EN
)) {
2306 tmp
|= (PWR_TUNER_EN
);
2307 value
[0] = (u8
) tmp
;
2308 value
[1] = (u8
) (tmp
>> 8);
2309 value
[2] = (u8
) (tmp
>> 16);
2310 value
[3] = (u8
) (tmp
>> 24);
2311 status
= cx231xx_write_ctrl_reg(dev
, VRT_SET_REGISTER
,
2312 PWR_CTL_EN
, value
, 4);
2313 msleep(PWR_SLEEP_INTERVAL
);
2316 if (!(tmp
& PWR_AV_EN
)) {
2318 value
[0] = (u8
) tmp
;
2319 value
[1] = (u8
) (tmp
>> 8);
2320 value
[2] = (u8
) (tmp
>> 16);
2321 value
[3] = (u8
) (tmp
>> 24);
2322 status
= cx231xx_write_ctrl_reg(dev
, VRT_SET_REGISTER
,
2323 PWR_CTL_EN
, value
, 4);
2324 msleep(PWR_SLEEP_INTERVAL
);
2326 if (!(tmp
& PWR_ISO_EN
)) {
2328 value
[0] = (u8
) tmp
;
2329 value
[1] = (u8
) (tmp
>> 8);
2330 value
[2] = (u8
) (tmp
>> 16);
2331 value
[3] = (u8
) (tmp
>> 24);
2332 status
= cx231xx_write_ctrl_reg(dev
, VRT_SET_REGISTER
,
2333 PWR_CTL_EN
, value
, 4);
2334 msleep(PWR_SLEEP_INTERVAL
);
2337 if (!(tmp
& POLARIS_AVMODE_ANALOGT_TV
)) {
2338 tmp
|= POLARIS_AVMODE_ANALOGT_TV
;
2339 value
[0] = (u8
) tmp
;
2340 value
[1] = (u8
) (tmp
>> 8);
2341 value
[2] = (u8
) (tmp
>> 16);
2342 value
[3] = (u8
) (tmp
>> 24);
2343 status
= cx231xx_write_ctrl_reg(dev
, VRT_SET_REGISTER
,
2344 PWR_CTL_EN
, value
, 4);
2345 msleep(PWR_SLEEP_INTERVAL
);
2348 if ((dev
->model
== CX231XX_BOARD_CNXT_CARRAERA
) ||
2349 (dev
->model
== CX231XX_BOARD_CNXT_RDE_250
) ||
2350 (dev
->model
== CX231XX_BOARD_CNXT_SHELBY
) ||
2351 (dev
->model
== CX231XX_BOARD_CNXT_RDU_250
)) {
2352 /* tuner path to channel 1 from port 3 */
2353 cx231xx_enable_i2c_for_tuner(dev
, I2C_3
);
2355 /* reset the Tuner */
2356 cx231xx_gpio_set(dev
, dev
->board
.tuner_gpio
);
2358 if (dev
->cx231xx_reset_analog_tuner
)
2359 dev
->cx231xx_reset_analog_tuner(dev
);
2360 } else if ((dev
->model
== CX231XX_BOARD_CNXT_RDE_253S
) ||
2361 (dev
->model
== CX231XX_BOARD_CNXT_VIDEO_GRABBER
) ||
2362 (dev
->model
== CX231XX_BOARD_CNXT_RDU_253S
)) {
2363 /* tuner path to channel 1 from port 3 */
2364 cx231xx_enable_i2c_for_tuner(dev
, I2C_3
);
2365 if (dev
->cx231xx_reset_analog_tuner
)
2366 dev
->cx231xx_reset_analog_tuner(dev
);
2367 } else if (dev
->model
== CX231XX_BOARD_HAUPPAUGE_EXETER
) {
2368 /* tuner path to channel 1 from port 1 ?? */
2369 cx231xx_enable_i2c_for_tuner(dev
, I2C_1
);
2371 if (dev
->cx231xx_reset_analog_tuner
)
2372 dev
->cx231xx_reset_analog_tuner(dev
);
2377 case POLARIS_AVMODE_DIGITAL
:
2378 if (!(tmp
& PWR_TUNER_EN
)) {
2379 tmp
|= (PWR_TUNER_EN
);
2380 value
[0] = (u8
) tmp
;
2381 value
[1] = (u8
) (tmp
>> 8);
2382 value
[2] = (u8
) (tmp
>> 16);
2383 value
[3] = (u8
) (tmp
>> 24);
2384 status
= cx231xx_write_ctrl_reg(dev
, VRT_SET_REGISTER
,
2385 PWR_CTL_EN
, value
, 4);
2386 msleep(PWR_SLEEP_INTERVAL
);
2388 if (!(tmp
& PWR_AV_EN
)) {
2390 value
[0] = (u8
) tmp
;
2391 value
[1] = (u8
) (tmp
>> 8);
2392 value
[2] = (u8
) (tmp
>> 16);
2393 value
[3] = (u8
) (tmp
>> 24);
2394 status
= cx231xx_write_ctrl_reg(dev
, VRT_SET_REGISTER
,
2395 PWR_CTL_EN
, value
, 4);
2396 msleep(PWR_SLEEP_INTERVAL
);
2398 if (!(tmp
& PWR_ISO_EN
)) {
2400 value
[0] = (u8
) tmp
;
2401 value
[1] = (u8
) (tmp
>> 8);
2402 value
[2] = (u8
) (tmp
>> 16);
2403 value
[3] = (u8
) (tmp
>> 24);
2404 status
= cx231xx_write_ctrl_reg(dev
, VRT_SET_REGISTER
,
2405 PWR_CTL_EN
, value
, 4);
2406 msleep(PWR_SLEEP_INTERVAL
);
2409 tmp
|= POLARIS_AVMODE_DIGITAL
| I2C_DEMOD_EN
;
2410 value
[0] = (u8
) tmp
;
2411 value
[1] = (u8
) (tmp
>> 8);
2412 value
[2] = (u8
) (tmp
>> 16);
2413 value
[3] = (u8
) (tmp
>> 24);
2414 status
= cx231xx_write_ctrl_reg(dev
, VRT_SET_REGISTER
,
2415 PWR_CTL_EN
, value
, 4);
2416 msleep(PWR_SLEEP_INTERVAL
);
2418 if (!(tmp
& PWR_DEMOD_EN
)) {
2419 tmp
|= PWR_DEMOD_EN
;
2420 value
[0] = (u8
) tmp
;
2421 value
[1] = (u8
) (tmp
>> 8);
2422 value
[2] = (u8
) (tmp
>> 16);
2423 value
[3] = (u8
) (tmp
>> 24);
2424 status
= cx231xx_write_ctrl_reg(dev
, VRT_SET_REGISTER
,
2425 PWR_CTL_EN
, value
, 4);
2426 msleep(PWR_SLEEP_INTERVAL
);
2429 if ((dev
->model
== CX231XX_BOARD_CNXT_CARRAERA
) ||
2430 (dev
->model
== CX231XX_BOARD_CNXT_RDE_250
) ||
2431 (dev
->model
== CX231XX_BOARD_CNXT_SHELBY
) ||
2432 (dev
->model
== CX231XX_BOARD_CNXT_RDU_250
)) {
2433 /* tuner path to channel 1 from port 3 */
2434 cx231xx_enable_i2c_for_tuner(dev
, I2C_3
);
2436 /* reset the Tuner */
2437 cx231xx_gpio_set(dev
, dev
->board
.tuner_gpio
);
2439 if (dev
->cx231xx_reset_analog_tuner
)
2440 dev
->cx231xx_reset_analog_tuner(dev
);
2441 } else if ((dev
->model
== CX231XX_BOARD_CNXT_RDE_253S
) ||
2442 (dev
->model
== CX231XX_BOARD_CNXT_VIDEO_GRABBER
) ||
2443 (dev
->model
== CX231XX_BOARD_CNXT_RDU_253S
)) {
2444 /* tuner path to channel 1 from port 3 */
2445 cx231xx_enable_i2c_for_tuner(dev
, I2C_3
);
2446 if (dev
->cx231xx_reset_analog_tuner
)
2447 dev
->cx231xx_reset_analog_tuner(dev
);
2448 } else if (dev
->model
== CX231XX_BOARD_HAUPPAUGE_EXETER
) {
2449 /* tuner path to channel 1 from port 1 ?? */
2450 cx231xx_enable_i2c_for_tuner(dev
, I2C_1
);
2452 if (dev
->cx231xx_reset_analog_tuner
)
2453 dev
->cx231xx_reset_analog_tuner(dev
);
2462 msleep(PWR_SLEEP_INTERVAL
);
2464 /* For power saving, only enable Pwr_resetout_n
2465 when digital TV is selected. */
2466 if (mode
== POLARIS_AVMODE_DIGITAL
) {
2467 tmp
|= PWR_RESETOUT_EN
;
2468 value
[0] = (u8
) tmp
;
2469 value
[1] = (u8
) (tmp
>> 8);
2470 value
[2] = (u8
) (tmp
>> 16);
2471 value
[3] = (u8
) (tmp
>> 24);
2472 status
= cx231xx_write_ctrl_reg(dev
, VRT_SET_REGISTER
,
2473 PWR_CTL_EN
, value
, 4);
2474 msleep(PWR_SLEEP_INTERVAL
);
2477 /* update power control for afe */
2478 status
= cx231xx_afe_update_power_control(dev
, mode
);
2480 /* update power control for i2s_blk */
2481 status
= cx231xx_i2s_blk_update_power_control(dev
, mode
);
2483 status
= cx231xx_read_ctrl_reg(dev
, VRT_GET_REGISTER
, PWR_CTL_EN
, value
,
2489 int cx231xx_power_suspend(struct cx231xx
*dev
)
2491 u8 value
[4] = { 0, 0, 0, 0 };
2495 status
= cx231xx_read_ctrl_reg(dev
, VRT_GET_REGISTER
, PWR_CTL_EN
,
2500 tmp
= *((u32
*) value
);
2501 tmp
&= (~PWR_MODE_MASK
);
2503 value
[0] = (u8
) tmp
;
2504 value
[1] = (u8
) (tmp
>> 8);
2505 value
[2] = (u8
) (tmp
>> 16);
2506 value
[3] = (u8
) (tmp
>> 24);
2507 status
= cx231xx_write_ctrl_reg(dev
, VRT_SET_REGISTER
, PWR_CTL_EN
,
2513 /******************************************************************************
2514 * S T R E A M C O N T R O L functions *
2515 ******************************************************************************/
2516 int cx231xx_start_stream(struct cx231xx
*dev
, u32 ep_mask
)
2518 u8 value
[4] = { 0x0, 0x0, 0x0, 0x0 };
2522 cx231xx_info("cx231xx_start_stream():: ep_mask = %x\n", ep_mask
);
2523 status
= cx231xx_read_ctrl_reg(dev
, VRT_GET_REGISTER
, EP_MODE_SET
,
2528 tmp
= *((u32
*) value
);
2530 value
[0] = (u8
) tmp
;
2531 value
[1] = (u8
) (tmp
>> 8);
2532 value
[2] = (u8
) (tmp
>> 16);
2533 value
[3] = (u8
) (tmp
>> 24);
2535 status
= cx231xx_write_ctrl_reg(dev
, VRT_SET_REGISTER
, EP_MODE_SET
,
2541 int cx231xx_stop_stream(struct cx231xx
*dev
, u32 ep_mask
)
2543 u8 value
[4] = { 0x0, 0x0, 0x0, 0x0 };
2547 cx231xx_info("cx231xx_stop_stream():: ep_mask = %x\n", ep_mask
);
2549 cx231xx_read_ctrl_reg(dev
, VRT_GET_REGISTER
, EP_MODE_SET
, value
, 4);
2553 tmp
= *((u32
*) value
);
2555 value
[0] = (u8
) tmp
;
2556 value
[1] = (u8
) (tmp
>> 8);
2557 value
[2] = (u8
) (tmp
>> 16);
2558 value
[3] = (u8
) (tmp
>> 24);
2560 status
= cx231xx_write_ctrl_reg(dev
, VRT_SET_REGISTER
, EP_MODE_SET
,
2566 int cx231xx_initialize_stream_xfer(struct cx231xx
*dev
, u32 media_type
)
2570 u8 val
[4] = { 0, 0, 0, 0 };
2572 if (dev
->udev
->speed
== USB_SPEED_HIGH
) {
2573 switch (media_type
) {
2574 case 81: /* audio */
2575 cx231xx_info("%s: Audio enter HANC\n", __func__
);
2577 cx231xx_mode_register(dev
, TS_MODE_REG
, 0x9300);
2581 cx231xx_info("%s: set vanc registers\n", __func__
);
2582 status
= cx231xx_mode_register(dev
, TS_MODE_REG
, 0x300);
2585 case 3: /* sliced cc */
2586 cx231xx_info("%s: set hanc registers\n", __func__
);
2588 cx231xx_mode_register(dev
, TS_MODE_REG
, 0x1300);
2592 cx231xx_info("%s: set video registers\n", __func__
);
2593 status
= cx231xx_mode_register(dev
, TS_MODE_REG
, 0x100);
2597 cx231xx_info("%s: set ts1 registers", __func__
);
2599 if (dev
->model
== CX231XX_BOARD_CNXT_VIDEO_GRABBER
) {
2600 cx231xx_info(" MPEG\n");
2601 value
&= 0xFFFFFFFC;
2604 status
= cx231xx_mode_register(dev
, TS_MODE_REG
, value
);
2610 status
= cx231xx_write_ctrl_reg(dev
, VRT_SET_REGISTER
,
2611 TS1_CFG_REG
, val
, 4);
2617 status
= cx231xx_write_ctrl_reg(dev
, VRT_SET_REGISTER
,
2618 TS1_LENGTH_REG
, val
, 4);
2621 cx231xx_info(" BDA\n");
2622 status
= cx231xx_mode_register(dev
, TS_MODE_REG
, 0x101);
2623 status
= cx231xx_mode_register(dev
, TS1_CFG_REG
, 0x010);
2627 case 6: /* ts1 parallel mode */
2628 cx231xx_info("%s: set ts1 parrallel mode registers\n",
2630 status
= cx231xx_mode_register(dev
, TS_MODE_REG
, 0x100);
2631 status
= cx231xx_mode_register(dev
, TS1_CFG_REG
, 0x400);
2635 status
= cx231xx_mode_register(dev
, TS_MODE_REG
, 0x101);
2641 int cx231xx_capture_start(struct cx231xx
*dev
, int start
, u8 media_type
)
2645 struct pcb_config
*pcb_config
;
2647 /* get EP for media type */
2648 pcb_config
= (struct pcb_config
*)&dev
->current_pcb_config
;
2650 if (pcb_config
->config_num
== 1) {
2651 switch (media_type
) {
2653 ep_mask
= ENABLE_EP4
; /* ep4 [00:1000] */
2656 ep_mask
= ENABLE_EP3
; /* ep3 [00:0100] */
2659 ep_mask
= ENABLE_EP5
; /* ep5 [01:0000] */
2661 case 3: /* Sliced_cc */
2662 ep_mask
= ENABLE_EP6
; /* ep6 [10:0000] */
2665 case 6: /* ts1 parallel mode */
2666 ep_mask
= ENABLE_EP1
; /* ep1 [00:0001] */
2669 ep_mask
= ENABLE_EP2
; /* ep2 [00:0010] */
2673 } else if (pcb_config
->config_num
> 1) {
2674 switch (media_type
) {
2676 ep_mask
= ENABLE_EP4
; /* ep4 [00:1000] */
2679 ep_mask
= ENABLE_EP3
; /* ep3 [00:0100] */
2682 ep_mask
= ENABLE_EP5
; /* ep5 [01:0000] */
2684 case 3: /* Sliced_cc */
2685 ep_mask
= ENABLE_EP6
; /* ep6 [10:0000] */
2688 case 6: /* ts1 parallel mode */
2689 ep_mask
= ENABLE_EP1
; /* ep1 [00:0001] */
2692 ep_mask
= ENABLE_EP2
; /* ep2 [00:0010] */
2699 rc
= cx231xx_initialize_stream_xfer(dev
, media_type
);
2704 /* enable video capture */
2706 rc
= cx231xx_start_stream(dev
, ep_mask
);
2708 /* disable video capture */
2710 rc
= cx231xx_stop_stream(dev
, ep_mask
);
2713 if (dev
->mode
== CX231XX_ANALOG_MODE
)
2714 ;/* do any in Analog mode */
2716 ;/* do any in digital mode */
2720 EXPORT_SYMBOL_GPL(cx231xx_capture_start
);
2722 /*****************************************************************************
2723 * G P I O B I T control functions *
2724 ******************************************************************************/
2725 int cx231xx_set_gpio_bit(struct cx231xx
*dev
, u32 gpio_bit
, u8
*gpio_val
)
2729 status
= cx231xx_send_gpio_cmd(dev
, gpio_bit
, gpio_val
, 4, 0, 0);
2734 int cx231xx_get_gpio_bit(struct cx231xx
*dev
, u32 gpio_bit
, u8
*gpio_val
)
2738 status
= cx231xx_send_gpio_cmd(dev
, gpio_bit
, gpio_val
, 4, 0, 1);
2744 * cx231xx_set_gpio_direction
2745 * Sets the direction of the GPIO pin to input or output
2748 * pin_number : The GPIO Pin number to program the direction for
2750 * pin_value : The Direction of the GPIO Pin under reference.
2751 * 0 = Input direction
2752 * 1 = Output direction
2754 int cx231xx_set_gpio_direction(struct cx231xx
*dev
,
2755 int pin_number
, int pin_value
)
2760 /* Check for valid pin_number - if 32 , bail out */
2761 if (pin_number
>= 32)
2766 value
= dev
->gpio_dir
& (~(1 << pin_number
)); /* clear */
2768 value
= dev
->gpio_dir
| (1 << pin_number
);
2770 status
= cx231xx_set_gpio_bit(dev
, value
, (u8
*) &dev
->gpio_val
);
2772 /* cache the value for future */
2773 dev
->gpio_dir
= value
;
2779 * cx231xx_set_gpio_value
2780 * Sets the value of the GPIO pin to Logic high or low. The Pin under
2781 * reference should ALREADY BE SET IN OUTPUT MODE !!!!!!!!!
2784 * pin_number : The GPIO Pin number to program the direction for
2785 * pin_value : The value of the GPIO Pin under reference.
2789 int cx231xx_set_gpio_value(struct cx231xx
*dev
, int pin_number
, int pin_value
)
2794 /* Check for valid pin_number - if 0xFF , bail out */
2795 if (pin_number
>= 32)
2798 /* first do a sanity check - if the Pin is not output, make it output */
2799 if ((dev
->gpio_dir
& (1 << pin_number
)) == 0x00) {
2800 /* It was in input mode */
2801 value
= dev
->gpio_dir
| (1 << pin_number
);
2802 dev
->gpio_dir
= value
;
2803 status
= cx231xx_set_gpio_bit(dev
, dev
->gpio_dir
,
2804 (u8
*) &dev
->gpio_val
);
2809 value
= dev
->gpio_val
& (~(1 << pin_number
));
2811 value
= dev
->gpio_val
| (1 << pin_number
);
2813 /* store the value */
2814 dev
->gpio_val
= value
;
2816 /* toggle bit0 of GP_IO */
2817 status
= cx231xx_set_gpio_bit(dev
, dev
->gpio_dir
, (u8
*)&dev
->gpio_val
);
2822 /*****************************************************************************
2823 * G P I O I2C related functions *
2824 ******************************************************************************/
2825 int cx231xx_gpio_i2c_start(struct cx231xx
*dev
)
2829 /* set SCL to output 1 ; set SDA to output 1 */
2830 dev
->gpio_dir
|= 1 << dev
->board
.tuner_scl_gpio
;
2831 dev
->gpio_dir
|= 1 << dev
->board
.tuner_sda_gpio
;
2832 dev
->gpio_val
|= 1 << dev
->board
.tuner_scl_gpio
;
2833 dev
->gpio_val
|= 1 << dev
->board
.tuner_sda_gpio
;
2835 status
= cx231xx_set_gpio_bit(dev
, dev
->gpio_dir
, (u8
*)&dev
->gpio_val
);
2839 /* set SCL to output 1; set SDA to output 0 */
2840 dev
->gpio_val
|= 1 << dev
->board
.tuner_scl_gpio
;
2841 dev
->gpio_val
&= ~(1 << dev
->board
.tuner_sda_gpio
);
2843 status
= cx231xx_set_gpio_bit(dev
, dev
->gpio_dir
, (u8
*)&dev
->gpio_val
);
2847 /* set SCL to output 0; set SDA to output 0 */
2848 dev
->gpio_val
&= ~(1 << dev
->board
.tuner_scl_gpio
);
2849 dev
->gpio_val
&= ~(1 << dev
->board
.tuner_sda_gpio
);
2851 status
= cx231xx_set_gpio_bit(dev
, dev
->gpio_dir
, (u8
*)&dev
->gpio_val
);
2858 int cx231xx_gpio_i2c_end(struct cx231xx
*dev
)
2862 /* set SCL to output 0; set SDA to output 0 */
2863 dev
->gpio_dir
|= 1 << dev
->board
.tuner_scl_gpio
;
2864 dev
->gpio_dir
|= 1 << dev
->board
.tuner_sda_gpio
;
2866 dev
->gpio_val
&= ~(1 << dev
->board
.tuner_scl_gpio
);
2867 dev
->gpio_val
&= ~(1 << dev
->board
.tuner_sda_gpio
);
2869 status
= cx231xx_set_gpio_bit(dev
, dev
->gpio_dir
, (u8
*)&dev
->gpio_val
);
2873 /* set SCL to output 1; set SDA to output 0 */
2874 dev
->gpio_val
|= 1 << dev
->board
.tuner_scl_gpio
;
2875 dev
->gpio_val
&= ~(1 << dev
->board
.tuner_sda_gpio
);
2877 status
= cx231xx_set_gpio_bit(dev
, dev
->gpio_dir
, (u8
*)&dev
->gpio_val
);
2881 /* set SCL to input ,release SCL cable control
2882 set SDA to input ,release SDA cable control */
2883 dev
->gpio_dir
&= ~(1 << dev
->board
.tuner_scl_gpio
);
2884 dev
->gpio_dir
&= ~(1 << dev
->board
.tuner_sda_gpio
);
2887 cx231xx_set_gpio_bit(dev
, dev
->gpio_dir
, (u8
*)&dev
->gpio_val
);
2894 int cx231xx_gpio_i2c_write_byte(struct cx231xx
*dev
, u8 data
)
2899 /* set SCL to output ; set SDA to output */
2900 dev
->gpio_dir
|= 1 << dev
->board
.tuner_scl_gpio
;
2901 dev
->gpio_dir
|= 1 << dev
->board
.tuner_sda_gpio
;
2903 for (i
= 0; i
< 8; i
++) {
2904 if (((data
<< i
) & 0x80) == 0) {
2905 /* set SCL to output 0; set SDA to output 0 */
2906 dev
->gpio_val
&= ~(1 << dev
->board
.tuner_scl_gpio
);
2907 dev
->gpio_val
&= ~(1 << dev
->board
.tuner_sda_gpio
);
2908 status
= cx231xx_set_gpio_bit(dev
, dev
->gpio_dir
,
2909 (u8
*)&dev
->gpio_val
);
2911 /* set SCL to output 1; set SDA to output 0 */
2912 dev
->gpio_val
|= 1 << dev
->board
.tuner_scl_gpio
;
2913 status
= cx231xx_set_gpio_bit(dev
, dev
->gpio_dir
,
2914 (u8
*)&dev
->gpio_val
);
2916 /* set SCL to output 0; set SDA to output 0 */
2917 dev
->gpio_val
&= ~(1 << dev
->board
.tuner_scl_gpio
);
2918 status
= cx231xx_set_gpio_bit(dev
, dev
->gpio_dir
,
2919 (u8
*)&dev
->gpio_val
);
2921 /* set SCL to output 0; set SDA to output 1 */
2922 dev
->gpio_val
&= ~(1 << dev
->board
.tuner_scl_gpio
);
2923 dev
->gpio_val
|= 1 << dev
->board
.tuner_sda_gpio
;
2924 status
= cx231xx_set_gpio_bit(dev
, dev
->gpio_dir
,
2925 (u8
*)&dev
->gpio_val
);
2927 /* set SCL to output 1; set SDA to output 1 */
2928 dev
->gpio_val
|= 1 << dev
->board
.tuner_scl_gpio
;
2929 status
= cx231xx_set_gpio_bit(dev
, dev
->gpio_dir
,
2930 (u8
*)&dev
->gpio_val
);
2932 /* set SCL to output 0; set SDA to output 1 */
2933 dev
->gpio_val
&= ~(1 << dev
->board
.tuner_scl_gpio
);
2934 status
= cx231xx_set_gpio_bit(dev
, dev
->gpio_dir
,
2935 (u8
*)&dev
->gpio_val
);
2941 int cx231xx_gpio_i2c_read_byte(struct cx231xx
*dev
, u8
*buf
)
2945 u32 gpio_logic_value
= 0;
2949 for (i
= 0; i
< 8; i
++) { /* send write I2c addr */
2951 /* set SCL to output 0; set SDA to input */
2952 dev
->gpio_val
&= ~(1 << dev
->board
.tuner_scl_gpio
);
2953 status
= cx231xx_set_gpio_bit(dev
, dev
->gpio_dir
,
2954 (u8
*)&dev
->gpio_val
);
2956 /* set SCL to output 1; set SDA to input */
2957 dev
->gpio_val
|= 1 << dev
->board
.tuner_scl_gpio
;
2958 status
= cx231xx_set_gpio_bit(dev
, dev
->gpio_dir
,
2959 (u8
*)&dev
->gpio_val
);
2961 /* get SDA data bit */
2962 gpio_logic_value
= dev
->gpio_val
;
2963 status
= cx231xx_get_gpio_bit(dev
, dev
->gpio_dir
,
2964 (u8
*)&dev
->gpio_val
);
2965 if ((dev
->gpio_val
& (1 << dev
->board
.tuner_sda_gpio
)) != 0)
2966 value
|= (1 << (8 - i
- 1));
2968 dev
->gpio_val
= gpio_logic_value
;
2971 /* set SCL to output 0,finish the read latest SCL signal.
2972 !!!set SDA to input, never to modify SDA direction at
2974 dev
->gpio_val
&= ~(1 << dev
->board
.tuner_scl_gpio
);
2975 status
= cx231xx_set_gpio_bit(dev
, dev
->gpio_dir
, (u8
*)&dev
->gpio_val
);
2977 /* store the value */
2978 *buf
= value
& 0xff;
2983 int cx231xx_gpio_i2c_read_ack(struct cx231xx
*dev
)
2986 u32 gpio_logic_value
= 0;
2990 /* clock stretch; set SCL to input; set SDA to input;
2991 get SCL value till SCL = 1 */
2992 dev
->gpio_dir
&= ~(1 << dev
->board
.tuner_sda_gpio
);
2993 dev
->gpio_dir
&= ~(1 << dev
->board
.tuner_scl_gpio
);
2995 gpio_logic_value
= dev
->gpio_val
;
2996 status
= cx231xx_set_gpio_bit(dev
, dev
->gpio_dir
, (u8
*)&dev
->gpio_val
);
3000 status
= cx231xx_get_gpio_bit(dev
, dev
->gpio_dir
,
3001 (u8
*)&dev
->gpio_val
);
3003 } while (((dev
->gpio_val
&
3004 (1 << dev
->board
.tuner_scl_gpio
)) == 0) &&
3008 cx231xx_info("No ACK after %d msec -GPIO I2C failed!",
3013 * through clock stretch, slave has given a SCL signal,
3014 * so the SDA data can be directly read.
3016 status
= cx231xx_get_gpio_bit(dev
, dev
->gpio_dir
, (u8
*)&dev
->gpio_val
);
3018 if ((dev
->gpio_val
& 1 << dev
->board
.tuner_sda_gpio
) == 0) {
3019 dev
->gpio_val
= gpio_logic_value
;
3020 dev
->gpio_val
&= ~(1 << dev
->board
.tuner_sda_gpio
);
3023 dev
->gpio_val
= gpio_logic_value
;
3024 dev
->gpio_val
|= (1 << dev
->board
.tuner_sda_gpio
);
3027 /* read SDA end, set the SCL to output 0, after this operation,
3028 SDA direction can be changed. */
3029 dev
->gpio_val
= gpio_logic_value
;
3030 dev
->gpio_dir
|= (1 << dev
->board
.tuner_scl_gpio
);
3031 dev
->gpio_val
&= ~(1 << dev
->board
.tuner_scl_gpio
);
3032 status
= cx231xx_set_gpio_bit(dev
, dev
->gpio_dir
, (u8
*)&dev
->gpio_val
);
3037 int cx231xx_gpio_i2c_write_ack(struct cx231xx
*dev
)
3041 /* set SDA to ouput */
3042 dev
->gpio_dir
|= 1 << dev
->board
.tuner_sda_gpio
;
3043 status
= cx231xx_set_gpio_bit(dev
, dev
->gpio_dir
, (u8
*)&dev
->gpio_val
);
3045 /* set SCL = 0 (output); set SDA = 0 (output) */
3046 dev
->gpio_val
&= ~(1 << dev
->board
.tuner_sda_gpio
);
3047 dev
->gpio_val
&= ~(1 << dev
->board
.tuner_scl_gpio
);
3048 status
= cx231xx_set_gpio_bit(dev
, dev
->gpio_dir
, (u8
*)&dev
->gpio_val
);
3050 /* set SCL = 1 (output); set SDA = 0 (output) */
3051 dev
->gpio_val
|= 1 << dev
->board
.tuner_scl_gpio
;
3052 status
= cx231xx_set_gpio_bit(dev
, dev
->gpio_dir
, (u8
*)&dev
->gpio_val
);
3054 /* set SCL = 0 (output); set SDA = 0 (output) */
3055 dev
->gpio_val
&= ~(1 << dev
->board
.tuner_scl_gpio
);
3056 status
= cx231xx_set_gpio_bit(dev
, dev
->gpio_dir
, (u8
*)&dev
->gpio_val
);
3058 /* set SDA to input,and then the slave will read data from SDA. */
3059 dev
->gpio_dir
&= ~(1 << dev
->board
.tuner_sda_gpio
);
3060 status
= cx231xx_set_gpio_bit(dev
, dev
->gpio_dir
, (u8
*)&dev
->gpio_val
);
3065 int cx231xx_gpio_i2c_write_nak(struct cx231xx
*dev
)
3069 /* set scl to output ; set sda to input */
3070 dev
->gpio_dir
|= 1 << dev
->board
.tuner_scl_gpio
;
3071 dev
->gpio_dir
&= ~(1 << dev
->board
.tuner_sda_gpio
);
3072 status
= cx231xx_set_gpio_bit(dev
, dev
->gpio_dir
, (u8
*)&dev
->gpio_val
);
3074 /* set scl to output 0; set sda to input */
3075 dev
->gpio_val
&= ~(1 << dev
->board
.tuner_scl_gpio
);
3076 status
= cx231xx_set_gpio_bit(dev
, dev
->gpio_dir
, (u8
*)&dev
->gpio_val
);
3078 /* set scl to output 1; set sda to input */
3079 dev
->gpio_val
|= 1 << dev
->board
.tuner_scl_gpio
;
3080 status
= cx231xx_set_gpio_bit(dev
, dev
->gpio_dir
, (u8
*)&dev
->gpio_val
);
3085 /*****************************************************************************
3086 * G P I O I2C related functions *
3087 ******************************************************************************/
3088 /* cx231xx_gpio_i2c_read
3089 * Function to read data from gpio based I2C interface
3091 int cx231xx_gpio_i2c_read(struct cx231xx
*dev
, u8 dev_addr
, u8
*buf
, u8 len
)
3097 mutex_lock(&dev
->gpio_i2c_lock
);
3100 status
= cx231xx_gpio_i2c_start(dev
);
3102 /* write dev_addr */
3103 status
= cx231xx_gpio_i2c_write_byte(dev
, (dev_addr
<< 1) + 1);
3106 status
= cx231xx_gpio_i2c_read_ack(dev
);
3109 for (i
= 0; i
< len
; i
++) {
3112 status
= cx231xx_gpio_i2c_read_byte(dev
, &buf
[i
]);
3114 if ((i
+ 1) != len
) {
3115 /* only do write ack if we more length */
3116 status
= cx231xx_gpio_i2c_write_ack(dev
);
3120 /* write NAK - inform reads are complete */
3121 status
= cx231xx_gpio_i2c_write_nak(dev
);
3124 status
= cx231xx_gpio_i2c_end(dev
);
3126 /* release the lock */
3127 mutex_unlock(&dev
->gpio_i2c_lock
);
3132 /* cx231xx_gpio_i2c_write
3133 * Function to write data to gpio based I2C interface
3135 int cx231xx_gpio_i2c_write(struct cx231xx
*dev
, u8 dev_addr
, u8
*buf
, u8 len
)
3141 mutex_lock(&dev
->gpio_i2c_lock
);
3144 status
= cx231xx_gpio_i2c_start(dev
);
3146 /* write dev_addr */
3147 status
= cx231xx_gpio_i2c_write_byte(dev
, dev_addr
<< 1);
3150 status
= cx231xx_gpio_i2c_read_ack(dev
);
3152 for (i
= 0; i
< len
; i
++) {
3154 status
= cx231xx_gpio_i2c_write_byte(dev
, buf
[i
]);
3157 status
= cx231xx_gpio_i2c_read_ack(dev
);
3161 status
= cx231xx_gpio_i2c_end(dev
);
3163 /* release the lock */
3164 mutex_unlock(&dev
->gpio_i2c_lock
);