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;
}
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;
}
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);
}
}
}
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;
}
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;
}
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");
}
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;
}
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);
}
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");
}
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);
}
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;
}
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);
}
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;
}
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));
}
}
}