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. */ 39 static unsigned long lb_interval_jiffies = 50 * HZ / 1000; 40 41 static 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 49 static 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 63 static DEFINE_MUTEX(lb_mutex); 64 /* Return 0 if able to throttle correctly, error otherwise */ 65 static 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; 89 out: 90 mutex_unlock(&lb_mutex); 91 92 return ret; 93 } 94 95 static 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 115 static 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; 159 exit: 160 kfree(msg); 161 return ret; 162 } 163 164 static 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 183 static 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; 218 exit: 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 */ 231 static 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 291 exit: 292 kfree(msg); 293 return (ok && i == 0) ? count : -EINVAL; 294 } 295 296 static char const *seqname[] = { 297 "ERROR", "S5", "S3", "S0", "S5S3", "S3S0", 298 "S0S3", "S3S5", "STOP", "RUN", "PULSE", "TEST", "KONAMI", 299 }; 300 301 static 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 338 exit: 339 kfree(msg); 340 return ret; 341 } 342 343 static 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; 388 exit: 389 kfree(msg); 390 return ret; 391 } 392 393 /* Module initialization */ 394 395 static DEVICE_ATTR_RW(interval_msec); 396 static DEVICE_ATTR_RO(version); 397 static DEVICE_ATTR_WO(brightness); 398 static DEVICE_ATTR_WO(led_rgb); 399 static DEVICE_ATTR_RW(sequence); 400 static 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 409 static 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 = to_platform_device(ec->dev); 416 struct cros_ec_platform *pdata = pdev->dev.platform_data; 417 int is_cros_ec; 418 419 is_cros_ec = strcmp(pdata->ec_name, CROS_EC_DEV_NAME); 420 421 if (is_cros_ec != 0) 422 return 0; 423 424 /* Only instantiate this stuff if the EC has a lightbar */ 425 if (get_lightbar_version(ec, NULL, NULL)) 426 return a->mode; 427 else 428 return 0; 429 } 430 431 struct attribute_group cros_ec_lightbar_attr_group = { 432 .name = "lightbar", 433 .attrs = __lb_cmds_attrs, 434 .is_visible = cros_ec_lightbar_attrs_are_visible, 435 }; 436