/*!
* 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;
}
