Contributors: 11
Author Tokens Token Proportion Commits Commit Proportion
Rui Miguel Silva 4755 81.81% 10 34.48%
Kris Huang 501 8.62% 2 6.90%
Viresh Kumar 374 6.43% 3 10.34%
Sakari Ailus 94 1.62% 2 6.90%
Greg Kroah-Hartman 31 0.53% 5 17.24%
Dan Carpenter 23 0.40% 1 3.45%
Arvind Yadav 14 0.24% 2 6.90%
Chen Zhou 11 0.19% 1 3.45%
David Lin 4 0.07% 1 3.45%
Karthik Tummala 4 0.07% 1 3.45%
Zheng Yongjun 1 0.02% 1 3.45%
Total 5812 29 


// SPDX-License-Identifier: GPL-2.0
/*
 * Greybus Lights protocol driver.
 *
 * Copyright 2015 Google Inc.
 * Copyright 2015 Linaro Ltd.
 */

#include <linux/kernel.h>
#include <linux/leds.h>
#include <linux/led-class-flash.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/greybus.h>
#include <media/v4l2-flash-led-class.h>

#define NAMES_MAX	32

struct gb_channel {
	u8				id;
	u32				flags;
	u32				color;
	char				*color_name;
	u8				fade_in;
	u8				fade_out;
	u32				mode;
	char				*mode_name;
	struct attribute		**attrs;
	struct attribute_group		*attr_group;
	const struct attribute_group	**attr_groups;
	struct led_classdev		*led;
#if IS_REACHABLE(CONFIG_LEDS_CLASS_FLASH)
	struct led_classdev_flash	fled;
	struct led_flash_setting	intensity_uA;
	struct led_flash_setting	timeout_us;
#else
	struct led_classdev		cled;
#endif
	struct gb_light			*light;
	bool				is_registered;
	bool				releasing;
	bool				strobe_state;
	bool				active;
	struct mutex			lock;
};

struct gb_light {
	u8			id;
	char			*name;
	struct gb_lights	*glights;
	u32			flags;
	u8			channels_count;
	struct gb_channel	*channels;
	bool			has_flash;
	bool			ready;
#if IS_REACHABLE(CONFIG_V4L2_FLASH_LED_CLASS)
	struct v4l2_flash	*v4l2_flash;
	struct v4l2_flash	*v4l2_flash_ind;
#endif
};

struct gb_lights {
	struct gb_connection	*connection;
	u8			lights_count;
	struct gb_light		*lights;
	struct mutex		lights_lock;
};

static void gb_lights_channel_free(struct gb_channel *channel);

static struct gb_connection *get_conn_from_channel(struct gb_channel *channel)
{
	return channel->light->glights->connection;
}

static struct gb_connection *get_conn_from_light(struct gb_light *light)
{
	return light->glights->connection;
}

static bool is_channel_flash(struct gb_channel *channel)
{
	return !!(channel->mode & (GB_CHANNEL_MODE_FLASH | GB_CHANNEL_MODE_TORCH
				   | GB_CHANNEL_MODE_INDICATOR));
}

#if IS_REACHABLE(CONFIG_LEDS_CLASS_FLASH)
static struct gb_channel *get_channel_from_cdev(struct led_classdev *cdev)
{
	struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(cdev);

	return container_of(fled_cdev, struct gb_channel, fled);
}

static struct led_classdev *get_channel_cdev(struct gb_channel *channel)
{
	return &channel->fled.led_cdev;
}

static struct gb_channel *get_channel_from_mode(struct gb_light *light,
						u32 mode)
{
	struct gb_channel *channel = NULL;
	int i;

	for (i = 0; i < light->channels_count; i++) {
		channel = &light->channels[i];
		if (channel && channel->mode == mode)
			break;
	}
	return channel;
}

static int __gb_lights_flash_intensity_set(struct gb_channel *channel,
					   u32 intensity)
{
	struct gb_connection *connection = get_conn_from_channel(channel);
	struct gb_bundle *bundle = connection->bundle;
	struct gb_lights_set_flash_intensity_request req;
	int ret;

	if (channel->releasing)
		return -ESHUTDOWN;

	ret = gb_pm_runtime_get_sync(bundle);
	if (ret < 0)
		return ret;

	req.light_id = channel->light->id;
	req.channel_id = channel->id;
	req.intensity_uA = cpu_to_le32(intensity);

	ret = gb_operation_sync(connection, GB_LIGHTS_TYPE_SET_FLASH_INTENSITY,
				&req, sizeof(req), NULL, 0);

	gb_pm_runtime_put_autosuspend(bundle);

	return ret;
}

static int __gb_lights_flash_brightness_set(struct gb_channel *channel)
{
	u32 intensity;

	/* If the channel is flash we need to get the attached torch channel */
	if (channel->mode & GB_CHANNEL_MODE_FLASH)
		channel = get_channel_from_mode(channel->light,
						GB_CHANNEL_MODE_TORCH);

	/* For not flash we need to convert brightness to intensity */
	intensity = channel->intensity_uA.min +
			(channel->intensity_uA.step * channel->led->brightness);

	return __gb_lights_flash_intensity_set(channel, intensity);
}
#else
static struct gb_channel *get_channel_from_cdev(struct led_classdev *cdev)
{
	return container_of(cdev, struct gb_channel, cled);
}

