1/* 2 * cros_ec_lightbar - expose the Chromebook Pixel lightbar to userspace 3 * 4 * Copyright (C) 2014 Google, Inc. 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program. If not, see <http://www.gnu.org/licenses/>. 18 */ 19 20#define pr_fmt(fmt) "cros_ec_lightbar: " fmt 21 22#include <linux/ctype.h> 23#include <linux/delay.h> 24#include <linux/device.h> 25#include <linux/fs.h> 26#include <linux/kobject.h> 27#include <linux/mfd/cros_ec.h> 28#include <linux/mfd/cros_ec_commands.h> 29#include <linux/module.h> 30#include <linux/platform_device.h> 31#include <linux/sched.h> 32#include <linux/types.h> 33#include <linux/uaccess.h> 34#include <linux/slab.h> 35 36#include "cros_ec_dev.h" 37 38/* Rate-limit the lightbar interface to prevent DoS. */ 39static unsigned long lb_interval_jiffies = 50 * HZ / 1000; 40 41static ssize_t interval_msec_show(struct device *dev, 42 struct device_attribute *attr, char *buf) 43{ 44 unsigned long msec = lb_interval_jiffies * 1000 / HZ; 45 46 return scnprintf(buf, PAGE_SIZE, "%lu\n", msec); 47} 48 49static ssize_t interval_msec_store(struct device *dev, 50 struct device_attribute *attr, 51 const char *buf, size_t count) 52{ 53 unsigned long msec; 54 55 if (kstrtoul(buf, 0, &msec)) 56 return -EINVAL; 57 58 lb_interval_jiffies = msec * HZ / 1000; 59 60 return count; 61} 62 63static DEFINE_MUTEX(lb_mutex); 64/* Return 0 if able to throttle correctly, error otherwise */ 65static int lb_throttle(void) 66{ 67 static unsigned long last_access; 68 unsigned long now, next_timeslot; 69 long delay; 70 int ret = 0; 71 72 mutex_lock(&lb_mutex); 73 74 now = jiffies; 75 next_timeslot = last_access + lb_interval_jiffies; 76 77 if (time_before(now, next_timeslot)) { 78 delay = (long)(next_timeslot) - (long)now; 79 set_current_state(TASK_INTERRUPTIBLE); 80 if (schedule_timeout(delay) > 0) { 81 /* interrupted - just abort */ 82 ret = -EINTR; 83 goto out; 84 } 85 now = jiffies; 86 } 87 88 last_access = now; 89out: 90 mutex_unlock(&lb_mutex); 91 92 return ret; 93} 94 95static struct cros_ec_command *alloc_lightbar_cmd_msg(struct cros_ec_dev *ec) 96{ 97 struct cros_ec_command *msg; 98 int len; 99 100 len = max(sizeof(struct ec_params_lightbar), 101 sizeof(struct ec_response_lightbar)); 102 103 msg = kmalloc(sizeof(*msg) + len, GFP_KERNEL); 104 if (!msg) 105 return NULL; 106 107 msg->version = 0; 108 msg->command = EC_CMD_LIGHTBAR_CMD + ec->cmd_offset; 109 msg->outsize = sizeof(struct ec_params_lightbar); 110 msg->insize = sizeof(struct ec_response_lightbar); 111 112 return msg; 113} 114 115static int get_lightbar_version(struct cros_ec_dev *ec, 116 uint32_t *ver_ptr, uint32_t *flg_ptr) 117{ 118 struct ec_params_lightbar *param; 119 struct ec_response_lightbar *resp; 120 struct cros_ec_command *msg; 121 int ret; 122 123 msg = alloc_lightbar_cmd_msg(ec); 124 if (!msg) 125 return 0; 126 127 param = (struct ec_params_lightbar *)msg->data; 128 param->cmd = LIGHTBAR_CMD_VERSION; 129 ret = cros_ec_cmd_xfer(ec->ec_dev, msg); 130 if (ret < 0) { 131 ret = 0; 132 goto exit; 133 } 134 135 switch (msg->result) { 136 case EC_RES_INVALID_PARAM: 137 /* Pixel had no version command. */ 138 if (ver_ptr) 139 *ver_ptr = 0; 140 if (flg_ptr) 141 *flg_ptr = 0; 142 ret = 1; 143 goto exit; 144 145 case EC_RES_SUCCESS: 146 resp = (struct ec_response_lightbar *)msg->data; 147 148 /* Future devices w/lightbars should implement this command */ 149 if (ver_ptr) 150 *ver_ptr = resp->version.num; 151 if (flg_ptr) 152 *flg_ptr = resp->version.flags; 153 ret = 1; 154 goto exit; 155 } 156 157 /* Anything else (ie, EC_RES_INVALID_COMMAND) - no lightbar */ 158 ret = 0; 159exit: 160 kfree(msg); 161 return ret; 162} 163 164static ssize_t version_show(struct device *dev, 165 struct device_attribute *attr, char *buf) 166{ 167 uint32_t version = 0, flags = 0; 168 struct cros_ec_dev *ec = container_of(dev, 169 struct cros_ec_dev, class_dev); 170 int ret; 171 172 ret = lb_throttle(); 173 if (ret) 174 return ret; 175 176 /* This should always succeed, because we check during init. */ 177 if (!get_lightbar_version(ec, &version, &flags)) 178 return -EIO; 179 180 return scnprintf(buf, PAGE_SIZE, "%d %d\n", version, flags); 181} 182 183static ssize_t brightness_store(struct device *dev, 184 struct device_attribute *attr, 185 const char *buf, size_t count) 186{ 187 struct ec_params_lightbar *param; 188 struct cros_ec_command *msg; 189 int ret; 190 unsigned int val; 191 struct cros_ec_dev *ec = container_of(dev, 192 struct cros_ec_dev, class_dev); 193 194 if (kstrtouint(buf, 0, &val)) 195 return -EINVAL; 196 197 msg = alloc_lightbar_cmd_msg(ec); 198 if (!msg) 199 return -ENOMEM; 200 201 param = (struct ec_params_lightbar *)msg->data; 202 param->cmd = LIGHTBAR_CMD_SET_BRIGHTNESS; 203 param->set_brightness.num = val; 204 ret = lb_throttle(); 205 if (ret) 206 goto exit; 207 208 ret = cros_ec_cmd_xfer(ec->ec_dev, msg); 209 if (ret < 0) 210 goto exit; 211 212 if (msg->result != EC_RES_SUCCESS) { 213 ret = -EINVAL; 214 goto exit; 215 } 216 217 ret = count; 218exit: 219 kfree(msg); 220 return ret; 221} 222 223 224/* 225 * We expect numbers, and we'll keep reading until we find them, skipping over 226 * any whitespace (sysfs guarantees that the input is null-terminated). Every 227 * four numbers are sent to the lightbar as <LED,R,G,B>. We fail at the first 228 * parsing error, if we don't parse any numbers, or if we have numbers left 229 * over. 230 */ 231static ssize_t led_rgb_store(struct device *dev, struct device_attribute *attr, 232 const char *buf, size_t count) 233{ 234 struct ec_params_lightbar *param; 235 struct cros_ec_command *msg; 236 struct cros_ec_dev *ec = container_of(dev, 237 struct cros_ec_dev, class_dev); 238 unsigned int val[4]; 239 int ret, i = 0, j = 0, ok = 0; 240 241 msg = alloc_lightbar_cmd_msg(ec); 242 if (!msg) 243 return -ENOMEM; 244 245 do { 246 /* Skip any whitespace */ 247 while (*buf && isspace(*buf)) 248 buf++; 249 250 if (!*buf) 251 break; 252 253 ret = sscanf(buf, "%i", &val[i++]); 254 if (ret == 0) 255 goto exit; 256 257 if (i == 4) { 258 param = (struct ec_params_lightbar *)msg->data; 259 param->cmd = LIGHTBAR_CMD_SET_RGB; 260 param->set_rgb.led = val[0]; 261 param->set_rgb.red = val[1]; 262 param->set_rgb.green = val[2]; 263 param->set_rgb.blue = val[3]; 264 /* 265 * Throttle only the first of every four transactions, 266 * so that the user can update all four LEDs at once. 267 */ 268 if ((j++ % 4) == 0) { 269 ret = lb_throttle(); 270 if (ret) 271 goto exit; 272 } 273 274 ret = cros_ec_cmd_xfer(ec->ec_dev, msg); 275 if (ret < 0) 276 goto exit; 277 278 if (msg->result != EC_RES_SUCCESS) 279 goto exit; 280 281 i = 0; 282 ok = 1; 283 } 284 285 /* Skip over the number we just read */ 286 while (*buf && !isspace(*buf)) 287 buf++; 288 289 } while (*buf); 290 291exit: 292 kfree(msg); 293 return (ok && i == 0) ? count : -EINVAL; 294} 295 296static char const *seqname[] = { 297 "ERROR", "S5", "S3", "S0", "S5S3", "S3S0", 298 "S0S3", "S3S5", "STOP", "RUN", "PULSE", "TEST", "KONAMI", 299}; 300 301static ssize_t sequence_show(struct device *dev, 302 struct device_attribute *attr, char *buf) 303{ 304 struct ec_params_lightbar *param; 305 struct ec_response_lightbar *resp; 306 struct cros_ec_command *msg; 307 int ret; 308 struct cros_ec_dev *ec = container_of(dev, 309 struct cros_ec_dev, class_dev); 310 311 msg = alloc_lightbar_cmd_msg(ec); 312 if (!msg) 313 return -ENOMEM; 314 315 param = (struct ec_params_lightbar *)msg->data; 316 param->cmd = LIGHTBAR_CMD_GET_SEQ; 317 ret = lb_throttle(); 318 if (ret) 319 goto exit; 320 321 ret = cros_ec_cmd_xfer(ec->ec_dev, msg); 322 if (ret < 0) 323 goto exit; 324 325 if (msg->result != EC_RES_SUCCESS) { 326 ret = scnprintf(buf, PAGE_SIZE, 327 "ERROR: EC returned %d\n", msg->result); 328 goto exit; 329 } 330 331 resp = (struct ec_response_lightbar *)msg->data; 332 if (resp->get_seq.num >= ARRAY_SIZE(seqname)) 333 ret = scnprintf(buf, PAGE_SIZE, "%d\n", resp->get_seq.num); 334 else 335 ret = scnprintf(buf, PAGE_SIZE, "%s\n", 336 seqname[resp->get_seq.num]); 337 338exit: 339 kfree(msg); 340 return ret; 341} 342 343static ssize_t sequence_store(struct device *dev, struct device_attribute *attr, 344 const char *buf, size_t count) 345{ 346 struct ec_params_lightbar *param; 347 struct cros_ec_command *msg; 348 unsigned int num; 349 int ret, len; 350 struct cros_ec_dev *ec = container_of(dev, 351 struct cros_ec_dev, class_dev); 352 353 for (len = 0; len < count; len++) 354 if (!isalnum(buf[len])) 355 break; 356 357 for (num = 0; num < ARRAY_SIZE(seqname); num++) 358 if (!strncasecmp(seqname[num], buf, len)) 359 break; 360 361 if (num >= ARRAY_SIZE(seqname)) { 362 ret = kstrtouint(buf, 0, &num); 363 if (ret) 364 return ret; 365 } 366 367 msg = alloc_lightbar_cmd_msg(ec); 368 if (!msg) 369 return -ENOMEM; 370 371 param = (struct ec_params_lightbar *)msg->data; 372 param->cmd = LIGHTBAR_CMD_SEQ; 373 param->seq.num = num; 374 ret = lb_throttle(); 375 if (ret) 376 goto exit; 377 378 ret = cros_ec_cmd_xfer(ec->ec_dev, msg); 379 if (ret < 0) 380 goto exit; 381 382 if (msg->result != EC_RES_SUCCESS) { 383 ret = -EINVAL; 384 goto exit; 385 } 386 387 ret = count; 388exit: 389 kfree(msg); 390 return ret; 391} 392 393/* Module initialization */ 394 395static DEVICE_ATTR_RW(interval_msec); 396static DEVICE_ATTR_RO(version); 397static DEVICE_ATTR_WO(brightness); 398static DEVICE_ATTR_WO(led_rgb); 399static DEVICE_ATTR_RW(sequence); 400static struct attribute *__lb_cmds_attrs[] = { 401 &dev_attr_interval_msec.attr, 402 &dev_attr_version.attr, 403 &dev_attr_brightness.attr, 404 &dev_attr_led_rgb.attr, 405 &dev_attr_sequence.attr, 406 NULL, 407}; 408 409static umode_t cros_ec_lightbar_attrs_are_visible(struct kobject *kobj, 410 struct attribute *a, int n) 411{ 412 struct device *dev = container_of(kobj, struct device, kobj); 413 struct cros_ec_dev *ec = container_of(dev, 414 struct cros_ec_dev, class_dev); 415 struct platform_device *pdev = container_of(ec->dev, 416 struct platform_device, dev); 417 if (pdev->id != 0) 418 return 0; 419 420 /* Only instantiate this stuff if the EC has a lightbar */ 421 if (get_lightbar_version(ec, NULL, NULL)) 422 return a->mode; 423 else 424 return 0; 425} 426 427struct attribute_group cros_ec_lightbar_attr_group = { 428 .name = "lightbar", 429 .attrs = __lb_cmds_attrs, 430 .is_visible = cros_ec_lightbar_attrs_are_visible, 431}; 432