@@ -30,6 +30,17 @@ config LEDS_CLASS_FLASH
for the flash related features of a LED device. It can be built
as a module.
+config LEDS_FLASH_MANAGER
+ bool "LED Flash Manager Support"
+ depends on LEDS_CLASS_FLASH
+ depends on OF
+ help
+ This option enables the Flash Manager functionality for the
+ LED Flash Class. It allows for chaning the flash - strobe provider
+ connections dynamically. You'll need this only if any of the flash
+ led devices on the board has its external strobe signal routed
+ through multiplexer(s).
+
comment "LED drivers"
config LEDS_88PM860X
@@ -3,6 +3,10 @@
obj-$(CONFIG_NEW_LEDS) += led-core.o
obj-$(CONFIG_LEDS_CLASS) += led-class.o
obj-$(CONFIG_LEDS_CLASS_FLASH) += led-class-flash.o
+obj-$(CONFIG_LEDS_FLASH_MANAGER) += led-fm.o
+led-fm-objs := led-flash-manager.o \
+ led-flash-gpio-mux.o \
+ of_led_flash_manager.o
obj-$(CONFIG_LEDS_TRIGGERS) += led-triggers.o
# LED Platform Drivers
@@ -13,6 +13,7 @@
#include <linux/init.h>
#include <linux/leds.h>
#include <linux/led-class-flash.h>
+#include <linux/led-flash-manager.h>
#include <linux/module.h>
#include <linux/slab.h>
#include "leds.h"
@@ -468,6 +469,13 @@ int led_classdev_flash_register(struct device *parent,
if (ret < 0)
return -EINVAL;
+ /* Register in the flash manager if there is related data to parse */
+ if (node) {
+ ret = led_flash_manager_register_flash(flash, node);
+ if (ret < 0)
+ goto err_flash_manager_register;
+ }
+
/* Create flash led specific sysfs attributes */
ret = led_flash_create_sysfs_groups(flash);
if (ret < 0)
@@ -476,6 +484,8 @@ int led_classdev_flash_register(struct device *parent,
return 0;
err_create_sysfs_groups:
+ led_flash_manager_unregister_flash(flash);
+err_flash_manager_register:
led_classdev_unregister(led_cdev);
return ret;
@@ -488,6 +498,7 @@ void led_classdev_flash_unregister(struct led_classdev_flash *flash)
return;
led_flash_remove_sysfs_groups(flash);
+ led_flash_manager_unregister_flash(flash);
led_classdev_unregister(&flash->led_cdev);
}
EXPORT_SYMBOL_GPL(led_classdev_flash_unregister);
@@ -542,6 +553,7 @@ EXPORT_SYMBOL_GPL(led_get_flash_fault);
int led_set_external_strobe(struct led_classdev_flash *flash, bool enable)
{
+ struct led_classdev *led_cdev = &flash->led_cdev;
int ret;
if (flash->has_external_strobe) {
@@ -556,6 +568,13 @@ int led_set_external_strobe(struct led_classdev_flash *flash, bool enable)
}
flash->external_strobe = enable;
+
+ if (led_cdev->flags & LED_DEV_CAP_FL_MANAGER) {
+ ret = led_flash_manager_set_external_strobe(flash,
+ enable);
+ if (ret < 0)
+ return ret;
+ }
} else if (enable) {
return -EINVAL;
}
new file mode 100644
@@ -0,0 +1,102 @@
+/*
+ * LED Flash Class gpio mux
+ *
+ * Copyright (C) 2014 Samsung Electronics Co., Ltd
+ * Author: Jacek Anaszewski <j.anaszewski@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation."
+ */
+
+#include <linux/gpio.h>
+#include <linux/led-flash-gpio-mux.h>
+#include <linux/of_gpio.h>
+#include <linux/slab.h>
+
+int led_flash_gpio_mux_select_line(u32 line_id, void *mux)
+{
+ struct led_flash_gpio_mux *gpio_mux = (struct led_flash_gpio_mux *) mux;
+ struct led_flash_gpio_mux_selector *sel;
+ u32 mask = 1;
+
+ /* Setup selectors */
+ list_for_each_entry(sel, &gpio_mux->selectors, list) {
+ gpio_set_value(sel->gpio, !!(line_id & mask));
+ mask <<= 1;
+ }
+
+ return 0;
+}
+EXPORT_SYMBOL_GPL(led_flash_gpio_mux_select_line);
+
+/* Create standard gpio mux */
+int led_flash_gpio_mux_create(struct led_flash_gpio_mux **new_mux,
+ struct device_node *mux_node)
+{
+ struct led_flash_gpio_mux *mux;
+ struct led_flash_gpio_mux_selector *sel;
+ int gpio_num, gpio, ret, i;
+ char gpio_name[20];
+ static int cnt_gpio;
+
+ /* Get the number of mux selectors */
+ gpio_num = of_gpio_count(mux_node);
+ if (gpio_num == 0)
+ return -EINVAL;
+
+ mux = kzalloc(sizeof(*mux), GFP_KERNEL);
+ if (!mux)
+ return -ENOMEM;
+
+ INIT_LIST_HEAD(&mux->selectors);
+
+ /* Request gpios for all selectors */
+ for (i = 0; i < gpio_num; ++i) {
+ gpio = of_get_gpio(mux_node, i);
+ if (gpio_is_valid(gpio)) {
+ sprintf(gpio_name, "v4l2_mux selector %d", cnt_gpio++);
+ ret = gpio_request_one(gpio, GPIOF_DIR_OUT, gpio_name);
+ if (ret < 0)
+ goto err_gpio_request;
+
+ /* Add new entry to the gpio selectors list */
+ sel = kzalloc(sizeof(*sel), GFP_KERNEL);
+ if (!sel) {
+ ret = -ENOMEM;
+ goto err_gpio_request;
+ }
+ sel->gpio = gpio;
+
+ list_add_tail(&sel->list, &mux->selectors);
+ } else {
+ ret = -EINVAL;
+ goto err_gpio_request;
+ }
+
+ }
+
+ *new_mux = mux;
+
+ return 0;
+
+err_gpio_request:
+ led_flash_gpio_mux_release(mux);
+
+ return ret;
+}
+EXPORT_SYMBOL_GPL(led_flash_gpio_mux_create);
+
+void led_flash_gpio_mux_release(void *mux)
+{
+ struct led_flash_gpio_mux *gpio_mux = (struct led_flash_gpio_mux *) mux;
+ struct led_flash_gpio_mux_selector *sel, *n;
+
+ list_for_each_entry_safe(sel, n, &gpio_mux->selectors, list) {
+ if (gpio_is_valid(sel->gpio))
+ gpio_free(sel->gpio);
+ kfree(sel);
+ }
+ kfree(gpio_mux);
+}
+EXPORT_SYMBOL_GPL(led_flash_gpio_mux_release);
new file mode 100644
@@ -0,0 +1,590 @@
+/*
+ * LED Flash Manager for maintaining LED Flash Class devices
+ * along with their corresponding muxex, faciliating dynamic
+ * reconfiguration of the strobe signal source.
+ *
+ * Copyright (C) 2014 Samsung Electronics Co., Ltd
+ * Author: Jacek Anaszewski <j.anaszewski@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation."
+ */
+
+#include <linux/delay.h>
+#include <linux/led-class-flash.h>
+#include <linux/led-flash-gpio-mux.h>
+#include <linux/led-flash-manager.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/of_gpio.h>
+#include <linux/of_led_flash_manager.h>
+#include <linux/slab.h>
+
+static LIST_HEAD(flash_list);
+static LIST_HEAD(mux_bound_list);
+static LIST_HEAD(mux_waiting_list);
+static DEFINE_MUTEX(fm_lock);
+
+static ssize_t strobe_provider_store(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t size)
+{
+ struct led_classdev *led_cdev = dev_get_drvdata(dev);
+ struct led_classdev_flash *flash = lcdev_to_flash(led_cdev);
+ unsigned long provider_id;
+ ssize_t ret;
+
+ mutex_lock(&led_cdev->led_lock);
+
+ if (led_sysfs_is_locked(led_cdev)) {
+ ret = -EBUSY;
+ goto unlock;
+ }
+
+ ret = kstrtoul(buf, 10, &provider_id);
+ if (ret)
+ goto unlock;
+
+ if (provider_id > flash->num_strobe_providers - 1) {
+ ret = -ERANGE;
+ goto unlock;
+ }
+
+ flash->strobe_provider_id = provider_id;
+
+ ret = size;
+unlock:
+ mutex_unlock(&led_cdev->led_lock);
+ return ret;
+}
+
+static ssize_t strobe_provider_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct led_classdev *led_cdev = dev_get_drvdata(dev);
+ struct led_classdev_flash *flash = lcdev_to_flash(led_cdev);
+
+ return sprintf(buf, "%u\n", flash->strobe_provider_id);
+}
+static DEVICE_ATTR_RW(strobe_provider);
+
+static ssize_t available_strobe_providers_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct led_flash_strobe_provider *provider =
+ container_of(attr, struct led_flash_strobe_provider, attr);
+ const char *no_name = "undefined";
+ const char *provider_name;
+
+ provider_name = provider->name ? provider->name :
+ no_name;
+
+ return sprintf(buf, "%s\n", provider_name);
+}
+
+static int led_flash_manager_create_providers_attrs(
+ struct led_classdev_flash *flash)
+{
+ struct led_flash_strobe_provider *provider;
+ struct led_classdev *led_cdev = &flash->led_cdev;
+ int cnt_attr = 0;
+ int ret;
+
+ list_for_each_entry(provider, &flash->strobe_providers, list) {
+ provider->attr.show = available_strobe_providers_show;
+ provider->attr.attr.mode = S_IRUGO;
+
+ sprintf(provider->attr_name, "strobe_provider%d",
+ cnt_attr++);
+ provider->attr.attr.name = provider->attr_name;
+
+ sysfs_attr_init(&provider->attr.attr);
+
+ ret = sysfs_create_file(&led_cdev->dev->kobj,
+ &provider->attr.attr);
+ if (ret < 0)
+ goto error_create_attr;
+
+ provider->attr_registered = true;
+ }
+
+ /*
+ * strobe_provider attribute is required only if there have been more
+ * than one strobe source defined for the LED Flash Class device.
+ */
+ if (cnt_attr > 1) {
+ ret = sysfs_create_file(&led_cdev->dev->kobj,
+ &dev_attr_strobe_provider.attr);
+ if (ret < 0)
+ goto error_create_attr;
+ }
+
+ return 0;
+
+error_create_attr:
+ list_for_each_entry(provider, &flash->strobe_providers, list) {
+ if (!provider->attr_registered)
+ break;
+ sysfs_remove_file(&led_cdev->dev->kobj, &provider->attr.attr);
+ }
+
+ return ret;
+}
+
+static void led_flash_manager_remove_providers_attrs(
+ struct led_classdev_flash *flash)
+{
+ struct led_flash_strobe_provider *provider;
+ struct led_classdev *led_cdev = &flash->led_cdev;
+ int cnt_attr = 0;
+
+ list_for_each_entry(provider, &flash->strobe_providers, list) {
+ if (!provider->attr_registered)
+ break;
+ sysfs_remove_file(&led_cdev->dev->kobj, &provider->attr.attr);
+ provider->attr_registered = false;
+ ++cnt_attr;
+ }
+
+ /*
+ * If there was more than one strobe_providerN attr to remove
+ * than there is also strobe_provider attr to remove.
+ */
+ if (cnt_attr > 1)
+ sysfs_remove_file(&led_cdev->dev->kobj,
+ &dev_attr_strobe_provider.attr);
+}
+
+/* Return mux associated with gate */
+static struct led_flash_mux *led_flash_manager_get_mux_by_gate(
+ struct led_flash_strobe_gate *gate,
+ struct list_head *mux_list)
+{
+ struct led_flash_mux *mux;
+
+ list_for_each_entry(mux, mux_list, list)
+ if (mux->node == gate->mux_node)
+ return mux;
+
+ return NULL;
+}
+
+/* Setup all muxes in the gate list */
+static int led_flash_manager_setup_muxes(struct led_classdev_flash *flash,
+ struct list_head *gate_list)
+{
+ struct led_classdev *led_cdev = &flash->led_cdev;
+ struct led_flash_strobe_gate *gate;
+ struct led_flash_mux *mux;
+ struct device *dev = led_cdev->dev->parent;
+ int ret = 0;
+
+ list_for_each_entry(gate, gate_list, list) {
+ mux = led_flash_manager_get_mux_by_gate(gate, &mux_bound_list);
+ if (!mux) {
+ dev_err(dev, "Flash mux not bound (%s)\n",
+ gate->mux_node->name);
+ return -ENODEV;
+ }
+
+ ret = mux->ops->select_line(gate->line_id,
+ mux->private_data);
+ }
+
+ return ret;
+}
+
+/*
+ * Setup all muxes required to open the route
+ * to the external strobe signal provider
+ */
+static int led_flash_manager_select_strobe_provider(
+ struct led_classdev_flash *flash,
+ int provider_id)
+{
+ struct led_flash_strobe_provider *provider;
+ int ret, provider_cnt = 0;
+
+ list_for_each_entry(provider, &flash->strobe_providers, list)
+ if (provider_cnt++ == provider_id) {
+ ret = led_flash_manager_setup_muxes(flash,
+ &provider->strobe_gates);
+ return ret;
+ }
+
+ return -EINVAL;
+}
+
+/*
+ * Setup all muxes required to open the route
+ * either to software or external strobe source.
+ */
+int led_flash_manager_set_external_strobe(
+ struct led_classdev_flash *flash,
+ bool external)
+{
+ int ret;
+
+ if (external)
+ ret = led_flash_manager_select_strobe_provider(flash,
+ flash->strobe_provider_id);
+ else
+ /* There can be only one software strobe provider */
+ ret = led_flash_manager_setup_muxes(flash,
+ &flash->software_strobe_gates);
+
+ return ret;
+}
+EXPORT_SYMBOL_GPL(led_flash_manager_set_external_strobe);
+
+/* Notify flash manager that async mux is available. */
+int led_flash_manager_bind_async_mux(struct led_flash_mux *async_mux)
+{
+ struct led_flash_mux *mux;
+ bool mux_found = false;
+ int ret = 0;
+
+ if (!async_mux)
+ return -EINVAL;
+
+ mutex_lock(&fm_lock);
+
+ /*
+ * Check whether the LED Flash Class device using this
+ * mux has been already registered in the flash manager.
+ */
+ list_for_each_entry(mux, &mux_waiting_list, list)
+ if (async_mux->node == mux->node) {
+ /* Move the mux to the bound muxes list */
+
+ list_move(&mux->list, &mux_bound_list);
+ mux_found = true;
+
+ if (!try_module_get(async_mux->owner)) {
+ ret = -ENODEV;
+ goto unlock;
+ }
+
+ break;
+ }
+
+ if (!mux_found) {
+ /* This is a new mux - create its representation */
+ mux = kzalloc(sizeof(*mux), GFP_KERNEL);
+ if (!mux) {
+ ret = -ENOMEM;
+ goto unlock;
+ }
+
+ INIT_LIST_HEAD(&mux->refs);
+
+ /* Add the mux to the bound list. */
+ list_add(&mux->list, &mux_bound_list);
+ }
+
+ mux->ops = async_mux->ops;
+ mux->node = async_mux->node;
+ mux->owner = async_mux->owner;
+
+unlock:
+ mutex_unlock(&fm_lock);
+
+ return ret;
+}
+EXPORT_SYMBOL_GPL(led_flash_manager_bind_async_mux);
+
+int led_flash_manager_unbind_async_mux(struct device_node *mux_node)
+{
+ struct led_flash_mux *mux;
+ int ret = -ENODEV;
+
+ mutex_lock(&fm_lock);
+
+ /*
+ * Mux can be unbound only when is not used by any
+ * flash led device, otherwise this is erroneous call.
+ */
+ list_for_each_entry(mux, &mux_waiting_list, list)
+ if (mux->node == mux_node) {
+ list_move(&mux->list, &mux_waiting_list);
+ ret = 0;
+ break;
+ }
+
+ mutex_unlock(&fm_lock);
+
+ return ret;
+}
+EXPORT_SYMBOL_GPL(led_flash_manager_unbind_async_mux);
+
+struct led_flash_mux_ops gpio_mux_ops = {
+ .select_line = led_flash_gpio_mux_select_line,
+ .release_private_data = led_flash_gpio_mux_release,
+};
+
+static int __add_mux_ref(struct led_flash_mux_ref *ref,
+ struct led_flash_mux *mux)
+{
+ struct led_flash_mux_ref *r;
+ int ret;
+
+ /*
+ * One mux device usually appear in more than one strobe
+ * gate of a single flash LED device (e.g. one software
+ * and one hardware strobe gate is defined in its DT binding,
+ * which reflects two lines of a mux). Don't allow for
+ * more than one flash reference to the same mux.
+ */
+ list_for_each_entry(r, &mux->refs, list)
+ if (r->flash == ref->flash) {
+ kfree(ref);
+ return 0;
+ }
+
+ /* protect async mux against rmmod */
+ if (mux->owner) {
+ ret = try_module_get(mux->owner);
+ if (ret < 0)
+ return ret;
+ }
+
+ list_add(&ref->list, &mux->refs);
+
+ return 0;
+}
+
+static void __remove_mux_ref(struct led_flash_mux_ref *ref,
+ struct led_flash_mux *mux)
+{
+ /* decrement async mux refcount */
+ if (mux->owner)
+ module_put(mux->owner);
+
+ list_del(&ref->list);
+}
+
+/*
+ * Parse mux node and add the mux it refers to either to waiting
+ * or bound list depending on the mux type (gpio or asynchronous).
+ */
+static int led_flash_manager_parse_mux_node(struct led_classdev_flash *flash,
+ struct led_flash_strobe_gate *gate)
+{
+ struct led_flash_mux *mux;
+ struct device_node *async_mux_node;
+ struct led_flash_gpio_mux *gpio_mux;
+ struct led_flash_mux_ref *ref;
+ int ret = -EINVAL;
+
+ /* Create flash ref to be added to the mux references list */
+ ref = kzalloc(sizeof(*ref), GFP_KERNEL);
+ if (!ref)
+ return -ENOMEM;
+ ref->flash = flash;
+
+ /* if this is async mux update gate's mux_node accordingly */
+ async_mux_node = of_parse_phandle(gate->mux_node, "mux-async", 0);
+ if (async_mux_node)
+ gate->mux_node = async_mux_node;
+
+ /* Check if the mux isn't already on waiting list */
+ list_for_each_entry(mux, &mux_waiting_list, list)
+ if (mux->node == gate->mux_node)
+ return __add_mux_ref(ref, mux);
+
+ /* Check if the mux isn't already on bound list */
+ list_for_each_entry(mux, &mux_bound_list, list)
+ if (mux->node == gate->mux_node)
+ return __add_mux_ref(ref, mux);
+
+ /* This is a new mux - create its representation */
+ mux = kzalloc(sizeof(*mux), GFP_KERNEL);
+ if (!mux)
+ return -ENOMEM;
+
+ mux->node = gate->mux_node;
+
+ INIT_LIST_HEAD(&mux->refs);
+
+ /* Increment reference count */
+ ret = __add_mux_ref(ref, mux);
+ if (ret < 0)
+ return ret;
+
+ /*
+ * Check if this mux has its own driver
+ * or this is standard gpio mux.
+ */
+ if (async_mux_node) {
+ /* Add async mux to the waiting list */
+ list_add(&mux->list, &mux_waiting_list);
+ } else {
+ /* Create default gpio mux */
+ ret = led_flash_gpio_mux_create(&gpio_mux, gate->mux_node);
+ if (ret < 0)
+ goto err_gpio_mux_init;
+
+ /* Register gpio mux device */
+ mux->private_data = gpio_mux;
+ mux->ops = &gpio_mux_ops;
+ list_add(&mux->list, &mux_bound_list);
+ }
+
+ return 0;
+
+err_gpio_mux_init:
+ kfree(mux);
+ kfree(ref);
+
+ return ret;
+}
+
+static void led_flash_manager_release_mux(struct led_flash_mux *mux)
+{
+ if (mux->ops->release_private_data) {
+ if (mux->ops->release_private_data)
+ mux->ops->release_private_data(mux->private_data);
+ list_del(&mux->list);
+ kfree(mux);
+ }
+}
+
+static void led_flash_manager_remove_flash_refs(
+ struct led_classdev_flash *flash)
+{
+ struct led_flash_mux_ref *ref, *rn;
+ struct led_flash_mux *mux, *mn;
+
+ /*
+ * Remove references to the flash from
+ * all the muxes on the list.
+ */
+ list_for_each_entry_safe(mux, mn, &mux_bound_list, list)
+ /* Seek for matching flash ref */
+ list_for_each_entry_safe(ref, rn, &mux->refs, list)
+ if (ref->flash == flash) {
+ /* Decrement reference count */
+ __remove_mux_ref(ref, mux);
+ kfree(ref);
+ /*
+ * Release mux if there are no more
+ * references pointing to it.
+ */
+ if (list_empty(&mux->refs))
+ led_flash_manager_release_mux(mux);
+ }
+}
+
+int led_flash_manager_register_flash(struct led_classdev_flash *flash,
+ struct device_node *node)
+{
+ struct led_flash_strobe_provider *provider;
+ struct led_flash_strobe_gate *gate;
+ struct led_classdev_flash *fl;
+ struct led_classdev *led_cdev = &flash->led_cdev;
+ int ret = 0;
+
+ if (!flash || !node)
+ return -EINVAL;
+
+ mutex_lock(&fm_lock);
+
+ /* Don't allow to register the same flash more than once */
+ list_for_each_entry(fl, &flash_list, list)
+ if (fl == flash)
+ goto unlock;
+
+ INIT_LIST_HEAD(&flash->software_strobe_gates);
+ INIT_LIST_HEAD(&flash->strobe_providers);
+
+ ret = of_led_flash_manager_parse_dt(flash, node);
+ if (ret < 0)
+ goto unlock;
+
+ /*
+ * Register mux devices declared by the flash device
+ * if they have not been yet known to the flash manager.
+ */
+ list_for_each_entry(gate, &flash->software_strobe_gates, list) {
+ ret = led_flash_manager_parse_mux_node(flash, gate);
+ if (ret < 0)
+ goto err_parse_mux_node;
+ }
+
+ list_for_each_entry(provider, &flash->strobe_providers, list) {
+ list_for_each_entry(gate, &provider->strobe_gates, list) {
+ ret = led_flash_manager_parse_mux_node(flash, gate);
+ if (ret < 0)
+ goto err_parse_mux_node;
+ }
+ ++flash->num_strobe_providers;
+ }
+
+ /*
+ * It doesn't make sense to register in the flash manager
+ * if there are no strobe providers defined.
+ */
+ if (flash->num_strobe_providers == 0)
+ goto err_parse_mux_node;
+
+ led_cdev->flags |= LED_DEV_CAP_FL_MANAGER;
+ flash->has_external_strobe = true;
+ flash->strobe_provider_id = 0;
+
+ /* Create sysfs attributes describing available strobe providers. */
+ ret = led_flash_manager_create_providers_attrs(flash);
+ if (ret < 0)
+ goto err_create_provider_attrs;
+
+ /* Add flash to the list of flashes maintained by the flash manager. */
+ list_add_tail(&flash->list, &flash_list);
+
+ mutex_unlock(&fm_lock);
+
+ return ret;
+
+err_create_provider_attrs:
+ led_flash_manager_remove_providers_attrs(flash);
+err_parse_mux_node:
+ led_flash_manager_remove_flash_refs(flash);
+ of_led_flash_manager_release_dt_data(flash);
+unlock:
+ mutex_unlock(&fm_lock);
+
+ return ret;
+}
+EXPORT_SYMBOL_GPL(led_flash_manager_register_flash);
+
+void led_flash_manager_unregister_flash(struct led_classdev_flash *flash)
+{
+ struct led_classdev_flash *fl, *n;
+ bool found_flash = false;
+
+ mutex_lock(&fm_lock);
+
+ /* Remove flash from the list, if found */
+ list_for_each_entry_safe(fl, n, &flash_list, list)
+ if (fl == flash) {
+ found_flash = true;
+ break;
+ }
+
+ if (!found_flash)
+ goto unlock;
+
+ list_del(&fl->list);
+
+ led_flash_manager_remove_providers_attrs(flash);
+
+ /* Remove all references to the flash */
+ led_flash_manager_remove_flash_refs(flash);
+ of_led_flash_manager_release_dt_data(flash);
+
+unlock:
+ mutex_unlock(&fm_lock);
+}
+EXPORT_SYMBOL_GPL(led_flash_manager_unregister_flash);
+
+MODULE_AUTHOR("Jacek Anaszewski <j.anaszewski@samsung.com>");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("LED Flash Manager");
new file mode 100644
@@ -0,0 +1,155 @@
+/*
+ * LED flash manager of helpers.
+ *
+ * Copyright (C) 2014 Samsung Electronics Co., Ltd
+ * Author: Jacek Anaszewski <j.anaszewski@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation."
+ */
+
+#include <linux/device.h>
+#include <linux/led-class-flash.h>
+#include <linux/of.h>
+#include <linux/of_led_flash_manager.h>
+#include <linux/slab.h>
+
+static int __parse_strobe_gate_node(struct led_classdev_flash *flash,
+ struct device_node *node,
+ struct list_head *gates)
+{
+ struct device_node *mux_node, *subnode;
+ struct led_flash_strobe_gate *gate;
+ struct led_classdev *led_cdev = &flash->led_cdev;
+ u32 line_id;
+ int ret, num_gates = 0;
+
+ /* Get node mux node */
+ mux_node = of_parse_phandle(node, "mux", 0);
+ if (!mux_node)
+ return -EINVAL;
+
+ /* Get the value the mux has to be written to open the gate */
+ ret = of_property_read_u32(node, "mux-line-id", &line_id);
+ if (ret < 0)
+ return ret;
+
+ gate = kzalloc(sizeof(*gate), GFP_KERNEL);
+ if (!gate)
+ return -ENOMEM;
+
+ gate->mux_node = mux_node;
+ gate->line_id = line_id;
+ list_add_tail(&gate->list, gates);
+
+ /* Parse nested gate nodes */
+ for_each_available_child_of_node(node, subnode) {
+ if (!of_node_ncmp(subnode->name, "gate", 4)) {
+ ret = __parse_strobe_gate_node(flash, subnode, gates);
+ if (ret < 0) {
+ dev_dbg(led_cdev->dev->parent,
+ "Failed to parse gate node (%d)\n",
+ ret);
+ goto err_parse_gate;
+ }
+
+ if (++num_gates > 1) {
+ dev_dbg(led_cdev->dev->parent,
+ "Only one available child gate is allowed.\n");
+ ret = -EINVAL;
+ goto err_parse_gate;
+ }
+ }
+ }
+
+ return 0;
+
+err_parse_gate:
+ kfree(gate);
+
+ return ret;
+}
+
+static int __parse_strobe_provider_node(struct led_classdev_flash *flash,
+ struct device_node *node)
+{
+ struct device_node *provider_node;
+ struct led_flash_strobe_provider *provider;
+ int ret;
+
+ /* Create strobe provider representation */
+ provider = kzalloc(sizeof(*provider), GFP_KERNEL);
+ if (!provider)
+ return -ENOMEM;
+
+ /* Get phandle of the device generating strobe source signal */
+ provider_node = of_parse_phandle(node, "strobe-provider", 0);
+
+ /* provider property may be absent */
+ if (provider_node) {
+ /* Use compatible property as a strobe provider name */
+ ret = of_property_read_string(provider_node, "compatible",
+ (const char **) &provider->name);
+ if (ret < 0)
+ goto err_read_name;
+ }
+
+ INIT_LIST_HEAD(&provider->strobe_gates);
+
+ list_add_tail(&provider->list, &flash->strobe_providers);
+
+ ret = __parse_strobe_gate_node(flash, node, &provider->strobe_gates);
+ if (ret < 0)
+ goto err_read_name;
+
+ return 0;
+
+err_read_name:
+ kfree(provider);
+
+ return ret;
+}
+
+int of_led_flash_manager_parse_dt(struct led_classdev_flash *flash,
+ struct device_node *node)
+{
+ struct device_node *subnode;
+ int ret;
+
+ for_each_available_child_of_node(node, subnode) {
+ if (!of_node_cmp(subnode->name, "gate-software-strobe")) {
+ ret = __parse_strobe_gate_node(flash, subnode,
+ &flash->software_strobe_gates);
+ if (ret < 0)
+ return ret;
+ }
+ if (!of_node_ncmp(subnode->name, "gate-external-strobe", 20)) {
+ ret = __parse_strobe_provider_node(flash, subnode);
+ if (ret < 0)
+ return ret;
+ }
+ }
+
+ return 0;
+}
+EXPORT_SYMBOL_GPL(of_led_flash_manager_parse_dt);
+
+void of_led_flash_manager_release_dt_data(struct led_classdev_flash *flash)
+{
+ struct list_head *gate_list;
+ struct led_flash_strobe_gate *gate, *gn;
+ struct led_flash_strobe_provider *provider, *sn;
+
+ gate_list = &flash->software_strobe_gates;
+ list_for_each_entry_safe(gate, gn, gate_list, list)
+ kfree(gate);
+
+ list_for_each_entry_safe(provider, sn, &flash->strobe_providers, list) {
+ list_for_each_entry_safe(gate, gn, &provider->strobe_gates,
+ list)
+ kfree(gate);
+ kfree(provider);
+ }
+}
+EXPORT_SYMBOL_GPL(of_led_flash_manager_release_dt_data);
new file mode 100644
@@ -0,0 +1,68 @@
+/*
+ * LED Flash Class gpio mux
+ *
+ * Copyright (C) 2014 Samsung Electronics Co., Ltd
+ * Author: Jacek Anaszewski <j.anaszewski@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation."
+ */
+
+#ifndef _LED_FLASH_GPIO_MUX_H
+#define _LED_FLASH_GPIO_MUX_H
+
+struct device_node;
+
+struct list_head;
+
+/**
+ * struct led_flash_gpio_mux_selector - element of gpio mux selectors list
+ * @list: links mux selectors
+ * @gpio: mux selector gpio
+ */
+struct led_flash_gpio_mux_selector {
+ struct list_head list;
+ int gpio;
+};
+
+/**
+ * struct led_flash_gpio_mux - gpio mux
+ * @selectors: mux selectors
+ */
+struct led_flash_gpio_mux {
+ struct list_head selectors;
+};
+
+/**
+ * led_flash_gpio_mux_create - create gpio mux
+ * @new_mux: created mux
+ * @mux_node: device tree node with gpio definitions
+ *
+ * Create V4L2 subdev wrapping given LED subsystem device.
+ *
+ * Returns: 0 on success or negative error value on failure
+ */
+int led_flash_gpio_mux_create(struct led_flash_gpio_mux **new_mux,
+ struct device_node *mux_node);
+
+/**
+ * led_flash_gpio_mux_release - release gpio mux
+ * @gpio_mux: mux to be released
+ *
+ * Create V4L2 subdev wrapping given LED subsystem device.
+ */
+void led_flash_gpio_mux_release(void *gpio_mux);
+
+/**
+ * led_flash_gpio_mux_select_line - select mux line
+ * @line_id: id of the line to be selected
+ * @mux: mux to be set
+ *
+ * Create V4L2 subdev wrapping given LED subsystem device.
+ *
+ * Returns: 0 on success or negative error value on failure
+ */
+int led_flash_gpio_mux_select_line(u32 line_id, void *mux);
+
+#endif /* _LED_FLASH_GPIO_MUX_H */
new file mode 100644
@@ -0,0 +1,146 @@
+/*
+ * LED Flash Manager for maintaining LED Flash Class devices
+ * along with their corresponding muxes that faciliate dynamic
+ * reconfiguration of the strobe signal source.
+ *
+ * Copyright (C) 2014 Samsung Electronics Co., Ltd
+ * Author: Jacek Anaszewski <j.anaszewski@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation."
+ */
+
+#ifndef _LED_FLASH_MANAGER_H
+#define _LED_FLASH_MANAGER_H
+
+#include <linux/types.h>
+
+struct list_head;
+
+struct led_flash_mux_ops {
+ /* select mux line */
+ int (*select_line)(u32 line_id, void *mux);
+ /*
+ * release private mux data - it is intended for gpio muxes
+ * only and mustn't be initialized by asynchronous muxes.
+ */
+ void (*release_private_data)(void *mux);
+};
+
+/**
+ * struct led_flash_mux_ref - flash mux reference
+ * @list: links flashes pointing to a mux
+ * @flash: flash holding a mux reference
+ */
+struct led_flash_mux_ref {
+ struct list_head list;
+ struct led_classdev_flash *flash;
+};
+
+/**
+ * struct led_flash_mux - flash mux used for routing strobe signal
+ * @list: list of muxes declared by registered flashes
+ * @node: mux Device Tree node
+ * @private_data: mux internal data
+ * @ops: ops facilitating mux state manipulation
+ * @refs: list of flashes using the mux
+ * @owner: module owning an async mux driver
+ */
+struct led_flash_mux {
+ struct list_head list;
+ struct device_node *node;
+ void *private_data;
+ struct led_flash_mux_ops *ops;
+ struct list_head refs;
+ struct module *owner;
+};
+
+#ifdef CONFIG_LEDS_FLASH_MANAGER
+
+/**
+ * led_flash_manager_set_external_strobe - setup strobe signal routing
+ * @flash: the flash LED to set
+ * @external: true - setup external strobe,
+ * false - setup software strobe
+ *
+ * Configure muxes to route either software or external
+ * strobe signal to the flash LED device.
+ *
+ * Returns: 0 on success or negative error value on failure.
+ */
+int led_flash_manager_set_external_strobe(
+ struct led_classdev_flash *flash,
+ bool external);
+
+/**
+ * led_flash_manager_bind_async_mux - bind asynchronous mulitplexer
+ * @async_mux: mux registration data
+ *
+ * Notify the flash manager that an asychronous mux has been probed.
+ *
+ * Returns: 0 on success or negative error value on failure.
+ */
+int led_flash_manager_bind_async_mux(struct led_flash_mux *async_mux);
+
+/**
+ * led_flash_manager_unbind_async_mux - unbind asynchronous mulitplexer
+ * @mux_node: device node of the mux to be unbound
+ *
+ * Notify the flash manager that an asychronous mux has been removed.
+ *
+ * Returns: 0 on success or negative error value on failure.
+ */
+int led_flash_manager_unbind_async_mux(struct device_node *mux_node);
+
+/**
+ * led_flash_manager_register_flash - register LED Flash Class device
+ in the flash manager
+ * @flash: the flash LED to register
+ * @node: Device Tree node - it is expected to contain information
+ * about strobe signal topology
+ *
+ * Register LED Flash Class device and retrieve information
+ * about topology of the strobe signals available for the device.
+ *
+ * Returns: 0 on success or negative error value on failure.
+ */
+int led_flash_manager_register_flash(struct led_classdev_flash *flash,
+ struct device_node *node);
+
+/**
+ * led_flash_manager_unregister_flash - unregister LED Flash Class device
+ * from the flash manager
+ * @flash: the flash LED to unregister
+ *
+ * Unregister LED Flash Class device from the flash manager.
+ */
+void led_flash_manager_unregister_flash(struct led_classdev_flash *flash);
+#else
+static inline int led_flash_manager_set_external_strobe(
+ struct led_classdev_flash *flash,
+ bool external)
+{
+ return 0;
+}
+static inline int led_flash_manager_bind_async_mux(
+ struct led_flash_mux *async_mux)
+{
+ return 0;
+}
+static inline int led_flash_manager_unbind_async_mux(
+ struct device_node *mux_node)
+{
+ return 0;
+}
+static inline int led_flash_manager_register_flash(
+ struct led_classdev_flash *flash,
+ struct device_node *node)
+{
+ return 0;
+}
+static inline void led_flash_manager_unregister_flash(
+ struct led_classdev_flash *flash) { }
+#endif /* CONFIG_LEDS_FLASH_MANAGER */
+
+#endif /* _LED_FLASH_MANAGER_H */
@@ -46,6 +46,7 @@ struct led_classdev {
#define LED_DEV_CAP_TORCH (1 << 21)
#define LED_DEV_CAP_FLASH (1 << 22)
#define LED_DEV_CAP_INDICATOR (1 << 23)
+#define LED_DEV_CAP_FL_MANAGER (1 << 24)
/* Set LED brightness level */
/* Must not sleep, use a workqueue if needed */
new file mode 100644
@@ -0,0 +1,80 @@
+/*
+ * LED flash manager of helpers.
+ *
+ * Copyright (C) 2014 Samsung Electronics Co., Ltd
+ * Author: Jacek Anaszewski <j.anaszewski@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation."
+ */
+
+#ifndef _OF_LED_FLASH_MANAGER_H
+#define _OF_LED_FLASH_MANAGER_H
+
+#include <linux/sysfs.h>
+#include <linux/device.h>
+
+struct led_classdev_flash;
+struct device_node;
+struct list_head;
+
+#define MAX_ATTR_NAME 18 /* allows for strobe providers ids up to 999 */
+
+/**
+ * struct led_flash_strobe_gate - strobe signal gate
+ * @list: links gates
+ * @mux_node: gate's parent mux
+ * @line_id: id of a mux line that the gate represents
+ */
+struct led_flash_strobe_gate {
+ struct list_head list;
+ struct device_node *mux_node;
+ u32 line_id;
+};
+
+/**
+ * struct led_flash_strobe_provider - external strobe signal provider that
+ may be associated with the flash device
+ * @list: links strobe providers
+ * @strobe_gates: list of gates that route strobe signal
+ from the strobe provider to the flash device
+ * @node: device node of the strobe provider device
+ */
+struct led_flash_strobe_provider {
+ struct list_head list;
+ struct list_head strobe_gates;
+ const char *name;
+ struct device_attribute attr;
+ char attr_name[MAX_ATTR_NAME];
+ bool attr_registered;
+};
+
+/**
+ * of_led_flash_manager_parse_dt - parse flash manager data of
+ * a LED Flash Class device DT node
+ *
+ * @flash: the LED Flash Class device to store the parsed data in
+ * @node: device node to parse
+ *
+ * Parse the multiplexers' settings that need to be applied for
+ * opening a route to all the flash strobe signals available for
+ * the device.
+ *
+ * Returns: 0 on success or negative error value on failure
+ */
+int of_led_flash_manager_parse_dt(struct led_classdev_flash *flash,
+ struct device_node *node);
+
+
+/**
+ * of_led_flash_manager_release_dt_data - release parsed DT data
+ *
+ * @flash: the LED Flash Class device to release data from
+ *
+ * Release data structures containing information about strobe
+ * source routes available for the device.
+ */
+void of_led_flash_manager_release_dt_data(struct led_classdev_flash *flash);
+
+#endif /* _OF_LED_FLASH_MANAGER_H */