A-Team_Digital_Solutions/android_kernel_motorola_sm6375
Watch
2
0
Fork
You've already forked android_kernel_motorola_sm6375
 0
mirror of https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git synced 2026-10-30 03:27:44 -04:00
Code Issues Projects Releases Packages Wiki Activity

Merge branch 'staging/motorola-kernel-modules/MMI-U1UGS34.23-110-23-2' into lineage-22.2

Browse source 
Based on tag 'MMI-U1UGS34.23-110-23-2' of https://github.com/MotorolaMobilityLLC/motorola-kernel-modules

Fogos push for Android 14

* staging/motorola-kernel-modules/MMI-U1UGS34.23-110-23-2: (3149 commits)
  Documentation: Remove slg51000.txt
  treewide: Remove conflicting Makefiles
  include: Remove unused synaptics_tcm.h header
  fs: Remove exfat drivers
  dlkm: goodix_fod_mmi: fix KE issue
  dlkm: goodix_fod: support drm panel notification
  moto_swap: Add reset_bdev to close backing dev for ramboost2.0
  add page fault pages to list head to avoid be swapped out soon
  fogos: TP: open 1st icnl9916c force up config
  workaround fix long page fault issue
  Revert "(CR) moto_swap: Add SWP_SYNCHRONOUS_IO cmd for ioctl"
  fix null pointer at quota_day_store
  moto_swap: Add SWP_SYNCHRONOUS_IO cmd for ioctl
  charge: config qg iterm small than FCC
  moto_swap:fix kernel panic on memcg conf
  Moto kernel protection module
  Add macro to close debug function in user build
  fogo/motorola:Fogo 5g na optimize stowed mode
  input: goodix_berlin: enable palm cancel for report id
  Update UWB driver to version 7.4
  ...

 Conflicts:
	Documentation/devicetree/bindings~HEAD

Change-Id: I1e380097e692b2efea451cbcf4dc42d972e6dd5a
This commit is contained in:
Michael Bestas 2025-03-21 18:42:06 +02:00
commit af40082e75
No known key found for this signature in database
2037 changed files with 1289620 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

10
drivers/leds/Android.mk Executable file
View file

@ -0,0 +1,10 @@
DLKM_DIR := motorola/kernel/modules
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := leds-indicator-pwm.ko
LOCAL_MODULE_TAGS := optional
LOCAL_MODULE_PATH := $(KERNEL_MODULES_OUT)
include $(DLKM_DIR)/AndroidKernelModule.mk
include $(call first-makefiles-under,$(LOCAL_PATH))

6
drivers/leds/Kbuild Executable file
View file

@ -0,0 +1,6 @@
# add -Wall to try to catch everything we can.
EXTRA_CFLAGS += -Wall
EXTRA_CFLAGS += -I$(TOP)/motorola/kernel/modules/include
obj-m += leds-indicator-pwm.o

8
drivers/leds/aw2033/Android.mk Executable file
View file

@ -0,0 +1,8 @@
DLKM_DIR := motorola/kernel/modules
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := leds_aw2033.ko
LOCAL_MODULE_TAGS := optional
LOCAL_MODULE_PATH := $(KERNEL_MODULES_OUT)
include $(DLKM_DIR)/AndroidKernelModule.mk

6
drivers/leds/aw2033/Kbuild Executable file
View file

@ -0,0 +1,6 @@
# add -Wall to try to catch everything we can.
EXTRA_CFLAGS += -Wall
EXTRA_CFLAGS += -I$(TOP)/motorola/kernel/modules/include
obj-m += leds_aw2033.o

657
drivers/leds/aw2033/leds_aw2033.c Normal file
View file

