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 return -EINVAL; 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 return ret; 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 ret = -EINVAL; 280 goto exit; 281 } 282 283 i = 0; 284 ok = 1; 285 } 286 287 /* Skip over the number we just read */ 288 while (*buf && !isspace(*buf)) 289 buf++; 290 291 } while (*buf); 292 293 exit: 294 kfree(msg); 295 return (ok && i == 0) ? count : -EINVAL; 296 } 297 298 static char const *seqname[] = { 299 "ERROR", "S5", "S3", "S0", "S5S3", "S3S0", 300 "S0S3", "S3S5", "STOP", "RUN", "PULSE", "TEST", "KONAMI", 301 }; 302 303 static ssize_t sequence_show(struct device *dev, 304 struct device_attribute *attr, char *buf) 305 { 306 struct ec_params_lightbar *param; 307 struct ec_response_lightbar *resp; 308 struct cros_ec_command *msg; 309 int ret; 310 struct cros_ec_dev *ec = container_of(dev, 311 struct cros_ec_dev, class_dev); 312 313 msg = alloc_lightbar_cmd_msg(ec); 314 if (!msg) 315 return -ENOMEM; 316 317 param = (struct ec_params_lightbar *)msg->data; 318 param->cmd = LIGHTBAR_CMD_GET_SEQ; 319 ret = lb_throttle(); 320 if (ret) 321 goto exit; 322 323 ret = cros_ec_cmd_xfer(ec->ec_dev, msg); 324 if (ret < 0) 325 goto exit; 326 327 if (msg->result != EC_RES_SUCCESS) { 328 ret = scnprintf(buf, PAGE_SIZE, 329 "ERROR: EC returned %d\n", msg->result); 330 goto exit; 331 } 332 333 resp = (struct ec_response_lightbar *)msg->data; 334 if (resp->get_seq.num >= ARRAY_SIZE(seqname)) 335 ret = scnprintf(buf, PAGE_SIZE, "%d\n", resp->get_seq.num); 336 else 337 ret = scnprintf(buf, PAGE_SIZE, "%s\n", 338 seqname[resp->get_seq.num]); 339 340 exit: 341 kfree(msg); 342 return ret; 343 } 344 345 static ssize_t sequence_store(struct device *dev, struct device_attribute *attr, 346 const char *buf, size_t count) 347 { 348 struct ec_params_lightbar *param; 349 struct cros_ec_command *msg; 350 unsigned int num; 351 int ret, len; 352 struct cros_ec_dev *ec = container_of(dev, 353 struct cros_ec_dev, class_dev); 354 355 msg = alloc_lightbar_cmd_msg(ec); 356 if (!msg) 357 return -ENOMEM; 358 359 for (len = 0; len < count; len++) 360 if (!isalnum(buf[len])) 361 break; 362 363 for (num = 0; num < ARRAY_SIZE(seqname); num++) 364 if (!strncasecmp(seqname[num], buf, len)) 365 break; 366 367 if (num >= ARRAY_SIZE(seqname)) { 368 ret = kstrtouint(buf, 0, &num); 369 if (ret) 370 return ret; 371 } 372 373 param = (struct ec_params_lightbar *)msg->data; 374 param->cmd = LIGHTBAR_CMD_SEQ; 375 param->seq.num = num; 376 ret = lb_throttle(); 377 if (ret) 378 return ret; 379 380 ret = cros_ec_cmd_xfer(ec->ec_dev, msg); 381 if (ret < 0) 382 return ret; 383 384 if (msg->result != EC_RES_SUCCESS) 385 return -EINVAL; 386 387 return count; 388 } 389 390 /* Module initialization */ 391 392 static DEVICE_ATTR_RW(interval_msec); 393 static DEVICE_ATTR_RO(version); 394 static DEVICE_ATTR_WO(brightness); 395 static DEVICE_ATTR_WO(led_rgb); 396 static DEVICE_ATTR_RW(sequence); 397 static struct attribute *__lb_cmds_attrs[] = { 398 &dev_attr_interval_msec.attr, 399 &dev_attr_version.attr, 400 &dev_attr_brightness.attr, 401 &dev_attr_led_rgb.attr, 402 &dev_attr_sequence.attr, 403 NULL, 404 }; 405 406 static umode_t cros_ec_lightbar_attrs_are_visible(struct kobject *kobj, 407 struct attribute *a, int n) 408 { 409 struct device *dev = container_of(kobj, struct device, kobj); 410 struct cros_ec_dev *ec = container_of(dev, 411 struct cros_ec_dev, class_dev); 412 struct platform_device *pdev = container_of(ec->dev, 413 struct platform_device, dev); 414 if (pdev->id != 0) 415 return 0; 416 417 /* Only instantiate this stuff if the EC has a lightbar */ 418 if (get_lightbar_version(ec, NULL, NULL)) 419 return a->mode; 420 else 421 return 0; 422 } 423 424 struct attribute_group cros_ec_lightbar_attr_group = { 425 .name = "lightbar", 426 .attrs = __lb_cmds_attrs, 427 .is_visible = cros_ec_lightbar_attrs_are_visible, 428 }; 429