drivers/gpio/gpio-fsm.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  *  GPIO FSM driver
   4  *
   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
  12  *  etc.
  13  *
  14  *  Copyright (C) 2020 Raspberry Pi (Trading) Ltd.
  15  */
  16
  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>
  24
  25 #include <dt-bindings/gpio/gpio-fsm.h>
  26
  27 #define MODULE_NAME "gpio-fsm"
  28
  29 #define GF_IO_TYPE(x) ((u32)(x) & 0xffff)
  30 #define GF_IO_INDEX(x) ((u32)(x) >> 16)
  31
  32 enum {
  33         SIGNAL_GPIO,
  34         SIGNAL_SOFT
  35 };
  36
  37 enum {
  38         INPUT_GPIO,
  39         INPUT_SOFT
  40 };
  41
  42 enum {
  43         SYM_UNDEFINED,
  44         SYM_NAME,
  45         SYM_SET,
  46         SYM_START,
  47         SYM_SHUTDOWN,
  48
  49         SYM_MAX
  50 };
  51
  52 struct soft_gpio {
  53         int dir;
  54         int value;
  55 };
  56
  57 struct input_gpio_state {
  58         struct gpio_fsm *gf;
  59         struct gpio_desc  *desc;
  60         struct fsm_state *target;
  61         int index;
  62         int value;
  63         int irq;
  64         bool enabled;
  65         bool active_low;
  66 };
  67
  68 struct gpio_event {
  69         int index;
  70         int value;
  71         struct fsm_state *target;
  72 };
  73
  74 struct symtab_entry {
  75         const char *name;
  76         void *value;
  77         struct symtab_entry *next;
  78 };
  79
  80 struct output_signal {
  81         u8 type;
  82         u8 value;
  83         u16 index;
  84 };
  85
  86 struct fsm_state {
  87         const char *name;
  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;
  98 };
  99
 100 struct gpio_fsm {
 101         struct gpio_chip gc;
 102         struct device *dev;
 103         spinlock_t spinlock;
 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;
 120
 121         struct fsm_state *current_state;
 122         struct fsm_state *next_state;
 123         struct fsm_state *delay_target_state;
 124         unsigned int delay_jiffies;
 125         int delay_ms;
 126         unsigned int debug;
 127         bool shutting_down;
 128         struct symtab_entry *symtab;
 129 };
 130
 131 static struct symtab_entry *do_add_symbol(struct symtab_entry **symtab,
 132                                           const char *name, void *value)
 133 {
 134         struct symtab_entry **p = symtab;
 135
 136         while (*p && strcmp((*p)->name, name))
 137                 p = &(*p)->next;
 138
 139         if (*p) {
 140                 /* This is an existing symbol */
 141                 if ((*p)->value) {
 142                         /* Already defined */
 143                         if (value) {
 144                                 if ((uintptr_t)value < SYM_MAX)
 145                                         return ERR_PTR(-EINVAL);
 146                                 else
 147                                         return ERR_PTR(-EEXIST);
 148                         }
 149                 } else {
 150                         /* Undefined */
 151                         (*p)->value = value;
 152                 }
 153         } else {
 154                 /* This is a new symbol */
 155                 *p = kmalloc(sizeof(struct symtab_entry), GFP_KERNEL);
 156                 if (*p) {
 157                         (*p)->name = name;
 158                         (*p)->value = value;
 159                         (*p)->next = NULL;
 160                 }
 161         }
 162         return *p;
 163 }
 164
 165 static int add_symbol(struct symtab_entry **symtab,
 166                       const char *name, void *value)
 167 {
 168         struct symtab_entry *sym = do_add_symbol(symtab, name, value);
 169
 170         return PTR_ERR_OR_ZERO(sym);
 171 }
 172
 173 static struct symtab_entry *get_symbol(struct symtab_entry **symtab,
 174                                        const char *name)
 175 {
 176         struct symtab_entry *sym = do_add_symbol(symtab, name, NULL);
 177
 178         if (IS_ERR(sym))
 179                 return NULL;
 180         return sym;
 181 }
 182
 183 static void free_symbols(struct symtab_entry **symtab)
 184 {
 185         struct symtab_entry *sym = *symtab;
 186         void *p;
 187
 188         *symtab = NULL;
 189         while (sym) {
 190                 p = sym;
 191                 sym = sym->next;
 192                 kfree(p);
 193         }
 194 }
 195
 196 static int gpio_fsm_get_direction(struct gpio_chip *gc, unsigned int off)
 197 {
 198         struct gpio_fsm *gf = gpiochip_get_data(gc);
 199         struct soft_gpio *sg;
 200
 201         if (off >= gf->num_soft_gpios)
 202                 return -EINVAL;
 203         sg = &gf->soft_gpios[off];
 204
 205         return sg->dir;
 206 }
 207
 208 static int gpio_fsm_get(struct gpio_chip *gc, unsigned int off)
 209 {
 210         struct gpio_fsm *gf = gpiochip_get_data(gc);
 211         struct soft_gpio *sg;
 212
 213         if (off >= gf->num_soft_gpios)
 214                 return -EINVAL;
 215         sg = &gf->soft_gpios[off];
 216
 217         return sg->value;
 218 }
 219
 220 static void gpio_fsm_go_to_state(struct gpio_fsm *gf,
 221                                    struct fsm_state *new_state)
 222 {
 223         struct input_gpio_state *inp_state;
 224         struct gpio_event *gp_ev;
 225         struct fsm_state *state;
 226         int i;
 227
 228         dev_dbg(gf->dev, "go_to_state(%s)\n",
 229                   new_state ? new_state->name : "<unset>");
 230
 231         spin_lock(&gf->spinlock);
 232
 233         if (gf->next_state) {
 234                 /* Something else has already requested a transition */
 235                 spin_unlock(&gf->spinlock);
 236                 return;
 237         }
 238
 239         gf->next_state = new_state;
 240         state = gf->current_state;
 241         gf->delay_target_state = NULL;
 242
 243         if (state) {
 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;
 249                 }
 250         }
 251
 252         spin_unlock(&gf->spinlock);
 253
 254         if (new_state)
 255                 schedule_work(&gf->work);
 256 }
 257
 258 static void gpio_fsm_set_soft(struct gpio_fsm *gf,
 259                                 unsigned int off, int val)
 260 {
 261         struct soft_gpio *sg = &gf->soft_gpios[off];
 262         struct gpio_event *gp_ev;
 263         struct fsm_state *state;
 264         int i;
 265
 266         dev_dbg(gf->dev, "set(%d,%d)\n", off, val);
 267         state = gf->current_state;
 268         sg->value = val;
 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) {
 272                         if (gf->debug)
 273                                 dev_info(gf->dev,
 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);
 277                         break;
 278                 }
 279         }
 280 }
 281
 282 static int gpio_fsm_direction_input(struct gpio_chip *gc, unsigned int off)
 283 {
 284         struct gpio_fsm *gf = gpiochip_get_data(gc);
 285         struct soft_gpio *sg;
 286
 287         if (off >= gf->num_soft_gpios)
 288                 return -EINVAL;
 289         sg = &gf->soft_gpios[off];
 290         sg->dir = GPIOF_DIR_IN;
 291
 292         return 0;
 293 }
 294
 295 static int gpio_fsm_direction_output(struct gpio_chip *gc, unsigned int off,
 296                                        int value)
 297 {
 298         struct gpio_fsm *gf = gpiochip_get_data(gc);
 299         struct soft_gpio *sg;
 300
 301         if (off >= gf->num_soft_gpios)
 302                 return -EINVAL;
 303         sg = &gf->soft_gpios[off];
 304         sg->dir = GPIOF_DIR_OUT;
 305         gpio_fsm_set_soft(gf, off, value);
 306
 307         return 0;
 308 }
 309
 310 static void gpio_fsm_set(struct gpio_chip *gc, unsigned int off, int val)
 311 {
 312         struct gpio_fsm *gf;
 313
 314         gf = gpiochip_get_data(gc);
 315         if (off < gf->num_soft_gpios)
 316                 gpio_fsm_set_soft(gf, off, val);
 317 }
 318
 319 static void gpio_fsm_enter_state(struct gpio_fsm *gf,
 320                                    struct fsm_state *state)
 321 {
 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;
 327         int value;
 328         int i;
 329
 330         dev_dbg(gf->dev, "enter_state(%s)\n", state->name);
 331
 332         gf->current_state = state;
 333
 334         // 1. Apply any listed signals
 335         for (i = 0; i < state->num_signals; i++) {
 336                 signal = &state->signals[i];
 337
 338                 if (gf->debug)
 339                         dev_info(gf->dev, "  set %s %d->%d\n",
 340                                  (signal->type == SIGNAL_GPIO) ? "GF_OUT" :
 341                                  "GF_SOFT",
 342                                  signal->index, signal->value);
 343                 switch (signal->type) {
 344                 case SIGNAL_GPIO:
 345                         gpiod = gf->output_gpios->desc[signal->index];
 346                         gpiod_set_value_cansleep(gpiod, signal->value);
 347                         break;
 348                 case SIGNAL_SOFT:
 349                         soft = &gf->soft_gpios[signal->index];
 350                         gpio_fsm_set_soft(gf, signal->index, signal->value);
 351                         break;
 352                 }
 353         }
 354
 355         // 2. Exit if successfully reached shutdown state
 356         if (gf->shutting_down && state == state->shutdown_target) {
 357                 wake_up(&gf->shutdown_event);
 358                 return;
 359         }
 360
 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
 364                 // at a later time.
 365                 gf->shutdown_jiffies =
 366                         jiffies + msecs_to_jiffies(state->shutdown_ms);
 367
 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);
 373                 }
 374         }
 375
 376         // During shutdown, skip everything else
 377         if (gf->shutting_down)
 378                 return;
 379
 380         // Otherwise record what the shutdown time would be
 381         gf->shutdown_jiffies = jiffies + msecs_to_jiffies(state->shutdown_ms);
 382
 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) {
 387                         if (gf->debug)
 388                                 dev_info(gf->dev,
 389                                          "GF_SOFT %d=%d -> %s\n", event->index,
 390                                          event->value, event->target->name);
 391                         gpio_fsm_go_to_state(gf, event->target);
 392                         return;
 393                 }
 394         }
 395
 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;
 403
 404                 value = gpiod_get_value(gf->input_gpios->desc[event->index]);
 405
 406                 // Clear stale event state
 407                 disable_irq(inp_state->irq);
 408
 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);
 413
 414                 if (value == event->value && inp_state->target) {
 415                         if (gf->debug)
 416                                 dev_info(gf->dev,
 417                                          "GF_IN %d=%d -> %s\n", event->index,
 418                                          event->value, event->target->name);
 419                         gpio_fsm_go_to_state(gf, event->target);
 420                         return;
 421                 }
 422         }
 423
 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);
 431         }
 432 }
 433
 434 static void gpio_fsm_work(struct work_struct *work)
 435 {
 436         struct input_gpio_state *inp_state;
 437         struct fsm_state *new_state;
 438         struct fsm_state *state;
 439         struct gpio_event *gp_ev;
 440         struct gpio_fsm *gf;
 441         int i;
 442
 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;
 447         if (!new_state)
 448                 new_state = gf->delay_target_state;
 449         gf->next_state = NULL;
 450         gf->delay_target_state = NULL;
 451         spin_unlock(&gf->spinlock);
 452
 453         if (state) {
 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,
 461                                                  IRQF_TRIGGER_NONE);
 462                         }
 463                 }
 464         }
 465
 466         if (new_state)
 467                 gpio_fsm_enter_state(gf, new_state);
 468 }
 469
 470 static irqreturn_t gpio_fsm_gpio_irq_handler(int irq, void *dev_id)
 471 {
 472         struct input_gpio_state *inp_state = dev_id;
 473         struct gpio_fsm *gf = inp_state->gf;
 474         struct fsm_state *target;
 475
 476         target = inp_state->target;
 477         if (!target)
 478                 return IRQ_NONE;
 479
 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);
 483         if (gf->debug)
 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);
 487         return IRQ_HANDLED;
 488 }
 489
 490 static void gpio_fsm_timer(struct timer_list *timer)
 491 {
 492         struct gpio_fsm *gf = container_of(timer, struct gpio_fsm, timer);
 493         struct fsm_state *target;
 494
 495         target = gf->delay_target_state;
 496         if (!target)
 497                 return;
 498
 499         if (gf->debug)
 500                 dev_info(gf->dev, "GF_DELAY %d -> %s\n", gf->delay_ms,
 501                          target->name);
 502
 503         gpio_fsm_go_to_state(gf, target);
 504 }
 505
 506 int gpio_fsm_parse_signals(struct gpio_fsm *gf, struct fsm_state *state,
 507                              struct property *prop)
 508 {
 509         const __be32 *cells = prop->value;
 510         struct output_signal *signal;
 511         u32 io;
 512         u32 type;
 513         u32 index;
 514         u32 value;
 515         int ret = 0;
 516         int i;
 517
 518         if (prop->length % 8) {
 519                 dev_err(gf->dev, "malformed set in state %s\n",
 520                         state->name);
 521                 return -EINVAL;
 522         }
 523
 524         state->num_signals = prop->length/8;
 525         state->signals = devm_kcalloc(gf->dev, state->num_signals,
 526                                       sizeof(struct output_signal),
 527                                       GFP_KERNEL);
 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]);
 534
 535                 if (type != GF_OUT && type != GF_SOFT) {
 536                         dev_err(gf->dev,
 537                                 "invalid set type %d in state %s\n",
 538                                 type, state->name);
 539                         ret = -EINVAL;
 540                         break;
 541                 }
 542                 if (type == GF_OUT && index >= gf->num_output_gpios) {
 543                         dev_err(gf->dev,
 544                                 "invalid GF_OUT number %d in state %s\n",
 545                                 index, state->name);
 546                         ret = -EINVAL;
 547                         break;
 548                 }
 549                 if (type == GF_SOFT && index >= gf->num_soft_gpios) {
 550                         dev_err(gf->dev,
 551                                 "invalid GF_SOFT number %d in state %s\n",
 552                                 index, state->name);
 553                         ret = -EINVAL;
 554                         break;
 555                 }
 556                 if (value != 0 && value != 1) {
 557                         dev_err(gf->dev,
 558                                 "invalid set value %d in state %s\n",
 559                                 value, state->name);
 560                         ret = -EINVAL;
 561                         break;
 562                 }
 563                 signal->type = (type == GF_OUT) ? SIGNAL_GPIO : SIGNAL_SOFT;
 564                 signal->index = index;
 565                 signal->value = value;
 566                 cells += 2;
 567         }
 568
 569         return ret;
 570 }
 571
 572 struct gpio_event *new_event(struct gpio_event **events, int *num_events)
 573 {
 574         int num = ++(*num_events);
 575         *events = krealloc(*events, num * sizeof(struct gpio_event),
 576                            GFP_KERNEL);
 577         return *events ? *events + (num - 1) : NULL;
 578 }
 579
 580 int gpio_fsm_parse_events(struct gpio_fsm *gf, struct fsm_state *state,
 581                             struct property *prop)
 582 {
 583         const __be32 *cells = prop->value;
 584         struct symtab_entry *sym;
 585         int num_cells;
 586         int ret = 0;
 587         int i;
 588
 589         if (prop->length % 8) {
 590                 dev_err(gf->dev,
 591                         "malformed transitions from state %s to state %s\n",
 592                         state->name, prop->name);
 593                 return -EINVAL;
 594         }
 595
 596         sym = get_symbol(&gf->symtab, prop->name);
 597         num_cells = prop->length / 4;
 598         i = 0;
 599         while (i < num_cells) {
 600                 struct gpio_event *gp_ev;
 601                 u32 event, param;
 602                 u32 index;
 603
 604                 event = be32_to_cpu(cells[i++]);
 605                 param = be32_to_cpu(cells[i++]);
 606                 index = GF_IO_INDEX(event);
 607
 608                 switch (GF_IO_TYPE(event)) {
 609                 case GF_IN:
 610                         if (index >= gf->num_input_gpios) {
 611                                 dev_err(gf->dev,
 612                                         "invalid GF_IN %d in transitions from state %s to state %s\n",
 613                                         index, state->name, prop->name);
 614                                 return -EINVAL;
 615                         }
 616                         if (param > 1) {
 617                                 dev_err(gf->dev,
 618                                         "invalid GF_IN value %d in transitions from state %s to state %s\n",
 619                                         param, state->name, prop->name);
 620                                 return -EINVAL;
 621                         }
 622                         gp_ev = new_event(&state->gpio_events,
 623                                           &state->num_gpio_events);
 624                         if (!gp_ev)
 625                                 return -ENOMEM;
 626                         gp_ev->index = index;
 627                         gp_ev->value = param;
 628                         gp_ev->target = (struct fsm_state *)sym;
 629                         break;
 630
 631                 case GF_SOFT:
 632                         if (index >= gf->num_soft_gpios) {
 633                                 dev_err(gf->dev,
 634                                         "invalid GF_SOFT %d in transitions from state %s to state %s\n",
 635                                         index, state->name, prop->name);
 636                                 return -EINVAL;
 637                         }
 638                         if (param > 1) {
 639                                 dev_err(gf->dev,
 640                                         "invalid GF_SOFT value %d in transitions from state %s to state %s\n",
 641                                         param, state->name, prop->name);
 642                                 return -EINVAL;
 643                         }
 644                         gp_ev = new_event(&state->soft_events,
 645                                           &state->num_soft_events);
 646                         if (!gp_ev)
 647                                 return -ENOMEM;
 648                         gp_ev->index = index;
 649                         gp_ev->value = param;
 650                         gp_ev->target = (struct fsm_state *)sym;
 651                         break;
 652
 653                 case GF_DELAY:
 654                         if (state->delay_target) {
 655                                 dev_err(gf->dev,
 656                                         "state %s has multiple GF_DELAYs\n",
 657                                         state->name);
 658                                 return -EINVAL;
 659                         }
 660                         state->delay_target = (struct fsm_state *)sym;
 661                         state->delay_ms = param;
 662                         break;
 663
 664                 case GF_SHUTDOWN:
 665                         if (state->shutdown_target == state) {
 666                                 dev_err(gf->dev,
 667                                         "shutdown state %s has GF_SHUTDOWN\n",
 668                                         state->name);
 669                                 return -EINVAL;
 670                         } else if (state->shutdown_target) {
 671                                 dev_err(gf->dev,
 672                                         "state %s has multiple GF_SHUTDOWNs\n",
 673                                         state->name);
 674                                 return -EINVAL;
 675                         }
 676                         state->shutdown_target =
 677                                 (struct fsm_state *)sym;
 678                         state->shutdown_ms = param;
 679                         break;
 680
 681                 default:
 682                         dev_err(gf->dev,
 683                                 "invalid event %08x in transitions from state %s to state %s\n",
 684                                 event, state->name, prop->name);
 685                         return -EINVAL;
 686                 }
 687         }
 688         if (i != num_cells) {
 689                 dev_err(gf->dev,
 690                         "malformed transitions from state %s to state %s\n",
 691                         state->name, prop->name);
 692                 return -EINVAL;
 693         }
 694
 695         return ret;
 696 }
 697
 698 int gpio_fsm_parse_state(struct gpio_fsm *gf,
 699                            struct fsm_state *state,
 700                            struct device_node *np)
 701 {
 702         struct symtab_entry *sym;
 703         struct property *prop;
 704         int ret;
 705
 706         state->name = np->name;
 707         ret = add_symbol(&gf->symtab, np->name, state);
 708         if (ret) {
 709                 switch (ret) {
 710                 case -EINVAL:
 711                         dev_err(gf->dev, "'%s' is not a valid state name\n",
 712                                 np->name);
 713                         break;
 714                 case -EEXIST:
 715                         dev_err(gf->dev, "state %s already defined\n",
 716                                 np->name);
 717                         break;
 718                 default:
 719                         dev_err(gf->dev, "error %d adding state %s symbol\n",
 720                                 ret, np->name);
 721                         break;
 722                 }
 723                 return ret;
 724         }
 725
 726         for_each_property_of_node(np, prop) {
 727                 sym = get_symbol(&gf->symtab, prop->name);
 728                 if (!sym) {
 729                         ret = -ENOMEM;
 730                         break;
 731                 }
 732
 733                 switch ((uintptr_t)sym->value) {
 734                 case SYM_SET:
 735                         ret = gpio_fsm_parse_signals(gf, state, prop);
 736                         break;
 737                 case SYM_START:
 738                         if (gf->start_state) {
 739                                 dev_err(gf->dev, "multiple start states\n");
 740                                 ret = -EINVAL;
 741                         } else {
 742                                 gf->start_state = state;
 743                         }
 744                         break;
 745                 case SYM_SHUTDOWN:
 746                         state->shutdown_target = state;
 747                         gf->shutdown_state = state;
 748                         break;
 749                 case SYM_NAME:
 750                         /* Ignore */
 751                         break;
 752                 default:
 753                         /* A set of transition events to this state */
 754                         ret = gpio_fsm_parse_events(gf, state, prop);
 755                         break;
 756                 }
 757         }
 758
 759         return ret;
 760 }
 761
 762 static void dump_all(struct gpio_fsm *gf)
 763 {
 764         int i, j;
 765
 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]);
 770
 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]);
 775
 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);
 781
 782         dev_info(gf->dev, "Start state: %s\n",
 783                  gf->start_state ? gf->start_state->name : "-");
 784
 785         dev_info(gf->dev, "Shutdown timeout: %d ms\n",
 786                  gf->shutdown_timeout_ms);
 787
 788         for (i = 0; i < gf->num_states; i++) {
 789                 struct fsm_state *state = &gf->states[i];
 790
 791                 dev_info(gf->dev, "State %s:\n", state->name);
 792
 793                 if (state->shutdown_target == state)
 794                         dev_info(gf->dev, "  Shutdown state\n");
 795
 796                 dev_info(gf->dev, "  Signals:\n");
 797                 for (j = 0; j < state->num_signals; j++) {
 798                         struct output_signal *signal = &state->signals[j];
 799
 800                         dev_info(gf->dev, "    %d: %s %d=%d\n", j,
 801                                  (signal->type == SIGNAL_GPIO) ? "GPIO" :
 802                                                                  "SOFT",
 803                                  signal->index, signal->value);
 804                 }
 805
 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];
 809
 810                         dev_info(gf->dev, "    %d: %d=%d -> %s\n", j,
 811                                  event->index, event->value,
 812                                  event->target->name);
 813                 }
 814
 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];
 818
 819                         dev_info(gf->dev, "    %d: %d=%d -> %s\n", j,
 820                                  event->index, event->value,
 821                                  event->target->name);
 822                 }
 823
 824                 if (state->delay_target)
 825                         dev_info(gf->dev, "  Delay: %d ms -> %s\n",
 826                                  state->delay_ms, state->delay_target->name);
 827
 828                 if (state->shutdown_target && state->shutdown_target != state)
 829                         dev_info(gf->dev, "  Shutdown: %d ms -> %s\n",
 830                                  state->shutdown_ms,
 831                                  state->shutdown_target->name);
 832         }
 833         dev_info(gf->dev, "\n");
 834 }
 835
 836 static int resolve_sym_to_state(struct gpio_fsm *gf, struct fsm_state **pstate)
 837 {
 838         struct symtab_entry *sym = (struct symtab_entry *)*pstate;
 839
 840         if (!sym)
 841                 return -ENOMEM;
 842
 843         *pstate = sym->value;
 844
 845         if (!*pstate) {
 846                 dev_err(gf->dev, "state %s not defined\n",
 847                         sym->name);
 848                 return -EINVAL;
 849         }
 850
 851         return 0;
 852 }
 853
 854
 855 /*
 856  * /sys/class/gpio-fsm/<fsm-name>/
 857  *   /state ... the current state
 858  */
 859
 860 static ssize_t state_show(struct device *dev,
 861                           struct device_attribute *attr, char *buf)
 862 {
 863         const struct gpio_fsm *gf = dev_get_drvdata(dev);
 864
 865         return sprintf(buf, "%s\n", gf->current_state->name);
 866 }
 867 static DEVICE_ATTR_RO(state);
 868
 869 static ssize_t delay_state_show(struct device *dev,
 870                           struct device_attribute *attr, char *buf)
 871 {
 872         const struct gpio_fsm *gf = dev_get_drvdata(dev);
 873
 874         return sprintf(buf, "%s\n",
 875                        gf->delay_target_state ? gf->delay_target_state->name :
 876                        "-");
 877 }
 878
 879 static DEVICE_ATTR_RO(delay_state);
 880
 881 static ssize_t delay_ms_show(struct device *dev,
 882                              struct device_attribute *attr, char *buf)
 883 {
 884         const struct gpio_fsm *gf = dev_get_drvdata(dev);
 885         int jiffies_left;
 886
 887         jiffies_left = max((int)(gf->delay_jiffies - jiffies), 0);
 888         return sprintf(buf,
 889                        gf->delay_target_state ? "%u\n" : "-\n",
 890                        jiffies_to_msecs(jiffies_left));
 891 }
 892 static DEVICE_ATTR_RO(delay_ms);
 893
 894 static struct attribute *gpio_fsm_attrs[] = {
 895         &dev_attr_state.attr,
 896         &dev_attr_delay_state.attr,
 897         &dev_attr_delay_ms.attr,
 898         NULL,
 899 };
 900
 901 static const struct attribute_group gpio_fsm_group = {
 902         .attrs = gpio_fsm_attrs,
 903         //.is_visible = gpio_is_visible,
 904 };
 905
 906 static const struct attribute_group *gpio_fsm_groups[] = {
 907         &gpio_fsm_group,
 908         NULL
 909 };
 910
 911 static struct attribute *gpio_fsm_class_attrs[] = {
 912         // There are no top-level attributes
 913         NULL,
 914 };
 915 ATTRIBUTE_GROUPS(gpio_fsm_class);
 916
 917 static struct class gpio_fsm_class = {
 918         .name =         MODULE_NAME,
 919         .owner =        THIS_MODULE,
 920
 921         .class_groups = gpio_fsm_class_groups,
 922 };
 923
 924 static int gpio_fsm_probe(struct platform_device *pdev)
 925 {
 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;
 931         struct gpio_fsm *gf;
 932         u32 debug = 0;
 933         int num_states;
 934         u32 num_soft_gpios;
 935         int ret;
 936         int i;
 937         static const char *const reserved_symbols[] = {
 938                 [SYM_NAME] = "name",
 939                 [SYM_SET] = "set",
 940                 [SYM_START] = "start_state",
 941                 [SYM_SHUTDOWN] = "shutdown_state",
 942         };
 943
 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");
 947                 return -EINVAL;
 948         }
 949
 950         of_property_read_u32(np, "debug", &debug);
 951
 952         gf = devm_kzalloc(dev, sizeof(*gf), GFP_KERNEL);
 953         if (!gf)
 954                 return -ENOMEM;
 955
 956         gf->dev = dev;
 957         gf->debug = debug;
 958
 959         if (of_property_read_u32(np, "shutdown-timeout-ms",
 960                                  &gf->shutdown_timeout_ms))
 961                 gf->shutdown_timeout_ms = 5000;
 962
 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);
 966         if (!gf->soft_gpios)
 967                 return -ENOMEM;
 968         for (i = 0; i < num_soft_gpios; i++) {
 969                 struct soft_gpio *sg = &gf->soft_gpios[i];
 970
 971                 sg->dir = GPIOF_DIR_IN;
 972                 sg->value = 0;
 973         }
 974
 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);
 979                 return ret;
 980         }
 981         gf->num_input_gpios = (gf->input_gpios ? gf->input_gpios->ndescs : 0);
 982
 983         gf->input_gpio_states = devm_kcalloc(dev, gf->num_input_gpios,
 984                                              sizeof(struct input_gpio_state),
 985                                              GFP_KERNEL);
 986         if (!gf->input_gpio_states)
 987                 return -ENOMEM;
 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];
 991                 inp_state->gf = gf;
 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,
 998                                                IRQF_TRIGGER_NONE,
 999                                                dev_name(dev),
