static ssize_t rory_control_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
int rory_control;
sec_get_param(param_rory_control, &rory_control);
return snprintf(buf, PAGE_SIZE, "%d\n", rory_control);
}
static ssize_t slideCount_show
(struct device *dev, struct device_attribute *attr, char *buf)
{
int slideCount;
sec_get_param(param_slideCount, &slideCount);
return snprintf(buf, PAGE_SIZE, "%d\n", slideCount);
}
static ssize_t update_cp_bin_show
(struct device *dev, struct device_attribute *attr, char *buf)
{
int update = 0;
sec_get_param(param_update_cp_bin, (void *)&update);
return snprintf(buf, sizeof(buf), "%d\n", update);
}
static ssize_t power_off_reason_show
(struct device *dev, struct device_attribute *attr, char *buf)
{
int power_off_reason;
sec_get_param(param_power_off_reason, &power_off_reason);
return sprintf(buf, "0x%X\n", power_off_reason);
}
static ssize_t sales_code_show
(struct device *dev, struct device_attribute *attr, char *buf)
{
int sales_code;
sec_get_param(param_sales_code, &sales_code);
return sprintf(buf, "%d\n", sales_code);
}
static ssize_t movinand_checksum_pass_show
(struct device *dev, struct device_attribute *attr, char *buf)
{
int ret = 0;
sec_get_param(param_index_movinand_checksum_pass, &ret);
if (ret == 1 || ret == 0) {
pr_err("checksum is not in valuable range.\n");
ret = 1;
}
return snprintf(buf, sizeof(buf), "%u\n", ret);
}
int kernel_sec_get_debug_level(void)
{
sec_get_param(param_index_debuglevel, &sec_dbg_level);
if (!(sec_dbg_level == KERNEL_SEC_DEBUG_LEVEL_LOW
|| sec_dbg_level == KERNEL_SEC_DEBUG_LEVEL_MID
|| sec_dbg_level == KERNEL_SEC_DEBUG_LEVEL_HIGH)) {
/*In case of invalid debug level, default (debug level low)*/
pr_notice(KERN_NOTICE "(%s) The debug value is"\
"invalid(0x%x)!! Set default level(LOW)\n",
__func__, sec_dbg_level);
sec_dbg_level = KERNEL_SEC_DEBUG_LEVEL_LOW;
sec_set_param(param_index_debuglevel, &sec_dbg_level);
}
return sec_dbg_level;
}
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);
sec_get_param(param_index_uartsel, &secsw->switch_sel);
if (strncmp(buf, "PDA", 3) == 0 || strncmp(buf, "pda", 3) == 0) {
uart_switch_mode(secsw, SWITCH_APQ8K);
secsw->switch_sel |= UART_SEL_MASK;
pr_debug("[UART Switch] Path : PDA\n");
}
if (strncmp(buf, "MODEM", 5) == 0 || strncmp(buf, "modem", 5) == 0) {
uart_switch_mode(secsw, SWITCH_MDM9K);
secsw->switch_sel &= ~UART_SEL_MASK;
pr_debug("[UART Switch] Path : MODEM\n");
}
sec_set_param(param_index_uartsel, &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 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;
}
