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