@ -0,0 +1,657 @@
/*
* Copyright (c) 2017, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
* only version 2 as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
*/
#include <linux/delay.h>
#include <linux/i2c.h>
#include <linux/init.h>
#include <linux/leds.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#include <linux/regulator/consumer.h>
#include "leds_aw2033.h"
#define AW2033_DRIVER_VERSION "V1.0.2"
/* register address */
#define AW2033_REG_RESET 0x00
#define AW2033_REG_GCR1 0x01
#define AW2033_REG_STATUS 0x02
#define AW2033_REG_PATST 0x03
#define AW2033_REG_GCR2 0x04
#define AW2033_REG_LEDEN 0x30
#define AW2033_REG_LCFG0 0x31
#define AW2033_REG_LCFG1 0x32
#define AW2033_REG_LCFG2 0x33
#define AW2033_REG_PWM0 0x34
#define AW2033_REG_PWM1 0x35
#define AW2033_REG_PWM2 0x36
#define AW2033_REG_LED0T0 0x37
#define AW2033_REG_LED0T1 0x38
#define AW2033_REG_LED0T2 0x39
#define AW2033_REG_LED1T0 0x3A
#define AW2033_REG_LED1T1 0x3B
#define AW2033_REG_LED1T2 0x3C
#define AW2033_REG_LED2T0 0x3D
#define AW2033_REG_LED2T1 0x3E
#define AW2033_REG_LED2T2 0x3F
/* register bits */
#define AW2033_CHIPID 0x09
#define AW2033_RESET_MASK 0x55
#define AW2033_CHIP_DISABLE_MASK 0x00
#define AW2033_CHIP_ENABLE_MASK 0x01
#define AW2033_CHARGE_DISABLE_MASK 0x02
#define AW2033_LED_BREATH_MODE_MASK 0x10
#define AW2033_LED_MANUAL_MODE_MASK 0x00
#define AW2033_LED_BREATHE_PWM_MASK 0xFF
#define AW2033_LED_MANUAL_PWM_MASK 0xFF
#define AW2033_LED_FADEIN_MODE_MASK 0x20
#define AW2033_LED_FADEOUT_MODE_MASK 0x40
#define AW2033_CLEAR_MASK 0x00
#define MAX_RISE_TIME_MS 15
#define MAX_HOLD_TIME_MS 15
#define MAX_FALL_TIME_MS 15
#define MAX_OFF_TIME_MS 15
/* aw2033 register read/write access*/
#define REG_NONE_ACCESS 0
#define REG_RD_ACCESS (1 << 0)
#define REG_WR_ACCESS (1 << 1)
#define AW2033_REG_MAX 0x7F
const unsigned char aw2033_reg_access[AW2033_REG_MAX] = {
[AW2033_REG_RESET] = REG_RD_ACCESS|REG_WR_ACCESS,
[AW2033_REG_GCR1] = REG_RD_ACCESS|REG_WR_ACCESS,
[AW2033_REG_STATUS] = REG_RD_ACCESS,
[AW2033_REG_PATST] = REG_RD_ACCESS,
[AW2033_REG_GCR2] = REG_RD_ACCESS|REG_WR_ACCESS,
[AW2033_REG_LEDEN] = REG_RD_ACCESS|REG_WR_ACCESS,
[AW2033_REG_LCFG0] = REG_RD_ACCESS|REG_WR_ACCESS,
[AW2033_REG_LCFG1] = REG_RD_ACCESS|REG_WR_ACCESS,
[AW2033_REG_LCFG2] = REG_RD_ACCESS|REG_WR_ACCESS,
[AW2033_REG_PWM0] = REG_RD_ACCESS|REG_WR_ACCESS,
[AW2033_REG_PWM1] = REG_RD_ACCESS|REG_WR_ACCESS,
[AW2033_REG_PWM2] = REG_RD_ACCESS|REG_WR_ACCESS,
[AW2033_REG_LED0T0] = REG_RD_ACCESS|REG_WR_ACCESS,
[AW2033_REG_LED0T1] = REG_RD_ACCESS|REG_WR_ACCESS,
[AW2033_REG_LED0T2] = REG_RD_ACCESS|REG_WR_ACCESS,
[AW2033_REG_LED1T0] = REG_RD_ACCESS|REG_WR_ACCESS,
[AW2033_REG_LED1T1] = REG_RD_ACCESS|REG_WR_ACCESS,
[AW2033_REG_LED1T2] = REG_RD_ACCESS|REG_WR_ACCESS,
[AW2033_REG_LED2T0] = REG_RD_ACCESS|REG_WR_ACCESS,
[AW2033_REG_LED2T1] = REG_RD_ACCESS|REG_WR_ACCESS,
[AW2033_REG_LED2T2] = REG_RD_ACCESS|REG_WR_ACCESS,
};
struct aw2033_led {
struct i2c_client *client;
struct led_classdev cdev;
struct aw2033_platform_data *pdata;
struct work_struct brightness_work;
struct mutex lock;
int num_leds;
int id;
};
static int aw2033_write(struct aw2033_led *led, u8 reg, u8 val)
{
int ret = -EINVAL, retry_times = 0;
do {
ret = i2c_smbus_write_byte_data(led->client, reg, val);
retry_times++;
if (retry_times == 5)
break;
} while (ret < 0);
return ret;
}
static int aw2033_read(struct aw2033_led *led, u8 reg, u8 *val)
{
int ret = -EINVAL, retry_times = 0;
do {
ret = i2c_smbus_read_byte_data(led->client, reg);
retry_times++;
if (retry_times == 5)
break;
} while (ret < 0);
if (ret < 0)
return ret;
*val = ret;
return 0;
}
static void aw2033_soft_reset(struct aw2033_led *led)
{
int reg;
/* don't use reset reg, it cause CHGDIS enable */
/* aw2033_write(led, AW2033_REG_RESET, AW2033_RESET_MASK); */
aw2033_write(led, AW2033_REG_GCR1, AW2033_CHARGE_DISABLE_MASK);
aw2033_write(led, AW2033_REG_GCR2, AW2033_CLEAR_MASK);
for (reg = AW2033_REG_LEDEN; reg <= AW2033_REG_LED2T2; reg++)
aw2033_write(led, reg, AW2033_CLEAR_MASK);
/* msleep(5); */ /* don't need delay anymore*/
}
static void aw2033_brightness_work(struct work_struct *work)
{
struct aw2033_led *led = container_of(work, struct aw2033_led,
brightness_work);
u8 val;
mutex_lock(&led->pdata->led->lock);
/* enable aw2033 if disabled */
aw2033_read(led, AW2033_REG_GCR1, &val);
/*only enable when brightness is bigger than 0, avoid blink when boot */
if ((led->cdev.brightness > 0) && !(val&AW2033_CHIP_ENABLE_MASK)) {
aw2033_write(led, AW2033_REG_GCR1,
AW2033_CHARGE_DISABLE_MASK | AW2033_CHIP_ENABLE_MASK);
msleep(2);
}
if (led->cdev.brightness > 0) {
if (led->cdev.brightness > led->cdev.max_brightness)
led->cdev.brightness = led->cdev.max_brightness;
aw2033_write(led, AW2033_REG_GCR2, led->pdata->imax);
aw2033_write(led, AW2033_REG_LCFG0 + led->id,
(AW2033_LED_MANUAL_MODE_MASK | led->pdata->led_current));
aw2033_write(led, AW2033_REG_PWM0 + led->id, led->cdev.brightness);
aw2033_read(led, AW2033_REG_LEDEN, &val);
aw2033_write(led, AW2033_REG_LEDEN, val | (1 << led->id));
} else {
aw2033_read(led, AW2033_REG_LEDEN, &val);
aw2033_write(led, AW2033_REG_LEDEN, val & (~(1 << led->id)));
}
/*
* If value in AW_REG_LED_ENABLE is 0, it means the RGB leds are
* all off. So we need to power it off.
*/
aw2033_read(led, AW2033_REG_LEDEN, &val);
if (val == 0) {
aw2033_write(led, AW2033_REG_GCR1,
AW2033_CHARGE_DISABLE_MASK | AW2033_CHIP_DISABLE_MASK);
mutex_unlock(&led->pdata->led->lock);
return;
}
mutex_unlock(&led->pdata->led->lock);
}
static void aw2033_led_blink_set(struct aw2033_led *led, unsigned long blinking)
{
u8 val;
/* enable aw2033 if disabled */
aw2033_read(led, AW2033_REG_GCR1, &val);
/*only enable when blinking is bigger than 0, avoid blink when boot */
if ((blinking > 0) && !(val&AW2033_CHIP_ENABLE_MASK)) {
aw2033_write(led, AW2033_REG_GCR1,
AW2033_CHARGE_DISABLE_MASK | AW2033_CHIP_ENABLE_MASK);
msleep(2);
}
led->cdev.brightness = blinking;
if (led->cdev.brightness > led->cdev.max_brightness)
led->cdev.brightness = led->cdev.max_brightness;
pr_info("aw2033_led_blink_set %ld %d\n", blinking, led->cdev.brightness);
if (blinking > 0) {
aw2033_write(led, AW2033_REG_GCR2, led->pdata->imax);
aw2033_write(led, AW2033_REG_PWM0 + led->id, led->cdev.brightness);
aw2033_write(led, AW2033_REG_LED0T0 + led->id*3,
(led->pdata->rise_time_ms << 4 | led->pdata->hold_time_ms));
aw2033_write(led, AW2033_REG_LED0T1 + led->id*3,
(led->pdata->fall_time_ms << 4 | led->pdata->off_time_ms));
aw2033_write(led, AW2033_REG_LCFG0 + led->id,
(AW2033_LED_BREATH_MODE_MASK | led->pdata->led_current));
aw2033_read(led, AW2033_REG_LEDEN, &val);
aw2033_write(led, AW2033_REG_LEDEN, val | (1 << led->id));
} else {
aw2033_read(led, AW2033_REG_LEDEN, &val);
aw2033_write(led, AW2033_REG_LEDEN, val & (~(1 << led->id)));
}
/*
* If value in AW_REG_LED_ENABLE is 0, it means the RGB leds are
* all off. So we need to power it off.
*/
aw2033_read(led, AW2033_REG_LEDEN, &val);
if (val == 0) {
aw2033_write(led, AW2033_REG_GCR1,
AW2033_CHARGE_DISABLE_MASK | AW2033_CHIP_DISABLE_MASK);
}
}
static void aw2033_set_brightness(struct led_classdev *cdev,
enum led_brightness brightness)
{
struct aw2033_led *led = container_of(cdev, struct aw2033_led, cdev);
led->cdev.brightness = brightness;
pr_info("aw2033_set_brightness %d\n", brightness);
schedule_work(&led->brightness_work);
}
static ssize_t aw2033_store_blink(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t len)
{
unsigned long blinking;
struct led_classdev *led_cdev = dev_get_drvdata(dev);
struct aw2033_led *led =
container_of(led_cdev, struct aw2033_led, cdev);
ssize_t ret = -EINVAL;
ret = kstrtoul(buf, 10, &blinking);
if (ret)
return ret;
mutex_lock(&led->pdata->led->lock);
aw2033_led_blink_set(led, blinking);
mutex_unlock(&led->pdata->led->lock);
return len;
}
static ssize_t aw2033_led_time_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct led_classdev *led_cdev = dev_get_drvdata(dev);
struct aw2033_led *led =
container_of(led_cdev, struct aw2033_led, cdev);
return snprintf(buf, PAGE_SIZE, "%d %d %d %d\n",
led->pdata->rise_time_ms, led->pdata->hold_time_ms,
led->pdata->fall_time_ms, led->pdata->off_time_ms);
}
static ssize_t aw2033_led_time_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t len)
{
struct led_classdev *led_cdev = dev_get_drvdata(dev);
struct aw2033_led *led =
container_of(led_cdev, struct aw2033_led, cdev);
int rc, rise_time_ms, hold_time_ms, fall_time_ms, off_time_ms;
rc = sscanf(buf, "%d %d %d %d",
&rise_time_ms, &hold_time_ms,
&fall_time_ms, &off_time_ms);
mutex_lock(&led->pdata->led->lock);
led->pdata->rise_time_ms = (rise_time_ms > MAX_RISE_TIME_MS) ?
MAX_RISE_TIME_MS : rise_time_ms;
led->pdata->hold_time_ms = (hold_time_ms > MAX_HOLD_TIME_MS) ?
MAX_HOLD_TIME_MS : hold_time_ms;
led->pdata->fall_time_ms = (fall_time_ms > MAX_FALL_TIME_MS) ?
MAX_FALL_TIME_MS : fall_time_ms;
led->pdata->off_time_ms = (off_time_ms > MAX_OFF_TIME_MS) ?
MAX_OFF_TIME_MS : off_time_ms;
aw2033_led_blink_set(led, 1);
mutex_unlock(&led->pdata->led->lock);
return len;
}
static ssize_t aw2033_reg_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct led_classdev *led_cdev = dev_get_drvdata(dev);
struct aw2033_led *led =
container_of(led_cdev, struct aw2033_led, cdev);
unsigned char i, reg_val;
ssize_t len = 0;
for (i = 0; i < AW2033_REG_MAX; i++) {
if (!(aw2033_reg_access[i] & REG_RD_ACCESS))
continue;
aw2033_read(led, i, &reg_val);
len += snprintf(buf + len, PAGE_SIZE - len, "reg:0x%02x=0x%02x\n", i, reg_val);
}
return len;
}
static ssize_t aw2033_reg_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t len)
{
struct led_classdev *led_cdev = dev_get_drvdata(dev);
struct aw2033_led *led =
container_of(led_cdev, struct aw2033_led, cdev);
unsigned int databuf[2];
if (sscanf(buf, "%x %x", &databuf[0], &databuf[1]) == 2)
aw2033_write(led, (unsigned char)databuf[0], (unsigned char)databuf[1]);
return len;
}
static DEVICE_ATTR(blink, 0664, NULL, aw2033_store_blink);
static DEVICE_ATTR(led_time, 0664, aw2033_led_time_show, aw2033_led_time_store);
static DEVICE_ATTR(reg, 0664, aw2033_reg_show, aw2033_reg_store);
static struct attribute *aw2033_led_attributes[] = {
&dev_attr_blink.attr,
&dev_attr_led_time.attr,
&dev_attr_reg.attr,
NULL,
};
static struct attribute_group aw2033_led_attr_group = {
.attrs = aw2033_led_attributes
};
static int aw2033_check_chipid(struct aw2033_led *led)
{
u8 val;
u8 cnt;
for (cnt = 5; cnt > 0; cnt--) {
aw2033_read(led, AW2033_REG_RESET, &val);
dev_notice(&led->client->dev, "aw2033 chip id %0x", val);
if (val == AW2033_CHIPID)
return 0;
}
return -EINVAL;
}
static int aw2033_led_err_handle(struct aw2033_led *led_array,
int parsed_leds)
{
int i;
/*
* If probe fails, cannot free resource of all LEDs, only free
* resources of LEDs which have allocated these resource really.
*/
for (i = 0; i < parsed_leds; i++) {
sysfs_remove_group(&led_array[i].cdev.dev->kobj,
&aw2033_led_attr_group);
led_classdev_unregister(&led_array[i].cdev);
cancel_work_sync(&led_array[i].brightness_work);
devm_kfree(&led_array->client->dev, led_array[i].pdata);
led_array[i].pdata = NULL;
}
return i;
}
static int aw2033_led_parse_child_node(struct aw2033_led *led_array,
struct device_node *node)
{
struct aw2033_led *led;
struct device_node *temp;
struct aw2033_platform_data *pdata;
int rc = 0, parsed_leds = 0;
for_each_child_of_node(node, temp) {
led = &led_array[parsed_leds];
led->client = led_array->client;
pdata = devm_kzalloc(&led->client->dev,
sizeof(struct aw2033_platform_data),
GFP_KERNEL);
if (!pdata) {
dev_err(&led->client->dev,
"Failed to allocate memory\n");
goto free_err;
}
pdata->led = led_array;
led->pdata = pdata;
rc = of_property_read_string(temp, "aw2033,name",
&led->cdev.name);
if (rc < 0) {
dev_err(&led->client->dev,
"Failure reading led name, rc = %d\n", rc);
goto free_pdata;
}
rc = of_property_read_u32(temp, "aw2033,id",
&led->id);
if (rc < 0) {
dev_err(&led->client->dev,
"Failure reading id, rc = %d\n", rc);
goto free_pdata;
}
rc = of_property_read_u32(temp, "aw2033,imax",
&led->pdata->imax);
if (rc < 0) {
dev_err(&led->client->dev,
"Failure reading id, rc = %d\n", rc);
goto free_pdata;
}
rc = of_property_read_u32(temp, "aw2033,led-current",
&led->pdata->led_current);
if (rc < 0) {
dev_err(&led->client->dev,
"Failure reading led-current, rc = %d\n", rc);
goto free_pdata;
}
rc = of_property_read_u32(temp, "aw2033,max-brightness",
&led->cdev.max_brightness);
if (rc < 0) {
dev_err(&led->client->dev,
"Failure reading max-brightness, rc = %d\n",
rc);
goto free_pdata;
}
rc = of_property_read_u32(temp, "aw2033,rise-time-ms",
&led->pdata->rise_time_ms);
if (rc < 0) {
dev_err(&led->client->dev,
"Failure reading rise-time-ms, rc = %d\n", rc);
goto free_pdata;
}
rc = of_property_read_u32(temp, "aw2033,hold-time-ms",
&led->pdata->hold_time_ms);
if (rc < 0) {
dev_err(&led->client->dev,
"Failure reading hold-time-ms, rc = %d\n", rc);
goto free_pdata;
}
rc = of_property_read_u32(temp, "aw2033,fall-time-ms",
&led->pdata->fall_time_ms);
if (rc < 0) {
dev_err(&led->client->dev,
"Failure reading fall-time-ms, rc = %d\n", rc);
goto free_pdata;
}
rc = of_property_read_u32(temp, "aw2033,off-time-ms",
&led->pdata->off_time_ms);
if (rc < 0) {
dev_err(&led->client->dev,
"Failure reading off-time-ms, rc = %d\n", rc);
goto free_pdata;
}
INIT_WORK(&led->brightness_work, aw2033_brightness_work);
led->cdev.brightness_set = aw2033_set_brightness;
rc = led_classdev_register(&led->client->dev, &led->cdev);
if (rc) {
dev_err(&led->client->dev,
"unable to register led %d,rc=%d\n",
led->id, rc);
goto free_pdata;
}
rc = sysfs_create_group(&led->cdev.dev->kobj,
&aw2033_led_attr_group);
if (rc) {
dev_err(&led->client->dev, "led sysfs rc: %d\n", rc);
goto free_class;
}
parsed_leds++;
}
return 0;
free_class:
aw2033_led_err_handle(led_array, parsed_leds);
led_classdev_unregister(&led_array[parsed_leds].cdev);
cancel_work_sync(&led_array[parsed_leds].brightness_work);
devm_kfree(&led->client->dev, led_array[parsed_leds].pdata);
led_array[parsed_leds].pdata = NULL;
return rc;
free_pdata:
aw2033_led_err_handle(led_array, parsed_leds);
devm_kfree(&led->client->dev, led_array[parsed_leds].pdata);
return rc;
free_err:
aw2033_led_err_handle(led_array, parsed_leds);
return rc;
}
static int aw2033_led_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct aw2033_led *led_array;
struct device_node *node;
int ret, num_leds = 0;
node = client->dev.of_node;
if (node == NULL)
return -EINVAL;
num_leds = of_get_child_count(node);
if (!num_leds)
return -EINVAL;
led_array = devm_kzalloc(&client->dev,
(sizeof(struct aw2033_led) * num_leds), GFP_KERNEL);
if (!led_array)
return -ENOMEM;
led_array->client = client;
led_array->num_leds = num_leds;
mutex_init(&led_array->lock);
ret = aw2033_led_parse_child_node(led_array, node);
if (ret) {
dev_err(&client->dev, "parsed node error\n");
goto free_led_arry;
}
i2c_set_clientdata(client, led_array);
ret = aw2033_check_chipid(led_array);
if (ret) {
dev_err(&client->dev, "Check chip id error\n");
goto fail_parsed_node;
}
/* soft rst */
aw2033_soft_reset(led_array);
return 0;
fail_parsed_node:
aw2033_led_err_handle(led_array, num_leds);
free_led_arry:
mutex_destroy(&led_array->lock);
devm_kfree(&client->dev, led_array);
led_array = NULL;
return ret;
}
static int aw2033_led_remove(struct i2c_client *client)
{
struct aw2033_led *led_array = i2c_get_clientdata(client);
int i, parsed_leds = led_array->num_leds;
for (i = 0; i < parsed_leds; i++) {
sysfs_remove_group(&led_array[i].cdev.dev->kobj,
&aw2033_led_attr_group);
led_classdev_unregister(&led_array[i].cdev);
cancel_work_sync(&led_array[i].brightness_work);
devm_kfree(&client->dev, led_array[i].pdata);
led_array[i].pdata = NULL;
}
mutex_destroy(&led_array->lock);
devm_kfree(&client->dev, led_array);
led_array = NULL;
return 0;
}
static void aw2033_led_shutdown(struct i2c_client *client)
{
struct aw2033_led *led_array = i2c_get_clientdata(client);
pr_info("aw2033 shutdown start.\n");
aw2033_write(led_array, AW2033_REG_GCR1,
AW2033_CHARGE_DISABLE_MASK | AW2033_CHIP_DISABLE_MASK);
pr_info("aw2033 shutdown done.\n");
}
static const struct i2c_device_id aw2033_led_id[] = {
{"aw2033_led", 0},
{},
};
MODULE_DEVICE_TABLE(i2c, aw2033_led_id);
static struct of_device_id aw2033_match_table[] = {
{ .compatible = "awinic,aw2033_led",},
{ },
};
static struct i2c_driver aw2033_led_driver = {
.probe = aw2033_led_probe,
.remove = aw2033_led_remove,
.shutdown = aw2033_led_shutdown,
.driver = {
.name = "aw2033_led",
.owner = THIS_MODULE,
.of_match_table = of_match_ptr(aw2033_match_table),
},
.id_table = aw2033_led_id,
};
static int __init aw2033_led_init(void)
{
pr_info("%s: driver version: %s\n", __func__, AW2033_DRIVER_VERSION);
return i2c_add_driver(&aw2033_led_driver);
}
module_init(aw2033_led_init);
static void __exit aw2033_led_exit(void)
{
i2c_del_driver(&aw2033_led_driver);
}
module_exit(aw2033_led_exit);
MODULE_AUTHOR("<[email protected]>");
MODULE_DESCRIPTION("AWINIC AW2033 LED driver");
MODULE_LICENSE("GPL v2");

