1/*
2 * Core driver for the pin config portions of the pin control subsystem
3 *
4 * Copyright (C) 2011 ST-Ericsson SA
5 * Written on behalf of Linaro for ST-Ericsson
6 *
7 * Author: Linus Walleij <linus.walleij@linaro.org>
8 *
9 * License terms: GNU General Public License (GPL) version 2
10 */
11#define pr_fmt(fmt) "pinconfig core: " fmt
12
13#include <linux/kernel.h>
14#include <linux/module.h>
15#include <linux/init.h>
16#include <linux/device.h>
17#include <linux/slab.h>
18#include <linux/debugfs.h>
19#include <linux/seq_file.h>
20#include <linux/pinctrl/machine.h>
21#include <linux/pinctrl/pinctrl.h>
22#include <linux/pinctrl/pinconf.h>
23#include "core.h"
24#include "pinconf.h"
25
26int pinconf_check_ops(struct pinctrl_dev *pctldev)
27{
28	const struct pinconf_ops *ops = pctldev->desc->confops;
29
30	/* We must be able to read out pin status */
31	if (!ops->pin_config_get && !ops->pin_config_group_get)
32		return -EINVAL;
33	/* We have to be able to config the pins in SOME way */
34	if (!ops->pin_config_set && !ops->pin_config_group_set)
35		return -EINVAL;
36	return 0;
37}
38
39int pinconf_validate_map(struct pinctrl_map const *map, int i)
40{
41	if (!map->data.configs.group_or_pin) {
42		pr_err("failed to register map %s (%d): no group/pin given\n",
43		       map->name, i);
44		return -EINVAL;
45	}
46
47	if (map->data.configs.num_configs &&
48			!map->data.configs.configs) {
49		pr_err("failed to register map %s (%d): no configs ptr given\n",
50		       map->name, i);
51		return -EINVAL;
52	}
53
54	return 0;
55}
56
57int pin_config_get_for_pin(struct pinctrl_dev *pctldev, unsigned pin,
58			   unsigned long *config)
59{
60	const struct pinconf_ops *ops = pctldev->desc->confops;
61
62	if (!ops || !ops->pin_config_get) {
63		dev_err(pctldev->dev, "cannot get pin configuration, missing "
64			"pin_config_get() function in driver\n");
65		return -EINVAL;
66	}
67
68	return ops->pin_config_get(pctldev, pin, config);
69}
70
71/**
72 * pin_config_get() - get the configuration of a single pin parameter
73 * @dev_name: name of the pin controller device for this pin
74 * @name: name of the pin to get the config for
75 * @config: the config pointed to by this argument will be filled in with the
76 *	current pin state, it can be used directly by drivers as a numeral, or
77 *	it can be dereferenced to any struct.
78 */
79int pin_config_get(const char *dev_name, const char *name,
80			  unsigned long *config)
81{
82	struct pinctrl_dev *pctldev;
83	int pin;
84
85	mutex_lock(&pinctrl_mutex);
86
87	pctldev = get_pinctrl_dev_from_devname(dev_name);
88	if (!pctldev) {
89		pin = -EINVAL;
90		goto unlock;
91	}
92
93	pin = pin_get_from_name(pctldev, name);
94	if (pin < 0)
95		goto unlock;
96
97	pin = pin_config_get_for_pin(pctldev, pin, config);
98
99unlock:
100	mutex_unlock(&pinctrl_mutex);
101	return pin;
102}
103EXPORT_SYMBOL(pin_config_get);
104
105static int pin_config_set_for_pin(struct pinctrl_dev *pctldev, unsigned pin,
106			   unsigned long config)
107{
108	const struct pinconf_ops *ops = pctldev->desc->confops;
109	int ret;
110
111	if (!ops || !ops->pin_config_set) {
112		dev_err(pctldev->dev, "cannot configure pin, missing "
113			"config function in driver\n");
114		return -EINVAL;
115	}
116
117	ret = ops->pin_config_set(pctldev, pin, config);
118	if (ret) {
119		dev_err(pctldev->dev,
120			"unable to set pin configuration on pin %d\n", pin);
121		return ret;
122	}
123
124	return 0;
125}
126
127/**
128 * pin_config_set() - set the configuration of a single pin parameter
129 * @dev_name: name of pin controller device for this pin
130 * @name: name of the pin to set the config for
131 * @config: the config in this argument will contain the desired pin state, it
132 *	can be used directly by drivers as a numeral, or it can be dereferenced
133 *	to any struct.
134 */
135int pin_config_set(const char *dev_name, const char *name,
136		   unsigned long config)
137{
138	struct pinctrl_dev *pctldev;
139	int pin, ret;
140
141	mutex_lock(&pinctrl_mutex);
142
143	pctldev = get_pinctrl_dev_from_devname(dev_name);
144	if (!pctldev) {
145		ret = -EINVAL;
146		goto unlock;
147	}
148
149	pin = pin_get_from_name(pctldev, name);
150	if (pin < 0) {
151		ret = pin;
152		goto unlock;
153	}
154
155	ret = pin_config_set_for_pin(pctldev, pin, config);
156
157unlock:
158	mutex_unlock(&pinctrl_mutex);
159	return ret;
160}
161EXPORT_SYMBOL(pin_config_set);
162
163int pin_config_group_get(const char *dev_name, const char *pin_group,
164			 unsigned long *config)
165{
166	struct pinctrl_dev *pctldev;
167	const struct pinconf_ops *ops;
168	int selector, ret;
169
170	mutex_lock(&pinctrl_mutex);
171
172	pctldev = get_pinctrl_dev_from_devname(dev_name);
173	if (!pctldev) {
174		ret = -EINVAL;
175		goto unlock;
176	}
177	ops = pctldev->desc->confops;
178
179	if (!ops || !ops->pin_config_group_get) {
180		dev_err(pctldev->dev, "cannot get configuration for pin "
181			"group, missing group config get function in "
182			"driver\n");
183		ret = -EINVAL;
184		goto unlock;
185	}
186
187	selector = pinctrl_get_group_selector(pctldev, pin_group);
188	if (selector < 0) {
189		ret = selector;
190		goto unlock;
191	}
192
193	ret = ops->pin_config_group_get(pctldev, selector, config);
194
195unlock:
196	mutex_unlock(&pinctrl_mutex);
197	return ret;
198}
199EXPORT_SYMBOL(pin_config_group_get);
200
201int pin_config_group_set(const char *dev_name, const char *pin_group,
202			 unsigned long config)
203{
204	struct pinctrl_dev *pctldev;
205	const struct pinconf_ops *ops;
206	const struct pinctrl_ops *pctlops;
207	int selector;
208	const unsigned *pins;
209	unsigned num_pins;
210	int ret;
211	int i;
212
213	mutex_lock(&pinctrl_mutex);
214
215	pctldev = get_pinctrl_dev_from_devname(dev_name);
216	if (!pctldev) {
217		ret = -EINVAL;
218		goto unlock;
219	}
220	ops = pctldev->desc->confops;
221	pctlops = pctldev->desc->pctlops;
222
223	if (!ops || (!ops->pin_config_group_set && !ops->pin_config_set)) {
224		dev_err(pctldev->dev, "cannot configure pin group, missing "
225			"config function in driver\n");
226		ret = -EINVAL;
227		goto unlock;
228	}
229
230	selector = pinctrl_get_group_selector(pctldev, pin_group);
231	if (selector < 0) {
232		ret = selector;
233		goto unlock;
234	}
235
236	ret = pctlops->get_group_pins(pctldev, selector, &pins, &num_pins);
237	if (ret) {
238		dev_err(pctldev->dev, "cannot configure pin group, error "
239			"getting pins\n");
240		goto unlock;
241	}
242
243	/*
244	 * If the pin controller supports handling entire groups we use that
245	 * capability.
246	 */
247	if (ops->pin_config_group_set) {
248		ret = ops->pin_config_group_set(pctldev, selector, config);
249		/*
250		 * If the pin controller prefer that a certain group be handled
251		 * pin-by-pin as well, it returns -EAGAIN.
252		 */
253		if (ret != -EAGAIN)
254			goto unlock;
255	}
256
257	/*
258	 * If the controller cannot handle entire groups, we configure each pin
259	 * individually.
260	 */
261	if (!ops->pin_config_set) {
262		ret = 0;
263		goto unlock;
264	}
265
266	for (i = 0; i < num_pins; i++) {
267		ret = ops->pin_config_set(pctldev, pins[i], config);
268		if (ret < 0)
269			goto unlock;
270	}
271
272	ret = 0;
273
274unlock:
275	mutex_unlock(&pinctrl_mutex);
276
277	return ret;
278}
279EXPORT_SYMBOL(pin_config_group_set);
280
281int pinconf_map_to_setting(struct pinctrl_map const *map,
282			  struct pinctrl_setting *setting)
283{
284	struct pinctrl_dev *pctldev = setting->pctldev;
285	int pin;
286
287	switch (setting->type) {
288	case PIN_MAP_TYPE_CONFIGS_PIN:
289		pin = pin_get_from_name(pctldev,
290					map->data.configs.group_or_pin);
291		if (pin < 0) {
292			dev_err(pctldev->dev, "could not map pin config for \"%s\"",
293				map->data.configs.group_or_pin);
294			return pin;
295		}
296		setting->data.configs.group_or_pin = pin;
297		break;
298	case PIN_MAP_TYPE_CONFIGS_GROUP:
299		pin = pinctrl_get_group_selector(pctldev,
300					 map->data.configs.group_or_pin);
301		if (pin < 0) {
302			dev_err(pctldev->dev, "could not map group config for \"%s\"",
303				map->data.configs.group_or_pin);
304			return pin;
305		}
306		setting->data.configs.group_or_pin = pin;
307		break;
308	default:
309		return -EINVAL;
310	}
311
312	setting->data.configs.num_configs = map->data.configs.num_configs;
313	setting->data.configs.configs = map->data.configs.configs;
314
315	return 0;
316}
317
318void pinconf_free_setting(struct pinctrl_setting const *setting)
319{
320}
321
322int pinconf_apply_setting(struct pinctrl_setting const *setting)
323{
324	struct pinctrl_dev *pctldev = setting->pctldev;
325	const struct pinconf_ops *ops = pctldev->desc->confops;
326	int i, ret;
327
328	if (!ops) {
329		dev_err(pctldev->dev, "missing confops\n");
330		return -EINVAL;
331	}
332
333	switch (setting->type) {
334	case PIN_MAP_TYPE_CONFIGS_PIN:
335		if (!ops->pin_config_set) {
336			dev_err(pctldev->dev, "missing pin_config_set op\n");
337			return -EINVAL;
338		}
339		for (i = 0; i < setting->data.configs.num_configs; i++) {
340			ret = ops->pin_config_set(pctldev,
341					setting->data.configs.group_or_pin,
342					setting->data.configs.configs[i]);
343			if (ret < 0) {
344				dev_err(pctldev->dev,
345					"pin_config_set op failed for pin %d config %08lx\n",
346					setting->data.configs.group_or_pin,
347					setting->data.configs.configs[i]);
348				return ret;
349			}
350		}
351		break;
352	case PIN_MAP_TYPE_CONFIGS_GROUP:
353		if (!ops->pin_config_group_set) {
354			dev_err(pctldev->dev,
355				"missing pin_config_group_set op\n");
356			return -EINVAL;
357		}
358		for (i = 0; i < setting->data.configs.num_configs; i++) {
359			ret = ops->pin_config_group_set(pctldev,
360					setting->data.configs.group_or_pin,
361					setting->data.configs.configs[i]);
362			if (ret < 0) {
363				dev_err(pctldev->dev,
364					"pin_config_group_set op failed for group %d config %08lx\n",
365					setting->data.configs.group_or_pin,
366					setting->data.configs.configs[i]);
367				return ret;
368			}
369		}
370		break;
371	default:
372		return -EINVAL;
373	}
374
375	return 0;
376}
377
378#ifdef CONFIG_DEBUG_FS
379
380void pinconf_show_map(struct seq_file *s, struct pinctrl_map const *map)
381{
382	int i;
383
384	switch (map->type) {
385	case PIN_MAP_TYPE_CONFIGS_PIN:
386		seq_printf(s, "pin ");
387		break;
388	case PIN_MAP_TYPE_CONFIGS_GROUP:
389		seq_printf(s, "group ");
390		break;
391	default:
392		break;
393	}
394
395	seq_printf(s, "%s\n", map->data.configs.group_or_pin);
396
397	for (i = 0; i < map->data.configs.num_configs; i++)
398		seq_printf(s, "config %08lx\n", map->data.configs.configs[i]);
399}
400
401void pinconf_show_setting(struct seq_file *s,
402			  struct pinctrl_setting const *setting)
403{
404	struct pinctrl_dev *pctldev = setting->pctldev;
405	const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
406	struct pin_desc *desc;
407	int i;
408
409	switch (setting->type) {
410	case PIN_MAP_TYPE_CONFIGS_PIN:
411		desc = pin_desc_get(setting->pctldev,
412				    setting->data.configs.group_or_pin);
413		seq_printf(s, "pin %s (%d)",
414			   desc->name ? desc->name : "unnamed",
415			   setting->data.configs.group_or_pin);
416		break;
417	case PIN_MAP_TYPE_CONFIGS_GROUP:
418		seq_printf(s, "group %s (%d)",
419			   pctlops->get_group_name(pctldev,
420					setting->data.configs.group_or_pin),
421			   setting->data.configs.group_or_pin);
422		break;
423	default:
424		break;
425	}
426
427	/*
428	 * FIXME: We should really get the pin controler to dump the config
429	 * values, so they can be decoded to something meaningful.
430	 */
431	for (i = 0; i < setting->data.configs.num_configs; i++)
432		seq_printf(s, " %08lx", setting->data.configs.configs[i]);
433
434	seq_printf(s, "\n");
435}
436
437static void pinconf_dump_pin(struct pinctrl_dev *pctldev,
438			     struct seq_file *s, int pin)
439{
440	const struct pinconf_ops *ops = pctldev->desc->confops;
441
442	/* no-op when not using generic pin config */
443	pinconf_generic_dump_pin(pctldev, s, pin);
444	if (ops && ops->pin_config_dbg_show)
445		ops->pin_config_dbg_show(pctldev, s, pin);
446}
447
448static int pinconf_pins_show(struct seq_file *s, void *what)
449{
450	struct pinctrl_dev *pctldev = s->private;
451	unsigned i, pin;
452
453	seq_puts(s, "Pin config settings per pin\n");
454	seq_puts(s, "Format: pin (name): pinmux setting array\n");
455
456	mutex_lock(&pinctrl_mutex);
457
458	/* The pin number can be retrived from the pin controller descriptor */
459	for (i = 0; i < pctldev->desc->npins; i++) {
460		struct pin_desc *desc;
461
462		pin = pctldev->desc->pins[i].number;
463		desc = pin_desc_get(pctldev, pin);
464		/* Skip if we cannot search the pin */
465		if (desc == NULL)
466			continue;
467
468		seq_printf(s, "pin %d (%s):", pin,
469			   desc->name ? desc->name : "unnamed");
470
471		pinconf_dump_pin(pctldev, s, pin);
472
473		seq_printf(s, "\n");
474	}
475
476	mutex_unlock(&pinctrl_mutex);
477
478	return 0;
479}
480
481static void pinconf_dump_group(struct pinctrl_dev *pctldev,
482			       struct seq_file *s, unsigned selector,
483			       const char *gname)
484{
485	const struct pinconf_ops *ops = pctldev->desc->confops;
486
487	/* no-op when not using generic pin config */
488	pinconf_generic_dump_group(pctldev, s, gname);
489	if (ops && ops->pin_config_group_dbg_show)
490		ops->pin_config_group_dbg_show(pctldev, s, selector);
491}
492
493static int pinconf_groups_show(struct seq_file *s, void *what)
494{
495	struct pinctrl_dev *pctldev = s->private;
496	const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
497	const struct pinconf_ops *ops = pctldev->desc->confops;
498	unsigned selector = 0;
499
500	if (!ops || !ops->pin_config_group_get)
501		return 0;
502
503	seq_puts(s, "Pin config settings per pin group\n");
504	seq_puts(s, "Format: group (name): pinmux setting array\n");
505
506	mutex_lock(&pinctrl_mutex);
507
508	while (pctlops->list_groups(pctldev, selector) >= 0) {
509		const char *gname = pctlops->get_group_name(pctldev, selector);
510
511		seq_printf(s, "%u (%s):", selector, gname);
512		pinconf_dump_group(pctldev, s, selector, gname);
513		seq_printf(s, "\n");
514
515		selector++;
516	}
517
518	mutex_unlock(&pinctrl_mutex);
519
520	return 0;
521}
522
523static int pinconf_pins_open(struct inode *inode, struct file *file)
524{
525	return single_open(file, pinconf_pins_show, inode->i_private);
526}
527
528static int pinconf_groups_open(struct inode *inode, struct file *file)
529{
530	return single_open(file, pinconf_groups_show, inode->i_private);
531}
532
533static const struct file_operations pinconf_pins_ops = {
534	.open		= pinconf_pins_open,
535	.read		= seq_read,
536	.llseek		= seq_lseek,
537	.release	= single_release,
538};
539
540static const struct file_operations pinconf_groups_ops = {
541	.open		= pinconf_groups_open,
542	.read		= seq_read,
543	.llseek		= seq_lseek,
544	.release	= single_release,
545};
546
547void pinconf_init_device_debugfs(struct dentry *devroot,
548			 struct pinctrl_dev *pctldev)
549{
550	debugfs_create_file("pinconf-pins", S_IFREG | S_IRUGO,
551			    devroot, pctldev, &pinconf_pins_ops);
552	debugfs_create_file("pinconf-groups", S_IFREG | S_IRUGO,
553			    devroot, pctldev, &pinconf_groups_ops);
554}
555
556#endif
557