/*
 * PowerNV LED Driver
 *
 * Copyright IBM Corp. 2015
 *
 * Author: Vasant Hegde <hegdevasant@linux.vnet.ibm.com>
 * Author: Anshuman Khandual <khandual@linux.vnet.ibm.com>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 */

#include <linux/leds.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/types.h>

#include <asm/opal.h>

/* Map LED type to description. */
struct led_type_map {
        const int       type;
        const char      *desc;
};
static const struct led_type_map led_type_map[] = {
        {OPAL_SLOT_LED_TYPE_ID,         "identify"},
        {OPAL_SLOT_LED_TYPE_FAULT,      "fault"},
        {OPAL_SLOT_LED_TYPE_ATTN,       "attention"},
        {-1,                            NULL},
};

struct powernv_led_common {
        /*
         * By default unload path resets all the LEDs. But on PowerNV
         * platform we want to retain LED state across reboot as these
         * are controlled by firmware. Also service processor can modify
         * the LEDs independent of OS. Hence avoid resetting LEDs in
         * unload path.
         */
        bool            led_disabled;

        /* Max supported LED type */
        __be64          max_led_type;

        /* glabal lock */
        struct mutex    lock;
};

/* PowerNV LED data */
struct powernv_led_data {
        struct led_classdev     cdev;
        char                    *loc_code;      /* LED location code */
        int                     led_type;       /* OPAL_SLOT_LED_TYPE_* */

        struct powernv_led_common *common;
};


/* Returns OPAL_SLOT_LED_TYPE_* for given led type string */
static int powernv_get_led_type(const char *led_type_desc)
{
        int i;

        for (i = 0; i < ARRAY_SIZE(led_type_map); i++)
                if (!strcmp(led_type_map[i].desc, led_type_desc))
                        return led_type_map[i].type;

        return -1;
}

/*
 * This commits the state change of the requested LED through an OPAL call.
 * This function is called from work queue task context when ever it gets
 * scheduled. This function can sleep at opal_async_wait_response call.
 */
static int powernv_led_set(struct powernv_led_data *powernv_led,
                            enum led_brightness value)
{
        int rc, token;
        u64 led_mask, led_value = 0;
        __be64 max_type;
        struct opal_msg msg;
        struct device *dev = powernv_led->cdev.dev;
        struct powernv_led_common *powernv_led_common = powernv_led->common;

        /* Prepare for the OPAL call */
        max_type = powernv_led_common->max_led_type;
        led_mask = OPAL_SLOT_LED_STATE_ON << powernv_led->led_type;
        if (value)
                led_value = led_mask;

        /* OPAL async call */
        token = opal_async_get_token_interruptible();
        if (token < 0) {
                if (token != -ERESTARTSYS)
                        dev_err(dev, "%s: Couldn't get OPAL async token\n",
                                __func__);
                return token;
        }

        rc = opal_leds_set_ind(token, powernv_led->loc_code,
                               led_mask, led_value, &max_type);
        if (rc != OPAL_ASYNC_COMPLETION) {
                dev_err(dev, "%s: OPAL set LED call failed for %s [rc=%d]\n",
                        __func__, powernv_led->loc_code, rc);
                goto out_token;
        }

        rc = opal_async_wait_response(token, &msg);
        if (rc) {
                dev_err(dev,
                        "%s: Failed to wait for the async response [rc=%d]\n",
                        __func__, rc);
                goto out_token;
        }

        rc = opal_get_async_rc(msg);
        if (rc != OPAL_SUCCESS)
                dev_err(dev, "%s : OAPL async call returned failed [rc=%d]\n",
                        __func__, rc);

out_token:
        opal_async_release_token(token);
        return rc;
}

/*
 * This function fetches the LED state for a given LED type for
 * mentioned LED classdev structure.
 */
static enum led_brightness powernv_led_get(struct powernv_led_data *powernv_led)
{
        int rc;
        __be64 mask, value, max_type;
        u64 led_mask, led_value;
        struct device *dev = powernv_led->cdev.dev;
        struct powernv_led_common *powernv_led_common = powernv_led->common;

        /* Fetch all LED status */
        mask = cpu_to_be64(0);
        value = cpu_to_be64(0);
        max_type = powernv_led_common->max_led_type;

        rc = opal_leds_get_ind(powernv_led->loc_code,
                               &mask, &value, &max_type);
        if (rc != OPAL_SUCCESS && rc != OPAL_PARTIAL) {
                dev_err(dev, "%s: OPAL get led call failed [rc=%d]\n",
                        __func__, rc);
                return LED_OFF;
        }

        led_mask = be64_to_cpu(mask);
        led_value = be64_to_cpu(value);

        /* LED status available */
        if (!((led_mask >> powernv_led->led_type) & OPAL_SLOT_LED_STATE_ON)) {
                dev_err(dev, "%s: LED status not available for %s\n",
                        __func__, powernv_led->cdev.name);
                return LED_OFF;
        }

        /* LED status value */
        if ((led_value >> powernv_led->led_type) & OPAL_SLOT_LED_STATE_ON)
                return LED_FULL;

        return LED_OFF;
}

/*
 * LED classdev 'brightness_get' function. This schedules work
 * to update LED state.
 */
