drivers/firmware/arm_sdei.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 // Copyright (C) 2017 Arm Ltd.
   3 #define pr_fmt(fmt) "sdei: " fmt
   4
   5 #include <linux/acpi.h>
   6 #include <linux/arm_sdei.h>
   7 #include <linux/arm-smccc.h>
   8 #include <linux/atomic.h>
   9 #include <linux/bitops.h>
  10 #include <linux/compiler.h>
  11 #include <linux/cpuhotplug.h>
  12 #include <linux/cpu.h>
  13 #include <linux/cpu_pm.h>
  14 #include <linux/errno.h>
  15 #include <linux/hardirq.h>
  16 #include <linux/kernel.h>
  17 #include <linux/kprobes.h>
  18 #include <linux/kvm_host.h>
  19 #include <linux/list.h>
  20 #include <linux/mutex.h>
  21 #include <linux/notifier.h>
  22 #include <linux/of.h>
  23 #include <linux/of_platform.h>
  24 #include <linux/percpu.h>
  25 #include <linux/platform_device.h>
  26 #include <linux/pm.h>
  27 #include <linux/ptrace.h>
  28 #include <linux/preempt.h>
  29 #include <linux/reboot.h>
  30 #include <linux/slab.h>
  31 #include <linux/smp.h>
  32 #include <linux/spinlock.h>
  33 #include <linux/uaccess.h>
  34
  35 /*
  36  * The call to use to reach the firmware.
  37  */
  38 static asmlinkage void (*sdei_firmware_call)(unsigned long function_id,
  39                       unsigned long arg0, unsigned long arg1,
  40                       unsigned long arg2, unsigned long arg3,
  41                       unsigned long arg4, struct arm_smccc_res *res);
  42
  43 /* entry point from firmware to arch asm code */
  44 static unsigned long sdei_entry_point;
  45
  46 static int sdei_hp_state;
  47
  48 struct sdei_event {
  49         /* These three are protected by the sdei_list_lock */
  50         struct list_head        list;
  51         bool                    reregister;
  52         bool                    reenable;
  53
  54         u32                     event_num;
  55         u8                      type;
  56         u8                      priority;
  57
  58         /* This pointer is handed to firmware as the event argument. */
  59         union {
  60                 /* Shared events */
  61                 struct sdei_registered_event *registered;
  62
  63                 /* CPU private events */
  64                 struct sdei_registered_event __percpu *private_registered;
  65         };
  66 };
  67
  68 /* Take the mutex for any API call or modification. Take the mutex first. */
  69 static DEFINE_MUTEX(sdei_events_lock);
  70
  71 /* and then hold this when modifying the list */
  72 static DEFINE_SPINLOCK(sdei_list_lock);
  73 static LIST_HEAD(sdei_list);
  74
  75 /* Private events are registered/enabled via IPI passing one of these */
  76 struct sdei_crosscall_args {
  77         struct sdei_event *event;
  78         atomic_t errors;
  79         int first_error;
  80 };
  81
  82 #define CROSSCALL_INIT(arg, event)      (arg.event = event, \
  83                                          arg.first_error = 0, \
  84                                          atomic_set(&arg.errors, 0))
  85
  86 static inline int sdei_do_cross_call(void *fn, struct sdei_event * event)
  87 {
  88         struct sdei_crosscall_args arg;
  89
  90         CROSSCALL_INIT(arg, event);
  91         on_each_cpu(fn, &arg, true);
  92
  93         return arg.first_error;
  94 }
  95
  96 static inline void
  97 sdei_cross_call_return(struct sdei_crosscall_args *arg, int err)
  98 {
  99         if (err && (atomic_inc_return(&arg->errors) == 1))
 100                 arg->first_error = err;
 101 }
 102
 103 static int sdei_to_linux_errno(unsigned long sdei_err)
 104 {
 105         switch (sdei_err) {
 106         case SDEI_NOT_SUPPORTED:
 107                 return -EOPNOTSUPP;
 108         case SDEI_INVALID_PARAMETERS:
 109                 return -EINVAL;
 110         case SDEI_DENIED:
 111                 return -EPERM;
 112         case SDEI_PENDING:
 113                 return -EINPROGRESS;
 114         case SDEI_OUT_OF_RESOURCE:
 115                 return -ENOMEM;
 116         }
 117
 118         /* Not an error value ... */
 119         return sdei_err;
 120 }
 121
 122 /*
 123  * If x0 is any of these values, then the call failed, use sdei_to_linux_errno()
 124  * to translate.
 125  */
 126 static int sdei_is_err(struct arm_smccc_res *res)
 127 {
 128         switch (res->a0) {
 129         case SDEI_NOT_SUPPORTED:
 130         case SDEI_INVALID_PARAMETERS:
 131         case SDEI_DENIED:
 132         case SDEI_PENDING:
 133         case SDEI_OUT_OF_RESOURCE:
 134                 return true;
 135         }
 136
 137         return false;
 138 }
 139
 140 static int invoke_sdei_fn(unsigned long function_id, unsigned long arg0,
 141                           unsigned long arg1, unsigned long arg2,
 142                           unsigned long arg3, unsigned long arg4,
 143                           u64 *result)
 144 {
 145         int err = 0;
 146         struct arm_smccc_res res;
 147
 148         if (sdei_firmware_call) {
 149                 sdei_firmware_call(function_id, arg0, arg1, arg2, arg3, arg4,
 150                                    &res);
 151                 if (sdei_is_err(&res))
 152                         err = sdei_to_linux_errno(res.a0);
 153         } else {
 154                 /*
 155                  * !sdei_firmware_call means we failed to probe or called
 156                  * sdei_mark_interface_broken(). -EIO is not an error returned
 157                  * by sdei_to_linux_errno() and is used to suppress messages
 158                  * from this driver.
 159                  */
 160                 err = -EIO;
 161                 res.a0 = SDEI_NOT_SUPPORTED;
 162         }
 163
 164         if (result)
 165                 *result = res.a0;
 166
 167         return err;
 168 }
 169
 170 static struct sdei_event *sdei_event_find(u32 event_num)
 171 {
 172         struct sdei_event *e, *found = NULL;
 173
 174         lockdep_assert_held(&sdei_events_lock);
 175
 176         spin_lock(&sdei_list_lock);
 177         list_for_each_entry(e, &sdei_list, list) {
 178                 if (e->event_num == event_num) {
 179                         found = e;
 180                         break;
 181                 }
 182         }
 183         spin_unlock(&sdei_list_lock);
 184
 185         return found;
 186 }
 187
 188 int sdei_api_event_context(u32 query, u64 *result)
 189 {
 190         return invoke_sdei_fn(SDEI_1_0_FN_SDEI_EVENT_CONTEXT, query, 0, 0, 0, 0,
 191                               result);
 192 }
 193 NOKPROBE_SYMBOL(sdei_api_event_context);
 194
 195 static int sdei_api_event_get_info(u32 event, u32 info, u64 *result)
 196 {
 197         return invoke_sdei_fn(SDEI_1_0_FN_SDEI_EVENT_GET_INFO, event, info, 0,
 198                               0, 0, result);
 199 }
 200
 201 static struct sdei_event *sdei_event_create(u32 event_num,
 202                                             sdei_event_callback *cb,
 203                                             void *cb_arg)
 204 {
 205         int err;
 206         u64 result;
 207         struct sdei_event *event;
 208         struct sdei_registered_event *reg;
 209
 210         lockdep_assert_held(&sdei_events_lock);
 211
 212         event = kzalloc(sizeof(*event), GFP_KERNEL);
 213         if (!event)
 214                 return ERR_PTR(-ENOMEM);
 215
 216         INIT_LIST_HEAD(&event->list);
 217         event->event_num = event_num;
 218
 219         err = sdei_api_event_get_info(event_num, SDEI_EVENT_INFO_EV_PRIORITY,
 220                                       &result);
 221         if (err) {
 222                 kfree(event);
 223                 return ERR_PTR(err);
 224         }
 225         event->priority = result;
 226
 227         err = sdei_api_event_get_info(event_num, SDEI_EVENT_INFO_EV_TYPE,
 228                                       &result);
 229         if (err) {
 230                 kfree(event);
 231                 return ERR_PTR(err);
 232         }
 233         event->type = result;
 234
 235         if (event->type == SDEI_EVENT_TYPE_SHARED) {
 236                 reg = kzalloc(sizeof(*reg), GFP_KERNEL);
 237                 if (!reg) {
 238                         kfree(event);
 239                         return ERR_PTR(-ENOMEM);
 240                 }
 241
 242                 reg->event_num = event_num;
 243                 reg->priority = event->priority;
 244
 245                 reg->callback = cb;
 246                 reg->callback_arg = cb_arg;
 247                 event->registered = reg;
 248         } else {
 249                 int cpu;
 250                 struct sdei_registered_event __percpu *regs;
 251
 252                 regs = alloc_percpu(struct sdei_registered_event);
 253                 if (!regs) {
 254                         kfree(event);
 255                         return ERR_PTR(-ENOMEM);
 256                 }
 257
 258                 for_each_possible_cpu(cpu) {
 259                         reg = per_cpu_ptr(regs, cpu);
 260
 261                         reg->event_num = event->event_num;
 262                         reg->priority = event->priority;
 263                         reg->callback = cb;
 264                         reg->callback_arg = cb_arg;
 265                 }
 266
 267                 event->private_registered = regs;
 268         }
 269
 270         if (sdei_event_find(event_num)) {
 271                 kfree(event->registered);
 272                 kfree(event);
 273                 event = ERR_PTR(-EBUSY);
 274         } else {
 275                 spin_lock(&sdei_list_lock);
 276                 list_add(&event->list, &sdei_list);
 277                 spin_unlock(&sdei_list_lock);
 278         }
 279
 280         return event;
 281 }
 282
 283 static void sdei_event_destroy(struct sdei_event *event)
 284 {
 285         lockdep_assert_held(&sdei_events_lock);
 286
 287         spin_lock(&sdei_list_lock);
 288         list_del(&event->list);
 289         spin_unlock(&sdei_list_lock);
 290
 291         if (event->type == SDEI_EVENT_TYPE_SHARED)
 292                 kfree(event->registered);
 293         else
 294                 free_percpu(event->private_registered);
 295
 296         kfree(event);
 297 }
 298
 299 static int sdei_api_get_version(u64 *version)
 300 {
 301         return invoke_sdei_fn(SDEI_1_0_FN_SDEI_VERSION, 0, 0, 0, 0, 0, version);
 302 }
 303
 304 int sdei_mask_local_cpu(void)
 305 {
 306         int err;
 307
 308         err = invoke_sdei_fn(SDEI_1_0_FN_SDEI_PE_MASK, 0, 0, 0, 0, 0, NULL);
 309         if (err && err != -EIO) {
 310                 pr_warn_once("failed to mask CPU[%u]: %d\n",
 311                               smp_processor_id(), err);
 312                 return err;
 313         }
 314
 315         return 0;
 316 }
 317
 318 static void _ipi_mask_cpu(void *ignored)
 319 {
 320         WARN_ON_ONCE(preemptible());
 321         sdei_mask_local_cpu();
 322 }
 323
 324 int sdei_unmask_local_cpu(void)
 325 {
 326         int err;
 327
 328         err = invoke_sdei_fn(SDEI_1_0_FN_SDEI_PE_UNMASK, 0, 0, 0, 0, 0, NULL);
 329         if (err && err != -EIO) {
 330                 pr_warn_once("failed to unmask CPU[%u]: %d\n",
 331                              smp_processor_id(), err);
 332                 return err;
 333         }
 334
 335         return 0;
 336 }
 337
 338 static void _ipi_unmask_cpu(void *ignored)
 339 {
 340         WARN_ON_ONCE(preemptible());
 341         sdei_unmask_local_cpu();
 342 }
 343
 344 static void _ipi_private_reset(void *ignored)
 345 {
 346         int err;
 347
 348         WARN_ON_ONCE(preemptible());
 349
 350         err = invoke_sdei_fn(SDEI_1_0_FN_SDEI_PRIVATE_RESET, 0, 0, 0, 0, 0,
 351                              NULL);
 352         if (err && err != -EIO)
 353                 pr_warn_once("failed to reset CPU[%u]: %d\n",
 354                              smp_processor_id(), err);
 355 }
 356
 357 static int sdei_api_shared_reset(void)
 358 {
 359         return invoke_sdei_fn(SDEI_1_0_FN_SDEI_SHARED_RESET, 0, 0, 0, 0, 0,
 360                               NULL);
 361 }
 362
 363 static void sdei_mark_interface_broken(void)
 364 {
 365         pr_err("disabling SDEI firmware interface\n");
 366         on_each_cpu(&_ipi_mask_cpu, NULL, true);
 367         sdei_firmware_call = NULL;
 368 }
 369
 370 static int sdei_platform_reset(void)
 371 {
 372         int err;
 373
 374         on_each_cpu(&_ipi_private_reset, NULL, true);
 375         err = sdei_api_shared_reset();
 376         if (err) {
 377                 pr_err("Failed to reset platform: %d\n", err);
 378                 sdei_mark_interface_broken();
 379         }
 380
 381         return err;
 382 }
 383
 384 static int sdei_api_event_enable(u32 event_num)
 385 {
 386         return invoke_sdei_fn(SDEI_1_0_FN_SDEI_EVENT_ENABLE, event_num, 0, 0, 0,
 387                               0, NULL);
 388 }
 389
 390 /* Called directly by the hotplug callbacks */
 391 static void _local_event_enable(void *data)
 392 {
 393         int err;
 394         struct sdei_crosscall_args *arg = data;
 395
 396         err = sdei_api_event_enable(arg->event->event_num);
 397
 398         sdei_cross_call_return(arg, err);
 399 }
 400
 401 int sdei_event_enable(u32 event_num)
 402 {
 403         int err = -EINVAL;
 404         struct sdei_event *event;
 405
 406         mutex_lock(&sdei_events_lock);
 407         event = sdei_event_find(event_num);
 408         if (!event) {
 409                 mutex_unlock(&sdei_events_lock);
 410                 return -ENOENT;
 411         }
 412
 413
 414         cpus_read_lock();
 415         if (event->type == SDEI_EVENT_TYPE_SHARED)
 416                 err = sdei_api_event_enable(event->event_num);
 417         else
 418                 err = sdei_do_cross_call(_local_event_enable, event);
 419
 420         if (!err) {
 421                 spin_lock(&sdei_list_lock);
 422                 event->reenable = true;
 423                 spin_unlock(&sdei_list_lock);
 424         }
 425         cpus_read_unlock();
 426         mutex_unlock(&sdei_events_lock);
 427
 428         return err;
 429 }
 430 EXPORT_SYMBOL(sdei_event_enable);
 431
 432 static int sdei_api_event_disable(u32 event_num)
 433 {
 434         return invoke_sdei_fn(SDEI_1_0_FN_SDEI_EVENT_DISABLE, event_num, 0, 0,
 435                               0, 0, NULL);
 436 }
 437
 438 static void _ipi_event_disable(void *data)
 439 {
 440         int err;
 441         struct sdei_crosscall_args *arg = data;
 442
 443         err = sdei_api_event_disable(arg->event->event_num);
 444
 445         sdei_cross_call_return(arg, err);
 446 }
 447
 448 int sdei_event_disable(u32 event_num)
 449 {
 450         int err = -EINVAL;
 451         struct sdei_event *event;
 452
 453         mutex_lock(&sdei_events_lock);
 454         event = sdei_event_find(event_num);
 455         if (!event) {
 456                 mutex_unlock(&sdei_events_lock);
 457                 return -ENOENT;
 458         }
 459
 460         spin_lock(&sdei_list_lock);
 461         event->reenable = false;
 462         spin_unlock(&sdei_list_lock);
 463
 464         if (event->type == SDEI_EVENT_TYPE_SHARED)
 465                 err = sdei_api_event_disable(event->event_num);
 466         else
 467                 err = sdei_do_cross_call(_ipi_event_disable, event);
 468         mutex_unlock(&sdei_events_lock);
 469
 470         return err;
 471 }
 472 EXPORT_SYMBOL(sdei_event_disable);
 473
 474 static int sdei_api_event_unregister(u32 event_num)
 475 {
 476         return invoke_sdei_fn(SDEI_1_0_FN_SDEI_EVENT_UNREGISTER, event_num, 0,
 477                               0, 0, 0, NULL);
 478 }
 479
 480 /* Called directly by the hotplug callbacks */
 481 static void _local_event_unregister(void *data)
 482 {
 483         int err;
 484         struct sdei_crosscall_args *arg = data;
 485
 486         err = sdei_api_event_unregister(arg->event->event_num);
 487
 488         sdei_cross_call_return(arg, err);
 489 }
 490
 491 static int _sdei_event_unregister(struct sdei_event *event)
 492 {
 493         lockdep_assert_held(&sdei_events_lock);
 494
 495         if (event->type == SDEI_EVENT_TYPE_SHARED)
 496                 return sdei_api_event_unregister(event->event_num);
 497
 498         return sdei_do_cross_call(_local_event_unregister, event);
 499 }
 500
 501 int sdei_event_unregister(u32 event_num)
 502 {
 503         int err;
 504         struct sdei_event *event;
 505
 506         WARN_ON(in_nmi());
 507
 508         mutex_lock(&sdei_events_lock);
 509         event = sdei_event_find(event_num);
 510         do {
 511                 if (!event) {
 512                         pr_warn("Event %u not registered\n", event_num);
 513                         err = -ENOENT;
 514                         break;
 515                 }
 516
 517                 spin_lock(&sdei_list_lock);
 518                 event->reregister = false;
 519                 event->reenable = false;
 520                 spin_unlock(&sdei_list_lock);
 521
 522                 err = _sdei_event_unregister(event);
 523                 if (err)
 524                         break;
 525
 526                 sdei_event_destroy(event);
 527         } while (0);
 528         mutex_unlock(&sdei_events_lock);
 529
 530         return err;
 531 }
 532 EXPORT_SYMBOL(sdei_event_unregister);
 533
 534 /*
 535  * unregister events, but don't destroy them as they are re-registered by
 536  * sdei_reregister_shared().
 537  */
 538 static int sdei_unregister_shared(void)
 539 {
 540         int err = 0;
 541         struct sdei_event *event;
 542
 543         mutex_lock(&sdei_events_lock);
 544         spin_lock(&sdei_list_lock);
 545         list_for_each_entry(event, &sdei_list, list) {
 546                 if (event->type != SDEI_EVENT_TYPE_SHARED)
 547                         continue;
 548
 549                 err = _sdei_event_unregister(event);
 550                 if (err)
 551                         break;
 552         }
 553         spin_unlock(&sdei_list_lock);
 554         mutex_unlock(&sdei_events_lock);
 555
 556         return err;
 557 }
 558
 559 static int sdei_api_event_register(u32 event_num, unsigned long entry_point,
 560                                    void *arg, u64 flags, u64 affinity)
 561 {
 562         return invoke_sdei_fn(SDEI_1_0_FN_SDEI_EVENT_REGISTER, event_num,
 563                               (unsigned long)entry_point, (unsigned long)arg,
 564                               flags, affinity, NULL);
 565 }
 566
 567 /* Called directly by the hotplug callbacks */
 568 static void _local_event_register(void *data)
 569 {
 570         int err;
 571         struct sdei_registered_event *reg;
 572         struct sdei_crosscall_args *arg = data;
 573
 574         reg = per_cpu_ptr(arg->event->private_registered, smp_processor_id());
 575         err = sdei_api_event_register(arg->event->event_num, sdei_entry_point,
 576                                       reg, 0, 0);
 577
 578         sdei_cross_call_return(arg, err);
 579 }
 580
 581 static int _sdei_event_register(struct sdei_event *event)
 582 {
 583         int err;
 584
 585         lockdep_assert_held(&sdei_events_lock);
 586
 587         if (event->type == SDEI_EVENT_TYPE_SHARED)
 588                 return sdei_api_event_register(event->event_num,
 589                                                sdei_entry_point,
 590                                                event->registered,
 591                                                SDEI_EVENT_REGISTER_RM_ANY, 0);
 592
 593         err = sdei_do_cross_call(_local_event_register, event);
 594         if (err)
 595                 sdei_do_cross_call(_local_event_unregister, event);
 596
 597         return err;
 598 }
 599
 600 int sdei_event_register(u32 event_num, sdei_event_callback *cb, void *arg)
 601 {
 602         int err;
 603         struct sdei_event *event;
 604
 605         WARN_ON(in_nmi());
 606
 607         mutex_lock(&sdei_events_lock);
 608         do {
 609                 if (sdei_event_find(event_num)) {
 610                         pr_warn("Event %u already registered\n", event_num);
 611                         err = -EBUSY;
 612                         break;
 613                 }
 614
 615                 event = sdei_event_create(event_num, cb, arg);
 616                 if (IS_ERR(event)) {
 617                         err = PTR_ERR(event);
 618                         pr_warn("Failed to create event %u: %d\n", event_num,
 619                                 err);
 620                         break;
 621                 }
 622
 623                 cpus_read_lock();
 624                 err = _sdei_event_register(event);
 625                 if (err) {
 626                         sdei_event_destroy(event);
 627                         pr_warn("Failed to register event %u: %d\n", event_num,
 628                                 err);
 629                 } else {
 630                         spin_lock(&sdei_list_lock);
 631                         event->reregister = true;
 632                         spin_unlock(&sdei_list_lock);
 633                 }
 634                 cpus_read_unlock();
 635         } while (0);
 636         mutex_unlock(&sdei_events_lock);
 637
 638         return err;
 639 }
 640 EXPORT_SYMBOL(sdei_event_register);
 641
 642 static int sdei_reregister_event(struct sdei_event *event)
 643 {
 644         int err;
 645
 646         lockdep_assert_held(&sdei_events_lock);
 647
 648         err = _sdei_event_register(event);
 649         if (err) {
 650                 pr_err("Failed to re-register event %u\n", event->event_num);
 651                 sdei_event_destroy(event);
 652                 return err;
 653         }
 654
 655         if (event->reenable) {
 656                 if (event->type == SDEI_EVENT_TYPE_SHARED)
 657                         err = sdei_api_event_enable(event->event_num);
 658                 else
 659                         err = sdei_do_cross_call(_local_event_enable, event);
 660         }
 661
 662         if (err)
 663                 pr_err("Failed to re-enable event %u\n", event->event_num);
 664
 665         return err;
 666 }
 667
 668 static int sdei_reregister_shared(void)
 669 {
 670         int err = 0;
 671         struct sdei_event *event;
 672
 673         mutex_lock(&sdei_events_lock);
 674         spin_lock(&sdei_list_lock);
 675         list_for_each_entry(event, &sdei_list, list) {
 676                 if (event->type != SDEI_EVENT_TYPE_SHARED)
 677                         continue;
 678
 679                 if (event->reregister) {
 680                         err = sdei_reregister_event(event);
 681                         if (err)
 682                                 break;
 683                 }
 684         }
 685         spin_unlock(&sdei_list_lock);
 686         mutex_unlock(&sdei_events_lock);
 687
 688         return err;
 689 }
 690
 691 static int sdei_cpuhp_down(unsigned int cpu)
 692 {
 693         struct sdei_event *event;
 694         struct sdei_crosscall_args arg;
 695
 696         /* un-register private events */
 697         spin_lock(&sdei_list_lock);
 698         list_for_each_entry(event, &sdei_list, list) {
 699                 if (event->type == SDEI_EVENT_TYPE_SHARED)
 700                         continue;
 701
 702                 CROSSCALL_INIT(arg, event);
 703                 /* call the cross-call function locally... */
 704                 _local_event_unregister(&arg);
 705                 if (arg.first_error)
 706                         pr_err("Failed to unregister event %u: %d\n",
 707                                event->event_num, arg.first_error);
 708         }
 709         spin_unlock(&sdei_list_lock);
 710
 711         return sdei_mask_local_cpu();
 712 }
 713
 714 static int sdei_cpuhp_up(unsigned int cpu)
 715 {
 716         struct sdei_event *event;
 717         struct sdei_crosscall_args arg;
 718
 719         /* re-register/enable private events */
 720         spin_lock(&sdei_list_lock);
 721         list_for_each_entry(event, &sdei_list, list) {
 722                 if (event->type == SDEI_EVENT_TYPE_SHARED)
 723                         continue;
 724
 725                 if (event->reregister) {
 726                         CROSSCALL_INIT(arg, event);
 727                         /* call the cross-call function locally... */
 728                         _local_event_register(&arg);
 729                         if (arg.first_error)
 730                                 pr_err("Failed to re-register event %u: %d\n",
 731                                        event->event_num, arg.first_error);
 732                 }
 733
 734                 if (event->reenable) {
 735                         CROSSCALL_INIT(arg, event);
 736                         _local_event_enable(&arg);
 737                         if (arg.first_error)
 738                                 pr_err("Failed to re-enable event %u: %d\n",
 739                                        event->event_num, arg.first_error);
 740                 }
 741         }
 742         spin_unlock(&sdei_list_lock);
 743
 744         return sdei_unmask_local_cpu();
 745 }
 746
 747 /* When entering idle, mask/unmask events for this cpu */
 748 static int sdei_pm_notifier(struct notifier_block *nb, unsigned long action,
 749                             void *data)
 750 {
 751         int rv;
 752
 753         WARN_ON_ONCE(preemptible());
 754
 755         switch (action) {
 756         case CPU_PM_ENTER:
 757                 rv = sdei_mask_local_cpu();
 758                 break;
 759         case CPU_PM_EXIT:
 760         case CPU_PM_ENTER_FAILED:
 761                 rv = sdei_unmask_local_cpu();
 762                 break;
 763         default:
 764                 return NOTIFY_DONE;
 765         }
 766
 767         if (rv)
 768                 return notifier_from_errno(rv);
 769
 770         return NOTIFY_OK;
 771 }
 772
 773 static struct notifier_block sdei_pm_nb = {
 774         .notifier_call = sdei_pm_notifier,
 775 };
 776
 777 static int sdei_device_suspend(struct device *dev)
 778 {
 779         on_each_cpu(_ipi_mask_cpu, NULL, true);
 780
 781         return 0;
 782 }
 783
 784 static int sdei_device_resume(struct device *dev)
 785 {
 786         on_each_cpu(_ipi_unmask_cpu, NULL, true);
 787
 788         return 0;
 789 }
 790
 791 /*
 792  * We need all events to be reregistered when we resume from hibernate.
 793  *
 794  * The sequence is freeze->thaw. Reboot. freeze->restore. We unregister
 795  * events during freeze, then re-register and re-enable them during thaw
 796  * and restore.
 797  */
 798 static int sdei_device_freeze(struct device *dev)
 799 {
 800         int err;
 801
 802         /* unregister private events */
 803         cpuhp_remove_state(sdei_entry_point);
 804
 805         err = sdei_unregister_shared();
 806         if (err)
 807                 return err;
 808
 809         return 0;
 810 }
 811
 812 static int sdei_device_thaw(struct device *dev)
 813 {
 814         int err;
 815
 816         /* re-register shared events */
 817         err = sdei_reregister_shared();
 818         if (err) {
 819                 pr_warn("Failed to re-register shared events...\n");
 820                 sdei_mark_interface_broken();
 821                 return err;
 822         }
 823
 824         err = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "SDEI",
 825                                 &sdei_cpuhp_up, &sdei_cpuhp_down);
 826         if (err < 0) {
 827                 pr_warn("Failed to re-register CPU hotplug notifier...\n");
 828                 return err;
 829         }
 830
 831         sdei_hp_state = err;
 832         return 0;
 833 }
 834
 835 static int sdei_device_restore(struct device *dev)
 836 {
 837         int err;
 838
 839         err = sdei_platform_reset();
 840         if (err)
 841                 return err;
 842
 843         return sdei_device_thaw(dev);
 844 }
 845
 846 static const struct dev_pm_ops sdei_pm_ops = {
 847         .suspend = sdei_device_suspend,
 848         .resume = sdei_device_resume,
 849         .freeze = sdei_device_freeze,
 850         .thaw = sdei_device_thaw,
 851         .restore = sdei_device_restore,
 852 };
 853
 854 /*
 855  * Mask all CPUs and unregister all events on panic, reboot or kexec.
 856  */
 857 static int sdei_reboot_notifier(struct notifier_block *nb, unsigned long action,
 858                                 void *data)
 859 {
 860         /*
 861          * We are going to reset the interface, after this there is no point
 862          * doing work when we take CPUs offline.
 863          */
 864         cpuhp_remove_state(sdei_hp_state);
 865
 866         sdei_platform_reset();
 867
 868         return NOTIFY_OK;
 869 }
 870
 871 static struct notifier_block sdei_reboot_nb = {
 872         .notifier_call = sdei_reboot_notifier,
 873 };
 874
 875 static void sdei_smccc_smc(unsigned long function_id,
 876                            unsigned long arg0, unsigned long arg1,
 877                            unsigned long arg2, unsigned long arg3,
 878                            unsigned long arg4, struct arm_smccc_res *res)
 879 {
 880         arm_smccc_smc(function_id, arg0, arg1, arg2, arg3, arg4, 0, 0, res);
 881 }
 882
 883 static void sdei_smccc_hvc(unsigned long function_id,
 884                            unsigned long arg0, unsigned long arg1,
 885                            unsigned long arg2, unsigned long arg3,
 886                            unsigned long arg4, struct arm_smccc_res *res)
 887 {
 888         arm_smccc_hvc(function_id, arg0, arg1, arg2, arg3, arg4, 0, 0, res);
 889 }
 890
 891 static int sdei_get_conduit(struct platform_device *pdev)
 892 {
 893         const char *method;
 894         struct device_node *np = pdev->dev.of_node;
 895
 896         sdei_firmware_call = NULL;
 897         if (np) {
 898                 if (of_property_read_string(np, "method", &method)) {
 899                         pr_warn("missing \"method\" property\n");
 900                         return CONDUIT_INVALID;
 901                 }
 902
 903                 if (!strcmp("hvc", method)) {
 904                         sdei_firmware_call = &sdei_smccc_hvc;
 905                         return CONDUIT_HVC;
 906                 } else if (!strcmp("smc", method)) {
 907                         sdei_firmware_call = &sdei_smccc_smc;
 908                         return CONDUIT_SMC;
 909                 }
 910
 911                 pr_warn("invalid \"method\" property: %s\n", method);
 912         } else if (IS_ENABLED(CONFIG_ACPI) && !acpi_disabled) {
 913                 if (acpi_psci_use_hvc()) {
 914                         sdei_firmware_call = &sdei_smccc_hvc;
 915                         return CONDUIT_HVC;
 916                 } else {
 917                         sdei_firmware_call = &sdei_smccc_smc;
 918                         return CONDUIT_SMC;
 919                 }
 920         }
 921
 922         return CONDUIT_INVALID;
 923 }
 924
 925 static int sdei_probe(struct platform_device *pdev)
 926 {
 927         int err;
 928         u64 ver = 0;
 929         int conduit;
 930
 931         conduit = sdei_get_conduit(pdev);
 932         if (!sdei_firmware_call)
 933                 return 0;
 934
 935         err = sdei_api_get_version(&ver);
 936         if (err == -EOPNOTSUPP)
 937                 pr_err("advertised but not implemented in platform firmware\n");
 938         if (err) {
 939                 pr_err("Failed to get SDEI version: %d\n", err);
 940                 sdei_mark_interface_broken();
 941                 return err;
 942         }
 943
 944         pr_info("SDEIv%d.%d (0x%x) detected in firmware.\n",
 945                 (int)SDEI_VERSION_MAJOR(ver), (int)SDEI_VERSION_MINOR(ver),
 946                 (int)SDEI_VERSION_VENDOR(ver));
 947
 948         if (SDEI_VERSION_MAJOR(ver) != 1) {
 949                 pr_warn("Conflicting SDEI version detected.\n");
 950                 sdei_mark_interface_broken();
 951                 return -EINVAL;
 952         }
 953
 954         err = sdei_platform_reset();
 955         if (err)
 956                 return err;
 957
 958         sdei_entry_point = sdei_arch_get_entry_point(conduit);
 959         if (!sdei_entry_point) {
 960                 /* Not supported due to hardware or boot configuration */
 961                 sdei_mark_interface_broken();
 962                 return 0;
 963         }
 964
 965         err = cpu_pm_register_notifier(&sdei_pm_nb);
 966         if (err) {
 967                 pr_warn("Failed to register CPU PM notifier...\n");
 968                 goto error;
 969         }
 970
 971         err = register_reboot_notifier(&sdei_reboot_nb);
 972         if (err) {
 973                 pr_warn("Failed to register reboot notifier...\n");
 974                 goto remove_cpupm;
 975         }
 976
 977         err = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "SDEI",
 978                                 &sdei_cpuhp_up, &sdei_cpuhp_down);
 979         if (err < 0) {
 980                 pr_warn("Failed to register CPU hotplug notifier...\n");
 981                 goto remove_reboot;
 982         }
 983
 984         sdei_hp_state = err;
 985
 986         return 0;
 987
 988 remove_reboot:
 989         unregister_reboot_notifier(&sdei_reboot_nb);
 990
 991 remove_cpupm:
 992         cpu_pm_unregister_notifier(&sdei_pm_nb);
 993
 994 error:
 995         sdei_mark_interface_broken();
 996         return err;
 997 }
 998
 999 static const struct of_device_id sdei_of_match[] = {
1000         { .compatible = "arm,sdei-1.0" },
1001         {}
1002 };
1003
1004 static struct platform_driver sdei_driver = {
1005         .driver         = {
1006                 .name                   = "sdei",
1007                 .pm                     = &sdei_pm_ops,
1008                 .of_match_table         = sdei_of_match,
1009         },
1010         .probe          = sdei_probe,
1011 };
1012
1013 static bool __init sdei_present_dt(void)
1014 {
1015         struct device_node *np, *fw_np;
1016
1017         fw_np = of_find_node_by_name(NULL, "firmware");
1018         if (!fw_np)
1019                 return false;
1020
1021         np = of_find_matching_node(fw_np, sdei_of_match);
1022         if (!np)
1023                 return false;
1024         of_node_put(np);
1025
1026         return true;
1027 }
1028
1029 static bool __init sdei_present_acpi(void)
1030 {
1031         acpi_status status;
1032         struct platform_device *pdev;
1033         struct acpi_table_header *sdei_table_header;
1034
1035         if (acpi_disabled)
1036                 return false;
1037
1038         status = acpi_get_table(ACPI_SIG_SDEI, 0, &sdei_table_header);
1039         if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
1040                 const char *msg = acpi_format_exception(status);
1041
1042                 pr_info("Failed to get ACPI:SDEI table, %s\n", msg);
1043         }
1044         if (ACPI_FAILURE(status))
1045                 return false;
1046
1047         pdev = platform_device_register_simple(sdei_driver.driver.name, 0, NULL,
1048                                                0);
1049         if (IS_ERR(pdev))
1050                 return false;
1051
1052         return true;
1053 }
1054
1055 static int __init sdei_init(void)
1056 {
1057         if (sdei_present_dt() || sdei_present_acpi())
1058                 platform_driver_register(&sdei_driver);
1059
1060         return 0;
1061 }
1062
1063 /*
1064  * On an ACPI system SDEI needs to be ready before HEST:GHES tries to register
1065  * its events. ACPI is initialised from a subsys_initcall(), GHES is initialised
1066  * by device_initcall(). We want to be called in the middle.
1067  */
1068 subsys_initcall_sync(sdei_init);
1069
1070 int sdei_event_handler(struct pt_regs *regs,
1071                        struct sdei_registered_event *arg)
1072 {
1073         int err;
1074         mm_segment_t orig_addr_limit;
1075         u32 event_num = arg->event_num;
1076
1077         orig_addr_limit = get_fs();
1078         set_fs(USER_DS);
1079
1080         err = arg->callback(event_num, regs, arg->callback_arg);
1081         if (err)
1082                 pr_err_ratelimited("event %u on CPU %u failed with error: %d\n",
1083                                    event_num, smp_processor_id(), err);
1084
1085         set_fs(orig_addr_limit);
1086
1087         return err;
1088 }
1089 NOKPROBE_SYMBOL(sdei_event_handler);