39
drivers/leds/aw2033/leds_aw2033.h Normal file
View file

@ -0,0 +1,39 @@
/*
* Copyright (c) 2015, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
* only version 2 as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
*/
#ifndef __LINUX_AW2033_LED_H__
#define __LINUX_AW2033_LED_H__
/* The definition of each time described as shown in figure.
* /-----------\
* / | \
* /| | |\
* / | | | \-----------
* |hold_time_ms | |
* | | |
* rise_time_ms fall_time_ms |
* off_time_ms
*/
struct aw2033_platform_data {
int imax;
int led_current;
int rise_time_ms;
int hold_time_ms;
int fall_time_ms;
int off_time_ms;
struct aw2033_led *led;
};
#endif

512
drivers/leds/leds-indicator-pwm.c Normal file
View file

@ -0,0 +1,512 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2018-2019, 2021, The Linux Foundation. All rights reserved.
*/
#include <linux/bitops.h>
#include <linux/device.h>
#include <linux/err.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/leds.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/platform_device.h>
#include <linux/pwm.h>
#include <linux/types.h>
#include <linux/pinctrl/consumer.h>
#define TRILED_NUM_MAX 3
#define PWM_PERIOD_DEFAULT_NS 1000000
struct pwm_setting {
u64 pre_period_ns;
u64 period_ns;
u64 duty_ns;
};
struct led_setting {
u64 on_ms;
u64 off_ms;
enum led_brightness brightness;
bool blink;
bool breath;
};
struct qpnp_led_dev {
struct led_classdev cdev;
struct pwm_device *pwm_dev;
struct pwm_setting pwm_setting;
struct led_setting led_setting;
struct indicator_led_chip *chip;
struct mutex lock;
const char *label;
const char *default_trigger;
u8 id;
bool blinking;
bool breathing;
};
struct indicator_led_chip {
struct device *dev;
struct qpnp_led_dev *leds;
struct nvmem_device *pbs_nvmem;
struct mutex bus_lock;
int num_leds;
u16 reg_base;
u8 subtype;
u8 bitmap;
struct pinctrl *pinctrl;
struct pinctrl_state *pin_sta_default;
};
static int __indicator_led_config_pwm(struct qpnp_led_dev *led,
struct pwm_setting *pwm)
{
struct pwm_state pstate;
int rc;
pwm_get_state(led->pwm_dev, &pstate);
pstate.enabled = !!(pwm->duty_ns != 0);
pstate.period = pwm->period_ns;
pstate.duty_cycle = pwm->duty_ns;
pstate.output_type = led->led_setting.breath ?
PWM_OUTPUT_MODULATED : PWM_OUTPUT_FIXED;
rc = pwm_apply_state(led->pwm_dev, &pstate);
if (rc < 0)
dev_err(led->chip->dev, "Apply PWM state for %s led failed, rc=%d\n",
led->cdev.name, rc);
return rc;
}
static int __indicator_led_set(struct qpnp_led_dev *led)
{
int rc = 0;
rc = __indicator_led_config_pwm(led, &led->pwm_setting);
if (rc < 0) {
dev_err(led->chip->dev, "Configure PWM for %s led failed, rc=%d\n",
led->cdev.name, rc);
return rc;
}
return rc;
}
static int indicator_led_set(struct qpnp_led_dev *led)
{
u64 on_ms, off_ms, period_ns, duty_ns;
enum led_brightness brightness = led->led_setting.brightness;
int rc = 0;
if (led->led_setting.blink) {
on_ms = led->led_setting.on_ms;
off_ms = led->led_setting.off_ms;
duty_ns = on_ms * NSEC_PER_MSEC;
period_ns = (on_ms + off_ms) * NSEC_PER_MSEC;
if (period_ns < duty_ns && duty_ns != 0)
period_ns = duty_ns + 1;
} else {
/* Use initial period if no blinking is required */
period_ns = led->pwm_setting.pre_period_ns;
if (brightness == LED_OFF)
duty_ns = 0;
duty_ns = period_ns * brightness;
do_div(duty_ns, LED_FULL);
if (period_ns < duty_ns && duty_ns != 0)
period_ns = duty_ns + 1;
}
dev_dbg(led->chip->dev, "PWM settings for %s led: period = %lluns, duty = %lluns\n",
led->cdev.name, period_ns, duty_ns);
led->pwm_setting.duty_ns = duty_ns;
led->pwm_setting.period_ns = period_ns;
rc = __indicator_led_set(led);
if (rc < 0) {
dev_err(led->chip->dev, "__indicator_led_set %s failed, rc=%d\n",
led->cdev.name, rc);
return rc;
}
if (led->led_setting.blink) {
led->cdev.brightness = LED_FULL;
led->blinking = true;
led->breathing = false;
} else if (led->led_setting.breath) {
led->cdev.brightness = LED_FULL;
led->blinking = false;
led->breathing = true;
} else {
led->cdev.brightness = led->led_setting.brightness;
led->blinking = false;
led->breathing = false;
}
return rc;
}
static int indicator_led_set_brightness(struct led_classdev *led_cdev,
enum led_brightness brightness)
{
struct qpnp_led_dev *led =
container_of(led_cdev, struct qpnp_led_dev, cdev);
int rc = 0;
mutex_lock(&led->lock);
if (brightness > LED_FULL)
brightness = LED_FULL;
if (brightness == led->led_setting.brightness &&
!led->blinking && !led->breathing) {
mutex_unlock(&led->lock);
return 0;
}
led->led_setting.brightness = brightness;
if (!!brightness)
led->led_setting.off_ms = 0;
else
led->led_setting.on_ms = 0;
led->led_setting.blink = false;
led->led_setting.breath = false;
rc = indicator_led_set(led);
if (rc)
dev_err(led->chip->dev, "Set led failed for %s, rc=%d\n",
led->label, rc);
mutex_unlock(&led->lock);
return rc;
}
static enum led_brightness indicator_led_get_brightness(
struct led_classdev *led_cdev)
{
return led_cdev->brightness;
}
static int indicator_led_set_blink(struct led_classdev *led_cdev,
unsigned long *on_ms, unsigned long *off_ms)
{
struct qpnp_led_dev *led =
container_of(led_cdev, struct qpnp_led_dev, cdev);
int rc = 0;
mutex_lock(&led->lock);
if (led->blinking && *on_ms == led->led_setting.on_ms &&
*off_ms == led->led_setting.off_ms) {
dev_dbg(led_cdev->dev, "Ignore, on/off setting is not changed: on %lums, off %lums\n",
*on_ms, *off_ms);
mutex_unlock(&led->lock);
return 0;
}
if (*on_ms == 0) {
led->led_setting.blink = false;
led->led_setting.breath = false;
led->led_setting.brightness = LED_OFF;
} else if (*off_ms == 0) {
led->led_setting.blink = false;
led->led_setting.breath = false;
led->led_setting.brightness = led->cdev.brightness;
} else {
led->led_setting.on_ms = *on_ms;
led->led_setting.off_ms = *off_ms;
led->led_setting.blink = true;
led->led_setting.breath = false;
}
rc = indicator_led_set(led);
if (rc)
dev_err(led->chip->dev, "Set led failed for %s, rc=%d\n",
led->label, rc);
mutex_unlock(&led->lock);
return rc;
}
static ssize_t breath_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
struct led_classdev *led_cdev = dev_get_drvdata(dev);
struct qpnp_led_dev *led =
container_of(led_cdev, struct qpnp_led_dev, cdev);
return scnprintf(buf, PAGE_SIZE, "%d\n", led->led_setting.breath);
}
static ssize_t breath_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
int rc;
bool breath;
struct led_classdev *led_cdev = dev_get_drvdata(dev);
struct qpnp_led_dev *led =
container_of(led_cdev, struct qpnp_led_dev, cdev);
rc = kstrtobool(buf, &breath);
if (rc < 0)
return rc;
cancel_work_sync(&led_cdev->set_brightness_work);
mutex_lock(&led->lock);
if (led->breathing == breath)
goto unlock;
led->led_setting.blink = false;
led->led_setting.breath = breath;
led->led_setting.brightness = breath ? LED_FULL : LED_OFF;
rc = indicator_led_set(led);
if (rc < 0)
dev_err(led->chip->dev, "Set led failed for %s, rc=%d\n",
led->label, rc);
unlock:
mutex_unlock(&led->lock);
return (rc < 0) ? rc : count;
}
static DEVICE_ATTR_RW(breath);
static const struct attribute *breath_attrs[] = {
&dev_attr_breath.attr,
NULL
};
static int indicator_led_register(struct indicator_led_chip *chip)
{
struct qpnp_led_dev *led;
int rc, i, j;
for (i = 0; i < chip->num_leds; i++) {
led = &chip->leds[i];
mutex_init(&led->lock);
led->cdev.name = led->label;
led->cdev.max_brightness = LED_FULL;
led->cdev.brightness_set_blocking = indicator_led_set_brightness;
led->cdev.brightness_get = indicator_led_get_brightness;
led->cdev.blink_set = indicator_led_set_blink;
led->cdev.default_trigger = led->default_trigger;
led->cdev.brightness = LED_OFF;
rc = devm_led_classdev_register(chip->dev, &led->cdev);
if (rc < 0) {
dev_err(chip->dev, "%s led class device registering failed, rc=%d\n",
led->label, rc);
goto err_out;
}
if (pwm_get_output_type_supported(led->pwm_dev)
& PWM_OUTPUT_MODULATED) {
rc = sysfs_create_files(&led->cdev.dev->kobj,
breath_attrs);
if (rc < 0) {
dev_err(chip->dev, "Create breath file for %s led failed, rc=%d\n",
led->label, rc);
goto err_out;
}
}
}
return 0;
err_out:
for (j = 0; j <= i; j++) {
if (j < i)
sysfs_remove_files(&chip->leds[j].cdev.dev->kobj,
breath_attrs);
mutex_destroy(&chip->leds[j].lock);
}
return rc;
}
static int indicator_led_parse_dt(struct indicator_led_chip *chip)
{
struct device_node *node = chip->dev->of_node, *child_node;
struct qpnp_led_dev *led;
struct pwm_args pargs;
int rc = 0, id, i = 0;
chip->num_leds = of_get_available_child_count(node);
if (chip->num_leds == 0) {
dev_err(chip->dev, "No led child node defined\n");
return -ENODEV;
}
if (chip->num_leds > TRILED_NUM_MAX) {
dev_err(chip->dev, "can't support %d leds(max %d)\n",
chip->num_leds, TRILED_NUM_MAX);
return -EINVAL;
}
chip->leds = devm_kcalloc(chip->dev, chip->num_leds,
sizeof(struct qpnp_led_dev), GFP_KERNEL);
if (!chip->leds)
return -ENOMEM;
for_each_available_child_of_node(node, child_node) {
rc = of_property_read_u32(child_node, "led-sources", &id);
if (rc) {
dev_err(chip->dev, "Get led-sources failed, rc=%d\n",
rc);
return rc;
}
if (id >= TRILED_NUM_MAX) {
dev_err(chip->dev, "only support 0~%d current source\n",
TRILED_NUM_MAX - 1);
return -EINVAL;
}
led = &chip->leds[i++];
led->chip = chip;
led->id = id;
led->label =
of_get_property(child_node, "label", NULL) ? :
child_node->name;
led->pwm_dev =
devm_of_pwm_get(chip->dev, child_node, NULL);
if (IS_ERR(led->pwm_dev)) {
rc = PTR_ERR(led->pwm_dev);
if (rc != -EPROBE_DEFER)
dev_err(chip->dev, "Get pwm device for %s led failed, rc=%d\n",
led->label, rc);
return rc;
}
pwm_get_args(led->pwm_dev, &pargs);
if (pargs.period == 0)
led->pwm_setting.pre_period_ns = PWM_PERIOD_DEFAULT_NS;
else
led->pwm_setting.pre_period_ns = pargs.period;
led->default_trigger = of_get_property(child_node,
"linux,default-trigger", NULL);
}
return rc;
}
static int indicator_led_pinctrl_init(struct indicator_led_chip *chip)
{
int rc = 0;
chip->pinctrl = devm_pinctrl_get(chip->dev);
if (IS_ERR_OR_NULL(chip->pinctrl)) {
dev_err(chip->dev, "Failed to get pinctrl handler");
chip->pinctrl = NULL;
return -EINVAL;
}
chip->pin_sta_default = pinctrl_lookup_state(chip->pinctrl, PINCTRL_STATE_DEFAULT);
if (IS_ERR_OR_NULL(chip->pin_sta_default)) {
rc = PTR_ERR(chip->pin_sta_default);
dev_err(chip->dev, "Failed to get pinctrl state:%s, r:%d",
PINCTRL_STATE_DEFAULT, rc);
chip->pin_sta_default = NULL;
goto exit_pinctrl_put;
}
rc = pinctrl_select_state(chip->pinctrl, chip->pin_sta_default);
if (rc < 0) {
dev_err(chip->dev, "Failed to select default pinstate, rc:%d", rc);
}
exit_pinctrl_put:
devm_pinctrl_put(chip->pinctrl);
chip->pinctrl = NULL;
return rc;
}
static int indicator_led_probe(struct platform_device *pdev)
{
struct indicator_led_chip *chip;
int rc = 0;
chip = devm_kzalloc(&pdev->dev, sizeof(*chip), GFP_KERNEL);
if (!chip)
return -ENOMEM;
chip->dev = &pdev->dev;
rc = indicator_led_parse_dt(chip);
if (rc < 0) {
if (rc != -EPROBE_DEFER)
dev_err(chip->dev, "Devicetree properties parsing failed, rc=%d\n",
rc);
return rc;
}
rc = indicator_led_pinctrl_init(chip);
if(rc < 0) {
dev_err(chip->dev, "Indicator led pinctrl init failed, rc=%d\n", rc);
return rc;
}
mutex_init(&chip->bus_lock);
dev_set_drvdata(chip->dev, chip);
rc = indicator_led_register(chip);
if (rc < 0) {
dev_err(chip->dev, "Registering LED class devices failed, rc=%d\n",
rc);
goto destroy;
}
dev_err(chip->dev, "%s has been finished\n", __func__);
return 0;
destroy:
mutex_destroy(&chip->bus_lock);
dev_set_drvdata(chip->dev, NULL);
return rc;
}
static int indicator_led_remove(struct platform_device *pdev)
{
int i;
struct indicator_led_chip *chip = dev_get_drvdata(&pdev->dev);
mutex_destroy(&chip->bus_lock);
for (i = 0; i < chip->num_leds; i++) {
sysfs_remove_files(&chip->leds[i].cdev.dev->kobj, breath_attrs);
mutex_destroy(&chip->leds[i].lock);
}
dev_set_drvdata(chip->dev, NULL);
return 0;
}
static const struct of_device_id indicator_led_of_match[] = {
{ .compatible = "qcom,indicator-pwm-led",},
{ },
};
static struct platform_driver indicator_led_driver = {
.driver = {
.name = "qcom,indicator-pwm-led",
.of_match_table = indicator_led_of_match,
},
.probe = indicator_led_probe,
.remove = indicator_led_remove,
};
module_platform_driver(indicator_led_driver);
MODULE_DESCRIPTION("PWM LED driver");
MODULE_LICENSE("GPL v2");
MODULE_SOFTDEP("pre: pwm-qti-lpg");

