platform/chrome: wilco_ec: Add keyboard backlight LED support (119a3cb6) · Commits · 戴 / test

drivers/platform/chrome/wilco_ec/Kconfig

+1 −1

Original line number	Diff line number	Diff line
		# SPDX-License-Identifier: GPL-2.0-only
		config WILCO_EC
		tristate "ChromeOS Wilco Embedded Controller"
		depends on ACPI && X86 && CROS_EC_LPC
		depends on ACPI && X86 && CROS_EC_LPC && LEDS_CLASS
		help
		If you say Y here, you get support for talking to the ChromeOS
		Wilco EC over an eSPI bus. This uses a simple byte-level protocol

drivers/platform/chrome/wilco_ec/Makefile

+2 −1

Original line number	Diff line number	Diff line
		# SPDX-License-Identifier: GPL-2.0

		wilco_ec-objs := core.o mailbox.o properties.o sysfs.o
		wilco_ec-objs := core.o keyboard_leds.o mailbox.o \
		properties.o sysfs.o
		obj-$(CONFIG_WILCO_EC) += wilco_ec.o
		wilco_ec_debugfs-objs := debugfs.o
		obj-$(CONFIG_WILCO_EC_DEBUGFS) += wilco_ec_debugfs.o

drivers/platform/chrome/wilco_ec/core.c

+9 −4

