static void max77828_rgb_set(struct max77828_led_data *led_data)
{
int ret;
int id = led_data->data->id;
u8 reg;
u8 bit = 0;
switch(id)
{
case MAX77828_RGB_R:
reg = MAX77828_LED_REG_LED1BRT;
bit = 1<<1;
break;
case MAX77828_RGB_G:
reg = MAX77828_LED_REG_LED2BRT;
bit = 1<<2;
break;
case MAX77828_RGB_B:
reg = MAX77828_LED_REG_LED3BRT;
bit = 1<<3;
break;
default :
printk("(%s) : Not valid LED ID\n",__func__);
break;
}
if((enum led_brightness)led_data->test_brightness == LED_OFF)
{
printk("(%s) LED_OFF\n",__func__);
/* LED OFF */
ret = max77828_update_reg(led_data->i2c, MAX77828_LED_REG_LEDEN, 0, bit);
if(IS_ERR_VALUE(ret))
pr_err("(%s) : LED Bit 0x%02x update failed\n",__func__, bit );
}
else
{
/* Set Current*/
ret = max77828_write_reg(led_data->i2c, reg, (unsigned int)led_data->test_brightness);
if(IS_ERR_VALUE(ret))
pr_err("(%s) : write failed\n",__func__);
/* LEDBLNK ON */
ret = max77828_write_reg(led_data->i2c, MAX77828_LED_REG_LEDBLNK, 0x50);
if(IS_ERR_VALUE(ret))
pr_err("(%s) : LED Bit %x update failed\n",__func__, bit );
/* LEDRMP ON */
ret = max77828_write_reg(led_data->i2c, MAX77828_LED_REG_LEDRMP, 0x00);
if(IS_ERR_VALUE(ret))
pr_err("(%s) : LED Bit %x update failed\n",__func__, bit );
ret = max77828_read_reg(led_data->i2c, MAX77828_LED_REG_LEDEN, ®);
bit |= reg;
/* LED ON */
ret = max77828_write_reg(led_data->i2c, MAX77828_LED_REG_LEDEN, bit);
if(IS_ERR_VALUE(ret))
pr_err("(%s) : LED Bit %x update failed\n",__func__, bit );
}
return;
}
static int max77828_rgb_blink(struct led_classdev *led_cdev, unsigned long
*delay_on, unsigned long *delay_off)
{
u8 val;
int ret;
struct max77828_led_data *led_data = container_of(led_cdev, struct max77828_led_data, led);
if(*delay_on==0 && *delay_off==0)
{
ret = max77828_read_reg(led_data->i2c, MAX77828_LED_REG_LEDBLNK, &val);
if(IS_ERR_VALUE(ret))
pr_err("(%s) : LED Enable Bit read failed\n",__func__ );
printk("(%s) LED Blink reg (0x%02x)\n",__func__,val);
*delay_on = (val & MAX77828_LEDBLINKD) * 200;
val = (val & MAX77828_LEDBLINKP);
printk("(%s) LED Blink reg (blink pd. : 0x%02x)(delay: 0x%02lx)\n",__func__,val, *delay_on);
if(val <= 0x0A)
val = val * 500 + 1000;
else if (val <= 0x0C)
val = (val - 0x0A) * 1000 + 6000;
else if (val <= 0x0E)
val = (val - 0x0C) * 2000 + 8000;
else
val = *delay_on;
*delay_off = val - *delay_on;
}
else
{
if (unlikely(*delay_on > 3000))
return -EINVAL;
val = *delay_on + *delay_off;
if (val <= 6000)
val = (val - 1000) / 500;
else if (val < 8000)
val = (val - 6000) / 1000;
else if (val < 12000)
val = (val - 8000) / 2000;
else
return -EINVAL;
val |= (*delay_on / 200);
ret = max77828_write_reg(led_data->i2c, MAX77828_LED_REG_LEDBLNK, val);
if(IS_ERR_VALUE(ret))
{
pr_err("(%s) : LED write failed\n",__func__ );
return ret;
}
}
return 0;
}
static unsigned int max77828_rgb_get(struct led_classdev *led_cdev)
{
const struct device *parent = led_cdev->dev->parent;
struct max77828_rgb *max77828_rgb = dev_get_drvdata(parent);
struct device *dev;
int n;
int ret;
u8 value;
ret = max77828_rgb_number(led_cdev, &max77828_rgb);
if (IS_ERR_VALUE(ret)) {
dev_err(led_cdev->dev,
"max77828_rgb_number() returns %d.\n", ret);
return 0;
}
n = ret;
dev = led_cdev->dev;
/* Get status */
ret = max77828_read_reg(max77828_rgb->i2c,
MAX77828_RGBLED_REG_LEDEN, &value);
if (IS_ERR_VALUE(ret)) {
dev_err(dev, "can't read LEDEN : %d\n", ret);
return 0;
}
if (!(value & (1 << n)))
return LED_OFF;
/* Get current */
ret = max77828_read_reg(max77828_rgb->i2c,
MAX77828_RGBLED_REG_LED0BRT + n, &value);
if (IS_ERR_VALUE(ret)) {
dev_err(dev, "can't read LED0BRT : %d\n", ret);
return 0;
}
return value;
}
static int max77828_freeze(struct device *dev)
{
struct i2c_client *i2c = container_of(dev, struct i2c_client, dev);
struct max77828_dev *max77828 = i2c_get_clientdata(i2c);
int i;
for (i = 0; i < ARRAY_SIZE(max77828_dumpaddr_pmic); i++)
max77828_read_reg(i2c, max77828_dumpaddr_pmic[i],
&max77828->reg_pmic_dump[i]);
for (i = 0; i < ARRAY_SIZE(max77828_dumpaddr_muic); i++)
max77828_read_reg(i2c, max77828_dumpaddr_muic[i],
&max77828->reg_muic_dump[i]);
for (i = 0; i < ARRAY_SIZE(max77828_dumpaddr_led); i++)
max77828_read_reg(i2c, max77828_dumpaddr_led[i],
&max77828->reg_led_dump[i]);
disable_irq(max77828->irq);
return 0;
}
static void print_all_reg_value(struct i2c_client *client)
{
u8 value;
u8 i;
for (i = 2; i != 0x36; ++i) {
max77828_read_reg(client, i, &value);
printk(KERN_ERR "LEDS_MAX77828 REG(%x) = %x\n", i, value);
if(i==0x12)
i=0x2F;
value = 0;
}
}
static void max77828_haptic_i2c(struct max77828_haptic_data *hap_data, bool en)
{
int ret;
u8 value = hap_data->reg;
pr_debug("[VIB] %s %d\n", __func__, en);
if (en)
value = 0xC3;
ret = max77828_write_reg(hap_data->i2c, MAX77828_PMIC_REG_MCONFIG, value);
if (ret)
pr_err("[VIB] i2c write error %d\n", ret);
ret = max77828_read_reg(hap_data->i2c, MAX77828_PMIC_REG_MCONFIG, &value);
if (ret)
pr_err("[VIB] i2c read error %d\n", ret);
}
static int max77828_i2c_probe(struct i2c_client *i2c,
const struct i2c_device_id *dev_id)
{
struct max77828_dev *max77828;
struct max77828_platform_data *pdata = i2c->dev.platform_data;
u8 reg_data;
int ret = 0;
pr_info("%s:%s\n", MFD_DEV_NAME, __func__);
max77828 = kzalloc(sizeof(struct max77828_dev), GFP_KERNEL);
if (!max77828) {
dev_err(&i2c->dev, "%s: Failed to alloc mem for max77828\n", __func__);
return -ENOMEM;
}
if (i2c->dev.of_node) {
pdata = devm_kzalloc(&i2c->dev, sizeof(struct max77828_platform_data),
GFP_KERNEL);
if (!pdata) {
dev_err(&i2c->dev, "Failed to allocate memory \n");
ret = -ENOMEM;
goto err;
}
ret = of_max77828_dt(&i2c->dev, pdata);
if (ret < 0){
dev_err(&i2c->dev, "Failed to get device of_node \n");
return ret;
}
i2c->dev.platform_data = pdata;
} else
pdata = i2c->dev.platform_data;
max77828->dev = &i2c->dev;
max77828->i2c = i2c;
max77828->irq = i2c->irq;
if (pdata) {
max77828->pdata = pdata;
pdata->irq_base = irq_alloc_descs(-1, 0, MAX77828_IRQ_NR, -1);
if (pdata->irq_base < 0) {
pr_err("%s:%s irq_alloc_descs Fail! ret(%d)\n",
MFD_DEV_NAME, __func__, pdata->irq_base);
ret = -EINVAL;
goto err;
} else
max77828->irq_base = pdata->irq_base;
max77828->irq_gpio = pdata->irq_gpio;
max77828->wakeup = pdata->wakeup;
} else {
ret = -EINVAL;
goto err;
}
mutex_init(&max77828->i2c_lock);
i2c_set_clientdata(i2c, max77828);
if (max77828_read_reg(i2c, MAX77828_PMIC_REG_PMICREV, ®_data) < 0) {
dev_err(max77828->dev,
"device not found on this channel (this is not an error)\n");
ret = -ENODEV;
goto err;
} else {
/* print rev */
max77828->pmic_rev = (reg_data & 0x7);
max77828->pmic_ver = ((reg_data & 0xF8) >> 0x3);
pr_info("%s:%s device found: rev.0x%x, ver.0x%x\n",
MFD_DEV_NAME, __func__,
max77828->pmic_rev, max77828->pmic_ver);
}
max77828->muic = i2c_new_dummy(i2c->adapter, I2C_ADDR_MUIC);
i2c_set_clientdata(max77828->muic, max77828);
max77828->led = i2c_new_dummy(i2c->adapter, I2C_ADDR_LED);
i2c_set_clientdata(max77828->led, max77828);
ret = max77828_irq_init(max77828);
if (ret < 0)
goto err_irq_init;
ret = mfd_add_devices(max77828->dev, -1, max77828_devs,
ARRAY_SIZE(max77828_devs), NULL, 0, NULL);
if (ret < 0)
goto err_mfd;
device_init_wakeup(max77828->dev, pdata->wakeup);
return ret;
err_mfd:
mfd_remove_devices(max77828->dev);
err_irq_init:
i2c_unregister_device(max77828->muic);
i2c_unregister_device(max77828->led);
err:
kfree(max77828);
return ret;
}
static int max77828_i2c_probe(struct i2c_client *i2c,
const struct i2c_device_id *id)
{
struct max77828_dev *max77828;
struct max77828_platform_data *pdata = i2c->dev.platform_data;
u8 reg_data;
int ret = 0;
dev_info(&i2c->dev, "%s\n", __func__);
max77828 = kzalloc(sizeof(struct max77828_dev), GFP_KERNEL);
if (!max77828) {
dev_err(&i2c->dev, "%s: Failed to alloc mem for max77828\n", __func__);
return -ENOMEM;
}
if (i2c->dev.of_node) {
pdata = devm_kzalloc(&i2c->dev, sizeof(struct max77828_platform_data),
GFP_KERNEL);
if (!pdata) {
dev_err(&i2c->dev, "Failed to allocate memory \n");
ret = -ENOMEM;
goto err;
}
ret = of_max77828_dt(&i2c->dev, pdata);
if (ret < 0){
dev_err(&i2c->dev, "Failed to get device of_node \n");
return ret;
}
/*pdata update to other modules*/
pdata->muic_data = &max77828_muic;
#ifdef CONFIG_LEDS_MAX77828
pdata->led_data = &max77828_led_pdata;
#endif
i2c->dev.platform_data = pdata;
} else
pdata = i2c->dev.platform_data;
max77828->dev = &i2c->dev;
max77828->i2c = i2c;
max77828->irq = i2c->irq;
if (pdata) {
max77828->pdata = pdata;
max77828->irq_base = pdata->irq_base;
max77828->irq_gpio = pdata->irq_gpio;
max77828->wakeup = pdata->wakeup;
gpio_tlmm_config(GPIO_CFG(max77828->irq_gpio, 0, GPIO_CFG_INPUT,
GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_DISABLE);
} else {
ret = -EINVAL;
goto err;
}
mutex_init(&max77828->iolock);
i2c_set_clientdata(i2c, max77828);
if (max77828_read_reg(i2c, MAX77828_PMIC_REG_PMICREV, ®_data) < 0) {
dev_err(max77828->dev,
"device not found on this channel (this is not an error)\n");
ret = -ENODEV;
goto err;
} else {
/* print rev */
max77828->pmic_rev = (reg_data & 0x7);
max77828->pmic_ver = ((reg_data & 0xF8) >> 0x3);
pr_info("%s: device found: rev.0x%x, ver.0x%x\n", __func__,
max77828->pmic_rev, max77828->pmic_ver);
}
max77828->muic = i2c_new_dummy(i2c->adapter, I2C_ADDR_MUIC);
i2c_set_clientdata(max77828->muic, max77828);
max77828->led = i2c_new_dummy(i2c->adapter, I2C_ADDR_LED);
i2c_set_clientdata(max77828->led, max77828);
ret = max77828_irq_init(max77828);
if (ret < 0)
goto err_irq_init;
ret = mfd_add_devices(max77828->dev, -1, max77828_devs,
ARRAY_SIZE(max77828_devs), NULL, 0);
if (ret < 0)
goto err_mfd;
device_init_wakeup(max77828->dev, pdata->wakeup);
return ret;
err_mfd:
mfd_remove_devices(max77828->dev);
max77828_irq_exit(max77828);
err_irq_init:
i2c_unregister_device(max77828->muic);
i2c_unregister_device(max77828->led);
err:
kfree(max77828);
return ret;
}
