1 From 69f26eddc66378e33866cb30fc36309cd1d71b4a Mon Sep 17 00:00:00 2001
2 From: Phil Elwell <phil@raspberrypi.com>
3 Date: Wed, 30 Sep 2020 12:00:54 +0100
4 Subject: [PATCH] gpio: Add gpio-fsm driver
6 The gpio-fsm driver implements simple state machines that allow GPIOs
7 to be controlled in response to inputs from other GPIOs - real and
8 soft/virtual - and time delays. It can:
9 + create dummy GPIOs for drivers that demand them,
10 + drive multiple GPIOs from a single input, with optional delays,
11 + add a debounce circuit to an input,
12 + drive pattern sequences onto LEDs
15 Signed-off-by: Phil Elwell <phil@raspberrypi.com>
17 drivers/gpio/Kconfig | 9 +
18 drivers/gpio/Makefile | 1 +
19 drivers/gpio/gpio-fsm.c | 1103 +++++++++++++++++++++++++++
20 include/dt-bindings/gpio/gpio-fsm.h | 21 +
21 4 files changed, 1134 insertions(+)
22 create mode 100644 drivers/gpio/gpio-fsm.c
23 create mode 100644 include/dt-bindings/gpio/gpio-fsm.h
25 --- a/drivers/gpio/Kconfig
26 +++ b/drivers/gpio/Kconfig
27 @@ -1164,6 +1164,15 @@ config HTC_EGPIO
28 several HTC phones. It provides basic support for input
29 pins, output pins, and irqs.
32 + tristate "GPIO FSM support"
34 + The GPIO FSM driver allows the creation of state machines for
35 + manipulating GPIOs (both real and virtual), with state transitions
36 + triggered by GPIO edges or delays.
41 tristate "Janz VMOD-TTL Digital IO Module"
42 depends on MFD_JANZ_CMODIO
43 --- a/drivers/gpio/Makefile
44 +++ b/drivers/gpio/Makefile
45 @@ -61,6 +61,7 @@ obj-$(CONFIG_GPIO_EP93XX) += gpio-ep93x
46 obj-$(CONFIG_GPIO_EXAR) += gpio-exar.o
47 obj-$(CONFIG_GPIO_F7188X) += gpio-f7188x.o
48 obj-$(CONFIG_GPIO_FTGPIO010) += gpio-ftgpio010.o
49 +obj-$(CONFIG_GPIO_FSM) += gpio-fsm.o
50 obj-$(CONFIG_GPIO_GE_FPGA) += gpio-ge.o
51 obj-$(CONFIG_GPIO_GPIO_MM) += gpio-gpio-mm.o
52 obj-$(CONFIG_GPIO_GRGPIO) += gpio-grgpio.o
54 +++ b/drivers/gpio/gpio-fsm.c
56 +// SPDX-License-Identifier: GPL-2.0+
60 + * This driver implements simple state machines that allow real GPIOs to be
61 + * controlled in response to inputs from other GPIOs - real and soft/virtual -
62 + * and time delays. It can:
63 + * + create dummy GPIOs for drivers that demand them
64 + * + drive multiple GPIOs from a single input, with optional delays
65 + * + add a debounce circuit to an input
66 + * + drive pattern sequences onto LEDs
69 + * Copyright (C) 2020 Raspberry Pi (Trading) Ltd.
72 +#include <linux/err.h>
73 +#include <linux/gpio.h>
74 +#include <linux/gpio/driver.h>
75 +#include <linux/interrupt.h>
76 +#include <linux/module.h>
77 +#include <linux/platform_device.h>
79 +#include <dt-bindings/gpio/gpio-fsm.h>
81 +#define MODULE_NAME "gpio-fsm"
83 +#define GF_IO_TYPE(x) ((u32)(x) & 0xffff)
84 +#define GF_IO_INDEX(x) ((u32)(x) >> 16)
111 +struct input_gpio_state {
112 + struct gpio_fsm *gf;
113 + struct gpio_desc *desc;
114 + struct fsm_state *target;
125 + struct fsm_state *target;
128 +struct symtab_entry {
131 + struct symtab_entry *next;
134 +struct output_signal {
142 + struct output_signal *signals;
143 + struct gpio_event *gpio_events;
144 + struct gpio_event *soft_events;
145 + struct fsm_state *delay_target;
146 + struct fsm_state *shutdown_target;
147 + unsigned int num_signals;
148 + unsigned int num_gpio_events;
149 + unsigned int num_soft_events;
150 + unsigned int delay_ms;
151 + unsigned int shutdown_ms;
155 + struct gpio_chip gc;
156 + struct device *dev;
157 + spinlock_t spinlock;
158 + struct work_struct work;
159 + struct timer_list timer;
160 + wait_queue_head_t shutdown_event;
161 + struct fsm_state *states;
162 + struct input_gpio_state *input_gpio_states;
163 + struct gpio_descs *input_gpios;
164 + struct gpio_descs *output_gpios;
165 + struct soft_gpio *soft_gpios;
166 + struct fsm_state *start_state;
167 + struct fsm_state *shutdown_state;
168 + unsigned int num_states;
169 + unsigned int num_output_gpios;
170 + unsigned int num_input_gpios;
171 + unsigned int num_soft_gpios;
172 + unsigned int shutdown_timeout_ms;
173 + unsigned int shutdown_jiffies;
175 + struct fsm_state *current_state;
176 + struct fsm_state *next_state;
177 + struct fsm_state *delay_target_state;
179 + unsigned int debug;
180 + bool shutting_down;
181 + struct symtab_entry *symtab;
184 +static struct symtab_entry *do_add_symbol(struct symtab_entry **symtab,
185 + const char *name, void *value)
187 + struct symtab_entry **p = symtab;
189 + while (*p && strcmp((*p)->name, name))
193 + /* This is an existing symbol */
195 + /* Already defined */
197 + if ((uintptr_t)value < SYM_MAX)
198 + return ERR_PTR(-EINVAL);
200 + return ERR_PTR(-EEXIST);
204 + (*p)->value = value;
207 + /* This is a new symbol */
208 + *p = kmalloc(sizeof(struct symtab_entry), GFP_KERNEL);
211 + (*p)->value = value;
218 +static int add_symbol(struct symtab_entry **symtab,
219 + const char *name, void *value)
221 + struct symtab_entry *sym = do_add_symbol(symtab, name, value);
223 + return PTR_ERR_OR_ZERO(sym);
226 +static struct symtab_entry *get_symbol(struct symtab_entry **symtab,
229 + struct symtab_entry *sym = do_add_symbol(symtab, name, NULL);
236 +static void free_symbols(struct symtab_entry **symtab)
238 + struct symtab_entry *sym = *symtab;
249 +static int gpio_fsm_get_direction(struct gpio_chip *gc, unsigned int off)
251 + struct gpio_fsm *gf = gpiochip_get_data(gc);
252 + struct soft_gpio *sg;
254 + if (off >= gf->num_soft_gpios)
256 + sg = &gf->soft_gpios[off];
261 +static int gpio_fsm_get(struct gpio_chip *gc, unsigned int off)
263 + struct gpio_fsm *gf = gpiochip_get_data(gc);
264 + struct soft_gpio *sg;
266 + if (off >= gf->num_soft_gpios)
268 + sg = &gf->soft_gpios[off];
273 +static void gpio_fsm_go_to_state(struct gpio_fsm *gf,
274 + struct fsm_state *new_state)
276 + struct input_gpio_state *inp_state;
277 + struct gpio_event *gp_ev;
278 + struct fsm_state *state;
281 + dev_dbg(gf->dev, "go_to_state(%s)\n",
282 + new_state ? new_state->name : "<unset>");
284 + spin_lock(&gf->spinlock);
286 + if (gf->next_state) {
287 + /* Something else has already requested a transition */
288 + spin_unlock(&gf->spinlock);
292 + gf->next_state = new_state;
293 + state = gf->current_state;
294 + gf->delay_target_state = NULL;
297 + /* Disarm any GPIO IRQs */
298 + for (i = 0; i < state->num_gpio_events; i++) {
299 + gp_ev = &state->gpio_events[i];
300 + inp_state = &gf->input_gpio_states[gp_ev->index];
301 + inp_state->target = NULL;
305 + spin_unlock(&gf->spinlock);
308 + schedule_work(&gf->work);
311 +static void gpio_fsm_set_soft(struct gpio_fsm *gf,
312 + unsigned int off, int val)
314 + struct soft_gpio *sg = &gf->soft_gpios[off];
315 + struct gpio_event *gp_ev;
316 + struct fsm_state *state;
319 + dev_dbg(gf->dev, "set(%d,%d)\n", off, val);
320 + state = gf->current_state;
322 + for (i = 0; i < state->num_soft_events; i++) {
323 + gp_ev = &state->soft_events[i];
324 + if (gp_ev->index == off && gp_ev->value == val) {
327 + "GF_SOFT %d->%d -> %s\n", gp_ev->index,
328 + gp_ev->value, gp_ev->target->name);
329 + gpio_fsm_go_to_state(gf, gp_ev->target);
335 +static int gpio_fsm_direction_input(struct gpio_chip *gc, unsigned int off)
337 + struct gpio_fsm *gf = gpiochip_get_data(gc);
338 + struct soft_gpio *sg;
340 + if (off >= gf->num_soft_gpios)
342 + sg = &gf->soft_gpios[off];
343 + sg->dir = GPIOF_DIR_IN;
348 +static int gpio_fsm_direction_output(struct gpio_chip *gc, unsigned int off,
351 + struct gpio_fsm *gf = gpiochip_get_data(gc);
352 + struct soft_gpio *sg;
354 + if (off >= gf->num_soft_gpios)
356 + sg = &gf->soft_gpios[off];
357 + sg->dir = GPIOF_DIR_OUT;
358 + gpio_fsm_set_soft(gf, off, value);
363 +static void gpio_fsm_set(struct gpio_chip *gc, unsigned int off, int val)
365 + struct gpio_fsm *gf;
367 + gf = gpiochip_get_data(gc);
368 + if (off < gf->num_soft_gpios)
369 + gpio_fsm_set_soft(gf, off, val);
372 +static void gpio_fsm_enter_state(struct gpio_fsm *gf,
373 + struct fsm_state *state)
375 + struct input_gpio_state *inp_state;
376 + struct output_signal *signal;
377 + struct gpio_event *event;
378 + struct gpio_desc *gpiod;
379 + struct soft_gpio *soft;
383 + dev_dbg(gf->dev, "enter_state(%s)\n", state->name);
385 + gf->current_state = state;
387 + // 1. Apply any listed signals
388 + for (i = 0; i < state->num_signals; i++) {
389 + signal = &state->signals[i];
392 + dev_info(gf->dev, " set %s %d->%d\n",
393 + (signal->type == SIGNAL_GPIO) ? "GF_OUT" :
395 + signal->index, signal->value);
396 + switch (signal->type) {
398 + gpiod = gf->output_gpios->desc[signal->index];
399 + gpiod_set_value_cansleep(gpiod, signal->value);
402 + soft = &gf->soft_gpios[signal->index];
403 + gpio_fsm_set_soft(gf, signal->index, signal->value);
408 + // 2. Exit if successfully reached shutdown state
409 + if (gf->shutting_down && state == state->shutdown_target) {
410 + wake_up(&gf->shutdown_event);
414 + // 3. Schedule a timer callback if shutting down
415 + if (state->shutdown_target) {
416 + // Remember the absolute shutdown time in case remove is called
417 + // at a later time.
418 + gf->shutdown_jiffies =
419 + jiffies + msecs_to_jiffies(state->shutdown_ms);
421 + if (gf->shutting_down) {
422 + gf->delay_target_state = state->shutdown_target;
423 + gf->delay_ms = state->shutdown_ms;
424 + mod_timer(&gf->timer, gf->shutdown_jiffies);
428 + // During shutdown, skip everything else
429 + if (gf->shutting_down)
432 + // Otherwise record what the shutdown time would be
433 + gf->shutdown_jiffies = jiffies + msecs_to_jiffies(state->shutdown_ms);
435 + // 4. Check soft inputs for transitions to take
436 + for (i = 0; i < state->num_soft_events; i++) {
437 + event = &state->soft_events[i];
438 + if (gf->soft_gpios[event->index].value == event->value) {
441 + "GF_SOFT %d=%d -> %s\n", event->index,
442 + event->value, event->target->name);
443 + gpio_fsm_go_to_state(gf, event->target);
448 + // 5. Check GPIOs for transitions to take, enabling the IRQs
449 + for (i = 0; i < state->num_gpio_events; i++) {
450 + event = &state->gpio_events[i];
451 + inp_state = &gf->input_gpio_states[event->index];
452 + inp_state->target = event->target;
453 + inp_state->value = event->value;
454 + inp_state->enabled = true;
456 + value = gpiod_get_value(gf->input_gpios->desc[event->index]);
458 + // Clear stale event state
459 + disable_irq(inp_state->irq);
461 + irq_set_irq_type(inp_state->irq,
462 + (inp_state->value ^ inp_state->active_low) ?
463 + IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING);
464 + enable_irq(inp_state->irq);
466 + if (value == event->value && inp_state->target) {
469 + "GF_IN %d=%d -> %s\n", event->index,
470 + event->value, event->target->name);
471 + gpio_fsm_go_to_state(gf, event->target);
476 + // 6. Schedule a timer callback if delay_target
477 + if (state->delay_target) {
478 + gf->delay_target_state = state->delay_target;
479 + gf->delay_ms = state->delay_ms;
480 + mod_timer(&gf->timer,
481 + jiffies + msecs_to_jiffies(state->delay_ms));
485 +static void gpio_fsm_work(struct work_struct *work)
487 + struct input_gpio_state *inp_state;
488 + struct fsm_state *new_state;
489 + struct fsm_state *state;
490 + struct gpio_event *gp_ev;
491 + struct gpio_fsm *gf;
494 + gf = container_of(work, struct gpio_fsm, work);
495 + spin_lock(&gf->spinlock);
496 + state = gf->current_state;
497 + new_state = gf->next_state;
499 + new_state = gf->delay_target_state;
500 + gf->next_state = NULL;
501 + gf->delay_target_state = NULL;
502 + spin_unlock(&gf->spinlock);
505 + /* Disable any enabled GPIO IRQs */
506 + for (i = 0; i < state->num_gpio_events; i++) {
507 + gp_ev = &state->gpio_events[i];
508 + inp_state = &gf->input_gpio_states[gp_ev->index];
509 + if (inp_state->enabled) {
510 + inp_state->enabled = false;
511 + irq_set_irq_type(inp_state->irq,
512 + IRQF_TRIGGER_NONE);
518 + gpio_fsm_enter_state(gf, new_state);
521 +static irqreturn_t gpio_fsm_gpio_irq_handler(int irq, void *dev_id)
523 + struct input_gpio_state *inp_state = dev_id;
524 + struct gpio_fsm *gf = inp_state->gf;
525 + struct fsm_state *target;
527 + target = inp_state->target;
531 + /* If the IRQ has fired then the desired state _must_ have occurred */
532 + inp_state->enabled = false;
533 + irq_set_irq_type(inp_state->irq, IRQF_TRIGGER_NONE);
535 + dev_info(gf->dev, "GF_IN %d->%d -> %s\n",
536 + inp_state->index, inp_state->value, target->name);
537 + gpio_fsm_go_to_state(gf, target);
538 + return IRQ_HANDLED;
541 +static void gpio_fsm_timer(struct timer_list *timer)
543 + struct gpio_fsm *gf = container_of(timer, struct gpio_fsm, timer);
544 + struct fsm_state *target;
546 + target = gf->delay_target_state;
551 + dev_info(gf->dev, "GF_DELAY %d -> %s\n", gf->delay_ms,
554 + gpio_fsm_go_to_state(gf, target);
557 +int gpio_fsm_parse_signals(struct gpio_fsm *gf, struct fsm_state *state,
558 + struct property *prop)
560 + const __be32 *cells = prop->value;
561 + struct output_signal *signal;
569 + if (prop->length % 8) {
570 + dev_err(gf->dev, "malformed set in state %s\n",
575 + state->num_signals = prop->length/8;
576 + state->signals = devm_kcalloc(gf->dev, state->num_signals,
577 + sizeof(struct output_signal),
579 + for (i = 0; i < state->num_signals; i++) {
580 + signal = &state->signals[i];
581 + io = be32_to_cpu(cells[0]);
582 + type = GF_IO_TYPE(io);
583 + index = GF_IO_INDEX(io);
584 + value = be32_to_cpu(cells[1]);
586 + if (type != GF_OUT && type != GF_SOFT) {
588 + "invalid set type %d in state %s\n",
589 + type, state->name);
593 + if (type == GF_OUT && index >= gf->num_output_gpios) {
595 + "invalid GF_OUT number %d in state %s\n",
596 + index, state->name);
600 + if (type == GF_SOFT && index >= gf->num_soft_gpios) {
602 + "invalid GF_SOFT number %d in state %s\n",
603 + index, state->name);
607 + if (value != 0 && value != 1) {
609 + "invalid set value %d in state %s\n",
610 + value, state->name);
614 + signal->type = (type == GF_OUT) ? SIGNAL_GPIO : SIGNAL_SOFT;
615 + signal->index = index;
616 + signal->value = value;
623 +struct gpio_event *new_event(struct gpio_event **events, int *num_events)
625 + int num = ++(*num_events);
626 + *events = krealloc(*events, num * sizeof(struct gpio_event),
628 + return *events ? *events + (num - 1) : NULL;
631 +int gpio_fsm_parse_events(struct gpio_fsm *gf, struct fsm_state *state,
632 + struct property *prop)
634 + const __be32 *cells = prop->value;
635 + struct symtab_entry *sym;
640 + if (prop->length % 8) {
642 + "malformed transitions from state %s to state %s\n",
643 + state->name, prop->name);
647 + sym = get_symbol(&gf->symtab, prop->name);
648 + num_cells = prop->length / 4;
650 + while (i < num_cells) {
651 + struct gpio_event *gp_ev;
655 + event = be32_to_cpu(cells[i++]);
656 + param = be32_to_cpu(cells[i++]);
657 + index = GF_IO_INDEX(event);
659 + switch (GF_IO_TYPE(event)) {
661 + if (index >= gf->num_input_gpios) {
663 + "invalid GF_IN %d in transitions from state %s to state %s\n",
664 + index, state->name, prop->name);
669 + "invalid GF_IN value %d in transitions from state %s to state %s\n",
670 + param, state->name, prop->name);
673 + gp_ev = new_event(&state->gpio_events,
674 + &state->num_gpio_events);
677 + gp_ev->index = index;
678 + gp_ev->value = param;
679 + gp_ev->target = (struct fsm_state *)sym;
683 + if (index >= gf->num_soft_gpios) {
685 + "invalid GF_SOFT %d in transitions from state %s to state %s\n",
686 + index, state->name, prop->name);
691 + "invalid GF_SOFT value %d in transitions from state %s to state %s\n",
692 + param, state->name, prop->name);
695 + gp_ev = new_event(&state->soft_events,
696 + &state->num_soft_events);
699 + gp_ev->index = index;
700 + gp_ev->value = param;
701 + gp_ev->target = (struct fsm_state *)sym;
705 + if (state->delay_target) {
707 + "state %s has multiple GF_DELAYs\n",
711 + state->delay_target = (struct fsm_state *)sym;
712 + state->delay_ms = param;
716 + if (state->shutdown_target == state) {
718 + "shutdown state %s has GF_SHUTDOWN\n",
721 + } else if (state->shutdown_target) {
723 + "state %s has multiple GF_SHUTDOWNs\n",
727 + state->shutdown_target =
728 + (struct fsm_state *)sym;
729 + state->shutdown_ms = param;
734 + "invalid event %08x in transitions from state %s to state %s\n",
735 + event, state->name, prop->name);
739 + if (i != num_cells) {
741 + "malformed transitions from state %s to state %s\n",
742 + state->name, prop->name);
749 +int gpio_fsm_parse_state(struct gpio_fsm *gf,
750 + struct fsm_state *state,
751 + struct device_node *np)
753 + struct symtab_entry *sym;
754 + struct property *prop;
757 + state->name = np->name;
758 + ret = add_symbol(&gf->symtab, np->name, state);
762 + dev_err(gf->dev, "'%s' is not a valid state name\n",
766 + dev_err(gf->dev, "state %s already defined\n",
770 + dev_err(gf->dev, "error %d adding state %s symbol\n",
777 + for_each_property_of_node(np, prop) {
778 + sym = get_symbol(&gf->symtab, prop->name);
784 + switch ((uintptr_t)sym->value) {
786 + ret = gpio_fsm_parse_signals(gf, state, prop);
789 + if (gf->start_state) {
790 + dev_err(gf->dev, "multiple start states\n");
793 + gf->start_state = state;
797 + state->shutdown_target = state;
798 + gf->shutdown_state = state;
804 + /* A set of transition events to this state */
805 + ret = gpio_fsm_parse_events(gf, state, prop);
813 +static void dump_all(struct gpio_fsm *gf)
817 + dev_info(gf->dev, "Input GPIOs:\n");
818 + for (i = 0; i < gf->num_input_gpios; i++)
819 + dev_info(gf->dev, " %d: %p\n", i,
820 + gf->input_gpios->desc[i]);
822 + dev_info(gf->dev, "Output GPIOs:\n");
823 + for (i = 0; i < gf->num_output_gpios; i++)
824 + dev_info(gf->dev, " %d: %p\n", i,
825 + gf->output_gpios->desc[i]);
827 + dev_info(gf->dev, "Soft GPIOs:\n");
828 + for (i = 0; i < gf->num_soft_gpios; i++)
829 + dev_info(gf->dev, " %d: %s %d\n", i,
830 + (gf->soft_gpios[i].dir == GPIOF_DIR_IN) ? "IN" : "OUT",
831 + gf->soft_gpios[i].value);
833 + dev_info(gf->dev, "Start state: %s\n",
834 + gf->start_state ? gf->start_state->name : "-");
836 + dev_info(gf->dev, "Shutdown timeout: %d ms\n",
837 + gf->shutdown_timeout_ms);
839 + for (i = 0; i < gf->num_states; i++) {
840 + struct fsm_state *state = &gf->states[i];
842 + dev_info(gf->dev, "State %s:\n", state->name);
844 + if (state->shutdown_target == state)
845 + dev_info(gf->dev, " Shutdown state\n");
847 + dev_info(gf->dev, " Signals:\n");
848 + for (j = 0; j < state->num_signals; j++) {
849 + struct output_signal *signal = &state->signals[j];
851 + dev_info(gf->dev, " %d: %s %d=%d\n", j,
852 + (signal->type == SIGNAL_GPIO) ? "GPIO" :
854 + signal->index, signal->value);
857 + dev_info(gf->dev, " GPIO events:\n");
858 + for (j = 0; j < state->num_gpio_events; j++) {
859 + struct gpio_event *event = &state->gpio_events[j];
861 + dev_info(gf->dev, " %d: %d=%d -> %s\n", j,
862 + event->index, event->value,
863 + event->target->name);
866 + dev_info(gf->dev, " Soft events:\n");
867 + for (j = 0; j < state->num_soft_events; j++) {
868 + struct gpio_event *event = &state->soft_events[j];
870 + dev_info(gf->dev, " %d: %d=%d -> %s\n", j,
871 + event->index, event->value,
872 + event->target->name);
875 + if (state->delay_target)
876 + dev_info(gf->dev, " Delay: %d ms -> %s\n",
877 + state->delay_ms, state->delay_target->name);
879 + if (state->shutdown_target && state->shutdown_target != state)
880 + dev_info(gf->dev, " Shutdown: %d ms -> %s\n",
881 + state->shutdown_ms,
882 + state->shutdown_target->name);
884 + dev_info(gf->dev, "\n");
887 +static int resolve_sym_to_state(struct gpio_fsm *gf, struct fsm_state **pstate)
889 + struct symtab_entry *sym = (struct symtab_entry *)*pstate;
894 + *pstate = sym->value;
897 + dev_err(gf->dev, "state %s not defined\n",
905 +static int gpio_fsm_probe(struct platform_device *pdev)
907 + struct input_gpio_state *inp_state;
908 + struct device *dev = &pdev->dev;
909 + struct device_node *np = dev->of_node;
910 + struct device_node *cp;
911 + struct gpio_fsm *gf;
914 + u32 num_soft_gpios;
917 + static const char *const reserved_symbols[] = {
918 + [SYM_NAME] = "name",
920 + [SYM_START] = "start_state",
921 + [SYM_SHUTDOWN] = "shutdown_state",
924 + if (of_property_read_u32(np, "num-soft-gpios", &num_soft_gpios)) {
925 + dev_err(dev, "missing 'num-soft-gpios' property\n");
929 + of_property_read_u32(np, "debug", &debug);
931 + gf = devm_kzalloc(dev, sizeof(*gf), GFP_KERNEL);
938 + if (of_property_read_u32(np, "shutdown-timeout-ms",
939 + &gf->shutdown_timeout_ms))
940 + gf->shutdown_timeout_ms = 5000;
942 + gf->num_soft_gpios = num_soft_gpios;
943 + gf->soft_gpios = devm_kcalloc(dev, num_soft_gpios,
944 + sizeof(struct soft_gpio), GFP_KERNEL);
945 + if (!gf->soft_gpios)
947 + for (i = 0; i < num_soft_gpios; i++) {
948 + struct soft_gpio *sg = &gf->soft_gpios[i];
950 + sg->dir = GPIOF_DIR_IN;
954 + gf->input_gpios = devm_gpiod_get_array_optional(dev, "input", GPIOD_IN);
955 + if (IS_ERR(gf->input_gpios)) {
956 + ret = PTR_ERR(gf->input_gpios);
957 + dev_err(dev, "failed to get input gpios from DT - %d\n", ret);
960 + gf->num_input_gpios = (gf->input_gpios ? gf->input_gpios->ndescs : 0);
962 + gf->input_gpio_states = devm_kcalloc(dev, gf->num_input_gpios,
963 + sizeof(struct input_gpio_state),
965 + if (!gf->input_gpio_states)
967 + for (i = 0; i < gf->num_input_gpios; i++) {
968 + inp_state = &gf->input_gpio_states[i];
969 + inp_state->desc = gf->input_gpios->desc[i];
970 + inp_state->gf = gf;
971 + inp_state->index = i;
972 + inp_state->irq = gpiod_to_irq(inp_state->desc);
973 + inp_state->active_low = gpiod_is_active_low(inp_state->desc);
974 + if (inp_state->irq >= 0)
975 + ret = devm_request_irq(gf->dev, inp_state->irq,
976 + gpio_fsm_gpio_irq_handler,
981 + ret = inp_state->irq;
985 + "failed to get IRQ for input gpio - %d\n",
991 + gf->output_gpios = devm_gpiod_get_array_optional(dev, "output",
993 + if (IS_ERR(gf->output_gpios)) {
994 + ret = PTR_ERR(gf->output_gpios);
995 + dev_err(dev, "failed to get output gpios from DT - %d\n", ret);
998 + gf->num_output_gpios = (gf->output_gpios ? gf->output_gpios->ndescs :
1001 + num_states = of_get_child_count(np);
1002 + if (!num_states) {
1003 + dev_err(dev, "no states declared\n");
1006 + gf->states = devm_kcalloc(dev, num_states,
1007 + sizeof(struct fsm_state), GFP_KERNEL);
1011 + // add reserved words to the symbol table
1012 + for (i = 0; i < ARRAY_SIZE(reserved_symbols); i++) {
1013 + if (reserved_symbols[i])
1014 + add_symbol(&gf->symtab, reserved_symbols[i], (void *)i);
1017 + // parse the state
1018 + for_each_child_of_node(np, cp) {
1019 + struct fsm_state *state = &gf->states[gf->num_states];
1021 + ret = gpio_fsm_parse_state(gf, state, cp);
1027 + if (!gf->start_state) {
1028 + dev_err(gf->dev, "no start state defined\n");
1032 + // resolve symbol pointers into state pointers
1033 + for (i = 0; !ret && i < gf->num_states; i++) {
1034 + struct fsm_state *state = &gf->states[i];
1037 + for (j = 0; !ret && j < state->num_gpio_events; j++) {
1038 + struct gpio_event *ev = &state->gpio_events[j];
1040 + ret = resolve_sym_to_state(gf, &ev->target);
1043 + for (j = 0; !ret && j < state->num_soft_events; j++) {
1044 + struct gpio_event *ev = &state->soft_events[j];
1046 + ret = resolve_sym_to_state(gf, &ev->target);
1050 + resolve_sym_to_state(gf, &state->delay_target);
1051 + if (state->shutdown_target != state)
1052 + resolve_sym_to_state(gf,
1053 + &state->shutdown_target);
1057 + if (!ret && gf->debug > 1)
1060 + free_symbols(&gf->symtab);
1065 + gf->gc.parent = dev;
1066 + gf->gc.label = np->name;
1067 + gf->gc.owner = THIS_MODULE;
1068 + gf->gc.of_node = np;
1070 + gf->gc.ngpio = num_soft_gpios;
1072 + gf->gc.get_direction = gpio_fsm_get_direction;
1073 + gf->gc.direction_input = gpio_fsm_direction_input;
1074 + gf->gc.direction_output = gpio_fsm_direction_output;
1075 + gf->gc.get = gpio_fsm_get;
1076 + gf->gc.set = gpio_fsm_set;
1077 + gf->gc.can_sleep = true;
1078 + spin_lock_init(&gf->spinlock);
1079 + INIT_WORK(&gf->work, gpio_fsm_work);
1080 + timer_setup(&gf->timer, gpio_fsm_timer, 0);
1081 + init_waitqueue_head(&gf->shutdown_event);
1083 + platform_set_drvdata(pdev, gf);
1086 + dev_info(gf->dev, "Start -> %s\n", gf->start_state->name);
1088 + gpio_fsm_go_to_state(gf, gf->start_state);
1090 + return devm_gpiochip_add_data(dev, &gf->gc, gf);
1093 +static int gpio_fsm_remove(struct platform_device *pdev)
1095 + struct gpio_fsm *gf = platform_get_drvdata(pdev);
1098 + if (gf->shutdown_state) {
1100 + dev_info(gf->dev, "Shutting down...\n");
1102 + spin_lock(&gf->spinlock);
1103 + gf->shutting_down = true;
1104 + if (gf->current_state->shutdown_target &&
1105 + gf->current_state->shutdown_target != gf->current_state) {
1106 + gf->delay_target_state =
1107 + gf->current_state->shutdown_target;
1108 + mod_timer(&gf->timer, gf->shutdown_jiffies);
1110 + spin_unlock(&gf->spinlock);
1112 + wait_event_timeout(gf->shutdown_event,
1113 + gf->current_state->shutdown_target ==
1114 + gf->current_state,
1115 + msecs_to_jiffies(gf->shutdown_timeout_ms));
1116 + if (gf->current_state->shutdown_target == gf->current_state)
1117 + gpio_fsm_enter_state(gf, gf->shutdown_state);
1119 + cancel_work_sync(&gf->work);
1120 + del_timer_sync(&gf->timer);
1122 + /* Events aren't allocated from managed storage */
1123 + for (i = 0; i < gf->num_states; i++) {
1124 + kfree(gf->states[i].gpio_events);
1125 + kfree(gf->states[i].soft_events);
1128 + dev_info(gf->dev, "Exiting\n");
1133 +static void gpio_fsm_shutdown(struct platform_device *pdev)
1135 + gpio_fsm_remove(pdev);
1138 +static const struct of_device_id gpio_fsm_ids[] = {
1139 + { .compatible = "rpi,gpio-fsm" },
1142 +MODULE_DEVICE_TABLE(of, gpio_fsm_ids);
1144 +static struct platform_driver gpio_fsm_driver = {
1146 + .name = MODULE_NAME,
1147 + .of_match_table = of_match_ptr(gpio_fsm_ids),
1149 + .probe = gpio_fsm_probe,
1150 + .remove = gpio_fsm_remove,
1151 + .shutdown = gpio_fsm_shutdown,
1153 +module_platform_driver(gpio_fsm_driver);
1155 +MODULE_LICENSE("GPL");
1156 +MODULE_AUTHOR("Phil Elwell <phil@raspberrypi.com>");
1157 +MODULE_DESCRIPTION("GPIO FSM driver");
1158 +MODULE_ALIAS("platform:gpio-fsm");
1160 +++ b/include/dt-bindings/gpio/gpio-fsm.h
1162 +/* SPDX-License-Identifier: GPL-2.0+ */
1164 + * This header provides constants for binding rpi,gpio-fsm.
1167 +#ifndef _DT_BINDINGS_GPIO_FSM_H
1168 +#define _DT_BINDINGS_GPIO_FSM_H
1174 +#define GF_SHUTDOWN 4
1176 +#define GF_IO(t, v) (((v) << 16) | ((t) & 0xffff))
1178 +#define GF_IP(x) GF_IO(GF_IN, (x))
1179 +#define GF_OP(x) GF_IO(GF_OUT, (x))
1180 +#define GF_SW(x) GF_IO(GF_SOFT, (x))