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