Ejemplo n.º 1
0
int enrc2u_wifi_suspend_gpio(void)
{
	printk("[WLAN] pull SDIO pins to low by suspend\n");
	
	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_SDMMC3_CMD, TEGRA_PUPD_NORMAL);
	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_SDMMC3_DAT0, TEGRA_PUPD_NORMAL);
	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_SDMMC3_DAT1, TEGRA_PUPD_NORMAL);
	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_SDMMC3_DAT2, TEGRA_PUPD_NORMAL);
	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_SDMMC3_DAT3, TEGRA_PUPD_NORMAL);
	
	tegra_gpio_enable(WIFI_SDIO_CLK);
	tegra_gpio_enable(WIFI_SDIO_CMD);
	tegra_gpio_enable(WIFI_SDIO_D0);
	tegra_gpio_enable(WIFI_SDIO_D1);
	tegra_gpio_enable(WIFI_SDIO_D2);
	tegra_gpio_enable(WIFI_SDIO_D3);
	
	gpio_direction_output(WIFI_SDIO_CLK, 0);
	gpio_direction_input(WIFI_SDIO_CMD);
	gpio_direction_input(WIFI_SDIO_D0);
	gpio_direction_input(WIFI_SDIO_D1);
	gpio_direction_input(WIFI_SDIO_D2);
	gpio_direction_input(WIFI_SDIO_D3);
	
	return 0;
}
Ejemplo n.º 2
0
static int baseband_init(void)
{
	int ret;

	ret = gpio_request_array(modem_gpios, ARRAY_SIZE(modem_gpios));
	if (ret) {
		pr_warn("%s:gpio request failed\n", __func__);
		return ret;
	}

	baseband_reg = regulator_get(NULL, "vdd_core_bb");
	if (IS_ERR_OR_NULL(baseband_reg))
		pr_warn("%s: baseband regulator get failed\n", __func__);
	else
		regulator_enable(baseband_reg);

	/* enable pull-up for MDM1 UART RX */
	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_GPIO_PU1,
				    TEGRA_PUPD_PULL_UP);

	/* enable pull-down for MDM1_COLD_BOOT */
	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_ULPI_DATA4,
				    TEGRA_PUPD_PULL_DOWN);

	/* export GPIO for user space access through sysfs */
	gpio_export(MDM_RST, false);

	return 0;
}
Ejemplo n.º 3
0
void blue_pincfg_uartc_suspend(void) {
    /* BT_EN GPIO-U.00 O(L) */

    gpio_direction_output(TEGRA_GPIO_PU0, 0);

    /* UART3_CTS_N GPIO-A.01 I(PU) */
    tegra_gpio_enable(TEGRA_GPIO_PA1);
    gpio_direction_input(TEGRA_GPIO_PA1);
    tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_UART3_CTS_N, TEGRA_PUPD_PULL_UP);

    /* UART3_RTS_N GPIO-C.00 O(H) */
    tegra_gpio_enable(TEGRA_GPIO_PC0);
    gpio_direction_output(TEGRA_GPIO_PC0, 1);

    /* UART3_TXD GPIO-W.06 O(H) */
    tegra_gpio_enable(TEGRA_GPIO_PW6);
    gpio_direction_output(TEGRA_GPIO_PW6, 1);

    /* UART3_RXD GPIO-W.07 I(PU) */
    tegra_gpio_enable(TEGRA_GPIO_PW7);
    gpio_direction_input(TEGRA_GPIO_PW7);
    tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_UART3_RXD, TEGRA_PUPD_PULL_UP);

    /* UART3 CTS_N WAKEUP GPIO-O.05 I(NP) */
    tegra_gpio_enable(TEGRA_GPIO_PO5);
    gpio_direction_input(TEGRA_GPIO_PO5);
    tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_ULPI_DATA4, TEGRA_PUPD_NORMAL);
}
static void enrc2u_comp_irq_init(void)
{
	int ret = 0;
	if(board_get_sku_tag() == 0x34600) {
		ret = gpio_request(TEGRA_GPIO_PN5, "COMP_INT");
		if (ret < 0) {
			pr_err("[COMP] %s: gpio_request failed %d\n", __func__, ret);
			return;
		}

		ret = gpio_direction_input(TEGRA_GPIO_PN5);
		if (ret < 0) {
			pr_err("[COMP] %s: gpio_direction_input failed %d\n", __func__, ret);
			gpio_free(TEGRA_GPIO_PN5);
			return;
		}

		tegra_gpio_enable(TEGRA_GPIO_PN5);
		tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_LCD_SDOUT, TEGRA_PUPD_PULL_DOWN);
	}
	else {
		// comp int
		if ( (htc_get_pcbid_info() < PROJECT_PHASE_XB)){
			ret = gpio_request(TEGRA_GPIO_PJ2, "COMP_INT");
			if (ret < 0) {
				pr_err("[COMP] %s: gpio_request failed %d\n", __func__, ret);
				return;
			}

			ret = gpio_direction_input(TEGRA_GPIO_PJ2);
			if (ret < 0) {
				pr_err("[COMP] %s: gpio_direction_input failed %d\n", __func__, ret);
				gpio_free(TEGRA_GPIO_PJ2);
				return;
		}

			tegra_gpio_enable(TEGRA_GPIO_PJ2);
			tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_GMI_CS1_N, TEGRA_PUPD_NORMAL);
		}
		else{
			ret = gpio_request(TEGRA_GPIO_PN5, "COMP_INT");
			if (ret < 0) {
				pr_err("[COMP] %s: gpio_request failed %d\n", __func__, ret);
				return;
			}

			ret = gpio_direction_input(TEGRA_GPIO_PN5);
			if (ret < 0) {
				pr_err("[COMP] %s: gpio_direction_input failed %d\n", __func__, ret);
				gpio_free(TEGRA_GPIO_PN5);
				return;
			}

			tegra_gpio_enable(TEGRA_GPIO_PN5);
			tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_LCD_SDOUT, TEGRA_PUPD_PULL_DOWN);

		}
	}
}
Ejemplo n.º 5
0
void blue_pincfg_uartc_resume(void) {
    tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_UART3_CTS_N, TEGRA_PUPD_NORMAL);
    tegra_gpio_disable(TEGRA_GPIO_PA1);
    tegra_gpio_disable(TEGRA_GPIO_PC0);
    tegra_gpio_disable(TEGRA_GPIO_PW6);
    tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_UART3_RXD, TEGRA_PUPD_NORMAL);
    tegra_gpio_disable(TEGRA_GPIO_PW7);
}
static void enrc2u_gsensor_irq_init(void)
{
	int ret = 0;
	if(board_get_sku_tag() == 0x34600) {
		ret = gpio_request(TEGRA_GPIO_PS0, "GSNR_INT");
		if (ret < 0) {
			pr_err("%s: gpio_request failed %d\n", __func__, ret);
			return;
		}

		ret = gpio_direction_input(TEGRA_GPIO_PS0);
		if (ret < 0) {
			pr_err("%s: gpio_direction_input failed %d\n", __func__, ret);
			gpio_free(TEGRA_GPIO_PS0);
			return;
		}
		tegra_gpio_enable(TEGRA_GPIO_PS0);
		tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_KB_ROW8, TEGRA_PUPD_PULL_DOWN);

	}
	else {
		if ( (htc_get_pcbid_info() < PROJECT_PHASE_XB)){
			ret = gpio_request(TEGRA_GPIO_PN5, "GSNR_INT");
			if (ret < 0) {
				pr_err("%s: gpio_request failed %d\n", __func__, ret);
				return;
			}

			ret = gpio_direction_input(TEGRA_GPIO_PN5);
			if (ret < 0) {
				pr_err("%s: gpio_direction_input failed %d\n", __func__, ret);
				gpio_free(TEGRA_GPIO_PN5);
				return;
			}
			tegra_gpio_enable(TEGRA_GPIO_PN5);
			tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_LCD_SDOUT, TEGRA_PUPD_PULL_DOWN);
		}
		else{
			ret = gpio_request(TEGRA_GPIO_PS0, "GSNR_INT");
			if (ret < 0) {
				pr_err("%s: gpio_request failed %d\n", __func__, ret);
				return;
			}

			ret = gpio_direction_input(TEGRA_GPIO_PS0);
			if (ret < 0) {
				pr_err("%s: gpio_direction_input failed %d\n", __func__, ret);
				gpio_free(TEGRA_GPIO_PS0);
				return;
			}
			tegra_gpio_enable(TEGRA_GPIO_PS0);
			tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_KB_ROW8, TEGRA_PUPD_PULL_DOWN);

		}
	}
}
static int baseband_init(void)
{
	int irq;
	int ret;

	ret = gpio_request_array(modem_gpios, ARRAY_SIZE(modem_gpios));
	if (ret)
		return ret;

	/* enable pull-up for ULPI STP */
	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_ULPI_STP,
				    TEGRA_PUPD_PULL_UP);

	/* enable pull-up for MDM2AP_ACK2 */
	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_GPIO_PV0,
				    TEGRA_PUPD_PULL_UP);

	tegra_gpio_enable(MODEM_PWR_ON);
	tegra_gpio_enable(MODEM_RESET);
	tegra_gpio_enable(AP2MDM_ACK2);
	tegra_gpio_enable(BB_RST_OUT);
	tegra_gpio_enable(AP2MDM_ACK);
	tegra_gpio_enable(MDM2AP_ACK);
	tegra_gpio_enable(TEGRA_GPIO_PY3);
	tegra_gpio_enable(TEGRA_GPIO_PO1);
	tegra_gpio_enable(TEGRA_GPIO_PO2);

	/* export GPIO for user space access through sysfs */
	gpio_export(MODEM_PWR_ON, false);

	/* phy init */
	tegra_null_ulpi_init();

	wake_lock_init(&mdm_wake_lock, WAKE_LOCK_SUSPEND, "mdm_lock");

	/* enable IRQ for BB_RST_OUT */
	irq = gpio_to_irq(BB_RST_OUT);

	ret = request_threaded_irq(irq, NULL, mdm_start_thread,
				   IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
				   "mdm_start", NULL);
	if (ret < 0) {
		pr_err("%s: request_threaded_irq error\n", __func__);
		return ret;
	}

	ret = enable_irq_wake(irq);
	if (ret) {
		pr_err("%s: enable_irq_wake error\n", __func__);
		free_irq(irq, NULL);
		return ret;
	}

	return 0;
}
Ejemplo n.º 8
0
static int __init grouper_touch_init(void)
{
	int touch_id;

    return elan_touch_init();	
	tegra_gpio_enable(GROUPER_TS_ID1);
	tegra_gpio_enable(GROUPER_TS_ID2);

	gpio_request(GROUPER_TS_ID1, "touch-id1");
	gpio_direction_input(GROUPER_TS_ID1);

	gpio_request(GROUPER_TS_ID2, "touch-id2");
	gpio_direction_input(GROUPER_TS_ID2);

	touch_id = gpio_get_value(GROUPER_TS_ID1) << 1;
	touch_id |= gpio_get_value(GROUPER_TS_ID2);

	pr_info("touch-id %d\n", touch_id);

	/* Disable TS_ID GPIO to save power */
	gpio_direction_output(GROUPER_TS_ID1, 0);
	tegra_pinmux_set_pullupdown(GROUPER_TS_ID1_PG, TEGRA_PUPD_NORMAL);
	tegra_pinmux_set_tristate(GROUPER_TS_ID1_PG, TEGRA_TRI_TRISTATE);
	gpio_direction_output(GROUPER_TS_ID2, 0);
	tegra_pinmux_set_pullupdown(GROUPER_TS_ID2_PG, TEGRA_PUPD_NORMAL);
	tegra_pinmux_set_tristate(GROUPER_TS_ID2_PG, TEGRA_TRI_TRISTATE);

	switch (touch_id) {
	case 0:
		pr_info("Raydium PCB based touch init\n");
		tegra_clk_init_from_table(spi_clk_init_table);
		touch_init_raydium(TEGRA_GPIO_PZ3, TEGRA_GPIO_PN5, 0);
		break;
	case 1:
		pr_info("Raydium On-Board touch init\n");
		tegra_clk_init_from_table(spi_clk_init_table);
		tegra_clk_init_from_table(touch_clk_init_table);
		clk_enable(tegra_get_clock_by_name("clk_out_3"));

		touch_init_raydium(TEGRA_GPIO_PZ3, TEGRA_GPIO_PN5, 1);
		break;
	case 3:
		pr_info("Synaptics PCB based touch init\n");
		touch_init_synaptics_grouper();
		break;
	default:
		pr_err("touch_id error, no touch %d\n", touch_id);
	}
	return 0;
}
Ejemplo n.º 9
0
static void loki_hdmi_hotplug_report(bool state)
{
	if (state) {
		tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_DDC_SDA,
						TEGRA_PUPD_PULL_DOWN);
		tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_DDC_SCL,
						TEGRA_PUPD_PULL_DOWN);
	} else {
		tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_DDC_SDA,
						TEGRA_PUPD_NORMAL);
		tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_DDC_SCL,
						TEGRA_PUPD_NORMAL);
	}
}
static void endeavortd_config_bt_off(void)
{

	/* BT_SHUTDOWN_N */
	gpio_set_value(ENDEAVORTD_GPIO_BT_SHUTDOWN_N, 0);
	mdelay(1);

	/* UART3_CTS_N GPIO-A.01 I(PU) */
	tegra_gpio_enable(ENDEAVORTD_GPIO_BT_UART3_CTS);
	gpio_direction_input(ENDEAVORTD_GPIO_BT_UART3_CTS);

	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_UART3_CTS_N, TEGRA_PUPD_PULL_UP);

	/* UART3_RTS_N GPIO-C.00 O(H) */
	tegra_gpio_enable(ENDEAVORTD_GPIO_BT_UART3_RTS);
	gpio_direction_output(ENDEAVORTD_GPIO_BT_UART3_RTS, 1);

	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_UART3_RTS_N, TEGRA_PUPD_PULL_UP);

	/* UART3_TXD GPIO-W.06 O(H) */
	tegra_gpio_enable(ENDEAVORTD_GPIO_BT_UART3_TX);
	gpio_direction_output(ENDEAVORTD_GPIO_BT_UART3_TX, 1);

	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_UART3_TXD, TEGRA_PUPD_PULL_UP);

	/* UART3_RXD GPIO-W.07 I(PU) */
	tegra_gpio_enable(ENDEAVORTD_GPIO_BT_UART3_RX);
	gpio_direction_input(ENDEAVORTD_GPIO_BT_UART3_RX);

	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_UART3_RXD, TEGRA_PUPD_PULL_UP);

	/* BT_RTS */
	gpio_set_value(ENDEAVORTD_GPIO_BT_UART3_RTS, 1);

	/* BT_CTS */

	/* BT_TX */
	gpio_set_value(ENDEAVORTD_GPIO_BT_UART3_TX, 1);

	/* BT_RX */

	/* BT_HOST_WAKE */
	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_ULPI_DATA4, TEGRA_PUPD_PULL_DOWN);

	/* BT_CHIP_WAKE */
	gpio_set_value(ENDEAVORTD_GPIO_BT_WAKE, 0);

	printk(KERN_INFO "[BT]== R OFF ==\n");
}
Ejemplo n.º 11
0
static int __init enrc2u_wifi_init(void)
{
	int rc;

	rc = gpio_request(WIFI_ENABLE, "wlan_power");
	if (rc)
		pr_err("WLAN_PWR gpio request failed:%d\n", rc);
	rc = gpio_request(WIFI_IRQ, "bcmsdh_sdmmc");
	if (rc)
		pr_err("WLAN_IRQ gpio request failed:%d\n", rc);
	/*configure wifi irq to input pull down default*/
	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_ULPI_DATA3, TEGRA_PUPD_PULL_DOWN);

	tegra_gpio_enable(WIFI_ENABLE);
	tegra_gpio_enable(WIFI_IRQ);

	rc = gpio_direction_output(WIFI_ENABLE, 0);
	if (rc)
		pr_err("WLAN_PWR gpio direction configuration failed:%d\n", rc);
	rc = gpio_direction_input(WIFI_IRQ);
	if (rc)
		pr_err("WLAN_WOW gpio direction configuration failed:%d\n", rc);
	enrc2u_init_wifi_mem();
	platform_device_register(&enrc2u_wifi_device);

	return 0;
}
Ejemplo n.º 12
0
void blue_pincfg_uartc_gpio_request(void) {

    /* BT_EN GPIO-U.00 O(L) */
    long err = 0;

    /* UART3_CTS_N GPIO-A.01 */
    err = gpio_request(TEGRA_GPIO_PA1, "bt");
    if (err)
        pr_err("BT_CTS_N gpio request failed:%d\n", err);

    /* UART3_RTS_N GPIO-C.00 */
    err = gpio_request(TEGRA_GPIO_PC0, "bt");
    if (err)
        pr_err("BT_RTS_N gpio request failed:%d\n", err);

    /* UART3_TXD GPIO-W.06  */
    err = gpio_request(TEGRA_GPIO_PW6, "bt");
    if (err)
        pr_err("BT_TXD gpio request failed:%d\n", err);

    /* UART3_RXD GPIO-W.07  */
    err = gpio_request(TEGRA_GPIO_PW7, "bt");
    if (err)
        pr_err("BT_RXD gpio request failed:%d\n", err);

    /* BT_CTS#WAKE_UPGPIO-O.05_W  */
    err = gpio_request(TEGRA_GPIO_PO5, "bt");
    if (err)
        pr_err("BT_WAKEUP gpio request failed:%d\n", err);
    tegra_gpio_enable(TEGRA_GPIO_PO5);
    gpio_direction_input(TEGRA_GPIO_PO5);
    tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_ULPI_DATA4, TEGRA_PUPD_NORMAL);


}
Ejemplo n.º 13
0
static int baseband_init(void)
{
	int ret;

	ret = gpio_request_array(modem_gpios, ARRAY_SIZE(modem_gpios));
	if (ret) {
		pr_warn("%s:gpio request failed\n", __func__);
		return ret;
	}

	/* enable pull-down for MDM_COLD_BOOT */
	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_GMI_IORDY,
				    TEGRA_PUPD_PULL_DOWN);

	/* If modem part is not inserted,
	 * cut modem buck-boost circuit power
	 * MDM_APACK2 0 : inserted
	 * MDM_APACK2 1 : not inserted  */
	if (gpio_get_value(MDM_APACK2))
		gpio_set_value(MODEM_EN, 0);

	/* export GPIO for user space access through sysfs */
	gpio_export(MODEM_EN, false);
	gpio_export(MDM_RST, false);
	gpio_export(MDM_APACK2, false);

	return 0;
}
static void enterprise_gyro_diag_init(void)
{
	int ret = 0;


	pr_info("[GYRO] gyro diag_start...\n");
		ret = gpio_request(TEGRA_GPIO_PH3, "GYRO_DIAG");
		if (ret < 0) {
			pr_err("%s: gpio_request failed %d\n", __func__, ret);
			return;
		}

		ret = gpio_direction_input(TEGRA_GPIO_PH3);
		if (ret < 0) {
			pr_err("%s: gpio_direction_input failed %d\n", __func__, ret);
			gpio_free(TEGRA_GPIO_PH3);
			return;
		}
		tegra_gpio_enable(TEGRA_GPIO_PH3);
		tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_GMI_AD11, TEGRA_PUPD_NORMAL);

		
	pr_info("[GYRO] gyro diag irq end...\n");

}
void __init stingray_pinmux_init(void)
{
	tegra_pinmux_config_table(stingray_pinmux, ARRAY_SIZE(stingray_pinmux));
	tegra_drive_pinmux_config_table(stingray_drive_pinmux,
		ARRAY_SIZE(stingray_drive_pinmux));

	if (!stingray_hw_has_cdma() && !stingray_hw_has_umts()) {
		/* Keep the pins from floating and creating excessive
		 * current drain. */
		tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_GMC,
					    TEGRA_PUPD_PULL_UP);
		tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_UDA,
					    TEGRA_PUPD_PULL_UP);
	}

	tegra_gpio_disable(TEGRA_GPIO_PE0);
	tegra_gpio_disable(TEGRA_GPIO_PE1);
	tegra_gpio_disable(TEGRA_GPIO_PE2);
	tegra_gpio_disable(TEGRA_GPIO_PE3);
	tegra_gpio_disable(TEGRA_GPIO_PE4);
	tegra_gpio_disable(TEGRA_GPIO_PE5);
	tegra_gpio_disable(TEGRA_GPIO_PE6);
	tegra_gpio_disable(TEGRA_GPIO_PE7);
	tegra_gpio_disable(TEGRA_GPIO_PF0);
	tegra_gpio_disable(TEGRA_GPIO_PF1);
	tegra_gpio_disable(TEGRA_GPIO_PF2);
	tegra_gpio_disable(TEGRA_GPIO_PF3);
	tegra_gpio_disable(TEGRA_GPIO_PF4);
	tegra_gpio_disable(TEGRA_GPIO_PF5);
	tegra_gpio_disable(TEGRA_GPIO_PF6);
	tegra_gpio_disable(TEGRA_GPIO_PF7);
	tegra_gpio_disable(TEGRA_GPIO_PM0);
	tegra_gpio_disable(TEGRA_GPIO_PM1);
	tegra_gpio_disable(TEGRA_GPIO_PM2);
	tegra_gpio_disable(TEGRA_GPIO_PM3);
	tegra_gpio_disable(TEGRA_GPIO_PM4);
	tegra_gpio_disable(TEGRA_GPIO_PM5);
	tegra_gpio_disable(TEGRA_GPIO_PM6);
	tegra_gpio_disable(TEGRA_GPIO_PM7);
	tegra_gpio_disable(TEGRA_GPIO_PN7);

	tegra_gpio_disable(TEGRA_GPIO_PK5);
	tegra_gpio_disable(TEGRA_GPIO_PK6);
}
static void enterprise_gsensor_irq_init(void)
{
	int ret = 0;

	//tegra_gpio_enable(TEGRA_GPIO_PH4);
	//ret = gpio_request(TEGRA_GPIO_PH4, SENSOR_MPU_NAME);
	pr_info("[GSNR] g-sensor irq_start...\n");
	if(htc_get_pcbid_info() <= PROJECT_PHASE_XB){
		ret = gpio_request(TEGRA_GPIO_PO5, "GSNR_INT");
		if (ret < 0) {
			pr_err("%s: gpio_request failed %d\n", __func__, ret);
			return;
		}

		ret = gpio_direction_input(TEGRA_GPIO_PO5);
		if (ret < 0) {
			pr_err("%s: gpio_direction_input failed %d\n", __func__, ret);
			gpio_free(TEGRA_GPIO_PO5);
			return;
		}
		tegra_gpio_enable(TEGRA_GPIO_PO5);
		tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_ULPI_DATA4, TEGRA_PUPD_NORMAL);
	}
	else{
		ret = gpio_request(TEGRA_GPIO_PN5, "GSNR_INT");
		if (ret < 0) {
			pr_err("%s: gpio_request failed %d\n", __func__, ret);
			return;
		}

		ret = gpio_direction_input(TEGRA_GPIO_PN5);
		if (ret < 0) {
			pr_err("%s: gpio_direction_input failed %d\n", __func__, ret);
			gpio_free(TEGRA_GPIO_PN5);
			return;
		}
		tegra_gpio_enable(TEGRA_GPIO_PN5);
		tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_LCD_SDOUT, TEGRA_PUPD_NORMAL);

	}
		
	pr_info("[GSNR] g-sensor irq end...\n");

}
Ejemplo n.º 17
0
int enrc2u_wifi_resume_gpio(void)
{
	printk("[WLAN] restore SDIO pins config by resume\n");
	
	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_SDMMC3_CMD, TEGRA_PUPD_PULL_UP);
	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_SDMMC3_DAT0, TEGRA_PUPD_PULL_UP);
	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_SDMMC3_DAT1, TEGRA_PUPD_PULL_UP);
	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_SDMMC3_DAT2, TEGRA_PUPD_PULL_UP);
	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_SDMMC3_DAT3, TEGRA_PUPD_PULL_UP);
	
	tegra_gpio_disable(WIFI_SDIO_CLK);
	tegra_gpio_disable(WIFI_SDIO_CMD);
	tegra_gpio_disable(WIFI_SDIO_D0);
	tegra_gpio_disable(WIFI_SDIO_D1);
	tegra_gpio_disable(WIFI_SDIO_D2);
	tegra_gpio_disable(WIFI_SDIO_D3);
	
	return 0;
}
static int baseband_init(void)
{
	int ret;

	ret = gpio_request_array(modem_gpios, ARRAY_SIZE(modem_gpios));
	if (ret)
		return ret;

	/* enable pull-up for ULPI STP */
	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_ULPI_STP,
				    TEGRA_PUPD_PULL_UP);

	/* enable pull-up for MDM2AP_ACK2 */
	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_GPIO_PV0,
				    TEGRA_PUPD_PULL_UP);

	/* export GPIO for user space access through sysfs */
	gpio_export(MODEM_PWR_ON, false);

	return 0;
}
static void endeavortd_config_bt_on(void)
{
	printk(KERN_INFO "[BT]== R ON ==\n");

	tegra_gpio_disable(ENDEAVORTD_GPIO_BT_UART3_CTS);
	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_UART3_CTS_N, TEGRA_PUPD_NORMAL);

	tegra_gpio_disable(ENDEAVORTD_GPIO_BT_UART3_RTS);
	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_UART3_RTS_N, TEGRA_PUPD_NORMAL);

	tegra_gpio_disable(ENDEAVORTD_GPIO_BT_UART3_TX);
	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_UART3_TXD, TEGRA_PUPD_NORMAL);

	tegra_gpio_disable(ENDEAVORTD_GPIO_BT_UART3_RX);
	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_UART3_RXD, TEGRA_PUPD_NORMAL);

	/* BT_RTS */

	/* BT_CTS */

	/* BT_TX */

	/* BT_RX */

	/* BT_HOST_WAKE */
	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_ULPI_DATA4, TEGRA_PUPD_PULL_UP);

	/* BT_CHIP_WAKE */
	gpio_set_value(ENDEAVORTD_GPIO_BT_WAKE, 1);

	/* BT_SHUTDOWN_N */
	gpio_set_value(ENDEAVORTD_GPIO_BT_SHUTDOWN_N, 0);
	mdelay(5);

	/* BT_SHUTDOWN_N */
	gpio_set_value(ENDEAVORTD_GPIO_BT_SHUTDOWN_N, 1);
	mdelay(1);

}
Ejemplo n.º 20
0
static int baseband2_init(void)
{
	int ret;

	tegra_pinmux_set_tristate(TEGRA_PINGROUP_GPIO_X1_AUD, TEGRA_TRI_NORMAL);

	ret = gpio_request_array(modem2_gpios, ARRAY_SIZE(modem2_gpios));
	if (ret)
		return ret;

	/* enable pull-down for MDM2_COLD_BOOT */
	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_KB_ROW4,
				    TEGRA_PUPD_PULL_DOWN);

	/* export GPIO for user space access through sysfs */
	gpio_export(MDM2_RST, false);

	return 0;
}
Ejemplo n.º 21
0
static int baseband_init(void)
{
	int ret;

	ret = gpio_request_array(modem_gpios, ARRAY_SIZE(modem_gpios));
	if (ret) {
		pr_warn("%s:gpio request failed\n", __func__);
		return ret;
	}

	/* enable pull-down for MDM_COLD_BOOT */
	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_ULPI_DATA4,
				    TEGRA_PUPD_PULL_DOWN);

	/* export GPIO for user space access through sysfs */
	gpio_export(MDM_RST, false);

	return 0;
}
static void __init enterprise_mpuirq_init(void)
{
    int ret = 0;

    tegra_gpio_enable(TEGRA_GPIO_PI6);
    ret = gpio_request(TEGRA_GPIO_PI6, SENSOR_MPU_NAME);
    if (ret < 0) {
        pr_err("%s: gpio_request failed %d\n", __func__, ret);
        return;
    }

    ret = gpio_direction_input(TEGRA_GPIO_PI6);
    if (ret < 0) {
        pr_err("%s: gpio_direction_input failed %d\n", __func__, ret);
        gpio_free(TEGRA_GPIO_PI6);
        return;
    }
    tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_GMI_CS7_N, TEGRA_PUPD_NORMAL);
}
static int __init ph450_init(void)
{
	int ret;

	ret = gpio_request(MODEM_PWR_ON, "mdm_power");
	if (ret)
		return ret;

	ret = gpio_request(MODEM_RESET, "mdm_reset");
	if (ret) {
		gpio_free(MODEM_PWR_ON);
		return ret;
	}
	ret = gpio_request(AP2MDM_ACK2, "ap2mdm_ack2");
	if (ret) {
		gpio_free(MODEM_PWR_ON);
		gpio_free(MODEM_RESET);
		return ret;
	}
	ret = gpio_request(MDM2AP_ACK2, "mdm2ap_ack2");
	if (ret) {
		gpio_free(MODEM_PWR_ON);
		gpio_free(MODEM_RESET);
		gpio_free(AP2MDM_ACK2);
		return ret;
	}

	/* enable pull-up for MDM2AP_ACK2 */
	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_UAC, TEGRA_PUPD_PULL_UP);

	tegra_gpio_enable(MODEM_PWR_ON);
	tegra_gpio_enable(MODEM_RESET);
	tegra_gpio_enable(AP2MDM_ACK2);
	tegra_gpio_enable(MDM2AP_ACK2);

	gpio_direction_output(MODEM_PWR_ON, 0);
	gpio_direction_output(MODEM_RESET, 0);
	gpio_direction_output(AP2MDM_ACK2, 1);
	gpio_direction_input(MDM2AP_ACK2);

	return 0;
}
static void enterprise_comp_irq_init(void)
{
    int ret = 0;

    ret = gpio_request(TEGRA_GPIO_PJ2, "COMP_INT");
    if (ret < 0) {
        pr_err("[COMP] %s: gpio_request failed %d\n", __func__, ret);
        return;
    }

    ret = gpio_direction_input(TEGRA_GPIO_PJ2);
    if (ret < 0) {
        pr_err("[COMP] %s: gpio_direction_input failed %d\n", __func__, ret);
        gpio_free(TEGRA_GPIO_PJ2);
        return;
    }

    tegra_gpio_enable(TEGRA_GPIO_PJ2);
    tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_GMI_CS1_N, TEGRA_PUPD_NORMAL);
    gpio_free(TEGRA_GPIO_PJ2);
}
Ejemplo n.º 25
0
static int __init roth_touch_init(void)
{
	struct board_info board_info;

	tegra_get_board_info(&board_info);
	if (board_info.board_id == BOARD_P2560) {
		int touch_id = tegra_get_touch_panel_id();
		if (touch_id == PANEL_TPK || touch_id == PANEL_WINTEK) {
			int err;
			err = gpio_request(TOUCH_GPIO_CLK, "touch-gpio-clk");
			if (err < 0)
				pr_err("%s: gpio_request failed %d\n",
					__func__, err);
			else {
				err = gpio_direction_output(TOUCH_GPIO_CLK, 0);
				if (err < 0)
					pr_err("%s: set output failed %d\n",
					__func__, err);
				gpio_free(TOUCH_GPIO_CLK);
			}
			tegra_pinmux_set_pullupdown(TOUCH_GPIO_CLK_PG,
							TEGRA_PUPD_NORMAL);
			tegra_pinmux_set_tristate(TOUCH_GPIO_CLK_PG,
							TEGRA_TRI_TRISTATE);
			rm31080ts_roth_data.name_of_clock = NULL;
			rm31080ts_roth_data.name_of_clock_con = NULL;
		} else
			tegra_clk_init_from_table(touch_clk_init_table);
	} else
		tegra_clk_init_from_table(touch_clk_init_table);
	rm31080a_roth_spi_board[0].irq =
		gpio_to_irq(TOUCH_GPIO_IRQ_RAYDIUM_SPI);
	touch_init_raydium(TOUCH_GPIO_IRQ_RAYDIUM_SPI,
				TOUCH_GPIO_RST_RAYDIUM_SPI,
				&rm31080ts_roth_data,
				&rm31080a_roth_spi_board[0],
				ARRAY_SIZE(rm31080a_roth_spi_board));
	return 0;
}
Ejemplo n.º 26
0
static void mdm_status_fn(struct work_struct *work)
{
	
	int value;

	//HTC+++
	mutex_lock(&MDM_BOOT_STATUS_CHECK_LOCK);
	mdm2ap_gpio_status = gpio_get_value(mdm_drv->mdm2ap_status_gpio);
	value = mdm2ap_gpio_status;
	//HTC---

	pr_info("mdm_status_fn\n");

	mdm_drv->ops->status_cb(mdm_drv, value);

	pr_debug("%s: status:%d\n", __func__, value);

	if ((value == 0) && mdm_drv->mdm_ready && !device_ehci_shutdown) {
		//++SSD_RIL: set mdm_drv->mdm_ready before restart modem
		mdm_drv->mdm_ready = 0;
		//--SSD_RIL
		pr_info("%s: unexpected reset external modem\n", __func__);
		/* HTC added start */
		dump_mdm_related_gpio();
		/* HTC added end */
		subsystem_restart(EXTERNAL_MODEM);
	} else if (value == 1) {
	  //Sophia:0510-Change to NO_PULL
	  extern const int gpio_to_pingroup[TEGRA_MAX_GPIO];
	  tegra_pinmux_set_pullupdown(gpio_to_pingroup[mdm_drv->mdm2ap_status_gpio], TEGRA_PUPD_NORMAL);
		pr_info("%s: status = 1: mdm is now ready\n", __func__);
	}

	//HTC+++
	mutex_unlock(&MDM_BOOT_STATUS_CHECK_LOCK);
	//HTC---
}
static void enterprise_gsensor_irq_init(void)
{
    int ret = 0;

    pr_info("[GSNR] g-sensor irq_start...\n");

    ret = gpio_request(TEGRA_GPIO_PN5, "GSNR_INT");
    if (ret < 0) {
        pr_err("%s: gpio_request failed %d\n", __func__, ret);
        return;
    }

    ret = gpio_direction_input(TEGRA_GPIO_PN5);
    if (ret < 0) {
        pr_err("%s: gpio_direction_input failed %d\n", __func__, ret);
        gpio_free(TEGRA_GPIO_PN5);
        return;
    }
    tegra_gpio_enable(TEGRA_GPIO_PN5);
    tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_LCD_SDOUT, TEGRA_PUPD_NORMAL);

    pr_info("[GSNR] g-sensor irq end...\n");

}
// Riemer 07-05-2012: Added __init
static void __init enterprise_mpuirq_init(void)
{
	int ret = 0;

	tegra_gpio_enable(TEGRA_GPIO_PI6);
	ret = gpio_request(TEGRA_GPIO_PI6, SENSOR_MPU_NAME);
	if (ret < 0) {
		pr_err("%s: gpio_request failed %d\n", __func__, ret);
		return;
	}

	ret = gpio_direction_input(TEGRA_GPIO_PI6);
	if (ret < 0) {
		pr_err("%s: gpio_direction_input failed %d\n", __func__, ret);
		gpio_free(TEGRA_GPIO_PI6);
		return;
	}
	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_GMI_CS7_N, TEGRA_PUPD_NORMAL);

	if(htc_get_pcbid_info() == PROJECT_PHASE_XA){
		i2c_register_board_info(0, mpu3050_i2c0_boardinfo,
					ARRAY_SIZE(mpu3050_i2c0_boardinfo));
	}
}
static void config_nfc_gpios(void)
{
    int ret = 0;

    ret = gpio_direction_output(RUBY_GPIO_NFC_VEN, 0);
    if (ret < 0) {
        pr_err("TEGRA_GPIO_PM5 output failed\n");
        pr_err("[NFC] %s: gpio_direction_output failed %d\n", __func__, ret);
        gpio_free(RUBY_GPIO_NFC_VEN);
        return;
    }
    tegra_gpio_enable(RUBY_GPIO_NFC_VEN);

    ret = gpio_direction_output(RUBY_GPIO_NFC_DL, 0);
    if (ret < 0) {
        pr_err("TEGRA_GPIO_PM6 output failed\n");
        pr_err("[NFC] %s: gpio_direction_output failed %d\n", __func__, ret);
        gpio_free(RUBY_GPIO_NFC_DL);
        return;
    }
    tegra_gpio_enable(RUBY_GPIO_NFC_DL);

    ret = gpio_direction_input(RUBY_GPIO_NFC_INT);
    if (ret < 0) {
        pr_err("TEGRA_GPIO_PY6 output failed\n");
        pr_err("[NFC] %s: gpio_direction_output failed %d\n", __func__, ret);
        gpio_free(RUBY_GPIO_NFC_INT);
        return;
    }
    tegra_gpio_enable(RUBY_GPIO_NFC_INT);

    tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_SDMMC1_DAT1, TEGRA_PUPD_NORMAL);

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

}
static void enrc2u_mpuirq_init(void)
{
	int ret = 0;
	if(board_get_sku_tag() == 0x34600) {
		tegra_gpio_enable(TEGRA_GPIO_PJ2);
		ret = gpio_request(TEGRA_GPIO_PJ2, SENSOR_MPU_NAME);
		if (ret < 0) {
			pr_err("%s: gpio_request failed %d\n", __func__, ret);
				return;
		}

		ret = gpio_direction_input(TEGRA_GPIO_PJ2);
		if (ret < 0) {
			pr_err("%s: gpio_direction_input failed %d\n", __func__, ret);
			gpio_free(TEGRA_GPIO_PJ2);
			return;
		}
		tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_GMI_CS1_N, TEGRA_PUPD_PULL_DOWN);

                        i2c_register_board_info(0, mpu3050_i2c0_boardinfo_xb,
                                        ARRAY_SIZE(mpu3050_i2c0_boardinfo_xb));

	}
	else{
		if ( (htc_get_pcbid_info() < PROJECT_PHASE_XB)){
			tegra_gpio_enable(TEGRA_GPIO_PS0);
			ret = gpio_request(TEGRA_GPIO_PS0, SENSOR_MPU_NAME);
			if (ret < 0) {
				pr_err("%s: gpio_request failed %d\n", __func__, ret);
				return;
			}

			ret = gpio_direction_input(TEGRA_GPIO_PS0);
			if (ret < 0) {
				pr_err("%s: gpio_direction_input failed %d\n", __func__, ret);
				gpio_free(TEGRA_GPIO_PS0);
				return;
			}
			tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_KB_ROW8, TEGRA_PUPD_PULL_DOWN);

			i2c_register_board_info(0, mpu3050_i2c0_boardinfo,
						ARRAY_SIZE(mpu3050_i2c0_boardinfo));
		}

		else{
			tegra_gpio_enable(TEGRA_GPIO_PJ2);
			ret = gpio_request(TEGRA_GPIO_PJ2, SENSOR_MPU_NAME);
			if (ret < 0) {
				pr_err("%s: gpio_request failed %d\n", __func__, ret);
				return;
			}

			ret = gpio_direction_input(TEGRA_GPIO_PJ2);
			if (ret < 0) {
				pr_err("%s: gpio_direction_input failed %d\n", __func__, ret);
				gpio_free(TEGRA_GPIO_PJ2);
				return;
			}
			tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_GMI_CS1_N, TEGRA_PUPD_PULL_DOWN);

			i2c_register_board_info(0, mpu3050_i2c0_boardinfo_xb,
					ARRAY_SIZE(mpu3050_i2c0_boardinfo_xb));

		}
	}
}