static int
do_vm86(xf86Int10InfoPtr pInt)
{
int retval, signo;
xf86InterceptSignals(&signo);
retval = vm86_rep(VM86S);
xf86InterceptSignals(NULL);
if (signo >= 0) {
xf86DrvMsg(pInt->scrnIndex, X_ERROR,
"vm86() syscall generated signal %d.\n", signo);
dump_registers(pInt);
dump_code(pInt);
stack_trace(pInt);
return 0;
}
switch (VM86_TYPE(retval)) {
case VM86_UNKNOWN:
if (!vm86_GP_fault(pInt)) return 0;
break;
case VM86_STI:
xf86DrvMsg(pInt->scrnIndex, X_ERROR, "vm86_sti :-((\n");
dump_registers(pInt);
dump_code(pInt);
stack_trace(pInt);
return 0;
case VM86_INTx:
pInt->num = VM86_ARG(retval);
if (!int_handler(pInt)) {
xf86DrvMsg(pInt->scrnIndex, X_ERROR,
"Unknown vm86_int: 0x%X\n\n", VM86_ARG(retval));
dump_registers(pInt);
dump_code(pInt);
stack_trace(pInt);
return 0;
}
/* I'm not sure yet what to do if we can handle ints */
break;
case VM86_SIGNAL:
return 1;
/*
* we used to warn here and bail out - but now the sigio stuff
* always fires signals at us. So we just ignore them for now.
*/
xf86DrvMsg(pInt->scrnIndex, X_WARNING, "received signal\n");
return 0;
default:
xf86DrvMsg(pInt->scrnIndex, X_ERROR, "unknown type(0x%x)=0x%x\n",
VM86_ARG(retval), VM86_TYPE(retval));
dump_registers(pInt);
dump_code(pInt);
stack_trace(pInt);
return 0;
}
return 1;
}
static ssize_t jz_dmic_regs_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct jz_dmic *jz_dmic = dev_get_drvdata(dev);
dump_registers(jz_dmic->dev);
return 0;
}
void debug_opcode(cpu* local_cpu, char *opcode, u16 n) {
#ifdef DEBUGOPCODE
// Get the n arguments.
u16 *args = get_args(local_cpu, n);
printf("%s\n\n\tInstruction/OpCode\n\n%s", COLORS_BG_BLACK, COLORS_RESET_BG);
printf(
"\t%s%s%s [%s%c%s] %s%s0x0%x%s, 0x0%x\n", // String & Replacement Flags
COLORS_BG_BLACK,
opcode,
COLORS_RESET_BG,
COLORS_LIGHT_BLUE,
get_register_value(local_cpu, args[0], 2),
COLORS_RESET,
COLORS_BLACK,
COLORS_BG_WHITE,
get_register_value(local_cpu, args[0], 0),
COLORS_RESET,
get_register_value(local_cpu, args[0], 3)
);
dump_registers(local_cpu, n);
printf("%s\n\n\tEND\n\n%s", COLORS_BG_BLACK, COLORS_RESET_BG);
free(args);
#endif
}
static unsigned int ncp6335d_get_mode(struct regulator_dev *rdev)
{
unsigned int val;
int rc;
struct ncp6335d_info *dd = rdev_get_drvdata(rdev);
struct i2c_client *client = to_i2c_client(dd->dev);
rc = regmap_read(dd->regmap, REG_NCP6335D_COMMAND, &val);
if (rc) {
dev_err(dd->dev, "Unable to get regulator mode rc(%d), %x\n", rc, client->addr);
getAddr(client);
rc = regmap_read(dd->regmap, REG_NCP6335D_COMMAND, &val);
if (rc) {
dev_err(dd->dev, "Unable to get regulator mode rc1(%d), %x\n", rc, client->addr);
return rc;
}
}
dump_registers(dd, REG_NCP6335D_COMMAND, __func__);
if (val & dd->mode_bit)
return REGULATOR_MODE_FAST;
return REGULATOR_MODE_NORMAL;
}
static int ncp6335d_get_voltage(struct regulator_dev *rdev)
{
unsigned int val;
int rc;
struct ncp6335d_info *dd = rdev_get_drvdata(rdev);
mutex_lock(&dd->ncp_mutex);
if (dd->is_suspend) {
rc = dd->curr_voltage;
dev_dbg(dd->dev, "Get voltage after suspend, (%d)\n", rc);
goto out;
}
rc = ncp6335x_read(dd, dd->vsel_reg, &val);
if (rc) {
dev_err(dd->dev, "Unable to get volatge rc(%d)", rc);
return rc;
}
dd->curr_voltage = ((val & NCP6335D_VOUT_SEL_MASK) * dd->step_size) +
dd->min_voltage;
rc = dd->curr_voltage;
dump_registers(dd, dd->vsel_reg, __func__);
out:
mutex_unlock(&dd->ncp_mutex);
return rc;
}
static ssize_t jz_spdif_regs_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct jz_spdif *jz_spdif = dev_get_drvdata(dev);
dump_registers(jz_spdif->aic);
return 0;
}
static int ncp6335d_set_voltage(struct regulator_dev *rdev,
int min_uV, int max_uV, unsigned *selector)
{
unsigned int temp = 0;
int rc, set_val, new_uV;
struct ncp6335d_info *dd = rdev_get_drvdata(rdev);
set_val = DIV_ROUND_UP(min_uV - NCP6335D_MIN_VOLTAGE_UV,
NCP6335D_STEP_VOLTAGE_UV);
new_uV = (set_val * NCP6335D_STEP_VOLTAGE_UV) +
NCP6335D_MIN_VOLTAGE_UV;
if (new_uV > (max_uV + NCP6335D_MIN_VOLTAGE_UV)) {
dev_err(dd->dev, "Unable to set volatge (%d %d)\n",
min_uV, max_uV);
return -EINVAL;
}
temp = dd->vsel_ctrl_val & ~NCP6335D_VOUT_SEL_MASK;
temp |= (set_val & NCP6335D_VOUT_SEL_MASK);
rc = regmap_write(dd->regmap, dd->vsel_reg, temp);
if (rc) {
dev_err(dd->dev, "Unable to set volatge (%d %d)\n",
min_uV, max_uV);
} else {
ncp633d_slew_delay(dd, dd->curr_voltage, new_uV);
dd->curr_voltage = new_uV;
dd->vsel_ctrl_val = temp;
}
dump_registers(dd, dd->vsel_reg, __func__);
return rc;
}
static int ncp6335d_set_mode(struct regulator_dev *rdev,
unsigned int mode)
{
int rc;
struct ncp6335d_info *dd = rdev_get_drvdata(rdev);
/* only FAST and NORMAL mode types are supported */
if (mode != REGULATOR_MODE_FAST && mode != REGULATOR_MODE_NORMAL) {
dev_err(dd->dev, "Mode %d not supported\n", mode);
return -EINVAL;
}
rc = regmap_update_bits(dd->regmap, REG_NCP6335D_COMMAND, dd->mode_bit,
(mode == REGULATOR_MODE_FAST) ? dd->mode_bit : 0);
if (rc) {
dev_err(dd->dev, "Unable to set operating mode rc(%d)", rc);
return rc;
}
rc = regmap_update_bits(dd->regmap, REG_NCP6335D_COMMAND,
NCP6335D_DVS_PWM_MODE,
(mode == REGULATOR_MODE_FAST) ?
NCP6335D_DVS_PWM_MODE : 0);
if (rc)
dev_err(dd->dev, "Unable to set DVS trans. mode rc(%d)", rc);
dump_registers(dd, REG_NCP6335D_COMMAND, __func__);
return rc;
}
static int ncp6335d_set_voltage(struct regulator_dev *rdev,
int min_uV, int max_uV, unsigned *selector)
{
int rc, set_val, new_uV;
struct ncp6335d_info *dd = rdev_get_drvdata(rdev);
set_val = DIV_ROUND_UP(min_uV - dd->min_voltage, dd->step_size);
new_uV = (set_val * dd->step_size) + dd->min_voltage;
if (new_uV > max_uV) {
dev_err(dd->dev, "Unable to set volatge (%d %d)\n",
min_uV, max_uV);
return -EINVAL;
}
#if 0
rc = ncp6335x_update_bits(dd, dd->vsel_reg,
NCP6335D_VOUT_SEL_MASK, (set_val & NCP6335D_VOUT_SEL_MASK));
#else
rc = ncp6335x_update_bits(dd, dd->vsel_reg,
0xFF, ((set_val & NCP6335D_VOUT_SEL_MASK)|0x80));
#endif
if (rc) {
dev_err(dd->dev, "Unable to set volatge (%d %d)\n",
min_uV, max_uV);
} else {
ncp633d_slew_delay(dd, dd->curr_voltage, new_uV);
dd->curr_voltage = new_uV;
}
dump_registers(dd, dd->vsel_reg, __func__);
return rc;
}
void handle_usr1(int sig) {
dump_registers();
if (halt) {
halt = 0;
} else {
halt = 1;
}
}
int main() {
registers regs; /* Registers */
memory mem; /* Main memory */
int i; /* Instruction count */
/*
* 'Boot up'??
*/
/* Initialize memory/registers to zero */
memset(mem.data, 0, MEMSIZE);
memset(®s, 0, sizeof(registers));
/* 'Load' sample program into memory */
memcpy(mem.data + OS_SIZE, test_program, sizeof(test_program));
/* Initialize some register and memory values
* (hard-coded for the purposes of testing)
*/
const uint32_t sample_value_addr = OS_SIZE + sizeof(test_program);
regs.general[0] = 0xDEADBEEF;
regs.general[1] = sample_value_addr;
regs.general[3] = 0xCAFEBABE;
printf("Initial state:\n");
dump_registers(®s);
dump_memory(&mem);
/* Execute program */
regs.prog_counter = OS_SIZE;
for (i = 0; i < sizeof(test_program)/sizeof(uint32_t); i++) {
printf("Executing instruction %u in test_program\n", i);
/* Execute instruction */
execute(®s, &mem);
/* Dump */
dump_registers(®s);
dump_memory(&mem);
}
return EXIT_SUCCESS;
}
void dump_crash_report(int tfd, unsigned pid, unsigned tid, bool at_fault)
{
char data[1024];
FILE *fp;
mapinfo *milist = 0;
unsigned int sp_list[STACK_CONTENT_DEPTH];
int stack_depth;
int frame0_pc_sane = 1;
if (!at_fault) {
_LOG(tfd, true,
"--- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---\n");
_LOG(tfd, true, "pid: %d, tid: %d\n", pid, tid);
}
dump_registers(tfd, tid, at_fault);
/* Clear stack pointer records */
memset(sp_list, 0, sizeof(sp_list));
sprintf(data, "/proc/%d/maps", pid);
fp = fopen(data, "r");
if(fp) {
while(fgets(data, 1024, fp)) {
mapinfo *mi = parse_maps_line(data);
if(mi) {
mi->next = milist;
milist = mi;
}
}
fclose(fp);
}
parse_exidx_info(milist, tid);
/* If stack unwinder fails, use the default solution to dump the stack
* content.
*/
stack_depth = unwind_backtrace_with_ptrace(tfd, tid, milist, sp_list,
&frame0_pc_sane, at_fault);
/* The stack unwinder should at least unwind two levels of stack. If less
* level is seen we make sure at lease pc and lr are dumped.
*/
if (stack_depth < 2) {
dump_pc_and_lr(tfd, tid, milist, stack_depth, at_fault);
}
dump_stack_and_code(tfd, tid, milist, stack_depth, sp_list, frame0_pc_sane,
at_fault);
while(milist) {
mapinfo *next = milist->next;
free(milist);
milist = next;
}
}
void ubc_break_work(register_stack *stack)
{
ubc_serial_init(57600);
ubc_serial_flush();
dump_registers(&(stack->r0), "R", 14);
ubc_serial_flush();
}
static int ncp6335d_set_voltage(struct regulator_dev *rdev,
int min_uV, int max_uV, unsigned *selector)
{
int rc, set_val, new_uV;
struct ncp6335d_info *dd = rdev_get_drvdata(rdev);
//<oliver 20150716>++ modify ncp output voltage for stability
static enum msm_cpu cur_cpu; //static variable constraint to this file
static char* buf = "0.0";
cur_cpu = socinfo_get_msm_cpu();
buf = OLIVER_socinfo_get_msm_cpu_revision();
set_val = DIV_ROUND_UP(min_uV - dd->min_voltage, dd->step_size);
if (!strncmp("3.0",buf,3)) {
//printk("OLIVER 3.0 found\n");
} else if ((MSM_CPU_8939 == cur_cpu)&&(asus_PRJ_ID == ASUS_ZE550KL)){
if (!strncmp("3",asus_project_stage,2)||!strncmp("1",asus_project_stage,2)) {
if (set_val < 80)
set_val = set_val + 5;
else if (set_val < 120) {
set_val = set_val + 4;
if (set_val > 120)
set_val = 120;
}
}else {
if (set_val < 80) {
set_val = set_val + 4;
if (set_val > 80)
set_val = 80;
}
}
}
//<oliver 20150716>--
new_uV = (set_val * dd->step_size) + dd->min_voltage;
if (new_uV > max_uV) {
dev_err(dd->dev, "Unable to set volatge (%d %d)\n",
min_uV, max_uV);
return -EINVAL;
}
rc = ncp6335x_update_bits(dd, dd->vsel_reg,
NCP6335D_VOUT_SEL_MASK, (set_val & NCP6335D_VOUT_SEL_MASK));
if (rc) {
dev_err(dd->dev, "Unable to set volatge (%d %d)\n",
min_uV, max_uV);
} else {
ncp633d_slew_delay(dd, dd->curr_voltage, new_uV);
dd->curr_voltage = new_uV;
}
dump_registers(dd, dd->vsel_reg, __func__);
return rc;
}
static void dump_context(struct ucontext *cx)
{
kprintf("iret_eip = 0x%lx\n", cx->iret_eip);
kprintf("iret_cs = 0x%lx\n", cx->iret_cs);
kprintf("iret_elfags = 0x%lx\n", cx->eflags);
if (!is_kernel_context(cx)) {
kprintf("iret_esp = 0x%lx\n", cx->iret_esp);
kprintf("iret_ss = 0x%lx\n", cx->iret_ss);
}
dump_registers(&cx->reg);
}
void process_command ()
{ char action;
char fname[100];
int pid, time, ret;
printf ("command> ");
scanf ("%c", &action);
while (action != 'T')
{ switch (action)
{ case 's': // submit
scanf ("%s", &fname);
if (Debug) printf ("File name: %s is submitted\n", fname);
submit_process (fname);
break;
case 'x': // execute
execute_process ();
break;
case 'r': // dump register
dump_registers ();
break;
case 'q': // dump ready queue and list of processes completed IO
dump_ready_queue ();
dump_doneWait_list ();
break;
case 'p': // dump PCB
printf ("PCB Dump Starts: Checks from 0 to %d\n", currentPid);
for (pid=1; pid<currentPid; pid++)
if (PCB[pid] != NULL) dump_PCB (pid);
break;
case 'e': // dump events in timer
dump_events ();
break;
case 'm': // dump Memory
for (pid=1; pid<currentPid; pid++)
if (PCB[pid] != NULL) dump_memory (pid);
break;
case 'w': // dump Swap Space
for (pid=1; pid<currentPid; pid++)
if (PCB[pid] != NULL) dump_swap_memory (pid);
break;
case 'l': // dump Spool
for (pid=1; pid<currentPid; pid++)
if (PCB[pid] != NULL) dump_spool (pid);
break;
case 'T': // Terminate, do nothing, terminate in while loop
break;
default:
printf ("Incorrect command!!!\n");
}
printf ("\ncommand> ");
scanf ("\n%c", &action);
if (Debug) printf ("Next command is %c\n", action);
}
}
static int ncp6335d_disable(struct regulator_dev *rdev)
{
int rc;
struct ncp6335d_info *dd = rdev_get_drvdata(rdev);
rc = regmap_update_bits(dd->regmap, dd->vsel_reg,
NCP6335D_ENABLE, 0);
if (rc)
dev_err(dd->dev, "Unable to disable regualtor rc(%d)", rc);
dump_registers(dd, dd->vsel_reg, __func__);
return rc;
}
// Main program: Initialize the cpu, and read the initial memory values
//
int main(int argc, char *argv[]) {
printf("SDC Simulator pt 1 Devanshu Bharel: CS 350 Lab 6\n");
CPU cpu_value, *cpu = &cpu_value;
printf("Initalizing CPU:\n");
initialize_CPU(cpu);
printf("Initalizing MEM:\n");
initialize_memory(argc, argv, cpu);
dump_CPU(cpu);
dump_memory(cpu);
dump_registers(cpu);
// That's it for Lab 6
//
return 0;
}
static int fan53555_set_voltage(struct regulator_dev *rdev,
int min_uV, int max_uV, unsigned *selector)
{
struct fan53555_device_info *di = rdev_get_drvdata(rdev);
int ret, set_val, new_uV;
unsigned int temp = 0;
mutex_lock(&di->restart_lock);
/*
* Do not allow any other voltage transitions after
* restart configuration is done.
*/
if (di->restart_config_done) {
dev_err(di->dev, "Restart config done. Cannot set volatage\n");
ret = -EINVAL;
goto err_set_vtg;
}
set_val = DIV_ROUND_UP(min_uV - di->vsel_min, di->vsel_step);
new_uV = (set_val * di->vsel_step) + di->vsel_min;
if (new_uV > (max_uV + di->vsel_step)) {
dev_err(di->dev, "Unable to set volatge (%d %d)\n",
min_uV, max_uV);
ret = -EINVAL;
goto err_set_vtg;
}
temp = di->vsel_ctrl_val & ~VSEL_NSEL_MASK;
temp |= (set_val & VSEL_NSEL_MASK);
ret = regmap_write(di->regmap, di->vol_reg, temp);
if (ret) {
dev_err(di->dev, "Unable to set volatge (%d %d)\n",
min_uV, max_uV);
goto err_set_vtg;
} else {
fan53555_slew_delay(di, di->curr_voltage, new_uV);
di->curr_voltage = new_uV;
di->vsel_ctrl_val = temp;
}
dump_registers(di, di->vol_reg, __func__);
err_set_vtg:
mutex_unlock(&di->restart_lock);
return ret;
}
//------------------------------------------------------------------------------
// Name: show_menu()
// Desc:
//------------------------------------------------------------------------------
void DumpState::show_menu() {
State state;
edb::v1::debugger_core->get_state(state);
std::cout << "------------------------------------------------------------------------------\n";
dump_registers(state);
std::cout << "[" << hex_string<quint16>(*state["ss"]) << ":" << hex_string(state.stack_pointer()) << "]---------------------------------------------------------[stack]\n";
dump_stack(state);
const edb::address_t data_address = edb::v1::current_data_view_address();
std::cout << "[" << hex_string<quint16>(*state["ds"]) << ":" << hex_string(data_address) << "]---------------------------------------------------------[ data]\n";
dump_data(data_address);
std::cout << "[" << hex_string<quint16>(*state["cs"]) << ":" << hex_string(state.instruction_pointer()) << "]---------------------------------------------------------[ code]\n";
dump_code(state);
std::cout << "------------------------------------------------------------------------------\n";
}
static int ncp6335d_set_voltage(struct regulator_dev *rdev,
int min_uV, int max_uV, unsigned *selector)
{
int rc = 0, set_val, new_uV;
struct ncp6335d_info *dd = rdev_get_drvdata(rdev);
struct i2c_client *client = to_i2c_client(dd->dev);
set_val = DIV_ROUND_UP(min_uV - dd->min_voltage, dd->step_size);
new_uV = (set_val * dd->step_size) + dd->min_voltage;
if (new_uV > max_uV) {
dev_err(dd->dev, "Unable to set volatge (%d %d)\n",
min_uV, max_uV);
return -EINVAL;
}
mutex_lock(&dd->ncp_mutex);
if (dd->is_suspend) {
dev_info(dd->dev, "Ignore voltage setting after suspend: %d\n",
new_uV);
goto out;
}
rc = regmap_update_bits(dd->regmap, dd->vsel_reg,
NCP6335D_VOUT_SEL_MASK, (set_val & NCP6335D_VOUT_SEL_MASK));
if (rc) {
dev_err(dd->dev, "Unable to set volatge (%d %d), %x\n",
min_uV, max_uV, client->addr);
getAddr(client);
rc = regmap_update_bits(dd->regmap, dd->vsel_reg,
NCP6335D_VOUT_SEL_MASK, (set_val & NCP6335D_VOUT_SEL_MASK));
if (rc)
dev_err(dd->dev, "Unable to set volatge1 (%d %d), %x\n",
min_uV, max_uV, client->addr);
}
if (!rc) {
ncp633d_slew_delay(dd, dd->curr_voltage, new_uV);
dd->curr_voltage = new_uV;
}
dump_registers(dd, dd->vsel_reg, __func__);
out:
mutex_unlock(&dd->ncp_mutex);
return rc;
}
static int ncp6335d_get_voltage(struct regulator_dev *rdev)
{
unsigned int val;
int rc;
struct ncp6335d_info *dd = rdev_get_drvdata(rdev);
rc = ncp6335x_read(dd, dd->vsel_reg, &val);
if (rc) {
dev_err(dd->dev, "Unable to get volatge rc(%d)", rc);
return rc;
}
dd->curr_voltage = ((val & NCP6335D_VOUT_SEL_MASK) * dd->step_size) +
dd->min_voltage;
dump_registers(dd, dd->vsel_reg, __func__);
return dd->curr_voltage;
}
SNAPSHOT_LOAD_MEMBER( lviv_state, lviv )
{
std::vector<uint8_t> lviv_snapshot_data(LVIV_SNAPSHOT_SIZE);
image.fread( &lviv_snapshot_data[0], LVIV_SNAPSHOT_SIZE);
if (lviv_verify_snapshot(&lviv_snapshot_data[0], snapshot_size) != image_verify_result::PASS)
{
return image_init_result::FAIL;
}
lviv_setup_snapshot (&lviv_snapshot_data[0]);
dump_registers();
logerror("Snapshot file loaded\n");
return image_init_result::PASS;
}
static int fan53555_get_voltage(struct regulator_dev *rdev)
{
unsigned int val;
int ret;
struct fan53555_device_info *di = rdev_get_drvdata(rdev);
ret = regmap_read(di->regmap, di->vol_reg, &val);
if (ret) {
dev_err(di->dev, "Unable to get volatge rc(%d)", ret);
return ret;
}
di->curr_voltage = ((val & VSEL_NSEL_MASK) *
di->vsel_step) + di->vsel_min;
dump_registers(di, di->vol_reg, __func__);
return di->curr_voltage;
}
SNAPSHOT_LOAD_MEMBER( lviv_state, lviv )
{
dynamic_buffer lviv_snapshot_data(LVIV_SNAPSHOT_SIZE);
image.fread( &lviv_snapshot_data[0], LVIV_SNAPSHOT_SIZE);
if(lviv_verify_snapshot(&lviv_snapshot_data[0], snapshot_size) == IMAGE_VERIFY_FAIL)
{
return IMAGE_INIT_FAIL;
}
lviv_setup_snapshot (&lviv_snapshot_data[0]);
dump_registers();
logerror("Snapshot file loaded\n");
return IMAGE_INIT_PASS;
}
static int ncp6335d_get_voltage(struct regulator_dev *rdev)
{
unsigned int val;
int rc;
struct ncp6335d_info *dd = rdev_get_drvdata(rdev);
rc = regmap_read(dd->regmap, dd->vsel_reg, &val);
if (rc) {
dev_err(dd->dev, "Unable to get volatge rc(%d)", rc);
return rc;
}
dd->curr_voltage = ((val & NCP6335D_VOUT_SEL_MASK) *
NCP6335D_STEP_VOLTAGE_UV) + NCP6335D_MIN_VOLTAGE_UV;
dump_registers(dd, dd->vsel_reg, __func__);
return dd->curr_voltage;
}
static int ncp6335d_set_mode(struct regulator_dev *rdev,
unsigned int mode)
{
int rc;
struct ncp6335d_info *dd = rdev_get_drvdata(rdev);
struct i2c_client *client = to_i2c_client(dd->dev);
if (mode != REGULATOR_MODE_FAST && mode != REGULATOR_MODE_NORMAL) {
dev_err(dd->dev, "Mode %d not supported\n", mode);
return -EINVAL;
}
rc = regmap_update_bits(dd->regmap, REG_NCP6335D_COMMAND, dd->mode_bit,
(mode == REGULATOR_MODE_FAST) ? dd->mode_bit : 0);
if (rc) {
dev_err(dd->dev, "Unable to set operating mode rc(%d), %x", rc, client->addr);
getAddr(client);
rc = regmap_update_bits(dd->regmap, REG_NCP6335D_COMMAND, dd->mode_bit,
(mode == REGULATOR_MODE_FAST) ? dd->mode_bit : 0);
if (rc)
dev_err(dd->dev, "Unable to set operating mode rc1(%d), %x", rc, client->addr);
return rc;
}
rc = regmap_update_bits(dd->regmap, REG_NCP6335D_COMMAND,
NCP6335D_DVS_PWM_MODE,
(mode == REGULATOR_MODE_FAST) ?
NCP6335D_DVS_PWM_MODE : 0);
if (rc) {
dev_err(dd->dev, "Unable to set DVS trans. mode rc(%d), %x", rc, client->addr);
getAddr(client);
rc = regmap_update_bits(dd->regmap, REG_NCP6335D_COMMAND,
NCP6335D_DVS_PWM_MODE,
(mode == REGULATOR_MODE_FAST) ?
NCP6335D_DVS_PWM_MODE : 0);
if (rc)
dev_err(dd->dev, "Unable to set DVS trans. mode rc1(%d), %x", rc, client->addr);
}
dump_registers(dd, REG_NCP6335D_COMMAND, __func__);
return rc;
}
static unsigned int ncp6335d_get_mode(struct regulator_dev *rdev)
{
unsigned int val;
int rc;
struct ncp6335d_info *dd = rdev_get_drvdata(rdev);
rc = ncp6335x_read(dd, REG_NCP6335D_COMMAND, &val);
if (rc) {
dev_err(dd->dev, "Unable to get regulator mode rc(%d)\n", rc);
return rc;
}
dump_registers(dd, REG_NCP6335D_COMMAND, __func__);
if (val & dd->mode_bit)
return REGULATOR_MODE_FAST;
return REGULATOR_MODE_NORMAL;
}
static int ncp6335d_disable(struct regulator_dev *rdev)
{
int rc;
unsigned int temp = 0;
struct ncp6335d_info *dd = rdev_get_drvdata(rdev);
temp = dd->vsel_ctrl_val & ~NCP6335D_ENABLE;
rc = regmap_write(dd->regmap, dd->vsel_reg, temp);
if (rc) {
dev_err(dd->dev, "Unable to disable regualtor rc(%d)", rc);
return rc;
}
dd->vsel_ctrl_val = temp;
dump_registers(dd, dd->vsel_reg, __func__);
return rc;
}
static int fan53555_disable(struct regulator_dev *rdev)
{
int ret;
unsigned int temp = 0;
struct fan53555_device_info *di = rdev_get_drvdata(rdev);
temp = di->vsel_ctrl_val & ~FAN53555_ENABLE;
ret = regmap_write(di->regmap, di->vol_reg, temp);
if (ret) {
dev_err(di->dev, "Unable to disable regualtor rc(%d)", ret);
return ret;
}
di->vsel_ctrl_val = temp;
dump_registers(di, di->vol_reg, __func__);
return ret;
}
