int sisi_get_host_wlan_irq(void) { #ifdef CONFIG_FIH_MACH_TAMSUI_GUA return GUA_WL_HOST_WAKE; #elif defined(CONFIG_FIH_MACH_TAMSUI_TAP) if(fih_get_product_phase() < Phase_AP) return TAP_WL_HOST_WAKE; else return TAP_WL_HOST_WAKE_FIX; //MTD-COMM-CD-OOB_FOR_MES-00+[ #elif defined(CONFIG_FIH_MACH_TAMSUI_MES) if(fih_get_product_phase() < Phase_SP) return MES_WL_HOST_WAKE; else return MES_WL_HOST_WAKE_FIX; //MTD-COMM-CD-OOB_FOR_MES-00+] #elif defined(CONFIG_FIH_MACH_TAMSUI_JLO) if(fih_get_product_phase() < Phase_SP2) return JLO_WL_HOST_WAKE; else return JLO_WL_HOST_WAKE_FIX; #else return -1; #endif }
int32_t pm8xxx_adc_scale_batt_therm(int32_t adc_code, const struct pm8xxx_adc_properties *adc_properties, const struct pm8xxx_adc_chan_properties *chan_properties, struct pm8xxx_adc_chan_result *adc_chan_result) { int64_t bat_voltage = 0; struct pm8xxx_adc_map_pt *adc_map = NULL; uint32_t adc_map_array_size; unsigned int phaseid = 0; bat_voltage = pm8xxx_adc_scale_ratiometric_calib(adc_code, adc_properties, chan_properties); ext_bat_voltage = bat_voltage; if (phaseid == 0) phaseid = fih_get_product_phase(); if (phaseid <= PHASE_SP) { adc_map = adcmap_btm_threshold; adc_map_array_size = ARRAY_SIZE(adcmap_btm_threshold); } else { adc_map = adcmap_btm_threshold_pre_ap; adc_map_array_size = ARRAY_SIZE(adcmap_btm_threshold_pre_ap); } return pm8xxx_adc_map_batt_therm( adc_map, adc_map_array_size, bat_voltage, &adc_chan_result->physical); }
static int phase_id_read_proc(char *page, char **start, off_t off, int count, int *eof, void *data) { int len; int pp = fih_get_product_phase(); char ver[25]= {0}; switch (pp) { case PHASE_EVM2: strncpy(ver, "EVM2", 4); ver[4]='\0'; break; case PHASE_EVM: strncpy(ver, "EVM", 3); ver[3]='\0'; break; case PHASE_PD: strncpy(ver, "PD", 2); ver[2]='\0'; break; case PHASE_DP: strncpy(ver, "DP", 2); ver[2]='\0'; break; case PHASE_SP: strncpy(ver, "SP", 2); ver[3]='\0'; break; case PHASE_PreAP: strncpy(ver, "PreAP", 5); ver[5]='\0'; break; case PHASE_AP: strncpy(ver, "AP", 2); ver[2]='\0'; break; case PHASE_TP: strncpy(ver, "TP", 2); ver[2]='\0'; break; case PHASE_PQ : strncpy(ver, "PQ", 2); ver[2]='\0'; break; case PHASE_TP2_MP: strncpy(ver, "TP2_MP", 6); ver[6]='\0'; break; default: strncpy(ver, "Unkonwn Baseband version",24); ver[24]='\0'; break; } len = snprintf(page, count, "%s\n", ver); /* MTD-BSP-VT-PROC-00* */ return proc_calc_metrics(page, start, off, count, eof, len); }
int32_t pm8xxx_adc_batt_scaler(struct pm8xxx_adc_arb_btm_param *btm_param, const struct pm8xxx_adc_properties *adc_properties, const struct pm8xxx_adc_chan_properties *chan_properties) { int rc; struct pm8xxx_adc_map_pt *adc_map = NULL; uint32_t adc_map_array_size; static unsigned int phaseid = 0; /* * this function is called by pm8xxx_adc_btm_configure which to configure * PMIC temperature IRQ and callback function, which alien battery * doesn't need to, so here don't take alien battery into consideration */ if (phaseid == 0) phaseid = fih_get_product_phase(); if (phaseid <= PHASE_SP) { adc_map = adcmap_btm_threshold; adc_map_array_size = ARRAY_SIZE(adcmap_btm_threshold); } else { adc_map = adcmap_btm_threshold_pre_ap; adc_map_array_size = ARRAY_SIZE(adcmap_btm_threshold_pre_ap); } rc = pm8xxx_adc_map_linear( adc_map, adc_map_array_size, (btm_param->low_thr_temp), &btm_param->low_thr_voltage); if (rc) return rc; btm_param->low_thr_voltage *= chan_properties->adc_graph[ADC_CALIB_RATIOMETRIC].dy; do_div(btm_param->low_thr_voltage, adc_properties->adc_vdd_reference); btm_param->low_thr_voltage += chan_properties->adc_graph[ADC_CALIB_RATIOMETRIC].adc_gnd; rc = pm8xxx_adc_map_linear( adc_map, adc_map_array_size, (btm_param->high_thr_temp), &btm_param->high_thr_voltage); if (rc) return rc; btm_param->high_thr_voltage *= chan_properties->adc_graph[ADC_CALIB_RATIOMETRIC].dy; do_div(btm_param->high_thr_voltage, adc_properties->adc_vdd_reference); btm_param->high_thr_voltage += chan_properties->adc_graph[ADC_CALIB_RATIOMETRIC].adc_gnd; return rc; }
/* FIH-SW3-KERNEL-EL-fix_coverity-issues-02*[ */ static ssize_t fih_hw_id_version_number_show(struct kobject *kobj, struct kobj_attribute *attr, char * buf) { char *s = buf; unsigned int hw_id; hw_id = fih_get_product_phase(); s += snprintf(s, PAGE_SIZE - ((size_t)(s-buf)), "%d", hw_id); s += snprintf(s, PAGE_SIZE - ((size_t)(s-buf)), "\n"); return (s - buf); }
static int support_sensor_read(char *page, char **start, off_t off, int count, int *eof, void *data) { int len; int project_id = fih_get_product_id(); int phase_id = fih_get_product_phase(); //Div2D5-OwenHuang-FB0_Sensor_Proc_Read-01+ int project_sensor = 0; switch (project_id){ case Product_FB0: project_sensor = DEFAULT_SUPPORT_SENSOR; break; case Product_FD1: project_sensor = DEFAULT_SUPPORT_SENSOR; break; case Product_SF3: project_sensor = DEFAULT_SUPPORT_SENSOR; break; case Product_SF5: //Div2D5-OwenHuang-FB0_Sensor_Proc_Read-01+{ if (phase_id == Product_PR1) project_sensor = BIT_ECOMPASS | BIT_GSENSOR | BIT_LIGHT; //not support proximity sensor at PR1 stage else project_sensor = DEFAULT_SUPPORT_SENSOR; //Div2D5-OwenHuang-FB0_Sensor_Proc_Read-01+} break; case Product_SF6: project_sensor = DEFAULT_SUPPORT_SENSOR; //DIV5-BSP-CH-SF6-SENSOR-PORTING04++ break; case Product_SF8: project_sensor = DEFAULT_SUPPORT_SENSOR; break; default: project_sensor = DEFAULT_SUPPORT_SENSOR; break; } len = snprintf(page, PAGE_SIZE, "%d\n", project_sensor); return proc_calc_metrics(page, start, off, count, eof, len); }
static int __init trout_h2w_init(void) { /* FIH-SW2-MM-AY-hsed_type-03 [ */ int product_id = fih_get_product_id(); int product_phase = fih_get_product_phase(); /* FIH-SW2-MM-AY-hsed_type-03 ] */ H2W_DBG("trout_h2w_init:set interrupt trigger level\n "); /* FIH-SW2-MM-AY-hsed_type-03 [ */ if (((product_id == Project_TAP) && ((product_phase == Phase_AP2) || (product_phase == Phase_MP))) || ((product_id == Project_MES) && (product_phase >= Phase_PreAP)) || ((product_id == Project_JLO) && (product_phase >= Phase_SP3))) isCTIAheadset = true; else isCTIAheadset = false; /* FIH-SW2-MM-AY-hsed_type-03 ] */ return platform_driver_register(&trout_h2w_driver); }
int32_t pm8xxx_adc_scale_batt_therm(int32_t adc_code, const struct pm8xxx_adc_properties *adc_properties, const struct pm8xxx_adc_chan_properties *chan_properties, struct pm8xxx_adc_chan_result *adc_chan_result) { int64_t bat_voltage = 0; struct pm8xxx_adc_map_pt *adc_map = NULL; uint32_t adc_map_array_size; unsigned int phaseid = 0; bat_voltage = pm8xxx_adc_scale_ratiometric_calib(adc_code, adc_properties, chan_properties); ext_bat_voltage = bat_voltage; if (ext_bat_voltage > 1700) { pr_err("[chg %s %d]ERROR!! Battery removed %lld", __func__, __LINE__, ext_bat_voltage); machine_power_off(); } if (phaseid == 0) phaseid = fih_get_product_phase(); if (phaseid <= PHASE_SP) { adc_map = adcmap_btm_threshold; adc_map_array_size = ARRAY_SIZE(adcmap_btm_threshold); } else { adc_map = adcmap_btm_threshold_pre_ap; adc_map_array_size = ARRAY_SIZE(adcmap_btm_threshold_pre_ap); } return pm8xxx_adc_map_batt_therm( adc_map, adc_map_array_size, bat_voltage, &adc_chan_result->physical); }
static ssize_t fih_hw_id_version_name_show(struct kobject *kobj, struct kobj_attribute *attr, char * buf) { char *s = buf; unsigned int hw_id; unsigned int i; /* KERNEL-HC-Fix_Coverity-00* */ hw_id = fih_get_product_phase(); /* FIH-SW3-KERNEL-EL-fix_coverity-issues-00*[ */ for( i = 0 ; i < sizeof(hw_id_map_table)/sizeof(hw_id_number_name_map); i++) { if(hw_id_map_table[i].hw_id_number == hw_id) { /* FIH-SW3-KERNEL-EL-fix_coverity-issues-02*[ */ s += snprintf(s, PAGE_SIZE - ((size_t)(s-buf)), "%s", hw_id_map_table[i].hw_id_name); s += snprintf(s, PAGE_SIZE - ((size_t)(s-buf)), "\r\n"); /* FIH-SW3-KERNEL-EL-fix_coverity-issues-02*] */ break; } } /* FIH-SW3-KERNEL-EL-fix_coverity-issues-00*] */ return (s - buf); }
static int baseband_read_proc(char *page, char **start, off_t off, int count, int *eof, void *data) { int len; int pp = fih_get_product_phase(); char ver[24]; switch (pp){ case Product_PR1: strcpy(ver, "PR1"); break; case Product_PR2: strcpy(ver, "PR2"); break; case Product_PR2p5: strcpy(ver, "PR2p5"); break; case Product_PR230: strcpy(ver, "PR230"); break; case Product_PR231: if (fih_get_product_id() == Product_FD1) //Div2-SW2-BSP, JOE HSU,FD1 PR235 = FB0 PR231 strcpy(ver, "PR235"); else strcpy(ver, "PR231"); break; case Product_PR232: strcpy(ver, "PR232"); break; case Product_PR3: strcpy(ver, "PR3"); break; //Div252-AC-HARDWARE_ID_01+{ case Product_PR1p5: strcpy(ver, "PR15"); break; //Div252-AC-HARDWARE_ID_01+} case Product_PR4: strcpy(ver, "PR4"); break; case Product_PR5: strcpy(ver, "PR5"); break; case Product_PCR: strcpy(ver, "PCR"); break; case Product_MP1: strcpy(ver, "MP1"); break; case Product_EVB: strcpy(ver, "EVB"); break; default: strcpy(ver, "Unkonwn Baseband version"); break; } len = snprintf(page, PAGE_SIZE, "%s\n", ver); return proc_calc_metrics(page, start, off, count, eof, len); }
/* FIH-SW-MM-VH-DISPLAY-JB00*[ */ static int msm_fb_dsi_client_msm_reset(int hold) { int rc = 0; static int dsi_reset_initialized = 0; printk(KERN_INFO "[DISPLAY]%s: E, hold <%d>\n", __func__, hold); if (dsi_reset_initialized == 0) { rc = gpio_request(GPIO_LCM_RESET, "gpio_disp_pwr"); if (rc < 0) { pr_err("[DISPLAY] %s: Failed to request lcm_reset, rc <%d>\n", __func__, rc); //return rc; } rc = gpio_tlmm_config(GPIO_CFG(GPIO_LCM_RESET, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE); if (unlikely(fih_get_product_phase() < Phase_SP2)) { printk(KERN_ALERT "[DISPLAY]%s: <%d> < SP2\n", __func__, fih_get_product_phase()); rc = gpio_request(GPIO_LCM_BKL_EN, "lcm_bkl_en"); if (rc < 0) { pr_err("[DISPLAY] %s: Failed to request lcm_bkl_en\n", __func__); //goto gpio_error; } rc = gpio_tlmm_config(GPIO_CFG(GPIO_LCM_BKL_EN, 0, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), GPIO_CFG_ENABLE); if (rc < 0) { pr_err("[DISPLAY] %s: Failed lcm_bkl_en enable\n", __func__); //goto gpio_error2; } } dsi_reset_initialized = 1; } if (hold) { gpio_direction_output(GPIO_LCM_RESET, 0); } else { #ifdef CONFIG_FIH_HR_MSLEEP rc |= gpio_direction_output(GPIO_LCM_RESET, 1); hr_msleep(5); rc |= gpio_direction_output(GPIO_LCM_RESET, 0); hr_msleep(5); rc |= gpio_direction_output(GPIO_LCM_RESET, 1); #else rc |= gpio_direction_output(GPIO_LCM_RESET, 1); msleep(5); rc |= gpio_direction_output(GPIO_LCM_RESET, 0); msleep(5); rc |= gpio_direction_output(GPIO_LCM_RESET, 1); #endif } #ifdef CONFIG_FIH_HR_MSLEEP hr_msleep(150); #else msleep(150); #endif #if 0 if (!rc) { if (machine_is_msm7x27a_surf() || machine_is_msm7625a_surf() || machine_is_msm8625_surf()) { lcdc_reset_ptr = ioremap_nocache(LCDC_RESET_PHYS, sizeof(uint32_t)); printk(KERN_ERR "[DISPLAY]%s: surf\n", __func__); if (!lcdc_reset_ptr) return 0; } printk(KERN_ERR "[DISPLAY]%s: X, rc <%d>\n", __func__, rc); return rc; } else { //goto gpio_error; } #endif #if 0 gpio_error2: pr_err("Failed GPIO bridge pd\n"); gpio_free(GPIO_LCDC_BRDG_PD); gpio_error: pr_err("Failed GPIO bridge reset\n"); gpio_free(GPIO_LCDC_BRDG_RESET_N); #endif printk(KERN_INFO "[DISPLAY]%s: X, rc <%d>\n", __func__, rc); return rc; }
static int fbx_kybd_suspend(struct platform_device *pdev, pm_message_t state) { struct pm8058_gpio button_configuration = { .direction = PM_GPIO_DIR_OUT, .pull = PM_GPIO_PULL_DN, .vin_sel = 2, .out_strength = PM_GPIO_STRENGTH_NO, .function = PM_GPIO_FUNC_NORMAL, .inv_int_pol = 0, }; int rc = 0; printk(KERN_INFO "%s\n", __func__); rc = pm8058_gpio_config(rd->pmic_gpio_vol_up, &button_configuration); if (rc < 0) { dev_err(rd->fbx_kybd_pdev, "%s: gpio %d configured failed\n", __func__, rd->pmic_gpio_vol_up); return rc; } else { rc = gpio_direction_output(rd->sys_gpio_vol_up, 0); if (rc < 0) { dev_err(rd->fbx_kybd_pdev, "%s: set gpio %d direction failed\n", __func__, rd->sys_gpio_vol_up); return rc; } } rc = pm8058_gpio_config(rd->pmic_gpio_vol_dn, &button_configuration); if (rc < 0) { dev_err(rd->fbx_kybd_pdev, "%s: gpio %d configured failed\n", __func__, rd->pmic_gpio_vol_dn); return rc; } else { rc = gpio_direction_output(rd->sys_gpio_vol_dn, 0); if (rc < 0) { dev_err(rd->fbx_kybd_pdev, "%s: set gpio %d direction failed\n", __func__, rd->sys_gpio_vol_dn); return rc; } } if (rd->product_phase == Product_PR1 || rd->product_phase == Product_EVB) { rc = pm8058_gpio_config(rd->pmic_gpio_cam_t, &button_configuration); if (rc < 0) { dev_err(rd->fbx_kybd_pdev, "%s: gpio %d configured failed\n", __func__, rd->pmic_gpio_cam_t); return rc; } else { rc = gpio_direction_output(rd->sys_gpio_cam_t, 0); if (rc < 0) { dev_err(rd->fbx_kybd_pdev, "%s: set gpio %d direction failed\n", __func__, rd->sys_gpio_cam_t); return rc; } } rc = pm8058_gpio_config(rd->pmic_gpio_cam_f, &button_configuration); if (rc < 0) { dev_err(rd->fbx_kybd_pdev, "%s: gpio %d configured failed\n", __func__, rd->pmic_gpio_cam_f); return rc; } else { rc = gpio_direction_output(rd->sys_gpio_cam_f, 0); if (rc < 0) { dev_err(rd->fbx_kybd_pdev, "%s: set gpio %d direction failed\n", __func__, rd->sys_gpio_cam_f); return rc; } } } return 0; } static int fbx_kybd_resume(struct platform_device *pdev) { struct pm8058_gpio button_configuration = { .direction = PM_GPIO_DIR_IN, .pull = PM_GPIO_PULL_DN, .vin_sel = 2, .out_strength = PM_GPIO_STRENGTH_NO, .function = PM_GPIO_FUNC_NORMAL, .inv_int_pol = 0, }; int rc = 0; printk(KERN_INFO "%s\n", __func__); rc = pm8058_gpio_config(rd->pmic_gpio_vol_up, &button_configuration); if (rc < 0) { dev_err(rd->fbx_kybd_pdev, "%s: gpio %d configured failed\n", __func__, rd->pmic_gpio_vol_up); return rc; } else { rc = gpio_direction_input(rd->sys_gpio_vol_up); if (rc < 0) { dev_err(rd->fbx_kybd_pdev, "%s: set gpio %d direction failed\n", __func__, rd->sys_gpio_vol_up); return rc; } } rc = pm8058_gpio_config(rd->pmic_gpio_vol_dn, &button_configuration); if (rc < 0) { dev_err(rd->fbx_kybd_pdev, "%s: gpio %d configured failed\n", __func__, rd->pmic_gpio_vol_dn); return rc; } else { rc = gpio_direction_input(rd->sys_gpio_vol_dn); if (rc < 0) { dev_err(rd->fbx_kybd_pdev, "%s: set gpio %d direction failed\n", __func__, rd->sys_gpio_vol_dn); return rc; } } if (rd->product_phase == Product_PR1 || rd->product_phase == Product_EVB) { rc = pm8058_gpio_config(rd->pmic_gpio_cam_t, &button_configuration); if (rc < 0) { dev_err(rd->fbx_kybd_pdev, "%s: gpio %d configured failed\n", __func__, rd->pmic_gpio_cam_t); return rc; } else { rc = gpio_direction_input(rd->sys_gpio_cam_t); if (rc < 0) { dev_err(rd->fbx_kybd_pdev, "%s: set gpio %d direction failed\n", __func__, rd->sys_gpio_cam_t); return rc; } } rc = pm8058_gpio_config(rd->pmic_gpio_cam_f, &button_configuration); if (rc < 0) { dev_err(rd->fbx_kybd_pdev, "%s: gpio %d configured failed\n", __func__, rd->pmic_gpio_cam_f); return rc; } else { rc = gpio_direction_input(rd->sys_gpio_cam_f); if (rc < 0) { dev_err(rd->fbx_kybd_pdev, "%s: set gpio %d direction failed\n", __func__, rd->sys_gpio_cam_f); return rc; } } } return 0; } static ssize_t fbx_kybd_gpio_status_show(struct device *dev, struct device_attribute *attr, char *buf) { return sprintf(buf, "%u\n", 0); } static ssize_t fbx_kybd_gpio_status_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { return count; } static DEVICE_ATTR(gpio_status, 0644, fbx_kybd_gpio_status_show, fbx_kybd_gpio_status_store); static int fbx_kybd_probe(struct platform_device *pdev) { struct fbx_kybd_platform_data *setup_data = pdev->dev.platform_data; int rc = -ENOMEM; rd = kzalloc(sizeof(struct fbx_kybd_record), GFP_KERNEL); if (!rd) { dev_err(&pdev->dev, "record memory allocation failed!!\n"); return rc; } rd->product_phase = fih_get_product_phase(); rd->fbx_kybd_pdev = &pdev->dev; rd->pmic_gpio_vol_up = setup_data->pmic_gpio_vol_up; rd->pmic_gpio_vol_dn = setup_data->pmic_gpio_vol_dn; rd->sys_gpio_vol_up = setup_data->sys_gpio_vol_up; rd->sys_gpio_vol_dn = setup_data->sys_gpio_vol_dn; if (rd->product_phase == Product_PR1 || rd->product_phase == Product_EVB) { rd->pmic_gpio_cam_f = setup_data->pmic_gpio_cam_f; rd->pmic_gpio_cam_t = setup_data->pmic_gpio_cam_t; rd->sys_gpio_cam_f = setup_data->sys_gpio_cam_f; rd->sys_gpio_cam_t = setup_data->sys_gpio_cam_t; } /* Div1-FW3-BSP-AUDIO */ rd->hook_sw_pin = setup_data->hook_sw_pin; rd->hooksw_irq_enable = false; headset_hook_wq = create_singlethread_workqueue("headset_hook"); if (!headset_hook_wq) { printk("%s: create workque failed \n", __func__); return -EBUSY; } //Request GPIOs rc = fbx_kybd_config_gpio(); if (rc) { goto failexit1; } else { dev_info(&pdev->dev, "%s: GPIOs configured SUCCESSFULLY!!\n", __func__); } //Initialize WORKs INIT_WORK(&rd->qkybd_volup, fbx_kybd_volup); INIT_WORK(&rd->qkybd_voldn, fbx_kybd_voldn); if (rd->product_phase == Product_PR1 || rd->product_phase == Product_EVB) { INIT_WORK(&rd->qkybd_camf, fbx_kybd_camf); INIT_WORK(&rd->qkybd_camt, fbx_kybd_camt); } /* Div1-FW3-BSP-AUDIO */ INIT_WORK(&rd->hook_switchkey, fbx_kybd_hooksw); //Request IRQs rc = fbx_kybd_irqsetup(); if (rc) goto failexit2; //Register Input Device to Input Subsystem fbx_kybd_connect2inputsys(); if (rd->fbx_kybd_idev == NULL) goto failexit2; rc = device_create_file(&pdev->dev, &dev_attr_gpio_status); if (rc) { dev_err(&pdev->dev, "%s: dev_attr_gpio_status failed\n", __func__); } return 0; failexit2: fbx_kybd_free_irq(); fbx_kybd_flush_work(); failexit1: fbx_kybd_release_gpio(); kfree(rd); return rc; } static struct platform_driver fbx_kybd_driver = { .driver = { .owner = THIS_MODULE, .name = fbx_kybd_name, }, .probe = fbx_kybd_probe, .remove = __devexit_p(fbx_kybd_remove), .suspend = fbx_kybd_suspend, .resume = fbx_kybd_resume, }; static int __init fbx_kybd_init(void) { return platform_driver_register(&fbx_kybd_driver); } static void __exit fbx_kybd_exit(void) { platform_driver_unregister(&fbx_kybd_driver); }
static int mipi_dsi_panel_power(int on) { int rc = 0, retVal = 0; static struct regulator *reg_vdd, *reg_iovdd, *reg_vdd_mipi; static bool dsi_power_on = false; unsigned int phaseid = 0; pr_info("[DISPLAY] +%s(%d)\n", __func__, on); if (!dsi_power_on) { /* INIT VDD_MIPI */ reg_vdd_mipi = regulator_get(&msm_mipi_dsi1_device.dev, "dsi_vdda"); if (IS_ERR(reg_vdd_mipi)) { pr_err("[DISPLAY]could not get reg_vdd_mipi, rc = %ld\n", PTR_ERR(reg_vdd_mipi)); retVal = -ENODEV; goto error; } rc = regulator_set_voltage(reg_vdd_mipi, 1200000, 1200000); if (rc) { pr_err("[DISPLAY]set_voltage VDD_MIPI failed, rc=%d\n", rc); retVal = -EINVAL; goto error; } /* INIT VDD FOR LCD*/ reg_vdd = regulator_get(&msm_mipi_dsi1_device.dev, "dsi_vdc"); if (IS_ERR(reg_vdd)) { pr_err("[DISPLAY]could not get reg_vdd, rc = %ld\n", PTR_ERR(reg_vdd)); retVal = -ENODEV; goto error; } rc = regulator_set_voltage(reg_vdd, 2800000, 2800000); if (rc) { pr_err("[DISPLAY]set_voltage reg_vdd failed, rc=%d\n", rc); retVal = -EINVAL; goto error; } /* INIT IOVDD FOR LCD*/ phaseid = fih_get_product_phase(); if(phaseid == PHASE_EVM ){ pr_info("[DISPLAY]Get L18\n"); reg_iovdd = regulator_get(&msm_mipi_dsi1_device.dev, "lcd_iovdd"); }else{ pr_info("[DISPLAY]Get LVS2\n"); reg_iovdd = regulator_get(&msm_mipi_dsi1_device.dev, "lcd_lvs2"); } if (IS_ERR(reg_iovdd)) { pr_err("[DISPLAY]could not get reg_iovdd, rc = %ld\n", PTR_ERR(reg_iovdd)); retVal = -ENODEV; goto error; } if(phaseid == PHASE_EVM ){ rc = regulator_set_voltage(reg_iovdd, 1800000, 1800000); if (rc) { pr_err("[DISPLAY]set_voltage reg_iovdd failed, rc=%d\n", rc); rc = -ENODEV; goto error; } } dsi_power_on = true; } if (on) { rc = regulator_set_optimum_mode(reg_vdd_mipi, 100000); if (rc < 0) { pr_err("[DISPLAY]set_optimum_mode VDD_MIPI failed, rc=%d\n", rc); retVal = -EINVAL; goto error; } rc = regulator_set_optimum_mode(reg_vdd, 100000); if (rc < 0) { pr_err("[DISPLAY]set_optimum_mode reg_vdd failed, rc=%d\n", rc); retVal = -EINVAL; goto error; } rc = regulator_set_optimum_mode(reg_iovdd, 100000); if (rc < 0) { pr_err("[DISPLAY]set_optimum_mode reg_iovdd failed, rc=%d\n", rc); retVal = -EINVAL; goto error; } rc = regulator_enable(reg_vdd_mipi); if (rc) { pr_err("[DISPLAY]enable VDD_MIPI failed, rc=%d\n", rc); retVal = -ENODEV; goto error; } rc = regulator_enable(reg_iovdd); if (rc) { pr_err("[DISPLAY]enable l18 failed, rc=%d\n", rc); retVal = -ENODEV; goto error; } rc = regulator_enable(reg_vdd); if (rc) { pr_err("[DISPLAY]enable l8 failed, rc=%d\n", rc); retVal = -ENODEV; goto error; } } else { rc = regulator_disable(reg_iovdd); if (rc) { pr_err("[DISPLAY]disable reg_vdd failed, rc=%d\n", rc); retVal = -ENODEV; goto error; } rc = regulator_disable(reg_vdd); if (rc) { pr_err("[DISPLAY]disable reg_vdd failed, rc=%d\n", rc); retVal = -ENODEV; goto error; } rc = regulator_disable(reg_vdd_mipi); if (rc) { pr_err("[DISPLAY]disable reg_vdd_mipi failed, rc=%d\n", rc); retVal = -ENODEV; goto error; } rc = regulator_set_optimum_mode(reg_vdd_mipi, 100); if (rc < 0) { pr_err("[DISPLAY]set_optimum_mode reg_vdd_mipi failed, rc=%d\n", rc); retVal = -EINVAL; goto error; } rc = regulator_set_optimum_mode(reg_vdd, 100); if (rc < 0) { pr_err("[DISPLAY]set_optimum_mode reg_vdd failed, rc=%d\n", rc); retVal = -EINVAL; goto error; } rc = regulator_set_optimum_mode(reg_iovdd, 100); if (rc < 0) { pr_err("[DISPLAY]set_optimum_mode reg_iovdd failed, rc=%d\n", rc); retVal = -EINVAL; goto error; } } error: return retVal; }
static int baseband_read_proc(char *page, char **start, off_t off, int count, int *eof, void *data) { int len; int pp = fih_get_product_phase(); char ver[25]={0}; switch (pp){ case Phase_EVB: strncpy(ver, "EVB", 3); ver[3]='\0'; break; case Phase_DP: strncpy(ver, "DP", 2); ver[2]='\0'; break; case Phase_SP: strncpy(ver, "SP", 2); ver[3]='\0'; break; /* MTD-BSP-VT-HWID-02+[ */ case Phase_SP2: strncpy(ver, "SP2", 3); ver[3]='\0'; break; /* MTD-BSP-VT-HWID-02+] */ case Phase_SP3: strncpy(ver, "SP3", 3); ver[3]='\0'; break; case Phase_AP: strncpy(ver, "AP", 2); ver[2]='\0'; break; case Phase_AP2: strncpy(ver, "AP2", 3); ver[3]='\0'; break; case Phase_PreAP: strncpy(ver, "PreAP", 5); ver[5]='\0'; break; case Phase_TP: strncpy(ver, "TP", 2); ver[2]='\0'; break; case Phase_TP2: strncpy(ver, "TP2", 3); ver[3]='\0'; break; case Phase_TP3: strncpy(ver, "TP3", 3); ver[3]='\0'; break; case Phase_PQ : strncpy(ver, "PQ", 2); ver[2]='\0'; break; case Phase_MP: strncpy(ver, "MP", 2); ver[2]='\0'; break; default: strncpy(ver, "Unkonwn Baseband version",24); ver[24]='\0'; break; } len = snprintf(page, count, "%s\n", ver); /* MTD-BSP-VT-PROC-00* */ return proc_calc_metrics(page, start, off, count, eof, len); }