/*
 * Generic support for sparse keymaps
 *
 * Copyright (c) 2009 Dmitry Torokhov
 *
 * Derived from wistron button driver:
 * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
 * Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
 * Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
 *
 * 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/input.h>
#include <linux/input/sparse-keymap.h>
#include <linux/module.h>
#include <linux/slab.h>

MODULE_AUTHOR("Dmitry Torokhov <dtor@mail.ru>");
MODULE_DESCRIPTION("Generic support for sparse keymaps");
MODULE_LICENSE("GPL v2");
MODULE_VERSION("0.1");

static unsigned int sparse_keymap_get_key_index(struct input_dev *dev,
                                                const struct key_entry *k)
{
        struct key_entry *key;
        unsigned int idx = 0;

        for (key = dev->keycode; key->type != KE_END; key++) {
                if (key->type == KE_KEY) {
                        if (key == k)
                                break;
                        idx++;
                }
        }

        return idx;
}

static struct key_entry *sparse_keymap_entry_by_index(struct input_dev *dev,
                                                      unsigned int index)
{
        struct key_entry *key;
        unsigned int key_cnt = 0;

        for (key = dev->keycode; key->type != KE_END; key++)
                if (key->type == KE_KEY)
                        if (key_cnt++ == index)
                                return key;

        return NULL;
}

/**
 * sparse_keymap_entry_from_scancode - perform sparse keymap lookup
 * @dev: Input device using sparse keymap
 * @code: Scan code
 *
 * This function is used to perform &struct key_entry lookup in an
 * input device using sparse keymap.
 */
struct key_entry *sparse_keymap_entry_from_scancode(struct input_dev *dev,
                                                    unsigned int code)
{
        struct key_entry *key;

        for (key = dev->keycode; key->type != KE_END; key++)
                if (code == key->code)
                        return key;

        return NULL;
}
EXPORT_SYMBOL(sparse_keymap_entry_from_scancode);

/**
 * sparse_keymap_entry_from_keycode - perform sparse keymap lookup
 * @dev: Input device using sparse keymap
 * @keycode: Key code
 *
 * This function is used to perform &struct key_entry lookup in an
 * input device using sparse keymap.
 */
struct key_entry *sparse_keymap_entry_from_keycode(struct input_dev *dev,
                                                   unsigned int keycode)
{
        struct key_entry *key;

        for (key = dev->keycode; key->type != KE_END; key++)
                if (key->type == KE_KEY && keycode == key->keycode)
                        return key;

        return NULL;
}
EXPORT_SYMBOL(sparse_keymap_entry_from_keycode);

static struct key_entry *sparse_keymap_locate(struct input_dev *dev,
                                        const struct input_keymap_entry *ke)
{
        struct key_entry *key;
        unsigned int scancode;

        if (ke->flags & INPUT_KEYMAP_BY_INDEX)
                key = sparse_keymap_entry_by_index(dev, ke->index);
        else if (input_scancode_to_scalar(ke, &scancode) == 0)
                key = sparse_keymap_entry_from_scancode(dev, scancode);
        else
                key = NULL;

        return key;
}

static int sparse_keymap_getkeycode(struct input_dev *dev,
                                    struct input_keymap_entry *ke)
{
        const struct key_entry *key;

        if (dev->keycode) {
                key = sparse_keymap_locate(dev, ke);
                if (key && key->type == KE_KEY) {
                        ke->keycode = key->keycode;
                        if (!(ke->flags & INPUT_KEYMAP_BY_INDEX))
                                ke->index =
                                        sparse_keymap_get_key_index(dev, key);
                        ke->len = sizeof(key->code);
                        memcpy(ke->scancode, &key->code, sizeof(key->code));
                        return 0;
                }
        }

        return -EINVAL;
}

static int sparse_keymap_setkeycode(struct input_dev *dev,
                                    const struct input_keymap_entry *ke,
                                    unsigned int *old_keycode)
{
        struct key_entry *key;

        if (dev->keycode) {
                key = sparse_keymap_locate(dev, ke);
                if (key && key->type == KE_KEY) {
                        *old_keycode = key->keycode;
                        key->keycode = ke->keycode;
                        set_bit(ke->keycode, dev->keybit);
                        if (!sparse_keymap_entry_from_keycode(dev, *old_keycode))
                                clear_bit(*old_keycode, dev->keybit);
                        return 0;
                }
        }

        return -EINVAL;
}

/**
 * sparse_keymap_setup - set up sparse keymap for an input device
 * @dev: Input device
 * @keymap: Keymap in form of array of &key_entry structures ending
 *      with %KE_END type entry
 * @setup: Function that can be used to adjust keymap entries
 *      depending on device's deeds, may be %NULL
 *
 * The function calculates size and allocates copy of the original
 * keymap after which sets up input device event bits appropriately.
 * Before destroying input device allocated keymap should be freed
 * with a call to sparse_keymap_free().
 */
