LXR linux/drivers/platform/chrome/wilco_ec/keyboard

   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Keyboard backlight LED driver for the Wilco Embedded Controller
   4 *
   5 * Copyright 2019 Google LLC
   6 *
   7 * Since the EC will never change the backlight level of its own accord,
   8 * we don't need to implement a brightness_get() method.
   9 */
  10
  11#include <linux/device.h>
  12#include <linux/kernel.h>
  13#include <linux/leds.h>
  14#include <linux/platform_data/wilco-ec.h>
  15#include <linux/slab.h>
  16
  17#define WILCO_EC_COMMAND_KBBL           0x75
  18#define WILCO_KBBL_MODE_FLAG_PWM        BIT(1)  /* Set brightness by percent. */
  19#define WILCO_KBBL_DEFAULT_BRIGHTNESS   0
  20
  21struct wilco_keyboard_leds {
  22        struct wilco_ec_device *ec;
  23        struct led_classdev keyboard;
  24};
  25
  26enum wilco_kbbl_subcommand {
  27        WILCO_KBBL_SUBCMD_GET_FEATURES = 0x00,
  28        WILCO_KBBL_SUBCMD_GET_STATE    = 0x01,
  29        WILCO_KBBL_SUBCMD_SET_STATE    = 0x02,
  30};
  31
  32/**
  33 * struct wilco_keyboard_leds_msg - Message to/from EC for keyboard LED control.
  34 * @command: Always WILCO_EC_COMMAND_KBBL.
  35 * @status: Set by EC to 0 on success, 0xFF on failure.
  36 * @subcmd: One of enum wilco_kbbl_subcommand.
  37 * @reserved3: Should be 0.
  38 * @mode: Bit flags for used mode, we want to use WILCO_KBBL_MODE_FLAG_PWM.
  39 * @reserved5to8: Should be 0.
  40 * @percent: Brightness in 0-100. Only meaningful in PWM mode.
  41 * @reserved10to15: Should be 0.
  42 */
  43struct wilco_keyboard_leds_msg {
  44        u8 command;
  45        u8 status;
  46        u8 subcmd;
  47        u8 reserved3;
  48        u8 mode;
  49        u8 reserved5to8[4];
  50        u8 percent;
  51        u8 reserved10to15[6];
  52} __packed;
  53
  54/* Send a request, get a response, and check that the response is good. */
  55static int send_kbbl_msg(struct wilco_ec_device *ec,
  56                         struct wilco_keyboard_leds_msg *request,
  57                         struct wilco_keyboard_leds_msg *response)
  58{
  59        struct wilco_ec_message msg;
  60        int ret;
  61
  62        memset(&msg, 0, sizeof(msg));
  63        msg.type = WILCO_EC_MSG_LEGACY;
  64        msg.request_data = request;
  65        msg.request_size = sizeof(*request);
  66        msg.response_data = response;
  67        msg.response_size = sizeof(*response);
  68
  69        ret = wilco_ec_mailbox(ec, &msg);
  70        if (ret < 0) {
  71                dev_err(ec->dev,
  72                        "Failed sending keyboard LEDs command: %d\n", ret);
  73                return ret;
  74        }
  75
  76        return 0;
  77}
  78
  79static int set_kbbl(struct wilco_ec_device *ec, enum led_brightness brightness)
  80{
  81        struct wilco_keyboard_leds_msg request;
  82        struct wilco_keyboard_leds_msg response;
  83        int ret;
  84
  85        memset(&request, 0, sizeof(request));
  86        request.command = WILCO_EC_COMMAND_KBBL;
  87        request.subcmd  = WILCO_KBBL_SUBCMD_SET_STATE;
  88        request.mode    = WILCO_KBBL_MODE_FLAG_PWM;
  89        request.percent = brightness;
  90
  91        ret = send_kbbl_msg(ec, &request, &response);
  92        if (ret < 0)
  93                return ret;
  94
  95        if (response.status) {
  96                dev_err(ec->dev,
  97                        "EC reported failure sending keyboard LEDs command: %d\n",
  98                        response.status);
  99                return -EIO;
 100        }
 101
 102        return 0;
 103}
 104
 105static int kbbl_exist(struct wilco_ec_device *ec, bool *exists)
 106{
 107        struct wilco_keyboard_leds_msg request;
 108        struct wilco_keyboard_leds_msg response;
 109        int ret;
 110
 111        memset(&request, 0, sizeof(request));
 112        request.command = WILCO_EC_COMMAND_KBBL;
 113        request.subcmd  = WILCO_KBBL_SUBCMD_GET_FEATURES;
 114
 115        ret = send_kbbl_msg(ec, &request, &response);
 116        if (ret < 0)
 117                return ret;
 118
 119        *exists = response.status != 0xFF;
 120
 121        return 0;
 122}
 123
 124/**
 125 * kbbl_init() - Initialize the state of the keyboard backlight.
 126 * @ec: EC device to talk to.
 127 *
 128 * Gets the current brightness, ensuring that the BIOS already initialized the
 129 * backlight to PWM mode. If not in PWM mode, then the current brightness is
 130 * meaningless, so set the brightness to WILCO_KBBL_DEFAULT_BRIGHTNESS.
 131 *
 132 * Return: Final brightness of the keyboard, or negative error code on failure.
 133 */
 134static int kbbl_init(struct wilco_ec_device *ec)
 135{
 136        struct wilco_keyboard_leds_msg request;
 137        struct wilco_keyboard_leds_msg response;
 138        int ret;
 139
 140        memset(&request, 0, sizeof(request));
 141        request.command = WILCO_EC_COMMAND_KBBL;
 142        request.subcmd  = WILCO_KBBL_SUBCMD_GET_STATE;
 143
 144        ret = send_kbbl_msg(ec, &request, &response);
 145        if (ret < 0)
 146                return ret;
 147
 148        if (response.status) {
 149                dev_err(ec->dev,
 150                        "EC reported failure sending keyboard LEDs command: %d\n",
 151                        response.status);
 152                return -EIO;
 153        }
 154
 155        if (response.mode & WILCO_KBBL_MODE_FLAG_PWM)
 156                return response.percent;
 157
 158        ret = set_kbbl(ec, WILCO_KBBL_DEFAULT_BRIGHTNESS);
 159        if (ret < 0)
 160                return ret;
 161
 162        return WILCO_KBBL_DEFAULT_BRIGHTNESS;
 163}
 164
 165static int wilco_keyboard_leds_set(struct led_classdev *cdev,
 166                                   enum led_brightness brightness)
 167{
 168        struct wilco_keyboard_leds *wkl =
 169                container_of(cdev, struct wilco_keyboard_leds, keyboard);
 170        return set_kbbl(wkl->ec, brightness);
 171}
 172
 173int wilco_keyboard_leds_init(struct wilco_ec_device *ec)
 174{
 175        struct wilco_keyboard_leds *wkl;
 176        bool leds_exist;
 177        int ret;
 178
 179        ret = kbbl_exist(ec, &leds_exist);
 180        if (ret < 0) {
 181                dev_err(ec->dev,
 182                        "Failed checking keyboard LEDs support: %d\n", ret);
 183                return ret;
 184        }
 185        if (!leds_exist)
 186                return 0;
 187
 188        wkl = devm_kzalloc(ec->dev, sizeof(*wkl), GFP_KERNEL);
 189        if (!wkl)
 190                return -ENOMEM;
 191
 192        wkl->ec = ec;
 193        wkl->keyboard.name = "platform::kbd_backlight";
 194        wkl->keyboard.max_brightness = 100;
 195        wkl->keyboard.flags = LED_CORE_SUSPENDRESUME;
 196        wkl->keyboard.brightness_set_blocking = wilco_keyboard_leds_set;
 197        ret = kbbl_init(ec);
 198        if (ret < 0)
 199                return ret;
 200        wkl->keyboard.brightness = ret;
 201
 202        return devm_led_classdev_register(ec->dev, &wkl->keyboard);
 203}
 204