Input: sparse-keymap - use a managed allocation for keymap copy

 * @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

 *	depending on device's needs, 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().

 * The allocated copy of the keymap is automatically freed when it

 * is no longer needed.

 */

int sparse_keymap_setup(struct input_dev *dev,

			const struct key_entry *keymap,

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

		map_size++;

	map = kcalloc(map_size, sizeof(struct key_entry), GFP_KERNEL);

	map = devm_kmemdup(&dev->dev, keymap, map_size * sizeof(*map),

			   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;

				return error;

		}

		switch (entry->type) {

	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

 * This function 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).

 * Since sparse_keymap_setup() now uses a managed allocation for the

 * keymap copy, use of this function is deprecated.

 */

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);