1 // SPDX-License-Identifier: GPL-2.0+
5 * This driver implements simple state machines that allow real GPIOs to be
6 * controlled in response to inputs from other GPIOs - real and soft/virtual -
7 * and time delays. It can:
8 * + create dummy GPIOs for drivers that demand them
9 * + drive multiple GPIOs from a single input, with optional delays
10 * + add a debounce circuit to an input
11 * + drive pattern sequences onto LEDs
14 * Copyright (C) 2020 Raspberry Pi (Trading) Ltd.
17 #include <linux/err.h>
18 #include <linux/gpio.h>
19 #include <linux/gpio/driver.h>
20 #include <linux/interrupt.h>
21 #include <linux/module.h>
22 #include <linux/platform_device.h>
23 #include <linux/sysfs.h>
25 #include <dt-bindings/gpio/gpio-fsm.h>
27 #define MODULE_NAME "gpio-fsm"
29 #define GF_IO_TYPE(x) ((u32)(x) & 0xffff)
30 #define GF_IO_INDEX(x) ((u32)(x) >> 16)
57 struct input_gpio_state {
59 struct gpio_desc *desc;
60 struct fsm_state *target;
71 struct fsm_state *target;
77 struct symtab_entry *next;
80 struct output_signal {
88 struct output_signal *signals;
89 struct gpio_event *gpio_events;
90 struct gpio_event *soft_events;
91 struct fsm_state *delay_target;
92 struct fsm_state *shutdown_target;
93 unsigned int num_signals;
94 unsigned int num_gpio_events;
95 unsigned int num_soft_events;
96 unsigned int delay_ms;
97 unsigned int shutdown_ms;
104 struct work_struct work;
105 struct timer_list timer;
106 wait_queue_head_t shutdown_event;
107 struct fsm_state *states;
108 struct input_gpio_state *input_gpio_states;
109 struct gpio_descs *input_gpios;
110 struct gpio_descs *output_gpios;
111 struct soft_gpio *soft_gpios;
112 struct fsm_state *start_state;
113 struct fsm_state *shutdown_state;
114 unsigned int num_states;
115 unsigned int num_output_gpios;
116 unsigned int num_input_gpios;
117 unsigned int num_soft_gpios;
118 unsigned int shutdown_timeout_ms;
119 unsigned int shutdown_jiffies;
121 struct fsm_state *current_state;
122 struct fsm_state *next_state;
123 struct fsm_state *delay_target_state;
124 unsigned int delay_jiffies;
128 struct symtab_entry *symtab;
131 static struct symtab_entry *do_add_symbol(struct symtab_entry **symtab,
132 const char *name, void *value)
134 struct symtab_entry **p = symtab;
136 while (*p && strcmp((*p)->name, name))
140 /* This is an existing symbol */
142 /* Already defined */
144 if ((uintptr_t)value < SYM_MAX)
145 return ERR_PTR(-EINVAL);
147 return ERR_PTR(-EEXIST);
154 /* This is a new symbol */
155 *p = kmalloc(sizeof(struct symtab_entry), GFP_KERNEL);
165 static int add_symbol(struct symtab_entry **symtab,
166 const char *name, void *value)
168 struct symtab_entry *sym = do_add_symbol(symtab, name, value);
170 return PTR_ERR_OR_ZERO(sym);
173 static struct symtab_entry *get_symbol(struct symtab_entry **symtab,
176 struct symtab_entry *sym = do_add_symbol(symtab, name, NULL);
183 static void free_symbols(struct symtab_entry **symtab)
185 struct symtab_entry *sym = *symtab;
196 static int gpio_fsm_get_direction(struct gpio_chip *gc, unsigned int off)
198 struct gpio_fsm *gf = gpiochip_get_data(gc);
199 struct soft_gpio *sg;
201 if (off >= gf->num_soft_gpios)
203 sg = &gf->soft_gpios[off];
208 static int gpio_fsm_get(struct gpio_chip *gc, unsigned int off)
210 struct gpio_fsm *gf = gpiochip_get_data(gc);
211 struct soft_gpio *sg;
213 if (off >= gf->num_soft_gpios)
215 sg = &gf->soft_gpios[off];
220 static void gpio_fsm_go_to_state(struct gpio_fsm *gf,
221 struct fsm_state *new_state)
223 struct input_gpio_state *inp_state;
224 struct gpio_event *gp_ev;
225 struct fsm_state *state;
228 dev_dbg(gf->dev, "go_to_state(%s)\n",
229 new_state ? new_state->name : "<unset>");
231 spin_lock(&gf->spinlock);
233 if (gf->next_state) {
234 /* Something else has already requested a transition */
235 spin_unlock(&gf->spinlock);
239 gf->next_state = new_state;
240 state = gf->current_state;
241 gf->delay_target_state = NULL;
244 /* Disarm any GPIO IRQs */
245 for (i = 0; i < state->num_gpio_events; i++) {
246 gp_ev = &state->gpio_events[i];
247 inp_state = &gf->input_gpio_states[gp_ev->index];
248 inp_state->target = NULL;
252 spin_unlock(&gf->spinlock);
255 schedule_work(&gf->work);
258 static void gpio_fsm_set_soft(struct gpio_fsm *gf,
259 unsigned int off, int val)
261 struct soft_gpio *sg = &gf->soft_gpios[off];
262 struct gpio_event *gp_ev;
263 struct fsm_state *state;
266 dev_dbg(gf->dev, "set(%d,%d)\n", off, val);
267 state = gf->current_state;
269 for (i = 0; i < state->num_soft_events; i++) {
270 gp_ev = &state->soft_events[i];
271 if (gp_ev->index == off && gp_ev->value == val) {
274 "GF_SOFT %d->%d -> %s\n", gp_ev->index,
275 gp_ev->value, gp_ev->target->name);
276 gpio_fsm_go_to_state(gf, gp_ev->target);
282 static int gpio_fsm_direction_input(struct gpio_chip *gc, unsigned int off)
284 struct gpio_fsm *gf = gpiochip_get_data(gc);
285 struct soft_gpio *sg;
287 if (off >= gf->num_soft_gpios)
289 sg = &gf->soft_gpios[off];
290 sg->dir = GPIOF_DIR_IN;
295 static int gpio_fsm_direction_output(struct gpio_chip *gc, unsigned int off,
298 struct gpio_fsm *gf = gpiochip_get_data(gc);
299 struct soft_gpio *sg;
301 if (off >= gf->num_soft_gpios)
303 sg = &gf->soft_gpios[off];
304 sg->dir = GPIOF_DIR_OUT;
305 gpio_fsm_set_soft(gf, off, value);
310 static void gpio_fsm_set(struct gpio_chip *gc, unsigned int off, int val)
314 gf = gpiochip_get_data(gc);
315 if (off < gf->num_soft_gpios)
316 gpio_fsm_set_soft(gf, off, val);
319 static void gpio_fsm_enter_state(struct gpio_fsm *gf,
320 struct fsm_state *state)
322 struct input_gpio_state *inp_state;
323 struct output_signal *signal;
324 struct gpio_event *event;
325 struct gpio_desc *gpiod;
326 struct soft_gpio *soft;
330 dev_dbg(gf->dev, "enter_state(%s)\n", state->name);
332 gf->current_state = state;
334 // 1. Apply any listed signals
335 for (i = 0; i < state->num_signals; i++) {
336 signal = &state->signals[i];
339 dev_info(gf->dev, " set %s %d->%d\n",
340 (signal->type == SIGNAL_GPIO) ? "GF_OUT" :
342 signal->index, signal->value);
343 switch (signal->type) {
345 gpiod = gf->output_gpios->desc[signal->index];
346 gpiod_set_value_cansleep(gpiod, signal->value);
349 soft = &gf->soft_gpios[signal->index];
350 gpio_fsm_set_soft(gf, signal->index, signal->value);
355 // 2. Exit if successfully reached shutdown state
356 if (gf->shutting_down && state == state->shutdown_target) {
357 wake_up(&gf->shutdown_event);
361 // 3. Schedule a timer callback if shutting down
362 if (state->shutdown_target) {
363 // Remember the absolute shutdown time in case remove is called
365 gf->shutdown_jiffies =
366 jiffies + msecs_to_jiffies(state->shutdown_ms);
368 if (gf->shutting_down) {
369 gf->delay_jiffies = gf->shutdown_jiffies;
370 gf->delay_target_state = state->shutdown_target;
371 gf->delay_ms = state->shutdown_ms;
372 mod_timer(&gf->timer, gf->delay_jiffies);
376 // During shutdown, skip everything else
377 if (gf->shutting_down)
380 // Otherwise record what the shutdown time would be
381 gf->shutdown_jiffies = jiffies + msecs_to_jiffies(state->shutdown_ms);
383 // 4. Check soft inputs for transitions to take
384 for (i = 0; i < state->num_soft_events; i++) {
385 event = &state->soft_events[i];
386 if (gf->soft_gpios[event->index].value == event->value) {
389 "GF_SOFT %d=%d -> %s\n", event->index,
390 event->value, event->target->name);
391 gpio_fsm_go_to_state(gf, event->target);
396 // 5. Check GPIOs for transitions to take, enabling the IRQs
397 for (i = 0; i < state->num_gpio_events; i++) {
398 event = &state->gpio_events[i];
399 inp_state = &gf->input_gpio_states[event->index];
400 inp_state->target = event->target;
401 inp_state->value = event->value;
402 inp_state->enabled = true;
404 value = gpiod_get_value(gf->input_gpios->desc[event->index]);
406 // Clear stale event state
407 disable_irq(inp_state->irq);
409 irq_set_irq_type(inp_state->irq,
410 (inp_state->value ^ inp_state->active_low) ?
411 IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING);
412 enable_irq(inp_state->irq);
414 if (value == event->value && inp_state->target) {
417 "GF_IN %d=%d -> %s\n", event->index,
418 event->value, event->target->name);
419 gpio_fsm_go_to_state(gf, event->target);
424 // 6. Schedule a timer callback if delay_target
425 if (state->delay_target) {
426 gf->delay_target_state = state->delay_target;
427 gf->delay_jiffies = jiffies +
428 msecs_to_jiffies(state->delay_ms);
429 gf->delay_ms = state->delay_ms;
430 mod_timer(&gf->timer, gf->delay_jiffies);
434 static void gpio_fsm_work(struct work_struct *work)
436 struct input_gpio_state *inp_state;
437 struct fsm_state *new_state;
438 struct fsm_state *state;
439 struct gpio_event *gp_ev;
443 gf = container_of(work, struct gpio_fsm, work);
444 spin_lock(&gf->spinlock);
445 state = gf->current_state;
446 new_state = gf->next_state;
448 new_state = gf->delay_target_state;
449 gf->next_state = NULL;
450 gf->delay_target_state = NULL;
451 spin_unlock(&gf->spinlock);
454 /* Disable any enabled GPIO IRQs */
455 for (i = 0; i < state->num_gpio_events; i++) {
456 gp_ev = &state->gpio_events[i];
457 inp_state = &gf->input_gpio_states[gp_ev->index];
458 if (inp_state->enabled) {
459 inp_state->enabled = false;
460 irq_set_irq_type(inp_state->irq,
467 gpio_fsm_enter_state(gf, new_state);
470 static irqreturn_t gpio_fsm_gpio_irq_handler(int irq, void *dev_id)
472 struct input_gpio_state *inp_state = dev_id;
473 struct gpio_fsm *gf = inp_state->gf;
474 struct fsm_state *target;
476 target = inp_state->target;
480 /* If the IRQ has fired then the desired state _must_ have occurred */
481 inp_state->enabled = false;
482 irq_set_irq_type(inp_state->irq, IRQF_TRIGGER_NONE);
484 dev_info(gf->dev, "GF_IN %d->%d -> %s\n",
485 inp_state->index, inp_state->value, target->name);
486 gpio_fsm_go_to_state(gf, target);
490 static void gpio_fsm_timer(struct timer_list *timer)
492 struct gpio_fsm *gf = container_of(timer, struct gpio_fsm, timer);
493 struct fsm_state *target;
495 target = gf->delay_target_state;
500 dev_info(gf->dev, "GF_DELAY %d -> %s\n", gf->delay_ms,
503 gpio_fsm_go_to_state(gf, target);
506 int gpio_fsm_parse_signals(struct gpio_fsm *gf, struct fsm_state *state,
507 struct property *prop)
509 const __be32 *cells = prop->value;
510 struct output_signal *signal;
518 if (prop->length % 8) {
519 dev_err(gf->dev, "malformed set in state %s\n",
524 state->num_signals = prop->length/8;
525 state->signals = devm_kcalloc(gf->dev, state->num_signals,
526 sizeof(struct output_signal),
528 for (i = 0; i < state->num_signals; i++) {
529 signal = &state->signals[i];
530 io = be32_to_cpu(cells[0]);
531 type = GF_IO_TYPE(io);
532 index = GF_IO_INDEX(io);
533 value = be32_to_cpu(cells[1]);
535 if (type != GF_OUT && type != GF_SOFT) {
537 "invalid set type %d in state %s\n",
542 if (type == GF_OUT && index >= gf->num_output_gpios) {
544 "invalid GF_OUT number %d in state %s\n",
549 if (type == GF_SOFT && index >= gf->num_soft_gpios) {
551 "invalid GF_SOFT number %d in state %s\n",
556 if (value != 0 && value != 1) {
558 "invalid set value %d in state %s\n",
563 signal->type = (type == GF_OUT) ? SIGNAL_GPIO : SIGNAL_SOFT;
564 signal->index = index;
565 signal->value = value;
572 struct gpio_event *new_event(struct gpio_event **events, int *num_events)
574 int num = ++(*num_events);
575 *events = krealloc(*events, num * sizeof(struct gpio_event),
577 return *events ? *events + (num - 1) : NULL;
580 int gpio_fsm_parse_events(struct gpio_fsm *gf, struct fsm_state *state,
581 struct property *prop)
583 const __be32 *cells = prop->value;
584 struct symtab_entry *sym;
589 if (prop->length % 8) {
591 "malformed transitions from state %s to state %s\n",
592 state->name, prop->name);
596 sym = get_symbol(&gf->symtab, prop->name);
597 num_cells = prop->length / 4;
599 while (i < num_cells) {
600 struct gpio_event *gp_ev;
604 event = be32_to_cpu(cells[i++]);
605 param = be32_to_cpu(cells[i++]);
606 index = GF_IO_INDEX(event);
608 switch (GF_IO_TYPE(event)) {
610 if (index >= gf->num_input_gpios) {
612 "invalid GF_IN %d in transitions from state %s to state %s\n",
613 index, state->name, prop->name);
618 "invalid GF_IN value %d in transitions from state %s to state %s\n",
619 param, state->name, prop->name);
622 gp_ev = new_event(&state->gpio_events,
623 &state->num_gpio_events);
626 gp_ev->index = index;
627 gp_ev->value = param;
628 gp_ev->target = (struct fsm_state *)sym;
632 if (index >= gf->num_soft_gpios) {
634 "invalid GF_SOFT %d in transitions from state %s to state %s\n",
635 index, state->name, prop->name);
640 "invalid GF_SOFT value %d in transitions from state %s to state %s\n",
641 param, state->name, prop->name);
644 gp_ev = new_event(&state->soft_events,
645 &state->num_soft_events);
648 gp_ev->index = index;
649 gp_ev->value = param;
650 gp_ev->target = (struct fsm_state *)sym;
654 if (state->delay_target) {
656 "state %s has multiple GF_DELAYs\n",
660 state->delay_target = (struct fsm_state *)sym;
661 state->delay_ms = param;
665 if (state->shutdown_target == state) {
667 "shutdown state %s has GF_SHUTDOWN\n",
670 } else if (state->shutdown_target) {
672 "state %s has multiple GF_SHUTDOWNs\n",
676 state->shutdown_target =
677 (struct fsm_state *)sym;
678 state->shutdown_ms = param;
683 "invalid event %08x in transitions from state %s to state %s\n",
684 event, state->name, prop->name);
688 if (i != num_cells) {
690 "malformed transitions from state %s to state %s\n",
691 state->name, prop->name);
698 int gpio_fsm_parse_state(struct gpio_fsm *gf,
699 struct fsm_state *state,
700 struct device_node *np)
702 struct symtab_entry *sym;
703 struct property *prop;
706 state->name = np->name;
707 ret = add_symbol(&gf->symtab, np->name, state);
711 dev_err(gf->dev, "'%s' is not a valid state name\n",
715 dev_err(gf->dev, "state %s already defined\n",
719 dev_err(gf->dev, "error %d adding state %s symbol\n",
726 for_each_property_of_node(np, prop) {
727 sym = get_symbol(&gf->symtab, prop->name);
733 switch ((uintptr_t)sym->value) {
735 ret = gpio_fsm_parse_signals(gf, state, prop);
738 if (gf->start_state) {
739 dev_err(gf->dev, "multiple start states\n");
742 gf->start_state = state;
746 state->shutdown_target = state;
747 gf->shutdown_state = state;
753 /* A set of transition events to this state */
754 ret = gpio_fsm_parse_events(gf, state, prop);
762 static void dump_all(struct gpio_fsm *gf)
766 dev_info(gf->dev, "Input GPIOs:\n");
767 for (i = 0; i < gf->num_input_gpios; i++)
768 dev_info(gf->dev, " %d: %p\n", i,
769 gf->input_gpios->desc[i]);
771 dev_info(gf->dev, "Output GPIOs:\n");
772 for (i = 0; i < gf->num_output_gpios; i++)
773 dev_info(gf->dev, " %d: %p\n", i,
774 gf->output_gpios->desc[i]);
776 dev_info(gf->dev, "Soft GPIOs:\n");
777 for (i = 0; i < gf->num_soft_gpios; i++)
778 dev_info(gf->dev, " %d: %s %d\n", i,
779 (gf->soft_gpios[i].dir == GPIOF_DIR_IN) ? "IN" : "OUT",
780 gf->soft_gpios[i].value);
782 dev_info(gf->dev, "Start state: %s\n",
783 gf->start_state ? gf->start_state->name : "-");
785 dev_info(gf->dev, "Shutdown timeout: %d ms\n",
786 gf->shutdown_timeout_ms);
788 for (i = 0; i < gf->num_states; i++) {
789 struct fsm_state *state = &gf->states[i];
791 dev_info(gf->dev, "State %s:\n", state->name);
793 if (state->shutdown_target == state)
794 dev_info(gf->dev, " Shutdown state\n");
796 dev_info(gf->dev, " Signals:\n");
797 for (j = 0; j < state->num_signals; j++) {
798 struct output_signal *signal = &state->signals[j];
800 dev_info(gf->dev, " %d: %s %d=%d\n", j,
801 (signal->type == SIGNAL_GPIO) ? "GPIO" :
803 signal->index, signal->value);
806 dev_info(gf->dev, " GPIO events:\n");
807 for (j = 0; j < state->num_gpio_events; j++) {
808 struct gpio_event *event = &state->gpio_events[j];
810 dev_info(gf->dev, " %d: %d=%d -> %s\n", j,
811 event->index, event->value,
812 event->target->name);
815 dev_info(gf->dev, " Soft events:\n");
816 for (j = 0; j < state->num_soft_events; j++) {
817 struct gpio_event *event = &state->soft_events[j];
819 dev_info(gf->dev, " %d: %d=%d -> %s\n", j,
820 event->index, event->value,
821 event->target->name);
824 if (state->delay_target)
825 dev_info(gf->dev, " Delay: %d ms -> %s\n",
826 state->delay_ms, state->delay_target->name);
828 if (state->shutdown_target && state->shutdown_target != state)
829 dev_info(gf->dev, " Shutdown: %d ms -> %s\n",
831 state->shutdown_target->name);
833 dev_info(gf->dev, "\n");
836 static int resolve_sym_to_state(struct gpio_fsm *gf, struct fsm_state **pstate)
838 struct symtab_entry *sym = (struct symtab_entry *)*pstate;
843 *pstate = sym->value;
846 dev_err(gf->dev, "state %s not defined\n",
856 * /sys/class/gpio-fsm/<fsm-name>/
857 * /state ... the current state
860 static ssize_t state_show(struct device *dev,
861 struct device_attribute *attr, char *buf)
863 const struct gpio_fsm *gf = dev_get_drvdata(dev);
865 return sprintf(buf, "%s\n", gf->current_state->name);
867 static DEVICE_ATTR_RO(state);
869 static ssize_t delay_state_show(struct device *dev,
870 struct device_attribute *attr, char *buf)
872 const struct gpio_fsm *gf = dev_get_drvdata(dev);
874 return sprintf(buf, "%s\n",
875 gf->delay_target_state ? gf->delay_target_state->name :
879 static DEVICE_ATTR_RO(delay_state);
881 static ssize_t delay_ms_show(struct device *dev,
882 struct device_attribute *attr, char *buf)
884 const struct gpio_fsm *gf = dev_get_drvdata(dev);
887 jiffies_left = max((int)(gf->delay_jiffies - jiffies), 0);
889 gf->delay_target_state ? "%u\n" : "-\n",
890 jiffies_to_msecs(jiffies_left));
892 static DEVICE_ATTR_RO(delay_ms);
894 static struct attribute *gpio_fsm_attrs[] = {
895 &dev_attr_state.attr,
896 &dev_attr_delay_state.attr,
897 &dev_attr_delay_ms.attr,
901 static const struct attribute_group gpio_fsm_group = {
902 .attrs = gpio_fsm_attrs,
903 //.is_visible = gpio_is_visible,
906 static const struct attribute_group *gpio_fsm_groups[] = {
911 static struct attribute *gpio_fsm_class_attrs[] = {
912 // There are no top-level attributes
915 ATTRIBUTE_GROUPS(gpio_fsm_class);
917 static struct class gpio_fsm_class = {
919 .owner = THIS_MODULE,
921 .class_groups = gpio_fsm_class_groups,
924 static int gpio_fsm_probe(struct platform_device *pdev)
926 struct input_gpio_state *inp_state;
927 struct device *dev = &pdev->dev;
928 struct device *sysfs_dev;
929 struct device_node *np = dev->of_node;
930 struct device_node *cp;
937 static const char *const reserved_symbols[] = {
940 [SYM_START] = "start_state",
941 [SYM_SHUTDOWN] = "shutdown_state",
944 if (of_property_read_u32(np, "num-swgpios", &num_soft_gpios) &&
945 of_property_read_u32(np, "num-soft-gpios", &num_soft_gpios)) {
946 dev_err(dev, "missing 'num-swgpios' property\n");
950 of_property_read_u32(np, "debug", &debug);
952 gf = devm_kzalloc(dev, sizeof(*gf), GFP_KERNEL);
959 if (of_property_read_u32(np, "shutdown-timeout-ms",
960 &gf->shutdown_timeout_ms))
961 gf->shutdown_timeout_ms = 5000;
963 gf->num_soft_gpios = num_soft_gpios;
964 gf->soft_gpios = devm_kcalloc(dev, num_soft_gpios,
965 sizeof(struct soft_gpio), GFP_KERNEL);
968 for (i = 0; i < num_soft_gpios; i++) {
969 struct soft_gpio *sg = &gf->soft_gpios[i];
971 sg->dir = GPIOF_DIR_IN;
975 gf->input_gpios = devm_gpiod_get_array_optional(dev, "input", GPIOD_IN);
976 if (IS_ERR(gf->input_gpios)) {
977 ret = PTR_ERR(gf->input_gpios);
978 dev_err(dev, "failed to get input gpios from DT - %d\n", ret);
981 gf->num_input_gpios = (gf->input_gpios ? gf->input_gpios->ndescs : 0);
983 gf->input_gpio_states = devm_kcalloc(dev, gf->num_input_gpios,
984 sizeof(struct input_gpio_state),
986 if (!gf->input_gpio_states)
988 for (i = 0; i < gf->num_input_gpios; i++) {
989 inp_state = &gf->input_gpio_states[i];
990 inp_state->desc = gf->input_gpios->desc[i];
992 inp_state->index = i;
993 inp_state->irq = gpiod_to_irq(inp_state->desc);
994 inp_state->active_low = gpiod_is_active_low(inp_state->desc);
995 if (inp_state->irq >= 0)
996 ret = devm_request_irq(gf->dev, inp_state->irq,
997 gpio_fsm_gpio_irq_handler,
1002 ret = inp_state->irq;
1006 "failed to get IRQ for input gpio - %d\n",
1012 gf->output_gpios = devm_gpiod_get_array_optional(dev, "output",
1014 if (IS_ERR(gf->output_gpios)) {
1015 ret = PTR_ERR(gf->output_gpios);
1016 dev_err(dev, "failed to get output gpios from DT - %d\n", ret);
1019 gf->num_output_gpios = (gf->output_gpios ? gf->output_gpios->ndescs :
1022 num_states = of_get_child_count(np);
1024 dev_err(dev, "no states declared\n");
1027 gf->states = devm_kcalloc(dev, num_states,
1028 sizeof(struct fsm_state), GFP_KERNEL);
1032 // add reserved words to the symbol table
1033 for (i = 0; i < ARRAY_SIZE(reserved_symbols); i++) {
1034 if (reserved_symbols[i])
1035 add_symbol(&gf->symtab, reserved_symbols[i],
1036 (void *)(uintptr_t)i);
1040 for_each_child_of_node(np, cp) {
1041 struct fsm_state *state = &gf->states[gf->num_states];
1043 ret = gpio_fsm_parse_state(gf, state, cp);
1049 if (!gf->start_state) {
1050 dev_err(gf->dev, "no start state defined\n");
1054 // resolve symbol pointers into state pointers
1055 for (i = 0; !ret && i < gf->num_states; i++) {
1056 struct fsm_state *state = &gf->states[i];
1059 for (j = 0; !ret && j < state->num_gpio_events; j++) {
1060 struct gpio_event *ev = &state->gpio_events[j];
1062 ret = resolve_sym_to_state(gf, &ev->target);
1065 for (j = 0; !ret && j < state->num_soft_events; j++) {
1066 struct gpio_event *ev = &state->soft_events[j];
1068 ret = resolve_sym_to_state(gf, &ev->target);
1072 resolve_sym_to_state(gf, &state->delay_target);
1073 if (state->shutdown_target != state)
1074 resolve_sym_to_state(gf,
1075 &state->shutdown_target);
1079 if (!ret && gf->debug > 1)
1082 free_symbols(&gf->symtab);
1087 gf->gc.parent = dev;
1088 gf->gc.label = np->name;
1089 gf->gc.owner = THIS_MODULE;
1090 gf->gc.of_node = np;
1092 gf->gc.ngpio = num_soft_gpios;
1094 gf->gc.get_direction = gpio_fsm_get_direction;
1095 gf->gc.direction_input = gpio_fsm_direction_input;
1096 gf->gc.direction_output = gpio_fsm_direction_output;
1097 gf->gc.get = gpio_fsm_get;
1098 gf->gc.set = gpio_fsm_set;
1099 gf->gc.can_sleep = true;
1100 spin_lock_init(&gf->spinlock);
1101 INIT_WORK(&gf->work, gpio_fsm_work);
1102 timer_setup(&gf->timer, gpio_fsm_timer, 0);
1103 init_waitqueue_head(&gf->shutdown_event);
1105 platform_set_drvdata(pdev, gf);
1107 sysfs_dev = device_create_with_groups(&gpio_fsm_class, dev,
1111 if (IS_ERR(sysfs_dev))
1112 dev_err(gf->dev, "Error creating sysfs entry\n");
1115 dev_info(gf->dev, "Start -> %s\n", gf->start_state->name);
1117 gpio_fsm_go_to_state(gf, gf->start_state);
1119 return devm_gpiochip_add_data(dev, &gf->gc, gf);
1122 static int gpio_fsm_remove(struct platform_device *pdev)
1124 struct gpio_fsm *gf = platform_get_drvdata(pdev);
1127 if (gf->shutdown_state) {
1129 dev_info(gf->dev, "Shutting down...\n");
1131 spin_lock(&gf->spinlock);
1132 gf->shutting_down = true;
1133 if (gf->current_state->shutdown_target &&
1134 gf->current_state->shutdown_target != gf->current_state) {
1135 gf->delay_target_state =
1136 gf->current_state->shutdown_target;
1137 mod_timer(&gf->timer, gf->shutdown_jiffies);
1139 spin_unlock(&gf->spinlock);
1141 wait_event_timeout(gf->shutdown_event,
1142 gf->current_state->shutdown_target ==
1144 msecs_to_jiffies(gf->shutdown_timeout_ms));
1145 /* On failure to reach a shutdown state, jump to one */
1146 if (gf->current_state->shutdown_target != gf->current_state)
1147 gpio_fsm_enter_state(gf, gf->shutdown_state);
1149 cancel_work_sync(&gf->work);
1150 del_timer_sync(&gf->timer);
1152 /* Events aren't allocated from managed storage */
1153 for (i = 0; i < gf->num_states; i++) {
1154 kfree(gf->states[i].gpio_events);
1155 kfree(gf->states[i].soft_events);
1158 dev_info(gf->dev, "Exiting\n");
1163 static void gpio_fsm_shutdown(struct platform_device *pdev)
1165 gpio_fsm_remove(pdev);
1168 static const struct of_device_id gpio_fsm_ids[] = {
1169 { .compatible = "rpi,gpio-fsm" },
1172 MODULE_DEVICE_TABLE(of, gpio_fsm_ids);
1174 static struct platform_driver gpio_fsm_driver = {
1176 .name = MODULE_NAME,
1177 .of_match_table = of_match_ptr(gpio_fsm_ids),
1179 .probe = gpio_fsm_probe,
1180 .remove = gpio_fsm_remove,
1181 .shutdown = gpio_fsm_shutdown,
1184 static int gpio_fsm_init(void)
1188 ret = class_register(&gpio_fsm_class);
1192 ret = platform_driver_register(&gpio_fsm_driver);
1194 class_unregister(&gpio_fsm_class);
1198 module_init(gpio_fsm_init);
1200 static void gpio_fsm_exit(void)
1202 platform_driver_unregister(&gpio_fsm_driver);
1203 class_unregister(&gpio_fsm_class);
1205 module_exit(gpio_fsm_exit);
1207 MODULE_LICENSE("GPL");
1208 MODULE_AUTHOR("Phil Elwell <phil@raspberrypi.com>");
1209 MODULE_DESCRIPTION("GPIO FSM driver");
1210 MODULE_ALIAS("platform:gpio-fsm");