1/*
2 * Pinctrl driver for the Wondermedia SoC's
3 *
4 * Copyright (c) 2013 Tony Prisk <linux@prisktech.co.nz>
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms and conditions of the GNU General Public License,
8 * version 2, as published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
13 * more details.
14 */
15
16#include <linux/err.h>
17#include <linux/gpio.h>
18#include <linux/interrupt.h>
19#include <linux/io.h>
20#include <linux/irq.h>
21#include <linux/module.h>
22#include <linux/of.h>
23#include <linux/of_irq.h>
24#include <linux/pinctrl/consumer.h>
25#include <linux/pinctrl/machine.h>
26#include <linux/pinctrl/pinconf.h>
27#include <linux/pinctrl/pinconf-generic.h>
28#include <linux/pinctrl/pinctrl.h>
29#include <linux/pinctrl/pinmux.h>
30#include <linux/platform_device.h>
31#include <linux/slab.h>
32
33#include "pinctrl-wmt.h"
34
35static inline void wmt_setbits(struct wmt_pinctrl_data *data, u32 reg,
36				 u32 mask)
37{
38	u32 val;
39
40	val = readl_relaxed(data->base + reg);
41	val |= mask;
42	writel_relaxed(val, data->base + reg);
43}
44
45static inline void wmt_clearbits(struct wmt_pinctrl_data *data, u32 reg,
46				   u32 mask)
47{
48	u32 val;
49
50	val = readl_relaxed(data->base + reg);
51	val &= ~mask;
52	writel_relaxed(val, data->base + reg);
53}
54
55enum wmt_func_sel {
56	WMT_FSEL_GPIO_IN = 0,
57	WMT_FSEL_GPIO_OUT = 1,
58	WMT_FSEL_ALT = 2,
59	WMT_FSEL_COUNT = 3,
60};
61
62static const char * const wmt_functions[WMT_FSEL_COUNT] = {
63	[WMT_FSEL_GPIO_IN] = "gpio_in",
64	[WMT_FSEL_GPIO_OUT] = "gpio_out",
65	[WMT_FSEL_ALT] = "alt",
66};
67
68static int wmt_pmx_get_functions_count(struct pinctrl_dev *pctldev)
69{
70	return WMT_FSEL_COUNT;
71}
72
73static const char *wmt_pmx_get_function_name(struct pinctrl_dev *pctldev,
74					     unsigned selector)
75{
76	return wmt_functions[selector];
77}
78
79static int wmt_pmx_get_function_groups(struct pinctrl_dev *pctldev,
80				       unsigned selector,
81				       const char * const **groups,
82				       unsigned * const num_groups)
83{
84	struct wmt_pinctrl_data *data = pinctrl_dev_get_drvdata(pctldev);
85
86	/* every pin does every function */
87	*groups = data->groups;
88	*num_groups = data->ngroups;
89
90	return 0;
91}
92
93static int wmt_set_pinmux(struct wmt_pinctrl_data *data, unsigned func,
94			  unsigned pin)
95{
96	u32 bank = WMT_BANK_FROM_PIN(pin);
97	u32 bit = WMT_BIT_FROM_PIN(pin);
98	u32 reg_en = data->banks[bank].reg_en;
99	u32 reg_dir = data->banks[bank].reg_dir;
100
101	if (reg_dir == NO_REG) {
102		dev_err(data->dev, "pin:%d no direction register defined\n",
103			pin);
104		return -EINVAL;
105	}
106
107	/*
108	 * If reg_en == NO_REG, we assume it is a dedicated GPIO and cannot be
109	 * disabled (as on VT8500) and that no alternate function is available.
110	 */
111	switch (func) {
112	case WMT_FSEL_GPIO_IN:
113		if (reg_en != NO_REG)
114			wmt_setbits(data, reg_en, BIT(bit));
115		wmt_clearbits(data, reg_dir, BIT(bit));
116		break;
117	case WMT_FSEL_GPIO_OUT:
118		if (reg_en != NO_REG)
119			wmt_setbits(data, reg_en, BIT(bit));
120		wmt_setbits(data, reg_dir, BIT(bit));
121		break;
122	case WMT_FSEL_ALT:
123		if (reg_en == NO_REG) {
124			dev_err(data->dev, "pin:%d no alt function available\n",
125				pin);
126			return -EINVAL;
127		}
128		wmt_clearbits(data, reg_en, BIT(bit));
129	}
130
131	return 0;
132}
133
134static int wmt_pmx_set_mux(struct pinctrl_dev *pctldev,
135			   unsigned func_selector,
136			   unsigned group_selector)
137{
138	struct wmt_pinctrl_data *data = pinctrl_dev_get_drvdata(pctldev);
139	u32 pinnum = data->pins[group_selector].number;
140
141	return wmt_set_pinmux(data, func_selector, pinnum);
142}
143
144static void wmt_pmx_gpio_disable_free(struct pinctrl_dev *pctldev,
145				      struct pinctrl_gpio_range *range,
146				      unsigned offset)
147{
148	struct wmt_pinctrl_data *data = pinctrl_dev_get_drvdata(pctldev);
149
150	/* disable by setting GPIO_IN */
151	wmt_set_pinmux(data, WMT_FSEL_GPIO_IN, offset);
152}
153
154static int wmt_pmx_gpio_set_direction(struct pinctrl_dev *pctldev,
155				      struct pinctrl_gpio_range *range,
156				      unsigned offset,
157				      bool input)
158{
159	struct wmt_pinctrl_data *data = pinctrl_dev_get_drvdata(pctldev);
160
161	wmt_set_pinmux(data, (input ? WMT_FSEL_GPIO_IN : WMT_FSEL_GPIO_OUT),
162		       offset);
163
164	return 0;
165}
166
167static struct pinmux_ops wmt_pinmux_ops = {
168	.get_functions_count = wmt_pmx_get_functions_count,
169	.get_function_name = wmt_pmx_get_function_name,
170	.get_function_groups = wmt_pmx_get_function_groups,
171	.set_mux = wmt_pmx_set_mux,
172	.gpio_disable_free = wmt_pmx_gpio_disable_free,
173	.gpio_set_direction = wmt_pmx_gpio_set_direction,
174};
175
176static int wmt_get_groups_count(struct pinctrl_dev *pctldev)
177{
178	struct wmt_pinctrl_data *data = pinctrl_dev_get_drvdata(pctldev);
179
180	return data->ngroups;
181}
182
183static const char *wmt_get_group_name(struct pinctrl_dev *pctldev,
184				      unsigned selector)
185{
186	struct wmt_pinctrl_data *data = pinctrl_dev_get_drvdata(pctldev);
187
188	return data->groups[selector];
189}
190
191static int wmt_get_group_pins(struct pinctrl_dev *pctldev,
192			      unsigned selector,
193			      const unsigned **pins,
194			      unsigned *num_pins)
195{
196	struct wmt_pinctrl_data *data = pinctrl_dev_get_drvdata(pctldev);
197
198	*pins = &data->pins[selector].number;
199	*num_pins = 1;
200
201	return 0;
202}
203
204static int wmt_pctl_find_group_by_pin(struct wmt_pinctrl_data *data, u32 pin)
205{
206	int i;
207
208	for (i = 0; i < data->npins; i++) {
209		if (data->pins[i].number == pin)
210			return i;
211	}
212
213	return -EINVAL;
214}
215
216static int wmt_pctl_dt_node_to_map_func(struct wmt_pinctrl_data *data,
217					struct device_node *np,
218					u32 pin, u32 fnum,
219					struct pinctrl_map **maps)
220{
221	int group;
222	struct pinctrl_map *map = *maps;
223
224	if (fnum >= ARRAY_SIZE(wmt_functions)) {
225		dev_err(data->dev, "invalid wm,function %d\n", fnum);
226		return -EINVAL;
227	}
228
229	group = wmt_pctl_find_group_by_pin(data, pin);
230	if (group < 0) {
231		dev_err(data->dev, "unable to match pin %d to group\n", pin);
232		return group;
233	}
234
235	map->type = PIN_MAP_TYPE_MUX_GROUP;
236	map->data.mux.group = data->groups[group];
237	map->data.mux.function = wmt_functions[fnum];
238	(*maps)++;
239
240	return 0;
241}
242
243static int wmt_pctl_dt_node_to_map_pull(struct wmt_pinctrl_data *data,
244					struct device_node *np,
245					u32 pin, u32 pull,
246					struct pinctrl_map **maps)
247{
248	int group;
249	unsigned long *configs;
250	struct pinctrl_map *map = *maps;
251
252	if (pull > 2) {
253		dev_err(data->dev, "invalid wm,pull %d\n", pull);
254		return -EINVAL;
255	}
256
257	group = wmt_pctl_find_group_by_pin(data, pin);
258	if (group < 0) {
259		dev_err(data->dev, "unable to match pin %d to group\n", pin);
260		return group;
261	}
262
263	configs = kzalloc(sizeof(*configs), GFP_KERNEL);
264	if (!configs)
265		return -ENOMEM;
266
267	switch (pull) {
268	case 0:
269		configs[0] = PIN_CONFIG_BIAS_DISABLE;
270		break;
271	case 1:
272		configs[0] = PIN_CONFIG_BIAS_PULL_DOWN;
273		break;
274	case 2:
275		configs[0] = PIN_CONFIG_BIAS_PULL_UP;
276		break;
277	default:
278		configs[0] = PIN_CONFIG_BIAS_DISABLE;
279		dev_err(data->dev, "invalid pull state %d - disabling\n", pull);
280	}
281
282	map->type = PIN_MAP_TYPE_CONFIGS_PIN;
283	map->data.configs.group_or_pin = data->groups[group];
284	map->data.configs.configs = configs;
285	map->data.configs.num_configs = 1;
286	(*maps)++;
287
288	return 0;
289}
290
291static void wmt_pctl_dt_free_map(struct pinctrl_dev *pctldev,
292				 struct pinctrl_map *maps,
293				 unsigned num_maps)
294{
295	int i;
296
297	for (i = 0; i < num_maps; i++)
298		if (maps[i].type == PIN_MAP_TYPE_CONFIGS_PIN)
299			kfree(maps[i].data.configs.configs);
300
301	kfree(maps);
302}
303
304static int wmt_pctl_dt_node_to_map(struct pinctrl_dev *pctldev,
305				   struct device_node *np,
306				   struct pinctrl_map **map,
307				   unsigned *num_maps)
308{
309	struct pinctrl_map *maps, *cur_map;
310	struct property *pins, *funcs, *pulls;
311	u32 pin, func, pull;
312	int num_pins, num_funcs, num_pulls, maps_per_pin;
313	int i, err;
314	struct wmt_pinctrl_data *data = pinctrl_dev_get_drvdata(pctldev);
315
316	pins = of_find_property(np, "wm,pins", NULL);
317	if (!pins) {
318		dev_err(data->dev, "missing wmt,pins property\n");
319		return -EINVAL;
320	}
321
322	funcs = of_find_property(np, "wm,function", NULL);
323	pulls = of_find_property(np, "wm,pull", NULL);
324
325	if (!funcs && !pulls) {
326		dev_err(data->dev, "neither wm,function nor wm,pull specified\n");
327		return -EINVAL;
328	}
329
330	/*
331	 * The following lines calculate how many values are defined for each
332	 * of the properties.
333	 */
334	num_pins = pins->length / sizeof(u32);
335	num_funcs = funcs ? (funcs->length / sizeof(u32)) : 0;
336	num_pulls = pulls ? (pulls->length / sizeof(u32)) : 0;
337
338	if (num_funcs > 1 && num_funcs != num_pins) {
339		dev_err(data->dev, "wm,function must have 1 or %d entries\n",
340			num_pins);
341		return -EINVAL;
342	}
343
344	if (num_pulls > 1 && num_pulls != num_pins) {
345		dev_err(data->dev, "wm,pull must have 1 or %d entries\n",
346			num_pins);
347		return -EINVAL;
348	}
349
350	maps_per_pin = 0;
351	if (num_funcs)
352		maps_per_pin++;
353	if (num_pulls)
354		maps_per_pin++;
355
356	cur_map = maps = kzalloc(num_pins * maps_per_pin * sizeof(*maps),
357				 GFP_KERNEL);
358	if (!maps)
359		return -ENOMEM;
360
361	for (i = 0; i < num_pins; i++) {
362		err = of_property_read_u32_index(np, "wm,pins", i, &pin);
363		if (err)
364			goto fail;
365
366		if (pin >= (data->nbanks * 32)) {
367			dev_err(data->dev, "invalid wm,pins value\n");
368			err = -EINVAL;
369			goto fail;
370		}
371
372		if (num_funcs) {
373			err = of_property_read_u32_index(np, "wm,function",
374						(num_funcs > 1 ? i : 0), &func);
375			if (err)
376				goto fail;
377
378			err = wmt_pctl_dt_node_to_map_func(data, np, pin, func,
379							   &cur_map);
380			if (err)
381				goto fail;
382		}
383
384		if (num_pulls) {
385			err = of_property_read_u32_index(np, "wm,pull",
386						(num_pulls > 1 ? i : 0), &pull);
387			if (err)
388				goto fail;
389
390			err = wmt_pctl_dt_node_to_map_pull(data, np, pin, pull,
391							   &cur_map);
392			if (err)
393				goto fail;
394		}
395	}
396	*map = maps;
397	*num_maps = num_pins * maps_per_pin;
398	return 0;
399
400/*
401 * The fail path removes any maps that have been allocated. The fail path is
402 * only called from code after maps has been kzalloc'd. It is also safe to
403 * pass 'num_pins * maps_per_pin' as the map count even though we probably
404 * failed before all the mappings were read as all maps are allocated at once,
405 * and configs are only allocated for .type = PIN_MAP_TYPE_CONFIGS_PIN - there
406 * is no failpath where a config can be allocated without .type being set.
407 */
408fail:
409	wmt_pctl_dt_free_map(pctldev, maps, num_pins * maps_per_pin);
410	return err;
411}
412
413static struct pinctrl_ops wmt_pctl_ops = {
414	.get_groups_count = wmt_get_groups_count,
415	.get_group_name	= wmt_get_group_name,
416	.get_group_pins	= wmt_get_group_pins,
417	.dt_node_to_map = wmt_pctl_dt_node_to_map,
418	.dt_free_map = wmt_pctl_dt_free_map,
419};
420
421static int wmt_pinconf_get(struct pinctrl_dev *pctldev, unsigned pin,
422			   unsigned long *config)
423{
424	return -ENOTSUPP;
425}
426
427static int wmt_pinconf_set(struct pinctrl_dev *pctldev, unsigned pin,
428			   unsigned long *configs, unsigned num_configs)
429{
430	struct wmt_pinctrl_data *data = pinctrl_dev_get_drvdata(pctldev);
431	enum pin_config_param param;
432	u16 arg;
433	u32 bank = WMT_BANK_FROM_PIN(pin);
434	u32 bit = WMT_BIT_FROM_PIN(pin);
435	u32 reg_pull_en = data->banks[bank].reg_pull_en;
436	u32 reg_pull_cfg = data->banks[bank].reg_pull_cfg;
437	int i;
438
439	if ((reg_pull_en == NO_REG) || (reg_pull_cfg == NO_REG)) {
440		dev_err(data->dev, "bias functions not supported on pin %d\n",
441			pin);
442		return -EINVAL;
443	}
444
445	for (i = 0; i < num_configs; i++) {
446		param = pinconf_to_config_param(configs[i]);
447		arg = pinconf_to_config_argument(configs[i]);
448
449		if ((param == PIN_CONFIG_BIAS_PULL_DOWN) ||
450		    (param == PIN_CONFIG_BIAS_PULL_UP)) {
451			if (arg == 0)
452				param = PIN_CONFIG_BIAS_DISABLE;
453		}
454
455		switch (param) {
456		case PIN_CONFIG_BIAS_DISABLE:
457			wmt_clearbits(data, reg_pull_en, BIT(bit));
458			break;
459		case PIN_CONFIG_BIAS_PULL_DOWN:
460			wmt_clearbits(data, reg_pull_cfg, BIT(bit));
461			wmt_setbits(data, reg_pull_en, BIT(bit));
462			break;
463		case PIN_CONFIG_BIAS_PULL_UP:
464			wmt_setbits(data, reg_pull_cfg, BIT(bit));
465			wmt_setbits(data, reg_pull_en, BIT(bit));
466			break;
467		default:
468			dev_err(data->dev, "unknown pinconf param\n");
469			return -EINVAL;
470		}
471	} /* for each config */
472
473	return 0;
474}
475
476static struct pinconf_ops wmt_pinconf_ops = {
477	.pin_config_get = wmt_pinconf_get,
478	.pin_config_set = wmt_pinconf_set,
479};
480
481static struct pinctrl_desc wmt_desc = {
482	.owner = THIS_MODULE,
483	.name = "pinctrl-wmt",
484	.pctlops = &wmt_pctl_ops,
485	.pmxops = &wmt_pinmux_ops,
486	.confops = &wmt_pinconf_ops,
487};
488
489static int wmt_gpio_request(struct gpio_chip *chip, unsigned offset)
490{
491	return pinctrl_request_gpio(chip->base + offset);
492}
493
494static void wmt_gpio_free(struct gpio_chip *chip, unsigned offset)
495{
496	pinctrl_free_gpio(chip->base + offset);
497}
498
499static int wmt_gpio_get_direction(struct gpio_chip *chip, unsigned offset)
500{
501	struct wmt_pinctrl_data *data = dev_get_drvdata(chip->dev);
502	u32 bank = WMT_BANK_FROM_PIN(offset);
503	u32 bit = WMT_BIT_FROM_PIN(offset);
504	u32 reg_dir = data->banks[bank].reg_dir;
505	u32 val;
506
507	val = readl_relaxed(data->base + reg_dir);
508	if (val & BIT(bit))
509		return GPIOF_DIR_OUT;
510	else
511		return GPIOF_DIR_IN;
512}
513
514static int wmt_gpio_get_value(struct gpio_chip *chip, unsigned offset)
515{
516	struct wmt_pinctrl_data *data = dev_get_drvdata(chip->dev);
517	u32 bank = WMT_BANK_FROM_PIN(offset);
518	u32 bit = WMT_BIT_FROM_PIN(offset);
519	u32 reg_data_in = data->banks[bank].reg_data_in;
520
521	if (reg_data_in == NO_REG) {
522		dev_err(data->dev, "no data in register defined\n");
523		return -EINVAL;
524	}
525
526	return !!(readl_relaxed(data->base + reg_data_in) & BIT(bit));
527}
528
529static void wmt_gpio_set_value(struct gpio_chip *chip, unsigned offset,
530			       int val)
531{
532	struct wmt_pinctrl_data *data = dev_get_drvdata(chip->dev);
533	u32 bank = WMT_BANK_FROM_PIN(offset);
534	u32 bit = WMT_BIT_FROM_PIN(offset);
535	u32 reg_data_out = data->banks[bank].reg_data_out;
536
537	if (reg_data_out == NO_REG) {
538		dev_err(data->dev, "no data out register defined\n");
539		return;
540	}
541
542	if (val)
543		wmt_setbits(data, reg_data_out, BIT(bit));
544	else
545		wmt_clearbits(data, reg_data_out, BIT(bit));
546}
547
548static int wmt_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
549{
550	return pinctrl_gpio_direction_input(chip->base + offset);
551}
552
553static int wmt_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
554				     int value)
555{
556	wmt_gpio_set_value(chip, offset, value);
557	return pinctrl_gpio_direction_output(chip->base + offset);
558}
559
560static struct gpio_chip wmt_gpio_chip = {
561	.label = "gpio-wmt",
562	.owner = THIS_MODULE,
563	.request = wmt_gpio_request,
564	.free = wmt_gpio_free,
565	.get_direction = wmt_gpio_get_direction,
566	.direction_input = wmt_gpio_direction_input,
567	.direction_output = wmt_gpio_direction_output,
568	.get = wmt_gpio_get_value,
569	.set = wmt_gpio_set_value,
570	.can_sleep = false,
571};
572
573int wmt_pinctrl_probe(struct platform_device *pdev,
574		      struct wmt_pinctrl_data *data)
575{
576	int err;
577	struct resource *res;
578
579	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
580	data->base = devm_ioremap_resource(&pdev->dev, res);
581	if (IS_ERR(data->base))
582		return PTR_ERR(data->base);
583
584	wmt_desc.pins = data->pins;
585	wmt_desc.npins = data->npins;
586
587	data->gpio_chip = wmt_gpio_chip;
588	data->gpio_chip.dev = &pdev->dev;
589	data->gpio_chip.of_node = pdev->dev.of_node;
590	data->gpio_chip.ngpio = data->nbanks * 32;
591
592	platform_set_drvdata(pdev, data);
593
594	data->dev = &pdev->dev;
595
596	data->pctl_dev = pinctrl_register(&wmt_desc, &pdev->dev, data);
597	if (!data->pctl_dev) {
598		dev_err(&pdev->dev, "Failed to register pinctrl\n");
599		return -EINVAL;
600	}
601
602	err = gpiochip_add(&data->gpio_chip);
603	if (err) {
604		dev_err(&pdev->dev, "could not add GPIO chip\n");
605		goto fail_gpio;
606	}
607
608	err = gpiochip_add_pin_range(&data->gpio_chip, dev_name(data->dev),
609				     0, 0, data->nbanks * 32);
610	if (err)
611		goto fail_range;
612
613	dev_info(&pdev->dev, "Pin controller initialized\n");
614
615	return 0;
616
617fail_range:
618	gpiochip_remove(&data->gpio_chip);
619fail_gpio:
620	pinctrl_unregister(data->pctl_dev);
621	return err;
622}
623
624int wmt_pinctrl_remove(struct platform_device *pdev)
625{
626	struct wmt_pinctrl_data *data = platform_get_drvdata(pdev);
627
628	gpiochip_remove(&data->gpio_chip);
629	pinctrl_unregister(data->pctl_dev);
630
631	return 0;
632}
633