From patchwork Tue May 8 05:39:45 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "\(Exiting\) Baolin Wang" X-Patchwork-Id: 135125 Delivered-To: patch@linaro.org Received: by 10.46.151.6 with SMTP id r6csp3984062lji; Mon, 7 May 2018 22:41:03 -0700 (PDT) X-Google-Smtp-Source: AB8JxZoJd/O81oQtclkxDbPGmO14w6PxOm9/bptYld234DjIiHle8kOacej7Hs3birm0DfEGEP/r X-Received: by 10.98.127.145 with SMTP id a139mr38827689pfd.25.1525758063504; Mon, 07 May 2018 22:41:03 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1525758063; cv=none; d=google.com; s=arc-20160816; b=ffL3r0vjyHVV09iJ9BJ8uVrss68tjDUbaz7hKdkD4YoSqmciEJaeD+Uy9Ss2LZrjxw bh2HXOLQKMfl885X8d5k8D3pc5yKGq7IbxfLEdH01b0Xkshnx5ACFAhb+vYlBBWOK0+i f5LPW/3fwIVx6MdV7S7Jzw1ABoOTqfY9A1t1p0qc/KC3ZR5mEdrcRNhvnv9PEoYf0If2 vIVOPFrc3Ap/+KQgm1XNDiAZCg3LQQWFYqm7LgK7WMhWnVkOFzD+7UIuYKjer68XdQdP wj79/QbtKnenHDwJfQ29X+zgxaRx0jbgmgbRIu1//spXd4EcSVmXbKJ9ozkvu9PIhWLm 5tdA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:references:in-reply-to:references :in-reply-to:message-id:date:subject:cc:to:from:dkim-signature :arc-authentication-results; bh=UAvzdy5XGGoICISOJrAWFShYoerGjnZ2IMym/OZ2VTY=; b=HVR/JDejRMTkVpYwSo9LrDnb8FgGEZehTFoDkTi85L7dCMRwCs1gt1bVs7K5J2tm// 645yniUEKJhCY8mPYkuPO+oMhtQjyGhBu47Kzvq2XNQqP1GCD9b34ICCdAXvN7QA6fdP 6BwDJW9W6ggj7h+6H7oSNdJB80zneWkbP2dhRuyAZ1jM4U3adNHgIHaV2fEotRVGtl9T RlpAc4MWaYaNLnaKx+IIImQC0kHWOnW4HilS4BymyycKPpR9OB9otJ2pxd3QLdIwD6xv nOG9zYkH/PRiSJ41eRkYKb8XJbwiEqD7UHFHX9vP3FK2ZJRai1HYYhzqyT1rsOOxGoNr q1dg== ARC-Authentication-Results: i=1; mx.google.com; dkim=neutral (body hash did not verify) header.i=@linaro.org header.s=google header.b=amqFaDGB; spf=pass (google.com: best guess record for domain of devicetree-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=devicetree-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id u78-v6si19178557pgb.136.2018.05.07.22.41.03; Mon, 07 May 2018 22:41:03 -0700 (PDT) Received-SPF: pass (google.com: best guess record for domain of devicetree-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=neutral (body hash did not verify) header.i=@linaro.org header.s=google header.b=amqFaDGB; spf=pass (google.com: best guess record for domain of devicetree-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=devicetree-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1754132AbeEHFlA (ORCPT + 6 others); Tue, 8 May 2018 01:41:00 -0400 Received: from mail-pg0-f65.google.com ([74.125.83.65]:33382 "EHLO mail-pg0-f65.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754084AbeEHFk6 (ORCPT ); Tue, 8 May 2018 01:40:58 -0400 Received: by mail-pg0-f65.google.com with SMTP id i194-v6so20673115pgd.0 for ; Mon, 07 May 2018 22:40:58 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :in-reply-to:references; bh=7mB7Thm4penUfV4x7t6gxIkA/FcuPZ10Poel7hAHzow=; b=amqFaDGBVFFe9lSo14dw53cGgLL0XS0KDcrrzruWbfHy1QQGa2fTd6/TiFlGBmmbNp 2Se55xKHOKplpjckUU1ck1wdtc+SIDoUgu3ifqKBfVJ72glLxVBuMkHKHZgC7V+rPlzC i3jmt9/8aXHBhLfDCd1ijYe0glcDG34cWO+Ec= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:in-reply-to:references; bh=7mB7Thm4penUfV4x7t6gxIkA/FcuPZ10Poel7hAHzow=; b=JlKdsIV+37eIKfKjqunqTsB6ly8En5uAJUXvKOUWfOs63/EczXIvJ0fWK7ay29cb5Z EyrCDKFutrP28Aa9k2aYd+EDoPU4CnpNa7ml65fSyr9E8NRt51d6tfRIucVUKRfneMVR nKbs9zSx5MG7aoSjMeSufYUF3d1WDSC5c6k/dn7Ut7lJ7hsr64wK+UGD+n55j1NS7ss/ VPLPevWKDfyAKg+WYLk5pciw4tYjucZ5xFJ/vQhp+IXt1uUv++h37URQ+eJFRNVbVDC7 ZiOHKw5KFfl3B/5odtulCFtopYu+NezqFSym8BaV7l8uhXv8SVH5A6qQeNB7bjAKX4wJ exgA== X-Gm-Message-State: ALQs6tDjvuEHQTnYxUAmlb5/sOT/YSt92Mo8IVlUiWsBD5mm5Tt0HdQB HwyJ6Vss9oS5q/LiW85xeMO40Q== X-Received: by 2002:a65:4289:: with SMTP id j9-v6mr22375041pgp.136.1525758057732; Mon, 07 May 2018 22:40:57 -0700 (PDT) Received: from baolinwangubtpc.spreadtrum.com ([117.18.48.102]) by smtp.gmail.com with ESMTPSA id o4sm47787524pfg.129.2018.05.07.22.40.54 (version=TLS1 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Mon, 07 May 2018 22:40:57 -0700 (PDT) From: Baolin Wang To: jacek.anaszewski@gmail.com, pavel@ucw.cz, robh+dt@kernel.org, mark.rutland@arm.com Cc: xiaotong.lu@spreadtrum.com, baolin.wang@linaro.org, broonie@kernel.org, linux-leds@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH v2 2/2] leds: Add Spreadtrum SC27xx breathing light controller driver Date: Tue, 8 May 2018 13:39:45 +0800 Message-Id: <9a2a07b8eb313ae3ba64af911337ee7ff7c9ad43.1525757122.git.baolin.wang@linaro.org> X-Mailer: git-send-email 1.7.9.5 In-Reply-To: References: In-Reply-To: References: Sender: devicetree-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: devicetree@vger.kernel.org From: Xiaotong Lu This patch adds Spreadtrum SC27xx PMIC series breathing light controller driver, which can support 3 LEDs. Each LED can work at normal PWM mode and breathing mode. Signed-off-by: Xiaotong Lu Signed-off-by: Baolin Wang --- Changes since v1: - Add ABI documentation. - Add mutex protection in case of concurrent access. - Change the LED device name pattern. - Fix build warning. --- .../ABI/testing/sysfs-class-led-driver-sc27xx | 19 + drivers/leds/Kconfig | 11 + drivers/leds/Makefile | 1 + drivers/leds/leds-sc27xx-bltc.c | 387 ++++++++++++++++++++ 4 files changed, 418 insertions(+) create mode 100644 Documentation/ABI/testing/sysfs-class-led-driver-sc27xx create mode 100644 drivers/leds/leds-sc27xx-bltc.c -- 1.7.9.5 -- To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html diff --git a/Documentation/ABI/testing/sysfs-class-led-driver-sc27xx b/Documentation/ABI/testing/sysfs-class-led-driver-sc27xx new file mode 100644 index 0000000..22166fb --- /dev/null +++ b/Documentation/ABI/testing/sysfs-class-led-driver-sc27xx @@ -0,0 +1,19 @@ +What: /sys/class/leds//rise_time +What: /sys/class/leds//high_time +What: /sys/class/leds//fall_time +What: /sys/class/leds//low_time +Date: May 2018 +KernelVersion: 4.18 +Contact: Xiaotong Lu +Description: + Set the pattern generator rise, high, fall and low + times (0..63). It's unit is 0.125s, it should be > 0. + + 1 - 125 ms + 2 - 250 ms + 3 - 375 ms + ... + ... + ... + 62 - 7.75 s + 63 - 7.875 s diff --git a/drivers/leds/Kconfig b/drivers/leds/Kconfig index 2c896c0..319449b 100644 --- a/drivers/leds/Kconfig +++ b/drivers/leds/Kconfig @@ -647,6 +647,17 @@ config LEDS_IS31FL32XX LED controllers. They are I2C devices with multiple constant-current channels, each with independent 256-level PWM control. +config LEDS_SC27XX_BLTC + tristate "LED support for the SC27xx breathing light controller" + depends on LEDS_CLASS && MFD_SC27XX_PMIC + depends on OF + help + Say Y here to include support for the SC27xx breathing light controller + LEDs. + + This driver can also be built as a module. If so the module will be + called leds-sc27xx-bltc. + comment "LED driver for blink(1) USB RGB LED is under Special HID drivers (HID_THINGM)" config LEDS_BLINKM diff --git a/drivers/leds/Makefile b/drivers/leds/Makefile index 91eca81..ff6917e 100644 --- a/drivers/leds/Makefile +++ b/drivers/leds/Makefile @@ -76,6 +76,7 @@ obj-$(CONFIG_LEDS_MLXREG) += leds-mlxreg.o obj-$(CONFIG_LEDS_NIC78BX) += leds-nic78bx.o obj-$(CONFIG_LEDS_MT6323) += leds-mt6323.o obj-$(CONFIG_LEDS_LM3692X) += leds-lm3692x.o +obj-$(CONFIG_LEDS_SC27XX_BLTC) += leds-sc27xx-bltc.o # LED SPI Drivers obj-$(CONFIG_LEDS_DAC124S085) += leds-dac124s085.o diff --git a/drivers/leds/leds-sc27xx-bltc.c b/drivers/leds/leds-sc27xx-bltc.c new file mode 100644 index 0000000..61c5b72 --- /dev/null +++ b/drivers/leds/leds-sc27xx-bltc.c @@ -0,0 +1,387 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (C) 2018 Spreadtrum Communications Inc. + +#include +#include +#include +#include +#include +#include + +/* PMIC global control register definition */ +#define SC27XX_MODULE_EN0 0xc08 +#define SC27XX_CLK_EN0 0xc18 +#define SC27XX_RGB_CTRL 0xebc + +#define SC27XX_BLTC_EN BIT(9) +#define SC27XX_RTC_EN BIT(7) +#define SC27XX_RGB_PD BIT(0) + +/* Breathing light controller register definition */ +#define SC27XX_LEDS_CTRL 0x00 +#define SC27XX_LEDS_PRESCALE 0x04 +#define SC27XX_LEDS_DUTY 0x08 +#define SC27XX_LEDS_CURVE0 0x0c +#define SC27XX_LEDS_CURVE1 0x10 + +#define SC27XX_CTRL_SHIFT 4 +#define SC27XX_LED_RUN BIT(0) +#define SC27XX_LED_TYPE BIT(1) + +#define SC27XX_DUTY_SHIFT 8 +#define SC27XX_DUTY_MASK GENMASK(15, 0) +#define SC27XX_MOD_MASK GENMASK(7, 0) + +#define SC27XX_CURVE_SHIFT 8 +#define SC27XX_CURVE_L_MASK GENMASK(7, 0) +#define SC27XX_CURVE_H_MASK GENMASK(15, 8) + +#define SC27XX_LEDS_OFFSET 0x10 +#define SC27XX_LEDS_MAX 3 +#define SC27XX_LEDS_TIME_MAX 63 + +/* + * The SC27xx breathing light controller can support 3 outputs: red LED, + * green LED and blue LED. Each LED can support normal PWM mode and breathing + * mode. + * + * In breathing mode, the LED output curve includes rise, high, fall and low 4 + * stages, and the duration of each stage is configurable. + */ +enum sc27xx_led_config { + SC27XX_RISE_TIME, + SC27XX_FALL_TIME, + SC27XX_HIGH_TIME, + SC27XX_LOW_TIME, +}; + +struct sc27xx_led { + char name[LED_MAX_NAME_SIZE]; + struct led_classdev ldev; + struct sc27xx_led_priv *priv; + enum led_brightness value; + u8 line; + bool breath_mode; + bool active; +}; + +struct sc27xx_led_priv { + struct sc27xx_led leds[SC27XX_LEDS_MAX]; + struct regmap *regmap; + struct mutex lock; + u32 base; +}; + +#define to_sc27xx_led(ldev) \ + container_of(ldev, struct sc27xx_led, ldev) + +static int sc27xx_led_init(struct regmap *regmap) +{ + int err; + + err = regmap_update_bits(regmap, SC27XX_MODULE_EN0, SC27XX_BLTC_EN, + SC27XX_BLTC_EN); + if (err) + return err; + + err = regmap_update_bits(regmap, SC27XX_CLK_EN0, SC27XX_RTC_EN, + SC27XX_RTC_EN); + if (err) + return err; + + return regmap_update_bits(regmap, SC27XX_RGB_CTRL, SC27XX_RGB_PD, 0); +} + +static u32 sc27xx_led_get_offset(struct sc27xx_led *leds) +{ + return leds->priv->base + SC27XX_LEDS_OFFSET * leds->line; +} + +static int sc27xx_led_enable(struct sc27xx_led *leds) +{ + u32 base = sc27xx_led_get_offset(leds); + u32 ctrl_base = leds->priv->base + SC27XX_LEDS_CTRL; + u8 ctrl_shift = SC27XX_CTRL_SHIFT * leds->line; + struct regmap *regmap = leds->priv->regmap; + int err; + + err = regmap_update_bits(regmap, base + SC27XX_LEDS_DUTY, + SC27XX_DUTY_MASK, + (leds->value << SC27XX_DUTY_SHIFT) | + SC27XX_MOD_MASK); + if (err) + return err; + + if (leds->breath_mode) + return regmap_update_bits(regmap, ctrl_base, + SC27XX_LED_RUN << ctrl_shift, + SC27XX_LED_RUN << ctrl_shift); + + return regmap_update_bits(regmap, ctrl_base, + (SC27XX_LED_RUN | SC27XX_LED_TYPE) << ctrl_shift, + (SC27XX_LED_RUN | SC27XX_LED_TYPE) << ctrl_shift); +} + +static int sc27xx_led_disable(struct sc27xx_led *leds) +{ + u8 ctrl_shift = SC27XX_CTRL_SHIFT * leds->line; + + leds->breath_mode = false; + + return regmap_update_bits(leds->priv->regmap, + leds->priv->base + SC27XX_LEDS_CTRL, + (SC27XX_LED_RUN | SC27XX_LED_TYPE) << ctrl_shift, 0); +} + +static int sc27xx_led_set(struct led_classdev *ldev, enum led_brightness value) +{ + struct sc27xx_led *leds = to_sc27xx_led(ldev); + int err; + + mutex_lock(&leds->priv->lock); + leds->value = value; + if (value == LED_OFF) + err = sc27xx_led_disable(leds); + else + err = sc27xx_led_enable(leds); + mutex_unlock(&leds->priv->lock); + + return err; +} + +static int sc27xx_led_config(struct sc27xx_led *leds, + enum sc27xx_led_config config, u32 val) +{ + u32 base = sc27xx_led_get_offset(leds); + struct regmap *regmap = leds->priv->regmap; + int err; + + mutex_lock(&leds->priv->lock); + switch (config) { + case SC27XX_RISE_TIME: + err = regmap_update_bits(regmap, base + SC27XX_LEDS_CURVE0, + SC27XX_CURVE_L_MASK, val); + break; + case SC27XX_FALL_TIME: + err = regmap_update_bits(regmap, base + SC27XX_LEDS_CURVE0, + SC27XX_CURVE_H_MASK, + val << SC27XX_CURVE_SHIFT); + break; + case SC27XX_HIGH_TIME: + err = regmap_update_bits(regmap, base + SC27XX_LEDS_CURVE1, + SC27XX_CURVE_L_MASK, val); + break; + case SC27XX_LOW_TIME: + err = regmap_update_bits(regmap, base + SC27XX_LEDS_CURVE1, + SC27XX_CURVE_H_MASK, + val << SC27XX_CURVE_SHIFT); + break; + default: + err = -ENOTSUPP; + break; + } + + if (!err && !leds->breath_mode) + leds->breath_mode = true; + + mutex_unlock(&leds->priv->lock); + + return err; +} + +static ssize_t rise_time_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t size) +{ + struct led_classdev *ldev = dev_get_drvdata(dev); + struct sc27xx_led *leds = to_sc27xx_led(ldev); + u32 val; + int err; + + if (kstrtou32(buf, 10, &val) || val > SC27XX_LEDS_TIME_MAX) + return -EINVAL; + + err = sc27xx_led_config(leds, SC27XX_RISE_TIME, val); + if (err) + return err; + + return size; +} + +static ssize_t fall_time_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t size) +{ + struct led_classdev *ldev = dev_get_drvdata(dev); + struct sc27xx_led *leds = to_sc27xx_led(ldev); + u32 val; + int err; + + if (kstrtou32(buf, 10, &val) || val > SC27XX_LEDS_TIME_MAX) + return -EINVAL; + + err = sc27xx_led_config(leds, SC27XX_FALL_TIME, val); + if (err) + return err; + + return size; +} + +static ssize_t high_time_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t size) +{ + struct led_classdev *ldev = dev_get_drvdata(dev); + struct sc27xx_led *leds = to_sc27xx_led(ldev); + u32 val; + int err; + + if (kstrtou32(buf, 10, &val) || val > SC27XX_LEDS_TIME_MAX) + return -EINVAL; + + err = sc27xx_led_config(leds, SC27XX_HIGH_TIME, val); + if (err) + return err; + + return size; +} + +static ssize_t low_time_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t size) +{ + struct led_classdev *ldev = dev_get_drvdata(dev); + struct sc27xx_led *leds = to_sc27xx_led(ldev); + u32 val; + int err; + + if (kstrtou32(buf, 10, &val) || val > SC27XX_LEDS_TIME_MAX) + return -EINVAL; + + err = sc27xx_led_config(leds, SC27XX_LOW_TIME, val); + if (err) + return err; + + return size; +} + +static DEVICE_ATTR_WO(rise_time); +static DEVICE_ATTR_WO(fall_time); +static DEVICE_ATTR_WO(high_time); +static DEVICE_ATTR_WO(low_time); + +static struct attribute *sc27xx_led_attrs[] = { + &dev_attr_rise_time.attr, + &dev_attr_fall_time.attr, + &dev_attr_high_time.attr, + &dev_attr_low_time.attr, + NULL, +}; +ATTRIBUTE_GROUPS(sc27xx_led); + +static int sc27xx_led_register(struct device *dev, struct sc27xx_led_priv *priv) +{ + int i, err; + + err = sc27xx_led_init(priv->regmap); + if (err) + return err; + + for (i = 0; i < SC27XX_LEDS_MAX; i++) { + struct sc27xx_led *led = &priv->leds[i]; + + if (!led->active) + continue; + + led->line = i; + led->priv = priv; + led->ldev.name = led->name; + led->ldev.brightness_set_blocking = sc27xx_led_set; + led->ldev.max_brightness = LED_FULL; + led->ldev.groups = sc27xx_led_groups; + + err = devm_led_classdev_register(dev, &led->ldev); + if (err) + return err; + } + + return 0; +} + +static int sc27xx_led_probe(struct platform_device *pdev) +{ + struct device *dev = &pdev->dev; + struct device_node *np = dev->of_node, *child; + struct sc27xx_led_priv *priv; + const char *str; + u32 base, count, reg; + int err; + + count = of_get_child_count(np); + if (!count || count > SC27XX_LEDS_MAX) + return -EINVAL; + + err = of_property_read_u32(np, "reg", &base); + if (err) { + dev_err(dev, "fail to get reg of property\n"); + return err; + } + + priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); + if (!priv) + return -ENOMEM; + + mutex_init(&priv->lock); + priv->base = base; + priv->regmap = dev_get_regmap(dev->parent, NULL); + if (IS_ERR(priv->regmap)) { + err = PTR_ERR(priv->regmap); + dev_err(dev, "failed to get regmap: %d\n", err); + return err; + } + + for_each_child_of_node(np, child) { + err = of_property_read_u32(child, "reg", ®); + if (err) { + of_node_put(child); + return err; + } + + if (reg >= SC27XX_LEDS_MAX || priv->leds[reg].active) { + of_node_put(child); + return -EINVAL; + } + + priv->leds[reg].active = true; + + err = of_property_read_string(child, "label", &str); + if (err) + snprintf(priv->leds[reg].name, LED_MAX_NAME_SIZE, + "sc27xx::"); + else + snprintf(priv->leds[reg].name, LED_MAX_NAME_SIZE, + "sc27xx:%s", str); + } + + return sc27xx_led_register(dev, priv); +} + +static const struct of_device_id sc27xx_led_of_match[] = { + { .compatible = "sprd,sc2731-bltc", }, + { } +}; +MODULE_DEVICE_TABLE(of, sc27xx_led_of_match); + +static struct platform_driver sc27xx_led_driver = { + .driver = { + .name = "sprd-bltc", + .of_match_table = sc27xx_led_of_match, + }, + .probe = sc27xx_led_probe, +}; + +module_platform_driver(sc27xx_led_driver); + +MODULE_DESCRIPTION("Spreadtrum SC27xx breathing light controller driver"); +MODULE_AUTHOR("Xiaotong Lu "); +MODULE_LICENSE("GPL v2");