xref: /linux/drivers/gpio/gpio-rcar.c (revision 9a6b55ac) 
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Renesas R-Car GPIO Support
4  *
5  *  Copyright (C) 2014 Renesas Electronics Corporation
6  *  Copyright (C) 2013 Magnus Damm
7  */
8 
9 #include <linux/err.h>
10 #include <linux/gpio/driver.h>
11 #include <linux/init.h>
12 #include <linux/interrupt.h>
13 #include <linux/io.h>
14 #include <linux/ioport.h>
15 #include <linux/irq.h>
16 #include <linux/module.h>
17 #include <linux/of.h>
18 #include <linux/of_device.h>
19 #include <linux/pinctrl/consumer.h>
20 #include <linux/platform_device.h>
21 #include <linux/pm_runtime.h>
22 #include <linux/spinlock.h>
23 #include <linux/slab.h>
24 
25 struct gpio_rcar_bank_info {
26 	u32 iointsel;
27 	u32 inoutsel;
28 	u32 outdt;
29 	u32 posneg;
30 	u32 edglevel;
31 	u32 bothedge;
32 	u32 intmsk;
33 };
34 
35 struct gpio_rcar_priv {
36 	void __iomem *base;
37 	spinlock_t lock;
38 	struct device *dev;
39 	struct gpio_chip gpio_chip;
40 	struct irq_chip irq_chip;
41 	unsigned int irq_parent;
42 	atomic_t wakeup_path;
43 	bool has_outdtsel;
44 	bool has_both_edge_trigger;
45 	struct gpio_rcar_bank_info bank_info;
46 };
47 
48 #define IOINTSEL 0x00	/* General IO/Interrupt Switching Register */
49 #define INOUTSEL 0x04	/* General Input/Output Switching Register */
50 #define OUTDT 0x08	/* General Output Register */
51 #define INDT 0x0c	/* General Input Register */
52 #define INTDT 0x10	/* Interrupt Display Register */
53 #define INTCLR 0x14	/* Interrupt Clear Register */
54 #define INTMSK 0x18	/* Interrupt Mask Register */
55 #define MSKCLR 0x1c	/* Interrupt Mask Clear Register */
56 #define POSNEG 0x20	/* Positive/Negative Logic Select Register */
57 #define EDGLEVEL 0x24	/* Edge/level Select Register */
58 #define FILONOFF 0x28	/* Chattering Prevention On/Off Register */
59 #define OUTDTSEL 0x40	/* Output Data Select Register */
60 #define BOTHEDGE 0x4c	/* One Edge/Both Edge Select Register */
61 
62 #define RCAR_MAX_GPIO_PER_BANK		32
63 
64 static inline u32 gpio_rcar_read(struct gpio_rcar_priv *p, int offs)
65 {
66 	return ioread32(p->base + offs);
67 }
68 
69 static inline void gpio_rcar_write(struct gpio_rcar_priv *p, int offs,
70 				   u32 value)
71 {
72 	iowrite32(value, p->base + offs);
73 }
74 
75 static void gpio_rcar_modify_bit(struct gpio_rcar_priv *p, int offs,
76 				 int bit, bool value)
77 {
78 	u32 tmp = gpio_rcar_read(p, offs);
79 
80 	if (value)
81 		tmp |= BIT(bit);
82 	else
83 		tmp &= ~BIT(bit);
84 
85 	gpio_rcar_write(p, offs, tmp);
86 }
87 
88 static void gpio_rcar_irq_disable(struct irq_data *d)
89 {
90 	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
91 	struct gpio_rcar_priv *p = gpiochip_get_data(gc);
92 
93 	gpio_rcar_write(p, INTMSK, ~BIT(irqd_to_hwirq(d)));
94 }
95 
96 static void gpio_rcar_irq_enable(struct irq_data *d)
97 {
98 	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
99 	struct gpio_rcar_priv *p = gpiochip_get_data(gc);
100 
101 	gpio_rcar_write(p, MSKCLR, BIT(irqd_to_hwirq(d)));
102 }
103 
104 static void gpio_rcar_config_interrupt_input_mode(struct gpio_rcar_priv *p,
105 						  unsigned int hwirq,
106 						  bool active_high_rising_edge,
107 						  bool level_trigger,
108 						  bool both)
109 {
110 	unsigned long flags;
111 
112 	/* follow steps in the GPIO documentation for
113 	 * "Setting Edge-Sensitive Interrupt Input Mode" and
114 	 * "Setting Level-Sensitive Interrupt Input Mode"
115 	 */
116 
117 	spin_lock_irqsave(&p->lock, flags);
118 
119 	/* Configure postive or negative logic in POSNEG */
120 	gpio_rcar_modify_bit(p, POSNEG, hwirq, !active_high_rising_edge);
121 
122 	/* Configure edge or level trigger in EDGLEVEL */
123 	gpio_rcar_modify_bit(p, EDGLEVEL, hwirq, !level_trigger);
124 
125 	/* Select one edge or both edges in BOTHEDGE */
126 	if (p->has_both_edge_trigger)
127 		gpio_rcar_modify_bit(p, BOTHEDGE, hwirq, both);
128 
129 	/* Select "Interrupt Input Mode" in IOINTSEL */
130 	gpio_rcar_modify_bit(p, IOINTSEL, hwirq, true);
131 
132 	/* Write INTCLR in case of edge trigger */
133 	if (!level_trigger)
134 		gpio_rcar_write(p, INTCLR, BIT(hwirq));
135 
136 	spin_unlock_irqrestore(&p->lock, flags);
137 }
138 
139 static int gpio_rcar_irq_set_type(struct irq_data *d, unsigned int type)
140 {
141 	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
142 	struct gpio_rcar_priv *p = gpiochip_get_data(gc);
143 	unsigned int hwirq = irqd_to_hwirq(d);
144 
145 	dev_dbg(p->dev, "sense irq = %d, type = %d\n", hwirq, type);
146 
147 	switch (type & IRQ_TYPE_SENSE_MASK) {
148 	case IRQ_TYPE_LEVEL_HIGH:
149 		gpio_rcar_config_interrupt_input_mode(p, hwirq, true, true,
150 						      false);
151 		break;
152 	case IRQ_TYPE_LEVEL_LOW:
153 		gpio_rcar_config_interrupt_input_mode(p, hwirq, false, true,
154 						      false);
155 		break;
156 	case IRQ_TYPE_EDGE_RISING:
157 		gpio_rcar_config_interrupt_input_mode(p, hwirq, true, false,
158 						      false);
159 		break;
160 	case IRQ_TYPE_EDGE_FALLING:
161 		gpio_rcar_config_interrupt_input_mode(p, hwirq, false, false,
162 						      false);
163 		break;
164 	case IRQ_TYPE_EDGE_BOTH:
165 		if (!p->has_both_edge_trigger)
166 			return -EINVAL;
167 		gpio_rcar_config_interrupt_input_mode(p, hwirq, true, false,
168 						      true);
169 		break;
170 	default:
171 		return -EINVAL;
172 	}
173 	return 0;
174 }
175 
176 static int gpio_rcar_irq_set_wake(struct irq_data *d, unsigned int on)
177 {
178 	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
179 	struct gpio_rcar_priv *p = gpiochip_get_data(gc);
180 	int error;
181 
182 	if (p->irq_parent) {
183 		error = irq_set_irq_wake(p->irq_parent, on);
184 		if (error) {
185 			dev_dbg(p->dev, "irq %u doesn't support irq_set_wake\n",
186 				p->irq_parent);
187 			p->irq_parent = 0;
188 		}
189 	}
190 
191 	if (on)
192 		atomic_inc(&p->wakeup_path);
193 	else
194 		atomic_dec(&p->wakeup_path);
195 
196 	return 0;
197 }
198 
199 static irqreturn_t gpio_rcar_irq_handler(int irq, void *dev_id)
200 {
201 	struct gpio_rcar_priv *p = dev_id;
202 	u32 pending;
203 	unsigned int offset, irqs_handled = 0;
204 
205 	while ((pending = gpio_rcar_read(p, INTDT) &
206 			  gpio_rcar_read(p, INTMSK))) {
207 		offset = __ffs(pending);
208 		gpio_rcar_write(p, INTCLR, BIT(offset));
209 		generic_handle_irq(irq_find_mapping(p->gpio_chip.irq.domain,
210 						    offset));
211 		irqs_handled++;
212 	}
213 
214 	return irqs_handled ? IRQ_HANDLED : IRQ_NONE;
215 }
216 
217 static void gpio_rcar_config_general_input_output_mode(struct gpio_chip *chip,
218 						       unsigned int gpio,
219 						       bool output)
220 {
221 	struct gpio_rcar_priv *p = gpiochip_get_data(chip);
222 	unsigned long flags;
223 
224 	/* follow steps in the GPIO documentation for
225 	 * "Setting General Output Mode" and
226 	 * "Setting General Input Mode"
227 	 */
228 
229 	spin_lock_irqsave(&p->lock, flags);
230 
231 	/* Configure postive logic in POSNEG */
232 	gpio_rcar_modify_bit(p, POSNEG, gpio, false);
233 
234 	/* Select "General Input/Output Mode" in IOINTSEL */
235 	gpio_rcar_modify_bit(p, IOINTSEL, gpio, false);
236 
237 	/* Select Input Mode or Output Mode in INOUTSEL */
238 	gpio_rcar_modify_bit(p, INOUTSEL, gpio, output);
239 
240 	/* Select General Output Register to output data in OUTDTSEL */
241 	if (p->has_outdtsel && output)
242 		gpio_rcar_modify_bit(p, OUTDTSEL, gpio, false);
243 
244 	spin_unlock_irqrestore(&p->lock, flags);
245 }
246 
247 static int gpio_rcar_request(struct gpio_chip *chip, unsigned offset)
248 {
249 	struct gpio_rcar_priv *p = gpiochip_get_data(chip);
250 	int error;
251 
252 	error = pm_runtime_get_sync(p->dev);
253 	if (error < 0)
254 		return error;
255 
256 	error = pinctrl_gpio_request(chip->base + offset);
257 	if (error)
258 		pm_runtime_put(p->dev);
259 
260 	return error;
261 }
262 
263 static void gpio_rcar_free(struct gpio_chip *chip, unsigned offset)
264 {
265 	struct gpio_rcar_priv *p = gpiochip_get_data(chip);
266 
267 	pinctrl_gpio_free(chip->base + offset);
268 
269 	/*
270 	 * Set the GPIO as an input to ensure that the next GPIO request won't
271 	 * drive the GPIO pin as an output.
272 	 */
273 	gpio_rcar_config_general_input_output_mode(chip, offset, false);
274 
275 	pm_runtime_put(p->dev);
276 }
277 
278 static int gpio_rcar_get_direction(struct gpio_chip *chip, unsigned int offset)
279 {
280 	struct gpio_rcar_priv *p = gpiochip_get_data(chip);
281 
282 	if (gpio_rcar_read(p, INOUTSEL) & BIT(offset))
283 		return GPIO_LINE_DIRECTION_OUT;
284 
285 	return GPIO_LINE_DIRECTION_IN;
286 }
287 
288 static int gpio_rcar_direction_input(struct gpio_chip *chip, unsigned offset)
289 {
290 	gpio_rcar_config_general_input_output_mode(chip, offset, false);
291 	return 0;
292 }
293 
294 static int gpio_rcar_get(struct gpio_chip *chip, unsigned offset)
295 {
296 	u32 bit = BIT(offset);
297 
298 	/* testing on r8a7790 shows that INDT does not show correct pin state
299 	 * when configured as output, so use OUTDT in case of output pins */
300 	if (gpio_rcar_read(gpiochip_get_data(chip), INOUTSEL) & bit)
301 		return !!(gpio_rcar_read(gpiochip_get_data(chip), OUTDT) & bit);
302 	else
303 		return !!(gpio_rcar_read(gpiochip_get_data(chip), INDT) & bit);
304 }
305 
306 static void gpio_rcar_set(struct gpio_chip *chip, unsigned offset, int value)
307 {
308 	struct gpio_rcar_priv *p = gpiochip_get_data(chip);
309 	unsigned long flags;
310 
311 	spin_lock_irqsave(&p->lock, flags);
312 	gpio_rcar_modify_bit(p, OUTDT, offset, value);
313 	spin_unlock_irqrestore(&p->lock, flags);
314 }
315 
316 static void gpio_rcar_set_multiple(struct gpio_chip *chip, unsigned long *mask,
317 				   unsigned long *bits)
318 {
319 	struct gpio_rcar_priv *p = gpiochip_get_data(chip);
320 	unsigned long flags;
321 	u32 val, bankmask;
322 
323 	bankmask = mask[0] & GENMASK(chip->ngpio - 1, 0);
324 	if (chip->valid_mask)
325 		bankmask &= chip->valid_mask[0];
326 
327 	if (!bankmask)
328 		return;
329 
330 	spin_lock_irqsave(&p->lock, flags);
331 	val = gpio_rcar_read(p, OUTDT);
332 	val &= ~bankmask;
333 	val |= (bankmask & bits[0]);
334 	gpio_rcar_write(p, OUTDT, val);
335 	spin_unlock_irqrestore(&p->lock, flags);
336 }
337 
338 static int gpio_rcar_direction_output(struct gpio_chip *chip, unsigned offset,
339 				      int value)
340 {
341 	/* write GPIO value to output before selecting output mode of pin */
342 	gpio_rcar_set(chip, offset, value);
343 	gpio_rcar_config_general_input_output_mode(chip, offset, true);
344 	return 0;
345 }
346 
347 struct gpio_rcar_info {
348 	bool has_outdtsel;
349 	bool has_both_edge_trigger;
350 };
351 
352 static const struct gpio_rcar_info gpio_rcar_info_gen1 = {
353 	.has_outdtsel = false,
354 	.has_both_edge_trigger = false,
355 };
356 
357 static const struct gpio_rcar_info gpio_rcar_info_gen2 = {
358 	.has_outdtsel = true,
359 	.has_both_edge_trigger = true,
360 };
361 
362 static const struct of_device_id gpio_rcar_of_table[] = {
363 	{
364 		.compatible = "renesas,gpio-r8a7743",
365 		/* RZ/G1 GPIO is identical to R-Car Gen2. */
366 		.data = &gpio_rcar_info_gen2,
367 	}, {
368 		.compatible = "renesas,gpio-r8a7790",
369 		.data = &gpio_rcar_info_gen2,
370 	}, {
371 		.compatible = "renesas,gpio-r8a7791",
372 		.data = &gpio_rcar_info_gen2,
373 	}, {
374 		.compatible = "renesas,gpio-r8a7792",
375 		.data = &gpio_rcar_info_gen2,
376 	}, {
377 		.compatible = "renesas,gpio-r8a7793",
378 		.data = &gpio_rcar_info_gen2,
379 	}, {
380 		.compatible = "renesas,gpio-r8a7794",
381 		.data = &gpio_rcar_info_gen2,
382 	}, {
383 		.compatible = "renesas,gpio-r8a7795",
384 		/* Gen3 GPIO is identical to Gen2. */
385 		.data = &gpio_rcar_info_gen2,
386 	}, {
387 		.compatible = "renesas,gpio-r8a7796",
388 		/* Gen3 GPIO is identical to Gen2. */
389 		.data = &gpio_rcar_info_gen2,
390 	}, {
391 		.compatible = "renesas,rcar-gen1-gpio",
392 		.data = &gpio_rcar_info_gen1,
393 	}, {
394 		.compatible = "renesas,rcar-gen2-gpio",
395 		.data = &gpio_rcar_info_gen2,
396 	}, {
397 		.compatible = "renesas,rcar-gen3-gpio",
398 		/* Gen3 GPIO is identical to Gen2. */
399 		.data = &gpio_rcar_info_gen2,
400 	}, {
401 		.compatible = "renesas,gpio-rcar",
402 		.data = &gpio_rcar_info_gen1,
403 	}, {
404 		/* Terminator */
405 	},
406 };
407 
408 MODULE_DEVICE_TABLE(of, gpio_rcar_of_table);
409 
410 static int gpio_rcar_parse_dt(struct gpio_rcar_priv *p, unsigned int *npins)
411 {
412 	struct device_node *np = p->dev->of_node;
413 	const struct gpio_rcar_info *info;
414 	struct of_phandle_args args;
415 	int ret;
416 
417 	info = of_device_get_match_data(p->dev);
418 	p->has_outdtsel = info->has_outdtsel;
419 	p->has_both_edge_trigger = info->has_both_edge_trigger;
420 
421 	ret = of_parse_phandle_with_fixed_args(np, "gpio-ranges", 3, 0, &args);
422 	*npins = ret == 0 ? args.args[2] : RCAR_MAX_GPIO_PER_BANK;
423 
424 	if (*npins == 0 || *npins > RCAR_MAX_GPIO_PER_BANK) {
425 		dev_warn(p->dev, "Invalid number of gpio lines %u, using %u\n",
426 			 *npins, RCAR_MAX_GPIO_PER_BANK);
427 		*npins = RCAR_MAX_GPIO_PER_BANK;
428 	}
429 
430 	return 0;
431 }
432 
433 static int gpio_rcar_probe(struct platform_device *pdev)
434 {
435 	struct gpio_rcar_priv *p;
436 	struct resource *irq;
437 	struct gpio_chip *gpio_chip;
438 	struct irq_chip *irq_chip;
439 	struct device *dev = &pdev->dev;
440 	const char *name = dev_name(dev);
441 	unsigned int npins;
442 	int ret;
443 
444 	p = devm_kzalloc(dev, sizeof(*p), GFP_KERNEL);
445 	if (!p)
446 		return -ENOMEM;
447 
448 	p->dev = dev;
449 	spin_lock_init(&p->lock);
450 
451 	/* Get device configuration from DT node */
452 	ret = gpio_rcar_parse_dt(p, &npins);
453 	if (ret < 0)
454 		return ret;
455 
456 	platform_set_drvdata(pdev, p);
457 
458 	pm_runtime_enable(dev);
459 
460 	irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
461 	if (!irq) {
462 		dev_err(dev, "missing IRQ\n");
463 		ret = -EINVAL;
464 		goto err0;
465 	}
466 
467 	p->base = devm_platform_ioremap_resource(pdev, 0);
468 	if (IS_ERR(p->base)) {
469 		ret = PTR_ERR(p->base);
470 		goto err0;
471 	}
472 
473 	gpio_chip = &p->gpio_chip;
474 	gpio_chip->request = gpio_rcar_request;
475 	gpio_chip->free = gpio_rcar_free;
476 	gpio_chip->get_direction = gpio_rcar_get_direction;
477 	gpio_chip->direction_input = gpio_rcar_direction_input;
478 	gpio_chip->get = gpio_rcar_get;
479 	gpio_chip->direction_output = gpio_rcar_direction_output;
480 	gpio_chip->set = gpio_rcar_set;
481 	gpio_chip->set_multiple = gpio_rcar_set_multiple;
482 	gpio_chip->label = name;
483 	gpio_chip->parent = dev;
484 	gpio_chip->owner = THIS_MODULE;
485 	gpio_chip->base = -1;
486 	gpio_chip->ngpio = npins;
487 
488 	irq_chip = &p->irq_chip;
489 	irq_chip->name = "gpio-rcar";
490 	irq_chip->parent_device = dev;
491 	irq_chip->irq_mask = gpio_rcar_irq_disable;
492 	irq_chip->irq_unmask = gpio_rcar_irq_enable;
493 	irq_chip->irq_set_type = gpio_rcar_irq_set_type;
494 	irq_chip->irq_set_wake = gpio_rcar_irq_set_wake;
495 	irq_chip->flags = IRQCHIP_SET_TYPE_MASKED | IRQCHIP_MASK_ON_SUSPEND;
496 
497 	ret = gpiochip_add_data(gpio_chip, p);
498 	if (ret) {
499 		dev_err(dev, "failed to add GPIO controller\n");
500 		goto err0;
501 	}
502 
503 	ret = gpiochip_irqchip_add(gpio_chip, irq_chip, 0, handle_level_irq,
504 				   IRQ_TYPE_NONE);
505 	if (ret) {
506 		dev_err(dev, "cannot add irqchip\n");
507 		goto err1;
508 	}
509 
510 	p->irq_parent = irq->start;
511 	if (devm_request_irq(dev, irq->start, gpio_rcar_irq_handler,
512 			     IRQF_SHARED, name, p)) {
513 		dev_err(dev, "failed to request IRQ\n");
514 		ret = -ENOENT;
515 		goto err1;
516 	}
517 
518 	dev_info(dev, "driving %d GPIOs\n", npins);
519 
520 	return 0;
521 
522 err1:
523 	gpiochip_remove(gpio_chip);
524 err0:
525 	pm_runtime_disable(dev);
526 	return ret;
527 }
528 
529 static int gpio_rcar_remove(struct platform_device *pdev)
530 {
531 	struct gpio_rcar_priv *p = platform_get_drvdata(pdev);
532 
533 	gpiochip_remove(&p->gpio_chip);
534 
535 	pm_runtime_disable(&pdev->dev);
536 	return 0;
537 }
538 
539 #ifdef CONFIG_PM_SLEEP
540 static int gpio_rcar_suspend(struct device *dev)
541 {
542 	struct gpio_rcar_priv *p = dev_get_drvdata(dev);
543 
544 	p->bank_info.iointsel = gpio_rcar_read(p, IOINTSEL);
545 	p->bank_info.inoutsel = gpio_rcar_read(p, INOUTSEL);
546 	p->bank_info.outdt = gpio_rcar_read(p, OUTDT);
547 	p->bank_info.intmsk = gpio_rcar_read(p, INTMSK);
548 	p->bank_info.posneg = gpio_rcar_read(p, POSNEG);
549 	p->bank_info.edglevel = gpio_rcar_read(p, EDGLEVEL);
550 	if (p->has_both_edge_trigger)
551 		p->bank_info.bothedge = gpio_rcar_read(p, BOTHEDGE);
552 
553 	if (atomic_read(&p->wakeup_path))
554 		device_set_wakeup_path(dev);
555 
556 	return 0;
557 }
558 
559 static int gpio_rcar_resume(struct device *dev)
560 {
561 	struct gpio_rcar_priv *p = dev_get_drvdata(dev);
562 	unsigned int offset;
563 	u32 mask;
564 
565 	for (offset = 0; offset < p->gpio_chip.ngpio; offset++) {
566 		if (!gpiochip_line_is_valid(&p->gpio_chip, offset))
567 			continue;
568 
569 		mask = BIT(offset);
570 		/* I/O pin */
571 		if (!(p->bank_info.iointsel & mask)) {
572 			if (p->bank_info.inoutsel & mask)
573 				gpio_rcar_direction_output(
574 					&p->gpio_chip, offset,
575 					!!(p->bank_info.outdt & mask));
576 			else
577 				gpio_rcar_direction_input(&p->gpio_chip,
578 							  offset);
579 		} else {
580 			/* Interrupt pin */
581 			gpio_rcar_config_interrupt_input_mode(
582 				p,
583 				offset,
584 				!(p->bank_info.posneg & mask),
585 				!(p->bank_info.edglevel & mask),
586 				!!(p->bank_info.bothedge & mask));
587 
588 			if (p->bank_info.intmsk & mask)
589 				gpio_rcar_write(p, MSKCLR, mask);
590 		}
591 	}
592 
593 	return 0;
594 }
595 #endif /* CONFIG_PM_SLEEP*/
596 
597 static SIMPLE_DEV_PM_OPS(gpio_rcar_pm_ops, gpio_rcar_suspend, gpio_rcar_resume);
598 
599 static struct platform_driver gpio_rcar_device_driver = {
600 	.probe		= gpio_rcar_probe,
601 	.remove		= gpio_rcar_remove,
602 	.driver		= {
603 		.name	= "gpio_rcar",
604 		.pm     = &gpio_rcar_pm_ops,
605 		.of_match_table = of_match_ptr(gpio_rcar_of_table),
606 	}
607 };
608 
609 module_platform_driver(gpio_rcar_device_driver);
610 
611 MODULE_AUTHOR("Magnus Damm");
612 MODULE_DESCRIPTION("Renesas R-Car GPIO Driver");
613 MODULE_LICENSE("GPL v2");
614