diff options
Diffstat (limited to 'drivers/pinctrl')
| -rw-r--r-- | drivers/pinctrl/core.c | 598 | ||||
| -rw-r--r-- | drivers/pinctrl/core.h | 30 | ||||
| -rw-r--r-- | drivers/pinctrl/pinmux.c | 711 | ||||
| -rw-r--r-- | drivers/pinctrl/pinmux.h | 67 |
4 files changed, 775 insertions, 631 deletions
diff --git a/drivers/pinctrl/core.c b/drivers/pinctrl/core.c index 75c6a6bb6c0a..ec32c545f07f 100644 --- a/drivers/pinctrl/core.c +++ b/drivers/pinctrl/core.c @@ -1,7 +1,7 @@ /* * Core driver for the pin control subsystem * - * Copyright (C) 2011 ST-Ericsson SA + * Copyright (C) 2011-2012 ST-Ericsson SA * Written on behalf of Linaro for ST-Ericsson * Based on bits of regulator core, gpio core and clk core * @@ -30,10 +30,30 @@ #include "pinmux.h" #include "pinconf.h" +/** + * struct pinctrl_hog - a list item to stash control hogs + * @node: pin control hog list node + * @map: map entry responsible for this hogging + * @pmx: the pin control hogged by this item + */ +struct pinctrl_hog { + struct list_head node; + struct pinctrl_map const *map; + struct pinctrl *p; +}; + /* Global list of pin control devices */ static DEFINE_MUTEX(pinctrldev_list_mutex); static LIST_HEAD(pinctrldev_list); +/* List of pin controller handles */ +static DEFINE_MUTEX(pinctrl_list_mutex); +static LIST_HEAD(pinctrl_list); + +/* Global pinctrl maps */ +static struct pinctrl_map *pinctrl_maps; +static unsigned pinctrl_maps_num; + const char *pinctrl_dev_get_name(struct pinctrl_dev *pctldev) { /* We're not allowed to register devices without name */ @@ -337,6 +357,476 @@ int pinctrl_get_group_selector(struct pinctrl_dev *pctldev, return -EINVAL; } +/** + * pinctrl_request_gpio() - request a single pin to be used in as GPIO + * @gpio: the GPIO pin number from the GPIO subsystem number space + * + * This function should *ONLY* be used from gpiolib-based GPIO drivers, + * as part of their gpio_request() semantics, platforms and individual drivers + * shall *NOT* request GPIO pins to be muxed in. + */ +int pinctrl_request_gpio(unsigned gpio) +{ + struct pinctrl_dev *pctldev; + struct pinctrl_gpio_range *range; + int ret; + int pin; + + ret = pinctrl_get_device_gpio_range(gpio, &pctldev, &range); + if (ret) + return -EINVAL; + + /* Convert to the pin controllers number space */ + pin = gpio - range->base + range->pin_base; + + return pinmux_request_gpio(pctldev, range, pin, gpio); +} +EXPORT_SYMBOL_GPL(pinctrl_request_gpio); + +/** + * pinctrl_free_gpio() - free control on a single pin, currently used as GPIO + * @gpio: the GPIO pin number from the GPIO subsystem number space + * + * This function should *ONLY* be used from gpiolib-based GPIO drivers, + * as part of their gpio_free() semantics, platforms and individual drivers + * shall *NOT* request GPIO pins to be muxed out. + */ +void pinctrl_free_gpio(unsigned gpio) +{ + struct pinctrl_dev *pctldev; + struct pinctrl_gpio_range *range; + int ret; + int pin; + + ret = pinctrl_get_device_gpio_range(gpio, &pctldev, &range); + if (ret) + return; + + /* Convert to the pin controllers number space */ + pin = gpio - range->base + range->pin_base; + + return pinmux_free_gpio(pctldev, pin, range); +} +EXPORT_SYMBOL_GPL(pinctrl_free_gpio); + +static int pinctrl_gpio_direction(unsigned gpio, bool input) +{ + struct pinctrl_dev *pctldev; + struct pinctrl_gpio_range *range; + int ret; + int pin; + + ret = pinctrl_get_device_gpio_range(gpio, &pctldev, &range); + if (ret) + return ret; + + /* Convert to the pin controllers number space */ + pin = gpio - range->base + range->pin_base; + + return pinmux_gpio_direction(pctldev, range, pin, input); +} + +/** + * pinctrl_gpio_direction_input() - request a GPIO pin to go into input mode + * @gpio: the GPIO pin number from the GPIO subsystem number space + * + * This function should *ONLY* be used from gpiolib-based GPIO drivers, + * as part of their gpio_direction_input() semantics, platforms and individual + * drivers shall *NOT* touch pin control GPIO calls. + */ +int pinctrl_gpio_direction_input(unsigned gpio) +{ + return pinctrl_gpio_direction(gpio, true); +} +EXPORT_SYMBOL_GPL(pinctrl_gpio_direction_input); + +/** + * pinctrl_gpio_direction_output() - request a GPIO pin to go into output mode + * @gpio: the GPIO pin number from the GPIO subsystem number space + * + * This function should *ONLY* be used from gpiolib-based GPIO drivers, + * as part of their gpio_direction_output() semantics, platforms and individual + * drivers shall *NOT* touch pin control GPIO calls. + */ +int pinctrl_gpio_direction_output(unsigned gpio) +{ + return pinctrl_gpio_direction(gpio, false); +} +EXPORT_SYMBOL_GPL(pinctrl_gpio_direction_output); + +/** + * pinctrl_get() - retrieves the pin controller handle for a certain device + * @dev: the device to get the pin controller handle for + * @name: an optional specific control mapping name or NULL, the name is only + * needed if you want to have more than one mapping per device, or if you + * need an anonymous pin control (not tied to any specific device) + */ +struct pinctrl *pinctrl_get(struct device *dev, const char *name) +{ + struct pinctrl_map const *map = NULL; + struct pinctrl_dev *pctldev = NULL; + const char *devname = NULL; + struct pinctrl *p; + bool found_map; + unsigned num_maps = 0; + int ret = -ENODEV; + int i; + + /* We must have dev or ID or both */ + if (!dev && !name) + return ERR_PTR(-EINVAL); + + if (dev) + devname = dev_name(dev); + + pr_debug("get pin control handle %s for device %s\n", name, + devname ? devname : "(none)"); + + /* + * create the state cookie holder struct pinctrl for each + * mapping, this is what consumers will get when requesting + * a pin control handle with pinctrl_get() + */ + p = kzalloc(sizeof(struct pinctrl), GFP_KERNEL); + if (p == NULL) + return ERR_PTR(-ENOMEM); + mutex_init(&p->mutex); + pinmux_init_pinctrl_handle(p); + + /* Iterate over the pin control maps to locate the right ones */ + for (i = 0; i < pinctrl_maps_num; i++) { + map = &pinctrl_maps[i]; + found_map = false; + + /* + * First, try to find the pctldev given in the map + */ + pctldev = get_pinctrl_dev_from_devname(map->ctrl_dev_name); + if (!pctldev) { + pr_warning("could not find a pinctrl device for pinmux function %s, fishy, they shall all have one\n", + map->function); + pr_warning("given pinctrl device name: %s", + map->ctrl_dev_name); + + /* Continue to check the other mappings anyway... */ + continue; + } + + pr_debug("in map, found pctldev %s to handle function %s", + dev_name(pctldev->dev), map->function); + + + /* + * If we're looking for a specific named map, this must match, + * else we loop and look for the next. + */ + if (name != NULL) { + if (map->name == NULL) + continue; + if (strcmp(map->name, name)) + continue; + } + + /* + * This is for the case where no device name is given, we + * already know that the function name matches from above + * code. + */ + if (!map->dev_name && (name != NULL)) + found_map = true; + + /* If the mapping has a device set up it must match */ + if (map->dev_name && + (!devname || !strcmp(map->dev_name, devname))) + /* MATCH! */ + found_map = true; + + /* If this map is applicable, then apply it */ + if (found_map) { + ret = pinmux_apply_muxmap(pctldev, p, dev, + devname, map); + if (ret) { + kfree(p); + return ERR_PTR(ret); + } + num_maps++; + } + } + + /* We should have atleast one map, right */ + if (!num_maps) { + pr_err("could not find any mux maps for device %s, ID %s\n", + devname ? devname : "(anonymous)", + name ? name : "(undefined)"); + kfree(p); + return ERR_PTR(-EINVAL); + } + + pr_debug("found %u mux maps for device %s, UD %s\n", + num_maps, + devname ? devname : "(anonymous)", + name ? name : "(undefined)"); + + /* Add the pinmux to the global list */ + mutex_lock(&pinctrl_list_mutex); + list_add(&p->node, &pinctrl_list); + mutex_unlock(&pinctrl_list_mutex); + + return p; +} +EXPORT_SYMBOL_GPL(pinctrl_get); + +/** + * pinctrl_put() - release a previously claimed pin control handle + * @p: a pin control handle previously claimed by pinctrl_get() + */ +void pinctrl_put(struct pinctrl *p) +{ + if (p == NULL) + return; + + mutex_lock(&p->mutex); + if (p->usecount) + pr_warn("releasing pin control handle with active users!\n"); + /* Free the groups and all acquired pins */ + pinmux_put(p); + mutex_unlock(&p->mutex); + + /* Remove from list */ + mutex_lock(&pinctrl_list_mutex); + list_del(&p->node); + mutex_unlock(&pinctrl_list_mutex); + + kfree(p); +} +EXPORT_SYMBOL_GPL(pinctrl_put); + +/** + * pinctrl_enable() - enable a certain pin controller setting + * @p: the pin control handle to enable, previously claimed by pinctrl_get() + */ +int pinctrl_enable(struct pinctrl *p) +{ + int ret = 0; + + if (p == NULL) + return -EINVAL; + mutex_lock(&p->mutex); + if (p->usecount++ == 0) { + ret = pinmux_enable(p); + if (ret) + p->usecount--; + } + mutex_unlock(&p->mutex); + return ret; +} +EXPORT_SYMBOL_GPL(pinctrl_enable); + +/** + * pinctrl_disable() - disable a certain pin control setting + * @p: the pin control handle to disable, previously claimed by pinctrl_get() + */ +void pinctrl_disable(struct pinctrl *p) +{ + if (p == NULL) + return; + + mutex_lock(&p->mutex); + if (--p->usecount == 0) { + pinmux_disable(p); + } + mutex_unlock(&p->mutex); +} +EXPORT_SYMBOL_GPL(pinctrl_disable); + +/** + * pinctrl_register_mappings() - register a set of pin controller mappings + * @maps: the pincontrol mappings table to register, this should be marked with + * __initdata so it can be discarded after boot, this function will + * perform a shallow copy for the mapping entries. + * @num_maps: the number of maps in the mapping table + * + * Only call this once during initialization of your machine, the function is + * tagged as __init and won't be callable after init has completed. The map + * passed into this function will be owned by the pinmux core and cannot be + * freed. + */ +int __init pinctrl_register_mappings(struct pinctrl_map const *maps, + unsigned num_maps) +{ + void *tmp_maps; + int i; + + pr_debug("add %d pinmux maps\n", num_maps); + + /* First sanity check the new mapping */ + for (i = 0; i < num_maps; i++) { + if (!maps[i].name) { + pr_err("failed to register map %d: no map name given\n", + i); + return -EINVAL; + } + + if (!maps[i].ctrl_dev_name) { + pr_err("failed to register map %s (%d): no pin control device given\n", + maps[i].name, i); + return -EINVAL; + } + + if (!maps[i].function) { + pr_err("failed to register map %s (%d): no function ID given\n", + maps[i].name, i); + return -EINVAL; + } + + if (!maps[i].dev_name) + pr_debug("add system map %s function %s with no device\n", + maps[i].name, + maps[i].function); + else + pr_debug("register map %s, function %s\n", + maps[i].name, + maps[i].function); + } + + /* + * Make a copy of the map array - string pointers will end up in the + * kernel const section anyway so these do not need to be deep copied. + */ + if (!pinctrl_maps_num) { + /* On first call, just copy them */ + tmp_maps = kmemdup(maps, + sizeof(struct pinctrl_map) * num_maps, + GFP_KERNEL); + if (!tmp_maps) + return -ENOMEM; + } else { + /* Subsequent calls, reallocate array to new size */ + size_t oldsize = sizeof(struct pinctrl_map) * pinctrl_maps_num; + size_t newsize = sizeof(struct pinctrl_map) * num_maps; + + tmp_maps = krealloc(pinctrl_maps, + oldsize + newsize, GFP_KERNEL); + if (!tmp_maps) + return -ENOMEM; + memcpy((tmp_maps + oldsize), maps, newsize); + } + + pinctrl_maps = tmp_maps; + pinctrl_maps_num += num_maps; + return 0; +} + +/* Hog a single map entry and add to the hoglist */ +static int pinctrl_hog_map(struct pinctrl_dev *pctldev, + struct pinctrl_map const *map) +{ + struct pinctrl_hog *hog; + struct pinctrl *p; + int ret; + + if (map->dev_name) { + /* + * TODO: the day we have device tree support, we can + * traverse the device tree and hog to specific device nodes + * without any problems, so then we can hog pinmuxes for + * all devices that just want a static pin mux at this point. + */ + dev_err(pctldev->dev, "map %s wants to hog a non-system pinmux, this is not going to work\n", + map->name); + return -EINVAL; + } + + hog = kzalloc(sizeof(struct pinctrl_hog), GFP_KERNEL); + if (!hog) + return -ENOMEM; + + p = pinctrl_get(NULL, map->name); + if (IS_ERR(p)) { + kfree(hog); + dev_err(pctldev->dev, + "could not get the %s pin control mapping for hogging\n", + map->name); + return PTR_ERR(p); + } + + ret = pinctrl_enable(p); + if (ret) { + pinctrl_put(p); + kfree(hog); + dev_err(pctldev->dev, + "could not enable the %s pin control mapping for hogging\n", + map->name); + return ret; + } + + hog->map = map; + hog->p = p; + + dev_info(pctldev->dev, "hogged map %s, function %s\n", map->name, + map->function); + mutex_lock(&pctldev->pinctrl_hogs_lock); + list_add(&hog->node, &pctldev->pinctrl_hogs); + mutex_unlock(&pctldev->pinctrl_hogs_lock); + + return 0; +} + +/** + * pinctrl_hog_maps() - hog specific map entries on controller device + * @pctldev: the pin control device to hog entries on + * + * When the pin controllers are registered, there may be some specific pinmux + * map entries that need to be hogged, i.e. get+enabled until the system shuts + * down. + */ +int pinctrl_hog_maps(struct pinctrl_dev *pctldev) +{ + struct device *dev = pctldev->dev; + const char *devname = dev_name(dev); + int ret; + int i; + + INIT_LIST_HEAD(&pctldev->pinctrl_hogs); + mutex_init(&pctldev->pinctrl_hogs_lock); + + for (i = 0; i < pinctrl_maps_num; i++) { + struct pinctrl_map const *map = &pinctrl_maps[i]; + + if (!map->hog_on_boot) + continue; + + if (map->ctrl_dev_name && + !strcmp(map->ctrl_dev_name, devname)) { + /* OK time to hog! */ + ret = pinctrl_hog_map(pctldev, map); + if (ret) + return ret; + } + } + return 0; +} + +/** + * pinctrl_unhog_maps() - unhog specific map entries on controller device + * @pctldev: the pin control device to unhog entries on + */ +void pinctrl_unhog_maps(struct pinctrl_dev *pctldev) +{ + struct list_head *node, *tmp; + + mutex_lock(&pctldev->pinctrl_hogs_lock); + list_for_each_safe(node, tmp, &pctldev->pinctrl_hogs) { + struct pinctrl_hog *hog = + list_entry(node, struct pinctrl_hog, node); + pinctrl_disable(hog->p); + pinctrl_put(hog->p); + list_del(node); + kfree(hog); + } + mutex_unlock(&pctldev->pinctrl_hogs_lock); +} + #ifdef CONFIG_DEBUG_FS static int pinctrl_pins_show(struct seq_file *s, void *what) @@ -427,6 +917,43 @@ static int pinctrl_gpioranges_show(struct seq_file *s, void *what) return 0; } +static int pinctrl_maps_show(struct seq_file *s, void *what) +{ + int i; + + seq_puts(s, "Pinctrl maps:\n"); + + for (i = 0; i < pinctrl_maps_num; i++) { + struct pinctrl_map const *map = &pinctrl_maps[i]; + + seq_printf(s, "%s:\n", map->name); + if (map->dev_name) + seq_printf(s, " device: %s\n", + map->dev_name); + else + seq_printf(s, " SYSTEM MUX\n"); + seq_printf(s, " controlling device %s\n", + map->ctrl_dev_name); + seq_printf(s, " function: %s\n", map->function); + seq_printf(s, " group: %s\n", map->group ? map->group : + "(default)"); + } + return 0; +} + +static int pinmux_hogs_show(struct seq_file *s, void *what) +{ + struct pinctrl_dev *pctldev = s->private; + struct pinctrl_hog *hog; + + seq_puts(s, "Pin control map hogs held by device\n"); + + list_for_each_entry(hog, &pctldev->pinctrl_hogs, node) + seq_printf(s, "%s\n", hog->map->name); + + return 0; +} + static int pinctrl_devices_show(struct seq_file *s, void *what) { struct pinctrl_dev *pctldev; @@ -450,6 +977,32 @@ static int pinctrl_devices_show(struct seq_file *s, void *what) return 0; } +static int pinctrl_show(struct seq_file *s, void *what) +{ + struct pinctrl *p; + + seq_puts(s, "Requested pin control handlers their pinmux maps:\n"); + list_for_each_entry(p, &pinctrl_list, node) { + struct pinctrl_dev *pctldev = p->pctldev; + + if (!pctldev) { + seq_puts(s, "NO PIN CONTROLLER DEVICE\n"); + continue; + } + + seq_printf(s, "device: %s", + pinctrl_dev_get_name(p->pctldev)); + + pinmux_dbg_show(s, p); + + seq_printf(s, " users: %u map-> %s\n", + p->usecount, + p->dev ? dev_name(p->dev) : "(system)"); + } + + return 0; +} + static int pinctrl_pins_open(struct inode *inode, struct file *file) { return single_open(file, pinctrl_pins_show, inode->i_private); @@ -465,11 +1018,26 @@ static int pinctrl_gpioranges_open(struct inode *inode, struct file *file) return single_open(file, pinctrl_gpioranges_show, inode->i_private); } +static int pinctrl_maps_open(struct inode *inode, struct file *file) +{ + return single_open(file, pinctrl_maps_show, inode->i_private); +} + +static int pinmux_hogs_open(struct inode *inode, struct file *file) +{ + return single_open(file, pinmux_hogs_show, inode->i_private); +} + static int pinctrl_devices_open(struct inode *inode, struct file *file) { return single_open(file, pinctrl_devices_show, NULL); } +static int pinctrl_open(struct inode *inode, struct file *file) +{ + return single_open(file, pinctrl_show, NULL); +} + static const struct file_operations pinctrl_pins_ops = { .open = pinctrl_pins_open, .read = seq_read, @@ -491,6 +1059,20 @@ static const struct file_operations pinctrl_gpioranges_ops = { .release = single_release, }; +static const struct file_operations pinctrl_maps_ops = { + .open = pinctrl_maps_open, + .read = seq_read, + .llseek = seq_lseek, + .release = single_release, +}; + +static const struct file_operations pinmux_hogs_ops = { + .open = pinmux_hogs_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, @@ -498,6 +1080,13 @@ static const struct file_operations pinctrl_devices_ops = { .release = single_release, }; +static const struct file_operations pinctrl_ops = { + .open = pinctrl_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) @@ -519,6 +1108,10 @@ static void pinctrl_init_device_debugfs(struct pinctrl_dev *pctldev) device_root, pctldev, &pinctrl_groups_ops); debugfs_create_file("gpio-ranges", S_IFREG | S_IRUGO, device_root, pctldev, &pinctrl_gpioranges_ops); + debugfs_create_file("pinctrl-maps", S_IFREG | S_IRUGO, + device_root, pctldev, &pinctrl_maps_ops); + debugfs_create_file("pinmux-hogs", S_IFREG | S_IRUGO, + device_root, pctldev, &pinmux_hogs_ops); pinmux_init_device_debugfs(device_root, pctldev); pinconf_init_device_debugfs(device_root, pctldev); } @@ -539,7 +1132,8 @@ static void pinctrl_init_debugfs(void) debugfs_create_file("pinctrl-devices", S_IFREG | S_IRUGO, debugfs_root, NULL, &pinctrl_devices_ops); - pinmux_init_debugfs(debugfs_root); + debugfs_create_file("pinctrl-handles", S_IFREG | S_IRUGO, + debugfs_root, NULL, &pinctrl_ops); } #else /* CONFIG_DEBUG_FS */ diff --git a/drivers/pinctrl/core.h b/drivers/pinctrl/core.h index 7a89888fce94..a50cdb053c84 100644 --- a/drivers/pinctrl/core.h +++ b/drivers/pinctrl/core.h @@ -30,6 +30,7 @@ struct pinctrl_gpio_range; * subsystem * @pinctrl_hogs_lock: lock for the pin control hog list * @pinctrl_hogs: list of pin control maps hogged by this device + * @device_root: debugfs root for this device */ struct pinctrl_dev { struct list_head node; @@ -41,12 +42,37 @@ struct pinctrl_dev { struct device *dev; struct module *owner; void *driver_data; + struct mutex pinctrl_hogs_lock; + struct list_head pinctrl_hogs; #ifdef CONFIG_DEBUG_FS struct dentry *device_root; #endif +}; + +/** + * struct pinctrl - per-device pin control state holder + * @node: global list node + * @dev: the device using this pin control handle + * @usecount: the number of active users of this pin controller setting, used + * to keep track of nested use cases + * @pctldev: pin control device handling this pin control handle + * @mutex: a lock for the pin control state holder + * @func_selector: the function selector for the pinmux device handling + * this pinmux + * @groups: the group selectors for the pinmux device and + * selector combination handling this pinmux, this is a list that + * will be traversed on all pinmux operations such as + * get/put/enable/disable + */ +struct pinctrl { + struct list_head node; + struct device *dev; + unsigned usecount; + struct pinctrl_dev *pctldev; + struct mutex mutex; #ifdef CONFIG_PINMUX - struct mutex pinctrl_hogs_lock; - struct list_head pinctrl_hogs; + unsigned func_selector; + struct list_head groups; #endif }; diff --git a/drivers/pinctrl/pinmux.c b/drivers/pinctrl/pinmux.c index 773835d18f55..fe4a00751c60 100644 --- a/drivers/pinctrl/pinmux.c +++ b/drivers/pinctrl/pinmux.c @@ -28,14 +28,7 @@ #include <linux/pinctrl/machine.h> #include <linux/pinctrl/pinmux.h> #include "core.h" - -/* List of pin controller handles */ -static DEFINE_MUTEX(pinctrl_list_mutex); -static LIST_HEAD(pinctrl_list); - -/* Global pinctrl maps */ -static struct pinctrl_map *pinctrl_maps; -static unsigned pinctrl_maps_num; +#include "pinmux.h" /** * struct pinmux_group - group list item for pinmux groups @@ -48,43 +41,6 @@ struct pinmux_group { }; /** - * struct pinctrl - per-device pin control state holder - * @node: global list node - * @dev: the device using this pin control handle - * @usecount: the number of active users of this pin controller setting, used - * to keep track of nested use cases - * @pctldev: pin control device handling this pin control handle - * @func_selector: the function selector for the pinmux device handling - * this pinmux - * @groups: the group selectors for the pinmux device and - * selector combination handling this pinmux, this is a list that - * will be traversed on all pinmux operations such as - * get/put/enable/disable - * @mutex: a lock for the pinmux state holder - */ -struct pinctrl { - struct list_head node; - struct device *dev; - unsigned usecount; - struct pinctrl_dev *pctldev; - unsigned func_selector; - struct list_head groups; - struct mutex mutex; -}; - -/** - * struct pinctrl_hog - a list item to stash control hogs - * @node: pin control hog list node - * @map: map entry responsible for this hogging - * @pmx: the pin control hogged by this item - */ -struct pinctrl_hog { - struct list_head node; - struct pinctrl_map const *map; - struct pinctrl *p; -}; - -/** * pin_request() - request a single pin to be muxed in, typically for GPIO * @pin: the pin number in the global pin space * @function: a functional name to give to this pin, passed to the driver @@ -207,28 +163,18 @@ static const char *pin_free(struct pinctrl_dev *pctldev, int pin, } /** - * pinctrl_request_gpio() - request a single pin to be used in as GPIO - * @gpio: the GPIO pin number from the GPIO subsystem number space - * - * This function should *ONLY* be used from gpiolib-based GPIO drivers, - * as part of their gpio_request() semantics, platforms and individual drivers - * shall *NOT* request GPIO pins to be muxed in. + * pinmux_request_gpio() - request pinmuxing for a GPIO pin + * @pctldev: pin controller device affected + * @pin: the pin to mux in for GPIO + * @range: the applicable GPIO range */ -int pinctrl_request_gpio(unsigned gpio) +int pinmux_request_gpio(struct pinctrl_dev *pctldev, + struct pinctrl_gpio_range *range, + unsigned pin, unsigned gpio) { char gpiostr[16]; const char *function; - struct pinctrl_dev *pctldev; - struct pinctrl_gpio_range *range; int ret; - int pin; - - ret = pinctrl_get_device_gpio_range(gpio, &pctldev, &range); - if (ret) - return -EINVAL; - - /* Convert to the pin controllers number space */ - pin = gpio - range->base + range->pin_base; /* Conjure some name stating what chip and pin this is taken by */ snprintf(gpiostr, 15, "%s:%d", range->name, gpio); @@ -243,53 +189,38 @@ int pinctrl_request_gpio(unsigned gpio) return ret; } -EXPORT_SYMBOL_GPL(pinctrl_request_gpio); /** - * pinctrl_free_gpio() - free control on a single pin, currently used as GPIO - * @gpio: the GPIO pin number from the GPIO subsystem number space - * - * This function should *ONLY* be used from gpiolib-based GPIO drivers, - * as part of their gpio_free() semantics, platforms and individual drivers - * shall *NOT* request GPIO pins to be muxed out. + * pinmux_free_gpio() - release a pin from GPIO muxing + * @pctldev: the pin controller device for the pin + * @pin: the affected currently GPIO-muxed in pin + * @range: applicable GPIO range */ -void pinctrl_free_gpio(unsigned gpio) +void pinmux_free_gpio(struct pinctrl_dev *pctldev, unsigned pin, + struct pinctrl_gpio_range *range) { - struct pinctrl_dev *pctldev; - struct pinctrl_gpio_range *range; - int ret; - int pin; const char *func; - ret = pinctrl_get_device_gpio_range(gpio, &pctldev, &range); - if (ret) - return; - - /* Convert to the pin controllers number space */ - pin = gpio - range->base + range->pin_base; - func = pin_free(pctldev, pin, range); kfree(func); } -EXPORT_SYMBOL_GPL(pinctrl_free_gpio); -static int pinctrl_gpio_direction(unsigned gpio, bool input) +/** + * pinmux_gpio_direction() - set the direction of a single muxed-in GPIO pin + * @pctldev: the pin controller handling this pin + * @range: applicable GPIO range + * @pin: the affected GPIO pin in this controller + * @input: true if we set the pin as input, false for output + */ +int pinmux_gpio_direction(struct pinctrl_dev *pctldev, + struct pinctrl_gpio_range *range, + unsigned pin, bool input) { - struct pinctrl_dev *pctldev; - struct pinctrl_gpio_range *range; const struct pinmux_ops *ops; int ret; - int pin; - - ret = pinctrl_get_device_gpio_range(gpio, &pctldev, &range); - if (ret) - return ret; ops = pctldev->desc->pmxops; - /* Convert to the pin controllers number space */ - pin = gpio - range->base + range->pin_base; - if (ops->gpio_set_direction) ret = ops->gpio_set_direction(pctldev, range, pin, input); else @@ -299,112 +230,6 @@ static int pinctrl_gpio_direction(unsigned gpio, bool input) } /** - * pinctrl_gpio_direction_input() - request a GPIO pin to go into input mode - * @gpio: the GPIO pin number from the GPIO subsystem number space - * - * This function should *ONLY* be used from gpiolib-based GPIO drivers, - * as part of their gpio_direction_input() semantics, platforms and individual - * drivers shall *NOT* touch pin control GPIO calls. - */ -int pinctrl_gpio_direction_input(unsigned gpio) -{ - return pinctrl_gpio_direction(gpio, true); -} -EXPORT_SYMBOL_GPL(pinctrl_gpio_direction_input); - -/** - * pinctrl_gpio_direction_output() - request a GPIO pin to go into output mode - * @gpio: the GPIO pin number from the GPIO subsystem number space - * - * This function should *ONLY* be used from gpiolib-based GPIO drivers, - * as part of their gpio_direction_output() semantics, platforms and individual - * drivers shall *NOT* touch pin control GPIO calls. - */ -int pinctrl_gpio_direction_output(unsigned gpio) -{ - return pinctrl_gpio_direction(gpio, false); -} -EXPORT_SYMBOL_GPL(pinctrl_gpio_direction_output); - -/** - * pinctrl_register_mappings() - register a set of pin controller mappings - * @maps: the pincontrol mappings table to register, this should be marked with - * __initdata so it can be discarded after boot, this function will - * perform a shallow copy for the mapping entries. - * @num_maps: the number of maps in the mapping table - * - * Only call this once during initialization of your machine, the function is - * tagged as __init and won't be callable after init has completed. The map - * passed into this function will be owned by the pinmux core and cannot be - * freed. - */ -int __init pinctrl_register_mappings(struct pinctrl_map const *maps, - unsigned num_maps) -{ - void *tmp_maps; - int i; - - pr_debug("add %d pinmux maps\n", num_maps); - - /* First sanity check the new mapping */ - for (i = 0; i < num_maps; i++) { - if (!maps[i].name) { - pr_err("failed to register map %d: no map name given\n", - i); - return -EINVAL; - } - - if (!maps[i].ctrl_dev_name) { - pr_err("failed to register map %s (%d): no pin control device given\n", - maps[i].name, i); - return -EINVAL; - } - - if (!maps[i].function) { - pr_err("failed to register map %s (%d): no function ID given\n", - maps[i].name, i); - return -EINVAL; - } - - if (!maps[i].dev_name) - pr_debug("add system map %s function %s with no device\n", - maps[i].name, - maps[i].function); - else - pr_debug("register map %s, function %s\n", - maps[i].name, - maps[i].function); - } - - /* - * Make a copy of the map array - string pointers will end up in the - * kernel const section anyway so these do not need to be deep copied. - */ - if (!pinctrl_maps_num) { - /* On first call, just copy them */ - tmp_maps = kmemdup(maps, - sizeof(struct pinctrl_map) * num_maps, - GFP_KERNEL); - if (!tmp_maps) - return -ENOMEM; - } else { - /* Subsequent calls, reallocate array to new size */ - size_t oldsize = sizeof(struct pinctrl_map) * pinctrl_maps_num; - size_t newsize = sizeof(struct pinctrl_map) * num_maps; - - tmp_maps = krealloc(pinctrl_maps, - oldsize + newsize, GFP_KERNEL); - if (!tmp_maps) - return -ENOMEM; - memcpy((tmp_maps + oldsize), maps, newsize); - } - - pinctrl_maps = tmp_maps; - pinctrl_maps_num += num_maps; - return 0; -} - -/** * acquire_pins() - acquire all the pins for a certain function on a pinmux * @pctldev: the device to take the pins on * @func_selector: the function selector to acquire the pins for @@ -660,227 +485,81 @@ static int pinmux_enable_muxmap(struct pinctrl_dev *pctldev, return 0; } -static void pinmux_free_groups(struct pinctrl *p) -{ - struct list_head *node, *tmp; - - list_for_each_safe(node, tmp, &p->groups) { - struct pinmux_group *grp = - list_entry(node, struct pinmux_group, node); - /* Release all pins taken by this group */ - release_pins(p->pctldev, grp->group_selector); - list_del(node); - kfree(grp); - } -} - /** - * pinctrl_get() - retrieves the pin controller handle for a certain device - * @dev: the device to get the pin controller handle for - * @name: an optional specific control mapping name or NULL, the name is only - * needed if you want to have more than one mapping per device, or if you - * need an anonymous pin control (not tied to any specific device) + * pinmux_apply_muxmap() - apply a certain mux mapping entry */ -struct pinctrl *pinctrl_get(struct device *dev, const char *name) +int pinmux_apply_muxmap(struct pinctrl_dev *pctldev, + struct pinctrl *p, + struct device *dev, + const char *devname, + struct pinctrl_map const *map) { - struct pinctrl_map const *map = NULL; - struct pinctrl_dev *pctldev = NULL; - const char *devname = NULL; - struct pinctrl *p; - bool found_map; - unsigned num_maps = 0; - int ret = -ENODEV; - int i; - - /* We must have dev or ID or both */ - if (!dev && !name) - return ERR_PTR(-EINVAL); - - if (dev) - devname = dev_name(dev); - - pr_debug("get mux %s for device %s\n", name, - devname ? devname : "(none)"); - - /* - * create the state cookie holder struct pinmux for each - * mapping, this is what consumers will get when requesting - * a pinmux handle with pinmux_get() - */ - p = kzalloc(sizeof(struct pinctrl), GFP_KERNEL); - if (p == NULL) - return ERR_PTR(-ENOMEM); - mutex_init(&p->mutex); - p->func_selector = UINT_MAX; - INIT_LIST_HEAD(&p->groups); - - /* Iterate over the pin control maps to locate the right ones */ - for (i = 0; i < pinctrl_maps_num; i++) { - map = &pinctrl_maps[i]; - found_map = false; - - /* - * First, try to find the pctldev given in the map - */ - pctldev = get_pinctrl_dev_from_devname(map->ctrl_dev_name); - if (!pctldev) { - pr_warning("could not find a pinctrl device for pinmux function %s, fishy, they shall all have one\n", - map->function); - pr_warning("given pinctrl device name: %s", - map->ctrl_dev_name); - - /* Continue to check the other mappings anyway... */ - continue; - } - - pr_debug("in map, found pctldev %s to handle function %s", - dev_name(pctldev->dev), map->function); - - - /* - * If we're looking for a specific named map, this must match, - * else we loop and look for the next. - */ - if (name != NULL) { - if (map->name == NULL) - continue; - if (strcmp(map->name, name)) - continue; - } - - /* - * This is for the case where no device name is given, we - * already know that the function name matches from above - * code. - */ - if (!map->dev_name && (name != NULL)) - found_map = true; - - /* If the mapping has a device set up it must match */ - if (map->dev_name && - (!devname || !strcmp(map->dev_name, devname))) - /* MATCH! */ - found_map = true; - - /* If this map is applicable, then apply it */ - if (found_map) { - ret = pinmux_enable_muxmap(pctldev, p, dev, - devname, map); - if (ret) { - pinmux_free_groups(p); - kfree(p); - return ERR_PTR(ret); - } - num_maps++; - } - } - + int ret; - /* We should have atleast one map, right */ - if (!num_maps) { - pr_err("could not find any mux maps for device %s, ID %s\n", - devname ? devname : "(anonymous)", - name ? name : "(undefined)"); - kfree(p); - return ERR_PTR(-EINVAL); + ret = pinmux_enable_muxmap(pctldev, p, dev, + devname, map); + if (ret) { + pinmux_put(p); + return ret; } - pr_debug("found %u mux maps for device %s, UD %s\n", - num_maps, - devname ? devname : "(anonymous)", - name ? name : "(undefined)"); - - /* Add the pinmux to the global list */ - mutex_lock(&pinctrl_list_mutex); - list_add(&p->node, &pinctrl_list); - mutex_unlock(&pinctrl_list_mutex); - - return p; + return 0; } -EXPORT_SYMBOL_GPL(pinctrl_get); /** - * pinctrl_put() - release a previously claimed pin control handle - * @p: a pin control handle previously claimed by pinctrl_get() + * pinmux_put() - free up the pinmux portions of a pin controller handle */ -void pinctrl_put(struct pinctrl *p) +void pinmux_put(struct pinctrl *p) { - if (p == NULL) - return; - - mutex_lock(&p->mutex); - if (p->usecount) - pr_warn("releasing pin control handle with active users!\n"); - /* Free the groups and all acquired pins */ - pinmux_free_groups(p); - mutex_unlock(&p->mutex); - - /* Remove from list */ - mutex_lock(&pinctrl_list_mutex); - list_del(&p->node); - mutex_unlock(&pinctrl_list_mutex); + struct list_head *node, *tmp; - kfree(p); + list_for_each_safe(node, tmp, &p->groups) { + struct pinmux_group *grp = + list_entry(node, struct pinmux_group, node); + /* Release all pins taken by this group */ + release_pins(p->pctldev, grp->group_selector); + list_del(node); + kfree(grp); + } } -EXPORT_SYMBOL_GPL(pinctrl_put); /** - * pinctrl_enable() - enable a certain pin controller setting - * @p: the pin control handle to enable, previously claimed by pinctrl_get() + * pinmux_enable() - enable the pinmux portion of a pin control handle */ -int pinctrl_enable(struct pinctrl *p) +int pinmux_enable(struct pinctrl *p) { - int ret = 0; + struct pinctrl_dev *pctldev = p->pctldev; + const struct pinmux_ops *ops = pctldev->desc->pmxops; + struct pinmux_group *grp; + int ret; - if (p == NULL) - return -EINVAL; - mutex_lock(&p->mutex); - if (p->usecount++ == 0) { - struct pinctrl_dev *pctldev = p->pctldev; - const struct pinmux_ops *ops = pctldev->desc->pmxops; - struct pinmux_group *grp; - - list_for_each_entry(grp, &p->groups, node) { - ret = ops->enable(pctldev, p->func_selector, - grp->group_selector); - if (ret) { - /* - * TODO: call disable() on all groups we called - * enable() on to this point? - */ - p->usecount--; - break; - } - } + list_for_each_entry(grp, &p->groups, node) { + ret = ops->enable(pctldev, p->func_selector, + grp->group_selector); + if (ret) + /* + * TODO: call disable() on all groups we called + * enable() on to this point? + */ + return ret; } - mutex_unlock(&p->mutex); - return ret; + return 0; } -EXPORT_SYMBOL_GPL(pinctrl_enable); /** - * pinctrl_disable() - disable a certain pin control setting - * @p: the pin control handle to disable, previously claimed by pinctrl_get() + * pinmux_disable() - disable the pinmux portions of a pin control handle */ -void pinctrl_disable(struct pinctrl *p) +void pinmux_disable(struct pinctrl *p) { - if (p == NULL) - return; - - mutex_lock(&p->mutex); - if (--p->usecount == 0) { - struct pinctrl_dev *pctldev = p->pctldev; - const struct pinmux_ops *ops = pctldev->desc->pmxops; - struct pinmux_group *grp; + struct pinctrl_dev *pctldev = p->pctldev; + const struct pinmux_ops *ops = pctldev->desc->pmxops; + struct pinmux_group *grp; - list_for_each_entry(grp, &p->groups, node) { - ops->disable(pctldev, p->func_selector, - grp->group_selector); - } + list_for_each_entry(grp, &p->groups, node) { + ops->disable(pctldev, p->func_selector, + grp->group_selector); } - mutex_unlock(&p->mutex); } -EXPORT_SYMBOL_GPL(pinctrl_disable); int pinmux_check_ops(struct pinctrl_dev *pctldev) { @@ -910,116 +589,6 @@ int pinmux_check_ops(struct pinctrl_dev *pctldev) return 0; } -/* Hog a single map entry and add to the hoglist */ -static int pinctrl_hog_map(struct pinctrl_dev *pctldev, - struct pinctrl_map const *map) -{ - struct pinctrl_hog *hog; - struct pinctrl *p; - int ret; - - if (map->dev_name) { - /* - * TODO: the day we have device tree support, we can - * traverse the device tree and hog to specific device nodes - * without any problems, so then we can hog pinmuxes for - * all devices that just want a static pin mux at this point. - */ - dev_err(pctldev->dev, "map %s wants to hog a non-system pinmux, this is not going to work\n", - map->name); - return -EINVAL; - } - - hog = kzalloc(sizeof(struct pinctrl_hog), GFP_KERNEL); - if (!hog) - return -ENOMEM; - - p = pinctrl_get(NULL, map->name); - if (IS_ERR(p)) { - kfree(hog); - dev_err(pctldev->dev, - "could not get the %s pin control mapping for hogging\n", - map->name); - return PTR_ERR(p); - } - - ret = pinctrl_enable(p); - if (ret) { - pinctrl_put(p); - kfree(hog); - dev_err(pctldev->dev, - "could not enable the %s pin control mapping for hogging\n", - map->name); - return ret; - } - - hog->map = map; - hog->p = p; - - dev_info(pctldev->dev, "hogged map %s, function %s\n", map->name, - map->function); - mutex_lock(&pctldev->pinctrl_hogs_lock); - list_add(&hog->node, &pctldev->pinctrl_hogs); - mutex_unlock(&pctldev->pinctrl_hogs_lock); - - return 0; -} - -/** - * pinctrl_hog_maps() - hog specific map entries on controller device - * @pctldev: the pin control device to hog entries on - * - * When the pin controllers are registered, there may be some specific pinmux - * map entries that need to be hogged, i.e. get+enabled until the system shuts - * down. - */ -int pinctrl_hog_maps(struct pinctrl_dev *pctldev) -{ - struct device *dev = pctldev->dev; - const char *devname = dev_name(dev); - int ret; - int i; - - INIT_LIST_HEAD(&pctldev->pinctrl_hogs); - mutex_init(&pctldev->pinctrl_hogs_lock); - - for (i = 0; i < pinctrl_maps_num; i++) { - struct pinctrl_map const *map = &pinctrl_maps[i]; - - if (!map->hog_on_boot) - continue; - - if (map->ctrl_dev_name && - !strcmp(map->ctrl_dev_name, devname)) { - /* OK time to hog! */ - ret = pinctrl_hog_map(pctldev, map); - if (ret) - return ret; - } - } - return 0; -} - -/** - * pinctrl_unhog_maps() - unhog specific map entries on controller device - * @pctldev: the pin control device to unhog entries on - */ -void pinctrl_unhog_maps(struct pinctrl_dev *pctldev) -{ - struct list_head *node, *tmp; - - mutex_lock(&pctldev->pinctrl_hogs_lock); - list_for_each_safe(node, tmp, &pctldev->pinctrl_hogs) { - struct pinctrl_hog *hog = - list_entry(node, struct pinctrl_hog, node); - pinctrl_disable(hog->p); - pinctrl_put(hog->p); - list_del(node); - kfree(hog); - } - mutex_unlock(&pctldev->pinctrl_hogs_lock); -} - #ifdef CONFIG_DEBUG_FS /* Called from pincontrol core */ @@ -1083,83 +652,29 @@ static int pinmux_pins_show(struct seq_file *s, void *what) return 0; } -static int pinmux_hogs_show(struct seq_file *s, void *what) -{ - struct pinctrl_dev *pctldev = s->private; - struct pinctrl_hog *hog; - - seq_puts(s, "Pin control map hogs held by device\n"); - - list_for_each_entry(hog, &pctldev->pinctrl_hogs, node) - seq_printf(s, "%s\n", hog->map->name); - - return 0; -} - -static int pinmux_show(struct seq_file *s, void *what) +void pinmux_dbg_show(struct seq_file *s, struct pinctrl *p) { - struct pinctrl *p; - - seq_puts(s, "Requested pinmuxes and their maps:\n"); - list_for_each_entry(p, &pinctrl_list, node) { - struct pinctrl_dev *pctldev = p->pctldev; - const struct pinmux_ops *pmxops; - const struct pinctrl_ops *pctlops; - struct pinmux_group *grp; - - if (!pctldev) { - seq_puts(s, "NO PIN CONTROLLER DEVICE\n"); - continue; - } - - pmxops = pctldev->desc->pmxops; - pctlops = pctldev->desc->pctlops; - - seq_printf(s, "device: %s function: %s (%u),", - pinctrl_dev_get_name(p->pctldev), - pmxops->get_function_name(pctldev, - p->func_selector), - p->func_selector); - - seq_printf(s, " groups: ["); - list_for_each_entry(grp, &p->groups, node) { - seq_printf(s, " %s (%u)", - pctlops->get_group_name(pctldev, - grp->group_selector), - grp->group_selector); - } - seq_printf(s, " ]"); + struct pinctrl_dev *pctldev = p->pctldev; + const struct pinmux_ops *pmxops; + const struct pinctrl_ops *pctlops; + struct pinmux_group *grp; - seq_printf(s, " users: %u map-> %s\n", - p->usecount, - p->dev ? dev_name(p->dev) : "(system)"); - } + pmxops = pctldev->desc->pmxops; + pctlops = pctldev->desc->pctlops; - return 0; -} - -static int pinctrl_maps_show(struct seq_file *s, void *what) -{ - int i; + seq_printf(s, " function: %s (%u),", + pmxops->get_function_name(pctldev, + p->func_selector), + p->func_selector); - seq_puts(s, "Pinctrl maps:\n"); - - for (i = 0; i < pinctrl_maps_num; i++) { - struct pinctrl_map const *map = &pinctrl_maps[i]; - - seq_printf(s, "%s:\n", map->name); - if (map->dev_name) - seq_printf(s, " device: %s\n", - map->dev_name); - else - seq_printf(s, " SYSTEM MUX\n"); - seq_printf(s, " controlling device %s\n", - map->ctrl_dev_name); - seq_printf(s, " function: %s\n", map->function); - seq_printf(s, " group: %s\n", map->group ? map->group : - "(default)"); + seq_printf(s, " groups: ["); + list_for_each_entry(grp, &p->groups, node) { + seq_printf(s, " %s (%u)", + pctlops->get_group_name(pctldev, + grp->group_selector), + grp->group_selector); } - return 0; + seq_printf(s, " ]"); } static int pinmux_functions_open(struct inode *inode, struct file *file) @@ -1172,21 +687,6 @@ static int pinmux_pins_open(struct inode *inode, struct file *file) return single_open(file, pinmux_pins_show, inode->i_private); } -static int pinmux_hogs_open(struct inode *inode, struct file *file) -{ - return single_open(file, pinmux_hogs_show, inode->i_private); -} - -static int pinmux_open(struct inode *inode, struct file *file) -{ - return single_open(file, pinmux_show, NULL); -} - -static int pinctrl_maps_open(struct inode *inode, struct file *file) -{ - return single_open(file, pinctrl_maps_show, NULL); -} - static const struct file_operations pinmux_functions_ops = { .open = pinmux_functions_open, .read = seq_read, @@ -1201,27 +701,6 @@ static const struct file_operations pinmux_pins_ops = { .release = single_release, }; -static const struct file_operations pinmux_hogs_ops = { - .open = pinmux_hogs_open, - .read = seq_read, - .llseek = seq_lseek, - .release = single_release, -}; - -static const struct file_operations pinmux_ops = { - .open = pinmux_open, - .read = seq_read, - .llseek = seq_lseek, - .release = single_release, -}; - -static const struct file_operations pinctrl_maps_ops = { - .open = pinctrl_maps_open, - .read = seq_read, - .llseek = seq_lseek, - .release = single_release, -}; - void pinmux_init_device_debugfs(struct dentry *devroot, struct pinctrl_dev *pctldev) { @@ -1229,16 +708,6 @@ void pinmux_init_device_debugfs(struct dentry *devroot, devroot, pctldev, &pinmux_functions_ops); debugfs_create_file("pinmux-pins", S_IFREG | S_IRUGO, devroot, pctldev, &pinmux_pins_ops); - debugfs_create_file("pinmux-hogs", S_IFREG | S_IRUGO, - devroot, pctldev, &pinmux_hogs_ops); -} - -void pinmux_init_debugfs(struct dentry *subsys_root) -{ - debugfs_create_file("pinmuxes", S_IFREG | S_IRUGO, - subsys_root, NULL, &pinmux_ops); - debugfs_create_file("pinctrl-maps", S_IFREG | S_IRUGO, - subsys_root, NULL, &pinctrl_maps_ops); } #endif /* CONFIG_DEBUG_FS */ diff --git a/drivers/pinctrl/pinmux.h b/drivers/pinctrl/pinmux.h index dfe81726965c..7680a1703252 100644 --- a/drivers/pinctrl/pinmux.h +++ b/drivers/pinctrl/pinmux.h @@ -15,9 +15,28 @@ int pinmux_check_ops(struct pinctrl_dev *pctldev); void pinmux_init_device_debugfs(struct dentry *devroot, struct pinctrl_dev *pctldev); -void pinmux_init_debugfs(struct dentry *subsys_root); -int pinctrl_hog_maps(struct pinctrl_dev *pctldev); -void pinctrl_unhog_maps(struct pinctrl_dev *pctldev); +int pinmux_request_gpio(struct pinctrl_dev *pctldev, + struct pinctrl_gpio_range *range, + unsigned pin, unsigned gpio); +void pinmux_free_gpio(struct pinctrl_dev *pctldev, unsigned pin, + struct pinctrl_gpio_range *range); +int pinmux_gpio_direction(struct pinctrl_dev *pctldev, + struct pinctrl_gpio_range *range, + unsigned pin, bool input); +static inline void pinmux_init_pinctrl_handle(struct pinctrl *p) +{ + p->func_selector = UINT_MAX; + INIT_LIST_HEAD(&p->groups); +} +int pinmux_apply_muxmap(struct pinctrl_dev *pctldev, + struct pinctrl *p, + struct device *dev, + const char *devname, + struct pinctrl_map const *map); +void pinmux_put(struct pinctrl *p); +int pinmux_enable(struct pinctrl *p); +void pinmux_disable(struct pinctrl *p); +void pinmux_dbg_show(struct seq_file *s, struct pinctrl *p); #else @@ -31,16 +50,52 @@ static inline void pinmux_init_device_debugfs(struct dentry *devroot, { } -static inline void pinmux_init_debugfs(struct dentry *subsys_root) +static inline int pinmux_request_gpio(struct pinctrl_dev *pctldev, + struct pinctrl_gpio_range *range, + unsigned pin, unsigned gpio) +{ + return 0; +} + +static inline void pinmux_free_gpio(struct pinctrl_dev *pctldev, + unsigned pin, + struct pinctrl_gpio_range *range) +{ +} + +static inline int pinmux_gpio_direction(struct pinctrl_dev *pctldev, + struct pinctrl_gpio_range *range, + unsigned pin, bool input) +{ + return 0; +} + +static inline void pinmux_init_pinctrl_handle(struct pinctrl *p) { } -static inline int pinctrl_hog_maps(struct pinctrl_dev *pctldev) +static inline int pinmux_apply_muxmap(struct pinctrl_dev *pctldev, + struct pinctrl *p, + struct device *dev, + const char *devname, + struct pinctrl_map const *map) { return 0; } -static inline void pinctrl_unhog_maps(struct pinctrl_dev *pctldev) +static inline void pinmux_put(struct pinctrl *p) +{ +} + +static inline int pinmux_enable(struct pinctrl *p) +{ +} + +static inline void pinmux_disable(struct pinctrl *p) +{ +} + +void pinmux_dbg_show(struct seq_file *s, struct pinctrl *p) { } |