static int powernv_brightness_set(struct led_classdev *led_cdev,
                                   enum led_brightness value)
{
        struct powernv_led_data *powernv_led =
                container_of(led_cdev, struct powernv_led_data, cdev);
        struct powernv_led_common *powernv_led_common = powernv_led->common;
        int rc;

        /* Do not modify LED in unload path */
        if (powernv_led_common->led_disabled)
                return 0;

        mutex_lock(&powernv_led_common->lock);
        rc = powernv_led_set(powernv_led, value);
        mutex_unlock(&powernv_led_common->lock);

        return rc;
}

/* LED classdev 'brightness_get' function */
static enum led_brightness powernv_brightness_get(struct led_classdev *led_cdev)
{
        struct powernv_led_data *powernv_led =
                container_of(led_cdev, struct powernv_led_data, cdev);

        return powernv_led_get(powernv_led);
}

/*
 * This function registers classdev structure for any given type of LED on
 * a given child LED device node.
 */
static int powernv_led_create(struct device *dev,
                              struct powernv_led_data *powernv_led,
                              const char *led_type_desc)
{
        int rc;

        /* Make sure LED type is supported */
        powernv_led->led_type = powernv_get_led_type(led_type_desc);
        if (powernv_led->led_type == -1) {
                dev_warn(dev, "%s: No support for led type : %s\n",
                         __func__, led_type_desc);
                return -EINVAL;
        }

        /* Create the name for classdev */
        powernv_led->cdev.name = devm_kasprintf(dev, GFP_KERNEL, "%s:%s",
                                                powernv_led->loc_code,
                                                led_type_desc);
        if (!powernv_led->cdev.name)
                return -ENOMEM;

        powernv_led->cdev.brightness_set_blocking = powernv_brightness_set;
        powernv_led->cdev.brightness_get = powernv_brightness_get;
        powernv_led->cdev.brightness = LED_OFF;
        powernv_led->cdev.max_brightness = LED_FULL;

        /* Register the classdev */
        rc = devm_led_classdev_register(dev, &powernv_led->cdev);
        if (rc) {
                dev_err(dev, "%s: Classdev registration failed for %s\n",
                        __func__, powernv_led->cdev.name);
        }

        return rc;
}

/* Go through LED device tree node and register LED classdev structure */
static int powernv_led_classdev(struct platform_device *pdev,
                                struct device_node *led_node,
                                struct powernv_led_common *powernv_led_common)
{
        const char *cur = NULL;
        int rc = -1;
        struct property *p;
        struct device_node *np;
        struct powernv_led_data *powernv_led;
        struct device *dev = &pdev->dev;

        for_each_child_of_node(led_node, np) {
                p = of_find_property(np, "led-types", NULL);

                while ((cur = of_prop_next_string(p, cur)) != NULL) {
                        powernv_led = devm_kzalloc(dev, sizeof(*powernv_led),
                                                   GFP_KERNEL);
                        if (!powernv_led) {
                                of_node_put(np);
                                return -ENOMEM;
                        }

                        powernv_led->common = powernv_led_common;
                        powernv_led->loc_code = (char *)np->name;

                        rc = powernv_led_create(dev, powernv_led, cur);
                        if (rc) {
                                of_node_put(np);
                                return rc;
                        }
                } /* while end */
        }

        return rc;
}

/* Platform driver probe */
static int powernv_led_probe(struct platform_device *pdev)
{
        struct device_node *led_node;
        struct powernv_led_common *powernv_led_common;
        struct device *dev = &pdev->dev;

        led_node = of_find_node_by_path("/ibm,opal/leds");
        if (!led_node) {
                dev_err(dev, "%s: LED parent device node not found\n",
                        __func__);
                return -EINVAL;
        }

        powernv_led_common = devm_kzalloc(dev, sizeof(*powernv_led_common),
                                          GFP_KERNEL);
        if (!powernv_led_common)
                return -ENOMEM;

        mutex_init(&powernv_led_common->lock);
        powernv_led_common->max_led_type = cpu_to_be64(OPAL_SLOT_LED_TYPE_MAX);

        platform_set_drvdata(pdev, powernv_led_common);

        return powernv_led_classdev(pdev, led_node, powernv_led_common);
}

/* Platform driver remove */
static int powernv_led_remove(struct platform_device *pdev)
{
        struct powernv_led_common *powernv_led_common;

        /* Disable LED operation */
        powernv_led_common = platform_get_drvdata(pdev);
        powernv_led_common->led_disabled = true;

        /* Destroy lock */
        mutex_destroy(&powernv_led_common->lock);

        dev_info(&pdev->dev, "PowerNV led module unregistered\n");
        return 0;
}

/* Platform driver property match */
static const struct of_device_id powernv_led_match[] = {
        {
                .compatible     = "ibm,opal-v3-led",
        },
        {},
};
MODULE_DEVICE_TABLE(of, powernv_led_match);

static struct platform_driver powernv_led_driver = {
        .probe  = powernv_led_probe,
        .remove = powernv_led_remove,
        .driver = {
                .name = "powernv-led-driver",
                .of_match_table = powernv_led_match,
        },
};

module_platform_driver(powernv_led_driver);

MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("PowerNV LED driver");
MODULE_AUTHOR("Vasant Hegde <hegdevasant@linux.vnet.ibm.com>");