1/*
2 * Core driver for the pin muxing portions of the pin control subsystem
3 *
4 * Copyright (C) 2011-2012 ST-Ericsson SA
5 * 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 *
10 * Copyright (C) 2012 NVIDIA CORPORATION. All rights reserved.
11 *
12 * 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>
24#include <linux/string.h>
25#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"
31#include "pinmux.h"
32
33int pinmux_check_ops(struct pinctrl_dev *pctldev)
34{
35	const struct pinmux_ops *ops = pctldev->desc->pmxops;
36	unsigned nfuncs;
37	unsigned selector = 0;
38
39	/* Check that we implement required operations */
40	if (!ops ||
41	    !ops->get_functions_count ||
42	    !ops->get_function_name ||
43	    !ops->get_function_groups ||
44	    !ops->set_mux) {
45		dev_err(pctldev->dev, "pinmux ops lacks necessary functions\n");
46		return -EINVAL;
47	}
48	/* Check that all functions registered have names */
49	nfuncs = ops->get_functions_count(pctldev);
50	while (selector < nfuncs) {
51		const char *fname = ops->get_function_name(pctldev,
52							   selector);
53		if (!fname) {
54			dev_err(pctldev->dev, "pinmux ops has no name for function%u\n",
55				selector);
56			return -EINVAL;
57		}
58		selector++;
59	}
60
61	return 0;
62}
63
64int 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
75/**
76 * pin_request() - request a single pin to be muxed in, typically for GPIO
77 * @pin: the pin number in the global pin space
78 * @owner: a representation of the owner of this pin; typically the device
79 *	name that controls its mux function, or the requested GPIO name
80 * @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,
84		       int pin, const char *owner,
85		       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
91	desc = pin_desc_get(pctldev, pin);
92	if (desc == NULL) {
93		dev_err(pctldev->dev,
94			"pin %d is not registered so it cannot be requested\n",
95			pin);
96		goto out;
97	}
98
99	dev_dbg(pctldev->dev, "request pin %d (%s) for %s\n",
100		pin, desc->name, owner);
101
102	if (gpio_range) {
103		/* There's no need to support multiple GPIO requests */
104		if (desc->gpio_owner) {
105			dev_err(pctldev->dev,
106				"pin %s already requested by %s; cannot claim for %s\n",
107				desc->name, desc->gpio_owner, owner);
108			goto out;
109		}
110		if (ops->strict && desc->mux_usecount &&
111		    strcmp(desc->mux_owner, owner)) {
112			dev_err(pctldev->dev,
113				"pin %s already requested by %s; cannot claim for %s\n",
114				desc->name, desc->mux_owner, owner);
115			goto out;
116		}
117
118		desc->gpio_owner = owner;
119	} else {
120		if (desc->mux_usecount && strcmp(desc->mux_owner, owner)) {
121			dev_err(pctldev->dev,
122				"pin %s already requested by %s; cannot claim for %s\n",
123				desc->name, desc->mux_owner, owner);
124			goto out;
125		}
126		if (ops->strict && desc->gpio_owner) {
127			dev_err(pctldev->dev,
128				"pin %s already requested by %s; cannot claim for %s\n",
129				desc->name, desc->gpio_owner, owner);
130			goto out;
131		}
132
133		desc->mux_usecount++;
134		if (desc->mux_usecount > 1)
135			return 0;
136
137		desc->mux_owner = owner;
138	}
139
140	/* Let each pin increase references to this module */
141	if (!try_module_get(pctldev->owner)) {
142		dev_err(pctldev->dev,
143			"could not increase module refcount for pin %d\n",
144			pin);
145		status = -EINVAL;
146		goto out_free_pin;
147	}
148
149	/*
150	 * If there is no kind of request function for the pin we just assume
151	 * we got it by default and proceed.
152	 */
153	if (gpio_range && ops->gpio_request_enable)
154		/* This requests and enables a single GPIO pin */
155		status = ops->gpio_request_enable(pctldev, gpio_range, pin);
156	else if (ops->request)
157		status = ops->request(pctldev, pin);
158	else
159		status = 0;
160
161	if (status) {
162		dev_err(pctldev->dev, "request() failed for pin %d\n", pin);
163		module_put(pctldev->owner);
164	}
165
166out_free_pin:
167	if (status) {
168		if (gpio_range) {
169			desc->gpio_owner = NULL;
170		} else {
171			desc->mux_usecount--;
172			if (!desc->mux_usecount)
173				desc->mux_owner = NULL;
174		}
175	}
176out:
177	if (status)
178		dev_err(pctldev->dev, "pin-%d (%s) status %d\n",
179			pin, owner, status);
180
181	return status;
182}
183
184/**
185 * pin_free() - release a single muxed in pin so something else can be muxed
186 * @pctldev: pin controller device handling this pin
187 * @pin: the pin to free
188 * @gpio_range: the range matching the GPIO pin if this is a request for a
189 *	single GPIO pin
190 *
191 * This function returns a pointer to the previous owner. This is used
192 * for callers that dynamically allocate an owner name so it can be freed
193 * once the pin is free. This is done for GPIO request functions.
194 */
195static const char *pin_free(struct pinctrl_dev *pctldev, int pin,
196			    struct pinctrl_gpio_range *gpio_range)
197{
198	const struct pinmux_ops *ops = pctldev->desc->pmxops;
199	struct pin_desc *desc;
200	const char *owner;
201
202	desc = pin_desc_get(pctldev, pin);
203	if (desc == NULL) {
204		dev_err(pctldev->dev,
205			"pin is not registered so it cannot be freed\n");
206		return NULL;
207	}
208
209	if (!gpio_range) {
210		/*
211		 * A pin should not be freed more times than allocated.
212		 */
213		if (WARN_ON(!desc->mux_usecount))
214			return NULL;
215		desc->mux_usecount--;
216		if (desc->mux_usecount)
217			return NULL;
218	}
219
220	/*
221	 * If there is no kind of request function for the pin we just assume
222	 * we got it by default and proceed.
223	 */
224	if (gpio_range && ops->gpio_disable_free)
225		ops->gpio_disable_free(pctldev, gpio_range, pin);
226	else if (ops->free)
227		ops->free(pctldev, pin);
228
229	if (gpio_range) {
230		owner = desc->gpio_owner;
231		desc->gpio_owner = NULL;
232	} else {
233		owner = desc->mux_owner;
234		desc->mux_owner = NULL;
235		desc->mux_setting = NULL;
236	}
237
238	module_put(pctldev->owner);
239
240	return owner;
241}
242
243/**
244 * pinmux_request_gpio() - request pinmuxing for a GPIO pin
245 * @pctldev: pin controller device affected
246 * @pin: the pin to mux in for GPIO
247 * @range: the applicable GPIO range
248 */
249int pinmux_request_gpio(struct pinctrl_dev *pctldev,
250			struct pinctrl_gpio_range *range,
251			unsigned pin, unsigned gpio)
252{
253	const char *owner;
254	int ret;
255
256	/* Conjure some name stating what chip and pin this is taken by */
257	owner = kasprintf(GFP_KERNEL, "%s:%d", range->name, gpio);
258	if (!owner)
259		return -EINVAL;
260
261	ret = pin_request(pctldev, pin, owner, range);
262	if (ret < 0)
263		kfree(owner);
264
265	return ret;
266}
267
268/**
269 * pinmux_free_gpio() - release a pin from GPIO muxing
270 * @pctldev: the pin controller device for the pin
271 * @pin: the affected currently GPIO-muxed in pin
272 * @range: applicable GPIO range
273 */
274void pinmux_free_gpio(struct pinctrl_dev *pctldev, unsigned pin,
275		      struct pinctrl_gpio_range *range)
276{
277	const char *owner;
278
279	owner = pin_free(pctldev, pin, range);
280	kfree(owner);
281}
282
283/**
284 * pinmux_gpio_direction() - set the direction of a single muxed-in GPIO pin
285 * @pctldev: the pin controller handling this pin
286 * @range: applicable GPIO range
287 * @pin: the affected GPIO pin in this controller
288 * @input: true if we set the pin as input, false for output
289 */
290int pinmux_gpio_direction(struct pinctrl_dev *pctldev,
291			  struct pinctrl_gpio_range *range,
292			  unsigned pin, bool input)
293{
294	const struct pinmux_ops *ops;
295	int ret;
296
297	ops = pctldev->desc->pmxops;
298
299	if (ops->gpio_set_direction)
300		ret = ops->gpio_set_direction(pctldev, range, pin, input);
301	else
302		ret = 0;
303
304	return ret;
305}
306
307static int pinmux_func_name_to_selector(struct pinctrl_dev *pctldev,
308					const char *function)
309{
310	const struct pinmux_ops *ops = pctldev->desc->pmxops;
311	unsigned nfuncs = ops->get_functions_count(pctldev);
312	unsigned selector = 0;
313
314	/* See if this pctldev has this function */
315	while (selector < nfuncs) {
316		const char *fname = ops->get_function_name(pctldev, selector);
317
318		if (!strcmp(function, fname))
319			return selector;
320
321		selector++;
322	}
323
324	dev_err(pctldev->dev, "function '%s' not supported\n", function);
325	return -EINVAL;
326}
327
328int pinmux_map_to_setting(struct pinctrl_map const *map,
329			  struct pinctrl_setting *setting)
330{
331	struct pinctrl_dev *pctldev = setting->pctldev;
332	const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
333	char const * const *groups;
334	unsigned num_groups;
335	int ret;
336	const char *group;
337	int i;
338
339	if (!pmxops) {
340		dev_err(pctldev->dev, "does not support mux function\n");
341		return -EINVAL;
342	}
343
344	ret = pinmux_func_name_to_selector(pctldev, map->data.mux.function);
345	if (ret < 0) {
346		dev_err(pctldev->dev, "invalid function %s in map table\n",
347			map->data.mux.function);
348		return ret;
349	}
350	setting->data.mux.func = ret;
351
352	ret = pmxops->get_function_groups(pctldev, setting->data.mux.func,
353					  &groups, &num_groups);
354	if (ret < 0) {
355		dev_err(pctldev->dev, "can't query groups for function %s\n",
356			map->data.mux.function);
357		return ret;
358	}
359	if (!num_groups) {
360		dev_err(pctldev->dev,
361			"function %s can't be selected on any group\n",
362			map->data.mux.function);
363		return -EINVAL;
364	}
365	if (map->data.mux.group) {
366		bool found = false;
367		group = map->data.mux.group;
368		for (i = 0; i < num_groups; i++) {
369			if (!strcmp(group, groups[i])) {
370				found = true;
371				break;
372			}
373		}
374		if (!found) {
375			dev_err(pctldev->dev,
376				"invalid group \"%s\" for function \"%s\"\n",
377				group, map->data.mux.function);
378			return -EINVAL;
379		}
380	} else {
381		group = groups[0];
382	}
383
384	ret = pinctrl_get_group_selector(pctldev, group);
385	if (ret < 0) {
386		dev_err(pctldev->dev, "invalid group %s in map table\n",
387			map->data.mux.group);
388		return ret;
389	}
390	setting->data.mux.group = ret;
391
392	return 0;
393}
394
395void pinmux_free_setting(struct pinctrl_setting const *setting)
396{
397	/* This function is currently unused */
398}
399
400int pinmux_enable_setting(struct pinctrl_setting const *setting)
401{
402	struct pinctrl_dev *pctldev = setting->pctldev;
403	const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
404	const struct pinmux_ops *ops = pctldev->desc->pmxops;
405	int ret = 0;
406	const unsigned *pins = NULL;
407	unsigned num_pins = 0;
408	int i;
409	struct pin_desc *desc;
410
411	if (pctlops->get_group_pins)
412		ret = pctlops->get_group_pins(pctldev, setting->data.mux.group,
413					      &pins, &num_pins);
414
415	if (ret) {
416		const char *gname;
417
418		/* errors only affect debug data, so just warn */
419		gname = pctlops->get_group_name(pctldev,
420						setting->data.mux.group);
421		dev_warn(pctldev->dev,
422			 "could not get pins for group %s\n",
423			 gname);
424		num_pins = 0;
425	}
426
427	/* Try to allocate all pins in this group, one by one */
428	for (i = 0; i < num_pins; i++) {
429		ret = pin_request(pctldev, pins[i], setting->dev_name, NULL);
430		if (ret) {
431			const char *gname;
432			const char *pname;
433
434			desc = pin_desc_get(pctldev, pins[i]);
435			pname = desc ? desc->name : "non-existing";
436			gname = pctlops->get_group_name(pctldev,
437						setting->data.mux.group);
438			dev_err(pctldev->dev,
439				"could not request pin %d (%s) from group %s "
440				" on device %s\n",
441				pins[i], pname, gname,
442				pinctrl_dev_get_name(pctldev));
443			goto err_pin_request;
444		}
445	}
446
447	/* Now that we have acquired the pins, encode the mux setting */
448	for (i = 0; i < num_pins; i++) {
449		desc = pin_desc_get(pctldev, pins[i]);
450		if (desc == NULL) {
451			dev_warn(pctldev->dev,
452				 "could not get pin desc for pin %d\n",
453				 pins[i]);
454			continue;
455		}
456		desc->mux_setting = &(setting->data.mux);
457	}
458
459	ret = ops->set_mux(pctldev, setting->data.mux.func,
460			   setting->data.mux.group);
461
462	if (ret)
463		goto err_set_mux;
464
465	return 0;
466
467err_set_mux:
468	for (i = 0; i < num_pins; i++) {
469		desc = pin_desc_get(pctldev, pins[i]);
470		if (desc)
471			desc->mux_setting = NULL;
472	}
473err_pin_request:
474	/* On error release all taken pins */
475	while (--i >= 0)
476		pin_free(pctldev, pins[i], NULL);
477
478	return ret;
479}
480
481void pinmux_disable_setting(struct pinctrl_setting const *setting)
482{
483	struct pinctrl_dev *pctldev = setting->pctldev;
484	const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
485	int ret = 0;
486	const unsigned *pins = NULL;
487	unsigned num_pins = 0;
488	int i;
489	struct pin_desc *desc;
490
491	if (pctlops->get_group_pins)
492		ret = pctlops->get_group_pins(pctldev, setting->data.mux.group,
493					      &pins, &num_pins);
494	if (ret) {
495		const char *gname;
496
497		/* errors only affect debug data, so just warn */
498		gname = pctlops->get_group_name(pctldev,
499						setting->data.mux.group);
500		dev_warn(pctldev->dev,
501			 "could not get pins for group %s\n",
502			 gname);
503		num_pins = 0;
504	}
505
506	/* Flag the descs that no setting is active */
507	for (i = 0; i < num_pins; i++) {
508		desc = pin_desc_get(pctldev, pins[i]);
509		if (desc == NULL) {
510			dev_warn(pctldev->dev,
511				 "could not get pin desc for pin %d\n",
512				 pins[i]);
513			continue;
514		}
515		if (desc->mux_setting == &(setting->data.mux)) {
516			desc->mux_setting = NULL;
517			/* And release the pin */
518			pin_free(pctldev, pins[i], NULL);
519		} else {
520			const char *gname;
521
522			gname = pctlops->get_group_name(pctldev,
523						setting->data.mux.group);
524			dev_warn(pctldev->dev,
525				 "not freeing pin %d (%s) as part of "
526				 "deactivating group %s - it is already "
527				 "used for some other setting",
528				 pins[i], desc->name, gname);
529		}
530	}
531}
532
533#ifdef CONFIG_DEBUG_FS
534
535/* Called from pincontrol core */
536static int pinmux_functions_show(struct seq_file *s, void *what)
537{
538	struct pinctrl_dev *pctldev = s->private;
539	const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
540	unsigned nfuncs;
541	unsigned func_selector = 0;
542
543	if (!pmxops)
544		return 0;
545
546	mutex_lock(&pctldev->mutex);
547	nfuncs = pmxops->get_functions_count(pctldev);
548	while (func_selector < nfuncs) {
549		const char *func = pmxops->get_function_name(pctldev,
550							  func_selector);
551		const char * const *groups;
552		unsigned num_groups;
553		int ret;
554		int i;
555
556		ret = pmxops->get_function_groups(pctldev, func_selector,
557						  &groups, &num_groups);
558		if (ret) {
559			seq_printf(s, "function %s: COULD NOT GET GROUPS\n",
560				   func);
561			func_selector++;
562			continue;
563		}
564
565		seq_printf(s, "function: %s, groups = [ ", func);
566		for (i = 0; i < num_groups; i++)
567			seq_printf(s, "%s ", groups[i]);
568		seq_puts(s, "]\n");
569
570		func_selector++;
571	}
572
573	mutex_unlock(&pctldev->mutex);
574
575	return 0;
576}
577
578static int pinmux_pins_show(struct seq_file *s, void *what)
579{
580	struct pinctrl_dev *pctldev = s->private;
581	const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
582	const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
583	unsigned i, pin;
584
585	if (!pmxops)
586		return 0;
587
588	seq_puts(s, "Pinmux settings per pin\n");
589	if (pmxops->strict)
590		seq_puts(s,
591		 "Format: pin (name): mux_owner|gpio_owner (strict) hog?\n");
592	else
593		seq_puts(s,
594		"Format: pin (name): mux_owner gpio_owner hog?\n");
595
596	mutex_lock(&pctldev->mutex);
597
598	/* The pin number can be retrived from the pin controller descriptor */
599	for (i = 0; i < pctldev->desc->npins; i++) {
600		struct pin_desc *desc;
601		bool is_hog = false;
602
603		pin = pctldev->desc->pins[i].number;
604		desc = pin_desc_get(pctldev, pin);
605		/* Skip if we cannot search the pin */
606		if (desc == NULL)
607			continue;
608
609		if (desc->mux_owner &&
610		    !strcmp(desc->mux_owner, pinctrl_dev_get_name(pctldev)))
611			is_hog = true;
612
613		if (pmxops->strict) {
614			if (desc->mux_owner)
615				seq_printf(s, "pin %d (%s): device %s%s",
616					   pin,
617					   desc->name ? desc->name : "unnamed",
618					   desc->mux_owner,
619					   is_hog ? " (HOG)" : "");
620			else if (desc->gpio_owner)
621				seq_printf(s, "pin %d (%s): GPIO %s",
622					   pin,
623					   desc->name ? desc->name : "unnamed",
624					   desc->gpio_owner);
625			else
626				seq_printf(s, "pin %d (%s): UNCLAIMED",
627					   pin,
628					   desc->name ? desc->name : "unnamed");
629		} else {
630			/* For non-strict controllers */
631			seq_printf(s, "pin %d (%s): %s %s%s", pin,
632				   desc->name ? desc->name : "unnamed",
633				   desc->mux_owner ? desc->mux_owner
634				   : "(MUX UNCLAIMED)",
635				   desc->gpio_owner ? desc->gpio_owner
636				   : "(GPIO UNCLAIMED)",
637				   is_hog ? " (HOG)" : "");
638		}
639
640		/* If mux: print function+group claiming the pin */
641		if (desc->mux_setting)
642			seq_printf(s, " function %s group %s\n",
643				   pmxops->get_function_name(pctldev,
644					desc->mux_setting->func),
645				   pctlops->get_group_name(pctldev,
646					desc->mux_setting->group));
647		else
648			seq_printf(s, "\n");
649	}
650
651	mutex_unlock(&pctldev->mutex);
652
653	return 0;
654}
655
656void pinmux_show_map(struct seq_file *s, struct pinctrl_map const *map)
657{
658	seq_printf(s, "group %s\nfunction %s\n",
659		map->data.mux.group ? map->data.mux.group : "(default)",
660		map->data.mux.function);
661}
662
663void pinmux_show_setting(struct seq_file *s,
664			 struct pinctrl_setting const *setting)
665{
666	struct pinctrl_dev *pctldev = setting->pctldev;
667	const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
668	const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
669
670	seq_printf(s, "group: %s (%u) function: %s (%u)\n",
671		   pctlops->get_group_name(pctldev, setting->data.mux.group),
672		   setting->data.mux.group,
673		   pmxops->get_function_name(pctldev, setting->data.mux.func),
674		   setting->data.mux.func);
675}
676
677static int pinmux_functions_open(struct inode *inode, struct file *file)
678{
679	return single_open(file, pinmux_functions_show, inode->i_private);
680}
681
682static int pinmux_pins_open(struct inode *inode, struct file *file)
683{
684	return single_open(file, pinmux_pins_show, inode->i_private);
685}
686
687static const struct file_operations pinmux_functions_ops = {
688	.open		= pinmux_functions_open,
689	.read		= seq_read,
690	.llseek		= seq_lseek,
691	.release	= single_release,
692};
693
694static const struct file_operations pinmux_pins_ops = {
695	.open		= pinmux_pins_open,
696	.read		= seq_read,
697	.llseek		= seq_lseek,
698	.release	= single_release,
699};
700
701void pinmux_init_device_debugfs(struct dentry *devroot,
702			 struct pinctrl_dev *pctldev)
703{
704	debugfs_create_file("pinmux-functions", S_IFREG | S_IRUGO,
705			    devroot, pctldev, &pinmux_functions_ops);
706	debugfs_create_file("pinmux-pins", S_IFREG | S_IRUGO,
707			    devroot, pctldev, &pinmux_pins_ops);
708}
709
710#endif /* CONFIG_DEBUG_FS */
711