/*
   * 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 interrups/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);