/*! * This function reads the interrupt status registers of PMIC * and determine the current active events. * * @param active_events array pointer to be used to return active * event numbers. * * @return This function returns PMIC version. */ unsigned int pmic_get_active_events(unsigned int *active_events) { unsigned int count = 0; unsigned int status0, status1; int bit_set; pmic_read(REG_INTERRUPT_STATUS_0, &status0); pmic_read(REG_INTERRUPT_STATUS_1, &status1); pmic_write(REG_INTERRUPT_STATUS_0, status0); pmic_write(REG_INTERRUPT_STATUS_1, status1); status0 &= events_enabled0; status1 &= events_enabled1; while (status0) { bit_set = ffs(status0) - 1; *(active_events + count) = bit_set; count++; status0 ^= (1 << bit_set); } while (status1) { bit_set = ffs(status1) - 1; *(active_events + count) = bit_set + 24; count++; status1 ^= (1 << bit_set); } return count; }
void toshiba_pmic_gpio_init(unsigned gpio) { pmic_write(gpio,0x85); pmic_write(gpio,0x98); pmic_write(gpio,0xB8); pmic_write(gpio,0xC6); }
/*! * This function initializes the PMIC registers. * * @return None */ int pmic_init_registers(void) { CHECK_ERROR(pmic_write(REG_INTERRUPT_MASK_0, MXC_PMIC_FRAME_MASK)); CHECK_ERROR(pmic_write(REG_INTERRUPT_MASK_1, MXC_PMIC_FRAME_MASK)); CHECK_ERROR(pmic_write(REG_INTERRUPT_STATUS_0, MXC_PMIC_FRAME_MASK)); CHECK_ERROR(pmic_write(REG_INTERRUPT_STATUS_1, MXC_PMIC_FRAME_MASK)); return PMIC_SUCCESS; }
void panel_backlight(int on) { unsigned char reg_data = 0xA0; if (on) pmic_write(0x132, reg_data); else pmic_write(0x132, 0); }
//[*]----------------------------------------------------------------------------------------------[*] //[*]----------------------------------------------------------------------------------------------[*] void pmic_init(void) { unsigned char rwdata; gpio_i2c_set_sda(HIGH); gpio_i2c_set_clk(HIGH); rwdata = 0x08; // reset delay changed : 7sec to 3sec pmic_write(0x0A, &rwdata, 1); rwdata = 0x14; // 1.8V Enable pmic_write(0x53, &rwdata, 1); // EMMC }
//[*]----------------------------------------------------------------------------------------------[*] //[*]----------------------------------------------------------------------------------------------[*] void emmc_pwr_reset(void) { unsigned char rwdata; gpio_i2c_set_sda(HIGH); gpio_i2c_set_clk(HIGH); rwdata = 0x14; // 1.8V Enable pmic_write(0x53, &rwdata, 1); // EMMC rwdata = 0x00; // 1.8V Enable // pmic_write(0x34, &rwdata, 1); // BUCK7 3.0V pmic_write(0x36, &rwdata, 1); // BUCK8 3.0V }
static int sharp_display_common_power(int on) { int rc = 0, flag_on = !!on; static int display_common_power_save_on; unsigned int vreg_ldo12, vreg_ldo15, vreg_ldo20, vreg_ldo16, vreg_ldo8; if (display_common_power_save_on == flag_on) return 0; display_common_power_save_on = flag_on; if (on) { /* set LCD reset */ rc = gpio_tlmm_config(lcd_reset_gpio, GPIO_ENABLE); if (rc) { return rc; } gpio_set(LCD_RESET, 0); /* bring reset line low to hold reset */ /* set VEE reset */ rc = gpio_tlmm_config(vee_reset_gpio, GPIO_ENABLE); if (rc) { return rc; } gpio_set(VEE_RESET, 1); gpio_set(VEE_RESET, 0); /* bring reset line low to hold reset */ mdelay(10); } /* Set LD008 to 1.8V - VEE (VCC, VDDIO, pullups) */ pmic_write(LDO08_CNTRL, 0x06 | LDO_LOCAL_EN_BMSK); /* Set LD012 to 1.8V - display (VDDIO) */ pmic_write(LDO12_CNTRL, 0x06 | LDO_LOCAL_EN_BMSK); /* Set LD015 to 3.0V - display (VCC), VEE (VLP) */ pmic_write(LDO15_CNTRL, 0x1E | LDO_LOCAL_EN_BMSK); /* wait for power to stabilize */ mdelay(10); gpio_config(VEE_RESET, 0); /*disable VEE_RESET, rely on pullups to bring it high */ mdelay(5); gpio_set(LCD_RESET, 1); /* bring reset line high */ mdelay(10); /* 10 msec before IO can be accessed */ return rc; }
int mc13892_init_registers(void) { CHECK_ERROR(pmic_write(REG_INT_MASK0, 0xFFFFFF)); CHECK_ERROR(pmic_write(REG_INT_MASK0, 0xFFFFFF)); CHECK_ERROR(pmic_write(REG_INT_STATUS0, 0xFFFFFF)); CHECK_ERROR(pmic_write(REG_INT_STATUS1, 0xFFFFFF)); /* disable auto charge */ if (machine_is_mx51_3ds()) CHECK_ERROR(pmic_write(REG_CHARGE, 0xB40003)); pm_power_off = mc13892_power_off; return PMIC_SUCCESS; }
void sharp_lcdc_on(void) { lcdc_clock_init(27648000); sharp_lcdc_panel_power(1); /*enable backlight, open up gpio, use default for LPG */ pmic_write(GPIO26_GPIO_CNTRL, 0x81); /* Write, Bank0, VIN0=VPH, Mode selection enabled */ pmic_write(GPIO26_GPIO_CNTRL, 0x99); /* Write, Bank1, OutOn/InOff, CMOS, Invert Output (GPIO High) */ pmic_write(GPIO26_GPIO_CNTRL, 0xAA); /* Write, Bank2, GPIO no pull */ pmic_write(GPIO26_GPIO_CNTRL, 0xB4); /* Write, Bank3, high drv strength */ pmic_write(GPIO26_GPIO_CNTRL, 0xC6); /* Write, Bank4, Src: Special Function 2 */ sharp_lcdc_disp_on(); }
/* Test PMIC I/O */ static int dm_test_power_pmic_io(struct unit_test_state *uts) { const char *name = "sandbox_pmic"; uint8_t out_buffer, in_buffer; struct udevice *dev; int reg_count, i; ut_assertok(pmic_get(name, &dev)); reg_count = pmic_reg_count(dev); ut_asserteq(reg_count, SANDBOX_PMIC_REG_COUNT); /* * Test PMIC I/O - write and read a loop counter. * usually we can't write to all PMIC's registers in the real hardware, * but we can to the sandbox pmic. */ for (i = 0; i < reg_count; i++) { out_buffer = i; ut_assertok(pmic_write(dev, i, &out_buffer, 1)); ut_assertok(pmic_read(dev, i, &in_buffer, 1)); ut_asserteq(out_buffer, in_buffer); } return 0; }
//[*]----------------------------------------------------------------------------------------------[*] int pmic_read (unsigned char reg, unsigned char *rdata, unsigned char rsize) { unsigned char ack, cnt; // register pointer write if(pmic_write(reg, NULL, 0)) goto read_stop; // restart gpio_i2c_start(); gpio_i2c_byte_write(MAX77687_ADDR + I2C_READ); // i2c address if((ack = gpio_i2c_chk_ack())) goto read_stop; for(cnt=0; cnt < rsize; cnt++) { gpio_i2c_byte_read(&rdata[cnt]); if(cnt == rsize -1) gpio_i2c_send_noack(); else gpio_i2c_send_ack(); } read_stop: gpio_i2c_stop(); return ack; }
static ssize_t pmic_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int reg, value, ret; char *p; reg = simple_strtoul(buf, NULL, 10); p = NULL; p = memchr(buf, ' ', count); if (p == NULL) { pmic_read(reg, &value); pr_debug("reg%02d: %06x\n", reg, value); return count; } p += 1; value = simple_strtoul(p, NULL, 16); ret = pmic_write(reg, value); if (ret == 0) pr_debug("write reg%02d: %06x\n", reg, value); else pr_debug("register update failed\n"); return count; }
static int s2mps11_buck_mode(struct udevice *dev, int op, int *opmode) { unsigned int addr, mode; unsigned char val; int buck, ret; buck = dev->driver_data; if (buck < 1 || buck > S2MPS11_BUCK_NUM) { pr_err("Wrong buck number: %d\n", buck); return -EINVAL; } addr = s2mps11_buck_ctrl[buck]; ret = pmic_read(dev->parent, addr, &val, 1); if (ret) return ret; if (op == PMIC_OP_GET) { val &= (S2MPS11_BUCK_MODE_MASK << S2MPS11_BUCK_MODE_SHIFT); switch (val) { case S2MPS11_BUCK_MODE_OFF: *opmode = OP_OFF; break; case S2MPS11_BUCK_MODE_STANDBY: *opmode = OP_STANDBY; break; case S2MPS11_BUCK_MODE_ON: *opmode = OP_ON; break; default: return -EINVAL; } return 0; } switch (*opmode) { case OP_OFF: mode = S2MPS11_BUCK_MODE_OFF; break; case OP_STANDBY: mode = S2MPS11_BUCK_MODE_STANDBY; break; case OP_ON: mode = S2MPS11_BUCK_MODE_ON; break; default: pr_err("Wrong mode: %d for buck: %d\n", *opmode, buck); return -EINVAL; } val &= ~(S2MPS11_BUCK_MODE_MASK << S2MPS11_BUCK_MODE_SHIFT); val |= mode; ret = pmic_write(dev->parent, addr, &val, 1); return ret; }
static int display_common_power(int on) { int rc = 0, flag_on = !!on; static int display_common_power_save_on; unsigned int vreg_ldo12, vreg_ldo15, vreg_ldo20, vreg_ldo16, vreg_ldo8; if (display_common_power_save_on == flag_on) return 0; display_common_power_save_on = flag_on; if (on) { /* reset Toshiba WeGA chip -- toggle reset pin -- gpio_180 */ rc = gpio_tlmm_config(wega_reset_gpio, GPIO_ENABLE); if (rc) { return rc; } gpio_set(180, 0); /* bring reset line low to hold reset */ } // Set power for WEGA chip. // Set LD020 to 1.5V pmic_write(LDO20_CNTRL, 0x00 | LDO_LOCAL_EN_BMSK); mdelay(5); // Set LD012 to 1.8V pmic_write(LDO12_CNTRL, 0x06 | LDO_LOCAL_EN_BMSK); mdelay(5); // Set LD016 to 2.6V pmic_write(LDO16_CNTRL, 0x16 | LDO_LOCAL_EN_BMSK); mdelay(5); // Set LD015 to 3.0V pmic_write(LDO15_CNTRL, 0x1E | LDO_LOCAL_EN_BMSK); mdelay(5); gpio_set(180, 1); /* bring reset line high */ mdelay(10); /* 10 msec before IO can be accessed */ if (rc) { return rc; } return rc; }
static int max77686_buck_val(struct udevice *dev, int op, int *uV) { unsigned int hex, ret, mask, adr; unsigned char val; int buck; buck = dev->driver_data; if (buck < 1 || buck > MAX77686_BUCK_NUM) { error("Wrong buck number: %d", buck); return -EINVAL; } if (op == PMIC_OP_GET) *uV = 0; /* &buck_out = ctrl + 1 */ adr = max77686_buck_addr[buck] + 1; /* mask */ switch (buck) { case 2: case 3: case 4: /* Those use voltage scallers - will support in the future */ mask = MAX77686_BUCK234_VOLT_MASK; return -ENOSYS; default: mask = MAX77686_BUCK_VOLT_MASK; } ret = pmic_read(dev->parent, adr, &val, 1); if (ret) return ret; if (op == PMIC_OP_GET) { val &= mask; ret = max77686_buck_hex2volt(buck, val); if (ret < 0) return ret; *uV = ret; return 0; } hex = max77686_buck_volt2hex(buck, *uV); if (hex < 0) return hex; val &= ~mask; val |= hex; ret = pmic_write(dev->parent, adr, &val, 1); return ret; }
static int s2mps11_buck_val(struct udevice *dev, int op, int *uV) { int hex, buck, ret; u32 mask, addr; u8 val; buck = dev->driver_data; if (buck < 1 || buck > S2MPS11_BUCK_NUM) { pr_err("Wrong buck number: %d\n", buck); return -EINVAL; } if (op == PMIC_OP_GET) *uV = 0; addr = s2mps11_buck_out[buck]; switch (buck) { case 9: mask = S2MPS11_BUCK9_VOLT_MASK; break; default: mask = S2MPS11_BUCK_VOLT_MASK; break; } ret = pmic_read(dev->parent, addr, &val, 1); if (ret) return ret; if (op == PMIC_OP_GET) { val &= mask; ret = s2mps11_buck_hex2volt(buck, val); if (ret < 0) return ret; *uV = ret; return 0; } hex = s2mps11_buck_volt2hex(buck, *uV); if (hex < 0) return hex; val &= ~mask; val |= hex; ret = pmic_write(dev->parent, addr, &val, 1); return ret; }
static int max77686_ldo_val(struct udevice *dev, int op, int *uV) { unsigned int ret, hex, adr; unsigned char val; int ldo; if (op == PMIC_OP_GET) *uV = 0; ldo = dev->driver_data; if (ldo < 1 || ldo > MAX77686_LDO_NUM) { error("Wrong ldo number: %d", ldo); return -EINVAL; } adr = MAX77686_REG_PMIC_LDO1CTRL1 + ldo - 1; ret = pmic_read(dev->parent, adr, &val, 1); if (ret) return ret; if (op == PMIC_OP_GET) { val &= MAX77686_LDO_VOLT_MASK; ret = max77686_ldo_hex2volt(ldo, val); if (ret < 0) return ret; *uV = ret; return 0; } hex = max77686_ldo_volt2hex(ldo, *uV); if (hex < 0) return hex; val &= ~MAX77686_LDO_VOLT_MASK; val |= hex; ret = pmic_write(dev->parent, adr, &val, 1); return ret; }
int __devinit pmic_init_registers(void) { /* * Set some registers to what they should be, * if for no other reason than to initialize our * software register copies. */ CHECK_ERROR(pmic_write(REG_MC34704_GENERAL2, 0x09)); CHECK_ERROR(pmic_write(REG_MC34704_VGSET1, 0)); CHECK_ERROR(pmic_write(REG_MC34704_REG2SET1, 0)); CHECK_ERROR(pmic_write(REG_MC34704_REG3SET1, 0)); CHECK_ERROR(pmic_write(REG_MC34704_REG4SET1, 0)); CHECK_ERROR(pmic_write(REG_MC34704_REG5SET1, 0)); return PMIC_SUCCESS; }
static int pmic_disable_charger(struct pmic_charger *charger) { int i; struct pmic_cfg *cfg; struct pmic_charger_platform_data *pdata = charger->pdata; if (pdata->disable) pdata->disable(); for (i = 0; i < pdata->disable_ncfgs; i++) { cfg = &pdata->disable_cfgs[i]; pmic_write(charger->master, cfg->reg, cfg->val); } led_trigger_event(charger->led, LED_OFF); pmic_sysfs_changed(); wake_unlock(&charger->wakelock); return 0; }
static int s2mps11_ldo_val(struct udevice *dev, int op, int *uV) { unsigned int addr; unsigned char val; int hex, ldo, ret; ldo = dev->driver_data; if (ldo < 1 || ldo > S2MPS11_LDO_NUM) { pr_err("Wrong ldo number: %d\n", ldo); return -EINVAL; } addr = S2MPS11_REG_L1CTRL + ldo - 1; ret = pmic_read(dev->parent, addr, &val, 1); if (ret) return ret; if (op == PMIC_OP_GET) { *uV = 0; val &= S2MPS11_LDO_VOLT_MASK; ret = s2mps11_ldo_hex2volt(ldo, val); if (ret < 0) return ret; *uV = ret; return 0; } hex = s2mps11_ldo_volt2hex(ldo, *uV); if (hex < 0) return hex; val &= ~S2MPS11_LDO_VOLT_MASK; val |= hex; ret = pmic_write(dev->parent, addr, &val, 1); return ret; }
/*! * This function is called by PMIC clients to write a register on PMIC. * * @param reg number of register * @param reg_value New value of register * @param reg_mask Bitmap mask indicating which bits to modify * * @return This function returns PMIC_SUCCESS if successful. */ PMIC_STATUS pmic_write_reg(int reg, unsigned int reg_value, unsigned int reg_mask) { int ret = 0; unsigned int temp = 0; ret = pmic_read(reg, &temp); if (ret != PMIC_SUCCESS) { return PMIC_ERROR; } temp = (temp & (~reg_mask)) | reg_value; #ifdef CONFIG_MXC_PMIC_MC13783 if (reg == REG_POWER_MISCELLANEOUS) temp &= 0xFFFE7FFF; #endif ret = pmic_write(reg, temp); if (ret != PMIC_SUCCESS) { return PMIC_ERROR; } pr_debug("Write REG[ %d ] = 0x%x\n", reg, reg_value); return ret; }
static int max77686_ldo_mode(struct udevice *dev, int op, int *opmode) { unsigned int ret, adr, mode; unsigned char val; int ldo; if (op == PMIC_OP_GET) *opmode = -EINVAL; ldo = dev->driver_data; if (ldo < 1 || ldo > MAX77686_LDO_NUM) { error("Wrong ldo number: %d", ldo); return -EINVAL; } adr = MAX77686_REG_PMIC_LDO1CTRL1 + ldo - 1; ret = pmic_read(dev->parent, adr, &val, 1); if (ret) return ret; if (op == PMIC_OP_GET) { val &= MAX77686_LDO_MODE_MASK; ret = max77686_ldo_hex2mode(ldo, val); if (ret < 0) return ret; *opmode = ret; return 0; } /* mode */ switch (*opmode) { case OPMODE_OFF: mode = MAX77686_LDO_MODE_OFF; break; case OPMODE_LPM: switch (ldo) { case 2: case 6: case 7: case 8: case 10: case 11: case 12: case 14: case 15: case 16: return -EINVAL; default: mode = MAX77686_LDO_MODE_LPM; } break; case OPMODE_STANDBY: switch (ldo) { case 2: case 6: case 7: case 8: case 10: case 11: case 12: case 14: case 15: case 16: mode = MAX77686_LDO_MODE_STANDBY; break; default: return -EINVAL; } break; case OPMODE_STANDBY_LPM: mode = MAX77686_LDO_MODE_STANDBY_LPM; break; case OPMODE_ON: mode = MAX77686_LDO_MODE_ON; break; default: mode = 0xff; } if (mode == 0xff) { error("Wrong mode: %d for ldo%d", *opmode, ldo); return -EINVAL; } val &= ~MAX77686_LDO_MODE_MASK; val |= mode; ret = pmic_write(dev->parent, adr, &val, 1); return ret; }
static int s2mps11_ldo_mode(struct udevice *dev, int op, int *opmode) { unsigned int addr, mode; unsigned char val; int ldo, ret; ldo = dev->driver_data; if (ldo < 1 || ldo > S2MPS11_LDO_NUM) { pr_err("Wrong ldo number: %d\n", ldo); return -EINVAL; } addr = S2MPS11_REG_L1CTRL + ldo - 1; ret = pmic_read(dev->parent, addr, &val, 1); if (ret) return ret; if (op == PMIC_OP_GET) { val &= (S2MPS11_LDO_MODE_MASK << S2MPS11_LDO_MODE_SHIFT); switch (val) { case S2MPS11_LDO_MODE_OFF: *opmode = OP_OFF; break; case S2MPS11_LDO_MODE_STANDBY: *opmode = OP_STANDBY; break; case S2MPS11_LDO_MODE_STANDBY_LPM: *opmode = OP_STANDBY_LPM; break; case S2MPS11_LDO_MODE_ON: *opmode = OP_ON; break; default: return -EINVAL; } return 0; } switch (*opmode) { case OP_OFF: mode = S2MPS11_LDO_MODE_OFF; break; case OP_STANDBY: mode = S2MPS11_LDO_MODE_STANDBY; break; case OP_STANDBY_LPM: mode = S2MPS11_LDO_MODE_STANDBY_LPM; break; case OP_ON: mode = S2MPS11_LDO_MODE_ON; break; default: pr_err("Wrong mode: %d for ldo: %d\n", *opmode, ldo); return -EINVAL; } val &= ~(S2MPS11_LDO_MODE_MASK << S2MPS11_LDO_MODE_SHIFT); val |= mode; ret = pmic_write(dev->parent, addr, &val, 1); return ret; }