a7y18lte-ubports/android_kernel_samsung_a7y18lte
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
master
android_kernel_samsung_a7y1.../drivers/leds/leds-s2mu205.c
prashantpaddune 3bca37f224 A750FXXU4CTBC
2020-03-27 21:51:54 +05:30

1219 lines
31 KiB
C
Raw Permalink Blame History

/*
* leds-s2mu205.c - LED class driver for S2MU205 LEDs.
*
* Copyright (C) 2019 Samsung Electronics
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
*/
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/err.h>
#include <linux/slab.h>
#include <linux/leds.h>
#include <linux/workqueue.h>
#include <linux/leds.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/mfd/samsung/s2mu205.h>
#include <linux/leds-s2mu205.h>
#include <linux/platform_device.h>
#include <linux/sec_batt.h>
extern struct class *camera_class;
struct device *flash_dev;
struct s2mu205_led_data *g_led_data[S2MU205_LED_NUM];
static int s2mu205_factory_mode;
static u8 leds_cur_max[] = {
S2MU205_FLASH_OUT_I_1200MA,
S2MU205_TORCH_OUT_I_320MA,
};
static u8 leds_time_max[] = {
S2MU205_FLASH_TIMEOUT_992MS,
S2MU205_TORCH_TIMEOUT_15728MS,
};
struct s2mu205_led_data {
struct led_classdev cdev;
struct s2mu205_led *data;
struct notifier_block batt_nb;
struct i2c_client *i2c;
struct work_struct work;
struct mutex lock;
spinlock_t value_lock;
int brightness;
int test_brightness;
int attach_ta;
int attach_sdp;
bool enable;
int torch_pin;
int flash_pin;
unsigned int flash_brightness;
unsigned int preflash_brightness;
unsigned int movie_brightness;
unsigned int torch_brightness;
unsigned int factory_brightness;
unsigned int flashlight_brightness[S2MU205_FLASH_LIGHT_MAX];
};
inline int s2mu205_flash_brightness(u32 flash_current)
{
if (flash_current <= 400)
return ((flash_current - 25)/25) & S2MU205_CHX_FLASH_IOUT;
else if (flash_current > 400 && flash_current <= 1200)
return (((flash_current - 400)/50) + 0x0F) & S2MU205_CHX_FLASH_IOUT;
else
return (flash_current & 0x00) | S2MU205_CHX_FLASH_IOUT;
}
inline int s2mu205_torch_brightness(u32 torch_current)
{
if (torch_current <= 320)
return (torch_current - 10)/10 & S2MU205_CHX_TORCH_IOUT;
else
return (torch_current & 0x00) | S2MU205_CHX_TORCH_IOUT;
}
/* This function is used by Charger */
void s2mu205_set_operation_mode(int value)
{
struct s2mu205_led_data *fled = g_led_data[S2MU205_FLASH_LED];
u8 reg;
s2mu205_factory_mode = value;
if (value == S2MU205_FACTORY) {
s2mu205_update_reg(fled->i2c, S2MU205_FLED_CTRL1,
0x80, S2MU205_CHGIN_ENGH);
} else if (value == S2MU205_NORMAL) {
s2mu205_read_reg(fled->i2c, S2MU205_FLED_STATUS, &reg);
if (fled->attach_ta &&
(reg & S2MU205_CH1_TORCH_ON || reg & S2MU205_CH2_TORCH_ON)){
s2mu205_update_reg(fled->i2c, S2MU205_FLED_CTRL1,
0x80, S2MU205_CHGIN_ENGH);
}
else{
s2mu205_update_reg(fled->i2c, S2MU205_FLED_CTRL1,
0x00, S2MU205_CHGIN_ENGH);
}
}
}
EXPORT_SYMBOL_GPL(s2mu205_set_operation_mode);
static void s2mu205_set_current(struct s2mu205_led_data *fled,
int chan, int curr)
{
struct s2mu205_led *data = fled->data;
int id = data->id;
u8 mask = 0, reg = 0;
switch (chan) {
case 1:
if (id == S2MU205_FLASH_LED) {
pr_info("%s: [CH%d] LED mode is flash\n", __func__, chan);
reg = S2MU205_FLED_CH1_CTRL0;
mask = S2MU205_CHX_FLASH_IOUT;
/* Flash LED CH1 Current setting (25mA ~ 1200mA) */
if (curr > S2MU205_FLASH_OUT_I_1200MA)
curr = S2MU205_FLASH_OUT_I_1200MA;
} else if (id == S2MU205_TORCH_LED) {
pr_info("%s: [CH%d] LED mode is torch\n", __func__, chan);
reg = S2MU205_FLED_CH1_CTRL1;
mask = S2MU205_CHX_TORCH_IOUT;
/* Torch LED CH1 Current setting (10mA ~ 320mA) */
if (curr > S2MU205_TORCH_OUT_I_320MA)
curr = S2MU205_TORCH_OUT_I_320MA;
}
/* Flash or Torch set current */
s2mu205_update_reg(fled->i2c, reg, curr, mask);
pr_info("%s: [CH%d] FLED Current setting = %d\n",
__func__, chan, curr);
break;
case 2:
if (id == S2MU205_FLASH_LED) {
pr_info("%s: [CH%d] LED mode is flash\n", __func__, chan);
reg = S2MU205_FLED_CH2_CTRL0;
mask = S2MU205_CHX_FLASH_IOUT;
/* Flash LED CH2 Current setting (25mA ~ 400mA) */
if (curr > S2MU205_FLASH_OUT_I_400MA)
curr = S2MU205_FLASH_OUT_I_400MA;
} else if (id == S2MU205_TORCH_LED) {
pr_info("%s: [CH%d] LED mode is torch\n", __func__, chan);
reg = S2MU205_FLED_CH2_CTRL1;
mask = S2MU205_CHX_TORCH_IOUT;
/* Torch LED CH2 Current setting (10mA ~ 320mA) */
if (curr > S2MU205_TORCH_OUT_I_320MA)
curr = S2MU205_TORCH_OUT_I_320MA;
}
/* Flash or Torch set current */
s2mu205_update_reg(fled->i2c, reg, curr, mask);
pr_info("%s: [CH%d] FLED Current setting = %d\n",
__func__, chan, curr);
break;
default:
pr_info("%s: Wrong channel\n", __func__);
break;
}
}
static int s2mu205_get_torch_curr(struct s2mu205_led_data *fled,
int chan)
{
int curr = -1;
u8 reg, dest;
switch (chan) {
case 1:
dest = S2MU205_FLED_CH1_CTRL1;
break;
case 2:
dest = S2MU205_FLED_CH2_CTRL1;
break;
default:
return -1;
break;
}
s2mu205_read_reg(fled->i2c, dest, &reg);
reg &= S2MU205_CHX_TORCH_IOUT;
curr = (curr * 10) + 10;
pr_info("%s: CH%02d torch curr = %dmA\n", __func__,
chan, curr);
return curr;
}
static int s2mu205_get_flash_curr(struct s2mu205_led_data *fled,
int chan)
{
int curr = -1;
u8 reg, dest;
switch (chan) {
case 1:
dest = S2MU205_FLED_CH1_CTRL0;
break;
case 2:
dest = S2MU205_FLED_CH2_CTRL0;
break;
default:
return -1;
break;
}
s2mu205_read_reg(fled->i2c, dest, &reg);
reg &= S2MU205_CHX_FLASH_IOUT;
if (reg <= S2MU205_FLASH_OUT_I_400MA)
curr = (curr * 25) + 25;
else
curr = (curr - 0x0F)*50 + 400;
pr_info("%s: CH%02d flash curr = %dmA\n", __func__,
chan, curr);
return curr;
}
#ifdef CONFIG_MUIC_NOTIFIER
static void attach_cable_check(muic_attached_dev_t attached_dev,
int *attach_ta, int *attach_sdp)
{
if (attached_dev == ATTACHED_DEV_USB_MUIC)
*attach_sdp = 1;
else
*attach_sdp = 0;
switch (attached_dev) {
case ATTACHED_DEV_TA_MUIC:
case ATTACHED_DEV_SMARTDOCK_TA_MUIC:
case ATTACHED_DEV_UNOFFICIAL_TA_MUIC:
case ATTACHED_DEV_UNOFFICIAL_ID_TA_MUIC:
case ATTACHED_DEV_CDP_MUIC:
case ATTACHED_DEV_USB_MUIC:
case ATTACHED_DEV_UNOFFICIAL_ID_CDP_MUIC:
*attach_ta = 1;
break;
default:
*attach_ta = 0;
break;
}
}
static int ta_notification(struct notifier_block *nb,
unsigned long action, void *data)
{
muic_attached_dev_t attached_dev = *(muic_attached_dev_t *)data;
u8 temp;
struct s2mu205_led_data *fled = container_of(nb,
struct s2mu205_led_data,
batt_nb);
#ifndef CONFIG_S2MU205_LEDS_I2C
int ret = 0;
#endif
switch (action) {
case MUIC_NOTIFY_CMD_DETACH:
case MUIC_NOTIFY_CMD_LOGICALLY_DETACH:
if (!fled->attach_ta)
goto err;
fled->attach_ta = 0;
if (!fled->data->id) {
pr_info("%s : flash mode\n", __func__);
goto err;
}
#ifndef CONFIG_S2MU205_LEDS_I2C
if (gpio_is_valid(fled->torch_pin)) {
ret = devm_gpio_request(fled->cdev.dev,
fled->torch_pin,
"s2mu205_gpio");
if (ret) {
pr_err("%s : fail to assignment gpio\n",
__func__);
goto gpio_free_data;
}
}
if (gpio_get_value(fled->torch_pin)) {
gpio_direction_output(fled->torch_pin, 0);
gpio_direction_output(fled->torch_pin, 1);
goto gpio_free_data;
}
#else
/* check TORCH On/Off */
s2mu205_read_reg(fled->i2c, S2MU205_FLED_STATUS, &temp);
if (temp & S2MU205_CH1_TORCH_ON) {
/* CH1 Torch Off */
s2mu205_update_reg(fled->i2c,
S2MU205_FLED_CTRL0,
S2MU205_TORCH_OFF,
S2MU205_CH1_TORCH_FLED_EN);
pr_info("%s : Torch Off\n", __func__);
/* CH1 Torch On */
s2mu205_update_reg(fled->i2c,
S2MU205_FLED_CTRL0,
S2MU205_CH1_TORCH_ON_I2C,
S2MU205_CH1_TORCH_FLED_EN);
pr_info("%s : Torch On\n", __func__);
}
#endif
if (s2mu205_factory_mode == S2MU205_NORMAL) {
/* CHGIN_ENGH = 0 */
s2mu205_update_reg(fled->i2c,
S2MU205_FLED_CTRL1,
0x00, S2MU205_CHGIN_ENGH);
}
break;
case MUIC_NOTIFY_CMD_ATTACH:
case MUIC_NOTIFY_CMD_LOGICALLY_ATTACH:
fled->attach_ta = 0;
attach_cable_check(attached_dev, &fled->attach_ta,
&fled->attach_sdp);
if (fled->attach_ta) {
s2mu205_read_reg(fled->i2c,
S2MU205_FLED_STATUS, &temp);
/* if Torch On & Charging On, set CHGIN_ENGH bit 1 */
if (temp & S2MU205_CH1_TORCH_ON ||
temp & S2MU205_CH2_TORCH_ON) {
s2mu205_update_reg(fled->i2c,
S2MU205_FLED_CTRL1,
0x80, S2MU205_CHGIN_ENGH);
}
}
return 0;
default:
goto err;
break;
}
#ifndef CONFIG_S2MU205_LEDS_I2C
gpio_free_data:
gpio_free(fled->torch_pin);
pr_info("%s: gpio free\n", __func__);
#endif
pr_info("%s: complete detached\n", __func__);
return 0;
err:
pr_err("%s: abandond access %d\n", __func__, fled->attach_ta);
return 0;
}
#endif
static void torch_led_on_off(int value)
{
pr_info("%s: Torch(%d), TA_Attach(%d)\n",
__func__, value, g_led_data[S2MU205_FLASH_LED]->attach_ta);
/* Torch On & TA Attach */
if (value && g_led_data[S2MU205_FLASH_LED]->attach_ta) {
s2mu205_update_reg(g_led_data[S2MU205_FLASH_LED]->i2c,
S2MU205_FLED_CTRL1, 0x80, S2MU205_CHGIN_ENGH);
pr_info("%s: CHGIN_ENGH set 1\n", __func__);
}
/* Torch Off */
if ((value == 0) && s2mu205_factory_mode == S2MU205_NORMAL) {
s2mu205_update_reg(g_led_data[S2MU205_FLASH_LED]->i2c,
S2MU205_FLED_CTRL1, 0x00,
S2MU205_CHGIN_ENGH);
pr_info("%s: CHGIN_ENGH set 0\n", __func__);
}
}
static void led_set(struct s2mu205_led_data *fled)
{
int id = fled->data->id, curr = fled->test_brightness;
#ifndef CONFIG_S2MU205_LEDS_I2C
int gpio_pin = (id == S2MU205_FLASH_LED) ?
fled->flash_pin : fled->torch_pin;
devm_gpio_request(fled->cdev.dev, gpio_pin,
"s2mu205_gpio_pin");
#endif
/* FLED Current setting */
s2mu205_set_current(fled, 1, curr);
if (curr == LED_TURN_OFF) {
pr_info("%s: LED Off\n", __func__);
#ifdef CONFIG_S2MU205_LEDS_I2C
/* I2C set Off */
if (id == S2MU205_FLASH_LED)
s2mu205_update_reg(fled->i2c, S2MU205_FLED_CTRL0,
S2MU205_FLASH_OFF,
S2MU205_CH1_FLASH_FLED_EN);
else if (id == S2MU205_TORCH_LED)
s2mu205_update_reg(fled->i2c, S2MU205_FLED_CTRL0,
S2MU205_TORCH_OFF,
S2MU205_CH1_TORCH_FLED_EN);
#else
/* GPIO set Low */
gpio_direction_output(gpio_pin, 0);
#endif
/* If torch mode is On, CHGIN_ENGH set 0 */
if (id == S2MU205_TORCH_LED && fled->attach_ta) {
if (s2mu205_factory_mode == S2MU205_NORMAL) {
s2mu205_update_reg(fled->i2c,
S2MU205_FLED_CTRL1,
0x00, S2MU205_CHGIN_ENGH);
}
}
#ifndef CONFIG_S2MU205_LEDS_I2C
goto gpio_free_data;
#endif
} else {
pr_info("%s: LED On\n", __func__);
/* Charging & Torch, CHGIN_ENGH set 1 */
if (id == S2MU205_TORCH_LED && fled->attach_ta) {
s2mu205_update_reg(fled->i2c,
S2MU205_FLED_CTRL1,
0x80, S2MU205_CHGIN_ENGH);
}
#ifdef CONFIG_S2MU205_LEDS_I2C
/* I2C set On */
if (id == S2MU205_FLASH_LED)
s2mu205_update_reg(fled->i2c, S2MU205_FLED_CTRL0,
S2MU205_CH1_FLASH_ON_I2C,
S2MU205_CH1_FLASH_FLED_EN);
else if (id == S2MU205_TORCH_LED)
s2mu205_update_reg(fled->i2c, S2MU205_FLED_CTRL0,
S2MU205_CH1_TORCH_ON_I2C,
S2MU205_CH1_TORCH_FLED_EN);
#else
/* GPIO set High */
gpio_direction_output(gpio_pin, 1);
goto gpio_free_data;
#endif
}
return;
#ifndef CONFIG_S2MU205_LEDS_I2C
gpio_free_data:
gpio_free(gpio_pin);
pr_info("%s: gpio free\n", __func__);
return;
#endif
}
static void s2mu205_led_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
unsigned long flags;
struct s2mu205_led_data *fled;
u8 max;
fled = container_of(led_cdev, struct s2mu205_led_data, cdev);
max = led_cdev->max_brightness;
pr_info("%s: value = %d, max = %d\n", __func__, value, max);
spin_lock_irqsave(&fled->value_lock, flags);
fled->test_brightness = min_t(int, (int)value, (int)max);
spin_unlock_irqrestore(&fled->value_lock, flags);
led_set(fled);
}
static void s2mu205_led_work(struct work_struct *work)
{
struct s2mu205_led_data *fled;
fled = container_of(work, struct s2mu205_led_data, work);
pr_debug("%s: [led]\n", __func__);
mutex_lock(&fled->lock);
led_set(fled);
mutex_unlock(&fled->lock);
}
static void s2mu205_led_setup(struct s2mu205_led_data *fled)
{
pr_info("%s: FLED setup start\n", __func__);
/* Controlled Channel1, Channel2 independently */
s2mu205_update_reg(fled->i2c, S2MU205_FLED_CTRL1,
0x00, S2MU205_EN_CHANNEL_SHARE);
/* Boost vout flash 4.5V */
s2mu205_update_reg(fled->i2c, S2MU205_FLED_CTRL2,
0x1C, S2MU205_BOOST_VOUT_FLASH);
/* FLED_BOOST_EN */
s2mu205_update_reg(fled->i2c, S2MU205_FLED_CTRL1,
0x40, S2MU205_FLED_BOOST_EN);
/* Flash timer Maximum mode */
s2mu205_update_reg(fled->i2c, S2MU205_FLED_CH1_CTRL3,
0x80, S2MU205_CHX_FLASH_TMR_MODE);
if (fled->data->id == S2MU205_FLASH_LED)
/* flash timer Maximum set */
s2mu205_update_reg(fled->i2c, S2MU205_FLED_CH1_CTRL3,
fled->data->timeout,
S2MU205_CHX_FLASH_TMR_DUR);
else
/* torch timer Maximum set */
s2mu205_update_reg(fled->i2c, S2MU205_FLED_CH1_CTRL2,
fled->data->timeout,
S2MU205_CHX_TORCH_TMR_DUR);
/* flash brightness set */
s2mu205_update_reg(fled->i2c, S2MU205_FLED_CH1_CTRL0,
fled->flash_brightness, S2MU205_CHX_FLASH_IOUT);
/* torch brightness set */
s2mu205_update_reg(fled->i2c, S2MU205_FLED_CH1_CTRL1,
fled->preflash_brightness, S2MU205_CHX_TORCH_IOUT);
/* factory mode set */
pr_info("%s: Factory mode[%s]\n", __func__,
factory_mode ? "Enable" : "Disable");
s2mu205_set_operation_mode(factory_mode);
/* I2C or GPIO mode set */
#ifdef CONFIG_S2MU205_LEDS_I2C
s2mu205_update_reg(fled->i2c, S2MU205_FLED_CTRL0,
S2MU205_TORCH_OFF, S2MU205_FLED_CTRL0_MASK);
#else
s2mu205_update_reg(fled->i2c, S2MU205_FLED_CTRL0,
S2MU205_CH1_FLASH_ON_GPIO, S2MU205_CH1_FLASH_FLED_EN);
s2mu205_update_reg(fled->i2c, S2MU205_FLED_CTRL0,
S2MU205_CH1_TORCH_ON_GPIO, S2MU205_CH1_TORCH_FLED_EN);
#endif
#ifdef S2MU205_FLED_DEBUG
s2mu205_led_dump_reg();
#endif
pr_info("%s: FLED setup complete\n", __func__);
}
#ifdef S2MU205_FLED_DEBUG
void s2mu205_led_dump_reg(void)
{
struct s2mu205_led_data *fled = g_led_data[S2MU205_FLASH_LED];
int i = 0;
u8 temp;
pr_info("[LED] S2MU205 FLED DEBUG : S\n");
/* FLED_STATUS to FLED_TEST3 */
for (i = 0x3F; i <= 0x4E; i++) {
s2mu205_read_reg(fled->i2c, i, &temp);
pr_info("[LED] 0x%02X : 0x%02X \n", i, temp);
}
pr_info("[LED] S2MU205 FLED DEBUG : X\n");
}
#endif
int s2mu205_led_mode_ctrl(int state)
{
struct s2mu205_led_data *fled = g_led_data[S2MU205_FLASH_LED];
int gpio_torch = fled->torch_pin;
int gpio_flash = fled->flash_pin;
pr_info("%s: state = %d\n", __func__, state);
devm_gpio_request(fled->cdev.dev, gpio_torch,
"s2mu205_gpio_torch");
devm_gpio_request(fled->cdev.dev, gpio_flash,
"s2mu205_gpio_flash");
switch (state) {
case S2MU205_FLED_MODE_OFF:
gpio_direction_output(gpio_torch, 0);
gpio_direction_output(gpio_flash, 0);
torch_led_on_off(0);
break;
case S2MU205_FLED_MODE_PREFLASH:
gpio_direction_output(gpio_torch, 1);
break;
case S2MU205_FLED_MODE_FLASH:
gpio_direction_output(gpio_flash, 1);
break;
case S2MU205_FLED_MODE_MOVIE:
gpio_direction_output(gpio_torch, 1);
torch_led_on_off(1);
break;
default:
break;
}
gpio_free(gpio_torch);
gpio_free(gpio_flash);
return 0;
}
static ssize_t fled_torch_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct s2mu205_led_data *fled = g_led_data[S2MU205_TORCH_LED];
char *str;
int curr, cnt = 0;
switch (fled->data->id) {
case S2MU205_FLASH_LED:
str = "FLASH";
break;
case S2MU205_TORCH_LED:
str = "TORCH";
break;
default:
str = "NONE";
break;
}
cnt += sprintf(buf + cnt, "FLED mode = %s\n", str);
/* FLED shows torch current in channel 1 */
curr = s2mu205_get_torch_curr(fled, 1);
pr_info("%s: Channel[%d], Curr[%dmA]\n", __func__, 1, curr);
if (curr >= 0)
cnt += sprintf(buf + cnt, "CH%02d: %dmA\n", 1, curr);
return cnt;
}
static ssize_t fled_torch_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct s2mu205_led_data *fled = g_led_data[S2MU205_TORCH_LED];
#ifdef CONFIG_S2MU205_LEDS_I2C
struct led_classdev *led_cdev = &fled->cdev;
#endif
int value = 0, brightness = 0;
u32 torch_current;
if ((buf == NULL) || kstrtouint(buf, 10, &value)) {
return -1;
}
pr_info("[LED]%s: value: %d\n", __func__, value);
mutex_lock(&fled->lock);
if (fled->data->id == S2MU205_FLASH_LED) {
pr_info("%s: flash is not controlled by sysfs", __func__);
mutex_unlock(&fled->lock);
return size;
}
if (value == 0) {
/* Turn off Torch */
brightness = LED_TURN_OFF;
} else if (1 <= value && value <= 32) {
/* for current check using sysfs (10mA~320mA) */
torch_current = value * 10;
brightness = s2mu205_torch_brightness(torch_current);
pr_info("%s: torch current: %dmA\n", __func__, torch_current);
} else if (value == 100) {
/* Turn on Torch */
brightness = fled->torch_brightness;
} else if (value == 200) {
/* Factory mode Turn on Torch */
brightness = fled->factory_brightness;
} else {
pr_info("[LED]%s: Invalid value:%d\n", __func__, value);
mutex_unlock(&fled->lock);
return size;
}
#ifdef CONFIG_S2MU205_LEDS_I2C
s2mu205_led_set(led_cdev, brightness);
#else
/* FLED Current setting */
s2mu205_set_current(fled, 1, brightness);
/* Torch GPIO set high */
s2mu205_update_reg(fled->i2c, S2MU205_FLED_CTRL0,
S2MU205_CH1_TORCH_ON_GPIO,
S2MU205_CH1_TORCH_FLED_EN);
if (brightness == LED_TURN_OFF)
s2mu205_led_mode_ctrl(S2MU205_FLED_MODE_OFF);
else
s2mu205_led_mode_ctrl(S2MU205_FLED_MODE_MOVIE);
#endif
#ifdef S2MU205_FLED_DEBUG
s2mu205_led_dump_reg();
#endif
mutex_unlock(&fled->lock);
return size;
}
static ssize_t fled_flash_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct s2mu205_led_data *fled = g_led_data[S2MU205_FLASH_LED];
char *str;
int curr, cnt = 0;
switch (fled->data->id) {
case S2MU205_FLASH_LED:
str = "FLASH";
break;
case S2MU205_TORCH_LED:
str = "TORCH";
break;
default:
str = "NONE";
break;
}
cnt += sprintf(buf + cnt, "FLED mode = %s\n", str);
/* FLED shows flash current in channel 1 */
curr = s2mu205_get_flash_curr(fled, 1);
pr_info("%s: Channel[%d], Curr[%dmA]\n", __func__, 1, curr);
if (curr >= 0)
cnt += sprintf(buf + cnt, "CH%02d: %dmA\n", 1, curr);
return cnt;
}
static ssize_t fled_flash_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct s2mu205_led_data *fled = g_led_data[S2MU205_FLASH_LED];
int prev_led_id = 0;
#ifdef CONFIG_S2MU205_LEDS_I2C
struct led_classdev *led_cdev = &fled->cdev;
#endif
int value = 0, brightness = 0;
int mode = -1;
if ((buf == NULL) || kstrtouint(buf, 10, &value)) {
return -1;
}
pr_info("[LED]%s: value: %d\n", __func__, value);
mutex_lock(&fled->lock);
if (fled->data->id == S2MU205_TORCH_LED) {
pr_info("%s: torch is not controlled by sysfs", __func__);
mutex_unlock(&fled->lock);
return size;
}
if (value <= 0) {
mode = S2MU205_FLED_MODE_OFF;
brightness = LED_TURN_OFF;
} else if (value == 1) {
mode = S2MU205_FLED_MODE_MOVIE;
brightness = fled->torch_brightness;
} else if (value == 100) {
/* Factory Torch*/
pr_info("%s: factory torch current [%d]\n", __func__, fled->factory_brightness);
brightness = fled->factory_brightness;
mode = S2MU205_FLED_MODE_MOVIE;
} else if (value == 200) {
/* Factory Flash */
pr_info("%s: factory flash current [%d]\n", __func__, fled->factory_brightness);
brightness = fled->factory_brightness;
mode = S2MU205_FLED_MODE_FLASH;
} else if (value <= 1010 && value >= 1001) {
mode = S2MU205_FLED_MODE_MOVIE;
/* (value) 1001, 1002, 1004, 1006, 1009 */
if (value <= 1001)
brightness = fled->flashlight_brightness[0];
else if (value <= 1002)
brightness = fled->flashlight_brightness[1];
else if (value <= 1004)
brightness = fled->flashlight_brightness[2];
else if (value <= 1006)
brightness = fled->flashlight_brightness[3];
else if (value <= 1009)
brightness = fled->flashlight_brightness[4];
else
brightness = fled->torch_brightness;
} else if (value == 2) {
mode = S2MU205_FLED_MODE_FLASH;
brightness = fled->flash_brightness;
}
if (mode == S2MU205_FLED_MODE_MOVIE) {
pr_info("%s: %d: S2MU205_FLED_MODE_MOVIE - %dmA\n", __func__, value, brightness );
/* torch current set */
#ifdef CONFIG_S2MU205_LEDS_I2C
s2mu205_led_set(led_cdev, brightness);
#else
prev_led_id = fled->data->id;
fled->data->id = S2MU205_TORCH_LED;
/* FLED Current setting */
s2mu205_set_current(fled, 1, brightness);
fled->data->id = prev_led_id;
/* Torch GPIO set high */
s2mu205_update_reg(fled->i2c, S2MU205_FLED_CTRL0,
S2MU205_CH1_TORCH_ON_GPIO,
S2MU205_CH1_TORCH_FLED_EN);
s2mu205_led_mode_ctrl(S2MU205_FLED_MODE_MOVIE);
#endif
} else if (mode == S2MU205_FLED_MODE_FLASH) {
pr_info("%s: %d: S2MU205_FLED_MODE_FLASH - %dmA\n", __func__, value, brightness );
#ifdef CONFIG_S2MU205_LEDS_I2C
s2mu205_led_set(led_cdev, brightness);
#else
prev_led_id = fled->data->id;
fled->data->id = S2MU205_FLASH_LED;
/* FLED Current setting */
s2mu205_set_current(fled, 1, brightness);
fled->data->id = prev_led_id;
/* Torch GPIO set high */
s2mu205_update_reg(fled->i2c, S2MU205_FLED_CTRL0,
S2MU205_CH1_FLASH_ON_GPIO,
S2MU205_CH1_FLASH_FLED_EN);
s2mu205_led_mode_ctrl(S2MU205_FLED_MODE_FLASH);
#endif
} else if (mode == S2MU205_FLED_MODE_OFF){
pr_info("%s: %d: S2MU205_FLED_MODE_OFF \n", __func__,value );
#ifdef CONFIG_S2MU205_LEDS_I2C
s2mu205_led_set(led_cdev, brightness);
#else
/* FLED Current setting */
s2mu205_set_current(fled, 1, brightness);
/* Torch GPIO set high */
s2mu205_update_reg(fled->i2c, S2MU205_FLED_CTRL0,
S2MU205_CH1_TORCH_ON_GPIO,
S2MU205_CH1_TORCH_FLED_EN);
s2mu205_led_mode_ctrl(S2MU205_FLED_MODE_OFF);
#endif
}
#ifdef S2MU205_FLED_DEBUG
s2mu205_led_dump_reg();
#endif
mutex_unlock(&fled->lock);
return size;
}
static DEVICE_ATTR(rear_torch_flash, 0644, fled_torch_show, fled_torch_store);
static DEVICE_ATTR(rear_flash, 0644, fled_flash_show, fled_flash_store);
#if defined(CONFIG_OF)
static int s2mu205_led_dt_parse_pdata(struct device *dev,
struct s2mu205_fled_platform_data *pdata)
{
struct device_node *led_np, *np, *c_np;
int ret, fled_index=0;
u32 temp, index;
const char *temp_str;
led_np = dev->parent->of_node;
if (!led_np) {
pr_err("%s: could not find led sub-node led_np\n", __func__);
return -ENODEV;
}
np = of_find_node_by_name(led_np, "flash_led");
if (!np) {
pr_err("%s: could not find led sub-node np\n", __func__);
return -EINVAL;
}
ret = pdata->torch_pin = of_get_named_gpio(np, "torch-gpio", 0);
if (ret < 0) {
pr_err("%s: can't get torch-gpio\n", __func__);
return ret;
}
ret = pdata->flash_pin = of_get_named_gpio(np, "flash-gpio", 0);
if (ret < 0) {
pr_err("%s: can't get flash-gpio\n", __func__);
return ret;
}
ret = of_property_read_u32(np, "flash_current", &temp);
if (ret < 0)
goto dt_err;
pdata->flash_brightness = s2mu205_flash_brightness(temp);
dev_info(dev, "flash_current = <%d>, brightness = %x\n",
temp, pdata->flash_brightness);
ret = of_property_read_u32(np, "preflash_current", &temp);
if (ret < 0)
goto dt_err;
pdata->preflash_brightness = s2mu205_torch_brightness(temp);
dev_info(dev, "preflash_current = <%d>, brightness = %x\n",
temp, pdata->preflash_brightness);
ret = of_property_read_u32(np, "movie_current", &temp);
if (ret < 0)
goto dt_err;
pdata->movie_brightness = s2mu205_torch_brightness(temp);
dev_info(dev, "movie_current = <%d>, brightness = %x\n",
temp, pdata->movie_brightness);
ret = of_property_read_u32(np, "torch_current", &temp);
if (ret < 0)
goto dt_err;
pdata->torch_brightness = s2mu205_torch_brightness(temp);
dev_info(dev, "torch_current = <%d>, brightness = %x\n",
temp, pdata->torch_brightness);
ret = of_property_read_u32(np, "factory_current", &temp);
if (ret < 0)
goto dt_err;
pdata->factory_brightness = s2mu205_torch_brightness(temp);
dev_info(dev, "factory_current = <%d>, brightness = %x\n",
temp, pdata->factory_brightness);
ret = of_property_read_u32_array(np, "flashlight_current",
pdata->flashlight_brightness, S2MU205_FLASH_LIGHT_MAX);
if (ret < 0) {
pr_err("%s : could not find flashlight_current\n", __func__);
//default setting
pdata->flashlight_brightness[0] = 45;
pdata->flashlight_brightness[1] = 75;
pdata->flashlight_brightness[2] = 125;
pdata->flashlight_brightness[3] = 195;
pdata->flashlight_brightness[4] = 270;
}
for (fled_index = 0; fled_index < S2MU205_FLASH_LIGHT_MAX; fled_index++) {
pdata->flashlight_brightness[fled_index] = s2mu205_torch_brightness(pdata->flashlight_brightness[fled_index]);
}
pdata->num_leds = of_get_child_count(np);
for_each_child_of_node(np, c_np) {
ret = of_property_read_u32(c_np, "id", &temp);
if (ret < 0)
goto dt_err;
index = temp;
if (index < S2MU205_LED_MAX) {
pdata->leds[index].id = temp;
ret = of_property_read_string(c_np,
"ledname", &temp_str);
if (ret)
goto dt_err;
pdata->leds[index].name = temp_str;
temp = index ? pdata->preflash_brightness :
pdata->flash_brightness;
if (temp > leds_cur_max[index])
temp = leds_cur_max[index];
pdata->leds[index].brightness = temp;
ret = of_property_read_u32(c_np, "timeout", &temp);
if (ret)
goto dt_err;
if (temp > leds_time_max[index])
temp = leds_time_max[index];
pdata->leds[index].timeout = temp;
}
}
return 0;
dt_err:
pr_err("%s failed to get a timeout\n", __func__);
return ret;
}
#endif /* CONFIG_OF */
int create_flash_sysfs(void)
{
int err = -ENODEV;
if (IS_ERR_OR_NULL(camera_class)) {
pr_err("flash_sysfs: error, camera class not exist");
return -ENODEV;
}
flash_dev = device_create(camera_class, NULL, 0, NULL, "flash");
if (IS_ERR(flash_dev)) {
pr_err("flash_sysfs: failed to create device(flash)\n");
return -ENODEV;
}
err = device_create_file(flash_dev, &dev_attr_rear_flash);
if (unlikely(err < 0)) {
pr_err("flash_sysfs: failed to create device file, %s\n",
dev_attr_rear_flash.attr.name);
}
err = device_create_file(flash_dev, &dev_attr_rear_torch_flash);
if (unlikely(err < 0)) {
pr_err("flash_sysfs: failed to create device file, %s\n",
dev_attr_rear_torch_flash.attr.name);
}
return 0;
}
static int s2mu205_led_probe(struct platform_device *pdev)
{
int ret = 0, i = 0, fled_index = 0;
struct s2mu205_dev *s2mu205 = dev_get_drvdata(pdev->dev.parent);
#ifndef CONFIG_OF
struct s2mu205_mfd_platform_data *s2mu205_pdata = NULL;
#endif
struct s2mu205_fled_platform_data *pdata;
struct s2mu205_led_data *fled;
struct s2mu205_led *data;
struct s2mu205_led_data **fled_data;
pr_info("%s: [s2mu205] FLED probe start\n", __func__);
if (!s2mu205) {
dev_err(&pdev->dev, "drvdata->dev.parent not supplied\n");
return -ENODEV;
}
#ifdef CONFIG_OF
pdata = kzalloc(sizeof(struct s2mu205_fled_platform_data), GFP_KERNEL);
if (!pdata) {
pr_err("%s: failed to allocate driver data\n", __func__);
return -ENOMEM;
}
if (s2mu205->dev->of_node) {
ret = s2mu205_led_dt_parse_pdata(&pdev->dev, pdata);
if (ret < 0) {
pr_err("%s: not found leds dt! ret[%d]\n",
__func__, ret);
kfree(pdata);
return -1;
}
}
#else
s2mu205_pdata = s2mu205->pdata;
if (!s2mu205_pdata) {
dev_err(&pdev->dev, "platform data not supplied\n");
return -ENODEV;
}
pdata = s2mu205_pdata->fled_platform_data;
if (!pdata) {
pr_err("%s: no platform data for this led is found\n",
__func__);
return -EFAULT;
}
#endif
fled_data = devm_kzalloc(s2mu205->dev,
sizeof(struct s2mu205_led_data *) *
S2MU205_LED_MAX, GFP_KERNEL);
if (!fled_data) {
pr_err("%s: memory allocation error fled_data", __func__);
kfree(pdata);
return -ENOMEM;
}
platform_set_drvdata(pdev, fled_data);
pr_info("%s: %d leds\n", __func__, pdata->num_leds);
for (i = 0; i != pdata->num_leds - 1; ++i) {
pr_info("%s: led[%d] setup ...\n", __func__, i);
data = devm_kzalloc(s2mu205->dev, sizeof(struct s2mu205_led),
GFP_KERNEL);
if (!data) {
pr_err("%s: memory allocation error data\n",
__func__);
ret = -ENOMEM;
continue;
}
memcpy(data, &(pdata->leds[i]), sizeof(struct s2mu205_led));
fled = devm_kzalloc(&pdev->dev,
sizeof(struct s2mu205_led_data),
GFP_KERNEL);
g_led_data[i] = fled;
fled_data[i] = fled;
if (!fled) {
pr_err("[%s] memory allocation error fled\n",
__func__);
kfree(data);
ret = -ENOMEM;
continue;
}
fled->i2c = s2mu205->i2c;
fled->data = data;
fled->cdev.name = data->name;
fled->cdev.brightness_set = s2mu205_led_set;
fled->cdev.flags = 0;
fled->cdev.brightness = data->brightness;
if(fled->data->id == S2MU205_TORCH_LED)
fled->cdev.max_brightness = S2MU205_TORCH_OUT_I_320MA;
else
fled->cdev.max_brightness = S2MU205_FLASH_OUT_I_1200MA;
mutex_init(&fled->lock);
spin_lock_init(&fled->value_lock);
INIT_WORK(&fled->work, s2mu205_led_work);
ret = led_classdev_register(&pdev->dev, &fled->cdev);
if (ret < 0) {
pr_err("unable to register LED\n");
cancel_work_sync(&fled->work);
mutex_destroy(&fled->lock);
kfree(data);
kfree(fled);
fled_data[i] = NULL;
g_led_data[i] = NULL;
ret = -EFAULT;
continue;
}
if (fled->data->id == S2MU205_FLASH_LED) {
create_flash_sysfs();
}
#ifndef CONFIG_S2MU205_LEDS_I2C
if (gpio_is_valid(pdata->torch_pin) &&
gpio_is_valid(pdata->flash_pin)) {
pr_info("%s: s2mu205 fled gpio allocation\n",
__func__);
fled->torch_pin = pdata->torch_pin;
fled->flash_pin = pdata->flash_pin;
gpio_request_one(pdata->torch_pin,
GPIOF_OUT_INIT_LOW,
"LED_GPIO_OUTPUT_LOW");
gpio_request_one(pdata->flash_pin,
GPIOF_OUT_INIT_LOW,
"LED_GPIO_OUTPUT_LOW");
gpio_free(pdata->torch_pin);
gpio_free(pdata->flash_pin);
}
#endif
fled->flash_brightness = pdata->flash_brightness;
fled->preflash_brightness = pdata->preflash_brightness;
fled->movie_brightness = pdata->movie_brightness;
fled->torch_brightness = pdata->torch_brightness;
fled->factory_brightness = pdata->factory_brightness;
for (fled_index = 0; fled_index < S2MU205_FLASH_LIGHT_MAX; fled_index++) {
fled->flashlight_brightness[fled_index] = pdata->flashlight_brightness[fled_index];
}
#ifdef CONFIG_MUIC_NOTIFIER
muic_notifier_register(&fled->batt_nb,
ta_notification,
MUIC_NOTIFY_DEV_CHARGER);
#endif
s2mu205_led_setup(fled);
}
#ifdef CONFIG_OF
kfree(pdata);
#endif
return 0;
}
static int s2mu205_led_remove(struct platform_device *pdev)
{
struct s2mu205_led_data **fled_data = platform_get_drvdata(pdev);
int i;
for (i = 0; i != S2MU205_LED_MAX; ++i) {
if (fled_data[i] == NULL)
continue;
cancel_work_sync(&fled_data[i]->work);
mutex_destroy(&fled_data[i]->lock);
led_classdev_unregister(&fled_data[i]->cdev);
kfree(fled_data[i]->data);
kfree(fled_data[i]);
g_led_data[i] = NULL;
}
kfree(fled_data);
return 0;
}
static const struct platform_device_id s2mu205_leds_id[] = {
{"leds-s2mu205", 0},
{},
};
static struct platform_driver s2mu205_led_driver = {
.driver = {
.name = "leds-s2mu205",
.owner = THIS_MODULE,
},
.probe = s2mu205_led_probe,
.remove = s2mu205_led_remove,
.id_table = s2mu205_leds_id,
};
static int __init s2mu205_led_driver_init(void)
{
return platform_driver_register(&s2mu205_led_driver);
}
module_init(s2mu205_led_driver_init);
static void __exit s2mu205_led_driver_exit(void)
{
platform_driver_unregister(&s2mu205_led_driver);
}
module_exit(s2mu205_led_driver_exit);
MODULE_AUTHOR("SUJI LEE <suji0908.lee@samsung.com>");
MODULE_DESCRIPTION("SAMSUNG s2mu205 LED Driver");
MODULE_LICENSE("GPL");
Reference in New Issue View Git Blame Copy Permalink