Example #1
0
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, &reg);
		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;
}
Example #2
0
static int max77828_led_hw_setup(struct max77828_led_data *led_data)
{
	int value;
	int ret;

	/*  pin control setting
  *  TORCHEN_PD & FLASHSTB_PD - Enabled
  *  Torch mode using TORCHEN
  *  Flash mode using both TORCHEN & FLASHSTB */
	value = max77828_led_get_en_value(led_data,0);
	value |= MAX77828_TORCH_MD_ANY|MAX77828_TORCHEN_PD|
						MAX77828_FLASH_MD_ANY|MAX77828_FLASHSTB_PD;
	ret = max77828_write_reg(led_data->i2c, MAX77828_LED_REG_MODE_SEL, value);
	if (IS_ERR_VALUE(ret))
		return ret;

	if (fdata->enable_maxflash)
	{
		if (fdata->maxflash_rising_timer > 4096 || fdata->maxflash_rising_timer > 4096)
			return -EINVAL;
		value = ((fdata->maxflash_rising_timer / 256 - 1) << max77828_set_bit(MAX77828_LB_TMR_R)) |
				((fdata->maxflash_falling_timer / 256 - 1) << max77828_set_bit(MAX77828_LB_TMR_F));
		ret = max77828_write_reg(led_data->i2c, MAX77828_LED_REG_MAXFLASH1, value);
		if (IS_ERR_VALUE(ret))
			return ret;

		switch(fdata->maxflash_hysteresis)
		{
		case 0:
			value = 0;
			break;
		case 50000:
			value = 1;
			break;
		case 100000:
			value = 2;
			break;
		case 300000:
			value = 6;
			break;
		case 350000:
			value = 7;
			break;
		default:
			return -EINVAL;
		}

		if (likely(fdata->maxflash_threshold >= 2400000 && fdata->maxflash_threshold <= 3400000))
			value |= (((fdata->maxflash_threshold - 2400000) / 33000 + 1) << max77828_set_bit(MAX77828_MAXFLASH_HYS));
		else
			return -EINVAL;
	}
	else
		value = 0;

	return ret;
}
Example #3
0
static void max77828_flash_set(struct max77828_led_data *led_data)
{
	int ret;
	int brightness = led_data->test_brightness;

	if(brightness == LED_OFF)
	{
		DEBUG_MAX77828("(%s) LED_OFF\n",__func__);
		/* mode select */
//		value = max77828_led_get_en_value(led_data,0);
		ret = max77828_write_reg(led_data->i2c, MAX77828_LED_REG_MODE_SEL, 0x0);
		if(IS_ERR_VALUE(ret))
			pr_err("(%s) :  MAX77828_LED_REG_MODE_SEL update failed\n",__func__);

		/* Flash OFF */
		ret = max77828_update_reg(led_data->i2c, MAX77828_LED_REG_I_FLASH1,
				0, MAX77828_FLASH_FLED1_EN);
		if(IS_ERR_VALUE(ret))
			pr_err("(%s) :  MAX77828_LED_REG_I_FLASH1 update failed\n",__func__ );
	}
	else
	{
		if(brightness > 0x3F)
			brightness = 0x3F;
		DEBUG_MAX77828("(%s) LED_ON\n",__func__);
		ret = max77828_write_reg(led_data->i2c, MAX77828_LED_REG_DCDC_CNTL1,
				MAX77828_DCDC_MODE_PAM);
		if(IS_ERR_VALUE(ret))
			pr_err("(%s) :  MAX77828_LED_REG_DCDC_CNTL1 write failed\n",__func__);
		/* mode select */
		ret = max77828_write_reg(led_data->i2c, MAX77828_LED_REG_MODE_SEL,0x47);
		if(IS_ERR_VALUE(ret))
			pr_err("(%s) :  MAX77828_LED_REG_MODE_SEL update failed\n",__func__);

		/* Flash ON, Set Current */
		ret = max77828_write_reg(led_data->i2c, MAX77828_LED_REG_I_FLASH1,
				MAX77828_FLASH_FLED1_EN |
				((unsigned int)brightness << max77828_set_bit(MAX77828_FLASH_IOUT)));
		if(IS_ERR_VALUE(ret))
			pr_err("(%s) :  MAX77828_LED_REG_I_FLASH1 write failed\n",__func__);
	}
	return;
}
Example #4
0
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;
}
Example #5
0
static int max77828_restore(struct device *dev)
{
	struct i2c_client *i2c = container_of(dev, struct i2c_client, dev);
	struct max77828_dev *max77828 = i2c_get_clientdata(i2c);
	int i;

	enable_irq(max77828->irq);

	for (i = 0; i < ARRAY_SIZE(max77828_dumpaddr_pmic); i++)
		max77828_write_reg(i2c, max77828_dumpaddr_pmic[i],
				max77828->reg_pmic_dump[i]);

	for (i = 0; i < ARRAY_SIZE(max77828_dumpaddr_muic); i++)
		max77828_write_reg(i2c, max77828_dumpaddr_muic[i],
				max77828->reg_muic_dump[i]);

	for (i = 0; i < ARRAY_SIZE(max77828_dumpaddr_led); i++)
		max77828_write_reg(i2c, max77828_dumpaddr_led[i],
				max77828->reg_led_dump[i]);

	return 0;
}
static int max77828_rgb_blink(struct device *dev,
				unsigned int delay_on, unsigned int delay_off)
{
	struct max77828_rgb *max77828_rgb = dev_get_drvdata(dev);
	int value;
	int ret;

	if (delay_on == 0 && delay_off == 0) {
		ret = max77828_write_reg(max77828_rgb->i2c,
					MAX77828_RGBLED_REG_LEDBLNK, 0x50);
		if (IS_ERR_VALUE(ret)) {
			dev_err(dev, "can't write REG_LEDBLNK : %d\n", ret);
			return -ENODEV;
		}
	} else {
		value = delay_on + delay_off;
		if (value <= 6000)
			value = (value - 1000) / 500;
		else if (value < 8000)
			value = (value - 6000) / 1000;
		else if (value < 12000)
			value = (value - 8000) / 2000;
		else
			return -EINVAL;

		value |= ((delay_on / 200) <<  4);
		ret = max77828_write_reg(max77828_rgb->i2c,
					MAX77828_RGBLED_REG_LEDBLNK, value);
		if (IS_ERR_VALUE(ret)) {
			dev_err(dev, "can't write REG_LEDBLNK : %d\n", ret);
			return -EINVAL;
		}
	}

	return 0;
}
static int max77828_rgb_ramp(struct device *dev, int ramp_up, int ramp_down)
{
	struct max77828_rgb *max77828_rgb = dev_get_drvdata(dev);
	int value;
	int ret;

	ramp_up /= 100;
	ramp_down /= 100;
	value = (ramp_down) | (ramp_up << 4);
	ret = max77828_write_reg(max77828_rgb->i2c,
					MAX77828_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 void max77828_rgb_set(struct led_classdev *led_cdev,
				unsigned int brightness)
{
	const struct device *parent = led_cdev->dev->parent;
	struct max77828_rgb *max77828_rgb = dev_get_drvdata(parent);
	struct device *dev;
	int n;
	int ret;

	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;
	}

	dev = led_cdev->dev;
	n = ret;

	if (brightness == LED_OFF) {
		/* Flash OFF */
		ret = max77828_update_reg(max77828_rgb->i2c,
					MAX77828_RGBLED_REG_LEDEN, 0 , 1 << n);
		if (IS_ERR_VALUE(ret)) {
			dev_err(dev, "can't write LEDEN : %d\n", ret);
			return;
		}
	} else {
		/* Set current */
		ret = max77828_write_reg(max77828_rgb->i2c,
				MAX77828_RGBLED_REG_LED0BRT + n, brightness);
		if (IS_ERR_VALUE(ret)) {
			dev_err(dev, "can't write LEDxBRT : %d\n", ret);
			return;
		}
		/* Flash ON */
		ret = max77828_update_reg(max77828_rgb->i2c,
				MAX77828_RGBLED_REG_LEDEN, 0xFF, 1 << n);
		if (IS_ERR_VALUE(ret)) {
			dev_err(dev, "can't write FLASH_EN : %d\n", ret);
			return;
		}
	}
}
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 void max77828_irq_sync_unlock(struct irq_data *data)
{
	struct max77828_dev *max77828 = irq_get_chip_data(data->irq);
	int i;

	for (i = 0; i < MAX77828_IRQ_GROUP_NR; i++) {
		u8 mask_reg = max77828_mask_reg[i];
		struct i2c_client *i2c = get_i2c(max77828, i);

		if (mask_reg == MAX77828_REG_INVALID ||
				IS_ERR_OR_NULL(i2c))
			continue;
		max77828->irq_masks_cache[i] = max77828->irq_masks_cur[i];

		max77828_write_reg(i2c, max77828_mask_reg[i],
				max77828->irq_masks_cur[i]);
	}

	mutex_unlock(&max77828->irqlock);
}
int max77828_irq_init(struct max77828_dev *max77828)
{
	int i;
	int cur_irq;
	int ret;

	pr_info("func: %s, irq_gpio: %d, irq_base: %d\n", __func__,
			max77828->irq_gpio, max77828->irq_base);
	if (!max77828->irq_gpio) {
		dev_warn(max77828->dev, "No interrupt specified.\n");
		max77828->irq_base = 0;
		return 0;
	}

	if (!max77828->irq_base) {
		dev_err(max77828->dev, "No interrupt base specified.\n");
		return 0;
	}

	mutex_init(&max77828->irqlock);

	max77828->irq = gpio_to_irq(max77828->irq_gpio);
	ret = gpio_request(max77828->irq_gpio, "if_pmic_irq");
	if (ret) {
		dev_err(max77828->dev, "%s: failed requesting gpio %d\n",
			__func__, max77828->irq_gpio);
		return ret;
	}
	gpio_direction_input(max77828->irq_gpio);
	gpio_free(max77828->irq_gpio);

	/* Mask individual interrupt sources */
	for (i = 0; i < MAX77828_IRQ_GROUP_NR; i++) {
		struct i2c_client *i2c;
		/* MUIC IRQ  0:MASK 1:NOT MASK */
		/* Other IRQ 1:MASK 0:NOT MASK */
		if (i >= MUIC_INT1 && i <= MUIC_INT3) {
			max77828->irq_masks_cur[i] = 0x00;
			max77828->irq_masks_cache[i] = 0x00;
		} else {
			max77828->irq_masks_cur[i] = 0xff;
			max77828->irq_masks_cache[i] = 0xff;
		}
		i2c = get_i2c(max77828, i);

		if (IS_ERR_OR_NULL(i2c))
			continue;
		if (max77828_mask_reg[i] == MAX77828_REG_INVALID)
			continue;
		if (i >= MUIC_INT1 && i <= MUIC_INT3)
			max77828_write_reg(i2c, max77828_mask_reg[i], 0x00);
		else
			max77828_write_reg(i2c, max77828_mask_reg[i], 0xff);
	}

	/* Register with genirq */
	for (i = 0; i < MAX77828_IRQ_NR; i++) {
		cur_irq = i + max77828->irq_base;
		irq_set_chip_data(cur_irq, max77828);
		irq_set_chip_and_handler(cur_irq, &max77828_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
	}

	ret = request_threaded_irq(max77828->irq, NULL, max77828_irq_thread,
				   IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
				   "max77828-irq", max77828);

	if (ret) {
		dev_err(max77828->dev, "Failed to request IRQ %d: %d\n",
			max77828->irq, ret);
		return ret;
	}

	return 0;
}
Example #12
0
static int max77828_led_setup(struct max77828_led_data *led_data)
{
	int ret = 0;

	struct max77828_led *data = led_data->data;
	int id = data->id;
	int value;
	int i;

	DEBUG_MAX77828("[LED] %s : id - %d\n", __func__,id);
	switch(id)
	{
		case MAX77828_FLASH:
			/* ramp up/down setting */
			// flash_ramp_up = 384
			// flash_ramp_down = 384
			for (i = 0; i < ARRAY_SIZE(flash_ramp); i++)
				if (fdata->flash_ramp_up <= flash_ramp[i])
					break;
			if (unlikely(i == ARRAY_SIZE(flash_ramp)))
				return -EINVAL;
			value = (unsigned int)i << max77828_set_bit(MAX77828_FLASH_RU);
			for (i = 0; i < ARRAY_SIZE(flash_ramp); i++)
				if (fdata->flash_ramp_down <= flash_ramp[i])
					break;
			if (unlikely(i == ARRAY_SIZE(flash_ramp)))
				return -EINVAL;
			value |= (unsigned int)i << max77828_set_bit(MAX77828_FLASH_RD);

			ret = max77828_write_reg(led_data->i2c, MAX77828_LED_REG_FLASH_RAMP_SEL, value);
			if (IS_ERR_VALUE(ret))
				return ret;
			/* flash timer control */
			value = MAX77828_FLASH_TMR_CNTL | MAX77828_FLASH_TMR;
			ret = max77828_write_reg(led_data->i2c, MAX77828_LED_REG_FLASH_TMR_CNTL, value);
			if (IS_ERR_VALUE(ret))
				return ret;

			/* MAXFLASH setting */
			value = 0xFF;
			ret = max77828_write_reg(led_data->i2c, MAX77828_LED_REG_MAXFLASH1, value);
			if (IS_ERR_VALUE(ret))
				return ret;

			value = 0x09;
			ret = max77828_write_reg(led_data->i2c, MAX77828_LED_REG_MAXFLASH1, value);
			if (IS_ERR_VALUE(ret))
				return ret;

			break;
		case MAX77828_TORCH:
			//torch_ramp_up = 16392
			//torch_ramp_down = 16392
			for (i = 0; i < ARRAY_SIZE(torch_ramp); i++)
					if (fdata->flash_ramp_up <= torch_ramp[i])
						break;
			if (unlikely(i == ARRAY_SIZE(torch_ramp)))
					return -EINVAL;
				value = (unsigned int)i << max77828_set_bit(MAX77828_TORCH_RU);

			for (i = 0; i < ARRAY_SIZE(torch_ramp); i++)
					if (fdata->flash_ramp_down <= torch_ramp[i])
						break;
			if (unlikely(i == ARRAY_SIZE(torch_ramp)))
					return -EINVAL;
			value |= (unsigned int)i << max77828_set_bit(MAX77828_TORCH_RD);
			ret = max77828_write_reg(led_data->i2c, MAX77828_LED_REG_FLASH_RAMP_SEL, value);
			if (IS_ERR_VALUE(ret))
				return ret;
		/* torch timer control */
			value = MAX77828_TORCH_TMR_CNTL | MAX77828_TORCH_TMR;
			ret = max77828_write_reg(led_data->i2c, MAX77828_LED_REG_TORCH_TMR_CNTL, value);
			if (IS_ERR_VALUE(ret))
				return ret;
			break;
		case MAX77828_RGB_R:
			ret = max77828_write_reg(led_data->i2c, MAX77828_LED_REG_LEDEN, 0x02);
			if (IS_ERR_VALUE(ret))
				return ret;
			ret = max77828_write_reg(led_data->i2c, MAX77828_LED_REG_LED0BRT, 0xFF);
			if (IS_ERR_VALUE(ret))
				return ret;
			break;
		case MAX77828_RGB_G:
			ret = max77828_write_reg(led_data->i2c, MAX77828_LED_REG_LED1BRT, 0x00);
			if (IS_ERR_VALUE(ret))
				return ret;
			break;
		case MAX77828_RGB_B:
			ret = max77828_write_reg(led_data->i2c, MAX77828_LED_REG_LED2BRT, 0x00);
			if (IS_ERR_VALUE(ret))
				return ret;
			break;
		default :
			printk("Error : No such LED present\n");
			break;
	}
	return ret;
}