int sparse_keymap_setup(struct input_dev *dev,
                        const struct key_entry *keymap,
                        int (*setup)(struct input_dev *, struct key_entry *))
{
        size_t map_size = 1; /* to account for the last KE_END entry */
        const struct key_entry *e;
        struct key_entry *map, *entry;
        int i;
        int error;

        for (e = keymap; e->type != KE_END; e++)
                map_size++;

        map = kcalloc(map_size, sizeof(struct key_entry), GFP_KERNEL);
        if (!map)
                return -ENOMEM;

        memcpy(map, keymap, map_size * sizeof(struct key_entry));

        for (i = 0; i < map_size; i++) {
                entry = &map[i];

                if (setup) {
                        error = setup(dev, entry);
                        if (error)
                                goto err_out;
                }

                switch (entry->type) {
                case KE_KEY:
                        __set_bit(EV_KEY, dev->evbit);
                        __set_bit(entry->keycode, dev->keybit);
                        break;

                case KE_SW:
                case KE_VSW:
                        __set_bit(EV_SW, dev->evbit);
                        __set_bit(entry->sw.code, dev->swbit);
                        break;
                }
        }

        if (test_bit(EV_KEY, dev->evbit)) {
                __set_bit(KEY_UNKNOWN, dev->keybit);
                __set_bit(EV_MSC, dev->evbit);
                __set_bit(MSC_SCAN, dev->mscbit);
        }

        dev->keycode = map;
        dev->keycodemax = map_size;
        dev->getkeycode = sparse_keymap_getkeycode;
        dev->setkeycode = sparse_keymap_setkeycode;

        return 0;

 err_out:
        kfree(map);
        return error;
}
EXPORT_SYMBOL(sparse_keymap_setup);

/**
 * sparse_keymap_free - free memory allocated for sparse keymap
 * @dev: Input device using sparse keymap
 *
 * This function is used to free memory allocated by sparse keymap
 * in an input device that was set up by sparse_keymap_setup().
 * NOTE: It is safe to cal this function while input device is
 * still registered (however the drivers should care not to try to
 * use freed keymap and thus have to shut off interrupts/polling
 * before freeing the keymap).
 */
void sparse_keymap_free(struct input_dev *dev)
{
        unsigned long flags;

        /*
         * Take event lock to prevent racing with input_get_keycode()
         * and input_set_keycode() if we are called while input device
         * is still registered.
         */
        spin_lock_irqsave(&dev->event_lock, flags);

        kfree(dev->keycode);
        dev->keycode = NULL;
        dev->keycodemax = 0;

        spin_unlock_irqrestore(&dev->event_lock, flags);
}
EXPORT_SYMBOL(sparse_keymap_free);

/**
 * sparse_keymap_report_entry - report event corresponding to given key entry
 * @dev: Input device for which event should be reported
 * @ke: key entry describing event
 * @value: Value that should be reported (ignored by %KE_SW entries)
 * @autorelease: Signals whether release event should be emitted for %KE_KEY
 *      entries right after reporting press event, ignored by all other
 *      entries
 *
 * This function is used to report input event described by given
 * &struct key_entry.
 */
void sparse_keymap_report_entry(struct input_dev *dev, const struct key_entry *ke,
                                unsigned int value, bool autorelease)
{
        switch (ke->type) {
        case KE_KEY:
                input_event(dev, EV_MSC, MSC_SCAN, ke->code);
                input_report_key(dev, ke->keycode, value);
                input_sync(dev);
                if (value && autorelease) {
                        input_report_key(dev, ke->keycode, 0);
                        input_sync(dev);
                }
                break;

        case KE_SW:
                value = ke->sw.value;
                /* fall through */

        case KE_VSW:
                input_report_switch(dev, ke->sw.code, value);
                break;
        }
}
EXPORT_SYMBOL(sparse_keymap_report_entry);

/**
 * sparse_keymap_report_event - report event corresponding to given scancode
 * @dev: Input device using sparse keymap
 * @code: Scan code
 * @value: Value that should be reported (ignored by %KE_SW entries)
 * @autorelease: Signals whether release event should be emitted for %KE_KEY
 *      entries right after reporting press event, ignored by all other
 *      entries
 *
 * This function is used to perform lookup in an input device using sparse
 * keymap and report corresponding event. Returns %true if lookup was
 * successful and %false otherwise.
 */
bool sparse_keymap_report_event(struct input_dev *dev, unsigned int code,
                                unsigned int value, bool autorelease)
{
        const struct key_entry *ke =
                sparse_keymap_entry_from_scancode(dev, code);
        struct key_entry unknown_ke;

        if (ke) {
                sparse_keymap_report_entry(dev, ke, value, autorelease);
                return true;
        }

        /* Report an unknown key event as a debugging aid */
        unknown_ke.type = KE_KEY;
        unknown_ke.code = code;
        unknown_ke.keycode = KEY_UNKNOWN;
        sparse_keymap_report_entry(dev, &unknown_ke, value, true);

        return false;
}
EXPORT_SYMBOL(sparse_keymap_report_event);