1000                                                inp_state);
1001                 else
1002                         ret = inp_state->irq;
1003
1004                 if (ret) {
1005                         dev_err(dev,
1006                                 "failed to get IRQ for input gpio - %d\n",
1007                                 ret);
1008                         return ret;
1009                 }
1010         }
1011
1012         gf->output_gpios = devm_gpiod_get_array_optional(dev, "output",
1013                                                          GPIOD_OUT_LOW);
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);
1017                 return ret;
1018         }
1019         gf->num_output_gpios = (gf->output_gpios ? gf->output_gpios->ndescs :
1020                                 0);
1021
1022         num_states = of_get_child_count(np);
1023         if (!num_states) {
1024                 dev_err(dev, "no states declared\n");
1025                 return -EINVAL;
1026         }
1027         gf->states = devm_kcalloc(dev, num_states,
1028                                   sizeof(struct fsm_state), GFP_KERNEL);
1029         if (!gf->states)
1030                 return -ENOMEM;
1031
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);
1037         }
1038
1039         // parse the state
1040         for_each_child_of_node(np, cp) {
1041                 struct fsm_state *state = &gf->states[gf->num_states];
1042
1043                 ret = gpio_fsm_parse_state(gf, state, cp);
1044                 if (ret)
1045                         return ret;
1046                 gf->num_states++;
1047         }
1048
1049         if (!gf->start_state) {
1050                 dev_err(gf->dev, "no start state defined\n");
1051                 return -EINVAL;
1052         }
1053
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];
1057                 int j;
1058
1059                 for (j = 0; !ret && j < state->num_gpio_events; j++) {
1060                         struct gpio_event *ev = &state->gpio_events[j];
1061
1062                         ret = resolve_sym_to_state(gf, &ev->target);
1063                 }
1064
1065                 for (j = 0; !ret && j < state->num_soft_events; j++) {
1066                         struct gpio_event *ev = &state->soft_events[j];
1067
1068                         ret = resolve_sym_to_state(gf, &ev->target);
1069                 }
1070
1071                 if (!ret) {
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);
1076                 }
1077         }
1078
1079         if (!ret && gf->debug > 1)
1080                 dump_all(gf);
1081
1082         free_symbols(&gf->symtab);
1083
1084         if (ret)
1085                 return ret;
1086
1087         gf->gc.parent = dev;
1088         gf->gc.label = np->name;
1089         gf->gc.owner = THIS_MODULE;
1090         gf->gc.of_node = np;
1091         gf->gc.base = -1;
1092         gf->gc.ngpio = num_soft_gpios;
1093
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);
1104
1105         platform_set_drvdata(pdev, gf);
1106
1107         sysfs_dev = device_create_with_groups(&gpio_fsm_class, dev,
1108                                               MKDEV(0, 0), gf,
1109                                               gpio_fsm_groups,
1110                                               "%s", np->name);
1111         if (IS_ERR(sysfs_dev))
1112                 dev_err(gf->dev, "Error creating sysfs entry\n");
1113
1114         if (gf->debug)
1115                 dev_info(gf->dev, "Start -> %s\n", gf->start_state->name);
1116
1117         gpio_fsm_go_to_state(gf, gf->start_state);
1118
1119         return devm_gpiochip_add_data(dev, &gf->gc, gf);
1120 }
1121
1122 static int gpio_fsm_remove(struct platform_device *pdev)
1123 {
1124         struct gpio_fsm *gf = platform_get_drvdata(pdev);
1125         int i;
1126
1127         if (gf->shutdown_state) {
1128                 if (gf->debug)
1129                         dev_info(gf->dev, "Shutting down...\n");
1130
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);
1138                 }
1139                 spin_unlock(&gf->spinlock);
1140
1141                 wait_event_timeout(gf->shutdown_event,
1142                                    gf->current_state->shutdown_target ==
1143                                    gf->current_state,
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);
1148         }
1149         cancel_work_sync(&gf->work);
1150         del_timer_sync(&gf->timer);
1151
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);
1156         }
1157         if (gf->debug)
1158                 dev_info(gf->dev, "Exiting\n");
1159
1160         return 0;
1161 }
1162
1163 static void gpio_fsm_shutdown(struct platform_device *pdev)
1164 {
1165         gpio_fsm_remove(pdev);
1166 }
1167
1168 static const struct of_device_id gpio_fsm_ids[] = {
1169         { .compatible = "rpi,gpio-fsm" },
1170         { }
1171 };
1172 MODULE_DEVICE_TABLE(of, gpio_fsm_ids);
1173
1174 static struct platform_driver gpio_fsm_driver = {
1175         .driver = {
1176                 .name           = MODULE_NAME,
1177                 .of_match_table = of_match_ptr(gpio_fsm_ids),
1178         },
1179         .probe = gpio_fsm_probe,
1180         .remove = gpio_fsm_remove,
1181         .shutdown = gpio_fsm_shutdown,
1182 };
1183
1184 static int gpio_fsm_init(void)
1185 {
1186         int ret;
1187
1188         ret = class_register(&gpio_fsm_class);
1189         if (ret)
1190                 return ret;
1191
1192         ret = platform_driver_register(&gpio_fsm_driver);
1193         if (ret)
1194                 class_unregister(&gpio_fsm_class);
1195
1196         return ret;
1197 }
1198 module_init(gpio_fsm_init);
1199
1200 static void gpio_fsm_exit(void)
1201 {
1202         platform_driver_unregister(&gpio_fsm_driver);
1203         class_unregister(&gpio_fsm_class);
1204 }
1205 module_exit(gpio_fsm_exit);
1206
1207 MODULE_LICENSE("GPL");
1208 MODULE_AUTHOR("Phil Elwell <phil@raspberrypi.com>");
1209 MODULE_DESCRIPTION("GPIO FSM driver");
1210 MODULE_ALIAS("platform:gpio-fsm");