示例#1
0
static int CardDetectPortForJM2(void)
{
#if defined(TCC892X_EMMC_BOOT)	//for TCC892x
	#if defined(TARGET_M805_892X_EVM) || defined(BOARD_TCC892X_STB_DEMO)
		return 0;	// 0: inserted,  1: removed
	#else
		#if (HW_REV == 0x1005)||(HW_REV == 0x1007)
		return (gpio_get(TCC_GPB(14)));
		#elif (HW_REV == 0x1006)
		return (gpio_get(TCC_GPE(26)));
		#elif (HW_REV == 0x1008)
		return (gpio_get(TCC_GPE(1)));
		#else	//(HW_REV >= 0x1000)&&(HW_REV <= 0x1004)
		return (gpio_get(TCC_GPD(12)));
		#endif
	#endif
#else	//for TCC880x

	PGPIO pGPIO = (PGPIO)(HwGPIO_BASE);

#if (HW_REV == 0x0614 || HW_REV == 0x0615 || HW_REV == 0x0621 || HW_REV == 0x0622 || HW_REV == 0x0623 || HW_REV == 0x0624)
	return (pGPIO->GPADAT&Hw13);
#else
	return (pGPIO->GPFDAT&Hw10);
#endif
#endif
}
示例#2
0
static int gpio_event_resume(struct platform_device *pdev)
{
#if 0	//Often does not wakeup in user mode. so, has commented. - 120303, hjbae
	int is_wakeup_by_powerkey = 0;
	PPMU pPMU = (PPMU)tcc_p2v(HwPMU_BASE);

#if defined(CONFIG_REGULATOR_AXP192_PEK) || defined(CONFIG_REGULATOR_AXP202_PEK)
	return 0;
#endif

	// WKUP from PowerKey & PowerKey is not pressed.
#if defined(CONFIG_MACH_M805_892X)
	if (system_rev == 0x2002 || system_rev == 0x2003 || system_rev == 0x2004 || system_rev == 0x2005)
	{
		if((pPMU->PMU_WKSTS1.bREG.GPIO_E15)&&(gpio_get_value(TCC_GPE(15))))
			is_wakeup_by_powerkey = 1;
	}
	else
	{
		if((pPMU->PMU_WKSTS0.bREG.GPIO_D09)&&(gpio_get_value(TCC_GPD(9))))
			is_wakeup_by_powerkey = 1;
	}
#elif defined(CONFIG_MACH_TCC8920ST)
	if((pPMU->PMU_WKSTS0.bREG.GPIO_D14)&&(gpio_get_value(TCC_GPD(14))))
		is_wakeup_by_powerkey = 1;
#elif defined(CONFIG_ARCH_TCC892X)
	if(system_rev == 0x1005 || system_rev == 0x1007 || system_rev == 0x1008)
	{
		if((pPMU->PMU_WKSTS1.bREG.GPIO_E30)&&(gpio_get_value(TCC_GPE(30))))
			is_wakeup_by_powerkey = 1;
	}
	else if(system_rev == 0x1006)
	{
		if((pPMU->PMU_WKSTS1.bREG.GPIO_E24)&&(gpio_get_value(TCC_GPE(24))))
			is_wakeup_by_powerkey = 1;
	}
	else
	{
		if((pPMU->PMU_WKSTS0.bREG.GPIO_G16)&&(gpio_get_value(TCC_GPG(16))))
			is_wakeup_by_powerkey = 1;
	}
#endif

	if (is_wakeup_by_powerkey == 1) {
		cancel_delayed_work(&work);
		if (event_dev)
			input_report_key(event_dev, KEY_POWER, 1);	//KEY_END
		queue_delayed_work(event_wq, &work, msecs_to_jiffies(100));

		printk("[Wakeup by Short PowerKey!!!]\n");
	}
#endif

	return 0;
}
static void sitronix_ts_port_init(void)
{
	volatile PGPIO pGPIO = (volatile PGPIO)tcc_p2v(HwGPIO_BASE);
	//int gp_penirq;

#if defined(CONFIG_ARCH_TCC88XX)
	if (machine_is_tcc8800()) {
		gp_penirq = TCC_GPA(6);
	}
#elif defined(CONFIG_ARCH_TCC892X)
	if (machine_is_tcc8920()) {
		if(system_rev == 0x1005 || system_rev == 0x1007)
			gp_penirq = TCC_GPB(11);
		else if(system_rev == 0x1006)
			gp_penirq = TCC_GPE(17);
		else if(system_rev == 0x1008)
			gp_penirq = TCC_GPE(5);
		else
			gp_penirq = TCC_GPG(18);
	}
#endif

      gpio_request(gp_penirq, "tsc_int");
      tcc_gpio_config(gp_penirq, GPIO_FN(0));
      gpio_direction_input(gp_penirq);

#if defined(CONFIG_ARCH_TCC88XX)
      if (machine_is_tcc8800()) {
		BITCSET(pGPIO->EINTSEL0 , HwEINTSEL0_EINT2_MASK, HwEINTSEL0_EINT2(SEL_GPIOA6));

		HwPIC->INTMSK0	|= Hw5;
		HwPIC->IEN0	&= ~Hw5;	/* disable Isr */
		HwPIC->MODEA0	&= ~Hw5; 	/* single edge */
		HwPIC->MODE0	&= ~Hw5;	/* set edge trigger mode */
		HwPIC->POL0	|= Hw5;		/* active-low */
		HwPIC->CLR0	|= Hw5;		/* clear pending status */
		HwPIC->SEL0	|= Hw5;		/* IRQ Select */
		HwPIC->IEN0	|= Hw5;
	}
#elif defined(CONFIG_ARCH_TCC892X)
	if (machine_is_tcc8920()) {
		if(system_rev == 0x1005 || system_rev == 0x1007)
			tcc_gpio_config_ext_intr(INT_EI2, EXTINT_GPIOB_11);
		else if(system_rev == 0x1006)
			tcc_gpio_config_ext_intr(INT_EI2, EXTINT_GPIOE_17);
		else if(system_rev == 0x1008)
			tcc_gpio_config_ext_intr(INT_EI2, EXTINT_GPIOE_05);
		else
			tcc_gpio_config_ext_intr(INT_EI2, EXTINT_GPIOG_18);
	}
#endif
}
示例#4
0
static int __init m803_init_mmc(void)
{
	if (!machine_is_m803())
		return 0;

	printk("%s\n",__func__);

	// system_rev : 0x0012 = M803 V0.2A
	if(system_rev == 0x0012 || system_rev == 0x0013)
	{
		// Change Card Detect
		mmc_ports[TCC_MMC_TYPE_SD].cd = TCC_GPE(25);
	}

#if defined(CONFIG_MMC_TCC_SDHC0)
	tcc_sdhc0_device.dev.platform_data = &m803_mmc_platform_data[0];
	platform_device_register(&tcc_sdhc0_device);
#endif
#if defined(CONFIG_MMC_TCC_SDHC1)
	tcc_sdhc1_device.dev.platform_data = &m803_mmc_platform_data[1];
	platform_device_register(&tcc_sdhc1_device);
#endif
#if defined(CONFIG_MMC_TCC_SDHC2)
	tcc_sdhc2_device.dev.platform_data = &m803_mmc_platform_data[2];
	platform_device_register(&tcc_sdhc2_device);
#endif
#if defined(CONFIG_MMC_TCC_SDHC3)
	tcc_sdhc3_device.dev.platform_data = &m803_mmc_platform_data[3];
	platform_device_register(&tcc_sdhc3_device);
#endif

	return 0;
}
int tcc_hp_is_valid(void)
{
#if defined(CONFIG_ARCH_TCC88XX)
    if(machine_is_m801_88()) {
        // gpio_get_value is ==> 0: disconnect, 1: connect
        return gpio_get_value(TCC_GPD(10));
    }
#elif defined(CONFIG_ARCH_TCC892X)
	if(machine_is_m805_892x())
	{
		// gpio_get_value is ==> 0: disconnect, 1: connect
		if(system_rev == 0x2002 || system_rev == 0x2003 || system_rev == 0x2004 || system_rev == 0x2005)
			return gpio_get_value(TCC_GPE(16));
		else
			return gpio_get_value(TCC_GPE(5));
	}
#endif

    return 0;
}
static void hp_un_mute(void)
{
#if defined(CONFIG_ARCH_TCC88XX)
	if(machine_is_m801_88())
		gpio_set_value(TCC_GPD(11), 1);
#elif defined(CONFIG_ARCH_TCC892X)
	if(machine_is_m805_892x())
	{
		if(system_rev == 0x2002 || system_rev == 0x2003 || system_rev == 0x2004 || system_rev == 0x2005)
			gpio_set_value(TCC_GPE(17), 1);
		else
			gpio_set_value(TCC_GPG(5), 1);
	}
#endif
}
static int rn5t614_port_init(int irq_num)
{
	if(system_rev == 0x1005 || system_rev == 0x1007)
	{
		tcc_gpio_config(TCC_GPE(29), GPIO_FN(0)|GPIO_PULL_DISABLE);  // GPIOE[31]: input mode, disable pull-up/down
		tcc_gpio_config_ext_intr(PMIC_IRQ, EXTINT_GPIOE_29);

		gpio_request(TCC_GPE(29), "PMIC_IRQ");
		gpio_direction_input(TCC_GPE(29));
	}
	else if(system_rev == 0x1006)
	{
		tcc_gpio_config(TCC_GPE(27), GPIO_FN(0)|GPIO_PULL_DISABLE);  // GPIOE[31]: input mode, disable pull-up/down
		tcc_gpio_config_ext_intr(PMIC_IRQ, EXTINT_GPIOE_27);

		gpio_request(TCC_GPE(27), "PMIC_IRQ");
		gpio_direction_input(TCC_GPE(27));
	}
	else if(system_rev == 0x1008)
	{
		tcc_gpio_config(TCC_GPD(9), GPIO_FN(0)|GPIO_PULL_DISABLE);  // GPIOE[31]: input mode, disable pull-up/down
		tcc_gpio_config_ext_intr(PMIC_IRQ, EXTINT_GPIOD_09);

		gpio_request(TCC_GPD(9), "PMIC_IRQ");
		gpio_direction_input(TCC_GPD(9));
	}
	else
	{
		tcc_gpio_config(TCC_GPE(31), GPIO_FN(0)|GPIO_PULL_DISABLE);  // GPIOE[31]: input mode, disable pull-up/down
		tcc_gpio_config_ext_intr(PMIC_IRQ, EXTINT_GPIOE_31);

		gpio_request(TCC_GPE(31), "PMIC_IRQ");
		gpio_direction_input(TCC_GPE(31));
	}

	return 0;
}
static void spk_un_mute(void)
{
#if defined(CONFIG_ARCH_TCC88XX)
	if(machine_is_m801_88())
		gpio_set_value(TCC_GPG(6), 1);
#elif defined(CONFIG_ARCH_TCC892X)
	if(machine_is_m805_892x())
	{
		if(system_rev == 0x2002 || system_rev == 0x2003 || system_rev == 0x2004 || system_rev == 0x2005) {
			gpio_set_value(TCC_GPE(18), 1);
		} else {
			#if defined(CONFIG_M805S_8923_0XA)
			gpio_set_value(TCC_GPG(11), 1);
			#else
			gpio_set_value(TCC_GPF(27), 1);
			#endif
		}
	}
#endif
}
示例#9
0
//  ************************************************************ //
//  Device Exit :
//
//  
//  ************************************************************ //
static void __exit gps_gpio_exit(void)  
{  

    gps_dbg("gps_gpio_exit");
	
    device_destroy(gps_class, MKDEV(gps_major, 0));
    class_destroy(gps_class);

    cdev_del(&gps_cdev);
    unregister_chrdev_region(dev, 1);

#if defined(CONFIG_MACH_TCC9300) || defined(CONFIG_MACH_TCC8800) || defined(CONFIG_MACH_TCC8920)
    // GPS Power off
    gps_dbg("GPS_PWREN off");
    if(machine_is_m801_88() || machine_is_m803()) // demo set
    {
        gpio_set_value(TCC_GPG(4), 0);
    }
    else if(machine_is_tcc8800() || machine_is_tcc8920())
    {
        gpio_direction_output(TCC_GPEXT1(6), 0);
    }
#elif defined(CONFIG_MACH_TCC8900)
    if(machine_is_tcc8900())    
    {
        gps_dbg("GPS_8900_PWREN off");
        gpio_set_value(TCC_GPD(25), 0);
    }
#elif defined(CONFIG_MACH_M805_892X)
    // GPS Power off
    gps_dbg("GPS_PWREN off");
    if(machine_is_m805_892x())
    {
		if (system_rev == 0x2002 || system_rev == 0x2003 || system_rev == 0x2004 || system_rev == 0x2005)
			gpio_set_value(TCC_GPE(14), 0);
		else
			gpio_set_value(TCC_GPC(6), 0);
    }
#endif
    gps_dbg("GPS driver unloaded");
}  
示例#10
0
//  ************************************************************ //
//  Device Open : 
//  when open, yet not ativity UART port
//  GPS device is yet disable status.
//  ************************************************************ //
static int gps_gpio_open (struct inode *inode, struct file *filp)  
{
    gps_k_flag = 0;   
    // Set the Port Configure for the UART5
    // GPIO SETTING
    gps_dbg("gps_gpio_open\n");
#if defined(CONFIG_MACH_TCC9300) || defined(CONFIG_MACH_TCC8800) || defined(CONFIG_MACH_TCC8920)
    if(machine_is_m801_88() || machine_is_m803()) // GPIOG[4]
    {
        gpio_set_value(TCC_GPG(4), 0);
    }
    else if(machine_is_tcc8800() || machine_is_tcc8920())
    {
        gps_dbg("gps_gpio_open -> set_velue");
        gpio_set_value(TCC_GPEXT1(6), 0);
    }
#elif defined(CONFIG_MACH_TCC8900)
    if(machine_is_tcc8900())
    {
        gps_dbg("machine_is_tcc8900 : gps_gpio_open\n\n");
        gpio_set_value(TCC_GPD(25), 0);    
    }
#elif defined(CONFIG_MACH_M805_892X)
    if(machine_is_m805_892x())
    {
		if (system_rev == 0x2002 || system_rev == 0x2003 || system_rev == 0x2004 || system_rev == 0x2005)
			gpio_set_value(TCC_GPE(14), 0);
		else
        	gpio_set_value(TCC_GPC(6), 0);
    }
#else

#endif


    gps_dbg("tcc92xx : gps_gpio_open\n\n");
    return 0;  
}
示例#11
0
static void lcdc_io_init_component(unsigned char lcdc_num, unsigned char type)
{
	unsigned int lcd_reg = 0;
	unsigned int width, height;
	stCOMPONENT_SPEC spec;
	stLTIMING		ComponentTiming;
	stLCDCTR		LcdCtrlParam;
	PVIOC_DISP		pDISPBase;
	PVIOC_WMIX		pWIXBase;
	PDDICONFIG 		pDDICfg = (PDDICONFIG)HwDDI_CONFIG_BASE;
	PNTSCPAL 		pTVE = (PNTSCPAL)HwNTSCPAL_BASE;
	PGPIO 			pGPIO = (PGPIO)HwGPIO_BASE;
	struct fbcon_config *fb_con;

	printf("%s, lcdc_num=%d, type=%d\n", __func__, lcdc_num, type);
		
	if(type >= LCDC_COMPONENT_MAX)
		type = defalut_component_resolution;

	#if defined(COMPONENT_CHIP_THS8200)
		#if defined(TARGET_BOARD_STB)
			/* THS8200 Power Control - GPIO_F16 */
			gpio_set(TCC_GPF(16), 1);
		#else
		#endif
	#endif

	#ifndef DEFAULT_DISPLAY_OUTPUT_DUAL
		BITSET(pTVE->DACPD, HwTVEDACPD_PD_EN);
	#endif
		
	component_get_spec(type, &spec);
	
	LCDC_IO_Set(lcdc_num, spec.component_bus_width);

	fb_con = &fb_cfg;
			
	if(lcdc_num)	
	{
		pDISPBase = (VIOC_DISP *)HwVIOC_DISP1;
		pWIXBase =(VIOC_WMIX *)HwVIOC_WMIX1; 
		tca_ckc_setperi(PERI_LCD1, ENABLE, spec.component_clock*spec.component_divider);
		//VIOC_OUTCFG_SetOutConfig(VIOC_OUTCFG_MRGB, VIOC_OUTCFG_DISP1);
	}
	else
	{
		pDISPBase = (VIOC_DISP *)HwVIOC_DISP0;
		pWIXBase =(VIOC_WMIX *)HwVIOC_WMIX0; 
		tca_ckc_setperi(PERI_LCD0, ENABLE, spec.component_clock*spec.component_divider);
		//VIOC_OUTCFG_SetOutConfig(VIOC_OUTCFG_MRGB, VIOC_OUTCFG_DISP0);
	}

	printf("LCDC0 clk:%d, LCDC1 clk:%d, PLL:%d, divide:%d\n", tca_ckc_getperi(PERI_LCD0), tca_ckc_getperi(PERI_LCD1), tca_ckc_getpll(PCDIRECTPLL0), spec.component_divider);
	
	width = spec.component_width;
	height = spec.component_height;

 	lcdc_set_logo(lcdc_num, width, height, fb_con);
	
	ComponentTiming.lpw = spec.component_LPW;
	ComponentTiming.lpc = spec.component_LPC + 1;
	ComponentTiming.lswc = spec.component_LSWC + 1;
	ComponentTiming.lewc = spec.component_LEWC + 1;
	
	ComponentTiming.vdb = spec.component_VDB;
	ComponentTiming.vdf = spec.component_VDF;
	ComponentTiming.fpw = spec.component_FPW1;
	ComponentTiming.flc = spec.component_FLC1;
	ComponentTiming.fswc = spec.component_FSWC1;
	ComponentTiming.fewc = spec.component_FEWC1;
	ComponentTiming.fpw2 = spec.component_FPW2;
	ComponentTiming.flc2 = spec.component_FLC2;
	ComponentTiming.fswc2 = spec.component_FSWC2;
	ComponentTiming.fewc2 = spec.component_FEWC2;

	VIOC_DISP_SetTimingParam(pDISPBase, &ComponentTiming);
 
	memset(&LcdCtrlParam, NULL, sizeof(LcdCtrlParam));

	switch(type)
	{
		case LCDC_COMPONENT_480I_NTSC:
		case LCDC_COMPONENT_576I_PAL:
			break;

		case LCDC_COMPONENT_720P:
			LcdCtrlParam.r2ymd = 3;
			LcdCtrlParam.ckg = 1;
			LcdCtrlParam.id= 0;
			LcdCtrlParam.iv = 1;
			LcdCtrlParam.ih = 1;
			LcdCtrlParam.ip = 0;
			LcdCtrlParam.pxdw = 12;
			LcdCtrlParam.ni = 1;
			break;

		case LCDC_COMPONENT_1080I:
			LcdCtrlParam.r2ymd = 3;
			LcdCtrlParam.ckg = 1;
			LcdCtrlParam.id= 1;
			LcdCtrlParam.iv = 1;
			LcdCtrlParam.ih = 0;
			LcdCtrlParam.ip = 1;
			LcdCtrlParam.pxdw = 12;
			LcdCtrlParam.ni = 0;
			LcdCtrlParam.tv = 1;
			break;

		default:
			break;
	}
	
	VIOC_DISP_SetControlConfigure(pDISPBase, &LcdCtrlParam);

	VIOC_DISP_SetSize(pDISPBase, width, height);
	VIOC_DISP_SetBGColor(pDISPBase, 0, 0 , 0);

	VIOC_WMIX_SetOverlayPriority(pWIXBase, 0);
	VIOC_WMIX_SetBGColor(pWIXBase, 0x00, 0x00, 0x00, 0xff);
	VIOC_WMIX_SetSize(pWIXBase, width, height);
	VIOC_WMIX_SetUpdate(pWIXBase);

	#if defined(TARGET_BOARD_STB)
		/* VE_FIELD: GPIO_E27 */
		gpio_config(TCC_GPE(27), GPIO_FN0|GPIO_OUTPUT|GPIO_HIGH);
	#endif
	
	/* Enable Component Chip */
	#if defined(COMPONENT_CHIP_CS4954)
		if(type == LCDC_COMPONENT_480I_NTSC)
			cs4954_enable(COMPONENT_MODE_NTSC_M); // NTSC_M
		else
			cs4954_enable(COMPONENT_MODE_PAL_B); // PAL_B
	#elif defined(COMPONENT_CHIP_THS8200)
		if(type == LCDC_COMPONENT_720P)
			ths8200_enable(COMPONENT_MODE_720P); // 720P
		else
			ths8200_enable(COMPONENT_MODE_1080I); // 1080I
	#endif

	VIOC_DISP_TurnOn(pDISPBase);
}
示例#12
0
unsigned IO_TCO_GetGpioFunc(unsigned uCH, unsigned uGPIO)
{
#ifdef TCC892X
	switch(uGPIO)
	{
		case TCC_GPB(9): 	// TCO0
		case TCC_GPB(10):	// TCO1
		case TCC_GPB(11):	// TCO2
		case TCC_GPB(12):	// TCO3
		case TCC_GPB(13):	// TCO4
		case TCC_GPB(14):	// TCO5
			return GPIO_FN12;

		case TCC_GPC(0): 	// TCO0
		case TCC_GPC(1):	// TCO1
		case TCC_GPC(2):	// TCO2
		case TCC_GPC(3):	// TCO3
		case TCC_GPC(4):	// TCO4
		case TCC_GPC(5):	// TCO5
			return GPIO_FN9;

		case TCC_GPD(9): 	// TCO0
		case TCC_GPD(10):	// TCO1
		case TCC_GPD(11):	// TCO2
		case TCC_GPD(12):	// TCO3
		case TCC_GPD(13):	// TCO4
		case TCC_GPD(14):	// TCO5
			return GPIO_FN9;

		case TCC_GPE(12): 	// TCO0
		case TCC_GPE(13):	// TCO1
		case TCC_GPE(14):	// TCO2
		case TCC_GPE(15):	// TCO3
		case TCC_GPE(16):	// TCO4
		case TCC_GPE(17):	// TCO5
			return GPIO_FN7;
			
		case TCC_GPF(16): 	// TCO0
		case TCC_GPF(17):	// TCO1
		case TCC_GPF(18):	// TCO2
		case TCC_GPF(19):	// TCO3
		case TCC_GPF(20):	// TCO4
		case TCC_GPF(21):	// TCO5
			return GPIO_FN11;	
			
		case TCC_GPG(5): 	// TCO0
		case TCC_GPG(6):	// TCO1
		case TCC_GPG(7):	// TCO2
		case TCC_GPG(8):	// TCO3
		case TCC_GPG(9):	// TCO4
		case TCC_GPG(10):	// TCO5
			return GPIO_FN7;				

		default:
			break;
	}
#elif defined(TCC88XX)
	switch(uGPIO)
	{
		case TCC_GPA(4): 	// TCO0
		case TCC_GPB(5):	// TCO1
		case TCC_GPB(6):	// TCO2
		case TCC_GPB(7):	// TCO3
		case TCC_GPB(14):	// TCO4
		case TCC_GPB(15):	// TCO5
			return GPIO_FN2;

		default:
			break;
	}
#else
#error code : not define TCO gpio functional setting at chipset
#endif//
	return 0;
}
示例#13
0
		.data0	= TCC_GPF(21),
		.data1	= TCC_GPF(20),
		.data2	= TCC_GPF(19),
		.data3	= TCC_GPF(18),
		.data4	= TCC_MMC_PORT_NULL,
		.data5	= TCC_MMC_PORT_NULL,
		.data6	= TCC_MMC_PORT_NULL,
		.data7	= TCC_MMC_PORT_NULL,
		.cmd	= TCC_GPF(22),
		.clk	= TCC_GPF(23),
		.cd	= TCC_GPF(17),

		.pwr = TCC_MMC_PORT_NULL,
	},
	[TCC_MMC_TYPE_WIFI] = {
		.data0	= TCC_GPE(28),
		.data1	= TCC_GPE(29),
		.data2	= TCC_GPE(30),
		.data3	= TCC_GPE(31),
		.data4	= TCC_MMC_PORT_NULL,
		.data5	= TCC_MMC_PORT_NULL,
		.data6	= TCC_MMC_PORT_NULL,
		.data7	= TCC_MMC_PORT_NULL,
		.cmd	= TCC_GPE(26),
		.clk	= TCC_GPE(27),
		.cd	= TCC_MMC_PORT_NULL,

		.pwr = TCC_MMC_PORT_NULL,
	},
};
示例#14
0
static int __init tcc_init_es8388(void)
{

	int ret;

    printk("%s() \n", __func__);

    if( !(machine_is_m801_88() || machine_is_m805_892x() || machine_is_tcc8920()) ) {
        alsa_dbg("\n\n\n\n%s() do not execution....\n\n", __func__);
        return 0;
    }

#if defined(CONFIG_ARCH_TCC88XX)
    alsa_dbg("TCC Board probe [%s]\n", __FUNCTION__);

    /* h/w mute control */
    if(machine_is_m801_88()) {
        tcc_gpio_config(TCC_GPG(6), GPIO_FN(0));
        tcc_gpio_config(TCC_GPD(11), GPIO_FN(0));
        gpio_request(TCC_GPG(6), "SPK_MUTE_CTL");
        gpio_request(TCC_GPD(11), "HP_MUTE_CTL");
        
        gpio_direction_output(TCC_GPG(6), 0);    // Speaker mute
        gpio_direction_output(TCC_GPD(11), 1);   // HeadPhone mute
        tcc_hp_hw_mute(false);
        tcc_spk_hw_mute(false);

        tcc_soc_card.name = "M801";
    }

#elif defined(CONFIG_ARCH_TCC892X)
	alsa_dbg("TCC Board probe [%s]\n", __FUNCTION__);

	/* h/w mute control */
	if(machine_is_m805_892x())
	{
		if(system_rev == 0x2002 || system_rev == 0x2003 || system_rev == 0x2004 || system_rev == 0x2005) {
			tcc_gpio_config(TCC_GPE(18), GPIO_FN(0));
			gpio_request(TCC_GPE(18), "SPK_MUTE_CTL");
			gpio_direction_output(TCC_GPE(18), 0);	 // Speaker mute
			
			tcc_gpio_config(TCC_GPE(17), GPIO_FN(0));
			gpio_request(TCC_GPE(17), "HP_MUTE_CTL");
			gpio_direction_output(TCC_GPE(17), 1);	 // HeadPhone mute
		}
		else {
			#if defined(CONFIG_M805S_8923_0XA)
			tcc_gpio_config(TCC_GPG(11), GPIO_FN(0));
			gpio_request(TCC_GPG(11), "SPK_MUTE_CTL");
			gpio_direction_output(TCC_GPG(11), 0);	 // Speaker mute
			#else
			tcc_gpio_config(TCC_GPF(27), GPIO_FN(0));
			gpio_request(TCC_GPF(27), "SPK_MUTE_CTL");
			gpio_direction_output(TCC_GPF(27), 0);	 // Speaker mute
			#endif

			tcc_gpio_config(TCC_GPG(5), GPIO_FN(0));
			gpio_request(TCC_GPG(5), "HP_MUTE_CTL");
			gpio_direction_output(TCC_GPG(5), 1);	 // HeadPhone mute
		}

		tcc_hp_hw_mute(false);
		tcc_spk_hw_mute(false);

        tcc_soc_card.name = "M805";
	}

#else
    alsa_dbg("TCC Board probe [%s]\n [Error] Don't support architecture..\n", __FUNCTION__);
	return 0;
#endif


    tcc_hp_hw_mute(true);
    tcc_spk_hw_mute(true);

    tca_tcc_initport();

    ret = es8388_i2c_register();

	tcc_snd_device = platform_device_alloc("soc-audio", -1);
	if (!tcc_snd_device)
		return -ENOMEM;

	platform_set_drvdata(tcc_snd_device, &tcc_soc_card);

	ret = platform_device_add(tcc_snd_device);
	if (ret) {
        printk(KERN_ERR "Unable to add platform device\n");\
		platform_device_put(tcc_snd_device);
	}

	return ret;
}
示例#15
0
//  ************************************************************ //
//  Device Release : 
//  
//  
//  ************************************************************ //
//static int gps_gpio_ioctl (struct inode *inode, struct file *filp,
//                           unsigned int cmd, unsigned long arg)  
static long gps_gpio_ioctl (struct file *filp, unsigned int cmd, void *arg)  
{
    gps_dbg("gps_gpio_ioctl\n");
    switch( cmd )  
    {  
#if defined(CONFIG_MACH_TCC9300)||defined(CONFIG_MACH_TCC8800) || defined(CONFIG_MACH_TCC8920)
        case 0 : // GPS_On
            gps_k_flag = 1;   
            if(machine_is_m801_88() || machine_is_m803()) // GPIOG[4]
            {
                gpio_set_value(TCC_GPG(4), 1);
            }
            else if(machine_is_tcc8800() || machine_is_tcc8920())
            {
                gpio_set_value(TCC_GPEXT1(6), 1);
            }
            gps_dbg("tccxxxx : gps_gpio_on\n");
            break;   
        case 1 : // GPS_Off
            gps_k_flag = 0;   
            if(machine_is_m801_88() || machine_is_m803()) // GPIOG[4]
            {
                gpio_set_value(TCC_GPG(4), 0);
            }
            else if(machine_is_tcc8800() || machine_is_tcc8920()) 
            {
                gpio_set_value(TCC_GPEXT1(6), 0);
            }
            gps_dbg("tccxxxx : gps_gpio_off\n");
            break;
#elif defined(CONFIG_MACH_TCC8900)
 
        case 0 : // GPS_On
            gps_k_flag = 1;   
            if(machine_is_tcc8900())
            {
                gpio_set_value(TCC_GPD(25), 1);   
            }
            break;   
        case 1 : // GPS_Off
            gps_k_flag = 0;   
            if(machine_is_tcc8900())
            {
                gpio_set_value(TCC_GPD(25), 0);   
            }
            break;            
#elif defined(CONFIG_MACH_M805_892X)
        case 0 : // GPS_On
            gps_k_flag = 1;
            if(machine_is_m805_892x())
            {
            	if (system_rev == 0x2002 || system_rev == 0x2003 || system_rev == 0x2004 || system_rev == 0x2005)
                	gpio_set_value(TCC_GPE(14), 1);
                else
                	gpio_set_value(TCC_GPC(6), 1);
            }
            gps_dbg("tccxxxx : gps_gpio_on\n");
            break;	 
        case 1 : // GPS_Off
            gps_k_flag = 0;
            if(machine_is_m805_892x())
            {
				if (system_rev == 0x2002 || system_rev == 0x2003 || system_rev == 0x2004 || system_rev == 0x2005)
                	gpio_set_value(TCC_GPE(14), 0);
                else
                	gpio_set_value(TCC_GPC(6), 0);
            }
            gps_dbg("tccxxxx : gps_gpio_off\n");
            break;
#else
        case 0 : // GPS_On
            gps_k_flag = 1;   

            break;   
        case 1 : // GPS_Off
            gps_k_flag = 0;   

            break;
#endif  // #if defined(CONFIG_MACH_TCC9300)
        default :
            break;
    };
    return 0;  
}  
示例#16
0
//  ************************************************************ //
//  Device Init :
//  
//  
//
//  ************************************************************ //
static int __init gps_gpio_init(void)  
{  
    int result;  
        gps_dbg("gps_gpio_init\n"); 

  
	if (0 == gps_major)
	{
		/* auto select a major */
		result = alloc_chrdev_region(&dev, 0, 1, GPS_GPIO_DEV_NAME);
		gps_major = MAJOR(dev);
	}
	else
	{
		/* use load time defined major number */
		dev = MKDEV(gps_major, 0);
		result = register_chrdev_region(dev, 1, GPS_GPIO_DEV_NAME);
	}

	memset(&gps_cdev, 0, sizeof(gps_cdev));

	/* initialize our char dev data */
	cdev_init(&gps_cdev, &gps_gpio_fops);

	/* register char dev with the kernel */
	result = cdev_add(&gps_cdev, dev, 1);
    
	if (0 != result)
	{
		unregister_chrdev_region(dev, 1);
		gps_dbg("Error registrating mali device object with the kernel\n");
	}

    gps_class = class_create(THIS_MODULE, GPS_GPIO_DEV_NAME);
    device_create(gps_class, NULL, MKDEV(gps_major, MINOR(dev)), NULL,
                  GPS_GPIO_DEV_NAME);

    if (result < 0)
        return result;  

#if defined(CONFIG_MACH_TCC9300) || defined(CONFIG_MACH_TCC8800) || defined(CONFIG_MACH_TCC8920)
    if(machine_is_m801_88() || machine_is_m803()) // GPIOG[4]
    {
        gps_dbg("GPS_PWREN on\n");
        tcc_gpio_config(TCC_GPG(4), GPIO_FN(0));
        gpio_request(TCC_GPG(4), "GPIO_PWREN");
        gpio_direction_output(TCC_GPG(4), 0);
    }
    else if(machine_is_tcc8800() || machine_is_tcc8920()) 
    {
        gps_dbg("gpio_direction_output__gps\n");
        gpio_direction_output(TCC_GPEXT1(6), 0);    // GPS Power On
    }
#elif defined(CONFIG_MACH_TCC8900)
    if(machine_is_tcc8900())
    {
        gps_dbg("GPS_8900_PWREN on\n");
        tcc_gpio_config(TCC_GPD(25), GPIO_FN(0));
        gpio_request(TCC_GPD(25), "GPIO_PWREN");
        gpio_set_value(TCC_GPD(25), 0);
    }
#elif defined(CONFIG_MACH_M805_892X)
    if(machine_is_m805_892x())
    {
        gps_dbg("GPS_PWREN on\n");
		if (system_rev == 0x2002 || system_rev == 0x2003 || system_rev == 0x2004 || system_rev == 0x2005) {
			tcc_gpio_config(TCC_GPE(14), GPIO_FN(0));
			gpio_request(TCC_GPE(14), "GPIO_PWREN");
			gpio_direction_output(TCC_GPE(14), 0);

		} else {
			tcc_gpio_config(TCC_GPC(6), GPIO_FN(0));
			gpio_request(TCC_GPC(6), "GPIO_PWREN");
			gpio_direction_output(TCC_GPC(6), 0);
        }
    }
#endif

    gps_dbg("GPS driver loaded\n");

    return 0;  
}  
示例#17
0
static void tcc_tsif_release_port(struct tcc_tsif_handle *h)
{
	volatile unsigned long* TSIFPORT = (volatile unsigned long *)tcc_p2v(HwTSIF_TSCHS_BASE);

	switch (h->gpio_port) {
		case 0:
				tcc_gpio_config(TCC_GPD(8), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);		//clk
				tcc_gpio_config(TCC_GPD(9), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);		//valid
				tcc_gpio_config(TCC_GPD(10), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);		//sync
				tcc_gpio_config(TCC_GPD(0), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);		//d0

				if(!(h->serial_mode)) {
					tcc_gpio_config(TCC_GPD(1), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d1
					tcc_gpio_config(TCC_GPD(2), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d2
					tcc_gpio_config(TCC_GPD(3), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d3
					tcc_gpio_config(TCC_GPD(4), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d4
					tcc_gpio_config(TCC_GPD(5), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d5
					tcc_gpio_config(TCC_GPD(6), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d6
					tcc_gpio_config(TCC_GPD(7), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d7
				}
			break;
		case 1:
				tcc_gpio_config(TCC_GPB(0), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);		//clk
				tcc_gpio_config(TCC_GPB(2), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);		//valid
				tcc_gpio_config(TCC_GPB(1), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);		//sync
				tcc_gpio_config(TCC_GPB(3), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);		//d0

				if(!(h->serial_mode)) {
					tcc_gpio_config(TCC_GPB(4), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d1
					tcc_gpio_config(TCC_GPB(5), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d2
					tcc_gpio_config(TCC_GPB(6), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d3
					tcc_gpio_config(TCC_GPB(7), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d4
					tcc_gpio_config(TCC_GPB(8), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d5
					tcc_gpio_config(TCC_GPB(9), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d6
					tcc_gpio_config(TCC_GPB(10), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d7
				}
			break;
		case 2:
				tcc_gpio_config(TCC_GPB(28), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);		//clk
				tcc_gpio_config(TCC_GPB(26), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);		//valid
				tcc_gpio_config(TCC_GPB(27), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);		//sync
				tcc_gpio_config(TCC_GPB(25), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);		//d0

				if(!(h->serial_mode)) {
					tcc_gpio_config(TCC_GPB(24), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d1
					tcc_gpio_config(TCC_GPB(23), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d2
					tcc_gpio_config(TCC_GPB(22), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d3
					tcc_gpio_config(TCC_GPB(21), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d4
					tcc_gpio_config(TCC_GPB(20), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d5
					tcc_gpio_config(TCC_GPB(19), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d6
					tcc_gpio_config(TCC_GPB(18), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d7
				}
			break;
		case 3:
				tcc_gpio_config(TCC_GPC(26), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);		//clk
				tcc_gpio_config(TCC_GPC(24), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);		//valid
				tcc_gpio_config(TCC_GPC(25), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);		//sync
				tcc_gpio_config(TCC_GPC(23), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);		//d0

				if(!(h->serial_mode)) {
					tcc_gpio_config(TCC_GPC(22), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d1
					tcc_gpio_config(TCC_GPC(21), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d2
					tcc_gpio_config(TCC_GPC(20), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d3
					tcc_gpio_config(TCC_GPC(19), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d4
					tcc_gpio_config(TCC_GPC(18), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d5
					tcc_gpio_config(TCC_GPC(17), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d6
					tcc_gpio_config(TCC_GPC(16), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d7
				}
			break;
		case 4:
				tcc_gpio_config(TCC_GPE(26), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);		//clk
				tcc_gpio_config(TCC_GPE(24), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);		//valid
				tcc_gpio_config(TCC_GPE(25), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);		//sync
				tcc_gpio_config(TCC_GPE(23), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);		//d0

				if(!(h->serial_mode)) {
					tcc_gpio_config(TCC_GPE(22), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d1
					tcc_gpio_config(TCC_GPE(21), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d2
					tcc_gpio_config(TCC_GPE(20), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d3
					tcc_gpio_config(TCC_GPE(19), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d4
					tcc_gpio_config(TCC_GPE(18), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d5
					tcc_gpio_config(TCC_GPE(17), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d6
					tcc_gpio_config(TCC_GPE(16), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);	//d7
				}
			break;
		case 5:
				tcc_gpio_config(TCC_GPF(0), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);		//clk
				tcc_gpio_config(TCC_GPF(2), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);		//valid
				tcc_gpio_config(TCC_GPF(1), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);		//sync
				tcc_gpio_config(TCC_GPF(3), GPIO_FN(0)|GPIO_OUTPUT|GPIO_LOW);		//d0

				if(!(h->serial_mode)) {
					tcc_gpio_config(TCC_GPF(4), GPIO_FN(2)|GPIO_OUTPUT|GPIO_LOW);	//d1
					tcc_gpio_config(TCC_GPF(5), GPIO_FN(2)|GPIO_OUTPUT|GPIO_LOW);	//d2
					tcc_gpio_config(TCC_GPF(6), GPIO_FN(2)|GPIO_OUTPUT|GPIO_LOW);	//d3
					tcc_gpio_config(TCC_GPF(7), GPIO_FN(2)|GPIO_OUTPUT|GPIO_LOW);	//d4
					tcc_gpio_config(TCC_GPF(8), GPIO_FN(2)|GPIO_OUTPUT|GPIO_LOW);	//d5
					tcc_gpio_config(TCC_GPF(9), GPIO_FN(2)|GPIO_OUTPUT|GPIO_LOW);	//d6
					tcc_gpio_config(TCC_GPF(10), GPIO_FN(2)|GPIO_OUTPUT|GPIO_LOW);	//d7
				}
			break;		
		default:
				printk("%s : select wrong port => %d\n", __func__, h->gpio_port);
			break;
	}

	{
		unsigned int clr = (0x3 << (12 + (2 * h->gpio_port))) | (0xf << (4 * h->id));

		BITCLR(*TSIFPORT, clr);
	}
}
示例#18
0
static int tca_tsif_set_port(struct tcc_tsif_handle *h)
{
	volatile unsigned long* TSIFPORT = (volatile unsigned long *)tcc_p2v(HwTSIF_TSCHS_BASE);
	int ret = 0;
    printk("%s : select port => %d, serial_mode => %d\n", __func__, h->gpio_port, h->serial_mode);

	switch (h->gpio_port) {
		case 0:
				tcc_gpio_config(TCC_GPD(8), GPIO_FN(2)|GPIO_SCHMITT_INPUT);		//clk
				tcc_gpio_config(TCC_GPD(9), GPIO_FN(2));		//valid
				tcc_gpio_config(TCC_GPD(10), GPIO_FN(2));		//sync
				tcc_gpio_config(TCC_GPD(7), GPIO_FN(2));		//d0

				if(!(h->serial_mode)) {
					tcc_gpio_config(TCC_GPD(6), GPIO_FN(2));	//d1
					tcc_gpio_config(TCC_GPD(5), GPIO_FN(2));	//d2
					tcc_gpio_config(TCC_GPD(4), GPIO_FN(2));	//d3
					tcc_gpio_config(TCC_GPD(3), GPIO_FN(2));	//d4
					tcc_gpio_config(TCC_GPD(2), GPIO_FN(2));	//d5
					tcc_gpio_config(TCC_GPD(1), GPIO_FN(2));	//d6
					tcc_gpio_config(TCC_GPD(0), GPIO_FN(2));	//d7
				}
			break;
		case 1:
				tcc_gpio_config(TCC_GPB(0), GPIO_FN(7)|GPIO_SCHMITT_INPUT);		//clk
				tcc_gpio_config(TCC_GPB(2), GPIO_FN(7));		//valid
				tcc_gpio_config(TCC_GPB(1), GPIO_FN(7));		//sync
				tcc_gpio_config(TCC_GPB(3), GPIO_FN(7));		//d0

				if(!(h->serial_mode)) {
					tcc_gpio_config(TCC_GPB(4), GPIO_FN(7));	//d1
					tcc_gpio_config(TCC_GPB(5), GPIO_FN(7));	//d2
					tcc_gpio_config(TCC_GPB(6), GPIO_FN(7));	//d3
					tcc_gpio_config(TCC_GPB(7), GPIO_FN(7));	//d4
					tcc_gpio_config(TCC_GPB(8), GPIO_FN(7));	//d5
					tcc_gpio_config(TCC_GPB(9), GPIO_FN(7));	//d6
					tcc_gpio_config(TCC_GPB(10), GPIO_FN(7));	//d7
				}
			break;
		case 2:
				tcc_gpio_config(TCC_GPB(28), GPIO_FN(7)|GPIO_SCHMITT_INPUT);		//clk
				tcc_gpio_config(TCC_GPB(26), GPIO_FN(7));		//valid
				tcc_gpio_config(TCC_GPB(27), GPIO_FN(7));		//sync
				tcc_gpio_config(TCC_GPB(25), GPIO_FN(7));		//d0

				if(!(h->serial_mode)) {
					tcc_gpio_config(TCC_GPB(24), GPIO_FN(7));	//d1
					tcc_gpio_config(TCC_GPB(23), GPIO_FN(7));	//d2
					tcc_gpio_config(TCC_GPB(22), GPIO_FN(7));	//d3
					tcc_gpio_config(TCC_GPB(21), GPIO_FN(7));	//d4
					tcc_gpio_config(TCC_GPB(20), GPIO_FN(7));	//d5
					tcc_gpio_config(TCC_GPB(19), GPIO_FN(7));	//d6
					tcc_gpio_config(TCC_GPB(18), GPIO_FN(7));	//d7
				}
			break;
		case 3:
				tcc_gpio_config(TCC_GPC(26), GPIO_FN(3)|GPIO_SCHMITT_INPUT);		//clk
				tcc_gpio_config(TCC_GPC(24), GPIO_FN(3));		//valid
				tcc_gpio_config(TCC_GPC(25), GPIO_FN(3));		//sync
				tcc_gpio_config(TCC_GPC(23), GPIO_FN(3));		//d0

				if(!(h->serial_mode)) {
					tcc_gpio_config(TCC_GPC(22), GPIO_FN(3));	//d1
					tcc_gpio_config(TCC_GPC(21), GPIO_FN(3));	//d2
					tcc_gpio_config(TCC_GPC(20), GPIO_FN(3));	//d3
					tcc_gpio_config(TCC_GPC(19), GPIO_FN(3));	//d4
					tcc_gpio_config(TCC_GPC(18), GPIO_FN(3));	//d5
					tcc_gpio_config(TCC_GPC(17), GPIO_FN(3));	//d6
					tcc_gpio_config(TCC_GPC(16), GPIO_FN(3));	//d7
				}
			break;
		case 4:
				tcc_gpio_config(TCC_GPE(26), GPIO_FN(4)|GPIO_SCHMITT_INPUT);		//clk
				tcc_gpio_config(TCC_GPE(24), GPIO_FN(4));		//valid
				tcc_gpio_config(TCC_GPE(25), GPIO_FN(4));		//sync
				tcc_gpio_config(TCC_GPE(23), GPIO_FN(4));		//d0

				if(!(h->serial_mode)) {
					tcc_gpio_config(TCC_GPE(22), GPIO_FN(4));	//d1
					tcc_gpio_config(TCC_GPE(21), GPIO_FN(4));	//d2
					tcc_gpio_config(TCC_GPE(20), GPIO_FN(4));	//d3
					tcc_gpio_config(TCC_GPE(19), GPIO_FN(4));	//d4
					tcc_gpio_config(TCC_GPE(18), GPIO_FN(4));	//d5
					tcc_gpio_config(TCC_GPE(17), GPIO_FN(4));	//d6
					tcc_gpio_config(TCC_GPE(16), GPIO_FN(4));	//d7
				}
			break;
		case 5:
				tcc_gpio_config(TCC_GPF(0), GPIO_FN(2)|GPIO_SCHMITT_INPUT);		//clk
				tcc_gpio_config(TCC_GPF(2), GPIO_FN(2));		//valid
				tcc_gpio_config(TCC_GPF(1), GPIO_FN(2));		//sync
				tcc_gpio_config(TCC_GPF(3), GPIO_FN(2));		//d0

				if(!(h->serial_mode)) {
					tcc_gpio_config(TCC_GPF(4), GPIO_FN(2));	//d1
					tcc_gpio_config(TCC_GPF(5), GPIO_FN(2));	//d2
					tcc_gpio_config(TCC_GPF(6), GPIO_FN(2));	//d3
					tcc_gpio_config(TCC_GPF(7), GPIO_FN(2));	//d4
					tcc_gpio_config(TCC_GPF(8), GPIO_FN(2));	//d5
					tcc_gpio_config(TCC_GPF(9), GPIO_FN(2));	//d6
					tcc_gpio_config(TCC_GPF(10), GPIO_FN(2));	//d7
				}
			break;		
		default:
				printk("%s : select wrong port => %d\n", __func__, h->gpio_port);
				ret = -1;
			break;
	}

	if(ret != -1) {
		unsigned int direction = 1 << (24 + h->gpio_port);
		unsigned int channel = (h->id & 0x3) << (12 + (2 * h->gpio_port));
		unsigned int port = (h->gpio_port & 0xf) << (4 * h->id);
		unsigned int clr = (0x3 << (12 + (2 * h->gpio_port))) | (0xf << (4 * h->id));

		BITCLR(*TSIFPORT, 0xffffffff);
		BITCLR(*TSIFPORT, direction);			//clk, sync, valid, data input direction select
		BITCSET(*TSIFPORT, clr, (channel | port));	//tsif channel & port number select
	}

	return ret;
}
示例#19
0
/*****************************************************************************
* Function Name : tca_i2c_setgpio(int ch)
* Description: I2C port configuration
* input parameter:
* 		int core; 	// I2C Core
*       int ch;   	// I2C master channel
******************************************************************************/
void tca_i2c_setgpio(int core, int ch)
{
	//PI2CPORTCFG i2c_portcfg = (PI2CPORTCFG)tcc_p2v(HwI2C_PORTCFG_BASE);

	switch (core)
	{
		case 0:
			#if defined(CONFIG_MACH_TCC8920ST)
				#if defined(CONFIG_STB_BOARD_DONGLE)
					//I2C[16] - GPIOE[14][15]
					//i2c_portcfg->PCFG0.bREG.MASTER0 = 16;
					BITCSET(((PI2CPORTCFG)io_p2v(HwI2C_PORTCFG_BASE))->PCFG0.nREG, 0x000000FF, 16);
					tcc_gpio_config(TCC_GPE(14), GPIO_FN6|GPIO_OUTPUT|GPIO_LOW);
					tcc_gpio_config(TCC_GPE(15), GPIO_FN6|GPIO_OUTPUT|GPIO_LOW);
				#elif defined(CONFIG_STB_BOARD_HDB892F)
					#if defined(CONFIG_HDB892F_BOARD_YJ8925T)
					#else
						//I2C[16] - GPIOE[14][15]
						//i2c_portcfg->PCFG0.bREG.MASTER0 = 16;
						BITCSET(((PI2CPORTCFG)io_p2v(HwI2C_PORTCFG_BASE))->PCFG0.nREG, 0x000000FF, 16);
						tcc_gpio_config(TCC_GPE(14), GPIO_FN6|GPIO_OUTPUT|GPIO_LOW);
						tcc_gpio_config(TCC_GPE(15), GPIO_FN6|GPIO_OUTPUT|GPIO_LOW);
					#endif
				#elif defined(CONFIG_STB_BOARD_ISDBT_MODULE)
					//I2C[22] - GPIOG[2][3]
					//i2c_portcfg->PCFG0.bREG.MASTER0 = 22;
					BITCSET(((PI2CPORTCFG)io_p2v(HwI2C_PORTCFG_BASE))->PCFG0.nREG, 0x000000FF, 22);
					tcc_gpio_config(TCC_GPG(2), GPIO_FN4|GPIO_OUTPUT|GPIO_LOW);
					tcc_gpio_config(TCC_GPG(3), GPIO_FN4|GPIO_OUTPUT|GPIO_LOW);
				#elif defined(CONFIG_STB_BOARD_UPC)
				#else
					//I2C[26] - GPIOG[18][19]
					//i2c_portcfg->PCFG0.bREG.MASTER0 = 26;
					BITCSET(((PI2CPORTCFG)io_p2v(HwI2C_PORTCFG_BASE))->PCFG0.nREG, 0x000000FF, 26);
					tcc_gpio_config(TCC_GPG(18), GPIO_FN4|GPIO_OUTPUT|GPIO_LOW);
					tcc_gpio_config(TCC_GPG(19), GPIO_FN4|GPIO_OUTPUT|GPIO_LOW);
				#endif
			#elif defined(CONFIG_MACH_M805_892X)
				if (system_rev == 0x2002 || system_rev == 0x2003 || system_rev == 0x2004 || system_rev == 0x2005 || system_rev == 0x2006 || system_rev == 0x2007 || system_rev == 0x2008)
				{
					//I2C[12] - GPIOC[2][3]
					//i2c_portcfg->PCFG0.bREG.MASTER0 = 12;
					BITCSET(((PI2CPORTCFG)io_p2v(HwI2C_PORTCFG_BASE))->PCFG0.nREG, 0x000000FF, 12);
					tcc_gpio_config(TCC_GPC(2), GPIO_FN7|GPIO_OUTPUT|GPIO_LOW);
					tcc_gpio_config(TCC_GPC(3), GPIO_FN7|GPIO_OUTPUT|GPIO_LOW);
				}
				else
				{
					#if defined(CONFIG_M805S_8923_0XA)
					//I2C[22] - GPIOG[2][3]
					//i2c_portcfg->PCFG0.bREG.MASTER0 = 22;
					BITCSET(((PI2CPORTCFG)io_p2v(HwI2C_PORTCFG_BASE))->PCFG0.nREG, 0x000000FF, 22);
					tcc_gpio_config(TCC_GPG(2), GPIO_FN4|GPIO_OUTPUT|GPIO_LOW);
					tcc_gpio_config(TCC_GPG(3), GPIO_FN4|GPIO_OUTPUT|GPIO_LOW);
					#else
					//I2C[23] - GPIOG[6][7]
					//i2c_portcfg->PCFG0.bREG.MASTER0 = 23;
					BITCSET(((PI2CPORTCFG)io_p2v(HwI2C_PORTCFG_BASE))->PCFG0.nREG, 0x000000FF, 23);
					tcc_gpio_config(TCC_GPG(6), GPIO_FN4|GPIO_OUTPUT|GPIO_LOW);
					tcc_gpio_config(TCC_GPG(7), GPIO_FN4|GPIO_OUTPUT|GPIO_LOW);
					#endif
				}
			#else
				if(system_rev == 0x1006)
				{
					//I2C[18] - GPIOF[13][14]
					//((PI2CPORTCFG)HwI2C_PORTCFG_BASE)->PCFG0.bREG.MASTER0 = 18;
					BITCSET(((PI2CPORTCFG)io_p2v(HwI2C_PORTCFG_BASE))->PCFG0.nREG, 0x000000FF, 18);
					tcc_gpio_config(TCC_GPF(13), GPIO_FN10|GPIO_OUTPUT|GPIO_LOW);
					tcc_gpio_config(TCC_GPF(14), GPIO_FN10|GPIO_OUTPUT|GPIO_LOW);
				}
				else if(system_rev == 0x1008)
				{
					//I2C[22] - GPIOG[2][3]
					//((PI2CPORTCFG)HwI2C_PORTCFG_BASE)->PCFG0.bREG.MASTER0 = 22;
					BITCSET(((PI2CPORTCFG)io_p2v(HwI2C_PORTCFG_BASE))->PCFG0.nREG, 0x000000FF, 22);
					tcc_gpio_config(TCC_GPG(2), GPIO_FN4|GPIO_OUTPUT|GPIO_LOW);
					tcc_gpio_config(TCC_GPG(3), GPIO_FN4|GPIO_OUTPUT|GPIO_LOW);
				}
				else
				{
					//I2C[8] - GPIOB[9][10]
					//i2c_portcfg->PCFG0.bREG.MASTER0 = 8;
					BITCSET(((PI2CPORTCFG)io_p2v(HwI2C_PORTCFG_BASE))->PCFG0.nREG, 0x000000FF, 8);
					tcc_gpio_config(TCC_GPB(9), GPIO_FN11|GPIO_OUTPUT|GPIO_LOW);
					tcc_gpio_config(TCC_GPB(10), GPIO_FN11|GPIO_OUTPUT|GPIO_LOW);
				}
			#endif
			break;
		case 1:
			#if defined(CONFIG_MACH_M805_892X)
			if (system_rev == 0x2002 || system_rev == 0x2003 || system_rev == 0x2004 || system_rev == 0x2005 || system_rev == 0x2006 || system_rev == 0x2007 || system_rev == 0x2008)
			{
				//I2C[25] - GPIOG[12][13]
				//i2c_portcfg->PCFG0.bREG.MASTER1 = 25;
				BITCSET(((PI2CPORTCFG)io_p2v(HwI2C_PORTCFG_BASE))->PCFG0.nREG, 0x0000FF00, 25<<8);
				tcc_gpio_config(TCC_GPG(12), GPIO_FN4|GPIO_OUTPUT|GPIO_LOW);
				tcc_gpio_config(TCC_GPG(13), GPIO_FN4|GPIO_OUTPUT|GPIO_LOW);
			}
			else
			{
				#if defined(CONFIG_M805S_8923_0XA)
				//I2C[21] - GPIOF[27][28]
				//i2c_portcfg->PCFG0.bREG.MASTER1 = 21;
				BITCSET(((PI2CPORTCFG)io_p2v(HwI2C_PORTCFG_BASE))->PCFG0.nREG, 0x0000FF00, 21<<8);
				tcc_gpio_config(TCC_GPF(27), GPIO_FN10|GPIO_OUTPUT|GPIO_LOW);
				tcc_gpio_config(TCC_GPF(28), GPIO_FN10|GPIO_OUTPUT|GPIO_LOW);
				#else
				//I2C[24] - GPIOG[10][11]
				//i2c_portcfg->PCFG0.bREG.MASTER1 = 24;
				BITCSET(((PI2CPORTCFG)io_p2v(HwI2C_PORTCFG_BASE))->PCFG0.nREG, 0x0000FF00, 24<<8);
				tcc_gpio_config(TCC_GPG(10), GPIO_FN4|GPIO_OUTPUT|GPIO_LOW);
				tcc_gpio_config(TCC_GPG(11), GPIO_FN4|GPIO_OUTPUT|GPIO_LOW);
				#endif
			}
			#else
			if(system_rev == 0x1005 || system_rev == 0x1007)
			{
				//I2C[21] - GPIOF[27][28]
				//i2c_portcfg->PCFG0.bREG.MASTER1 = 21;
				BITCSET(((PI2CPORTCFG)io_p2v(HwI2C_PORTCFG_BASE))->PCFG0.nREG, 0x0000FF00, 21<<8);
				tcc_gpio_config(TCC_GPF(27), GPIO_FN10|GPIO_OUTPUT|GPIO_LOW);
				tcc_gpio_config(TCC_GPF(28), GPIO_FN10|GPIO_OUTPUT|GPIO_LOW);
			}
			else if(system_rev == 0x1006)
			{
				//I2C[28] - GPIO_ADC[2][3]
				//((PI2CPORTCFG)HwI2C_PORTCFG_BASE)->PCFG0.bREG.MASTER1 = 28;
				BITCSET(((PI2CPORTCFG)io_p2v(HwI2C_PORTCFG_BASE))->PCFG0.nREG, 0x0000FF00, 28<<8);
				tcc_gpio_config(TCC_GPADC(2), GPIO_FN3|GPIO_OUTPUT|GPIO_LOW);
				tcc_gpio_config(TCC_GPADC(3), GPIO_FN3|GPIO_OUTPUT|GPIO_LOW);
			}
			else if(system_rev == 0x1008)
			{
				//I2C[13] - GPIOC[12][13]
				//((PI2CPORTCFG)HwI2C_PORTCFG_BASE)->PCFG0.bREG.MASTER1 = 13;
				BITCSET(((PI2CPORTCFG)io_p2v(HwI2C_PORTCFG_BASE))->PCFG0.nREG, 0x0000FF00, 13<<8);
				tcc_gpio_config(TCC_GPC(12), GPIO_FN7|GPIO_OUTPUT|GPIO_LOW);
				tcc_gpio_config(TCC_GPC(13), GPIO_FN7|GPIO_OUTPUT|GPIO_LOW);
			}
			else
			{
				#if defined(CONFIG_STB_BOARD_HDB892F) && defined(CONFIG_HDB892F_BOARD_YJ8925T)
					//I2C[16] - GPIOE[14][15]
					//i2c_portcfg->PCFG0.bREG.MASTER1 = 16;
					BITCSET(((PI2CPORTCFG)io_p2v(HwI2C_PORTCFG_BASE))->PCFG0.nREG, 0x0000FF00, 16<<8);
					tcc_gpio_config(TCC_GPE(14), GPIO_FN6|GPIO_OUTPUT|GPIO_LOW);
					tcc_gpio_config(TCC_GPE(15), GPIO_FN6|GPIO_OUTPUT|GPIO_LOW);
				#elif defined(CONFIG_STB_BOARD_UPC)
				#else
					//I2C[22] - GPIOG[2][3]
					//i2c_portcfg->PCFG0.bREG.MASTER1 = 22;
					BITCSET(((PI2CPORTCFG)io_p2v(HwI2C_PORTCFG_BASE))->PCFG0.nREG, 0x0000FF00, 22<<8);
					tcc_gpio_config(TCC_GPG(2), GPIO_FN4|GPIO_OUTPUT|GPIO_LOW);
					tcc_gpio_config(TCC_GPG(3), GPIO_FN4|GPIO_OUTPUT|GPIO_LOW);
				#endif
			}
			#endif
			break;
		case 2:
			#if defined(CONFIG_MACH_M805_892X)
			if (system_rev == 0x2002 || system_rev == 0x2003 || system_rev == 0x2004 || system_rev == 0x2005 || system_rev == 0x2006 || system_rev == 0x2007 || system_rev == 0x2008)
			{
				//I2C[18] - GPIOF[13][14]
				//i2c_portcfg->PCFG0.bREG.MASTER1 = 18;
				BITCSET(((PI2CPORTCFG)io_p2v(HwI2C_PORTCFG_BASE))->PCFG0.nREG, 0x00FF0000, 18<<16);
				tcc_gpio_config(TCC_GPF(13), GPIO_FN10|GPIO_OUTPUT|GPIO_LOW);
				tcc_gpio_config(TCC_GPF(14), GPIO_FN10|GPIO_OUTPUT|GPIO_LOW);
			}
			#else
			if(system_rev != 0x1006 && system_rev != 0x1008)
			{
				//I2C[28] - GPIO_ADC[2][3]
				//i2c_portcfg->PCFG0.bREG.MASTER2 = 28;
				BITCSET(((PI2CPORTCFG)io_p2v(HwI2C_PORTCFG_BASE))->PCFG0.nREG, 0x00FF0000, 28<<16);
				tcc_gpio_config(TCC_GPADC(2), GPIO_FN3|GPIO_OUTPUT|GPIO_LOW);
				tcc_gpio_config(TCC_GPADC(3), GPIO_FN3|GPIO_OUTPUT|GPIO_LOW);
			}
			#endif
			break;
		case 3:
			//I2C[27] - GPIO_HDMI[2][3]
			//i2c_portcfg->PCFG0.bREG.MASTER3 = 27;
			BITCSET(((PI2CPORTCFG)io_p2v(HwI2C_PORTCFG_BASE))->PCFG0.nREG, 0xFF000000, 27<<24);
			tcc_gpio_config(TCC_GPHDMI(2), GPIO_FN1|GPIO_OUTPUT|GPIO_LOW);
			tcc_gpio_config(TCC_GPHDMI(3), GPIO_FN1|GPIO_OUTPUT|GPIO_LOW);
			//Not used..
			break;
		default:
			break;
	}
}