/* * Restart requires that the secondary CPUs stop performing any activity * while the primary CPU resets the system. Systems with multiple CPUs must * provide a HW restart implementation, to ensure that all CPUs reset at once. * This is required so that any code running after reset on the primary CPU * doesn't have to co-ordinate with other CPUs to ensure they aren't still * executing pre-reset code, and using RAM that the primary CPU's code wishes * to use. Implementing such co-ordination would be essentially impossible. */ void machine_restart(char *cmd) { /* Disable interrupts first */ local_irq_disable(); smp_send_stop(); /* * UpdateCapsule() depends on the system being reset via * ResetSystem(). */ if (efi_enabled(EFI_RUNTIME_SERVICES)) efi_reboot(reboot_mode, NULL); /* Now call the architecture specific reboot code. */ if (arm_pm_restart) arm_pm_restart(reboot_mode, cmd); else do_kernel_restart(cmd); /* * Whoops - the architecture was unable to reboot. */ printk("Reboot failed -- System halted\n"); while (1); }
/* * Restart requires that the secondary CPUs stop performing any activity * while the primary CPU resets the system. Systems with a single CPU can * use soft_restart() as their machine descriptor's .restart hook, since that * will cause the only available CPU to reset. Systems with multiple CPUs must * provide a HW restart implementation, to ensure that all CPUs reset at once. * This is required so that any code running after reset on the primary CPU * doesn't have to co-ordinate with other CPUs to ensure they aren't still * executing pre-reset code, and using RAM that the primary CPU's code wishes * to use. Implementing such co-ordination would be essentially impossible. */ void machine_restart(char *cmd) { local_irq_disable(); smp_send_stop(); #if !defined(GSWA_CONFIG) && !defined(ABSM_CONFIG) if (arm_pm_restart) arm_pm_restart(reboot_mode, cmd); else do_kernel_restart(cmd); #else do_kernel_restart(cmd); #if defined(GSWA_CONFIG) #define WDT_GPIO1_19 499 gpio_direction_output(WDT_GPIO1_19, 0); #endif #if defined(ABSM_CONFIG) #define WDT_GPIO4_20 404 gpio_direction_output(WDT_GPIO4_20, 0); #endif #endif /* Give a grace period for failure to restart of 1s */ mdelay(1000); /* Whoops - the platform was unable to reboot. Tell the user! */ printk("Reboot failed -- System halted\n"); local_irq_disable(); while (1); }
void act8846_device_shutdown(void) { struct act8846 *act8846 = g_act8846; printk("%s\n",__func__); if (act8846->pmic_cpu_det_gpio) { gpio_direction_output(act8846->pmic_cpu_det_gpio,0); mdelay(100); } #if 1 if (act8846->pmic_hold_gpio) { gpio_direction_output(act8846->pmic_hold_gpio,0); mdelay(100); arm_pm_restart('h', "charge"); } #else ret = act8846_reg_read(act8846,0xc3); ret = act8846_set_bits(act8846, 0xc3,(0x1<<3),(0x1<<3)); ret = act8846_set_bits(act8846, 0xc3,(0x1<<4),(0x1<<4)); if (ret < 0) { printk("act8846 set 0xc3 error!\n"); return err; } #endif }
static void pwrkey_event_handler(void *param) { int pressed; unsigned int value; pressed = mxc_pwrkey->get_status((int)param); if (pressed) { pmic_read_reg(REG_MEM_A, &value, 0xffffff); if(value & 0x1){ pmic_write_reg(REG_MEM_A, (0 << 0), (1 << 0)); arm_pm_restart('h', "restart");} input_report_key( mxc_pwrkey->input, mxc_pwrkey->value, 1); pr_info("%s_Keydown\n", __func__); hw_set_pwbtn(0); if(deep_suspend) { queue_delayed_work(pwrkey_wq, &work_true, HZ / 2); } else { pwrkey_report_event0(1); } } else { pmic_read_reg(REG_MEM_A, &value, 0xffffff); if(value & 0x1){ pmic_write_reg(REG_MEM_A, (0 << 0), (1 << 0)); arm_pm_restart('h', "restart");} input_report_key( mxc_pwrkey->input, mxc_pwrkey->value, 0); pr_info("%s_Keyup\n", __func__); hw_set_pwbtn(1); if(deep_suspend) { deep_suspend = FALSE; queue_delayed_work(pwrkey_wq, &work_false, HZ / 2); } else { pwrkey_report_event0(0); } } }
static ssize_t update_firmware_store(struct kobject *kobj, struct kobj_attribute *attr, const char *buf, size_t count) { int ret0, ret1; int i, j; ret0 = i2c_smbus_read_byte_data(g_client,0x00); ret1 = i2c_smbus_read_byte_data(g_client,0x01); if (!strcmp(buf, "1")) { if ((ret1 == 0xf1) && (ret0 != 0x80) && (ret0 != 0x81) && (ret0 != 0x82)) { /*application chesmu error, update */ for(i = 0; i < 3; i++) { /* max update tries time is set 3 */ ret0 = i2c_update_firmware(); /*update firmware*/ if (ret0 == 0) { mdelay(800); /*wait for ts reset*/ break; } } } } // else if (!strcmp(buf, "2")) { /*update firmware from project menu*/ else if ( buf[0] == '2') { /*update firmware from project menu*/ for(i = 0; i < 3; i++) { /* max update tries time is set 3 */ ret0 = i2c_smbus_write_byte_data(g_client, 0x0d, 0x20); /* inform app switch to upgrade mode*/ printk("ret0 = %d\n", ret0); if (!ret0) { ret0 = i2c_update_firmware(); /*update firmware*/ if (ret0 == 0) { /*update firmware success */ printk("update firmware success\n!"); mdelay(800); /*wait for ts reset*/ return 1; } else if (ret0 == -2) /*update error,reboot*/ arm_pm_restart(0); } } } return ret0; }
void act8931_device_shutdown(void) { int ret; struct act8931 *act8931 = g_act8931; pr_info("%s\n", __func__); ret = act8931_reg_read(act8931, 0x01); ret = act8931_set_bits(act8931, 0x01, (0x1<<5) | (0x3<<0), (0x1<<5) | (0x3<<0)); if (ret < 0) pr_err("act8931 set 0x01 error!\n"); mdelay(100); arm_pm_restart('h', "charge"); }
/* * Restart requires that the secondary CPUs stop performing any activity * while the primary CPU resets the system. Systems with a single CPU can * use soft_restart() as their machine descriptor's .restart hook, since that * will cause the only available CPU to reset. Systems with multiple CPUs must * provide a HW restart implementation, to ensure that all CPUs reset at once. * This is required so that any code running after reset on the primary CPU * doesn't have to co-ordinate with other CPUs to ensure they aren't still * executing pre-reset code, and using RAM that the primary CPU's code wishes * to use. Implementing such co-ordination would be essentially impossible. */ void machine_restart(char *cmd) { local_irq_disable(); smp_send_stop(); if (arm_pm_restart) arm_pm_restart(reboot_mode, cmd); else do_kernel_restart(cmd); /* Give a grace period for failure to restart of 1s */ mdelay(1000); /* Whoops - the platform was unable to reboot. Tell the user! */ printk("Reboot failed -- System halted\n"); while (1); }
void machine_restart(char *cmd) { machine_shutdown(); /* Flush the console to make sure all the relevant messages make it * out to the console drivers */ arm_machine_flush_console(); arm_pm_restart(reboot_mode, cmd); /* Give a grace period for failure to restart of 1s */ mdelay(1000); /* Whoops - the platform was unable to reboot. Tell the user! */ printk("Reboot failed -- System halted\n"); local_irq_disable(); while (1); }
static void rk29_pm_power_off(void) { int count = 0; local_irq_disable(); local_fiq_disable(); printk(KERN_ERR "rk29_pm_power_off start...\n"); /* arm enter slow mode */ cru_writel((cru_readl(CRU_MODE_CON) & ~CRU_CPU_MODE_MASK) | CRU_CPU_MODE_SLOW, CRU_MODE_CON); LOOP(LOOPS_PER_USEC); while (1) { /* shut down the power by GPIO. */ if (gpio_get_value(POWER_ON_PIN) == GPIO_HIGH) { printk("POWER_ON_PIN is high\n"); gpio_set_value(POWER_ON_PIN, GPIO_LOW); } LOOP(5 * LOOPS_PER_MSEC); /* only normal power off can restart system safely */ if (system_state != SYSTEM_POWER_OFF) continue; if (gpio_get_value(PLAY_ON_PIN) != GPIO_HIGH) { if (!count) printk("PLAY_ON_PIN is low\n"); if (50 == count) /* break if keep low about 250ms */ break; count++; } else { count = 0; } } printk("system reboot\n"); gpio_set_value(POWER_ON_PIN, GPIO_HIGH); system_state = SYSTEM_RESTART; arm_pm_restart(0, NULL); while (1); }
static void rk2928_pm_power_off(void) { printk(KERN_ERR "rk2928_pm_power_off start...\n"); #if defined(CONFIG_REGULATOR_ACT8931) if(g_pmic_type == PMIC_TYPE_ACT8931) { if(act8931_charge_det) arm_pm_restart(0, NULL); } #endif #if defined(CONFIG_MFD_TPS65910) if(g_pmic_type == PMIC_TYPE_TPS65910) { tps65910_device_shutdown();//tps65910 shutdown } #endif gpio_direction_output(POWER_ON_PIN, GPIO_LOW); };
static void kona_power_off_charger(void) { pr_err("Rebooting into bootloader for charger.\n"); arm_pm_restart('t', NULL); }
static int manta_keyreset_fn(void) { arm_pm_restart('h', NULL); return 1; }
static ssize_t update_firmware_store(struct kobject *kobj, struct kobj_attribute *attr, const char *buf, size_t count) { int i; int ret = -1; int ret1; int *p = &i; printk("Update_firmware_store.\n"); #ifndef CONFIG_MELFAS_RESTORE_FIRMWARE if ((buf[0] == '2')&&(buf[1] == '\0')) { /* driver detect its device */ for (i = 0; i < 3; i++) { ret = i2c_smbus_read_byte_data(g_client, 0x00); if (ret >= 0) { goto firmware_find_device; } } printk("Dont find melfas_ts device\n"); return -1; firmware_find_device: ret = i2c_smbus_read_byte_data(g_client, 0x21); /* read firmware version */ printk("%s: reg21 = 0x%x\n", __FUNCTION__, ret); #else if (buf[0] == '2') { #endif disable_irq(g_client->irq); free_irq(g_client->irq, ts); g_client->addr = MELFAS_UPDATE_FIRMWARE_MODE_ADDR; /*update firmware*/ ret = i2c_update_firmware(); ret1 = gpio_tlmm_config(GPIO_CFG(TS_INT_GPIO, 0, GPIO_INPUT, GPIO_PULL_UP, GPIO_2MA), GPIO_ENABLE); ret1 = gpio_configure(TS_INT_GPIO, GPIOF_INPUT | IRQF_TRIGGER_FALLING); mdelay(10); g_client->addr = 0x23; /* touchscreen i2c addr */ enable_irq(g_client->irq); ret1 = request_irq(g_client->irq, melfas_ts_irq_handler, 0, g_client->name, ts); if (0 != ret1) { printk("request irq failed!\n"); } if( 0 != ret ){ printk("Update firmware failed!\n\n"); } else { printk("update firmware success!\n\n"); mdelay(200); /* for "printk" */ #ifdef CONFIG_MELFAS_RESTORE_FIRMWARE mdelay(8000); #else arm_pm_restart(0,p); #endif } } return ret; } static int i2c_update_firmware(void) { char *buf; struct file *filp; struct inode *inode = NULL; mm_segment_t oldfs; uint16_t length; int ret = 0; //"/data/melfas_ts_update_firmware.bin"; const char filename[]="/sdcard/update/melfas_ts_update_firmware.bin"; /* open file */ oldfs = get_fs(); set_fs(KERNEL_DS); filp = filp_open(filename, O_RDONLY, S_IRUSR); if (IS_ERR(filp)) { printk("%s: file %s filp_open error\n", __FUNCTION__,filename); set_fs(oldfs); return -1; } if (!filp->f_op) { printk("%s: File Operation Method Error\n", __FUNCTION__); filp_close(filp, NULL); set_fs(oldfs); return -1; } inode = filp->f_path.dentry->d_inode; if (!inode) { printk("%s: Get inode from filp failed\n", __FUNCTION__); filp_close(filp, NULL); set_fs(oldfs); return -1; } printk("%s file offset opsition: %u\n", __FUNCTION__, (unsigned)filp->f_pos); /* file's size */ length = i_size_read(inode->i_mapping->host); printk("%s: length=%d\n", __FUNCTION__, length); if (!( length > 0 && length < MCSDL_MAX_FILE_LENGTH )){ printk("file size error\n"); filp_close(filp, NULL); set_fs(oldfs); return -1; } /* allocation buff size */ buf = vmalloc((length+(length%2))); /* buf size if even */ if (!buf) { printk("alloctation memory failed\n"); filp_close(filp, NULL); set_fs(oldfs); return -1; } if ( length%2 == 1 ) { buf[length] = 0xFF; /* Fill Empty space */ } /* read data */ if (filp->f_op->read(filp, buf, length, &filp->f_pos) != length) { printk("%s: file read error\n", __FUNCTION__); filp_close(filp, NULL); set_fs(oldfs); vfree(buf); return -1; } #ifndef CONFIG_MELFAS_RESTORE_FIRMWARE /* disable other I2C device */ if (&TS_updateFW_gs_data->timer != NULL) { if (TS_updateFW_gs_data->use_irq) { disable_irq(TS_updateFW_gs_data->client->irq); } else { hrtimer_cancel(&TS_updateFW_gs_data->timer); } cancel_work_sync(&TS_updateFW_gs_data->work); mutex_lock(&TS_updateFW_gs_data->mlock); i2c_smbus_write_byte_data(TS_updateFW_gs_data->client, 0x20, 0); mutex_unlock(&TS_updateFW_gs_data->mlock); printk("hrtimer_cancel_GS\n"); } if (&TS_updateFW_aps_data->timer != NULL) { hrtimer_cancel(&TS_updateFW_aps_data->timer); cancel_work_sync(&TS_updateFW_aps_data->work); if (TS_updateFW_aps_wq) { printk("destroy_aps_wq\n"); destroy_workqueue(TS_updateFW_aps_wq); } mutex_lock(&TS_updateFW_aps_data->mlock); i2c_smbus_write_byte_data(TS_updateFW_aps_data->client, 0, 0); mutex_unlock(&TS_updateFW_aps_data->mlock); printk("hrtimer_cancel_APS\n"); } mdelay(1000); #endif ret = mcsdl_download(buf, length+(length%2)); filp_close(filp, NULL); set_fs(oldfs); vfree(buf); printk("%s: free file buffer\n", __FUNCTION__); return ret; }
static void restart_poweroff_do_poweroff(void) { arm_pm_restart('h', NULL); }
static long ncdiagd_power_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { int ret = 0; void __user *pArg = (void __user *)arg; printk(KERN_INFO "[%s] cmd:%d",__func__, cmd); switch(cmd) { case IOCTL_PW_RG_LP_CTL: { unsigned char enable; unsigned char vreg_id; ioctl_pw_value_type buf; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__INVALID; } enable = buf.req_buf[0]; vreg_id = buf.req_buf[1]; printk(KERN_INFO "DIAG_PW_RG_LP_CTL enable:%x vreg_id:%x", enable, vreg_id); ret = nc_pm8xxx_lp_mode_control(PM8XXX_VERSION_8921, vreg_id, enable); } break; case IOCTL_PW_RG_CTL: { unsigned char enable; unsigned char vreg_id; unsigned int min_volt, max_volt; ioctl_pw_value_type buf; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__INVALID; } enable = buf.req_buf[0]; vreg_id = buf.req_buf[1]; min_volt = cvt_val(buf.req_buf[3]); min_volt += cvt_val(buf.req_buf[2]) * 100; min_volt *= 1000; max_volt = cvt_val(buf.req_buf[5]); max_volt += cvt_val(buf.req_buf[4]) * 100; max_volt *= 1000; printk(KERN_INFO "DIAG_PW_RG_CTL enable :%x vreg_id :%x", enable, vreg_id); printk(KERN_INFO " min_volt:%x max_volt:%x", min_volt, max_volt); ret = nc_pm8xxx_vreg_control(PM8XXX_VERSION_8921, enable, vreg_id, min_volt, max_volt); } break; case IOCTL_PW_RG_SET_LVL: { unsigned char vreg_id; unsigned int min_volt, max_volt; ioctl_pw_value_type buf; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__INVALID; } vreg_id = buf.req_buf[0]; min_volt = cvt_val(buf.req_buf[2]); min_volt += cvt_val(buf.req_buf[1]) * 100; min_volt *= 1000; max_volt = cvt_val(buf.req_buf[4]); max_volt += cvt_val(buf.req_buf[3]) * 100; max_volt *= 1000; printk(KERN_INFO "DIAG_PW_RG_SET_LVL vreg_id:%x min_volt:%d max_volt:%d", vreg_id, min_volt, max_volt); ret = nc_pm8xxx_vreg_set_level(PM8XXX_VERSION_8921, vreg_id, min_volt, max_volt); } break; case IOCTL_PW_VT_PLDWN_SW: { unsigned char enable; unsigned char vreg_id; ioctl_pw_value_type buf; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__INVALID; } enable = buf.req_buf[0]; vreg_id = buf.req_buf[1]; printk(KERN_INFO "DIAG_PW_RG_SMPS_PSK enable:%x vreg_id:%x", enable, vreg_id); ret = nc_pm8xxx_vreg_pull_down_switch(PM8XXX_VERSION_8921, vreg_id, enable); } break; case IOCTL_PW_CHG_COIN_SW: { struct pm8xxx_coincell_chg param; ioctl_pw_value_type buf; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__INVALID; } param.state = buf.req_buf[0]; param.voltage = PM8XXX_COINCELL_VOLTAGE_3p2V; param.resistor = PM8XXX_COINCELL_RESISTOR_800_OHMS; ret = pm8xxx_coincell_chg_config(¶m); printk(KERN_INFO "DIAG_PW_CHG_COIN_SW enable:%x", param.state); } break; case IOCTL_PW_CHG_BAT_EBL: { bool enable; ioctl_pw_value_type buf; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__INVALID; } enable = (buf.req_buf[0]&0x01); ret = nc_pm8921_charger_enable(enable); printk(KERN_INFO "DIAG_PW_CHG_BAT_EBL enable:%x", enable); } break; case IOCTL_PW_CHG_DSBL: { unsigned char enable; ioctl_pw_value_type buf; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__INVALID; } enable = buf.req_buf[0]; enable = enable ? 0x00 : 0x01; ret = pm8921_disable_source_current(enable); printk(KERN_INFO "DIAG_PW_CHG_DSBL enable:%x", enable); } break; case IOCTL_PW_CHG_WCG_GET_STATE: { unsigned int rt_id = 0x00; unsigned int rt_status = 0x00; ioctl_pw_value_type buf; rt_id = PM8921_IRQ_BASE + PM8921_CABLE_IRQ; ret = nc_pm8921_get_rt_status(rt_id, &rt_status); if (ret != 0) { printk(KERN_ERR "nc_pm8921_get_rt_status failed \n"); return PM_ERR_FLAG__SBI_OPT_ERR; } buf.rsp_buf[0] = (u8)rt_status; if(copy_to_user((void *)pArg, &buf, sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_to_user failed"); return PM_ERR_FLAG__SBI_OPT_ERR; } printk(KERN_INFO "IOCTL_PW_CHG_WCG_GET_STATE rt_id:%x rt_status:%x", rt_id, rt_status); } break; case IOCTL_PW_CHG_WCG_SW: { ioctl_pw_value_type buf; struct pm_gpio param; int gpio_port; unsigned char enable = 0x00; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__SBI_OPT_ERR; } gpio_port = PM8921_GPIO_PM_TO_SYS(PM_DIAG_GPIO_32); param.direction = PM_GPIO_DIR_OUT; param.output_buffer = PM_GPIO_OUT_BUF_CMOS; param.output_value = 0; param.pull = PM_GPIO_PULL_NO; param.vin_sel = PM_GPIO_VIN_S4; param.out_strength = PM_GPIO_STRENGTH_LOW; param.function = PM_GPIO_FUNC_NORMAL; param.inv_int_pol = 0; param.disable_pin = 0; enable = buf.req_buf[0]; param.output_value = enable ? 0 : 1; ret = pm8xxx_gpio_config(gpio_port, ¶m); if (ret != 0) { printk(KERN_ERR "pm8xxx_gpio_config failed"); return PM_ERR_FLAG__SBI_OPT_ERR; } printk(KERN_INFO "IOCTL_PW_CHG_WCG_SW enable:%x param.output_value:%x ", enable, param.output_value); } break; case IOCTL_PW_CHG_VMAX_SET: { unsigned short voltage; ioctl_pw_value_type buf; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__INVALID; } voltage = buf.req_buf[1]; voltage += buf.req_buf[0] * 0x100; ret = nc_pm8921_chg_vmaxsel_set(voltage); printk(KERN_INFO "DIAG_PW_CHG_VMAX_SET voltage:%x", voltage); } break; case IOCTL_PW_CHG_IMAX_SET: { unsigned short cur_val; ioctl_pw_value_type buf; int ibat = 0; unsigned int iusb = 0; const int ibat_min = 325; const int ibat_max = 2000; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__INVALID; } cur_val = buf.req_buf[1]; cur_val += buf.req_buf[0] * 0x100; if (cur_val < ibat_min) { ibat = ibat_min; } else if (cur_val > ibat_max) { ibat = ibat_max; } else { ibat = (int)cur_val; } iusb = (unsigned int)(cur_val | PM8921_DIAG_IUSB_SET); pm8921_set_max_battery_charge_current(ibat); pm8921_charger_vbus_draw(iusb); printk(KERN_INFO "DIAG_PW_CHG_IMAX_SET cur_val:0x%04x", cur_val); } break; case IOCTL_PW_CHG_STATE_GET: { unsigned char chg_state = 0x00; ioctl_pw_value_type buf; ret = nc_pm8921_get_fsm_status((u64 *)&chg_state); buf.rsp_buf[0] = chg_state; if(copy_to_user((void *)pArg, &buf, sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_to_user failed"); return PM_ERR_FLAG__INVALID; } printk(KERN_INFO "DIAG_PW_CHG_STATE_GET chg_state:%x", chg_state); } break; case IOCTL_PW_CHG_USB_DSBL: { unsigned char enable; ioctl_pw_value_type buf; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__INVALID; } enable = buf.req_buf[0]; enable = enable ? 0x00 : 0x01; ret = nc_pm8921_chg_usb_suspend_enable(enable); printk(KERN_INFO "DIAG_PW_CHG_USB_DSBL enable:%x", enable); } break; case IOCTL_PW_ADC_RD_CHANNEL: { unsigned char analog_chnl, mpp_chnl; struct pm8xxx_adc_chan_result result; ioctl_pw_value_type buf; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__INVALID; } analog_chnl = buf.req_buf[0]; if (analog_chnl == CHANNEL_BATT_THERM) { analog_chnl = CHANNEL_BATT_THERM_UV; ret = pm8xxx_adc_read(analog_chnl, &result); } else if ((analog_chnl < PM8XXX_CHANNEL_MPP_SCALE1_IDX) || (analog_chnl == ADC_MPP_1_AMUX8 ) || (analog_chnl == ADC_MPP_1_AMUX3 ) || (analog_chnl == ADC_MPP_1_AMUX3_UV)) { ret = pm8xxx_adc_read(analog_chnl, &result); } else if ((analog_chnl >= PM8XXX_CHANNEL_MPP_SCALE1_IDX) && (analog_chnl <= ADC_MPP_1_ATEST_7 ) ) { mpp_chnl = analog_chnl - PM8XXX_CHANNEL_MPP_SCALE1_IDX; ret = pm8xxx_adc_mpp_config_read(mpp_chnl, CHANNEL_MPP_1, &result); } else if ((analog_chnl >= PM8XXX_CHANNEL_MPP_SCALE3_IDX) && (analog_chnl <= ADC_MPP_2_ATEST_7 ) ) { mpp_chnl = analog_chnl - PM8XXX_CHANNEL_MPP_SCALE3_IDX; ret = pm8xxx_adc_mpp_config_read(mpp_chnl, CHANNEL_MPP_2, &result); } else { printk(KERN_ERR "ADC_channel failed"); return PM_ERR_FLAG__FEATURE_NOT_SUPPORTED; } if(ret == PM_ERR_FLAG__SUCCESS) { if ((analog_chnl != CHANNEL_BATT_THERM) && (analog_chnl != ADC_MPP_1_AMUX8 ) && (analog_chnl != CHANNEL_MUXOFF ) && (analog_chnl != ADC_MPP_1_AMUX3 )) { if (result.physical != 0) { result.physical = div_u64(result.physical, 1000); } if (result.physical >= 0xFFFF) { result.physical = 0xFFFF; } } buf.rsp_buf[0] = (result.physical >> 8) & 0xff; buf.rsp_buf[1] = result.physical & 0xff; } if(copy_to_user((void *)pArg, &buf, sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_to_user failed"); return PM_ERR_FLAG__INVALID; } printk(KERN_INFO "DIAG_PW_ADC_RD_CHANNEL analog_chnl :%x", analog_chnl); printk(KERN_INFO " adc_read_val[0]:%x", (int)((result.physical >> 8) & 0xff)); printk(KERN_INFO " adc_read_val[1]:%x", (int)(result.physical & 0xff)); } break; case IOCTL_PW_SP_SMPLD_SW: { unsigned char enable; ioctl_pw_value_type buf; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__INVALID; } enable = buf.req_buf[0]; ret = pm8xxx_smpl_control(enable); printk(KERN_INFO "DIAG_PW_SP_SMPLD_SW enable:%x", enable); } break; case IOCTL_PW_SP_SMPLD_TM_SET: { unsigned char timer_set; ioctl_pw_value_type buf; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__INVALID; } timer_set = buf.req_buf[0]; ret = pm8xxx_smpl_set_delay(timer_set); printk(KERN_INFO "DIAG_PW_SP_SMPLD_TM_SET timer_set:%x", timer_set); } break; case IOCTL_PW_MPP_CNFDG_IPUT: { unsigned char mpp_port; unsigned char logi_level; ioctl_pw_value_type buf; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__INVALID; } mpp_port = buf.req_buf[0]; logi_level = buf.req_buf[1]; ret = nc_pm8xxx_mpp_config_digital_in(PM8921_MPP_PM_TO_SYS(mpp_port), logi_level, PM8XXX_MPP_DIN_TO_INT); printk(KERN_INFO "DIAG_PW_MPP_CNFDG_IPUT mpp_port:%x logi_level:%x", mpp_port +1, logi_level); } break; case IOCTL_PW_MPP_CNFDG_OPUT: { unsigned char mpp_port; unsigned char logi_level; unsigned char out_ctl; ioctl_pw_value_type buf; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__INVALID; } mpp_port = buf.req_buf[0]; logi_level = buf.req_buf[1]; out_ctl = buf.req_buf[2]; ret = nc_pm8xxx_mpp_config_digital_out(PM8921_MPP_PM_TO_SYS(mpp_port), logi_level, out_ctl); printk(KERN_INFO "DIAG_PW_MPP_CNFDG_OPUT mpp_port:%x logi_level:%x out_ctl:%x", mpp_port +1, logi_level, out_ctl); } break; case IOCTL_PW_MPP_CNFDG_IOPUT: { unsigned char mpp_port; unsigned char logi_level; unsigned char pull_set; ioctl_pw_value_type buf; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__INVALID; } mpp_port = buf.req_buf[0]; logi_level = buf.req_buf[1]; pull_set = buf.req_buf[2]; ret = nc_pm8xxx_mpp_config_bi_dir(PM8921_MPP_PM_TO_SYS(mpp_port), logi_level, pull_set); printk(KERN_INFO "DIAG_PW_MPP_CNFDG_IOPUT mpp_port:%x logi_level:%x pull_set:%x", mpp_port +1, logi_level, pull_set); } break; case IOCTL_PW_MPP_CNFAN_IPUT: { unsigned char mpp_port; unsigned char ain_chn; ioctl_pw_value_type buf; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__INVALID; } mpp_port = buf.req_buf[0]; ain_chn = buf.req_buf[1]; ret = nc_pm8xxx_mpp_config_analog_input(PM8921_MPP_PM_TO_SYS(mpp_port), ain_chn, PM8XXX_MPP_AOUT_CTRL_DISABLE); printk(KERN_INFO "DIAG_PW_MPP_CNFAN_IPUT mpp_port:%x ain_chn:%x", mpp_port + 1, ain_chn); } break; case IOCTL_PW_MPP_CNFAN_OPUT: { unsigned char mpp_port; unsigned char aout_level; unsigned char pm_onoff; ioctl_pw_value_type buf; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__INVALID; } mpp_port = buf.req_buf[0]; aout_level = buf.req_buf[1]; pm_onoff = buf.req_buf[2]; ret = nc_pm8xxx_mpp_config_analog_output(PM8921_MPP_PM_TO_SYS(mpp_port), aout_level, pm_onoff); printk(KERN_INFO "DIAG_PW_MPP_CNFAN_OPUT mpp_port:%x aout_level:%x pm_onoff:%x", mpp_port +1 , aout_level, pm_onoff); } break; case IOCTL_PW_MPP_CNF_I_SINK: { unsigned char mpp_port; unsigned char sink_level; unsigned char pm_onoff; ioctl_pw_value_type buf; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__INVALID; } mpp_port = buf.req_buf[0]; sink_level = buf.req_buf[1]; pm_onoff = buf.req_buf[2]; ret = nc_pm8xxx_mpp_config_current_sink(PM8921_MPP_PM_TO_SYS(mpp_port), sink_level, pm_onoff); printk(KERN_INFO "DIAG_PW_MPP_CNF_I_SINK mpp_port:%x sink_level:%x pm_onoff:%x", mpp_port + 1, sink_level, pm_onoff); } break; case IOCTL_PW_GPIO_CONFIG_SET: { ioctl_pw_value_type buf; struct pm_gpio param ; int gpio_port; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__INVALID; } gpio_port = PM8921_GPIO_PM_TO_SYS(buf.req_buf[0]); param.direction = buf.req_buf[1]; param.output_buffer = buf.req_buf[2]; param.output_value = buf.req_buf[3]; param.pull = buf.req_buf[4]; param.vin_sel = buf.req_buf[5]; param.out_strength = buf.req_buf[6]; param.function = buf.req_buf[7]; param.inv_int_pol = buf.req_buf[8]; param.disable_pin = buf.req_buf[9]; ret = pm8xxx_gpio_config(gpio_port, ¶m); printk(KERN_INFO "IOCTL_PW_GPIO_CONFIG_SET gpio_port :%x direction:%x output_buffer:%x", gpio_port, param.direction, param.output_buffer); printk(KERN_INFO " output_value:%x pull :%x vin_sel :%x", param.output_value, param.pull, param.vin_sel); printk(KERN_INFO " out_strength:%x function :%x inv_int_pol :%x", param.out_strength, param.function, param.inv_int_pol); printk(KERN_INFO " pin_disable :%x ", param.disable_pin); } break; case IOCTL_PW_GPIO_GET_STATE: { unsigned int gpio_id = 0x00; unsigned int gpio_state = 0x00; ioctl_pw_value_type buf; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__INVALID; } gpio_id = (unsigned int)buf.req_buf[0]; ret = nc_pm8921_gpio_get_state(gpio_id, &gpio_state); buf.rsp_buf[0] = (u8)gpio_state; if(copy_to_user((void *)pArg, &buf, sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_to_user failed"); return PM_ERR_FLAG__INVALID; } printk(KERN_INFO "DIAG_PW_GPIO_GET_STATE GPIO :%d value :%d", gpio_id+1, gpio_state); } break; case IOCTL_PW_PCT_OTP_STAGE_GET: { unsigned char itemp_stage = 0x00; ioctl_pw_value_type buf; ret = nc_pm8921_itemp_get_stage(&itemp_stage); buf.rsp_buf[0] = itemp_stage; if(copy_to_user((void *)pArg, &buf, sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_to_user failed"); return PM_ERR_FLAG__INVALID; } printk(KERN_INFO "DIAG_PW_PCT_OTP_STAGE_GET itemp_stage:%x", itemp_stage); } break; case IOCTL_PW_PCT_OTP_STG_OVD: { unsigned char enable; ioctl_pw_value_type buf; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__INVALID; } enable = buf.req_buf[0]; ret = nc_pm8921_itemp_stage_override(enable); printk(KERN_INFO "DIAG_PW_PCT_OTP_STG_OVD enable:%x", enable); } break; case IOCTL_PW_IR_RT_STATUS_GET: { unsigned int rt_id = 0x00; unsigned int rt_status = 0x00; ioctl_pw_value_type buf; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__INVALID; } rt_id = (unsigned int)buf.req_buf[0]; rt_id += PM8921_IRQ_BASE; nc_pm8921_get_rt_status(rt_id, &rt_status); buf.rsp_buf[0] = (u8)rt_status; if(copy_to_user((void *)pArg, &buf, sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_to_user failed"); return PM_ERR_FLAG__INVALID; } printk(KERN_INFO "DIAG_PW_IR_RT_STATUS_GET rt_id:%x rt_status:%x", rt_id, rt_status); } break; case IOCTL_PW8821_RG_LP_CTL: { unsigned char enable; unsigned char vreg_id; ioctl_pw_value_type buf; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__INVALID; } enable = buf.req_buf[0]; vreg_id = buf.req_buf[1]; printk(KERN_INFO "DIAG_PW8821_RG_LP_CTL enable:%x vreg_id:%x", enable, vreg_id); ret = nc_pm8xxx_lp_mode_control(PM8XXX_VERSION_8821, vreg_id, enable); } break; case IOCTL_PW8821_RG_CTL: { unsigned char enable; unsigned char vreg_id; unsigned int min_volt, max_volt; ioctl_pw_value_type buf; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__INVALID; } enable = buf.req_buf[0]; vreg_id = buf.req_buf[1]; min_volt = cvt_val(buf.req_buf[3]); min_volt += cvt_val(buf.req_buf[2]) * 100; min_volt *= 1000; max_volt = cvt_val(buf.req_buf[5]); max_volt += cvt_val(buf.req_buf[4]) * 100; max_volt *= 1000; printk(KERN_INFO "DIAG_PW8821_RG_CTL enable :%x vreg_id :%x", enable, vreg_id); printk(KERN_INFO " min_volt:%x max_volt:%x", min_volt, max_volt); ret = nc_pm8xxx_vreg_control(PM8XXX_VERSION_8821, enable, vreg_id, min_volt, max_volt); } break; case IOCTL_PW8821_RG_SET_LVL: { unsigned char vreg_id; unsigned int min_volt, max_volt; ioctl_pw_value_type buf; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__INVALID; } vreg_id = buf.req_buf[0]; min_volt = cvt_val(buf.req_buf[2]); min_volt += cvt_val(buf.req_buf[1]) * 100; min_volt *= 1000; max_volt = cvt_val(buf.req_buf[4]); max_volt += cvt_val(buf.req_buf[3]) * 100; max_volt *= 1000; printk(KERN_INFO "DIAG_PW8821_RG_SET_LVL vreg_id:%x min_volt:%x max_volt:%x", vreg_id, min_volt, max_volt); ret = nc_pm8xxx_vreg_set_level(PM8XXX_VERSION_8821, vreg_id, min_volt, max_volt); } break; case IOCTL_PW8821_VT_PLDWN_SW: { unsigned char enable; unsigned char vreg_id; ioctl_pw_value_type buf; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__INVALID; } enable = buf.req_buf[0]; vreg_id = buf.req_buf[1]; printk(KERN_INFO "DIAG_PW8821_RG_SMPS_PSK enable:%x vreg_id:%x", enable, vreg_id); ret = nc_pm8xxx_vreg_pull_down_switch(PM8XXX_VERSION_8821, vreg_id, enable); } break; case IOCTL_PW8821_MPP_CNFDG_IPUT: { unsigned char mpp_port; unsigned char logi_level; ioctl_pw_value_type buf; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__INVALID; } mpp_port = buf.req_buf[0]; logi_level = buf.req_buf[1]; ret = nc_pm8xxx_mpp_config_digital_in(PM8821_MPP_PM_TO_SYS(mpp_port), logi_level, PM8XXX_MPP_DIN_TO_INT); printk(KERN_INFO "DIAG_PW8821_MPP_CNFDG_IPUT mpp_port:%x logi_level:%x", mpp_port, logi_level); } break; case IOCTL_PW8821_MPP_CNFDG_OPUT: { unsigned char mpp_port; unsigned char logi_level; unsigned char out_ctl; ioctl_pw_value_type buf; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__INVALID; } mpp_port = buf.req_buf[0]; logi_level = buf.req_buf[1]; out_ctl = buf.req_buf[2]; ret = nc_pm8xxx_mpp_config_digital_out(PM8821_MPP_PM_TO_SYS(mpp_port), logi_level, out_ctl); printk(KERN_INFO "DIAG_PW8821_MPP_CNFDG_OPUT mpp_port:%x logi_level:%x out_ctl:%x", mpp_port, logi_level, out_ctl); } break; case IOCTL_PW8821_MPP_CNFDG_IOPUT: { unsigned char mpp_port; unsigned char logi_level; unsigned char pull_set; ioctl_pw_value_type buf; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__INVALID; } mpp_port = buf.req_buf[0]; logi_level = buf.req_buf[1]; pull_set = buf.req_buf[2]; ret = nc_pm8xxx_mpp_config_bi_dir(PM8821_MPP_PM_TO_SYS(mpp_port), logi_level, pull_set); printk(KERN_INFO "DIAG_PW8821_MPP_CNFDG_IOPUT mpp_port:%x logi_level:%x pull_set:%x", mpp_port, logi_level, pull_set); } break; case IOCTL_PW8821_MPP_CNFAN_IPUT: { unsigned char mpp_port; unsigned char ain_chn; ioctl_pw_value_type buf; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__INVALID; } mpp_port = buf.req_buf[0]; ain_chn = buf.req_buf[1]; ret = nc_pm8xxx_mpp_config_analog_input(PM8821_MPP_PM_TO_SYS(mpp_port), ain_chn, PM8XXX_MPP_AOUT_CTRL_DISABLE); printk(KERN_INFO "DIAG_PW8821_MPP_CNFAN_IPUT mpp_port:%x ain_chn:%x", mpp_port, ain_chn); } break; case IOCTL_PW8821_MPP_CNFAN_OPUT: { unsigned char mpp_port; unsigned char aout_level; unsigned char pm_onoff; ioctl_pw_value_type buf; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__INVALID; } mpp_port = buf.req_buf[0]; aout_level = buf.req_buf[1]; pm_onoff = buf.req_buf[2]; ret = nc_pm8xxx_mpp_config_analog_output(PM8821_MPP_PM_TO_SYS(mpp_port), aout_level, pm_onoff); printk(KERN_INFO "DIAG_PW8821_MPP_CNFAN_OPUT mpp_port:%x aout_level:%x pm_onoff:%x", mpp_port, aout_level, pm_onoff); } break; case IOCTL_PW8821_MPP_CNF_I_SINK: { unsigned char mpp_port; unsigned char sink_level; unsigned char pm_onoff; ioctl_pw_value_type buf; if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type))) { printk(KERN_ERR "copy_from_user failed"); return PM_ERR_FLAG__INVALID; } mpp_port = buf.req_buf[0]; sink_level = buf.req_buf[1]; pm_onoff = buf.req_buf[2]; ret = nc_pm8xxx_mpp_config_current_sink(PM8821_MPP_PM_TO_SYS(mpp_port), sink_level, pm_onoff); printk(KERN_INFO "DIAG_PW8821_MPP_CNF_I_SINK mpp_port:%x sink_level:%x pm_onoff:%x", mpp_port, sink_level, pm_onoff); } break; case IOCTL_PW_HW_RESET: printk(KERN_INFO "DVE005_FACTORY_DIAG_FTM_ONLINE_RESET_MODE"); printk(KERN_DEBUG "[ncdiagd_power.c]%s: Goto arm_pm_restart() in \n", __func__ ); arm_pm_restart(0, NULL); break; default: printk(KERN_ERR "Invalid Parameter"); return PM_ERR_FLAG__INVALID; } return ret; }