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 21 struct wilco_keyboard_leds { 22 struct wilco_ec_device *ec; 23 struct led_classdev keyboard; 24 }; 25 26 enum 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 */ 43 struct 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. */ 55 static 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 79 static 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 105 static 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 */ 134 static 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 165 static 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 173 int 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