static int max77843_rgb_ramp(struct device *dev, int ramp_up, int ramp_down)
{
struct max77843_rgb *max77843_rgb = dev_get_drvdata(dev);
int value;
int ret;
pr_info("leds-max77843-rgb: %s\n", __func__);
if (ramp_up <= 800) {
ramp_up /= 100;
} else {
ramp_up = (ramp_up - 800) * 2 + 800;
ramp_up /= 100;
}
if (ramp_down <= 800) {
ramp_down /= 100;
} else {
ramp_down = (ramp_down - 800) * 2 + 800;
ramp_down /= 100;
}
value = (ramp_down) | (ramp_up << 4);
ret = max77843_write_reg(max77843_rgb->i2c,
MAX77843_RGBLED_REG_LEDRMP, value);
if (IS_ERR_VALUE(ret)) {
dev_err(dev, "can't write REG_LEDRMP : %d\n", ret);
return -ENODEV;
}
return 0;
}
static int max77843_restore(struct device *dev)
{
struct i2c_client *i2c = container_of(dev, struct i2c_client, dev);
struct max77843_dev *max77843 = i2c_get_clientdata(i2c);
int i;
enable_irq(max77843->irq);
for (i = 0; i < ARRAY_SIZE(max77843_dumpaddr_pmic); i++)
max77843_write_reg(i2c, max77843_dumpaddr_pmic[i],
max77843->reg_pmic_dump[i]);
for (i = 0; i < ARRAY_SIZE(max77843_dumpaddr_muic); i++)
max77843_write_reg(i2c, max77843_dumpaddr_muic[i],
max77843->reg_muic_dump[i]);
for (i = 0; i < ARRAY_SIZE(max77843_dumpaddr_led); i++)
max77843_write_reg(i2c, max77843_dumpaddr_led[i],
max77843->reg_led_dump[i]);
return 0;
}
static void max77843_rgb_set(struct led_classdev *led_cdev,
unsigned int brightness)
{
const struct device *parent = led_cdev->dev->parent;
struct max77843_rgb *max77843_rgb = dev_get_drvdata(parent);
struct device *dev;
int n;
int ret;
ret = max77843_rgb_number(led_cdev, &max77843_rgb);
if (IS_ERR_VALUE(ret)) {
dev_err(led_cdev->dev,
"max77843_rgb_number() returns %d.\n", ret);
return;
}
dev = led_cdev->dev;
n = ret;
if (brightness == LED_OFF) {
/* Flash OFF */
ret = max77843_update_reg(max77843_rgb->i2c,
MAX77843_RGBLED_REG_LEDEN, 0 , 3 << (2*n));
if (IS_ERR_VALUE(ret)) {
dev_err(dev, "can't write LEDEN : %d\n", ret);
return;
}
} else {
/* Set current */
if (n==BLUE && (lcdtype_color != 51))
brightness = (brightness * 5) / 2;
ret = max77843_write_reg(max77843_rgb->i2c,
MAX77843_RGBLED_REG_LED0BRT + n, brightness);
if (IS_ERR_VALUE(ret)) {
dev_err(dev, "can't write LEDxBRT : %d\n", ret);
return;
}
/* Flash ON */
ret = max77843_update_reg(max77843_rgb->i2c,
MAX77843_RGBLED_REG_LEDEN, 0x55, 3 << (2*n));
if (IS_ERR_VALUE(ret)) {
dev_err(dev, "can't write FLASH_EN : %d\n", ret);
return;
}
}
}
static void max77843_irq_sync_unlock(struct irq_data *data)
{
struct max77843_dev *max77843 = irq_get_chip_data(data->irq);
int i;
for (i = 0; i < MAX77843_IRQ_GROUP_NR; i++) {
u8 mask_reg = max77843_mask_reg[i];
struct i2c_client *i2c = get_i2c(max77843, i);
if (mask_reg == MAX77843_REG_INVALID ||
IS_ERR_OR_NULL(i2c))
continue;
max77843->irq_masks_cache[i] = max77843->irq_masks_cur[i];
max77843_write_reg(i2c, max77843_mask_reg[i],
max77843->irq_masks_cur[i]);
}
mutex_unlock(&max77843->irqlock);
}
static int max77843_rgb_blink(struct device *dev,
unsigned int delay_on, unsigned int delay_off)
{
struct max77843_rgb *max77843_rgb = dev_get_drvdata(dev);
int value;
int ret = 0;
pr_info("leds-max77843-rgb: %s\n", __func__);
if( delay_on > 3250 || delay_off > 12000 )
return -EINVAL;
else {
value = (LEDBLNK_ON(delay_on) << 4) | LEDBLNK_OFF(delay_off);
ret = max77843_write_reg(max77843_rgb->i2c,
MAX77843_RGBLED_REG_LEDBLNK, value);
if (IS_ERR_VALUE(ret)) {
dev_err(dev, "can't write REG_LEDBLNK : %d\n", ret);
return -EINVAL;
}
}
return ret;
}
int max77843_irq_init(struct max77843_dev *max77843)
{
int i;
int cur_irq;
int ret;
u8 i2c_data;
pr_info("func: %s, irq_gpio: %d, irq_base: %d\n", __func__,
max77843->irq_gpio, max77843->irq_base);
if (!max77843->irq_gpio) {
dev_warn(max77843->dev, "No interrupt specified.\n");
max77843->irq_base = 0;
return 0;
}
if (!max77843->irq_base) {
dev_err(max77843->dev, "No interrupt base specified.\n");
return 0;
}
mutex_init(&max77843->irqlock);
max77843->irq = gpio_to_irq(max77843->irq_gpio);
ret = gpio_request(max77843->irq_gpio, "if_pmic_irq");
if (ret) {
dev_err(max77843->dev, "%s: failed requesting gpio %d\n",
__func__, max77843->irq_gpio);
return ret;
}
gpio_direction_input(max77843->irq_gpio);
gpio_free(max77843->irq_gpio);
/* Mask individual interrupt sources */
for (i = 0; i < MAX77843_IRQ_GROUP_NR; i++) {
struct i2c_client *i2c;
/* MUIC IRQ 0:MASK 1:NOT MASK */
/* Other IRQ 1:MASK 0:NOT MASK */
if (i >= MAX77843_MUIC_INT1 && i <= MAX77843_MUIC_INT3) {
max77843->irq_masks_cur[i] = 0x00;
max77843->irq_masks_cache[i] = 0x00;
} else {
max77843->irq_masks_cur[i] = 0xff;
max77843->irq_masks_cache[i] = 0xff;
}
i2c = get_i2c(max77843, i);
if (IS_ERR_OR_NULL(i2c))
continue;
if (max77843_mask_reg[i] == MAX77843_REG_INVALID)
continue;
if (i >= MAX77843_MUIC_INT1 && i <= MAX77843_MUIC_INT3)
max77843_write_reg(i2c, max77843_mask_reg[i], 0x00);
else
max77843_write_reg(i2c, max77843_mask_reg[i], 0xff);
}
/* Register with genirq */
for (i = 0; i < MAX77843_IRQ_NR; i++) {
cur_irq = i + max77843->irq_base;
irq_set_chip_data(cur_irq, max77843);
irq_set_chip_and_handler(cur_irq, &max77843_irq_chip,
handle_edge_irq);
irq_set_nested_thread(cur_irq, 1);
#ifdef CONFIG_ARM
set_irq_flags(cur_irq, IRQF_VALID);
#else
irq_set_noprobe(cur_irq);
#endif
}
/* Unmask max77843 interrupt */
ret = max77843_read_reg(max77843->i2c, MAX77843_PMIC_REG_INTSRC_MASK,
&i2c_data);
if (ret) {
dev_err(max77843->dev, "%s: fail to read muic reg\n", __func__);
return ret;
}
i2c_data &= ~(MAX77843_IRQSRC_CHG); /* Unmask charger interrupt */
i2c_data &= ~(MAX77843_IRQSRC_FG); /* Unmask fuelgauge interrupt */
i2c_data &= ~(MAX77843_IRQSRC_MUIC); /* Unmask muic interrupt */
max77843_write_reg(max77843->i2c, MAX77843_PMIC_REG_INTSRC_MASK,
i2c_data);
ret = request_threaded_irq(max77843->irq, NULL, max77843_irq_thread,
IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
"max77843-irq", max77843);
if (ret) {
dev_err(max77843->dev, "Failed to request IRQ %d: %d\n",
max77843->irq, ret);
return ret;
}
return 0;
}
static irqreturn_t max77843_irq_thread(int irq, void *data)
{
struct max77843_dev *max77843 = data;
u8 irq_reg[MAX77843_IRQ_GROUP_NR] = {0};
u8 tmp_irq_reg[MAX77843_IRQ_GROUP_NR] = {};
#if defined(CONFIG_MUIC_MAX77843_SUPPORT_AFC_CHARGER)
u8 tmp_irq_mask_reg[MAX77843_IRQ_GROUP_NR] = {};
#endif /* CONFIG_MUIC_MAX77843_SUPPORT_AFC_CHARGER */
static int check_num;
u8 irq_src;
int i, ret;
pr_debug("%s: irq gpio pre-state(0x%02x)\n", __func__,
gpio_get_value(max77843->irq_gpio));
ret = max77843_read_reg(max77843->i2c,
MAX77843_PMIC_REG_INTSRC, &irq_src);
if (ret) {
pr_err("%s:%s Failed to read interrupt source: %d\n",
MFD_DEV_NAME, __func__, ret);
return IRQ_NONE;
}
#ifdef BATTERY_LOG_MESSAGE
pr_info("%s: interrupt source(0x%02x)\n", __func__, irq_src);
#endif
if (irq_src & MAX77843_IRQSRC_CHG) {
/* CHG_INT */
ret = max77843_read_reg(max77843->charger, MAX77843_CHG_REG_CHG_INT,
&irq_reg[CHG_INT]);
pr_info("%s: charger interrupt(0x%02x)\n",
__func__, irq_reg[CHG_INT]);
/* mask chgin to prevent chgin infinite interrupt
* chgin is unmasked chgin isr
*/
if (irq_reg[CHG_INT] &
max77843_irqs[MAX77843_CHG_IRQ_CHGIN_I].mask) {
u8 reg_data;
max77843_read_reg(max77843->charger,
MAX77843_CHG_REG_CHG_INT_MASK, ®_data);
reg_data |= (1 << 6);
max77843_write_reg(max77843->charger,
MAX77843_CHG_REG_CHG_INT_MASK, reg_data);
}
}
if (irq_src & MAX77843_IRQSRC_FG) {
pr_info("[%s] fuelgauge interrupt\n", __func__);
pr_info("[%s]IRQ_BASE(%d), NESTED_IRQ(%d)\n",
__func__, max77843->irq_base, max77843->irq_base + MAX77843_FG_IRQ_ALERT);
handle_nested_irq(max77843->irq_base + MAX77843_FG_IRQ_ALERT);
return IRQ_HANDLED;
}
if (irq_src & MAX77843_IRQSRC_TOP) {
/* SYS_INT */
ret = max77843_read_reg(max77843->i2c, MAX77843_PMIC_REG_SYSTEM_INT,
&irq_reg[SYS_INT]);
pr_info("%s: topsys interrupt(0x%02x)\n", __func__, irq_reg[SYS_INT]);
}
if (irq_src & MAX77843_IRQSRC_MUIC) {
/* MUIC INT1 ~ INT3 */
ret = max77843_bulk_read(max77843->muic, MAX77843_MUIC_REG_INT1,
MAX77843_NUM_IRQ_MUIC_REGS, &tmp_irq_reg[MUIC_INT1]);
if (ret) {
pr_err("%s:%s Failed to read interrupt source: %d\n",
MFD_DEV_NAME, __func__, ret);
return IRQ_NONE;
}
#if defined(CONFIG_MUIC_MAX77843_SUPPORT_AFC_CHARGER)
max77843_bulk_read(max77843->muic, MAX77843_MUIC_REG_INTMASK1,
MAX77843_NUM_IRQ_MUIC_REGS, &tmp_irq_mask_reg[MUIC_INT1]);
for (i = MUIC_INT1; i < MAX77843_IRQ_GROUP_NR; i++)
tmp_irq_reg[i] &= tmp_irq_mask_reg[i];
#endif /* CONFIG_MUIC_MAX77843_SUPPORT_AFC_CHARGER */
/* Or temp irq register to irq register for if it retries */
for (i = MUIC_INT1; i <= MUIC_MAX_INT; i++)
irq_reg[i] |= tmp_irq_reg[i];
pr_info("%s: muic interrupt(0x%02x, 0x%02x, 0x%02x)\n", __func__,
irq_reg[MUIC_INT1], irq_reg[MUIC_INT2], irq_reg[MUIC_INT3]);
/* for debug */
if ((irq_reg[MUIC_INT1] == 0) && (irq_reg[MUIC_INT2] == 0)
&& (irq_reg[MUIC_INT3] == 0)) {
pr_info("%s: irq gpio post-state(0x%02x)\n", __func__,
gpio_get_value(max77843->irq_gpio));
if (check_num >= 15) {
max77843_muic_read_register(max77843->muic);
panic("max77843 muic interrupt gpio Err!\n");
}
check_num++;
} else
check_num = 0;
}
/* Apply masking */
for (i = 0; i < MAX77843_IRQ_GROUP_NR; i++) {
if (i >= MUIC_INT1 && i <= MUIC_MAX_INT)
irq_reg[i] &= max77843->irq_masks_cur[i];
else
irq_reg[i] &= ~max77843->irq_masks_cur[i];
}
/* Report */
for (i = 0; i < MAX77843_IRQ_NR; i++) {
if (irq_reg[max77843_irqs[i].group] & max77843_irqs[i].mask)
handle_nested_irq(max77843->irq_base + i);
}
return IRQ_HANDLED;
}
