static void max77843_haptic_i2c(struct max77843_haptic_data *hap_data, bool en)
{
int ret;
u8 lscnfg_val = 0x00;
pr_info("[VIB] %s %d\n", __func__, en);
if (en) {
lscnfg_val = MAX77843_REG_MAINCTRL1_BIASEN;
}
ret = max77843_update_reg(hap_data->i2c, MAX77843_PMIC_REG_MAINCTRL1,
lscnfg_val, MAX77843_REG_MAINCTRL1_BIASEN);
if (ret)
pr_err("[VIB] i2c REG_BIASEN update error %d\n", ret);
if (en) {
ret = max77843_update_reg(hap_data->i2c,
MAX77843_PMIC_REG_MCONFIG, 0xff, MOTOR_EN);
} else {
ret = max77843_update_reg(hap_data->i2c,
MAX77843_PMIC_REG_MCONFIG, 0x0, MOTOR_EN);
}
if (ret)
pr_err("[VIB] i2c MOTOR_EN update error %d\n", ret);
ret = max77843_update_reg(hap_data->i2c, MAX77843_PMIC_REG_MCONFIG,
0xff, MOTOR_LRA);
if (ret)
pr_err("[VIB] i2c MOTOR_LPA update error %d\n", ret);
}
static void max77843_rgb_set_state(struct led_classdev *led_cdev,
unsigned int brightness, unsigned int led_state)
{
const struct device *parent = led_cdev->dev->parent;
struct max77843_rgb *max77843_rgb = dev_get_drvdata(parent);
struct device *dev;
int n;
int ret;
pr_info("leds-max77843-rgb: %s\n", __func__);
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;
max77843_rgb_set(led_cdev, brightness);
ret = max77843_update_reg(max77843_rgb->i2c,
MAX77843_RGBLED_REG_LEDEN, led_state << (2*n), 0x3 << 2*n);
if (IS_ERR_VALUE(ret)) {
dev_err(dev, "can't write FLASH_EN : %d\n", ret);
return;
}
}
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 irqreturn_t max77843_irq_thread(int irq, void *data)
{
struct max77843_dev *max77843 = data;
u8 irq_reg[MAX77843_IRQ_GROUP_NR] = {0};
u8 irq_src;
int ret;
int i;
pr_debug("%s: irq gpio pre-state(0x%02x)\n", __func__,
gpio_get_value(max77843->irq_gpio));
clear_retry:
ret = max77843_read_reg(max77843->i2c,
MAX77843_PMIC_REG_INTSRC, &irq_src);
if (ret < 0) {
dev_err(max77843->dev, "Failed to read interrupt source: %d\n",
ret);
return IRQ_NONE;
}
pr_info("%s: interrupt source(0x%02x)\n", __func__, irq_src);
if (irq_src & MAX77843_IRQSRC_TOP) {
/* TOPSYS_INT */
ret = max77843_read_reg(max77843->i2c,
MAX77843_PMIC_REG_TOPSYS_INT,
&irq_reg[MAX77843_TOPSYS_INT]);
pr_info("%s: topsys interrupt(0x%02x)\n",
__func__, irq_reg[MAX77843_TOPSYS_INT]);
}
if (irq_src & MAX77843_IRQSRC_CHG) {
/* CHG_INT */
ret = max77843_read_reg(max77843->charger, MAX77843_CHG_REG_INT,
&irq_reg[MAX77843_CHG_INT]);
pr_info("%s: charger interrupt(0x%02x)\n",
__func__, irq_reg[MAX77843_CHG_INT]);
/* mask chgin to prevent chgin infinite interrupt
* chgin is unmasked chgin isr
*/
if (irq_reg[MAX77843_CHG_INT] & max77843_irqs[MAX77843_CHG_IRQ_CHGIN_I].mask) {
max77843_update_reg(max77843->i2c,
MAX77843_CHG_REG_INT_MASK, MAX77843_CHGIN_IM, MAX77843_CHGIN_IM);
}
}
if (irq_src & MAX77843_IRQSRC_FG) {
pr_info("%s: fuelgauge interrupt, 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_MUIC) {
/* MUIC INT1 ~ INT3 */
max77843_bulk_read(max77843->muic,
MAX77843_MUIC_REG_INT1,
MAX77843_NUM_IRQ_MUIC_REGS,
&irq_reg[MAX77843_MUIC_INT1]);
pr_info("%s: muic interrupt(0x%02x, 0x%02x, 0x%02x)\n",
__func__, irq_reg[MAX77843_MUIC_INT1],
irq_reg[MAX77843_MUIC_INT2], irq_reg[MAX77843_MUIC_INT3]);
}
pr_debug("%s: irq gpio post-state(0x%02x)\n", __func__,
gpio_get_value(max77843->irq_gpio));
if (gpio_get_value(max77843->irq_gpio) == 0) {
pr_warn("%s: irq_gpio is not High!\n", __func__);
goto clear_retry;
}
#if 0
/* Apply masking */
for (i = 0; i < MAX77843_IRQ_GROUP_NR; i++) {
if (i >= MAX77843_MUIC_INT1 && i <= MAX77843_MUIC_INT3)
irq_reg[i] &= max77843->irq_masks_cur[i];
else
irq_reg[i] &= ~max77843->irq_masks_cur[i];
}
#endif
/* 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;
}
static int max77843_i2c_probe(struct i2c_client *i2c,
const struct i2c_device_id *id)
{
struct max77843_dev *max77843;
struct max77843_platform_data *pdata;
u8 reg_data;
int ret = 0;
dev_info(&i2c->dev, "%s\n", __func__);
max77843 = kzalloc(sizeof(struct max77843_dev), GFP_KERNEL);
if (max77843 == NULL)
return -ENOMEM;
if (i2c->dev.of_node) {
pdata = devm_kzalloc(&i2c->dev,
sizeof(struct max77843_platform_data),
GFP_KERNEL);
if (!pdata) {
dev_err(&i2c->dev, "Failed to allocate memory \n");
ret = -ENOMEM;
goto err;
}
ret = of_max77843_dt(&i2c->dev, pdata);
if (ret < 0){
dev_err(&i2c->dev, "Failed to get device of_node \n");
goto err;
}
/*Filling the platform data*/
pdata->muic_data = &max77843_muic;
#ifdef CONFIG_REGULATOR_MAX77843
pdata->num_regulators = MAX77843_REG_MAX;
pdata->regulators = max77843_regulators;
#endif
#ifdef CONFIG_LEDS_MAX77843
pdata->led_data = &max77843_led_pdata;
#endif
/*pdata update to other modules*/
i2c->dev.platform_data = pdata;
} else
pdata = i2c->dev.platform_data;
i2c_set_clientdata(i2c, max77843);
max77843->dev = &i2c->dev;
max77843->i2c = i2c;
max77843->irq = i2c->irq;
if (pdata) {
max77843->pdata = pdata;
max77843->irq_base = irq_alloc_descs(-1, 0, MAX77843_IRQ_NR, -1);
if (max77843->irq_base < 0) {
pr_err("%s: irq_alloc_descs Fail ret(%d)\n",
__func__, max77843->irq_base);
ret = -EINVAL;
} else {
pdata->irq_base = max77843->irq_base;
}
max77843->irq_gpio = pdata->irq_gpio;
max77843->wakeup = pdata->wakeup;
gpio_tlmm_config(GPIO_CFG(max77843->irq_gpio, 0, GPIO_CFG_INPUT,
GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_DISABLE);
} else {
ret = -EINVAL;
goto err;
}
mutex_init(&max77843->iolock);
max77843->muic = i2c_new_dummy(i2c->adapter, I2C_ADDR_MUIC);
i2c_set_clientdata(max77843->muic, max77843);
max77843->charger = i2c_new_dummy(i2c->adapter, I2C_ADDR_CHG);
i2c_set_clientdata(max77843->charger, max77843);
max77843->fuelgauge = i2c_new_dummy(i2c->adapter, I2C_ADDR_FG);
i2c_set_clientdata(max77843->fuelgauge, max77843);
max77843->led = i2c_new_dummy(i2c->adapter, I2C_ADDR_LED);
i2c_set_clientdata(max77843->led, max77843);
if (max77843_read_reg(max77843->i2c, MAX77843_PMIC_REG_PMICID, ®_data) < 0) {
dev_err(max77843->dev,
"device not found on this channel (this is not an error)\n");
ret = -ENODEV;
} else {
/* print rev */
max77843->pmic_rev = (reg_data & 0x7);
max77843->pmic_ver = ((reg_data & 0xF8) >> 0x3);
pr_info("%s: device found: rev.0x%x, ver.0x%x\n", __func__,
max77843->pmic_rev, max77843->pmic_ver);
}
ret = max77843_irq_init(max77843);
if (ret < 0)
goto err_irq_init;
ret = mfd_add_devices(max77843->dev, -1, max77843_devs,
ARRAY_SIZE(max77843_devs), NULL, 0, NULL);
if (ret < 0)
goto err_mfd;
device_init_wakeup(max77843->dev, pdata->wakeup);
#if defined(CONFIG_ADC_ONESHOT)
/* Set oneshot mode */
max77843_update_reg(max77843->muic, MAX77843_MUIC_REG_CTRL4,
MAX77843_ADC_ONESHOT<<MAX77843_CTRL4_ADCMODE_SHIFT,
MAX77843_CTRL4_ADCMODE_MASK);
#else
/* Set continuous mode */
max77843_update_reg(max77843->muic, MAX77843_MUIC_REG_CTRL4,
MAX77843_ADC_ALWAYS<<MAX77843_CTRL4_ADCMODE_SHIFT,
MAX77843_CTRL4_ADCMODE_MASK);
#endif
return ret;
err_mfd:
mfd_remove_devices(max77843->dev);
max77843_irq_exit(max77843);
err_irq_init:
i2c_unregister_device(max77843->muic);
i2c_unregister_device(max77843->led);
err:
kfree(max77843);
return ret;
}
