/*
   * Core driver for the pin control subsystem
   *
   * Copyright (C) 2011 ST-Ericsson SA
   * Written on behalf of Linaro for ST-Ericsson
   * Based on bits of regulator core, gpio core and clk core
   *
   * Author: Linus Walleij <linus.walleij@linaro.org>
   *
   * License terms: GNU General Public License (GPL) version 2
   */
  #define pr_fmt(fmt) "pinctrl core: " fmt
  
  #include <linux/kernel.h>

  #include <linux/export.h>

  #include <linux/init.h>
  #include <linux/device.h>
  #include <linux/slab.h>
  #include <linux/radix-tree.h>
  #include <linux/err.h>
  #include <linux/list.h>
  #include <linux/mutex.h>
  #include <linux/spinlock.h>
  #include <linux/sysfs.h>
  #include <linux/debugfs.h>
  #include <linux/seq_file.h>
  #include <linux/pinctrl/pinctrl.h>
  #include <linux/pinctrl/machine.h>
  #include "core.h"
  #include "pinmux.h"

  #include "pinconf.h"

  
  /* Global list of pin control devices */
  static DEFINE_MUTEX(pinctrldev_list_mutex);
  static LIST_HEAD(pinctrldev_list);

  const char *pinctrl_dev_get_name(struct pinctrl_dev *pctldev)
  {
  	/* We're not allowed to register devices without name */
  	return pctldev->desc->name;
  }
  EXPORT_SYMBOL_GPL(pinctrl_dev_get_name);
  
  void *pinctrl_dev_get_drvdata(struct pinctrl_dev *pctldev)
  {
  	return pctldev->driver_data;
  }
  EXPORT_SYMBOL_GPL(pinctrl_dev_get_drvdata);
  
  /**
   * get_pinctrl_dev_from_dev() - look up pin controller device
   * @dev: a device pointer, this may be NULL but then devname needs to be
   *	defined instead
   * @devname: the name of a device instance, as returned by dev_name(), this
   *	may be NULL but then dev needs to be defined instead
   *
   * Looks up a pin control device matching a certain device name or pure device
   * pointer, the pure device pointer will take precedence.
   */
  struct pinctrl_dev *get_pinctrl_dev_from_dev(struct device *dev,
  					     const char *devname)
  {
  	struct pinctrl_dev *pctldev = NULL;
  	bool found = false;
  
  	mutex_lock(&pinctrldev_list_mutex);
  	list_for_each_entry(pctldev, &pinctrldev_list, node) {

  		if (dev && pctldev->dev == dev) {

  			/* Matched on device pointer */
  			found = true;
  			break;
  		}
  
  		if (devname &&

  		    !strcmp(dev_name(pctldev->dev), devname)) {

  			/* Matched on device name */
  			found = true;
  			break;
  		}
  	}
  	mutex_unlock(&pinctrldev_list_mutex);
  
  	return found ? pctldev : NULL;
  }

  struct pin_desc *pin_desc_get(struct pinctrl_dev *pctldev, unsigned int pin)

  {
  	struct pin_desc *pindesc;
  	unsigned long flags;
  
  	spin_lock_irqsave(&pctldev->pin_desc_tree_lock, flags);
  	pindesc = radix_tree_lookup(&pctldev->pin_desc_tree, pin);
  	spin_unlock_irqrestore(&pctldev->pin_desc_tree_lock, flags);
  
  	return pindesc;
  }
  
  /**

   * pin_get_from_name() - look up a pin number from a name
   * @pctldev: the pin control device to lookup the pin on
   * @name: the name of the pin to look up
   */
  int pin_get_from_name(struct pinctrl_dev *pctldev, const char *name)
  {

  	unsigned i, pin;

  	/* The pin number can be retrived from the pin controller descriptor */
  	for (i = 0; i < pctldev->desc->npins; i++) {

  		struct pin_desc *desc;

  		pin = pctldev->desc->pins[i].number;

  		desc = pin_desc_get(pctldev, pin);
  		/* Pin space may be sparse */
  		if (desc == NULL)
  			continue;
  		if (desc->name && !strcmp(name, desc->name))
  			return pin;
  	}
  
  	return -EINVAL;
  }
  
  /**

   * pin_is_valid() - check if pin exists on controller
   * @pctldev: the pin control device to check the pin on
   * @pin: pin to check, use the local pin controller index number
   *
   * This tells us whether a certain pin exist on a certain pin controller or
   * not. Pin lists may be sparse, so some pins may not exist.
   */
  bool pin_is_valid(struct pinctrl_dev *pctldev, int pin)
  {
  	struct pin_desc *pindesc;
  
  	if (pin < 0)
  		return false;
  
  	pindesc = pin_desc_get(pctldev, pin);
  	if (pindesc == NULL)
  		return false;
  
  	return true;
  }
  EXPORT_SYMBOL_GPL(pin_is_valid);
  
  /* Deletes a range of pin descriptors */
  static void pinctrl_free_pindescs(struct pinctrl_dev *pctldev,
  				  const struct pinctrl_pin_desc *pins,
  				  unsigned num_pins)
  {
  	int i;
  
  	spin_lock(&pctldev->pin_desc_tree_lock);
  	for (i = 0; i < num_pins; i++) {
  		struct pin_desc *pindesc;
  
  		pindesc = radix_tree_lookup(&pctldev->pin_desc_tree,
  					    pins[i].number);
  		if (pindesc != NULL) {
  			radix_tree_delete(&pctldev->pin_desc_tree,
  					  pins[i].number);

  			if (pindesc->dynamic_name)
  				kfree(pindesc->name);

  		}
  		kfree(pindesc);
  	}
  	spin_unlock(&pctldev->pin_desc_tree_lock);
  }
  
  static int pinctrl_register_one_pin(struct pinctrl_dev *pctldev,
  				    unsigned number, const char *name)
  {
  	struct pin_desc *pindesc;
  
  	pindesc = pin_desc_get(pctldev, number);
  	if (pindesc != NULL) {
  		pr_err("pin %d already registered on %s
  ", number,
  		       pctldev->desc->name);
  		return -EINVAL;
  	}
  
  	pindesc = kzalloc(sizeof(*pindesc), GFP_KERNEL);
  	if (pindesc == NULL)
  		return -ENOMEM;

  	spin_lock_init(&pindesc->lock);
  
  	/* Set owner */
  	pindesc->pctldev = pctldev;

  	/* Copy basic pin info */

  	if (pindesc->name) {
  		pindesc->name = name;
  	} else {
  		pindesc->name = kasprintf(GFP_KERNEL, "PIN%u", number);
  		if (pindesc->name == NULL)
  			return -ENOMEM;
  		pindesc->dynamic_name = true;
  	}

  
  	spin_lock(&pctldev->pin_desc_tree_lock);
  	radix_tree_insert(&pctldev->pin_desc_tree, number, pindesc);
  	spin_unlock(&pctldev->pin_desc_tree_lock);
  	pr_debug("registered pin %d (%s) on %s
  ",

  		 number, pindesc->name, pctldev->desc->name);

  	return 0;
  }
  
  static int pinctrl_register_pins(struct pinctrl_dev *pctldev,
  				 struct pinctrl_pin_desc const *pins,
  				 unsigned num_descs)
  {
  	unsigned i;
  	int ret = 0;
  
  	for (i = 0; i < num_descs; i++) {
  		ret = pinctrl_register_one_pin(pctldev,
  					       pins[i].number, pins[i].name);
  		if (ret)
  			return ret;
  	}
  
  	return 0;
  }
  
  /**
   * pinctrl_match_gpio_range() - check if a certain GPIO pin is in range
   * @pctldev: pin controller device to check
   * @gpio: gpio pin to check taken from the global GPIO pin space
   *
   * Tries to match a GPIO pin number to the ranges handled by a certain pin
   * controller, return the range or NULL
   */
  static struct pinctrl_gpio_range *
  pinctrl_match_gpio_range(struct pinctrl_dev *pctldev, unsigned gpio)
  {
  	struct pinctrl_gpio_range *range = NULL;
  
  	/* Loop over the ranges */
  	mutex_lock(&pctldev->gpio_ranges_lock);
  	list_for_each_entry(range, &pctldev->gpio_ranges, node) {
  		/* Check if we're in the valid range */
  		if (gpio >= range->base &&
  		    gpio < range->base + range->npins) {
  			mutex_unlock(&pctldev->gpio_ranges_lock);
  			return range;
  		}
  	}
  	mutex_unlock(&pctldev->gpio_ranges_lock);
  
  	return NULL;
  }
  
  /**
   * pinctrl_get_device_gpio_range() - find device for GPIO range
   * @gpio: the pin to locate the pin controller for
   * @outdev: the pin control device if found
   * @outrange: the GPIO range if found
   *
   * Find the pin controller handling a certain GPIO pin from the pinspace of
   * the GPIO subsystem, return the device and the matching GPIO range. Returns
   * negative if the GPIO range could not be found in any device.
   */
  int pinctrl_get_device_gpio_range(unsigned gpio,
  				struct pinctrl_dev **outdev,
  				struct pinctrl_gpio_range **outrange)
  {
  	struct pinctrl_dev *pctldev = NULL;
  
  	/* Loop over the pin controllers */
  	mutex_lock(&pinctrldev_list_mutex);
  	list_for_each_entry(pctldev, &pinctrldev_list, node) {
  		struct pinctrl_gpio_range *range;
  
  		range = pinctrl_match_gpio_range(pctldev, gpio);
  		if (range != NULL) {
  			*outdev = pctldev;
  			*outrange = range;
  			mutex_unlock(&pinctrldev_list_mutex);
  			return 0;
  		}
  	}
  	mutex_unlock(&pinctrldev_list_mutex);
  
  	return -EINVAL;
  }
  
  /**
   * pinctrl_add_gpio_range() - register a GPIO range for a controller
   * @pctldev: pin controller device to add the range to
   * @range: the GPIO range to add
   *
   * This adds a range of GPIOs to be handled by a certain pin controller. Call
   * this to register handled ranges after registering your pin controller.
   */
  void pinctrl_add_gpio_range(struct pinctrl_dev *pctldev,
  			    struct pinctrl_gpio_range *range)
  {
  	mutex_lock(&pctldev->gpio_ranges_lock);
  	list_add(&range->node, &pctldev->gpio_ranges);
  	mutex_unlock(&pctldev->gpio_ranges_lock);
  }
  
  /**
   * pinctrl_remove_gpio_range() - remove a range of GPIOs fro a pin controller
   * @pctldev: pin controller device to remove the range from
   * @range: the GPIO range to remove
   */
  void pinctrl_remove_gpio_range(struct pinctrl_dev *pctldev,
  			       struct pinctrl_gpio_range *range)
  {
  	mutex_lock(&pctldev->gpio_ranges_lock);
  	list_del(&range->node);
  	mutex_unlock(&pctldev->gpio_ranges_lock);
  }

  /**
   * pinctrl_get_group_selector() - returns the group selector for a group
   * @pctldev: the pin controller handling the group
   * @pin_group: the pin group to look up
   */
  int pinctrl_get_group_selector(struct pinctrl_dev *pctldev,
  			       const char *pin_group)
  {
  	const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
  	unsigned group_selector = 0;
  
  	while (pctlops->list_groups(pctldev, group_selector) >= 0) {
  		const char *gname = pctlops->get_group_name(pctldev,
  							    group_selector);
  		if (!strcmp(gname, pin_group)) {

  			dev_dbg(pctldev->dev,

  				"found group selector %u for %s
  ",
  				group_selector,
  				pin_group);
  			return group_selector;
  		}
  
  		group_selector++;
  	}

  	dev_err(pctldev->dev, "does not have pin group %s
  ",

  		pin_group);
  
  	return -EINVAL;
  }

  #ifdef CONFIG_DEBUG_FS
  
  static int pinctrl_pins_show(struct seq_file *s, void *what)
  {
  	struct pinctrl_dev *pctldev = s->private;
  	const struct pinctrl_ops *ops = pctldev->desc->pctlops;

  	unsigned i, pin;

  
  	seq_printf(s, "registered pins: %d
  ", pctldev->desc->npins);

  	/* The pin number can be retrived from the pin controller descriptor */
  	for (i = 0; i < pctldev->desc->npins; i++) {

  		struct pin_desc *desc;

  		pin = pctldev->desc->pins[i].number;

  		desc = pin_desc_get(pctldev, pin);
  		/* Pin space may be sparse */
  		if (desc == NULL)
  			continue;
  
  		seq_printf(s, "pin %d (%s) ", pin,
  			   desc->name ? desc->name : "unnamed");
  
  		/* Driver-specific info per pin */
  		if (ops->pin_dbg_show)
  			ops->pin_dbg_show(pctldev, s, pin);
  
  		seq_puts(s, "
  ");
  	}
  
  	return 0;
  }
  
  static int pinctrl_groups_show(struct seq_file *s, void *what)
  {
  	struct pinctrl_dev *pctldev = s->private;
  	const struct pinctrl_ops *ops = pctldev->desc->pctlops;
  	unsigned selector = 0;
  
  	/* No grouping */
  	if (!ops)
  		return 0;
  
  	seq_puts(s, "registered pin groups:
  ");
  	while (ops->list_groups(pctldev, selector) >= 0) {

  		const unsigned *pins;

  		unsigned num_pins;
  		const char *gname = ops->get_group_name(pctldev, selector);
  		int ret;
  		int i;
  
  		ret = ops->get_group_pins(pctldev, selector,
  					  &pins, &num_pins);
  		if (ret)
  			seq_printf(s, "%s [ERROR GETTING PINS]
  ",
  				   gname);
  		else {
  			seq_printf(s, "group: %s, pins = [ ", gname);
  			for (i = 0; i < num_pins; i++)
  				seq_printf(s, "%d ", pins[i]);
  			seq_puts(s, "]
  ");
  		}
  		selector++;
  	}
  
  
  	return 0;
  }
  
  static int pinctrl_gpioranges_show(struct seq_file *s, void *what)
  {
  	struct pinctrl_dev *pctldev = s->private;
  	struct pinctrl_gpio_range *range = NULL;
  
  	seq_puts(s, "GPIO ranges handled:
  ");
  
  	/* Loop over the ranges */
  	mutex_lock(&pctldev->gpio_ranges_lock);
  	list_for_each_entry(range, &pctldev->gpio_ranges, node) {

  		seq_printf(s, "%u: %s GPIOS [%u - %u] PINS [%u - %u]
  ",
  			   range->id, range->name,
  			   range->base, (range->base + range->npins - 1),
  			   range->pin_base,
  			   (range->pin_base + range->npins - 1));

  	}
  	mutex_unlock(&pctldev->gpio_ranges_lock);
  
  	return 0;
  }
  
  static int pinctrl_devices_show(struct seq_file *s, void *what)
  {
  	struct pinctrl_dev *pctldev;

  	seq_puts(s, "name [pinmux] [pinconf]
  ");

  	mutex_lock(&pinctrldev_list_mutex);
  	list_for_each_entry(pctldev, &pinctrldev_list, node) {
  		seq_printf(s, "%s ", pctldev->desc->name);
  		if (pctldev->desc->pmxops)

  			seq_puts(s, "yes ");
  		else
  			seq_puts(s, "no ");
  		if (pctldev->desc->confops)

  			seq_puts(s, "yes");
  		else
  			seq_puts(s, "no");
  		seq_puts(s, "
  ");
  	}
  	mutex_unlock(&pinctrldev_list_mutex);
  
  	return 0;
  }
  
  static int pinctrl_pins_open(struct inode *inode, struct file *file)
  {
  	return single_open(file, pinctrl_pins_show, inode->i_private);
  }
  
  static int pinctrl_groups_open(struct inode *inode, struct file *file)
  {
  	return single_open(file, pinctrl_groups_show, inode->i_private);
  }
  
  static int pinctrl_gpioranges_open(struct inode *inode, struct file *file)
  {
  	return single_open(file, pinctrl_gpioranges_show, inode->i_private);
  }
  
  static int pinctrl_devices_open(struct inode *inode, struct file *file)
  {
  	return single_open(file, pinctrl_devices_show, NULL);
  }
  
  static const struct file_operations pinctrl_pins_ops = {
  	.open		= pinctrl_pins_open,
  	.read		= seq_read,
  	.llseek		= seq_lseek,
  	.release	= single_release,
  };
  
  static const struct file_operations pinctrl_groups_ops = {
  	.open		= pinctrl_groups_open,
  	.read		= seq_read,
  	.llseek		= seq_lseek,
  	.release	= single_release,
  };
  
  static const struct file_operations pinctrl_gpioranges_ops = {
  	.open		= pinctrl_gpioranges_open,
  	.read		= seq_read,
  	.llseek		= seq_lseek,
  	.release	= single_release,
  };
  
  static const struct file_operations pinctrl_devices_ops = {
  	.open		= pinctrl_devices_open,
  	.read		= seq_read,
  	.llseek		= seq_lseek,
  	.release	= single_release,
  };
  
  static struct dentry *debugfs_root;
  
  static void pinctrl_init_device_debugfs(struct pinctrl_dev *pctldev)
  {
  	static struct dentry *device_root;

  	device_root = debugfs_create_dir(dev_name(pctldev->dev),

  					 debugfs_root);
  	if (IS_ERR(device_root) || !device_root) {
  		pr_warn("failed to create debugfs directory for %s
  ",

  			dev_name(pctldev->dev));

  		return;
  	}
  	debugfs_create_file("pins", S_IFREG | S_IRUGO,
  			    device_root, pctldev, &pinctrl_pins_ops);
  	debugfs_create_file("pingroups", S_IFREG | S_IRUGO,
  			    device_root, pctldev, &pinctrl_groups_ops);
  	debugfs_create_file("gpio-ranges", S_IFREG | S_IRUGO,
  			    device_root, pctldev, &pinctrl_gpioranges_ops);
  	pinmux_init_device_debugfs(device_root, pctldev);

  	pinconf_init_device_debugfs(device_root, pctldev);

  }
  
  static void pinctrl_init_debugfs(void)
  {
  	debugfs_root = debugfs_create_dir("pinctrl", NULL);
  	if (IS_ERR(debugfs_root) || !debugfs_root) {
  		pr_warn("failed to create debugfs directory
  ");
  		debugfs_root = NULL;
  		return;
  	}
  
  	debugfs_create_file("pinctrl-devices", S_IFREG | S_IRUGO,
  			    debugfs_root, NULL, &pinctrl_devices_ops);
  	pinmux_init_debugfs(debugfs_root);
  }
  
  #else /* CONFIG_DEBUG_FS */
  
  static void pinctrl_init_device_debugfs(struct pinctrl_dev *pctldev)
  {
  }
  
  static void pinctrl_init_debugfs(void)
  {
  }
  
  #endif
  
  /**
   * pinctrl_register() - register a pin controller device
   * @pctldesc: descriptor for this pin controller
   * @dev: parent device for this pin controller
   * @driver_data: private pin controller data for this pin controller
   */
  struct pinctrl_dev *pinctrl_register(struct pinctrl_desc *pctldesc,
  				    struct device *dev, void *driver_data)
  {

  	struct pinctrl_dev *pctldev;
  	int ret;
  
  	if (pctldesc == NULL)
  		return NULL;
  	if (pctldesc->name == NULL)
  		return NULL;
  
  	/* If we're implementing pinmuxing, check the ops for sanity */
  	if (pctldesc->pmxops) {
  		ret = pinmux_check_ops(pctldesc->pmxops);
  		if (ret) {
  			pr_err("%s pinmux ops lacks necessary functions
  ",
  			       pctldesc->name);
  			return NULL;
  		}
  	}

  	/* If we're implementing pinconfig, check the ops for sanity */
  	if (pctldesc->confops) {
  		ret = pinconf_check_ops(pctldesc->confops);
  		if (ret) {
  			pr_err("%s pin config ops lacks necessary functions
  ",
  			       pctldesc->name);
  			return NULL;
  		}
  	}

  	pctldev = kzalloc(sizeof(struct pinctrl_dev), GFP_KERNEL);
  	if (pctldev == NULL)
  		return NULL;
  
  	/* Initialize pin control device struct */
  	pctldev->owner = pctldesc->owner;
  	pctldev->desc = pctldesc;
  	pctldev->driver_data = driver_data;
  	INIT_RADIX_TREE(&pctldev->pin_desc_tree, GFP_KERNEL);
  	spin_lock_init(&pctldev->pin_desc_tree_lock);
  	INIT_LIST_HEAD(&pctldev->gpio_ranges);
  	mutex_init(&pctldev->gpio_ranges_lock);

  	pctldev->dev = dev;

  
  	/* Register all the pins */
  	pr_debug("try to register %d pins on %s...
  ",
  		 pctldesc->npins, pctldesc->name);
  	ret = pinctrl_register_pins(pctldev, pctldesc->pins, pctldesc->npins);
  	if (ret) {
  		pr_err("error during pin registration
  ");
  		pinctrl_free_pindescs(pctldev, pctldesc->pins,
  				      pctldesc->npins);

  		goto out_err;

  	}
  
  	pinctrl_init_device_debugfs(pctldev);
  	mutex_lock(&pinctrldev_list_mutex);
  	list_add(&pctldev->node, &pinctrldev_list);
  	mutex_unlock(&pinctrldev_list_mutex);
  	pinmux_hog_maps(pctldev);
  	return pctldev;

  out_err:
  	kfree(pctldev);

  	return NULL;
  }
  EXPORT_SYMBOL_GPL(pinctrl_register);
  
  /**
   * pinctrl_unregister() - unregister pinmux
   * @pctldev: pin controller to unregister
   *
   * Called by pinmux drivers to unregister a pinmux.
   */
  void pinctrl_unregister(struct pinctrl_dev *pctldev)
  {
  	if (pctldev == NULL)
  		return;
  
  	pinmux_unhog_maps(pctldev);
  	/* TODO: check that no pinmuxes are still active? */
  	mutex_lock(&pinctrldev_list_mutex);
  	list_del(&pctldev->node);
  	mutex_unlock(&pinctrldev_list_mutex);
  	/* Destroy descriptor tree */
  	pinctrl_free_pindescs(pctldev, pctldev->desc->pins,
  			      pctldev->desc->npins);

  	kfree(pctldev);

  }
  EXPORT_SYMBOL_GPL(pinctrl_unregister);
  
  static int __init pinctrl_init(void)
  {
  	pr_info("initialized pinctrl subsystem
  ");
  	pinctrl_init_debugfs();
  	return 0;
  }
  
  /* init early since many drivers really need to initialized pinmux early */
  core_initcall(pinctrl_init);