12
drivers/leds/trigger/Android.mk Normal file
View file

@ -0,0 +1,12 @@
DLKM_DIR := motorola/kernel/modules
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := ledtrig-sol.ko
LOCAL_MODULE_TAGS := optional
ifeq ($(DLKM_INSTALL_TO_VENDOR_OUT),true)
LOCAL_MODULE_PATH := $(TARGET_OUT_VENDOR)/lib/modules/
else
LOCAL_MODULE_PATH := $(KERNEL_MODULES_OUT)
endif
include $(DLKM_DIR)/AndroidKernelModule.mk

5
drivers/leds/trigger/Kbuild Normal file
View file

@ -0,0 +1,5 @@
EXTRA_CFLAGS += -Wall
EXTRA_CFLAGS += -I$(TOP)/motorola/kernel/modules/include
obj-m += ledtrig-sol.o

445
drivers/leds/trigger/ledtrig-sol.c Normal file
View file

@ -0,0 +1,445 @@
/*
* Description: Sign-of-life LED trigger
*
* Copyright (c) 2021 Lenovo, Inc. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/notifier.h>
#include <linux/leds.h>
#include <linux/power_supply.h>
#include <linux/device/class.h>
#include <linux/delay.h>
#include <linux/moduleparam.h>
#define CHARGING_DELAY_ON_DEFAULT (700)
#define CHARGING_DELAY_OFF_DEFAULT (700)
#define LOW_CAP_DELAY_ON_DEFAULT (3800)
#define LOW_CAP_DELAY_OFF_DEFAULT (200)
#define LOW_CAP_THRESHOLD_DEFAULT (15)
#define BATT_CAP_THRESHOLD_HALF (50)
#define BATT_CAP_THRESHOLD_HIGH (75)
#define BATT_CAP_THRESHOLD_FULL (100)
struct sol_trig_data {
struct led_classdev *led_cdev;
struct notifier_block nb;
unsigned long charging_delay_on;
unsigned long charging_delay_off;
unsigned long low_cap_delay_on;
unsigned long low_cap_delay_off;
int low_cap_threshold;
bool mmi_battery_psy_present;
bool battery_psy_present;
};
static int multi_led_enable = 0;
module_param(multi_led_enable, int, 0644);
static ssize_t charging_delay_on_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct led_classdev *led_cdev = led_trigger_get_led(dev);
struct sol_trig_data *sol_data = led_get_trigger_data(led_cdev);
return sprintf(buf, "%lu\n", sol_data->charging_delay_on);
}
static ssize_t charging_delay_on_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct led_classdev *led_cdev = led_trigger_get_led(dev);
struct sol_trig_data *sol_data = led_get_trigger_data(led_cdev);
unsigned long val;
ssize_t ret;
ret = kstrtoul(buf, 10, &val);
if (ret)
return ret;
sol_data->charging_delay_on = val;
return size;
}
static ssize_t charging_delay_off_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct led_classdev *led_cdev = led_trigger_get_led(dev);
struct sol_trig_data *sol_data = led_get_trigger_data(led_cdev);
return sprintf(buf, "%lu\n", sol_data->charging_delay_off);
}
static ssize_t charging_delay_off_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct led_classdev *led_cdev = led_trigger_get_led(dev);
struct sol_trig_data *sol_data = led_get_trigger_data(led_cdev);
unsigned long val;
ssize_t ret;
ret = kstrtoul(buf, 10, &val);
if (ret)
return ret;
sol_data->charging_delay_off = val;
return size;
}
static ssize_t low_cap_delay_on_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct led_classdev *led_cdev = led_trigger_get_led(dev);
struct sol_trig_data *sol_data = led_get_trigger_data(led_cdev);
return sprintf(buf, "%lu\n", sol_data->low_cap_delay_on);
}
static ssize_t low_cap_delay_on_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct led_classdev *led_cdev = led_trigger_get_led(dev);
struct sol_trig_data *sol_data = led_get_trigger_data(led_cdev);
unsigned long val;
ssize_t ret;
ret = kstrtoul(buf, 10, &val);
if (ret)
return ret;
sol_data->low_cap_delay_on = val;
return size;
}
static ssize_t low_cap_delay_off_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct led_classdev *led_cdev = led_trigger_get_led(dev);
struct sol_trig_data *sol_data = led_get_trigger_data(led_cdev);
return sprintf(buf, "%lu\n", sol_data->low_cap_delay_off);
}
static ssize_t low_cap_delay_off_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct led_classdev *led_cdev = led_trigger_get_led(dev);
struct sol_trig_data *sol_data = led_get_trigger_data(led_cdev);
unsigned long val;
ssize_t ret;
ret = kstrtoul(buf, 0, &val);
if (ret)
return ret;
sol_data->low_cap_delay_off = val;
return size;
}
static ssize_t low_cap_threshold_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct led_classdev *led_cdev = led_trigger_get_led(dev);
struct sol_trig_data *sol_data = led_get_trigger_data(led_cdev);
return sprintf(buf, "%d\n", sol_data->low_cap_threshold);
}
static ssize_t low_cap_threshold_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct led_classdev *led_cdev = led_trigger_get_led(dev);
struct sol_trig_data *sol_data = led_get_trigger_data(led_cdev);
long val;
ssize_t ret;
ret = kstrtol(buf, 0, &val);
if (ret)
return ret;
if (val > 100) /* Max capacity is 100% */
return -EINVAL;
sol_data->low_cap_threshold = val;
return size;
}
static DEVICE_ATTR(charging_delay_on, 0644, charging_delay_on_show, charging_delay_on_store);
static DEVICE_ATTR(charging_delay_off, 0644, charging_delay_off_show, charging_delay_off_store);
static DEVICE_ATTR(low_capacity_delay_on, 0644, low_cap_delay_on_show, low_cap_delay_on_store);
static DEVICE_ATTR(low_capacity_delay_off, 0644, low_cap_delay_off_show, low_cap_delay_off_store);
static DEVICE_ATTR(low_capacity_threshold, 0644, low_cap_threshold_show, low_cap_threshold_store);
static struct attribute *sol_trig_attrs[] = {
&dev_attr_charging_delay_on.attr,
&dev_attr_charging_delay_off.attr,
&dev_attr_low_capacity_delay_on.attr,
&dev_attr_low_capacity_delay_off.attr,
&dev_attr_low_capacity_threshold.attr,
NULL
};
ATTRIBUTE_GROUPS(sol_trig);
static int sol_trig_activate(struct led_classdev *led_cdev);
static void sol_trig_deactivate(struct led_classdev *led_cdev);
static struct led_trigger sol_led_trigger = {
.name = "sign-of-life",
.activate = sol_trig_activate,
.deactivate = sol_trig_deactivate,
.groups = sol_trig_groups,
};
static int is_multi_led_enabled () {
return multi_led_enable;
}
/* API to set sol led colour, brightness etc based on battery status */
static int sol_led_update_status(const char *led_name, bool blink, unsigned int brightness, struct sol_trig_data *sol_data)
{
struct led_classdev *led_cdev = sol_data->led_cdev;
dev_dbg(led_cdev->dev, "Entry sol_led_update_status name:%s, blink = %d, brightness = %u\n",led_name,blink,brightness);
if(!strcmp(led_name, "charging_full") && !strcmp(led_cdev->name, "charging_full")) {
dev_dbg(led_cdev->dev, "POWER_STATUS_FULL\n");
led_trigger_event(&sol_led_trigger, LED_OFF);
flush_work(&led_cdev->set_brightness_work);
led_set_brightness_sync(led_cdev, brightness);
if(blink){
led_blink_set(led_cdev, &sol_data->charging_delay_on, &sol_data->charging_delay_off);
dev_dbg(led_cdev->dev, "SETTING DONE FOR charging full blink delay_on=%lu,delay_off=%lu\n",sol_data->charging_delay_on, sol_data->charging_delay_off);
}
}
if(!strcmp(led_name, "charging") && !strcmp(led_cdev->name, "charging")) {
dev_dbg(led_cdev->dev, "POWER_STATUS_CHARGING\n");
led_trigger_event(&sol_led_trigger, LED_OFF);
flush_work(&led_cdev->set_brightness_work);
led_set_brightness_sync(led_cdev, brightness);
if(blink){
led_blink_set(led_cdev, &sol_data->charging_delay_on, &sol_data->charging_delay_off);
dev_dbg(led_cdev->dev, "SETTING DONE FOR charging blink delay_on=%lu,delay_off=%lu\n",sol_data->charging_delay_on, sol_data->charging_delay_off);
}
}
if(!strcmp(led_name, "charging_low") && !strcmp(led_cdev->name, "charging_low")) {
dev_dbg(led_cdev->dev, "POWER_STATUS_LOW\n");
led_trigger_event(&sol_led_trigger, LED_OFF);
flush_work(&led_cdev->set_brightness_work);
led_set_brightness_sync(led_cdev, brightness);
if(blink){
led_blink_set(led_cdev, &sol_data->low_cap_delay_on, &sol_data->low_cap_delay_off);
dev_dbg(led_cdev->dev, "SETTING DONE FOR low cap blink delay_on= %lu,delay_off=%lu\n",sol_data->low_cap_delay_on,sol_data->low_cap_delay_off);
}
}
return 0;
}
static int sol_trig_notifier_fn(struct notifier_block *nb, unsigned long action, void *data)
{
union power_supply_propval status;
union power_supply_propval capacity;
struct sol_trig_data *sol_data = container_of(nb, struct sol_trig_data, nb);
struct led_classdev *led_cdev = sol_data->led_cdev;
struct power_supply *psy = data;
/* We want to key the SOL LED off "mmi_battery" if possible. If mmi_battery is
* unavailable, try the "battery" PSY. If neither of those are available, just
* key off any battery PSY available.
*/
if (sol_data->mmi_battery_psy_present)
{
if (strcmp(psy->desc->name, "mmi_battery"))
return NOTIFY_OK;
}
else if (sol_data->battery_psy_present)
{
if (strcmp(psy->desc->name, "battery"))
return NOTIFY_OK;
}
else if (psy->desc->type != POWER_SUPPLY_TYPE_BATTERY)
{
return NOTIFY_OK;
}
if (power_supply_get_property(psy, POWER_SUPPLY_PROP_STATUS, &status)) {
dev_err(led_cdev->dev, "Failed to get PSY status.\n");
return NOTIFY_OK;
}
dev_dbg(led_cdev->dev, "%s: PSY status: %d\n", __func__, status.intval);
switch (status.intval) {
case POWER_SUPPLY_STATUS_UNKNOWN: /* Fall-through */
case POWER_SUPPLY_STATUS_FULL:
if(is_multi_led_enabled())
sol_led_update_status("charging_full", false, LED_FULL, sol_data);
else
led_set_brightness(led_cdev, LED_FULL);
break;
case POWER_SUPPLY_STATUS_CHARGING:
if(is_multi_led_enabled()) {
if (!power_supply_get_property(psy, POWER_SUPPLY_PROP_CAPACITY, &capacity))
dev_err(led_cdev->dev, "%s: Battery capacity: %d\n", __func__, capacity.intval);
/* charging_low led blink: Charging capacity <= 15% */
if (capacity.intval <= sol_data->low_cap_threshold)
sol_led_update_status("charging_low", true, LED_FULL, sol_data);
/* charging led blink: Charging capacity >15% and <75% */
if (capacity.intval > sol_data->low_cap_threshold && capacity.intval < BATT_CAP_THRESHOLD_HIGH)
sol_led_update_status("charging", true, LED_FULL, sol_data);
/* charging_full led blink: Charging capacity >=75 and < 100% */
if (capacity.intval >= BATT_CAP_THRESHOLD_HIGH && capacity.intval <= BATT_CAP_THRESHOLD_FULL)
sol_led_update_status("charging_full", true, LED_FULL, sol_data);
} else
led_blink_set(led_cdev, &sol_data->charging_delay_on, &sol_data->charging_delay_off);
break;
case POWER_SUPPLY_STATUS_DISCHARGING: /* Fall-through */
case POWER_SUPPLY_STATUS_NOT_CHARGING: /* Fall-through */
default:
/*
* If PSY capacity is equal-to or below a specified threshold, use a special low-capacity blink pattern.
* Otherwise, set LED to full brightness by default.
*/
if (!power_supply_get_property(psy, POWER_SUPPLY_PROP_CAPACITY, &capacity))
dev_dbg(led_cdev->dev, "%s: Battery capacity: %d\n", __func__, capacity.intval);
if(is_multi_led_enabled()) {
/* charging_low led blink: Charging capacity <= 15% */
if (capacity.intval <= sol_data->low_cap_threshold)
sol_led_update_status("charging_low", true, LED_FULL, sol_data);
/* charging led solid: Charging capacity >15% and <75% */
if (capacity.intval > sol_data->low_cap_threshold && capacity.intval < BATT_CAP_THRESHOLD_HIGH)
sol_led_update_status("charging", false, LED_HALF, sol_data);
/* charging_full led solid: Charging capacity >=75 and < 100% */
if (capacity.intval >= BATT_CAP_THRESHOLD_HIGH && capacity.intval <= BATT_CAP_THRESHOLD_FULL)
sol_led_update_status("charging_full", false, LED_HALF, sol_data);
}
else
if(capacity.intval <= sol_data->low_cap_threshold)
led_blink_set(led_cdev, &sol_data->low_cap_delay_on, &sol_data->low_cap_delay_off);
else
led_set_brightness(led_cdev, LED_FULL);
break;
}
return NOTIFY_OK;
}
static int sol_trig_identify_psy(struct device *dev, void *data)
{
struct sol_trig_data *sol_data = data;
struct power_supply *psy = dev_get_drvdata(dev);
if (!strcmp(psy->desc->name, "mmi_battery"))
sol_data->mmi_battery_psy_present = true;
if (!strcmp(psy->desc->name, "battery"))
sol_data->battery_psy_present = true;
return 0;
}
static int sol_trig_activate(struct led_classdev *led_cdev)
{
int ret;
struct sol_trig_data *sol_data;
sol_data = kzalloc(sizeof(*sol_data), GFP_KERNEL);
if (!sol_data)
return -ENOMEM;
sol_data->nb.notifier_call = sol_trig_notifier_fn;
ret = power_supply_reg_notifier(&sol_data->nb);
if (ret) {
dev_err(led_cdev->dev, "Failed to register notifier: %d\n", ret);
goto error;
}
sol_data->led_cdev = led_cdev;
sol_data->charging_delay_on = CHARGING_DELAY_ON_DEFAULT;
sol_data->charging_delay_off = CHARGING_DELAY_OFF_DEFAULT;
sol_data->low_cap_delay_on = LOW_CAP_DELAY_ON_DEFAULT;
sol_data->low_cap_delay_off = LOW_CAP_DELAY_OFF_DEFAULT;
sol_data->low_cap_threshold = LOW_CAP_THRESHOLD_DEFAULT;
sol_data->mmi_battery_psy_present = false;
sol_data->battery_psy_present = false;
class_for_each_device(power_supply_class, NULL, sol_data, sol_trig_identify_psy);
dev_err(led_cdev->dev, " %s, Initial brightness = %d\n",sol_data->led_cdev->name, sol_data->led_cdev->brightness);
led_set_trigger_data(led_cdev, sol_data);
led_set_brightness(led_cdev, LED_FULL); /* Set default LED state */
return 0;
error:
kfree(sol_data);
return ret;
}
static void sol_trig_deactivate(struct led_classdev *led_cdev)
{
struct sol_trig_data *sol_data = led_get_trigger_data(led_cdev);
power_supply_unreg_notifier(&sol_data->nb);
kfree(sol_data);
return;
}
static int __init sol_trig_init(void)
{
pr_err("multiled: multi_led_enable = %d\n",multi_led_enable);
return led_trigger_register(&sol_led_trigger);
}
static void __exit sol_trig_exit(void)
{
led_trigger_unregister(&sol_led_trigger);
}
module_init(sol_trig_init);
module_exit(sol_trig_exit);
MODULE_AUTHOR("Andy White <[email protected]>");
MODULE_DESCRIPTION("Sign-of-life LED trigger");
MODULE_LICENSE("GPL");