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