static ssize_t uart_switch_store ( struct device *dev, struct device_attribute *attr, const char *buf, size_t size ) { int switch_sel; int console_mode; int path_save = 1; if (sec_get_param_value) { sec_get_param_value(__SWITCH_SEL, &switch_sel); sec_get_param_value(__CONSOLE_MODE, &console_mode); } if (strstr(buf, "PDA") || strstr(buf, "pda")) { if(uart_current_owner != SWITCH_PDA) { sio_switch_config(AP_UART_MODE); } uart_current_owner = SWITCH_PDA; switch_sel |= UART_SEL_MASK; console_mode = 1; printk("[UART Switch] Path : PDA\n"); } else if (strstr(buf, "MODEM") || strstr(buf, "modem")) { if(uart_current_owner != SWITCH_MODEM) { sio_switch_config(CP_UART_MODE); } uart_current_owner = SWITCH_MODEM; switch_sel &= ~UART_SEL_MASK; console_mode = 0; printk("[UART Switch] Path : MODEM\n"); } if(strstr(buf, "NOSAVE") || strstr(buf, "nosave")) { path_save = 0; printk("[UART Switch] path is not saved\n"); } if(path_save) { if (sec_set_param_value) { sec_set_param_value(__SWITCH_SEL, &switch_sel); sec_set_param_value(__CONSOLE_MODE, &console_mode); } } return size; }
static ssize_t uart_switch_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { int switch_sel = 1; if (sec_get_param_value) sec_get_param_value(__SWITCH_SEL, &switch_sel); if (strncmp(buf, "PDA", 3) == 0 || strncmp(buf, "pda", 3) == 0) { gpio_set_value(GPIO_UART_SEL, GPIO_LEVEL_HIGH); uart_current_owner = 1; switch_sel |= UART_SEL_MASK; printk("[UART Switch] Path : PDA\n"); } if (strncmp(buf, "MODEM", 5) == 0 || strncmp(buf, "modem", 5) == 0) { gpio_set_value(GPIO_UART_SEL, GPIO_LEVEL_LOW); uart_current_owner = 0; switch_sel &= ~UART_SEL_MASK; printk("[UART Switch] Path : MODEM\n"); } if (sec_set_param_value) sec_set_param_value(__SWITCH_SEL, &switch_sel); return size; }
static void sec_switch_init_work(struct work_struct *work) { struct delayed_work *dw = container_of(work, struct delayed_work, work); struct sec_switch_wq *wq = container_of(dw, struct sec_switch_wq, work_q); struct sec_switch_struct *secsw = wq->sdata; int usb_sel = 0; int uart_sel = 0; int ret = 0; int samsung_kies_sel,ums_sel,mtp_sel,vtp_sel,askon_sel; // printk("%s : called!!\n", __func__); if (sec_get_param_value && secsw->pdata && secsw->pdata->set_regulator && secsw->pdata->get_phy_init_status && secsw->pdata->get_phy_init_status()) { sec_get_param_value(__SWITCH_SEL, &secsw->switch_sel); cancel_delayed_work(&wq->work_q); } //else if (!regulator_get(NULL, "vbus_ap") || !(secsw->pdata->get_phy_init_status())) { else { schedule_delayed_work(&wq->work_q, msecs_to_jiffies(1000)); return ; } if(secsw->pdata && secsw->pdata->get_regulator) { ret = secsw->pdata->get_regulator(); if(ret != 0) { pr_err("%s : failed to get regulators\n", __func__); return ; } } // init shared variable. if(secsw->pdata && secsw->pdata->set_switch_status) secsw->pdata->set_switch_status(secsw->switch_sel); usb_sel = secsw->switch_sel & (int)(USB_SEL_MASK); uart_sel = (secsw->switch_sel & (int)(UART_SEL_MASK)) >> 1; printk("%s : initial usb_sel(%d), uart_sel(%d)\n", __func__, usb_sel, uart_sel); // init UART/USB path. if(usb_sel) { usb_switch_mode(secsw, SWITCH_PDA); } else { usb_switch_mode(secsw, SWITCH_MODEM); } if(uart_sel) { gpio_set_value(GPIO_UART_SEL, 1); secsw->uart_owner = 1; } else { gpio_set_value(GPIO_UART_SEL, 0); secsw->uart_owner = 0; }
static ssize_t uart_sel_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct sec_switch_struct *secsw = dev_get_drvdata(dev); if (sec_get_param_value) sec_get_param_value(__SWITCH_SEL, &secsw->switch_sel); if (strncmp(buf, "PDA", 3) == 0 || strncmp(buf, "pda", 3) == 0) { gpio_set_value(GPIO_UART_SEL, 1); secsw->switch_sel |= UART_SEL_MASK; pr_debug("[UART Switch] Path : PDA\n"); } if (strncmp(buf, "MODEM", 5) == 0 || strncmp(buf, "modem", 5) == 0) { gpio_set_value(GPIO_UART_SEL, 0); secsw->switch_sel &= ~UART_SEL_MASK; pr_debug("[UART Switch] Path : MODEM\n"); } if (sec_set_param_value) sec_set_param_value(__SWITCH_SEL, &secsw->switch_sel); return size; }
static ssize_t usb_sel_store( struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { dmsg("\n"); if (sec_get_param_value) sec_get_param_value(__SWITCH_SEL, &switch_sel); if(strncmp(buf, "PDA", 3) == 0 || strncmp(buf, "pda", 3) == 0) { usb_switch_mode(SWITCH_PDA); usb_switching_value_update(SWITCH_PDA); switch_sel |= USB_SEL_MASK; } if(strncmp(buf, "MODEM", 5) == 0 || strncmp(buf, "modem", 5) == 0) { usb_switch_mode(SWITCH_MODEM); usb_switching_value_update(SWITCH_MODEM); switch_sel &= ~USB_SEL_MASK; } switching_value_update(); if (sec_set_param_value) sec_set_param_value(__SWITCH_SEL, &switch_sel); microusb_uart_status(0); return size; }
static ssize_t uart_switch_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { if (sec_get_param_value) sec_get_param_value(__SWITCH_SEL, &switch_sel); if (strncmp(buf, "PDA", 3) == 0 || strncmp(buf, "pda", 3) == 0) { Ap_Cp_Switch_Config(AP_UART_MODE); uart_switching_value_update(SWITCH_PDA); uart_current_owner = 1; switch_sel |= UART_SEL_MASK; printk("[UART Switch] Path : PDA\n"); } if (strncmp(buf, "MODEM", 5) == 0 || strncmp(buf, "modem", 5) == 0) { Ap_Cp_Switch_Config(CP_UART_MODE); uart_switching_value_update(SWITCH_MODEM); uart_current_owner = 0; switch_sel &= ~UART_SEL_MASK; printk("[UART Switch] Path : MODEM\n"); } switching_value_update(); if (sec_set_param_value) sec_set_param_value(__SWITCH_SEL, &switch_sel); return size; }
static ssize_t usb_sel_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct sec_switch_struct *secsw = dev_get_drvdata(dev); printk("\n"); if (sec_get_param_value) sec_get_param_value(__SWITCH_SEL, &(secsw->switch_sel)); if(strncmp(buf, "PDA", 3) == 0 || strncmp(buf, "pda", 3) == 0) { usb_switch_mode(secsw, SWITCH_PDA); // usb_switching_value_update(SWITCH_PDA); secsw->switch_sel |= USB_SEL_MASK; } if(strncmp(buf, "MODEM", 5) == 0 || strncmp(buf, "modem", 5) == 0) { usb_switch_mode(secsw, SWITCH_MODEM); // usb_switching_value_update(SWITCH_MODEM); secsw->switch_sel &= ~USB_SEL_MASK; } // switching_value_update(); if (sec_set_param_value) sec_set_param_value(__SWITCH_SEL, &(secsw->switch_sel)); // update shared variable. if(secsw->pdata && secsw->pdata->set_switch_status) secsw->pdata->set_switch_status(secsw->switch_sel); return size;
static ssize_t uart_switch_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct sec_switch_struct *secsw = dev_get_drvdata(dev); if (sec_get_param_value) sec_get_param_value(__SWITCH_SEL, &(secsw->switch_sel)); if (strncmp(buf, "PDA", 3) == 0 || strncmp(buf, "pda", 3) == 0) { gpio_set_value(GPIO_UART_SEL, 1); // uart_switching_value_update(SWITCH_PDA); secsw->uart_owner = 1; secsw->switch_sel |= UART_SEL_MASK; printk("[UART Switch] Path : PDA\n"); } if (strncmp(buf, "MODEM", 5) == 0 || strncmp(buf, "modem", 5) == 0) { gpio_set_value(GPIO_UART_SEL, 0); // uart_switching_value_update(SWITCH_MODEM); secsw->uart_owner = 0; secsw->switch_sel &= ~UART_SEL_MASK; printk("[UART Switch] Path : MODEM\n"); } // switching_value_update(); if (sec_set_param_value) sec_set_param_value(__SWITCH_SEL, &(secsw->switch_sel)); // update shared variable. if(secsw->pdata && secsw->pdata->set_switch_status) secsw->pdata->set_switch_status(secsw->switch_sel); return size;
static void microusb_uart_status(int status) { int switch_sel; int uart_sel; int usb_sel; if(!FSA9480_Get_JIG_UART_Status()) return; if (sec_get_param_value) sec_get_param_value(__SWITCH_SEL, &switch_sel); uart_sel = (switch_sel & (int)(UART_SEL_MASK)) >> 1; usb_sel = switch_sel & (int)(USB_SEL_MASK); if(status) { if(uart_sel) Ap_Cp_Switch_Config(AP_UART_MODE); else Ap_Cp_Switch_Config(CP_UART_MODE); } else { if(!usb_sel) Ap_Cp_Switch_Config(AP_USB_MODE); } }
static ssize_t uart_debug_show(struct device *dev, struct device_attribute *attr, char *buf) { int switch_sel = 0; if (sec_get_param_value) sec_get_param_value(__SWITCH_SEL, &switch_sel); return sprintf(buf, "%s\n", (switch_sel & UART_DEBUG_MASK) ? "ENABLE" : "DISABLE"); }
// TODO : remove this. int FSA9480_PMIC_CP_USB(void) { int usb_sel = 0; if (sec_get_param_value) sec_get_param_value(__SWITCH_SEL, &switch_sel); usb_sel = switch_sel & (int)(USB_SEL_MASK); return usb_sel; }
void UsbMenuSelStore(int sel) { if (sec_get_param_value) sec_get_param_value(__SWITCH_SEL, &switch_sel); if(sel == 0) { switch_sel &= ~(int)USB_UMS_MASK; switch_sel &= ~(int)USB_MTP_MASK; #if !defined(CONFIG_ARIES_NTT) // disable tethering xmoondash switch_sel &= ~(int)USB_VTP_MASK; #endif switch_sel &= ~(int)USB_ASKON_MASK; switch_sel |= (int)USB_SAMSUNG_KIES_MASK; } else if(sel == 1) { switch_sel &= ~(int)USB_UMS_MASK; switch_sel &= ~(int)USB_SAMSUNG_KIES_MASK; #if !defined(CONFIG_ARIES_NTT) // disable tethering xmoondash switch_sel &= ~(int)USB_VTP_MASK; #endif switch_sel &= ~(int)USB_ASKON_MASK; switch_sel |= (int)USB_MTP_MASK; } else if(sel == 2) { switch_sel &= ~(int)USB_SAMSUNG_KIES_MASK; switch_sel &= ~(int)USB_MTP_MASK; #if !defined(CONFIG_ARIES_NTT) // disable tethering xmoondash switch_sel &= ~(int)USB_VTP_MASK; #endif switch_sel &= ~(int)USB_ASKON_MASK; switch_sel |= (int)USB_UMS_MASK; } else if(sel == 3) { switch_sel &= ~(int)USB_UMS_MASK; switch_sel &= ~(int)USB_MTP_MASK; switch_sel &= ~(int)USB_SAMSUNG_KIES_MASK; switch_sel &= ~(int)USB_ASKON_MASK; #if !defined(CONFIG_ARIES_NTT) // disable tethering xmoondash switch_sel |= (int)USB_VTP_MASK; #endif } else if(sel == 4) { switch_sel &= ~(int)USB_UMS_MASK; switch_sel &= ~(int)USB_MTP_MASK; #if !defined(CONFIG_ARIES_NTT) // disable tethering xmoondash switch_sel &= ~(int)USB_VTP_MASK; #endif switch_sel &= ~(int)USB_SAMSUNG_KIES_MASK; switch_sel |= (int)USB_ASKON_MASK; } if (sec_set_param_value) sec_set_param_value(__SWITCH_SEL, &switch_sel); }
static ssize_t usb_sel_store ( struct device *dev, struct device_attribute *attr, const char *buf, size_t size ) { int switch_sel; int path_save = 1; if (sec_get_param_value) { sec_get_param_value(__SWITCH_SEL, &switch_sel); } if(strstr(buf, "PDA") || strstr(buf, "pda")) { if(usb_path != SWITCH_PDA) { sio_switch_config(AP_USB_MODE); } usb_path = SWITCH_PDA; switch_sel |= USB_SEL_MASK; printk("[USB Switch] Path : PDA\n"); } else if(strstr(buf, "MODEM") || strstr(buf, "modem")) { if(usb_path != SWITCH_MODEM) { sio_switch_config(CP_USB_MODE); } usb_path = SWITCH_MODEM; switch_sel &= ~USB_SEL_MASK; printk("[USB Switch] Path : MODEM\n"); } if(strstr(buf, "NOSAVE") || strstr(buf, "nosave")) { path_save = 0; printk("[USB Switch] path is not saved\n"); } if(path_save) { if (sec_set_param_value) { sec_set_param_value(__SWITCH_SEL, &switch_sel); } } return size; }
static ssize_t usb_sel_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct sec_switch_struct *secsw = dev_get_drvdata(dev); int value; value = usb_cable; pr_info("%s\n", __func__); pr_info("%s the device type detected is %x\n", __func__, value); if (sec_get_param_value) sec_get_param_value(__SWITCH_SEL, &secsw->switch_sel); if (strncmp(buf, "PDA", 3) == 0 || strncmp(buf, "pda", 3) == 0) { if (value == CABLE_CONNECTED) { usb_switch_mode(secsw, SWITCH_PDA); pr_info("[USB Switch] Path : PDA\n"); } else { pr_info("[USB Switch] Path is not change (PDA) Connect = %d\n", value); } secsw->switch_sel = (secsw->switch_sel & ~USB_PATH_MASK) | USB_PATH_PDA; } if (strncmp(buf, "MODEM", 5) == 0 || strncmp(buf, "modem", 5) == 0) { if (value == CABLE_CONNECTED) { usb_switch_mode(secsw, SWITCH_MODEM); pr_info("[USB Switch] Path : MODEM\n"); } else { pr_info("[USB Switch] Path is not change (MODEM) Connect = %d\n", value); } secsw->switch_sel = (secsw->switch_sel & ~USB_PATH_MASK) | USB_PATH_MODEM; } if (strncmp(buf, "LTEMODEM", 3) == 0 || strncmp(buf, "ltemodem", 3) == 0) { if (value == CABLE_CONNECTED) { usb_switch_mode(secsw, SWITCH_LTE); pr_info("[USB Switch] Path : LTEMODEM\n"); } else { pr_info("[USB Switch] Path is not change (LTEMODEM) Connect = %d\n", value); } secsw->switch_sel = (secsw->switch_sel & ~USB_PATH_MASK) | USB_PATH_LTE; } if (sec_set_param_value) sec_set_param_value(__SWITCH_SEL, &secsw->switch_sel); return size; }
void uart_insert_switch_state(void) { int usb_sel = 0; if(!connectivity_switching_init_state) return; if (sec_get_param_value) sec_get_param_value(__SWITCH_SEL, &switch_sel); usb_sel = switch_sel & (int)(USB_SEL_MASK); if(!usb_sel) Ap_Cp_Switch_Config(AP_USB_MODE); }
void sec_usb_switch(void) { int switch_sel = USB_PATH_PDA; if (!finish_sec_switch_init) { pr_info("%s : skip for initialing\n", __func__); initial_path_sel = USB_PATH_MASK; return; } if (sec_get_param_value) sec_get_param_value(__SWITCH_SEL, &switch_sel); usb_switch_mode(dev_get_drvdata(switch_dev), switch_sel & USB_PATH_MASK); }
static void sio_switch_init_worker(struct work_struct *ignored) { int switch_sel; if (sec_get_param_value) { sec_get_param_value(__SWITCH_SEL, &switch_sel); cancel_delayed_work(&sio_switch_init_work); } else { schedule_delayed_work(&sio_switch_init_work, msecs_to_jiffies(100)); return; } if (switch_sel & USB_SEL_MASK) usb_path = SWITCH_PDA; else usb_path = SWITCH_MODEM; if (switch_sel & UART_SEL_MASK) uart_current_owner = SWITCH_PDA; else uart_current_owner = SWITCH_MODEM; #ifdef _FMC_DM_ if (switch_sel & USB_LOCK_MASK) { usb_access_lock = 1; android_usb_set_connected(0); } #endif if (uart_current_owner == SWITCH_PDA) { sio_switch_config(AP_UART_MODE); } else if (uart_current_owner == SWITCH_MODEM) { printk("----------------- Cutting off PDA UART ---------------------\n"); sio_switch_config(CP_UART_MODE); } if (usb_path == SWITCH_MODEM) { sio_switch_config(CP_USB_MODE); } microusb_init(); }
static ssize_t enable_store ( struct device *dev, struct device_attribute *attr, const char *buf, size_t size ) { int value; int switch_sel; if (sscanf(buf, "%d", &value) != 1) { printk(KERN_ERR "enable_store: Invalid value\n"); return -EINVAL; } if((value < 0) || (value > 1)) { printk(KERN_ERR "enable_store: Invalid value\n"); return -EINVAL; } if(value != usb_access_lock) { if (sec_get_param_value) { sec_get_param_value(__SWITCH_SEL, &switch_sel); switch_sel &= ~USB_LOCK_MASK; if(value == 1) { switch_sel |= USB_LOCK_MASK; android_usb_set_connected(0); } else { android_usb_set_connected(0); android_usb_set_connected(1); } } usb_access_lock = value; if (sec_set_param_value) { sec_set_param_value(__SWITCH_SEL, &switch_sel); } } return size; }
static void sio_switch_init_worker(struct work_struct *ignored) { int switch_sel; if (sec_get_param_value) { sec_get_param_value(__SWITCH_SEL, &switch_sel); cancel_delayed_work(&sio_switch_init_work); } else { schedule_delayed_work(&sio_switch_init_work, msecs_to_jiffies(100)); return; } if (switch_sel & USB_SEL_MASK) { usb_path = SWITCH_PDA; sio_switch_config(AP_USB_MODE); } else usb_path = SWITCH_MODEM; if (switch_sel & UART_SEL_MASK) uart_current_owner = SWITCH_PDA; else uart_current_owner = SWITCH_MODEM; if (uart_current_owner == SWITCH_PDA) { sio_switch_config(AP_UART_MODE); } else if (uart_current_owner == SWITCH_MODEM) { printk("----------------- Cutting off PDA UART ---------------------\n"); sio_switch_config(CP_UART_MODE); } if (usb_path == SWITCH_MODEM) { sio_switch_config(CP_USB_MODE); } }
void PathSelStore(int sel) { if (sec_get_param_value) sec_get_param_value(__SWITCH_SEL, &switch_sel); if(sel == AP_USB_MODE) { switch_sel |= USB_SEL_MASK; } else if(sel == CP_USB_MODE) { switch_sel &= ~USB_SEL_MASK; } else if(sel == AP_UART_MODE) { switch_sel |= UART_SEL_MASK; } else if(sel == CP_UART_MODE) { switch_sel &= ~UART_SEL_MASK; } if (sec_set_param_value) sec_set_param_value(__SWITCH_SEL, &switch_sel); }
static ssize_t uart_debug_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct sec_switch_struct *secsw = dev_get_drvdata(dev); if (sec_get_param_value) sec_get_param_value(__SWITCH_SEL, &secsw->switch_sel); if (strncmp(buf, "DISABLE", 7) == 0 || strncmp(buf, "disable", 7) == 0) { pr_info("%s : uart debug disable\n", __func__); secsw->switch_sel &= ~UART_DEBUG_MASK; } else if (strncmp(buf, "ENABLE", 6) == 0 || strncmp(buf, "enable", 6) == 0) { pr_info("%s : uart debug enable\n", __func__); secsw->switch_sel |= UART_DEBUG_MASK; } if (sec_set_param_value) sec_set_param_value(__SWITCH_SEL, &secsw->switch_sel); return size; }
void usb_switch_state(void) { int usb_sel = 0; if(!connectivity_switching_init_state) return; if (sec_get_param_value) sec_get_param_value(__SWITCH_SEL, &switch_sel); usb_sel = switch_sel & (int)(USB_SEL_MASK); if(usb_sel) { usb_switch_mode(SWITCH_PDA); usb_switching_value_update(SWITCH_PDA); } else { usb_switch_mode(SWITCH_MODEM); usb_switching_value_update(SWITCH_MODEM); } }
static void sec_switch_init_work(struct work_struct *work) { struct delayed_work *dw = container_of(work, struct delayed_work, work); struct sec_switch_wq *wq = container_of(dw, struct sec_switch_wq, work_q); struct sec_switch_struct *secsw = wq->sdata; int usb_sel = 0; int uart_sel = 0; if (sec_get_param_value && secsw->pdata && secsw->pdata->set_vbus_status && secsw->pdata->get_phy_init_status && secsw->pdata->get_phy_init_status()) { sec_get_param_value(__SWITCH_SEL, &secsw->switch_sel); cancel_delayed_work(&wq->work_q); } else { schedule_delayed_work(&wq->work_q, msecs_to_jiffies(1000)); return; } pr_info("%s : initial sec switch value = 0x%X\n", __func__, secsw->switch_sel); if (!(secsw->switch_sel & UART_DEBUG_MASK) || ((secsw->switch_sel & UART_PATH_MASK) == UART_PATH_MASK)) secsw->switch_sel = (secsw->switch_sel & ~UART_PATH_MASK) | UART_PATH_MODEM; if ((secsw->switch_sel & USB_PATH_MASK) == USB_PATH_MASK) secsw->switch_sel = (secsw->switch_sel & ~USB_PATH_MASK) | USB_PATH_PDA; if (sec_set_param_value) sec_set_param_value(__SWITCH_SEL, &secsw->switch_sel); usb_sel = secsw->switch_sel & USB_PATH_MASK; uart_sel = (secsw->switch_sel & UART_PATH_MASK) >> 2; if (initial_path_sel == USB_PATH_MASK) usb_switch_mode(secsw, usb_sel); else if (initial_path_sel == UART_PATH_MASK) uart_switch_mode(secsw, uart_sel); finish_sec_switch_init = 1; }
static ssize_t usb_sel_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct sec_switch_struct *secsw = dev_get_drvdata(dev); if (sec_get_param_value) sec_get_param_value(__SWITCH_SEL, &secsw->switch_sel); if (strncmp(buf, "PDA", 3) == 0 || strncmp(buf, "pda", 3) == 0) { usb_switch_mode(secsw, SWITCH_PDA); secsw->switch_sel |= USB_SEL_MASK; } if (strncmp(buf, "MODEM", 5) == 0 || strncmp(buf, "modem", 5) == 0) { usb_switch_mode(secsw, SWITCH_MODEM); secsw->switch_sel &= ~USB_SEL_MASK; } if (sec_set_param_value) sec_set_param_value(__SWITCH_SEL, &secsw->switch_sel); return size; }
static void sec_switch_init_work(struct work_struct *work) { struct delayed_work *dw = container_of(work, struct delayed_work, work); struct sec_switch_wq *wq = container_of(dw, struct sec_switch_wq, work_q); struct sec_switch_struct *secsw = wq->sdata; int usb_sel = 0; int uart_sel = 0; if (sec_get_param_value && secsw->pdata && secsw->pdata->set_vbus_status && secsw->pdata->get_phy_init_status && secsw->pdata->get_phy_init_status()) { sec_get_param_value(__SWITCH_SEL, &secsw->switch_sel); cancel_delayed_work(&wq->work_q); } else { schedule_delayed_work(&wq->work_q, msecs_to_jiffies(1000)); return; } pr_debug("%s : initial sec switch value = 0x%X\n", __func__, secsw->switch_sel); usb_sel = secsw->switch_sel & USB_SEL_MASK; uart_sel = secsw->switch_sel & UART_SEL_MASK; /* init UART/USB path */ if (usb_sel) usb_switch_mode(secsw, SWITCH_PDA); else usb_switch_mode(secsw, SWITCH_MODEM); if (uart_sel) gpio_set_value(GPIO_UART_SEL, 1); else gpio_set_value(GPIO_UART_SEL, 0); }
static int __devinit battery_probe( struct platform_device *pdev ) // ---------------------------------------------------------------------------- // Description : probe function for battery driver. // Input Argument : // Return Value : { int ret = 0; int i = 0; int Debug_Usepopup = 1; struct battery_device_info *di; printk( "[BR] Battery Probe...\n\n" ); this_dev = &pdev->dev; di = kzalloc( sizeof(*di), GFP_KERNEL ); if(!di) return -ENOMEM; platform_set_drvdata( pdev, di ); di->dev = &pdev->dev; device_config = pdev->dev.platform_data; INIT_DELAYED_WORK( &di->battery_monitor_work, battery_monitor_work_handler ); // [ USE_REGULATOR di->usb3v1 = regulator_get( &pdev->dev, "usb3v1" ); if( IS_ERR( di->usb3v1 ) ) goto fail_regulator1; di->usb1v8 = regulator_get( &pdev->dev, "usb1v8" ); if( IS_ERR( di->usb1v8 ) ) goto fail_regulator2; di->usb1v5 = regulator_get( &pdev->dev, "usb1v5" ); if( IS_ERR( di->usb1v5 ) ) goto fail_regulator3; // ] /*Create power supplies*/ di->sec_battery.name = "battery"; di->sec_battery.type = POWER_SUPPLY_TYPE_BATTERY; di->sec_battery.properties = samsung_battery_props; di->sec_battery.num_properties = ARRAY_SIZE( samsung_battery_props ); di->sec_battery.get_property = samsung_battery_get_property; di->sec_battery.external_power_changed = samsung_pwr_external_power_changed; //di->sec_battery.use_for_apm = 1; di->sec_ac.name = "ac"; di->sec_ac.type = POWER_SUPPLY_TYPE_MAINS; di->sec_ac.supplied_to = samsung_bci_supplied_to; di->sec_ac.num_supplicants = ARRAY_SIZE( samsung_bci_supplied_to ); di->sec_ac.properties = samsung_ac_props; di->sec_ac.num_properties = ARRAY_SIZE( samsung_ac_props ); di->sec_ac.get_property = samsung_ac_get_property; di->sec_ac.external_power_changed = samsung_pwr_external_power_changed; di->sec_usb.name = "usb"; di->sec_usb.type = POWER_SUPPLY_TYPE_USB; di->sec_usb.supplied_to = samsung_bci_supplied_to; di->sec_usb.num_supplicants = ARRAY_SIZE( samsung_bci_supplied_to ); di->sec_usb.properties = samsung_usb_props; di->sec_usb.num_properties = ARRAY_SIZE( samsung_usb_props ); di->sec_usb.get_property = samsung_usb_get_property; di->sec_usb.external_power_changed = samsung_pwr_external_power_changed; ret = power_supply_register( &pdev->dev, &di->sec_battery ); if( ret ) { printk( "failed to register main battery, charger\n" ); goto batt_regi_fail1; } ret = power_supply_register( &pdev->dev, &di->sec_ac ); if( ret ) { printk( "failed to register ac\n" ); goto batt_regi_fail2; } ret = power_supply_register( &pdev->dev, &di->sec_usb ); if( ret ) { printk( "failed to register usb\n" ); goto batt_regi_fail3; } ret = sysfs_create_file( &di->sec_battery.dev->kobj, &batt_vol_toolow.attr ); if ( ret ) { printk( "sysfs create fail - %s\n", batt_vol_toolow.attr.name ); } ret = sysfs_create_file( &di->sec_battery.dev->kobj, &charging_source.attr ); if ( ret ) { printk( "sysfs create fail - %s\n", charging_source.attr.name ); } for( i = 0; i < ARRAY_SIZE( batt_sysfs_testmode ); i++ ) { ret = sysfs_create_file( &di->sec_battery.dev->kobj, &batt_sysfs_testmode[i].attr ); if ( ret ) { printk( "sysfs create fail - %s\n", batt_sysfs_testmode[i].attr.name ); } } // Init. ADC turn_resources_on_for_adc(); twl_i2c_write_u8( TWL4030_MODULE_USB, SEL_MADC_MCPC, CARKIT_ANA_CTRL ); turn_resources_off_for_adc(); batt_gptimer_12.name = "samsung_battery_timer"; batt_gptimer_12.expire_time =(unsigned int) MONITOR_DURATION_DUR_SLEEP; batt_gptimer_12.expire_callback = &battery_monitor_fleeting_wakeup_handler; batt_gptimer_12.data = (unsigned long) di; #if defined(CONFIG_SAMSUNG_ARCHER_TARGET_SK) if ( sec_get_param_value ) { sec_get_param_value(__DEBUG_BLOCKPOPUP, &Debug_Usepopup); } #endif if ( (Debug_Usepopup & 0x1) == 1 ) { sec_bci.battery.support_monitor_temp = 1; sec_bci.battery.support_monitor_timeout = 1; sec_bci.battery.support_monitor_full = 1; } else if ( (Debug_Usepopup & 0x1) == 0 ) { sec_bci.battery.support_monitor_temp = 0; sec_bci.battery.support_monitor_timeout = 0; sec_bci.battery.support_monitor_full = 0; } //schedule_delayed_work( &di->battery_monitor_work, 3*HZ ); queue_delayed_work( sec_bci.sec_battery_workq, &di->battery_monitor_work, 3*HZ ); // ready to go!! sec_bci.ready = true; return 0; batt_regi_fail3: power_supply_unregister( &di->sec_ac ); batt_regi_fail2: power_supply_unregister( &di->sec_battery ); batt_regi_fail1: // [ USE_REGULATOR regulator_put( di->usb1v5 ); di->usb1v5 = NULL; fail_regulator3: regulator_put( di->usb1v8 ); di->usb1v8 = NULL; fail_regulator2: regulator_put( di->usb3v1 ); di->usb3v1 = NULL; fail_regulator1: // ] kfree(di); return ret; }
static void connectivity_switching_init(struct work_struct *ignored) { int usb_sel, uart_sel, samsung_kies_sel, ums_sel, mtp_sel, vtp_sel, askon_sel; int lpm_mode_check = charging_mode_get(); switch_sel = 0; dmsg("\n"); if (sec_get_param_value) { sec_get_param_value(__SWITCH_SEL, &switch_sel); cancel_delayed_work(&switch_init_work); } else { schedule_delayed_work(&switch_init_work, msecs_to_jiffies(100)); return; } if(BOOTUP) { BOOTUP = 0; otg_phy_init(); //USB Power on after boot up. } usb_sel = switch_sel & (int)(USB_SEL_MASK); uart_sel = (switch_sel & (int)(UART_SEL_MASK)) >> 1; samsung_kies_sel = (switch_sel & (int)(USB_SAMSUNG_KIES_MASK)) >> 2; ums_sel = (switch_sel & (int)(USB_UMS_MASK)) >> 3; mtp_sel = (switch_sel & (int)(USB_MTP_MASK)) >> 4; #if !defined(CONFIG_TARGET_LOCALE_NTT) // disable tethering xmoondash vtp_sel = (switch_sel & (int)(USB_VTP_MASK)) >> 5; #endif askon_sel = (switch_sel & (int)(USB_ASKON_MASK)) >> 6; printk("\n[WJ] %s, %s, switch_sel=%d\n", __FILE__, __FUNCTION__, switch_sel); if( samsung_kies_sel ) currentusbstatus = USBSTATUS_SAMSUNG_KIES; else if(ums_sel) currentusbstatus = USBSTATUS_UMS; else if(mtp_sel) currentusbstatus = USBSTATUS_MTPONLY; else if(askon_sel) currentusbstatus = USBSTATUS_ASKON; if((switch_sel == 0x1) || (factoryresetstatus == 0xAE)) { PathSelStore(AP_USB_MODE); Ap_Cp_Switch_Config(AP_USB_MODE); usb_switching_value_update(SWITCH_PDA); PathSelStore(CP_UART_MODE); Ap_Cp_Switch_Config(CP_UART_MODE); uart_switching_value_update(SWITCH_MODEM); } else { if(usb_sel) { Ap_Cp_Switch_Config(AP_USB_MODE); usb_switching_value_update(SWITCH_PDA); } else { if(MicroJigUARTOffStatus) { Ap_Cp_Switch_Config(AP_USB_MODE); } else { Ap_Cp_Switch_Config(CP_USB_MODE); usb_switching_value_update(SWITCH_MODEM); } } if(uart_sel) { Ap_Cp_Switch_Config(AP_UART_MODE); uart_switching_value_update(SWITCH_PDA); } else { Ap_Cp_Switch_Config(CP_UART_MODE); uart_switching_value_update(SWITCH_MODEM); } } /*Turn off usb power when LPM mode*/ if(lpm_mode_check) otg_phy_off(); switching_value_update(); if((switch_sel == 1) || (factoryresetstatus == 0xAE)) { usb_switch_select(USBSTATUS_SAMSUNG_KIES); mtp_mode_on = 1; ap_usb_power_on(0); UsbMenuSelStore(0); } else { if(usb_sel) { if(samsung_kies_sel) { usb_switch_select(USBSTATUS_SAMSUNG_KIES); /*USB Power off till MTP Appl launching*/ #ifdef _SUPPORT_SAMSUNG_AUTOINSTALLER_ //mtp_mode_on = 1; //ap_usb_power_on(0); #else mtp_mode_on = 1; ap_usb_power_on(0); #endif } else if(mtp_sel) { usb_switch_select(USBSTATUS_MTPONLY); /*USB Power off till MTP Appl launching*/ mtp_mode_on = 1; ap_usb_power_on(0); } else if(ums_sel) { usb_switch_select(USBSTATUS_UMS); } #if !defined(CONFIG_TARGET_LOCALE_NTT) // disable tethering xmoondash else if(vtp_sel) { usb_switch_select(USBSTATUS_VTP); } #endif else if(askon_sel) { usb_switch_select(USBSTATUS_ASKON); } } } if(!FSA9480_Get_USB_Status()) { s3c_usb_cable(1); mdelay(5); s3c_usb_cable(0); } else { s3c_usb_cable(1); indicator_dev.state = 1; } dmsg("switch_sel : 0x%x\n", switch_sel); microusb_uart_status(1); connectivity_switching_init_state=1; }
static int UsbMenuSelStore(int sel) { int switch_sel, ret; if (sec_get_param_value) sec_get_param_value(__SWITCH_SEL, &switch_sel); if(sel == 0){ switch_sel &= ~(int)USB_UMS_MASK; switch_sel &= ~(int)USB_MTP_MASK; #if !defined(CONFIG_TARGET_LOCALE_NTT) // disable tethering xmoondash switch_sel &= ~(int)USB_VTP_MASK; #endif switch_sel &= ~(int)USB_ASKON_MASK; #ifdef _SUPPORT_SAMSUNG_AUTOINSTALLER_ switch_sel &= ~(int)USB_SAMSUNG_KIES_REAL_MASK; #endif switch_sel |= (int)USB_SAMSUNG_KIES_MASK; } else if(sel == 1){ switch_sel &= ~(int)USB_UMS_MASK; switch_sel &= ~(int)USB_SAMSUNG_KIES_MASK; #if !defined(CONFIG_TARGET_LOCALE_NTT) // disable tethering xmoondash switch_sel &= ~(int)USB_VTP_MASK; #endif switch_sel &= ~(int)USB_ASKON_MASK; #ifdef _SUPPORT_SAMSUNG_AUTOINSTALLER_ switch_sel &= ~(int)USB_SAMSUNG_KIES_REAL_MASK; #endif switch_sel |= (int)USB_MTP_MASK; } else if(sel == 2){ switch_sel &= ~(int)USB_SAMSUNG_KIES_MASK; switch_sel &= ~(int)USB_MTP_MASK; #if !defined(CONFIG_TARGET_LOCALE_NTT) // disable tethering xmoondash switch_sel &= ~(int)USB_VTP_MASK; #endif switch_sel &= ~(int)USB_ASKON_MASK; #ifdef _SUPPORT_SAMSUNG_AUTOINSTALLER_ switch_sel &= ~(int)USB_SAMSUNG_KIES_REAL_MASK; #endif switch_sel |= (int)USB_UMS_MASK; } else if(sel == 3){ switch_sel &= ~(int)USB_UMS_MASK; switch_sel &= ~(int)USB_MTP_MASK; switch_sel &= ~(int)USB_SAMSUNG_KIES_MASK; switch_sel &= ~(int)USB_ASKON_MASK; #ifdef _SUPPORT_SAMSUNG_AUTOINSTALLER_ switch_sel &= ~(int)USB_SAMSUNG_KIES_REAL_MASK; #endif #if !defined(CONFIG_TARGET_LOCALE_NTT) // disable tethering xmoondash switch_sel |= (int)USB_VTP_MASK; #endif } else if(sel == 4){ switch_sel &= ~(int)USB_UMS_MASK; switch_sel &= ~(int)USB_MTP_MASK; #if !defined(CONFIG_TARGET_LOCALE_NTT) // disable tethering xmoondash switch_sel &= ~(int)USB_VTP_MASK; #endif switch_sel &= ~(int)USB_SAMSUNG_KIES_MASK; #ifdef _SUPPORT_SAMSUNG_AUTOINSTALLER_ switch_sel &= ~(int)USB_SAMSUNG_KIES_REAL_MASK; #endif switch_sel |= (int)USB_ASKON_MASK; } #ifdef _SUPPORT_SAMSUNG_AUTOINSTALLER_ // KIES_REAL else if(sel == 5){ switch_sel &= ~(int)USB_UMS_MASK; switch_sel &= ~(int)USB_MTP_MASK; #if !defined(CONFIG_TARGET_LOCALE_NTT) // disable tethering xmoondash switch_sel &= ~(int)USB_VTP_MASK; #endif switch_sel &= ~(int)USB_ASKON_MASK; switch_sel &= ~(int)USB_SAMSUNG_KIES_MASK; switch_sel |= (int)USB_SAMSUNG_KIES_REAL_MASK; } #endif if (sec_set_param_value) sec_set_param_value(__SWITCH_SEL, &switch_sel); printk("\n[WJ] %s, %s, switch_sel=%d\n", __FILE__, __FUNCTION__, switch_sel); // returns current USB Mode setting... ret = switch_sel; ret &= ~(UART_SEL_MASK|USB_SEL_MASK); dmsg("ret = 0x%x\n", ret); return ret; }
static void sec_switch_init_work(struct work_struct *work) { struct delayed_work *dw = container_of(work, struct delayed_work, work); struct sec_switch_wq *wq = container_of(dw, struct sec_switch_wq, work_q); struct sec_switch_struct *secsw = wq->sdata; int usb_sel = 0; int uart_sel = 0; #if 0 if (sec_get_param_value && secsw->pdata && secsw->pdata->set_vbus_status && secsw->pdata->get_phy_init_status && secsw->pdata->get_phy_init_status() && check_for_cp_boot()) { sec_get_param_value(__SWITCH_SEL, &secsw->switch_sel); #endif if (secsw->pdata && secsw->pdata->set_vbus_status && secsw->pdata->get_phy_init_status && secsw->pdata->get_phy_init_status()) { #ifdef CONFIG_SEC_MISC if ( (!sec_get_param(param_index_uartsel, &secsw->switch_sel)) && (gRetryCount++ < 9) ) { pr_err("%s error value = %d \n", __func__, secsw->switch_sel); schedule_delayed_work(&wq->work_q, msecs_to_jiffies(1000)); return; } //To prevent lock up during getting parameter about switch_sel. if(gRetryCount > 9) { secsw->switch_sel = 1; // default modem pr_err("%s failed 10 times... So switch_sel is set by [1]\n", __func__); } gRetryCount = 0; #endif pr_err("%s value = %d \n", __func__, secsw->switch_sel); cancel_delayed_work(&wq->work_q); } else { schedule_delayed_work(&wq->work_q, msecs_to_jiffies(1000)); return; } usb_sel = secsw->switch_sel & USB_SEL_MASK; uart_sel = secsw->switch_sel & UART_SEL_MASK; // USB switch not use LTE if (usb_sel) usb_switch_mode(secsw, SWITCH_PDA); else usb_switch_mode(secsw, SWITCH_MODEM); // UART switch mode if (uart_sel) uart_switch_mode(secsw, SWITCH_PDA); else uart_switch_mode(secsw, SWITCH_MODEM); } static int sec_switch_probe(struct platform_device *pdev) { struct sec_switch_struct *secsw; struct sec_switch_platform_data *pdata = pdev->dev.platform_data; struct sec_switch_wq *wq; pr_err("sec_switch_probe enter %s\n", __func__); if (!pdata) { pr_err("%s : pdata is NULL.\n", __func__); return -ENODEV; } secsw = kzalloc(sizeof(struct sec_switch_struct), GFP_KERNEL); if (!secsw) { pr_err("%s : failed to allocate memory\n", __func__); return -ENOMEM; } secsw->pdata = pdata; #if defined (CONFIG_TARGET_LOCALE_US_ATT_REV01) || defined(CONFIG_KOR_MODEL_SHV_E160S)|| defined (CONFIG_KOR_MODEL_SHV_E160K) || defined (CONFIG_KOR_MODEL_SHV_E160L) || defined (CONFIG_JPN_MODEL_SC_05D) secsw->switch_sel = 3; #else secsw->switch_sel = 1; #endif dev_set_drvdata(switch_dev, secsw); /* create sysfs files */ if (device_create_file(switch_dev, &dev_attr_uart_sel) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_uart_sel.attr.name); if (device_create_file(switch_dev, &dev_attr_usb_sel) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_usb_sel.attr.name); if (device_create_file(switch_dev, &dev_attr_usb_state) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_usb_state.attr.name); if (device_create_file(switch_dev, &dev_attr_disable_vbus) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_usb_state.attr.name); if (device_create_file(switch_dev, &dev_attr_device_type) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_device_type.attr.name); #ifdef _SEC_DM_ usb_lock = device_create(sec_class, switch_dev, MKDEV(0, 0), NULL, ".usb_lock"); if (IS_ERR(usb_lock)) { pr_err("Failed to create device (usb_lock)!\n"); return PTR_ERR(usb_lock); } dev_set_drvdata(usb_lock, secsw); if (device_create_file(usb_lock, &dev_attr_enable) < 0) { pr_err("Failed to create device file(%s)!\n", dev_attr_enable.attr.name); device_destroy((struct class *)usb_lock, MKDEV(0, 0)); } #endif /* run work queue */ wq = kmalloc(sizeof(struct sec_switch_wq), GFP_ATOMIC); if (wq) { wq->sdata = secsw; INIT_DELAYED_WORK(&wq->work_q, sec_switch_init_work); schedule_delayed_work(&wq->work_q, msecs_to_jiffies(100)); } else return -ENOMEM; return 0; }