1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Greybus Lights protocol driver. 4 * 5 * Copyright 2015 Google Inc. 6 * Copyright 2015 Linaro Ltd. 7 */ 8 9 #include <linux/kernel.h> 10 #include <linux/leds.h> 11 #include <linux/led-class-flash.h> 12 #include <linux/module.h> 13 #include <linux/slab.h> 14 #include <linux/greybus.h> 15 #include <media/v4l2-flash-led-class.h> 16 17 #define NAMES_MAX 32 18 19 struct gb_channel { 20 u8 id; 21 u32 flags; 22 u32 color; 23 char *color_name; 24 u8 fade_in; 25 u8 fade_out; 26 u32 mode; 27 char *mode_name; 28 struct attribute **attrs; 29 struct attribute_group *attr_group; 30 const struct attribute_group **attr_groups; 31 struct led_classdev *led; 32 #if IS_REACHABLE(CONFIG_LEDS_CLASS_FLASH) 33 struct led_classdev_flash fled; 34 struct led_flash_setting intensity_uA; 35 struct led_flash_setting timeout_us; 36 #else 37 struct led_classdev cled; 38 #endif 39 struct gb_light *light; 40 bool is_registered; 41 bool releasing; 42 bool strobe_state; 43 bool active; 44 struct mutex lock; 45 }; 46 47 struct gb_light { 48 u8 id; 49 char *name; 50 struct gb_lights *glights; 51 u32 flags; 52 u8 channels_count; 53 struct gb_channel *channels; 54 bool has_flash; 55 bool ready; 56 #if IS_REACHABLE(CONFIG_V4L2_FLASH_LED_CLASS) 57 struct v4l2_flash *v4l2_flash; 58 struct v4l2_flash *v4l2_flash_ind; 59 #endif 60 }; 61 62 struct gb_lights { 63 struct gb_connection *connection; 64 u8 lights_count; 65 struct gb_light *lights; 66 struct mutex lights_lock; 67 }; 68 69 static void gb_lights_channel_free(struct gb_channel *channel); 70 71 static struct gb_connection *get_conn_from_channel(struct gb_channel *channel) 72 { 73 return channel->light->glights->connection; 74 } 75 76 static struct gb_connection *get_conn_from_light(struct gb_light *light) 77 { 78 return light->glights->connection; 79 } 80 81 static bool is_channel_flash(struct gb_channel *channel) 82 { 83 return !!(channel->mode & (GB_CHANNEL_MODE_FLASH | GB_CHANNEL_MODE_TORCH 84 | GB_CHANNEL_MODE_INDICATOR)); 85 } 86 87 #if IS_REACHABLE(CONFIG_LEDS_CLASS_FLASH) 88 static struct gb_channel *get_channel_from_cdev(struct led_classdev *cdev) 89 { 90 struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(cdev); 91 92 return container_of(fled_cdev, struct gb_channel, fled); 93 } 94 95 static struct led_classdev *get_channel_cdev(struct gb_channel *channel) 96 { 97 return &channel->fled.led_cdev; 98 } 99 100 static struct gb_channel *get_channel_from_mode(struct gb_light *light, 101 u32 mode) 102 { 103 struct gb_channel *channel = NULL; 104 int i; 105 106 for (i = 0; i < light->channels_count; i++) { 107 channel = &light->channels[i]; 108 if (channel && channel->mode == mode) 109 break; 110 } 111 return channel; 112 } 113 114 static int __gb_lights_flash_intensity_set(struct gb_channel *channel, 115 u32 intensity) 116 { 117 struct gb_connection *connection = get_conn_from_channel(channel); 118 struct gb_bundle *bundle = connection->bundle; 119 struct gb_lights_set_flash_intensity_request req; 120 int ret; 121 122 if (channel->releasing) 123 return -ESHUTDOWN; 124 125 ret = gb_pm_runtime_get_sync(bundle); 126 if (ret < 0) 127 return ret; 128 129 req.light_id = channel->light->id; 130 req.channel_id = channel->id; 131 req.intensity_uA = cpu_to_le32(intensity); 132 133 ret = gb_operation_sync(connection, GB_LIGHTS_TYPE_SET_FLASH_INTENSITY, 134 &req, sizeof(req), NULL, 0); 135 136 gb_pm_runtime_put_autosuspend(bundle); 137 138 return ret; 139 } 140 141 static int __gb_lights_flash_brightness_set(struct gb_channel *channel) 142 { 143 u32 intensity; 144 145 /* If the channel is flash we need to get the attached torch channel */ 146 if (channel->mode & GB_CHANNEL_MODE_FLASH) 147 channel = get_channel_from_mode(channel->light, 148 GB_CHANNEL_MODE_TORCH); 149 150 /* For not flash we need to convert brightness to intensity */ 151 intensity = channel->intensity_uA.min + 152 (channel->intensity_uA.step * channel->led->brightness); 153 154 return __gb_lights_flash_intensity_set(channel, intensity); 155 } 156 #else 157 static struct gb_channel *get_channel_from_cdev(struct led_classdev *cdev) 158 { 159 return container_of(cdev, struct gb_channel, cled); 160 } 161 162 static struct led_classdev *get_channel_cdev(struct gb_channel *channel) 163 { 164 return &channel->cled; 165 } 166 167 static int __gb_lights_flash_brightness_set(struct gb_channel *channel) 168 { 169 return 0; 170 } 171 #endif 172 173 static int gb_lights_color_set(struct gb_channel *channel, u32 color); 174 static int gb_lights_fade_set(struct gb_channel *channel); 175 176 static void led_lock(struct led_classdev *cdev) 177 { 178 mutex_lock(&cdev->led_access); 179 } 180 181 static void led_unlock(struct led_classdev *cdev) 182 { 183 mutex_unlock(&cdev->led_access); 184 } 185 186 #define gb_lights_fade_attr(__dir) \ 187 static ssize_t fade_##__dir##_show(struct device *dev, \ 188 struct device_attribute *attr, \ 189 char *buf) \ 190 { \ 191 struct led_classdev *cdev = dev_get_drvdata(dev); \ 192 struct gb_channel *channel = get_channel_from_cdev(cdev); \ 193 \ 194 return sprintf(buf, "%u\n", channel->fade_##__dir); \ 195 } \ 196 \ 197 static ssize_t fade_##__dir##_store(struct device *dev, \ 198 struct device_attribute *attr, \ 199 const char *buf, size_t size) \ 200 { \ 201 struct led_classdev *cdev = dev_get_drvdata(dev); \ 202 struct gb_channel *channel = get_channel_from_cdev(cdev); \ 203 u8 fade; \ 204 int ret; \ 205 \ 206 led_lock(cdev); \ 207 if (led_sysfs_is_disabled(cdev)) { \ 208 ret = -EBUSY; \ 209 goto unlock; \ 210 } \ 211 \ 212 ret = kstrtou8(buf, 0, &fade); \ 213 if (ret < 0) { \ 214 dev_err(dev, "could not parse fade value %d\n", ret); \ 215 goto unlock; \ 216 } \ 217 if (channel->fade_##__dir == fade) \ 218 goto unlock; \ 219 channel->fade_##__dir = fade; \ 220 \ 221 ret = gb_lights_fade_set(channel); \ 222 if (ret < 0) \ 223 goto unlock; \ 224 \ 225 ret = size; \ 226 unlock: \ 227 led_unlock(cdev); \ 228 return ret; \ 229 } \ 230 static DEVICE_ATTR_RW(fade_##__dir) 231 232 gb_lights_fade_attr(in); 233 gb_lights_fade_attr(out); 234 235 static ssize_t color_show(struct device *dev, struct device_attribute *attr, 236 char *buf) 237 { 238 struct led_classdev *cdev = dev_get_drvdata(dev); 239 struct gb_channel *channel = get_channel_from_cdev(cdev); 240 241 return sprintf(buf, "0x%08x\n", channel->color); 242 } 243 244 static ssize_t color_store(struct device *dev, struct device_attribute *attr, 245 const char *buf, size_t size) 246 { 247 struct led_classdev *cdev = dev_get_drvdata(dev); 248 struct gb_channel *channel = get_channel_from_cdev(cdev); 249 u32 color; 250 int ret; 251 252 led_lock(cdev); 253 if (led_sysfs_is_disabled(cdev)) { 254 ret = -EBUSY; 255 goto unlock; 256 } 257 ret = kstrtou32(buf, 0, &color); 258 if (ret < 0) { 259 dev_err(dev, "could not parse color value %d\n", ret); 260 goto unlock; 261 } 262 263 ret = gb_lights_color_set(channel, color); 264 if (ret < 0) 265 goto unlock; 266 267 channel->color = color; 268 ret = size; 269 unlock: 270 led_unlock(cdev); 271 return ret; 272 } 273 static DEVICE_ATTR_RW(color); 274 275 static int channel_attr_groups_set(struct gb_channel *channel, 276 struct led_classdev *cdev) 277 { 278 int attr = 0; 279 int size = 0; 280 281 if (channel->flags & GB_LIGHT_CHANNEL_MULTICOLOR) 282 size++; 283 if (channel->flags & GB_LIGHT_CHANNEL_FADER) 284 size += 2; 285 286 if (!size) 287 return 0; 288 289 /* Set attributes based in the channel flags */ 290 channel->attrs = kcalloc(size + 1, sizeof(*channel->attrs), GFP_KERNEL); 291 if (!channel->attrs) 292 return -ENOMEM; 293 channel->attr_group = kcalloc(1, sizeof(*channel->attr_group), 294 GFP_KERNEL); 295 if (!channel->attr_group) 296 return -ENOMEM; 297 channel->attr_groups = kcalloc(2, sizeof(*channel->attr_groups), 298 GFP_KERNEL); 299 if (!channel->attr_groups) 300 return -ENOMEM; 301 302 if (channel->flags & GB_LIGHT_CHANNEL_MULTICOLOR) 303 channel->attrs[attr++] = &dev_attr_color.attr; 304 if (channel->flags & GB_LIGHT_CHANNEL_FADER) { 305 channel->attrs[attr++] = &dev_attr_fade_in.attr; 306 channel->attrs[attr++] = &dev_attr_fade_out.attr; 307 } 308 309 channel->attr_group->attrs = channel->attrs; 310 311 channel->attr_groups[0] = channel->attr_group; 312 313 cdev->groups = channel->attr_groups; 314 315 return 0; 316 } 317 318 static int gb_lights_fade_set(struct gb_channel *channel) 319 { 320 struct gb_connection *connection = get_conn_from_channel(channel); 321 struct gb_bundle *bundle = connection->bundle; 322 struct gb_lights_set_fade_request req; 323 int ret; 324 325 if (channel->releasing) 326 return -ESHUTDOWN; 327 328 ret = gb_pm_runtime_get_sync(bundle); 329 if (ret < 0) 330 return ret; 331 332 req.light_id = channel->light->id; 333 req.channel_id = channel->id; 334 req.fade_in = channel->fade_in; 335 req.fade_out = channel->fade_out; 336 ret = gb_operation_sync(connection, GB_LIGHTS_TYPE_SET_FADE, 337 &req, sizeof(req), NULL, 0); 338 339 gb_pm_runtime_put_autosuspend(bundle); 340 341 return ret; 342 } 343 344 static int gb_lights_color_set(struct gb_channel *channel, u32 color) 345 { 346 struct gb_connection *connection = get_conn_from_channel(channel); 347 struct gb_bundle *bundle = connection->bundle; 348 struct gb_lights_set_color_request req; 349 int ret; 350 351 if (channel->releasing) 352 return -ESHUTDOWN; 353 354 ret = gb_pm_runtime_get_sync(bundle); 355 if (ret < 0) 356 return ret; 357 358 req.light_id = channel->light->id; 359 req.channel_id = channel->id; 360 req.color = cpu_to_le32(color); 361 ret = gb_operation_sync(connection, GB_LIGHTS_TYPE_SET_COLOR, 362 &req, sizeof(req), NULL, 0); 363 364 gb_pm_runtime_put_autosuspend(bundle); 365 366 return ret; 367 } 368 369 static int __gb_lights_led_brightness_set(struct gb_channel *channel) 370 { 371 struct gb_lights_set_brightness_request req; 372 struct gb_connection *connection = get_conn_from_channel(channel); 373 struct gb_bundle *bundle = connection->bundle; 374 bool old_active; 375 int ret; 376 377 mutex_lock(&channel->lock); 378 ret = gb_pm_runtime_get_sync(bundle); 379 if (ret < 0) 380 goto out_unlock; 381 382 old_active = channel->active; 383 384 req.light_id = channel->light->id; 385 req.channel_id = channel->id; 386 req.brightness = (u8)channel->led->brightness; 387 388 ret = gb_operation_sync(connection, GB_LIGHTS_TYPE_SET_BRIGHTNESS, 389 &req, sizeof(req), NULL, 0); 390 if (ret < 0) 391 goto out_pm_put; 392 393 if (channel->led->brightness) 394 channel->active = true; 395 else 396 channel->active = false; 397 398 /* we need to keep module alive when turning to active state */ 399 if (!old_active && channel->active) 400 goto out_unlock; 401 402 /* 403 * on the other hand if going to inactive we still hold a reference and 404 * need to put it, so we could go to suspend. 405 */ 406 if (old_active && !channel->active) 407 gb_pm_runtime_put_autosuspend(bundle); 408 409 out_pm_put: 410 gb_pm_runtime_put_autosuspend(bundle); 411 out_unlock: 412 mutex_unlock(&channel->lock); 413 414 return ret; 415 } 416 417 static int __gb_lights_brightness_set(struct gb_channel *channel) 418 { 419 int ret; 420 421 if (channel->releasing) 422 return 0; 423 424 if (is_channel_flash(channel)) 425 ret = __gb_lights_flash_brightness_set(channel); 426 else 427 ret = __gb_lights_led_brightness_set(channel); 428 429 return ret; 430 } 431 432 static int gb_brightness_set(struct led_classdev *cdev, 433 enum led_brightness value) 434 { 435 struct gb_channel *channel = get_channel_from_cdev(cdev); 436 437 channel->led->brightness = value; 438 439 return __gb_lights_brightness_set(channel); 440 } 441 442 static enum led_brightness gb_brightness_get(struct led_classdev *cdev) 443 444 { 445 struct gb_channel *channel = get_channel_from_cdev(cdev); 446 447 return channel->led->brightness; 448 } 449 450 static int gb_blink_set(struct led_classdev *cdev, unsigned long *delay_on, 451 unsigned long *delay_off) 452 { 453 struct gb_channel *channel = get_channel_from_cdev(cdev); 454 struct gb_connection *connection = get_conn_from_channel(channel); 455 struct gb_bundle *bundle = connection->bundle; 456 struct gb_lights_blink_request req; 457 bool old_active; 458 int ret; 459 460 if (channel->releasing) 461 return -ESHUTDOWN; 462 463 if (!delay_on || !delay_off) 464 return -EINVAL; 465 466 mutex_lock(&channel->lock); 467 ret = gb_pm_runtime_get_sync(bundle); 468 if (ret < 0) 469 goto out_unlock; 470 471 old_active = channel->active; 472 473 req.light_id = channel->light->id; 474 req.channel_id = channel->id; 475 req.time_on_ms = cpu_to_le16(*delay_on); 476 req.time_off_ms = cpu_to_le16(*delay_off); 477 478 ret = gb_operation_sync(connection, GB_LIGHTS_TYPE_SET_BLINK, &req, 479 sizeof(req), NULL, 0); 480 if (ret < 0) 481 goto out_pm_put; 482 483 if (*delay_on) 484 channel->active = true; 485 else 486 channel->active = false; 487 488 /* we need to keep module alive when turning to active state */ 489 if (!old_active && channel->active) 490 goto out_unlock; 491 492 /* 493 * on the other hand if going to inactive we still hold a reference and 494 * need to put it, so we could go to suspend. 495 */ 496 if (old_active && !channel->active) 497 gb_pm_runtime_put_autosuspend(bundle); 498 499 out_pm_put: 500 gb_pm_runtime_put_autosuspend(bundle); 501 out_unlock: 502 mutex_unlock(&channel->lock); 503 504 return ret; 505 } 506 507 static void gb_lights_led_operations_set(struct gb_channel *channel, 508 struct led_classdev *cdev) 509 { 510 cdev->brightness_get = gb_brightness_get; 511 cdev->brightness_set_blocking = gb_brightness_set; 512 513 if (channel->flags & GB_LIGHT_CHANNEL_BLINK) 514 cdev->blink_set = gb_blink_set; 515 } 516 517 #if IS_REACHABLE(CONFIG_V4L2_FLASH_LED_CLASS) 518 /* V4L2 specific helpers */ 519 static const struct v4l2_flash_ops v4l2_flash_ops; 520 521 static void __gb_lights_channel_v4l2_config(struct led_flash_setting *channel_s, 522 struct led_flash_setting *v4l2_s) 523 { 524 v4l2_s->min = channel_s->min; 525 v4l2_s->max = channel_s->max; 526 v4l2_s->step = channel_s->step; 527 /* For v4l2 val is the default value */ 528 v4l2_s->val = channel_s->max; 529 } 530 531 static int gb_lights_light_v4l2_register(struct gb_light *light) 532 { 533 struct gb_connection *connection = get_conn_from_light(light); 534 struct device *dev = &connection->bundle->dev; 535 struct v4l2_flash_config sd_cfg = { {0} }, sd_cfg_ind = { {0} }; 536 struct led_classdev_flash *fled; 537 struct led_classdev *iled = NULL; 538 struct gb_channel *channel_torch, *channel_ind, *channel_flash; 539 540 channel_torch = get_channel_from_mode(light, GB_CHANNEL_MODE_TORCH); 541 if (channel_torch) 542 __gb_lights_channel_v4l2_config(&channel_torch->intensity_uA, 543 &sd_cfg.intensity); 544 545 channel_ind = get_channel_from_mode(light, GB_CHANNEL_MODE_INDICATOR); 546 if (channel_ind) { 547 __gb_lights_channel_v4l2_config(&channel_ind->intensity_uA, 548 &sd_cfg_ind.intensity); 549 iled = &channel_ind->fled.led_cdev; 550 } 551 552 channel_flash = get_channel_from_mode(light, GB_CHANNEL_MODE_FLASH); 553 WARN_ON(!channel_flash); 554 555 fled = &channel_flash->fled; 556 557 snprintf(sd_cfg.dev_name, sizeof(sd_cfg.dev_name), "%s", light->name); 558 snprintf(sd_cfg_ind.dev_name, sizeof(sd_cfg_ind.dev_name), 559 "%s indicator", light->name); 560 561 /* Set the possible values to faults, in our case all faults */ 562 sd_cfg.flash_faults = LED_FAULT_OVER_VOLTAGE | LED_FAULT_TIMEOUT | 563 LED_FAULT_OVER_TEMPERATURE | LED_FAULT_SHORT_CIRCUIT | 564 LED_FAULT_OVER_CURRENT | LED_FAULT_INDICATOR | 565 LED_FAULT_UNDER_VOLTAGE | LED_FAULT_INPUT_VOLTAGE | 566 LED_FAULT_LED_OVER_TEMPERATURE; 567 568 light->v4l2_flash = v4l2_flash_init(dev, NULL, fled, &v4l2_flash_ops, 569 &sd_cfg); 570 if (IS_ERR(light->v4l2_flash)) 571 return PTR_ERR(light->v4l2_flash); 572 573 if (channel_ind) { 574 light->v4l2_flash_ind = 575 v4l2_flash_indicator_init(dev, NULL, iled, &sd_cfg_ind); 576 if (IS_ERR(light->v4l2_flash_ind)) { 577 v4l2_flash_release(light->v4l2_flash); 578 return PTR_ERR(light->v4l2_flash_ind); 579 } 580 } 581 582 return 0; 583 } 584 585 static void gb_lights_light_v4l2_unregister(struct gb_light *light) 586 { 587 v4l2_flash_release(light->v4l2_flash_ind); 588 v4l2_flash_release(light->v4l2_flash); 589 } 590 #else 591 static int gb_lights_light_v4l2_register(struct gb_light *light) 592 { 593 struct gb_connection *connection = get_conn_from_light(light); 594 595 dev_err(&connection->bundle->dev, "no support for v4l2 subdevices\n"); 596 return 0; 597 } 598 599 static void gb_lights_light_v4l2_unregister(struct gb_light *light) 600 { 601 } 602 #endif 603 604 #if IS_REACHABLE(CONFIG_LEDS_CLASS_FLASH) 605 /* Flash specific operations */ 606 static int gb_lights_flash_intensity_set(struct led_classdev_flash *fcdev, 607 u32 brightness) 608 { 609 struct gb_channel *channel = container_of(fcdev, struct gb_channel, 610 fled); 611 int ret; 612 613 ret = __gb_lights_flash_intensity_set(channel, brightness); 614 if (ret < 0) 615 return ret; 616 617 fcdev->brightness.val = brightness; 618 619 return 0; 620 } 621 622 static int gb_lights_flash_intensity_get(struct led_classdev_flash *fcdev, 623 u32 *brightness) 624 { 625 *brightness = fcdev->brightness.val; 626 627 return 0; 628 } 629 630 static int gb_lights_flash_strobe_set(struct led_classdev_flash *fcdev, 631 bool state) 632 { 633 struct gb_channel *channel = container_of(fcdev, struct gb_channel, 634 fled); 635 struct gb_connection *connection = get_conn_from_channel(channel); 636 struct gb_bundle *bundle = connection->bundle; 637 struct gb_lights_set_flash_strobe_request req; 638 int ret; 639 640 if (channel->releasing) 641 return -ESHUTDOWN; 642 643 ret = gb_pm_runtime_get_sync(bundle); 644 if (ret < 0) 645 return ret; 646 647 req.light_id = channel->light->id; 648 req.channel_id = channel->id; 649 req.state = state ? 1 : 0; 650 651 ret = gb_operation_sync(connection, GB_LIGHTS_TYPE_SET_FLASH_STROBE, 652 &req, sizeof(req), NULL, 0); 653 if (!ret) 654 channel->strobe_state = state; 655 656 gb_pm_runtime_put_autosuspend(bundle); 657 658 return ret; 659 } 660 661 static int gb_lights_flash_strobe_get(struct led_classdev_flash *fcdev, 662 bool *state) 663 { 664 struct gb_channel *channel = container_of(fcdev, struct gb_channel, 665 fled); 666 667 *state = channel->strobe_state; 668 return 0; 669 } 670 671 static int gb_lights_flash_timeout_set(struct led_classdev_flash *fcdev, 672 u32 timeout) 673 { 674 struct gb_channel *channel = container_of(fcdev, struct gb_channel, 675 fled); 676 struct gb_connection *connection = get_conn_from_channel(channel); 677 struct gb_bundle *bundle = connection->bundle; 678 struct gb_lights_set_flash_timeout_request req; 679 int ret; 680 681 if (channel->releasing) 682 return -ESHUTDOWN; 683 684 ret = gb_pm_runtime_get_sync(bundle); 685 if (ret < 0) 686 return ret; 687 688 req.light_id = channel->light->id; 689 req.channel_id = channel->id; 690 req.timeout_us = cpu_to_le32(timeout); 691 692 ret = gb_operation_sync(connection, GB_LIGHTS_TYPE_SET_FLASH_TIMEOUT, 693 &req, sizeof(req), NULL, 0); 694 if (!ret) 695 fcdev->timeout.val = timeout; 696 697 gb_pm_runtime_put_autosuspend(bundle); 698 699 return ret; 700 } 701 702 static int gb_lights_flash_fault_get(struct led_classdev_flash *fcdev, 703 u32 *fault) 704 { 705 struct gb_channel *channel = container_of(fcdev, struct gb_channel, 706 fled); 707 struct gb_connection *connection = get_conn_from_channel(channel); 708 struct gb_bundle *bundle = connection->bundle; 709 struct gb_lights_get_flash_fault_request req; 710 struct gb_lights_get_flash_fault_response resp; 711 int ret; 712 713 if (channel->releasing) 714 return -ESHUTDOWN; 715 716 ret = gb_pm_runtime_get_sync(bundle); 717 if (ret < 0) 718 return ret; 719 720 req.light_id = channel->light->id; 721 req.channel_id = channel->id; 722 723 ret = gb_operation_sync(connection, GB_LIGHTS_TYPE_GET_FLASH_FAULT, 724 &req, sizeof(req), &resp, sizeof(resp)); 725 if (!ret) 726 *fault = le32_to_cpu(resp.fault); 727 728 gb_pm_runtime_put_autosuspend(bundle); 729 730 return ret; 731 } 732 733 static const struct led_flash_ops gb_lights_flash_ops = { 734 .flash_brightness_set = gb_lights_flash_intensity_set, 735 .flash_brightness_get = gb_lights_flash_intensity_get, 736 .strobe_set = gb_lights_flash_strobe_set, 737 .strobe_get = gb_lights_flash_strobe_get, 738 .timeout_set = gb_lights_flash_timeout_set, 739 .fault_get = gb_lights_flash_fault_get, 740 }; 741 742 static int __gb_lights_channel_torch_attach(struct gb_channel *channel, 743 struct gb_channel *channel_torch) 744 { 745 char *name; 746 747 /* we can only attach torch to a flash channel */ 748 if (!(channel->mode & GB_CHANNEL_MODE_FLASH)) 749 return 0; 750 751 /* Move torch brightness to the destination */ 752 channel->led->max_brightness = channel_torch->led->max_brightness; 753 754 /* append mode name to flash name */ 755 name = kasprintf(GFP_KERNEL, "%s_%s", channel->led->name, 756 channel_torch->mode_name); 757 if (!name) 758 return -ENOMEM; 759 kfree(channel->led->name); 760 channel->led->name = name; 761 762 channel_torch->led = channel->led; 763 764 return 0; 765 } 766 767 static int __gb_lights_flash_led_register(struct gb_channel *channel) 768 { 769 struct gb_connection *connection = get_conn_from_channel(channel); 770 struct led_classdev_flash *fled = &channel->fled; 771 struct led_flash_setting *fset; 772 struct gb_channel *channel_torch; 773 int ret; 774 775 fled->ops = &gb_lights_flash_ops; 776 777 fled->led_cdev.flags |= LED_DEV_CAP_FLASH; 778 779 fset = &fled->brightness; 780 fset->min = channel->intensity_uA.min; 781 fset->max = channel->intensity_uA.max; 782 fset->step = channel->intensity_uA.step; 783 fset->val = channel->intensity_uA.max; 784 785 /* Only the flash mode have the timeout constraints settings */ 786 if (channel->mode & GB_CHANNEL_MODE_FLASH) { 787 fset = &fled->timeout; 788 fset->min = channel->timeout_us.min; 789 fset->max = channel->timeout_us.max; 790 fset->step = channel->timeout_us.step; 791 fset->val = channel->timeout_us.max; 792 } 793 794 /* 795 * If light have torch mode channel, this channel will be the led 796 * classdev of the registered above flash classdev 797 */ 798 channel_torch = get_channel_from_mode(channel->light, 799 GB_CHANNEL_MODE_TORCH); 800 if (channel_torch) { 801 ret = __gb_lights_channel_torch_attach(channel, channel_torch); 802 if (ret < 0) 803 goto fail; 804 } 805 806 ret = led_classdev_flash_register(&connection->bundle->dev, fled); 807 if (ret < 0) 808 goto fail; 809 810 channel->is_registered = true; 811 return 0; 812 fail: 813 channel->led = NULL; 814 return ret; 815 } 816 817 static void __gb_lights_flash_led_unregister(struct gb_channel *channel) 818 { 819 if (!channel->is_registered) 820 return; 821 822 led_classdev_flash_unregister(&channel->fled); 823 } 824 825 static int gb_lights_channel_flash_config(struct gb_channel *channel) 826 { 827 struct gb_connection *connection = get_conn_from_channel(channel); 828 struct gb_lights_get_channel_flash_config_request req; 829 struct gb_lights_get_channel_flash_config_response conf; 830 struct led_flash_setting *fset; 831 int ret; 832 833 req.light_id = channel->light->id; 834 req.channel_id = channel->id; 835 836 ret = gb_operation_sync(connection, 837 GB_LIGHTS_TYPE_GET_CHANNEL_FLASH_CONFIG, 838 &req, sizeof(req), &conf, sizeof(conf)); 839 if (ret < 0) 840 return ret; 841 842 /* 843 * Intensity constraints for flash related modes: flash, torch, 844 * indicator. They will be needed for v4l2 registration. 845 */ 846 fset = &channel->intensity_uA; 847 fset->min = le32_to_cpu(conf.intensity_min_uA); 848 fset->max = le32_to_cpu(conf.intensity_max_uA); 849 fset->step = le32_to_cpu(conf.intensity_step_uA); 850 851 /* 852 * On flash type, max brightness is set as the number of intensity steps 853 * available. 854 */ 855 channel->led->max_brightness = (fset->max - fset->min) / fset->step; 856 857 /* Only the flash mode have the timeout constraints settings */ 858 if (channel->mode & GB_CHANNEL_MODE_FLASH) { 859 fset = &channel->timeout_us; 860 fset->min = le32_to_cpu(conf.timeout_min_us); 861 fset->max = le32_to_cpu(conf.timeout_max_us); 862 fset->step = le32_to_cpu(conf.timeout_step_us); 863 } 864 865 return 0; 866 } 867 #else 868 static int gb_lights_channel_flash_config(struct gb_channel *channel) 869 { 870 struct gb_connection *connection = get_conn_from_channel(channel); 871 872 dev_err(&connection->bundle->dev, "no support for flash devices\n"); 873 return 0; 874 } 875 876 static int __gb_lights_flash_led_register(struct gb_channel *channel) 877 { 878 return 0; 879 } 880 881 static void __gb_lights_flash_led_unregister(struct gb_channel *channel) 882 { 883 } 884 885 #endif 886 887 static int __gb_lights_led_register(struct gb_channel *channel) 888 { 889 struct gb_connection *connection = get_conn_from_channel(channel); 890 struct led_classdev *cdev = get_channel_cdev(channel); 891 int ret; 892 893 ret = led_classdev_register(&connection->bundle->dev, cdev); 894 if (ret < 0) 895 channel->led = NULL; 896 else 897 channel->is_registered = true; 898 return ret; 899 } 900 901 static int gb_lights_channel_register(struct gb_channel *channel) 902 { 903 /* Normal LED channel, just register in led classdev and we are done */ 904 if (!is_channel_flash(channel)) 905 return __gb_lights_led_register(channel); 906 907 /* 908 * Flash Type need more work, register flash classdev, indicator as 909 * flash classdev, torch will be led classdev of the flash classdev. 910 */ 911 if (!(channel->mode & GB_CHANNEL_MODE_TORCH)) 912 return __gb_lights_flash_led_register(channel); 913 914 return 0; 915 } 916 917 static void __gb_lights_led_unregister(struct gb_channel *channel) 918 { 919 struct led_classdev *cdev = get_channel_cdev(channel); 920 921 if (!channel->is_registered) 922 return; 923 924 led_classdev_unregister(cdev); 925 kfree(cdev->name); 926 cdev->name = NULL; 927 channel->led = NULL; 928 } 929 930 static void gb_lights_channel_unregister(struct gb_channel *channel) 931 { 932 /* The same as register, handle channels differently */ 933 if (!is_channel_flash(channel)) { 934 __gb_lights_led_unregister(channel); 935 return; 936 } 937 938 if (channel->mode & GB_CHANNEL_MODE_TORCH) 939 __gb_lights_led_unregister(channel); 940 else 941 __gb_lights_flash_led_unregister(channel); 942 } 943 944 static int gb_lights_channel_config(struct gb_light *light, 945 struct gb_channel *channel) 946 { 947 struct gb_lights_get_channel_config_response conf; 948 struct gb_lights_get_channel_config_request req; 949 struct gb_connection *connection = get_conn_from_light(light); 950 struct led_classdev *cdev = get_channel_cdev(channel); 951 char *name; 952 int ret; 953 954 req.light_id = light->id; 955 req.channel_id = channel->id; 956 957 ret = gb_operation_sync(connection, GB_LIGHTS_TYPE_GET_CHANNEL_CONFIG, 958 &req, sizeof(req), &conf, sizeof(conf)); 959 if (ret < 0) 960 return ret; 961 962 channel->light = light; 963 channel->mode = le32_to_cpu(conf.mode); 964 channel->flags = le32_to_cpu(conf.flags); 965 channel->color = le32_to_cpu(conf.color); 966 channel->color_name = kstrndup(conf.color_name, NAMES_MAX, GFP_KERNEL); 967 if (!channel->color_name) 968 return -ENOMEM; 969 channel->mode_name = kstrndup(conf.mode_name, NAMES_MAX, GFP_KERNEL); 970 if (!channel->mode_name) 971 return -ENOMEM; 972 973 channel->led = cdev; 974 975 name = kasprintf(GFP_KERNEL, "%s:%s:%s", light->name, 976 channel->color_name, channel->mode_name); 977 if (!name) 978 return -ENOMEM; 979 980 cdev->name = name; 981 982 cdev->max_brightness = conf.max_brightness; 983 984 ret = channel_attr_groups_set(channel, cdev); 985 if (ret < 0) 986 return ret; 987 988 gb_lights_led_operations_set(channel, cdev); 989 990 /* 991 * If it is not a flash related channel (flash, torch or indicator) we 992 * are done here. If not, continue and fetch flash related 993 * configurations. 994 */ 995 if (!is_channel_flash(channel)) 996 return ret; 997 998 light->has_flash = true; 999 1000 return gb_lights_channel_flash_config(channel); 1001 } 1002 1003 static int gb_lights_light_config(struct gb_lights *glights, u8 id) 1004 { 1005 struct gb_light *light = &glights->lights[id]; 1006 struct gb_lights_get_light_config_request req; 1007 struct gb_lights_get_light_config_response conf; 1008 int ret; 1009 int i; 1010 1011 light->glights = glights; 1012 light->id = id; 1013 1014 req.id = id; 1015 1016 ret = gb_operation_sync(glights->connection, 1017 GB_LIGHTS_TYPE_GET_LIGHT_CONFIG, 1018 &req, sizeof(req), &conf, sizeof(conf)); 1019 if (ret < 0) 1020 return ret; 1021 1022 if (!conf.channel_count) 1023 return -EINVAL; 1024 if (!strlen(conf.name)) 1025 return -EINVAL; 1026 1027 light->channels_count = conf.channel_count; 1028 light->name = kstrndup(conf.name, NAMES_MAX, GFP_KERNEL); 1029 if (!light->name) 1030 return -ENOMEM; 1031 light->channels = kcalloc(light->channels_count, 1032 sizeof(struct gb_channel), GFP_KERNEL); 1033 if (!light->channels) 1034 return -ENOMEM; 1035 1036 /* First we collect all the configurations for all channels */ 1037 for (i = 0; i < light->channels_count; i++) { 1038 light->channels[i].id = i; 1039 ret = gb_lights_channel_config(light, &light->channels[i]); 1040 if (ret < 0) 1041 return ret; 1042 } 1043 1044 return 0; 1045 } 1046 1047 static int gb_lights_light_register(struct gb_light *light) 1048 { 1049 int ret; 1050 int i; 1051 1052 /* 1053 * Then, if everything went ok in getting configurations, we register 1054 * the classdev, flash classdev and v4l2 subsystem, if a flash device is 1055 * found. 1056 */ 1057 for (i = 0; i < light->channels_count; i++) { 1058 ret = gb_lights_channel_register(&light->channels[i]); 1059 if (ret < 0) 1060 return ret; 1061 1062 mutex_init(&light->channels[i].lock); 1063 } 1064 1065 light->ready = true; 1066 1067 if (light->has_flash) { 1068 ret = gb_lights_light_v4l2_register(light); 1069 if (ret < 0) { 1070 light->has_flash = false; 1071 return ret; 1072 } 1073 } 1074 1075 return 0; 1076 } 1077 1078 static void gb_lights_channel_free(struct gb_channel *channel) 1079 { 1080 kfree(channel->attrs); 1081 kfree(channel->attr_group); 1082 kfree(channel->attr_groups); 1083 kfree(channel->color_name); 1084 kfree(channel->mode_name); 1085 mutex_destroy(&channel->lock); 1086 } 1087 1088 static void gb_lights_channel_release(struct gb_channel *channel) 1089 { 1090 channel->releasing = true; 1091 1092 gb_lights_channel_unregister(channel); 1093 1094 gb_lights_channel_free(channel); 1095 } 1096 1097 static void gb_lights_light_release(struct gb_light *light) 1098 { 1099 int i; 1100 1101 light->ready = false; 1102 1103 if (light->has_flash) 1104 gb_lights_light_v4l2_unregister(light); 1105 light->has_flash = false; 1106 1107 for (i = 0; i < light->channels_count; i++) 1108 gb_lights_channel_release(&light->channels[i]); 1109 light->channels_count = 0; 1110 1111 kfree(light->channels); 1112 light->channels = NULL; 1113 kfree(light->name); 1114 light->name = NULL; 1115 } 1116 1117 static void gb_lights_release(struct gb_lights *glights) 1118 { 1119 int i; 1120 1121 if (!glights) 1122 return; 1123 1124 mutex_lock(&glights->lights_lock); 1125 if (!glights->lights) 1126 goto free_glights; 1127 1128 for (i = 0; i < glights->lights_count; i++) 1129 gb_lights_light_release(&glights->lights[i]); 1130 1131 kfree(glights->lights); 1132 1133 free_glights: 1134 mutex_unlock(&glights->lights_lock); 1135 mutex_destroy(&glights->lights_lock); 1136 kfree(glights); 1137 } 1138 1139 static int gb_lights_get_count(struct gb_lights *glights) 1140 { 1141 struct gb_lights_get_lights_response resp; 1142 int ret; 1143 1144 ret = gb_operation_sync(glights->connection, GB_LIGHTS_TYPE_GET_LIGHTS, 1145 NULL, 0, &resp, sizeof(resp)); 1146 if (ret < 0) 1147 return ret; 1148 1149 if (!resp.lights_count) 1150 return -EINVAL; 1151 1152 glights->lights_count = resp.lights_count; 1153 1154 return 0; 1155 } 1156 1157 static int gb_lights_create_all(struct gb_lights *glights) 1158 { 1159 struct gb_connection *connection = glights->connection; 1160 int ret; 1161 int i; 1162 1163 mutex_lock(&glights->lights_lock); 1164 ret = gb_lights_get_count(glights); 1165 if (ret < 0) 1166 goto out; 1167 1168 glights->lights = kcalloc(glights->lights_count, 1169 sizeof(struct gb_light), GFP_KERNEL); 1170 if (!glights->lights) { 1171 ret = -ENOMEM; 1172 goto out; 1173 } 1174 1175 for (i = 0; i < glights->lights_count; i++) { 1176 ret = gb_lights_light_config(glights, i); 1177 if (ret < 0) { 1178 dev_err(&connection->bundle->dev, 1179 "Fail to configure lights device\n"); 1180 goto out; 1181 } 1182 } 1183 1184 out: 1185 mutex_unlock(&glights->lights_lock); 1186 return ret; 1187 } 1188 1189 static int gb_lights_register_all(struct gb_lights *glights) 1190 { 1191 struct gb_connection *connection = glights->connection; 1192 int ret = 0; 1193 int i; 1194 1195 mutex_lock(&glights->lights_lock); 1196 for (i = 0; i < glights->lights_count; i++) { 1197 ret = gb_lights_light_register(&glights->lights[i]); 1198 if (ret < 0) { 1199 dev_err(&connection->bundle->dev, 1200 "Fail to enable lights device\n"); 1201 break; 1202 } 1203 } 1204 1205 mutex_unlock(&glights->lights_lock); 1206 return ret; 1207 } 1208 1209 static int gb_lights_request_handler(struct gb_operation *op) 1210 { 1211 struct gb_connection *connection = op->connection; 1212 struct device *dev = &connection->bundle->dev; 1213 struct gb_lights *glights = gb_connection_get_data(connection); 1214 struct gb_light *light; 1215 struct gb_message *request; 1216 struct gb_lights_event_request *payload; 1217 int ret = 0; 1218 u8 light_id; 1219 u8 event; 1220 1221 if (op->type != GB_LIGHTS_TYPE_EVENT) { 1222 dev_err(dev, "Unsupported unsolicited event: %u\n", op->type); 1223 return -EINVAL; 1224 } 1225 1226 request = op->request; 1227 1228 if (request->payload_size < sizeof(*payload)) { 1229 dev_err(dev, "Wrong event size received (%zu < %zu)\n", 1230 request->payload_size, sizeof(*payload)); 1231 return -EINVAL; 1232 } 1233 1234 payload = request->payload; 1235 light_id = payload->light_id; 1236 1237 if (light_id >= glights->lights_count || 1238 !glights->lights[light_id].ready) { 1239 dev_err(dev, "Event received for unconfigured light id: %d\n", 1240 light_id); 1241 return -EINVAL; 1242 } 1243 1244 event = payload->event; 1245 1246 if (event & GB_LIGHTS_LIGHT_CONFIG) { 1247 light = &glights->lights[light_id]; 1248 1249 mutex_lock(&glights->lights_lock); 1250 gb_lights_light_release(light); 1251 ret = gb_lights_light_config(glights, light_id); 1252 if (!ret) 1253 ret = gb_lights_light_register(light); 1254 if (ret < 0) 1255 gb_lights_light_release(light); 1256 mutex_unlock(&glights->lights_lock); 1257 } 1258 1259 return ret; 1260 } 1261 1262 static int gb_lights_probe(struct gb_bundle *bundle, 1263 const struct greybus_bundle_id *id) 1264 { 1265 struct greybus_descriptor_cport *cport_desc; 1266 struct gb_connection *connection; 1267 struct gb_lights *glights; 1268 int ret; 1269 1270 if (bundle->num_cports != 1) 1271 return -ENODEV; 1272 1273 cport_desc = &bundle->cport_desc[0]; 1274 if (cport_desc->protocol_id != GREYBUS_PROTOCOL_LIGHTS) 1275 return -ENODEV; 1276 1277 glights = kzalloc(sizeof(*glights), GFP_KERNEL); 1278 if (!glights) 1279 return -ENOMEM; 1280 1281 mutex_init(&glights->lights_lock); 1282 1283 connection = gb_connection_create(bundle, le16_to_cpu(cport_desc->id), 1284 gb_lights_request_handler); 1285 if (IS_ERR(connection)) { 1286 ret = PTR_ERR(connection); 1287 goto out; 1288 } 1289 1290 glights->connection = connection; 1291 gb_connection_set_data(connection, glights); 1292 1293 greybus_set_drvdata(bundle, glights); 1294 1295 /* We aren't ready to receive an incoming request yet */ 1296 ret = gb_connection_enable_tx(connection); 1297 if (ret) 1298 goto error_connection_destroy; 1299 1300 /* 1301 * Setup all the lights devices over this connection, if anything goes 1302 * wrong tear down all lights 1303 */ 1304 ret = gb_lights_create_all(glights); 1305 if (ret < 0) 1306 goto error_connection_disable; 1307 1308 /* We are ready to receive an incoming request now, enable RX as well */ 1309 ret = gb_connection_enable(connection); 1310 if (ret) 1311 goto error_connection_disable; 1312 1313 /* Enable & register lights */ 1314 ret = gb_lights_register_all(glights); 1315 if (ret < 0) 1316 goto error_connection_disable; 1317 1318 gb_pm_runtime_put_autosuspend(bundle); 1319 1320 return 0; 1321 1322 error_connection_disable: 1323 gb_connection_disable(connection); 1324 error_connection_destroy: 1325 gb_connection_destroy(connection); 1326 out: 1327 gb_lights_release(glights); 1328 return ret; 1329 } 1330 1331 static void gb_lights_disconnect(struct gb_bundle *bundle) 1332 { 1333 struct gb_lights *glights = greybus_get_drvdata(bundle); 1334 1335 if (gb_pm_runtime_get_sync(bundle)) 1336 gb_pm_runtime_get_noresume(bundle); 1337 1338 gb_connection_disable(glights->connection); 1339 gb_connection_destroy(glights->connection); 1340 1341 gb_lights_release(glights); 1342 } 1343 1344 static const struct greybus_bundle_id gb_lights_id_table[] = { 1345 { GREYBUS_DEVICE_CLASS(GREYBUS_CLASS_LIGHTS) }, 1346 { } 1347 }; 1348 MODULE_DEVICE_TABLE(greybus, gb_lights_id_table); 1349 1350 static struct greybus_driver gb_lights_driver = { 1351 .name = "lights", 1352 .probe = gb_lights_probe, 1353 .disconnect = gb_lights_disconnect, 1354 .id_table = gb_lights_id_table, 1355 }; 1356 module_greybus_driver(gb_lights_driver); 1357 1358 MODULE_LICENSE("GPL v2"); 1359