Original line number	Diff line number	Diff line
		@@ -5,10 +5,6 @@
		* Copyright 2018 Google LLC
		*
		* This is the entry point for the drivers that control the Wilco EC.
		* This driver is responsible for several tasks:
		* - Initialize the register interface that is used by wilco_ec_mailbox()
		* - Create a platform device which is picked up by the debugfs driver
		* - Create a platform device which is picked up by the RTC driver
		*/

		#include <linux/acpi.h>
		@@ -87,6 +83,15 @@ static int wilco_ec_probe(struct platform_device *pdev)
		goto unregister_debugfs;
		}

		/* Set up the keyboard backlight LEDs. */
		ret = wilco_keyboard_leds_init(ec);
		if (ret < 0) {
		dev_err(dev,
		"Failed to initialize keyboard LEDs: %d\n",
		ret);
		goto unregister_rtc;
		}

		ret = wilco_ec_add_sysfs(ec);
		if (ret < 0) {
		dev_err(dev, "Failed to create sysfs entries: %d", ret);

drivers/platform/chrome/wilco_ec/keyboard_leds.c

0 → 100644

+191 −0

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0
		/*
		* Keyboard backlight LED driver for the Wilco Embedded Controller
		*
		* Copyright 2019 Google LLC
		*
		* Since the EC will never change the backlight level of its own accord,
		* we don't need to implement a brightness_get() method.
		*/

		#include <linux/device.h>
		#include <linux/kernel.h>
		#include <linux/leds.h>
		#include <linux/platform_data/wilco-ec.h>
		#include <linux/slab.h>

		#define WILCO_EC_COMMAND_KBBL 0x75
		#define WILCO_KBBL_MODE_FLAG_PWM BIT(1) /* Set brightness by percent. */
		#define WILCO_KBBL_DEFAULT_BRIGHTNESS 0

		struct wilco_keyboard_leds {
		struct wilco_ec_device *ec;
		struct led_classdev keyboard;
		};

		enum wilco_kbbl_subcommand {
		WILCO_KBBL_SUBCMD_GET_FEATURES = 0x00,
		WILCO_KBBL_SUBCMD_GET_STATE = 0x01,
		WILCO_KBBL_SUBCMD_SET_STATE = 0x02,
		};

		/**
		* struct wilco_keyboard_leds_msg - Message to/from EC for keyboard LED control.
		* @command: Always WILCO_EC_COMMAND_KBBL.
		* @status: Set by EC to 0 on success, 0xFF on failure.
		* @subcmd: One of enum wilco_kbbl_subcommand.
		* @reserved3: Should be 0.
		* @mode: Bit flags for used mode, we want to use WILCO_KBBL_MODE_FLAG_PWM.
		* @reserved5to8: Should be 0.
		* @percent: Brightness in 0-100. Only meaningful in PWM mode.
		* @reserved10to15: Should be 0.
		*/
		struct wilco_keyboard_leds_msg {
		u8 command;
		u8 status;
		u8 subcmd;
		u8 reserved3;
		u8 mode;
		u8 reserved5to8[4];
		u8 percent;
		u8 reserved10to15[6];
		} __packed;

		/* Send a request, get a response, and check that the response is good. */
		static int send_kbbl_msg(struct wilco_ec_device *ec,
		struct wilco_keyboard_leds_msg *request,
		struct wilco_keyboard_leds_msg *response)
		{
		struct wilco_ec_message msg;
		int ret;

		memset(&msg, 0, sizeof(msg));
		msg.type = WILCO_EC_MSG_LEGACY;
		msg.request_data = request;
		msg.request_size = sizeof(*request);
		msg.response_data = response;
		msg.response_size = sizeof(*response);

		ret = wilco_ec_mailbox(ec, &msg);
		if (ret < 0) {
		dev_err(ec->dev,
		"Failed sending keyboard LEDs command: %d", ret);
		return ret;
		}

		if (response->status) {
		dev_err(ec->dev,
		"EC reported failure sending keyboard LEDs command: %d",
		response->status);
		return -EIO;
		}

		return 0;
		}

		static int set_kbbl(struct wilco_ec_device *ec, enum led_brightness brightness)
		{
		struct wilco_keyboard_leds_msg request;
		struct wilco_keyboard_leds_msg response;

		memset(&request, 0, sizeof(request));
		request.command = WILCO_EC_COMMAND_KBBL;
		request.subcmd = WILCO_KBBL_SUBCMD_SET_STATE;
		request.mode = WILCO_KBBL_MODE_FLAG_PWM;
		request.percent = brightness;

		return send_kbbl_msg(ec, &request, &response);
		}

		static int kbbl_exist(struct wilco_ec_device ec, bool exists)
		{
		struct wilco_keyboard_leds_msg request;
		struct wilco_keyboard_leds_msg response;
		int ret;

		memset(&request, 0, sizeof(request));
		request.command = WILCO_EC_COMMAND_KBBL;
		request.subcmd = WILCO_KBBL_SUBCMD_GET_FEATURES;

		ret = send_kbbl_msg(ec, &request, &response);
		if (ret < 0)
		return ret;

		*exists = response.status != 0xFF;

		return 0;
		}

		/**
		* kbbl_init() - Initialize the state of the keyboard backlight.
		* @ec: EC device to talk to.
		*
		* Gets the current brightness, ensuring that the BIOS already initialized the
		* backlight to PWM mode. If not in PWM mode, then the current brightness is
		* meaningless, so set the brightness to WILCO_KBBL_DEFAULT_BRIGHTNESS.
		*
		* Return: Final brightness of the keyboard, or negative error code on failure.
		*/
		static int kbbl_init(struct wilco_ec_device *ec)
		{
		struct wilco_keyboard_leds_msg request;
		struct wilco_keyboard_leds_msg response;
		int ret;

		memset(&request, 0, sizeof(request));
		request.command = WILCO_EC_COMMAND_KBBL;
		request.subcmd = WILCO_KBBL_SUBCMD_GET_STATE;

		ret = send_kbbl_msg(ec, &request, &response);
		if (ret < 0)
		return ret;

		if (response.mode & WILCO_KBBL_MODE_FLAG_PWM)
		return response.percent;

		ret = set_kbbl(ec, WILCO_KBBL_DEFAULT_BRIGHTNESS);
		if (ret < 0)
		return ret;

		return WILCO_KBBL_DEFAULT_BRIGHTNESS;
		}

		static int wilco_keyboard_leds_set(struct led_classdev *cdev,
		enum led_brightness brightness)
		{
		struct wilco_keyboard_leds *wkl =
		container_of(cdev, struct wilco_keyboard_leds, keyboard);
		return set_kbbl(wkl->ec, brightness);
		}

		int wilco_keyboard_leds_init(struct wilco_ec_device *ec)
		{
		struct wilco_keyboard_leds *wkl;
		bool leds_exist;
		int ret;

		ret = kbbl_exist(ec, &leds_exist);
		if (ret < 0) {
		dev_err(ec->dev,
		"Failed checking keyboard LEDs support: %d", ret);
		return ret;
		}
		if (!leds_exist)
		return 0;

		wkl = devm_kzalloc(ec->dev, sizeof(*wkl), GFP_KERNEL);
		if (!wkl)
		return -ENOMEM;

		wkl->ec = ec;
		wkl->keyboard.name = "platform::kbd_backlight";
		wkl->keyboard.max_brightness = 100;
		wkl->keyboard.flags = LED_CORE_SUSPENDRESUME;
		wkl->keyboard.brightness_set_blocking = wilco_keyboard_leds_set;
		ret = kbbl_init(ec);
		if (ret < 0)
		return ret;
		wkl->keyboard.brightness = ret;

		return devm_led_classdev_register(ec->dev, &wkl->keyboard);
		}

include/linux/platform_data/wilco-ec.h

+13 −0

Original line number	Diff line number	Diff line
		@@ -122,6 +122,19 @@ struct wilco_ec_message {
		*/
		int wilco_ec_mailbox(struct wilco_ec_device ec, struct wilco_ec_message msg);

		/**
		* wilco_keyboard_leds_init() - Set up the keyboard backlight LEDs.
		* @ec: EC device to query.
		*
		* After this call, the keyboard backlight will be exposed through a an LED
		* device at /sys/class/leds.
		*
		* This may sleep because it uses wilco_ec_mailbox().
		*
		* Return: 0 on success, negative error code on failure.
		*/
		int wilco_keyboard_leds_init(struct wilco_ec_device *ec);

		/*
		* A Property is typically a data item that is stored to NVRAM
		* by the EC. Each of these data items has an index associated

Admin message