blob: 051e8592990e9c9824563f8af789af05b1a5fdbf [file] [log] [blame]
Linus Walleij2744e8a2011-05-02 20:50:54 +02001/*
2 * Core driver for the pin muxing portions of the pin control subsystem
3 *
Linus Walleije93bcee2012-02-09 07:23:28 +01004 * Copyright (C) 2011-2012 ST-Ericsson SA
Linus Walleij2744e8a2011-05-02 20:50:54 +02005 * Written on behalf of Linaro for ST-Ericsson
6 * Based on bits of regulator core, gpio core and clk core
7 *
8 * Author: Linus Walleij <linus.walleij@linaro.org>
9 *
Stephen Warren7ecdb162012-03-02 13:05:45 -070010 * Copyright (C) 2012 NVIDIA CORPORATION. All rights reserved.
11 *
Linus Walleij2744e8a2011-05-02 20:50:54 +020012 * License terms: GNU General Public License (GPL) version 2
13 */
14#define pr_fmt(fmt) "pinmux core: " fmt
15
16#include <linux/kernel.h>
17#include <linux/module.h>
18#include <linux/init.h>
19#include <linux/device.h>
20#include <linux/slab.h>
21#include <linux/radix-tree.h>
22#include <linux/err.h>
23#include <linux/list.h>
Linus Walleij97607d12011-11-29 12:52:39 +010024#include <linux/string.h>
Linus Walleij2744e8a2011-05-02 20:50:54 +020025#include <linux/sysfs.h>
26#include <linux/debugfs.h>
27#include <linux/seq_file.h>
28#include <linux/pinctrl/machine.h>
29#include <linux/pinctrl/pinmux.h>
30#include "core.h"
Linus Walleijbefe5bd2012-02-09 19:47:48 +010031#include "pinmux.h"
Linus Walleij2744e8a2011-05-02 20:50:54 +020032
Stephen Warren03665e02012-02-19 23:45:45 -070033int pinmux_check_ops(struct pinctrl_dev *pctldev)
34{
35 const struct pinmux_ops *ops = pctldev->desc->pmxops;
Dong Aishenga1d31f72012-04-06 20:18:09 +080036 unsigned nfuncs;
Stephen Warren03665e02012-02-19 23:45:45 -070037 unsigned selector = 0;
38
39 /* Check that we implement required operations */
Dong Aishenga1d31f72012-04-06 20:18:09 +080040 if (!ops ||
41 !ops->get_functions_count ||
Stephen Warren03665e02012-02-19 23:45:45 -070042 !ops->get_function_name ||
43 !ops->get_function_groups ||
Dong Aisheng02b50ce2012-05-14 19:06:37 +080044 !ops->enable) {
John Crispinad6e1102012-04-26 16:47:11 +020045 dev_err(pctldev->dev, "pinmux ops lacks necessary functions\n");
Stephen Warren03665e02012-02-19 23:45:45 -070046 return -EINVAL;
John Crispinad6e1102012-04-26 16:47:11 +020047 }
Stephen Warren03665e02012-02-19 23:45:45 -070048 /* Check that all functions registered have names */
Dong Aishenga1d31f72012-04-06 20:18:09 +080049 nfuncs = ops->get_functions_count(pctldev);
Viresh Kumard1e90e92012-03-30 11:25:40 +053050 while (selector < nfuncs) {
Stephen Warren03665e02012-02-19 23:45:45 -070051 const char *fname = ops->get_function_name(pctldev,
52 selector);
53 if (!fname) {
Dong Aishenga1d31f72012-04-06 20:18:09 +080054 dev_err(pctldev->dev, "pinmux ops has no name for function%u\n",
Stephen Warren03665e02012-02-19 23:45:45 -070055 selector);
56 return -EINVAL;
57 }
58 selector++;
59 }
60
61 return 0;
62}
63
Stephen Warren1e2082b2012-03-02 13:05:48 -070064int pinmux_validate_map(struct pinctrl_map const *map, int i)
65{
66 if (!map->data.mux.function) {
67 pr_err("failed to register map %s (%d): no function given\n",
68 map->name, i);
69 return -EINVAL;
70 }
71
72 return 0;
73}
74
Linus Walleij2744e8a2011-05-02 20:50:54 +020075/**
Linus Walleij2744e8a2011-05-02 20:50:54 +020076 * pin_request() - request a single pin to be muxed in, typically for GPIO
77 * @pin: the pin number in the global pin space
Stephen Warren3cc70ed2012-02-19 23:45:44 -070078 * @owner: a representation of the owner of this pin; typically the device
79 * name that controls its mux function, or the requested GPIO name
Linus Walleij2744e8a2011-05-02 20:50:54 +020080 * @gpio_range: the range matching the GPIO pin if this is a request for a
81 * single GPIO pin
82 */
83static int pin_request(struct pinctrl_dev *pctldev,
Stephen Warren3cc70ed2012-02-19 23:45:44 -070084 int pin, const char *owner,
Linus Walleij2744e8a2011-05-02 20:50:54 +020085 struct pinctrl_gpio_range *gpio_range)
86{
87 struct pin_desc *desc;
88 const struct pinmux_ops *ops = pctldev->desc->pmxops;
89 int status = -EINVAL;
90
Linus Walleij2744e8a2011-05-02 20:50:54 +020091 desc = pin_desc_get(pctldev, pin);
92 if (desc == NULL) {
Stephen Warren51cd24e2011-12-09 16:59:05 -070093 dev_err(pctldev->dev,
Stephen Warrend47053162012-05-01 11:14:15 -060094 "pin %d is not registered so it cannot be requested\n",
95 pin);
Linus Walleij2744e8a2011-05-02 20:50:54 +020096 goto out;
97 }
98
Dong Aishengd0bd8df2012-04-17 15:00:45 +080099 dev_dbg(pctldev->dev, "request pin %d (%s) for %s\n",
100 pin, desc->name, owner);
101
Stephen Warren652162d2012-03-05 17:22:15 -0700102 if (gpio_range) {
103 /* There's no need to support multiple GPIO requests */
104 if (desc->gpio_owner) {
105 dev_err(pctldev->dev,
Stephen Warrend47053162012-05-01 11:14:15 -0600106 "pin %s already requested by %s; cannot claim for %s\n",
107 desc->name, desc->gpio_owner, owner);
Stephen Warren652162d2012-03-05 17:22:15 -0700108 goto out;
109 }
110
111 desc->gpio_owner = owner;
112 } else {
113 if (desc->mux_usecount && strcmp(desc->mux_owner, owner)) {
114 dev_err(pctldev->dev,
Stephen Warrend47053162012-05-01 11:14:15 -0600115 "pin %s already requested by %s; cannot claim for %s\n",
116 desc->name, desc->mux_owner, owner);
Stephen Warren652162d2012-03-05 17:22:15 -0700117 goto out;
118 }
119
120 desc->mux_usecount++;
121 if (desc->mux_usecount > 1)
122 return 0;
123
124 desc->mux_owner = owner;
Linus Walleij2744e8a2011-05-02 20:50:54 +0200125 }
Stephen Warren0e3db1732012-03-02 13:05:46 -0700126
Linus Walleij2744e8a2011-05-02 20:50:54 +0200127 /* Let each pin increase references to this module */
128 if (!try_module_get(pctldev->owner)) {
Stephen Warren51cd24e2011-12-09 16:59:05 -0700129 dev_err(pctldev->dev,
Linus Walleij2744e8a2011-05-02 20:50:54 +0200130 "could not increase module refcount for pin %d\n",
131 pin);
132 status = -EINVAL;
133 goto out_free_pin;
134 }
135
136 /*
137 * If there is no kind of request function for the pin we just assume
138 * we got it by default and proceed.
139 */
Stephen Warren3712a3c2011-10-21 12:25:53 -0600140 if (gpio_range && ops->gpio_request_enable)
Linus Walleij2744e8a2011-05-02 20:50:54 +0200141 /* This requests and enables a single GPIO pin */
142 status = ops->gpio_request_enable(pctldev, gpio_range, pin);
143 else if (ops->request)
144 status = ops->request(pctldev, pin);
145 else
146 status = 0;
147
Stephen Warren0e3db1732012-03-02 13:05:46 -0700148 if (status) {
Stephen Warrend47053162012-05-01 11:14:15 -0600149 dev_err(pctldev->dev, "request() failed for pin %d\n", pin);
Stephen Warren0e3db1732012-03-02 13:05:46 -0700150 module_put(pctldev->owner);
151 }
152
Linus Walleij2744e8a2011-05-02 20:50:54 +0200153out_free_pin:
Stephen Warren0e3db1732012-03-02 13:05:46 -0700154 if (status) {
Stephen Warren652162d2012-03-05 17:22:15 -0700155 if (gpio_range) {
156 desc->gpio_owner = NULL;
157 } else {
158 desc->mux_usecount--;
159 if (!desc->mux_usecount)
160 desc->mux_owner = NULL;
161 }
Stephen Warren0e3db1732012-03-02 13:05:46 -0700162 }
Linus Walleij2744e8a2011-05-02 20:50:54 +0200163out:
164 if (status)
Stephen Warren51cd24e2011-12-09 16:59:05 -0700165 dev_err(pctldev->dev, "pin-%d (%s) status %d\n",
Stephen Warrend47053162012-05-01 11:14:15 -0600166 pin, owner, status);
Linus Walleij2744e8a2011-05-02 20:50:54 +0200167
168 return status;
169}
170
171/**
172 * pin_free() - release a single muxed in pin so something else can be muxed
173 * @pctldev: pin controller device handling this pin
174 * @pin: the pin to free
Stephen Warren3712a3c2011-10-21 12:25:53 -0600175 * @gpio_range: the range matching the GPIO pin if this is a request for a
176 * single GPIO pin
Linus Walleij336cdba02011-11-10 09:27:41 +0100177 *
Stephen Warren3cc70ed2012-02-19 23:45:44 -0700178 * This function returns a pointer to the previous owner. This is used
179 * for callers that dynamically allocate an owner name so it can be freed
Linus Walleij336cdba02011-11-10 09:27:41 +0100180 * once the pin is free. This is done for GPIO request functions.
Linus Walleij2744e8a2011-05-02 20:50:54 +0200181 */
Stephen Warren3712a3c2011-10-21 12:25:53 -0600182static const char *pin_free(struct pinctrl_dev *pctldev, int pin,
183 struct pinctrl_gpio_range *gpio_range)
Linus Walleij2744e8a2011-05-02 20:50:54 +0200184{
185 const struct pinmux_ops *ops = pctldev->desc->pmxops;
186 struct pin_desc *desc;
Stephen Warren3cc70ed2012-02-19 23:45:44 -0700187 const char *owner;
Linus Walleij2744e8a2011-05-02 20:50:54 +0200188
189 desc = pin_desc_get(pctldev, pin);
190 if (desc == NULL) {
Stephen Warren51cd24e2011-12-09 16:59:05 -0700191 dev_err(pctldev->dev,
Linus Walleij2744e8a2011-05-02 20:50:54 +0200192 "pin is not registered so it cannot be freed\n");
Stephen Warren3712a3c2011-10-21 12:25:53 -0600193 return NULL;
Linus Walleij2744e8a2011-05-02 20:50:54 +0200194 }
195
Stephen Warren652162d2012-03-05 17:22:15 -0700196 if (!gpio_range) {
Richard Genoud740924a2013-03-21 12:21:47 +0100197 /*
198 * A pin should not be freed more times than allocated.
199 */
200 if (WARN_ON(!desc->mux_usecount))
201 return NULL;
Stephen Warren652162d2012-03-05 17:22:15 -0700202 desc->mux_usecount--;
203 if (desc->mux_usecount)
204 return NULL;
205 }
Stephen Warren0e3db1732012-03-02 13:05:46 -0700206
Stephen Warren3712a3c2011-10-21 12:25:53 -0600207 /*
208 * If there is no kind of request function for the pin we just assume
209 * we got it by default and proceed.
210 */
211 if (gpio_range && ops->gpio_disable_free)
212 ops->gpio_disable_free(pctldev, gpio_range, pin);
213 else if (ops->free)
Linus Walleij2744e8a2011-05-02 20:50:54 +0200214 ops->free(pctldev, pin);
215
Stephen Warren652162d2012-03-05 17:22:15 -0700216 if (gpio_range) {
217 owner = desc->gpio_owner;
218 desc->gpio_owner = NULL;
219 } else {
220 owner = desc->mux_owner;
221 desc->mux_owner = NULL;
222 desc->mux_setting = NULL;
223 }
224
Linus Walleij2744e8a2011-05-02 20:50:54 +0200225 module_put(pctldev->owner);
Stephen Warren3712a3c2011-10-21 12:25:53 -0600226
Stephen Warren3cc70ed2012-02-19 23:45:44 -0700227 return owner;
Linus Walleij2744e8a2011-05-02 20:50:54 +0200228}
229
230/**
Linus Walleijbefe5bd2012-02-09 19:47:48 +0100231 * pinmux_request_gpio() - request pinmuxing for a GPIO pin
232 * @pctldev: pin controller device affected
233 * @pin: the pin to mux in for GPIO
234 * @range: the applicable GPIO range
Linus Walleij2744e8a2011-05-02 20:50:54 +0200235 */
Linus Walleijbefe5bd2012-02-09 19:47:48 +0100236int pinmux_request_gpio(struct pinctrl_dev *pctldev,
237 struct pinctrl_gpio_range *range,
238 unsigned pin, unsigned gpio)
Linus Walleij2744e8a2011-05-02 20:50:54 +0200239{
Stephen Warren3cc70ed2012-02-19 23:45:44 -0700240 const char *owner;
Linus Walleij2744e8a2011-05-02 20:50:54 +0200241 int ret;
Linus Walleij2744e8a2011-05-02 20:50:54 +0200242
243 /* Conjure some name stating what chip and pin this is taken by */
Thomas Petazzoni23a895a2012-09-13 21:48:14 +0200244 owner = kasprintf(GFP_KERNEL, "%s:%d", range->name, gpio);
Stephen Warren3cc70ed2012-02-19 23:45:44 -0700245 if (!owner)
Stephen Warren5d2eaf82011-10-19 16:19:28 -0600246 return -EINVAL;
247
Stephen Warren3cc70ed2012-02-19 23:45:44 -0700248 ret = pin_request(pctldev, pin, owner, range);
Stephen Warren5d2eaf82011-10-19 16:19:28 -0600249 if (ret < 0)
Stephen Warren3cc70ed2012-02-19 23:45:44 -0700250 kfree(owner);
Stephen Warren5d2eaf82011-10-19 16:19:28 -0600251
252 return ret;
Linus Walleij2744e8a2011-05-02 20:50:54 +0200253}
Linus Walleij2744e8a2011-05-02 20:50:54 +0200254
255/**
Linus Walleijbefe5bd2012-02-09 19:47:48 +0100256 * pinmux_free_gpio() - release a pin from GPIO muxing
257 * @pctldev: the pin controller device for the pin
258 * @pin: the affected currently GPIO-muxed in pin
259 * @range: applicable GPIO range
Linus Walleij2744e8a2011-05-02 20:50:54 +0200260 */
Linus Walleijbefe5bd2012-02-09 19:47:48 +0100261void pinmux_free_gpio(struct pinctrl_dev *pctldev, unsigned pin,
262 struct pinctrl_gpio_range *range)
Linus Walleij2744e8a2011-05-02 20:50:54 +0200263{
Stephen Warren3cc70ed2012-02-19 23:45:44 -0700264 const char *owner;
Linus Walleij2744e8a2011-05-02 20:50:54 +0200265
Stephen Warren3cc70ed2012-02-19 23:45:44 -0700266 owner = pin_free(pctldev, pin, range);
267 kfree(owner);
Linus Walleij2744e8a2011-05-02 20:50:54 +0200268}
Linus Walleij2744e8a2011-05-02 20:50:54 +0200269
Linus Walleijbefe5bd2012-02-09 19:47:48 +0100270/**
271 * pinmux_gpio_direction() - set the direction of a single muxed-in GPIO pin
272 * @pctldev: the pin controller handling this pin
273 * @range: applicable GPIO range
274 * @pin: the affected GPIO pin in this controller
275 * @input: true if we set the pin as input, false for output
276 */
277int pinmux_gpio_direction(struct pinctrl_dev *pctldev,
278 struct pinctrl_gpio_range *range,
279 unsigned pin, bool input)
Linus Walleij542e7042011-11-14 10:06:22 +0100280{
Linus Walleij542e7042011-11-14 10:06:22 +0100281 const struct pinmux_ops *ops;
282 int ret;
Linus Walleij542e7042011-11-14 10:06:22 +0100283
284 ops = pctldev->desc->pmxops;
285
Linus Walleij542e7042011-11-14 10:06:22 +0100286 if (ops->gpio_set_direction)
287 ret = ops->gpio_set_direction(pctldev, range, pin, input);
288 else
289 ret = 0;
290
291 return ret;
292}
293
Stephen Warren7ecdb162012-03-02 13:05:45 -0700294static int pinmux_func_name_to_selector(struct pinctrl_dev *pctldev,
295 const char *function)
Linus Walleij2744e8a2011-05-02 20:50:54 +0200296{
297 const struct pinmux_ops *ops = pctldev->desc->pmxops;
Viresh Kumard1e90e92012-03-30 11:25:40 +0530298 unsigned nfuncs = ops->get_functions_count(pctldev);
Linus Walleij2744e8a2011-05-02 20:50:54 +0200299 unsigned selector = 0;
300
301 /* See if this pctldev has this function */
Viresh Kumard1e90e92012-03-30 11:25:40 +0530302 while (selector < nfuncs) {
Linus Walleij2744e8a2011-05-02 20:50:54 +0200303 const char *fname = ops->get_function_name(pctldev,
304 selector);
Linus Walleij2744e8a2011-05-02 20:50:54 +0200305
Stephen Warren7ecdb162012-03-02 13:05:45 -0700306 if (!strcmp(function, fname))
307 return selector;
Linus Walleij2744e8a2011-05-02 20:50:54 +0200308
Linus Walleij2744e8a2011-05-02 20:50:54 +0200309 selector++;
310 }
311
312 pr_err("%s does not support function %s\n",
Stephen Warren7ecdb162012-03-02 13:05:45 -0700313 pinctrl_dev_get_name(pctldev), function);
Linus Walleij2744e8a2011-05-02 20:50:54 +0200314 return -EINVAL;
315}
316
Stephen Warren7ecdb162012-03-02 13:05:45 -0700317int pinmux_map_to_setting(struct pinctrl_map const *map,
318 struct pinctrl_setting *setting)
Linus Walleij2744e8a2011-05-02 20:50:54 +0200319{
Stephen Warren7ecdb162012-03-02 13:05:45 -0700320 struct pinctrl_dev *pctldev = setting->pctldev;
321 const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
Stephen Warren7ecdb162012-03-02 13:05:45 -0700322 char const * const *groups;
323 unsigned num_groups;
Linus Walleij2744e8a2011-05-02 20:50:54 +0200324 int ret;
Stephen Warren7ecdb162012-03-02 13:05:45 -0700325 const char *group;
326 int i;
Linus Walleij2744e8a2011-05-02 20:50:54 +0200327
Dong Aishengad8bb722012-04-10 12:41:34 +0800328 if (!pmxops) {
329 dev_err(pctldev->dev, "does not support mux function\n");
330 return -EINVAL;
331 }
332
John Crispin15f70e12012-04-23 19:01:58 +0200333 ret = pinmux_func_name_to_selector(pctldev, map->data.mux.function);
John Crispinad6e1102012-04-26 16:47:11 +0200334 if (ret < 0) {
335 dev_err(pctldev->dev, "invalid function %s in map table\n",
336 map->data.mux.function);
John Crispin15f70e12012-04-23 19:01:58 +0200337 return ret;
John Crispinad6e1102012-04-26 16:47:11 +0200338 }
John Crispin15f70e12012-04-23 19:01:58 +0200339 setting->data.mux.func = ret;
Linus Walleij2744e8a2011-05-02 20:50:54 +0200340
Stephen Warren1e2082b2012-03-02 13:05:48 -0700341 ret = pmxops->get_function_groups(pctldev, setting->data.mux.func,
Stephen Warren7ecdb162012-03-02 13:05:45 -0700342 &groups, &num_groups);
John Crispinad6e1102012-04-26 16:47:11 +0200343 if (ret < 0) {
344 dev_err(pctldev->dev, "can't query groups for function %s\n",
345 map->data.mux.function);
Linus Walleij2744e8a2011-05-02 20:50:54 +0200346 return ret;
John Crispinad6e1102012-04-26 16:47:11 +0200347 }
348 if (!num_groups) {
349 dev_err(pctldev->dev,
350 "function %s can't be selected on any group\n",
351 map->data.mux.function);
Stephen Warren7ecdb162012-03-02 13:05:45 -0700352 return -EINVAL;
John Crispinad6e1102012-04-26 16:47:11 +0200353 }
Stephen Warren1e2082b2012-03-02 13:05:48 -0700354 if (map->data.mux.group) {
Stephen Warren7ecdb162012-03-02 13:05:45 -0700355 bool found = false;
Stephen Warren1e2082b2012-03-02 13:05:48 -0700356 group = map->data.mux.group;
Stephen Warren7ecdb162012-03-02 13:05:45 -0700357 for (i = 0; i < num_groups; i++) {
358 if (!strcmp(group, groups[i])) {
359 found = true;
360 break;
361 }
362 }
John Crispinad6e1102012-04-26 16:47:11 +0200363 if (!found) {
364 dev_err(pctldev->dev,
365 "invalid group \"%s\" for function \"%s\"\n",
366 group, map->data.mux.function);
Stephen Warren7ecdb162012-03-02 13:05:45 -0700367 return -EINVAL;
John Crispinad6e1102012-04-26 16:47:11 +0200368 }
Stephen Warren7ecdb162012-03-02 13:05:45 -0700369 } else {
370 group = groups[0];
371 }
372
John Crispin15f70e12012-04-23 19:01:58 +0200373 ret = pinctrl_get_group_selector(pctldev, group);
John Crispinad6e1102012-04-26 16:47:11 +0200374 if (ret < 0) {
375 dev_err(pctldev->dev, "invalid group %s in map table\n",
376 map->data.mux.group);
John Crispin15f70e12012-04-23 19:01:58 +0200377 return ret;
John Crispinad6e1102012-04-26 16:47:11 +0200378 }
John Crispin15f70e12012-04-23 19:01:58 +0200379 setting->data.mux.group = ret;
Stephen Warren7ecdb162012-03-02 13:05:45 -0700380
Linus Walleij2744e8a2011-05-02 20:50:54 +0200381 return 0;
382}
383
Stephen Warren7ecdb162012-03-02 13:05:45 -0700384void pinmux_free_setting(struct pinctrl_setting const *setting)
Linus Walleijbefe5bd2012-02-09 19:47:48 +0100385{
Linus Walleij1a789582012-10-17 20:51:54 +0200386 /* This function is currently unused */
Linus Walleijbefe5bd2012-02-09 19:47:48 +0100387}
388
Stephen Warren7ecdb162012-03-02 13:05:45 -0700389int pinmux_enable_setting(struct pinctrl_setting const *setting)
Linus Walleij2744e8a2011-05-02 20:50:54 +0200390{
Stephen Warren7ecdb162012-03-02 13:05:45 -0700391 struct pinctrl_dev *pctldev = setting->pctldev;
Stephen Warrenba110d92012-03-02 13:05:49 -0700392 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
Linus Walleijbefe5bd2012-02-09 19:47:48 +0100393 const struct pinmux_ops *ops = pctldev->desc->pmxops;
Antoine Ténarte5b3b2d2014-04-10 15:07:50 +0200394 int ret = 0;
395 const unsigned *pins = NULL;
396 unsigned num_pins = 0;
Stephen Warrenba110d92012-03-02 13:05:49 -0700397 int i;
398 struct pin_desc *desc;
399
Antoine Ténarte5b3b2d2014-04-10 15:07:50 +0200400 if (pctlops->get_group_pins)
401 ret = pctlops->get_group_pins(pctldev, setting->data.mux.group,
402 &pins, &num_pins);
403
Stephen Warrenba110d92012-03-02 13:05:49 -0700404 if (ret) {
Linus Walleij1c8e7942013-08-14 18:23:33 +0200405 const char *gname;
406
Stephen Warrenba110d92012-03-02 13:05:49 -0700407 /* errors only affect debug data, so just warn */
Linus Walleij1c8e7942013-08-14 18:23:33 +0200408 gname = pctlops->get_group_name(pctldev,
409 setting->data.mux.group);
Stephen Warrenba110d92012-03-02 13:05:49 -0700410 dev_warn(pctldev->dev,
Linus Walleij1c8e7942013-08-14 18:23:33 +0200411 "could not get pins for group %s\n",
412 gname);
Stephen Warrenba110d92012-03-02 13:05:49 -0700413 num_pins = 0;
414 }
415
Linus Walleij1a789582012-10-17 20:51:54 +0200416 /* Try to allocate all pins in this group, one by one */
417 for (i = 0; i < num_pins; i++) {
418 ret = pin_request(pctldev, pins[i], setting->dev_name, NULL);
419 if (ret) {
Linus Walleij1c8e7942013-08-14 18:23:33 +0200420 const char *gname;
421 const char *pname;
422
423 desc = pin_desc_get(pctldev, pins[i]);
424 pname = desc ? desc->name : "non-existing";
425 gname = pctlops->get_group_name(pctldev,
426 setting->data.mux.group);
Linus Walleij1a789582012-10-17 20:51:54 +0200427 dev_err(pctldev->dev,
Linus Walleij1c8e7942013-08-14 18:23:33 +0200428 "could not request pin %d (%s) from group %s "
429 " on device %s\n",
430 pins[i], pname, gname,
431 pinctrl_dev_get_name(pctldev));
Axel Line38d4572012-11-10 21:53:20 +0800432 goto err_pin_request;
Linus Walleij1a789582012-10-17 20:51:54 +0200433 }
434 }
435
436 /* Now that we have acquired the pins, encode the mux setting */
Stephen Warrenba110d92012-03-02 13:05:49 -0700437 for (i = 0; i < num_pins; i++) {
438 desc = pin_desc_get(pctldev, pins[i]);
439 if (desc == NULL) {
440 dev_warn(pctldev->dev,
441 "could not get pin desc for pin %d\n",
442 pins[i]);
443 continue;
444 }
445 desc->mux_setting = &(setting->data.mux);
446 }
Linus Walleij2744e8a2011-05-02 20:50:54 +0200447
Axel Line38d4572012-11-10 21:53:20 +0800448 ret = ops->enable(pctldev, setting->data.mux.func,
449 setting->data.mux.group);
450
451 if (ret)
452 goto err_enable;
453
454 return 0;
455
456err_enable:
457 for (i = 0; i < num_pins; i++) {
458 desc = pin_desc_get(pctldev, pins[i]);
459 if (desc)
460 desc->mux_setting = NULL;
461 }
462err_pin_request:
463 /* On error release all taken pins */
464 while (--i >= 0)
465 pin_free(pctldev, pins[i], NULL);
466
467 return ret;
Linus Walleij2744e8a2011-05-02 20:50:54 +0200468}
Linus Walleij2744e8a2011-05-02 20:50:54 +0200469
Stephen Warren7ecdb162012-03-02 13:05:45 -0700470void pinmux_disable_setting(struct pinctrl_setting const *setting)
Linus Walleij2744e8a2011-05-02 20:50:54 +0200471{
Stephen Warren7ecdb162012-03-02 13:05:45 -0700472 struct pinctrl_dev *pctldev = setting->pctldev;
Stephen Warrenba110d92012-03-02 13:05:49 -0700473 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
Linus Walleijbefe5bd2012-02-09 19:47:48 +0100474 const struct pinmux_ops *ops = pctldev->desc->pmxops;
Antoine Ténarte5b3b2d2014-04-10 15:07:50 +0200475 int ret = 0;
476 const unsigned *pins = NULL;
477 unsigned num_pins = 0;
Stephen Warrenba110d92012-03-02 13:05:49 -0700478 int i;
479 struct pin_desc *desc;
480
Antoine Ténarte5b3b2d2014-04-10 15:07:50 +0200481 if (pctlops->get_group_pins)
482 ret = pctlops->get_group_pins(pctldev, setting->data.mux.group,
483 &pins, &num_pins);
Stephen Warrenba110d92012-03-02 13:05:49 -0700484 if (ret) {
Linus Walleij1c8e7942013-08-14 18:23:33 +0200485 const char *gname;
486
Stephen Warrenba110d92012-03-02 13:05:49 -0700487 /* errors only affect debug data, so just warn */
Linus Walleij1c8e7942013-08-14 18:23:33 +0200488 gname = pctlops->get_group_name(pctldev,
489 setting->data.mux.group);
Stephen Warrenba110d92012-03-02 13:05:49 -0700490 dev_warn(pctldev->dev,
Linus Walleij1c8e7942013-08-14 18:23:33 +0200491 "could not get pins for group %s\n",
492 gname);
Stephen Warrenba110d92012-03-02 13:05:49 -0700493 num_pins = 0;
494 }
495
Linus Walleij1a789582012-10-17 20:51:54 +0200496 /* Flag the descs that no setting is active */
Stephen Warrenba110d92012-03-02 13:05:49 -0700497 for (i = 0; i < num_pins; i++) {
498 desc = pin_desc_get(pctldev, pins[i]);
499 if (desc == NULL) {
500 dev_warn(pctldev->dev,
501 "could not get pin desc for pin %d\n",
502 pins[i]);
503 continue;
504 }
Sonic Zhang744f0a92013-08-14 13:26:43 +0800505 if (desc->mux_setting == &(setting->data.mux)) {
506 desc->mux_setting = NULL;
507 /* And release the pin */
508 pin_free(pctldev, pins[i], NULL);
Linus Walleij1c8e7942013-08-14 18:23:33 +0200509 } else {
510 const char *gname;
Linus Walleij1c8e7942013-08-14 18:23:33 +0200511
Linus Walleij1c8e7942013-08-14 18:23:33 +0200512 gname = pctlops->get_group_name(pctldev,
513 setting->data.mux.group);
514 dev_warn(pctldev->dev,
515 "not freeing pin %d (%s) as part of "
516 "deactivating group %s - it is already "
517 "used for some other setting",
Michael Opdenacker808e6572013-10-29 04:50:45 +0100518 pins[i], desc->name, gname);
Sonic Zhang744f0a92013-08-14 13:26:43 +0800519 }
Stephen Warrenba110d92012-03-02 13:05:49 -0700520 }
Linus Walleij2744e8a2011-05-02 20:50:54 +0200521
Dong Aisheng02b50ce2012-05-14 19:06:37 +0800522 if (ops->disable)
523 ops->disable(pctldev, setting->data.mux.func, setting->data.mux.group);
Linus Walleij2744e8a2011-05-02 20:50:54 +0200524}
Linus Walleij2744e8a2011-05-02 20:50:54 +0200525
Linus Walleij2744e8a2011-05-02 20:50:54 +0200526#ifdef CONFIG_DEBUG_FS
527
528/* Called from pincontrol core */
529static int pinmux_functions_show(struct seq_file *s, void *what)
530{
531 struct pinctrl_dev *pctldev = s->private;
532 const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
Dong Aishengad8bb722012-04-10 12:41:34 +0800533 unsigned nfuncs;
Linus Walleij2744e8a2011-05-02 20:50:54 +0200534 unsigned func_selector = 0;
535
Dong Aishengad8bb722012-04-10 12:41:34 +0800536 if (!pmxops)
537 return 0;
Stephen Warren57b676f2012-03-02 13:05:44 -0700538
Patrice Chotard42fed7b2013-04-11 11:01:27 +0200539 mutex_lock(&pctldev->mutex);
Dong Aishengad8bb722012-04-10 12:41:34 +0800540 nfuncs = pmxops->get_functions_count(pctldev);
Viresh Kumard1e90e92012-03-30 11:25:40 +0530541 while (func_selector < nfuncs) {
Linus Walleij2744e8a2011-05-02 20:50:54 +0200542 const char *func = pmxops->get_function_name(pctldev,
543 func_selector);
544 const char * const *groups;
545 unsigned num_groups;
546 int ret;
547 int i;
548
549 ret = pmxops->get_function_groups(pctldev, func_selector,
550 &groups, &num_groups);
551 if (ret)
552 seq_printf(s, "function %s: COULD NOT GET GROUPS\n",
553 func);
554
555 seq_printf(s, "function: %s, groups = [ ", func);
556 for (i = 0; i < num_groups; i++)
557 seq_printf(s, "%s ", groups[i]);
558 seq_puts(s, "]\n");
559
560 func_selector++;
Linus Walleij2744e8a2011-05-02 20:50:54 +0200561 }
562
Patrice Chotard42fed7b2013-04-11 11:01:27 +0200563 mutex_unlock(&pctldev->mutex);
Stephen Warren57b676f2012-03-02 13:05:44 -0700564
Linus Walleij2744e8a2011-05-02 20:50:54 +0200565 return 0;
566}
567
568static int pinmux_pins_show(struct seq_file *s, void *what)
569{
570 struct pinctrl_dev *pctldev = s->private;
Stephen Warrenba110d92012-03-02 13:05:49 -0700571 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
572 const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
Chanho Park706e8522012-01-03 16:47:50 +0900573 unsigned i, pin;
Linus Walleij2744e8a2011-05-02 20:50:54 +0200574
Dong Aishengad8bb722012-04-10 12:41:34 +0800575 if (!pmxops)
576 return 0;
577
Linus Walleij2744e8a2011-05-02 20:50:54 +0200578 seq_puts(s, "Pinmux settings per pin\n");
Stephen Warren652162d2012-03-05 17:22:15 -0700579 seq_puts(s, "Format: pin (name): mux_owner gpio_owner hog?\n");
Linus Walleij2744e8a2011-05-02 20:50:54 +0200580
Patrice Chotard42fed7b2013-04-11 11:01:27 +0200581 mutex_lock(&pctldev->mutex);
Stephen Warren57b676f2012-03-02 13:05:44 -0700582
Chanho Park706e8522012-01-03 16:47:50 +0900583 /* The pin number can be retrived from the pin controller descriptor */
584 for (i = 0; i < pctldev->desc->npins; i++) {
Linus Walleij2744e8a2011-05-02 20:50:54 +0200585 struct pin_desc *desc;
Linus Walleij1cf94c42012-02-24 06:53:04 +0100586 bool is_hog = false;
Linus Walleij2744e8a2011-05-02 20:50:54 +0200587
Chanho Park706e8522012-01-03 16:47:50 +0900588 pin = pctldev->desc->pins[i].number;
Linus Walleij2744e8a2011-05-02 20:50:54 +0200589 desc = pin_desc_get(pctldev, pin);
Chanho Park706e8522012-01-03 16:47:50 +0900590 /* Skip if we cannot search the pin */
Linus Walleij2744e8a2011-05-02 20:50:54 +0200591 if (desc == NULL)
592 continue;
593
Stephen Warren652162d2012-03-05 17:22:15 -0700594 if (desc->mux_owner &&
595 !strcmp(desc->mux_owner, pinctrl_dev_get_name(pctldev)))
Linus Walleij1cf94c42012-02-24 06:53:04 +0100596 is_hog = true;
597
Stephen Warren652162d2012-03-05 17:22:15 -0700598 seq_printf(s, "pin %d (%s): %s %s%s", pin,
Linus Walleij2744e8a2011-05-02 20:50:54 +0200599 desc->name ? desc->name : "unnamed",
Stephen Warren652162d2012-03-05 17:22:15 -0700600 desc->mux_owner ? desc->mux_owner
601 : "(MUX UNCLAIMED)",
602 desc->gpio_owner ? desc->gpio_owner
603 : "(GPIO UNCLAIMED)",
Linus Walleij1cf94c42012-02-24 06:53:04 +0100604 is_hog ? " (HOG)" : "");
Stephen Warrenba110d92012-03-02 13:05:49 -0700605
606 if (desc->mux_setting)
607 seq_printf(s, " function %s group %s\n",
608 pmxops->get_function_name(pctldev,
609 desc->mux_setting->func),
610 pctlops->get_group_name(pctldev,
611 desc->mux_setting->group));
612 else
613 seq_printf(s, "\n");
Linus Walleij2744e8a2011-05-02 20:50:54 +0200614 }
615
Patrice Chotard42fed7b2013-04-11 11:01:27 +0200616 mutex_unlock(&pctldev->mutex);
Stephen Warren57b676f2012-03-02 13:05:44 -0700617
Linus Walleij2744e8a2011-05-02 20:50:54 +0200618 return 0;
619}
620
Stephen Warren1e2082b2012-03-02 13:05:48 -0700621void pinmux_show_map(struct seq_file *s, struct pinctrl_map const *map)
622{
623 seq_printf(s, "group %s\nfunction %s\n",
624 map->data.mux.group ? map->data.mux.group : "(default)",
625 map->data.mux.function);
626}
627
628void pinmux_show_setting(struct seq_file *s,
629 struct pinctrl_setting const *setting)
Linus Walleij2744e8a2011-05-02 20:50:54 +0200630{
Stephen Warren7ecdb162012-03-02 13:05:45 -0700631 struct pinctrl_dev *pctldev = setting->pctldev;
632 const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
633 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
Linus Walleij2744e8a2011-05-02 20:50:54 +0200634
Stephen Warren1e2082b2012-03-02 13:05:48 -0700635 seq_printf(s, "group: %s (%u) function: %s (%u)\n",
636 pctlops->get_group_name(pctldev, setting->data.mux.group),
637 setting->data.mux.group,
638 pmxops->get_function_name(pctldev, setting->data.mux.func),
639 setting->data.mux.func);
Linus Walleij2744e8a2011-05-02 20:50:54 +0200640}
641
642static int pinmux_functions_open(struct inode *inode, struct file *file)
643{
644 return single_open(file, pinmux_functions_show, inode->i_private);
645}
646
647static int pinmux_pins_open(struct inode *inode, struct file *file)
648{
649 return single_open(file, pinmux_pins_show, inode->i_private);
650}
651
Linus Walleij2744e8a2011-05-02 20:50:54 +0200652static const struct file_operations pinmux_functions_ops = {
653 .open = pinmux_functions_open,
654 .read = seq_read,
655 .llseek = seq_lseek,
656 .release = single_release,
657};
658
659static const struct file_operations pinmux_pins_ops = {
660 .open = pinmux_pins_open,
661 .read = seq_read,
662 .llseek = seq_lseek,
663 .release = single_release,
664};
665
Linus Walleij2744e8a2011-05-02 20:50:54 +0200666void pinmux_init_device_debugfs(struct dentry *devroot,
667 struct pinctrl_dev *pctldev)
668{
669 debugfs_create_file("pinmux-functions", S_IFREG | S_IRUGO,
670 devroot, pctldev, &pinmux_functions_ops);
671 debugfs_create_file("pinmux-pins", S_IFREG | S_IRUGO,
672 devroot, pctldev, &pinmux_pins_ops);
Linus Walleij2744e8a2011-05-02 20:50:54 +0200673}
674
675#endif /* CONFIG_DEBUG_FS */