static struct led_classdev *get_channel_cdev(struct gb_channel *channel)
{
	return &channel->cled;
}

static int __gb_lights_flash_brightness_set(struct gb_channel *channel)
{
	return 0;
}
#endif

static int gb_lights_color_set(struct gb_channel *channel, u32 color);
static int gb_lights_fade_set(struct gb_channel *channel);

static void led_lock(struct led_classdev *cdev)
{
	mutex_lock(&cdev->led_access);
}

static void led_unlock(struct led_classdev *cdev)
{
	mutex_unlock(&cdev->led_access);
}

#define gb_lights_fade_attr(__dir)					\
static ssize_t fade_##__dir##_show(struct device *dev,			\
				   struct device_attribute *attr,	\
				   char *buf)				\
{									\
	struct led_classdev *cdev = dev_get_drvdata(dev);		\
	struct gb_channel *channel = get_channel_from_cdev(cdev);	\
									\
	return sprintf(buf, "%u\n", channel->fade_##__dir);		\
}									\
									\
static ssize_t fade_##__dir##_store(struct device *dev,			\
				    struct device_attribute *attr,	\
				    const char *buf, size_t size)	\
{									\
	struct led_classdev *cdev = dev_get_drvdata(dev);		\
	struct gb_channel *channel = get_channel_from_cdev(cdev);	\
	u8 fade;							\
	int ret;							\
									\
	led_lock(cdev);							\
	if (led_sysfs_is_disabled(cdev)) {				\
		ret = -EBUSY;						\
		goto unlock;						\
	}								\
									\
	ret = kstrtou8(buf, 0, &fade);					\
	if (ret < 0) {							\
		dev_err(dev, "could not parse fade value %d\n", ret);	\
		goto unlock;						\
	}								\
	if (channel->fade_##__dir == fade)				\
		goto unlock;						\
	channel->fade_##__dir = fade;					\
									\
	ret = gb_lights_fade_set(channel);				\
	if (ret < 0)							\
		goto unlock;						\
									\
	ret = size;							\
unlock:									\
	led_unlock(cdev);						\
	return ret;							\
}									\
static DEVICE_ATTR_RW(fade_##__dir)

gb_lights_fade_attr(in);
gb_lights_fade_attr(out);

static ssize_t color_show(struct device *dev, struct device_attribute *attr,
			  char *buf)
{
	struct led_classdev *cdev = dev_get_drvdata(dev);
	struct gb_channel *channel = get_channel_from_cdev(cdev);

	return sprintf(buf, "0x%08x\n", channel->color);
}

static ssize_t color_store(struct device *dev, struct device_attribute *attr,
			   const char *buf, size_t size)
{
	struct led_classdev *cdev = dev_get_drvdata(dev);
	struct gb_channel *channel = get_channel_from_cdev(cdev);
	u32 color;
	int ret;

	led_lock(cdev);
	if (led_sysfs_is_disabled(cdev)) {
		ret = -EBUSY;
		goto unlock;
	}
	ret = kstrtou32(buf, 0, &color);
	if (ret < 0) {
		dev_err(dev, "could not parse color value %d\n", ret);
		goto unlock;
	}

	ret = gb_lights_color_set(channel, color);
	if (ret < 0)
		goto unlock;

	channel->color = color;
	ret = size;
unlock:
	led_unlock(cdev);
	return ret;
}
static DEVICE_ATTR_RW(color);

static int channel_attr_groups_set(struct gb_channel *channel,
				   struct led_classdev *cdev)
{
	int attr = 0;
	int size = 0;

	if (channel->flags & GB_LIGHT_CHANNEL_MULTICOLOR)
		size++;
	if (channel->flags & GB_LIGHT_CHANNEL_FADER)
		size += 2;

	if (!size)
		return 0;

	/* Set attributes based in the channel flags */
	channel->attrs = kcalloc(size + 1, sizeof(*channel->attrs), GFP_KERNEL);
	if (!channel->attrs)
		return -ENOMEM;
	channel->attr_group = kzalloc(sizeof(*channel->attr_group), GFP_KERNEL);
	if (!channel->attr_group)
		return -ENOMEM;
	channel->attr_groups = kcalloc(2, sizeof(*channel->attr_groups),
				       GFP_KERNEL);
	if (!channel->attr_groups)
		return -ENOMEM;

	if (channel->flags & GB_LIGHT_CHANNEL_MULTICOLOR)
		channel->attrs[attr++] = &dev_attr_color.attr;
	if (channel->flags & GB_LIGHT_CHANNEL_FADER) {
		channel->attrs[attr++] = &dev_attr_fade_in.attr;
		channel->attrs[attr++] = &dev_attr_fade_out.attr;
	}

	channel->attr_group->attrs = channel->attrs;

	channel->attr_groups[0] = channel->attr_group;

	cdev->groups = channel->attr_groups;

	return 0;
}

static int gb_lights_fade_set(struct gb_channel *channel)
{
	struct gb_connection *connection = get_conn_from_channel(channel);
	struct gb_bundle *bundle = connection->bundle;
	struct gb_lights_set_fade_request req;
	int ret;

	if (channel->releasing)
		return -ESHUTDOWN;

	ret = gb_pm_runtime_get_sync(bundle);
	if (ret < 0)
		return ret;

	req.light_id = channel->light->id;
	req.channel_id = channel->id;
	req.fade_in = channel->fade_in;
	req.fade_out = channel->fade_out;
	ret = gb_operation_sync(connection, GB_LIGHTS_TYPE_SET_FADE,
				&req, sizeof(req), NULL, 0);

	gb_pm_runtime_put_autosuspend(bundle);

	return ret;
}

static int gb_lights_color_set(struct gb_channel *channel, u32 color)
{
	struct gb_connection *connection = get_conn_from_channel(channel);
	struct gb_bundle *bundle = connection->bundle;
	struct gb_lights_set_color_request req;
	int ret;

	if (channel->releasing)
		return -ESHUTDOWN;

	ret = gb_pm_runtime_get_sync(bundle);
	if (ret < 0)
		return ret;

	req.light_id = channel->light->id;
	req.channel_id = channel->id;
	req.color = cpu_to_le32(color);
	ret = gb_operation_sync(connection, GB_LIGHTS_TYPE_SET_COLOR,
				&req, sizeof(req), NULL, 0);

	gb_pm_runtime_put_autosuspend(bundle);

	return ret;
}

static int __gb_lights_led_brightness_set(struct gb_channel *channel)
{
	struct gb_lights_set_brightness_request req;
	struct gb_connection *connection = get_conn_from_channel(channel);
	struct gb_bundle *bundle = connection->bundle;
	bool old_active;
	int ret;

	mutex_lock(&channel->lock);
	ret = gb_pm_runtime_get_sync(bundle);
	if (ret < 0)
		goto out_unlock;

	old_active = channel->active;

	req.light_id = channel->light->id;
	req.channel_id = channel->id;
	req.brightness = (u8)channel->led->brightness;

	ret = gb_operation_sync(connection, GB_LIGHTS_TYPE_SET_BRIGHTNESS,
				&req, sizeof(req), NULL, 0);
	if (ret < 0)
		goto out_pm_put;

	if (channel->led->brightness)
		channel->active = true;
	else
		channel->active = false;

	/* we need to keep module alive when turning to active state */
	if (!old_active && channel->active)
		goto out_unlock;

	/*
	 * on the other hand if going to inactive we still hold a reference and
	 * need to put it, so we could go to suspend.
	 */
	if (old_active && !channel->active)
		gb_pm_runtime_put_autosuspend(bundle);

out_pm_put:
	gb_pm_runtime_put_autosuspend(bundle);
out_unlock:
	mutex_unlock(&channel->lock);

	return ret;
}

static int __gb_lights_brightness_set(struct gb_channel *channel)
{
	int ret;

	if (channel->releasing)
		return 0;

	if (is_channel_flash(channel))
		ret = __gb_lights_flash_brightness_set(channel);
	else
		ret = __gb_lights_led_brightness_set(channel);

	return ret;
}

static int gb_brightness_set(struct led_classdev *cdev,
			     enum led_brightness value)
{
	struct gb_channel *channel = get_channel_from_cdev(cdev);

	channel->led->brightness = value;

	return __gb_lights_brightness_set(channel);
}

static enum led_brightness gb_brightness_get(struct led_classdev *cdev)

{
	struct gb_channel *channel = get_channel_from_cdev(cdev);

	return channel->led->brightness;
}

static int gb_blink_set(struct led_classdev *cdev, unsigned long *delay_on,
			unsigned long *delay_off)
{
	struct gb_channel *channel = get_channel_from_cdev(cdev);
	struct gb_connection *connection = get_conn_from_channel(channel);
	struct gb_bundle *bundle = connection->bundle;
	struct gb_lights_blink_request req;
	bool old_active;
	int ret;

	if (channel->releasing)
		return -ESHUTDOWN;

	if (!delay_on || !delay_off)
		return -EINVAL;

	mutex_lock(&channel->lock);
	ret = gb_pm_runtime_get_sync(bundle);
	if (ret < 0)
		goto out_unlock;

	old_active = channel->active;

	req.light_id = channel->light->id;
	req.channel_id = channel->id;
	req.time_on_ms = cpu_to_le16(*delay_on);
	req.time_off_ms = cpu_to_le16(*delay_off);

	ret = gb_operation_sync(connection, GB_LIGHTS_TYPE_SET_BLINK, &req,
				sizeof(req), NULL, 0);
	if (ret < 0)
		goto out_pm_put;

	if (*delay_on)
		channel->active = true;
	else
		channel->active = false;

	/* we need to keep module alive when turning to active state */
	if (!old_active && channel->active)
		goto out_unlock;

	/*
	 * on the other hand if going to inactive we still hold a reference and
	 * need to put it, so we could go to suspend.
	 */
	if (old_active && !channel->active)
		gb_pm_runtime_put_autosuspend(bundle);

out_pm_put:
	gb_pm_runtime_put_autosuspend(bundle);
out_unlock:
	mutex_unlock(&channel->lock);

	return ret;
}

static void gb_lights_led_operations_set(struct gb_channel *channel,
					 struct led_classdev *cdev)
{
	cdev->brightness_get = gb_brightness_get;
	cdev->brightness_set_blocking = gb_brightness_set;

	if (channel->flags & GB_LIGHT_CHANNEL_BLINK)
		cdev->blink_set = gb_blink_set;
}

#if IS_REACHABLE(CONFIG_V4L2_FLASH_LED_CLASS)
/* V4L2 specific helpers */
static const struct v4l2_flash_ops v4l2_flash_ops;

static void __gb_lights_channel_v4l2_config(struct led_flash_setting *channel_s,
					    struct led_flash_setting *v4l2_s)
{
	v4l2_s->min = channel_s->min;
	v4l2_s->max = channel_s->max;
	v4l2_s->step = channel_s->step;
	/* For v4l2 val is the default value */
	v4l2_s->val = channel_s->max;
}

static int gb_lights_light_v4l2_register(struct gb_light *light)
{
	struct gb_connection *connection = get_conn_from_light(light);
	struct device *dev = &connection->bundle->dev;
	struct v4l2_flash_config sd_cfg = { {0} }, sd_cfg_ind = { {0} };
	struct led_classdev_flash *fled;
	struct led_classdev *iled = NULL;
	struct gb_channel *channel_torch, *channel_ind, *channel_flash;

	channel_torch = get_channel_from_mode(light, GB_CHANNEL_MODE_TORCH);
	if (channel_torch)
		__gb_lights_channel_v4l2_config(&channel_torch->intensity_uA,
						&sd_cfg.intensity);

	channel_ind = get_channel_from_mode(light, GB_CHANNEL_MODE_INDICATOR);
	if (channel_ind) {
		__gb_lights_channel_v4l2_config(&channel_ind->intensity_uA,
						&sd_cfg_ind.intensity);
		iled = &channel_ind->fled.led_cdev;
	}

	channel_flash = get_channel_from_mode(light, GB_CHANNEL_MODE_FLASH);
	WARN_ON(!channel_flash);

	fled = &channel_flash->fled;

	snprintf(sd_cfg.dev_name, sizeof(sd_cfg.dev_name), "%s", light->name);
	snprintf(sd_cfg_ind.dev_name, sizeof(sd_cfg_ind.dev_name),
		 "%s indicator", light->name);

	/* Set the possible values to faults, in our case all faults */
	sd_cfg.flash_faults = LED_FAULT_OVER_VOLTAGE | LED_FAULT_TIMEOUT |
		LED_FAULT_OVER_TEMPERATURE | LED_FAULT_SHORT_CIRCUIT |
		LED_FAULT_OVER_CURRENT | LED_FAULT_INDICATOR |
		LED_FAULT_UNDER_VOLTAGE | LED_FAULT_INPUT_VOLTAGE |
		LED_FAULT_LED_OVER_TEMPERATURE;

	light->v4l2_flash = v4l2_flash_init(dev, NULL, fled, &v4l2_flash_ops,
					    &sd_cfg);
	if (IS_ERR(light->v4l2_flash))
		return PTR_ERR(light->v4l2_flash);

	if (channel_ind) {
		light->v4l2_flash_ind =
			v4l2_flash_indicator_init(dev, NULL, iled, &sd_cfg_ind);
		if (IS_ERR(light->v4l2_flash_ind)) {
			v4l2_flash_release(light->v4l2_flash);
			return PTR_ERR(light->v4l2_flash_ind);
		}
	}

	return 0;
}

static void gb_lights_light_v4l2_unregister(struct gb_light *light)
{
	v4l2_flash_release(light->v4l2_flash_ind);
	v4l2_flash_release(light->v4l2_flash);
}
#else
static int gb_lights_light_v4l2_register(struct gb_light *light)
{
	struct gb_connection *connection = get_conn_from_light(light);

	dev_err(&connection->bundle->dev, "no support for v4l2 subdevices\n");
	return 0;
}

static void gb_lights_light_v4l2_unregister(struct gb_light *light)
{
}
#endif

#if IS_REACHABLE(CONFIG_LEDS_CLASS_FLASH)
/* Flash specific operations */
static int gb_lights_flash_intensity_set(struct led_classdev_flash *fcdev,
					 u32 brightness)
{
	struct gb_channel *channel = container_of(fcdev, struct gb_channel,
						  fled);
	int ret;

	ret = __gb_lights_flash_intensity_set(channel, brightness);
	if (ret < 0)
		return ret;

	fcdev->brightness.val = brightness;

	return 0;
}

static int gb_lights_flash_intensity_get(struct led_classdev_flash *fcdev,
					 u32 *brightness)
{
	*brightness = fcdev->brightness.val;

	return 0;
}

static int gb_lights_flash_strobe_set(struct led_classdev_flash *fcdev,
				      bool state)
{
	struct gb_channel *channel = container_of(fcdev, struct gb_channel,
						  fled);
	struct gb_connection *connection = get_conn_from_channel(channel);
	struct gb_bundle *bundle = connection->bundle;
	struct gb_lights_set_flash_strobe_request req;
	int ret;

	if (channel->releasing)
		return -ESHUTDOWN;

	ret = gb_pm_runtime_get_sync(bundle);
	if (ret < 0)
		return ret;

	req.light_id = channel->light->id;
	req.channel_id = channel->id;
	req.state = state ? 1 : 0;

	ret = gb_operation_sync(connection, GB_LIGHTS_TYPE_SET_FLASH_STROBE,
				&req, sizeof(req), NULL, 0);
	if (!ret)
		channel->strobe_state = state;

	gb_pm_runtime_put_autosuspend(bundle);

	return ret;
}

static int gb_lights_flash_strobe_get(struct led_classdev_flash *fcdev,
				      bool *state)
{
	struct gb_channel *channel = container_of(fcdev, struct gb_channel,
						  fled);

	*state = channel->strobe_state;
	return 0;
}

static int gb_lights_flash_timeout_set(struct led_classdev_flash *fcdev,
				       u32 timeout)
{
	struct gb_channel *channel = container_of(fcdev, struct gb_channel,
						  fled);
	struct gb_connection *connection = get_conn_from_channel(channel);
	struct gb_bundle *bundle = connection->bundle;
	struct gb_lights_set_flash_timeout_request req;
	int ret;

	if (channel->releasing)
		return -ESHUTDOWN;

	ret = gb_pm_runtime_get_sync(bundle);
	if (ret < 0)
		return ret;

	req.light_id = channel->light->id;
	req.channel_id = channel->id;
	req.timeout_us = cpu_to_le32(timeout);

	ret = gb_operation_sync(connection, GB_LIGHTS_TYPE_SET_FLASH_TIMEOUT,
				&req, sizeof(req), NULL, 0);
	if (!ret)
		fcdev->timeout.val = timeout;

	gb_pm_runtime_put_autosuspend(bundle);

	return ret;
}

static int gb_lights_flash_fault_get(struct led_classdev_flash *fcdev,
				     u32 *fault)
{
	struct gb_channel *channel = container_of(fcdev, struct gb_channel,
						  fled);
	struct gb_connection *connection = get_conn_from_channel(channel);
	struct gb_bundle *bundle = connection->bundle;
	struct gb_lights_get_flash_fault_request req;
	struct gb_lights_get_flash_fault_response resp;
	int ret;

	if (channel->releasing)
		return -ESHUTDOWN;

	ret = gb_pm_runtime_get_sync(bundle);
	if (ret < 0)
		return ret;

	req.light_id = channel->light->id;
	req.channel_id = channel->id;

	ret = gb_operation_sync(connection, GB_LIGHTS_TYPE_GET_FLASH_FAULT,
				&req, sizeof(req), &resp, sizeof(resp));
	if (!ret)
		*fault = le32_to_cpu(resp.fault);

	gb_pm_runtime_put_autosuspend(bundle);

	return ret;
}

static const struct led_flash_ops gb_lights_flash_ops = {
	.flash_brightness_set	= gb_lights_flash_intensity_set,
	.flash_brightness_get	= gb_lights_flash_intensity_get,
	.strobe_set		= gb_lights_flash_strobe_set,
	.strobe_get		= gb_lights_flash_strobe_get,
	.timeout_set		= gb_lights_flash_timeout_set,
	.fault_get		= gb_lights_flash_fault_get,
};

static int __gb_lights_channel_torch_attach(struct gb_channel *channel,
					    struct gb_channel *channel_torch)
{
	char *name;

	/* we can only attach torch to a flash channel */
	if (!(channel->mode & GB_CHANNEL_MODE_FLASH))
		return 0;

	/* Move torch brightness to the destination */
	channel->led->max_brightness = channel_torch->led->max_brightness;

	/* append mode name to flash name */
	name = kasprintf(GFP_KERNEL, "%s_%s", channel->led->name,
			 channel_torch->mode_name);
	if (!name)
		return -ENOMEM;
	kfree(channel->led->name);
	channel->led->name = name;

	channel_torch->led = channel->led;

	return 0;
}

static int __gb_lights_flash_led_register(struct gb_channel *channel)
{
	struct gb_connection *connection = get_conn_from_channel(channel);
	struct led_classdev_flash *fled = &channel->fled;
	struct led_flash_setting *fset;
	struct gb_channel *channel_torch;
	int ret;

	fled->ops = &gb_lights_flash_ops;

	fled->led_cdev.flags |= LED_DEV_CAP_FLASH;

	fset = &fled->brightness;
	fset->min = channel->intensity_uA.min;
	fset->max = channel->intensity_uA.max;
	fset->step = channel->intensity_uA.step;
	fset->val = channel->intensity_uA.max;

	/* Only the flash mode have the timeout constraints settings */
	if (channel->mode & GB_CHANNEL_MODE_FLASH) {
		fset = &fled->timeout;
		fset->min = channel->timeout_us.min;
		fset->max = channel->timeout_us.max;
		fset->step = channel->timeout_us.step;
		fset->val = channel->timeout_us.max;
	}

	/*
	 * If light have torch mode channel, this channel will be the led
	 * classdev of the registered above flash classdev
	 */
	channel_torch = get_channel_from_mode(channel->light,
					      GB_CHANNEL_MODE_TORCH);
	if (channel_torch) {
		ret = __gb_lights_channel_torch_attach(channel, channel_torch);
		if (ret < 0)
			goto fail;
	}

	ret = led_classdev_flash_register(&connection->bundle->dev, fled);
	if (ret < 0)
		goto fail;

	channel->is_registered = true;
	return 0;
fail:
	channel->led = NULL;
	return ret;
}

static void __gb_lights_flash_led_unregister(struct gb_channel *channel)
{
	if (!channel->is_registered)
		return;

	led_classdev_flash_unregister(&channel->fled);
}

static int gb_lights_channel_flash_config(struct gb_channel *channel)
{
	struct gb_connection *connection = get_conn_from_channel(channel);
	struct gb_lights_get_channel_flash_config_request req;
	struct gb_lights_get_channel_flash_config_response conf;
	struct led_flash_setting *fset;
	int ret;

	req.light_id = channel->light->id;
	req.channel_id = channel->id;

	ret = gb_operation_sync(connection,
				GB_LIGHTS_TYPE_GET_CHANNEL_FLASH_CONFIG,
				&req, sizeof(req), &conf, sizeof(conf));
	if (ret < 0)
		return ret;

	/*
	 * Intensity constraints for flash related modes: flash, torch,
	 * indicator.  They will be needed for v4l2 registration.
	 */
	fset = &channel->intensity_uA;
	fset->min = le32_to_cpu(conf.intensity_min_uA);
	fset->max = le32_to_cpu(conf.intensity_max_uA);
	fset->step = le32_to_cpu(conf.intensity_step_uA);

	/*
	 * On flash type, max brightness is set as the number of intensity steps
	 * available.
	 */
	channel->led->max_brightness = (fset->max - fset->min) / fset->step;

	/* Only the flash mode have the timeout constraints settings */
	if (channel->mode & GB_CHANNEL_MODE_FLASH) {
		fset = &channel->timeout_us;
		fset->min = le32_to_cpu(conf.timeout_min_us);
		fset->max = le32_to_cpu(conf.timeout_max_us);
		fset->step = le32_to_cpu(conf.timeout_step_us);
	}

	return 0;
}
#else
static int gb_lights_channel_flash_config(struct gb_channel *channel)
{
	struct gb_connection *connection = get_conn_from_channel(channel);

	dev_err(&connection->bundle->dev, "no support for flash devices\n");
	return 0;
}

static int __gb_lights_flash_led_register(struct gb_channel *channel)
{
	return 0;
}

static void __gb_lights_flash_led_unregister(struct gb_channel *channel)
{
}

#endif

static int __gb_lights_led_register(struct gb_channel *channel)
{
	struct gb_connection *connection = get_conn_from_channel(channel);
	struct led_classdev *cdev = get_channel_cdev(channel);
	int ret;

	ret = led_classdev_register(&connection->bundle->dev, cdev);
	if (ret < 0)
		channel->led = NULL;
	else
		channel->is_registered = true;
	return ret;
}

static int gb_lights_channel_register(struct gb_channel *channel)
{
	/* Normal LED channel, just register in led classdev and we are done */
	if (!is_channel_flash(channel))
		return __gb_lights_led_register(channel);

	/*
	 * Flash Type need more work, register flash classdev, indicator as
	 * flash classdev, torch will be led classdev of the flash classdev.
	 */
	if (!(channel->mode & GB_CHANNEL_MODE_TORCH))
		return __gb_lights_flash_led_register(channel);

	return 0;
}

static void __gb_lights_led_unregister(struct gb_channel *channel)
{
	struct led_classdev *cdev = get_channel_cdev(channel);

	if (!channel->is_registered)
		return;

	led_classdev_unregister(cdev);
	kfree(cdev->name);
	cdev->name = NULL;
	channel->led = NULL;
}

static void gb_lights_channel_unregister(struct gb_channel *channel)
{
	/* The same as register, handle channels differently */
	if (!is_channel_flash(channel)) {
		__gb_lights_led_unregister(channel);
		return;
	}

	if (channel->mode & GB_CHANNEL_MODE_TORCH)
		__gb_lights_led_unregister(channel);
	else
		__gb_lights_flash_led_unregister(channel);
}

static int gb_lights_channel_config(struct gb_light *light,
				    struct gb_channel *channel)
{
	struct gb_lights_get_channel_config_response conf;
	struct gb_lights_get_channel_config_request req;
	struct gb_connection *connection = get_conn_from_light(light);
	struct led_classdev *cdev = get_channel_cdev(channel);
	char *name;
	int ret;

	req.light_id = light->id;
	req.channel_id = channel->id;

	ret = gb_operation_sync(connection, GB_LIGHTS_TYPE_GET_CHANNEL_CONFIG,
				&req, sizeof(req), &conf, sizeof(conf));
	if (ret < 0)
		return ret;

	channel->light = light;
	channel->mode = le32_to_cpu(conf.mode);
	channel->flags = le32_to_cpu(conf.flags);
	channel->color = le32_to_cpu(conf.color);
	channel->color_name = kstrndup(conf.color_name, NAMES_MAX, GFP_KERNEL);
	if (!channel->color_name)
		return -ENOMEM;
	channel->mode_name = kstrndup(conf.mode_name, NAMES_MAX, GFP_KERNEL);
	if (!channel->mode_name)
		return -ENOMEM;

	channel->led = cdev;

	name = kasprintf(GFP_KERNEL, "%s:%s:%s", light->name,
			 channel->color_name, channel->mode_name);
	if (!name)
		return -ENOMEM;

	cdev->name = name;

	cdev->max_brightness = conf.max_brightness;

	ret = channel_attr_groups_set(channel, cdev);
	if (ret < 0)
		return ret;

	gb_lights_led_operations_set(channel, cdev);

	/*
	 * If it is not a flash related channel (flash, torch or indicator) we
	 * are done here. If not, continue and fetch flash related
	 * configurations.
	 */
	if (!is_channel_flash(channel))
		return ret;

	light->has_flash = true;

	return gb_lights_channel_flash_config(channel);
}

static int gb_lights_light_config(struct gb_lights *glights, u8 id)
{
	struct gb_light *light = &glights->lights[id];
	struct gb_lights_get_light_config_request req;
	struct gb_lights_get_light_config_response conf;
	int ret;
	int i;

	light->glights = glights;
	light->id = id;

	req.id = id;

	ret = gb_operation_sync(glights->connection,
				GB_LIGHTS_TYPE_GET_LIGHT_CONFIG,
				&req, sizeof(req), &conf, sizeof(conf));
	if (ret < 0)
		return ret;

	if (!conf.channel_count)
		return -EINVAL;
	if (!strlen(conf.name))
		return -EINVAL;

	light->channels_count = conf.channel_count;
	light->name = kstrndup(conf.name, NAMES_MAX, GFP_KERNEL);
	if (!light->name)
		return -ENOMEM;
	light->channels = kcalloc(light->channels_count,
				  sizeof(struct gb_channel), GFP_KERNEL);
	if (!light->channels)
		return -ENOMEM;

	/* First we collect all the configurations for all channels */
	for (i = 0; i < light->channels_count; i++) {
		light->channels[i].id = i;
		ret = gb_lights_channel_config(light, &light->channels[i]);
		if (ret < 0)
			return ret;
	}

	return 0;
}

static int gb_lights_light_register(struct gb_light *light)
{
	int ret;
	int i;

	/*
	 * Then, if everything went ok in getting configurations, we register
	 * the classdev, flash classdev and v4l2 subsystem, if a flash device is
	 * found.
	 */
	for (i = 0; i < light->channels_count; i++) {
		ret = gb_lights_channel_register(&light->channels[i]);
		if (ret < 0)
			return ret;

		mutex_init(&light->channels[i].lock);
	}

	light->ready = true;

	if (light->has_flash) {
		ret = gb_lights_light_v4l2_register(light);
		if (ret < 0) {
			light->has_flash = false;
			return ret;
		}
	}

	return 0;
}

static void gb_lights_channel_free(struct gb_channel *channel)
{
	kfree(channel->attrs);
	kfree(channel->attr_group);
	kfree(channel->attr_groups);
	kfree(channel->color_name);
	kfree(channel->mode_name);
	mutex_destroy(&channel->lock);
}

static void gb_lights_channel_release(struct gb_channel *channel)
{
	channel->releasing = true;

	gb_lights_channel_unregister(channel);

	gb_lights_channel_free(channel);
}

static void gb_lights_light_release(struct gb_light *light)
{
	int i;

	light->ready = false;

	if (light->has_flash)
		gb_lights_light_v4l2_unregister(light);
	light->has_flash = false;

	for (i = 0; i < light->channels_count; i++)
		gb_lights_channel_release(&light->channels[i]);
	light->channels_count = 0;

	kfree(light->channels);
	light->channels = NULL;
	kfree(light->name);
	light->name = NULL;
}

static void gb_lights_release(struct gb_lights *glights)
{
	int i;

	if (!glights)
		return;

	mutex_lock(&glights->lights_lock);
	if (!glights->lights)
		goto free_glights;

	for (i = 0; i < glights->lights_count; i++)
		gb_lights_light_release(&glights->lights[i]);

	kfree(glights->lights);

free_glights:
	mutex_unlock(&glights->lights_lock);
	mutex_destroy(&glights->lights_lock);
	kfree(glights);
}

static int gb_lights_get_count(struct gb_lights *glights)
{
	struct gb_lights_get_lights_response resp;
	int ret;

	ret = gb_operation_sync(glights->connection, GB_LIGHTS_TYPE_GET_LIGHTS,
				NULL, 0, &resp, sizeof(resp));
	if (ret < 0)
		return ret;

	if (!resp.lights_count)
		return -EINVAL;

	glights->lights_count = resp.lights_count;

	return 0;
}

static int gb_lights_create_all(struct gb_lights *glights)
{
	struct gb_connection *connection = glights->connection;
	int ret;
	int i;

	mutex_lock(&glights->lights_lock);
	ret = gb_lights_get_count(glights);
	if (ret < 0)
		goto out;

	glights->lights = kcalloc(glights->lights_count,
				  sizeof(struct gb_light), GFP_KERNEL);
	if (!glights->lights) {
		ret = -ENOMEM;
		goto out;
	}

	for (i = 0; i < glights->lights_count; i++) {
		ret = gb_lights_light_config(glights, i);
		if (ret < 0) {
			dev_err(&connection->bundle->dev,
				"Fail to configure lights device\n");
			goto out;
		}
	}

out:
	mutex_unlock(&glights->lights_lock);
	return ret;
}

static int gb_lights_register_all(struct gb_lights *glights)
{
	struct gb_connection *connection = glights->connection;
	int ret = 0;
	int i;

	mutex_lock(&glights->lights_lock);
	for (i = 0; i < glights->lights_count; i++) {
		ret = gb_lights_light_register(&glights->lights[i]);
		if (ret < 0) {
			dev_err(&connection->bundle->dev,
				"Fail to enable lights device\n");
			break;
		}
	}

	mutex_unlock(&glights->lights_lock);
	return ret;
}

static int gb_lights_request_handler(struct gb_operation *op)
{
	struct gb_connection *connection = op->connection;
	struct device *dev = &connection->bundle->dev;
	struct gb_lights *glights = gb_connection_get_data(connection);
	struct gb_light *light;
	struct gb_message *request;
	struct gb_lights_event_request *payload;
	int ret =  0;
	u8 light_id;
	u8 event;

	if (op->type != GB_LIGHTS_TYPE_EVENT) {
		dev_err(dev, "Unsupported unsolicited event: %u\n", op->type);
		return -EINVAL;
	}

	request = op->request;

	if (request->payload_size < sizeof(*payload)) {
		dev_err(dev, "Wrong event size received (%zu < %zu)\n",
			request->payload_size, sizeof(*payload));
		return -EINVAL;
	}

	payload = request->payload;
	light_id = payload->light_id;

	if (light_id >= glights->lights_count ||
	    !glights->lights[light_id].ready) {
		dev_err(dev, "Event received for unconfigured light id: %d\n",
			light_id);
		return -EINVAL;
	}

	event = payload->event;

	if (event & GB_LIGHTS_LIGHT_CONFIG) {
		light = &glights->lights[light_id];

		mutex_lock(&glights->lights_lock);
		gb_lights_light_release(light);
		ret = gb_lights_light_config(glights, light_id);
		if (!ret)
			ret = gb_lights_light_register(light);
		if (ret < 0)
			gb_lights_light_release(light);
		mutex_unlock(&glights->lights_lock);
	}

	return ret;
}

static int gb_lights_probe(struct gb_bundle *bundle,
			   const struct greybus_bundle_id *id)
{
	struct greybus_descriptor_cport *cport_desc;
	struct gb_connection *connection;
	struct gb_lights *glights;
	int ret;

	if (bundle->num_cports != 1)
		return -ENODEV;

	cport_desc = &bundle->cport_desc[0];
	if (cport_desc->protocol_id != GREYBUS_PROTOCOL_LIGHTS)
		return -ENODEV;

	glights = kzalloc(sizeof(*glights), GFP_KERNEL);
	if (!glights)
		return -ENOMEM;

	mutex_init(&glights->lights_lock);

	connection = gb_connection_create(bundle, le16_to_cpu(cport_desc->id),
					  gb_lights_request_handler);
	if (IS_ERR(connection)) {
		ret = PTR_ERR(connection);
		goto out;
	}

	glights->connection = connection;
	gb_connection_set_data(connection, glights);

	greybus_set_drvdata(bundle, glights);

	/* We aren't ready to receive an incoming request yet */
	ret = gb_connection_enable_tx(connection);
	if (ret)
		goto error_connection_destroy;

	/*
	 * Setup all the lights devices over this connection, if anything goes
	 * wrong tear down all lights
	 */
	ret = gb_lights_create_all(glights);
	if (ret < 0)
		goto error_connection_disable;

	/* We are ready to receive an incoming request now, enable RX as well */
	ret = gb_connection_enable(connection);
	if (ret)
		goto error_connection_disable;

	/* Enable & register lights */
	ret = gb_lights_register_all(glights);
	if (ret < 0)
		goto error_connection_disable;

	gb_pm_runtime_put_autosuspend(bundle);

	return 0;

error_connection_disable:
	gb_connection_disable(connection);
error_connection_destroy:
	gb_connection_destroy(connection);
out:
	gb_lights_release(glights);
	return ret;
}

static void gb_lights_disconnect(struct gb_bundle *bundle)
{
	struct gb_lights *glights = greybus_get_drvdata(bundle);

	if (gb_pm_runtime_get_sync(bundle))
		gb_pm_runtime_get_noresume(bundle);

	gb_connection_disable(glights->connection);
	gb_connection_destroy(glights->connection);

	gb_lights_release(glights);
}

static const struct greybus_bundle_id gb_lights_id_table[] = {
	{ GREYBUS_DEVICE_CLASS(GREYBUS_CLASS_LIGHTS) },
	{ }
};
MODULE_DEVICE_TABLE(greybus, gb_lights_id_table);

static struct greybus_driver gb_lights_driver = {
	.name		= "lights",
	.probe		= gb_lights_probe,
	.disconnect	= gb_lights_disconnect,
	.id_table	= gb_lights_id_table,
};
module_greybus_driver(gb_lights_driver);

MODULE_LICENSE("GPL v2");