lib/test_firmware.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * This module provides an interface to trigger and test firmware loading.
   4  *
   5  * It is designed to be used for basic evaluation of the firmware loading
   6  * subsystem (for example when validating firmware verification). It lacks
   7  * any extra dependencies, and will not normally be loaded by the system
   8  * unless explicitly requested by name.
   9  */
  10
  11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  12
  13 #include <linux/init.h>
  14 #include <linux/module.h>
  15 #include <linux/printk.h>
  16 #include <linux/completion.h>
  17 #include <linux/firmware.h>
  18 #include <linux/device.h>
  19 #include <linux/fs.h>
  20 #include <linux/miscdevice.h>
  21 #include <linux/sizes.h>
  22 #include <linux/slab.h>
  23 #include <linux/uaccess.h>
  24 #include <linux/delay.h>
  25 #include <linux/kstrtox.h>
  26 #include <linux/kthread.h>
  27 #include <linux/vmalloc.h>
  28 #include <linux/efi_embedded_fw.h>
  29
  30 MODULE_IMPORT_NS(TEST_FIRMWARE);
  31
  32 #define TEST_FIRMWARE_NAME      "test-firmware.bin"
  33 #define TEST_FIRMWARE_NUM_REQS  4
  34 #define TEST_FIRMWARE_BUF_SIZE  SZ_1K
  35 #define TEST_UPLOAD_MAX_SIZE    SZ_2K
  36 #define TEST_UPLOAD_BLK_SIZE    37      /* Avoid powers of two in testing */
  37
  38 static DEFINE_MUTEX(test_fw_mutex);
  39 static const struct firmware *test_firmware;
  40 static LIST_HEAD(test_upload_list);
  41
  42 struct test_batched_req {
  43         u8 idx;
  44         int rc;
  45         bool sent;
  46         const struct firmware *fw;
  47         const char *name;
  48         const char *fw_buf;
  49         struct completion completion;
  50         struct task_struct *task;
  51         struct device *dev;
  52 };
  53
  54 /**
  55  * struct test_config - represents configuration for the test for different triggers
  56  *
  57  * @name: the name of the firmware file to look for
  58  * @into_buf: when the into_buf is used if this is true
  59  *      request_firmware_into_buf() will be used instead.
  60  * @buf_size: size of buf to allocate when into_buf is true
  61  * @file_offset: file offset to request when calling request_firmware_into_buf
  62  * @partial: partial read opt when calling request_firmware_into_buf
  63  * @sync_direct: when the sync trigger is used if this is true
  64  *      request_firmware_direct() will be used instead.
  65  * @send_uevent: whether or not to send a uevent for async requests
  66  * @num_requests: number of requests to try per test case. This is trigger
  67  *      specific.
  68  * @reqs: stores all requests information
  69  * @read_fw_idx: index of thread from which we want to read firmware results
  70  *      from through the read_fw trigger.
  71  * @upload_name: firmware name to be used with upload_read sysfs node
  72  * @test_result: a test may use this to collect the result from the call
  73  *      of the request_firmware*() calls used in their tests. In order of
  74  *      priority we always keep first any setup error. If no setup errors were
  75  *      found then we move on to the first error encountered while running the
  76  *      API. Note that for async calls this typically will be a successful
  77  *      result (0) unless of course you've used bogus parameters, or the system
  78  *      is out of memory.  In the async case the callback is expected to do a
  79  *      bit more homework to figure out what happened, unfortunately the only
  80  *      information passed today on error is the fact that no firmware was
  81  *      found so we can only assume -ENOENT on async calls if the firmware is
  82  *      NULL.
  83  *
  84  *      Errors you can expect:
  85  *
  86  *      API specific:
  87  *
  88  *      0:              success for sync, for async it means request was sent
  89  *      -EINVAL:        invalid parameters or request
  90  *      -ENOENT:        files not found
  91  *
  92  *      System environment:
  93  *
  94  *      -ENOMEM:        memory pressure on system
  95  *      -ENODEV:        out of number of devices to test
  96  *      -EINVAL:        an unexpected error has occurred
  97  * @req_firmware: if @sync_direct is true this is set to
  98  *      request_firmware_direct(), otherwise request_firmware()
  99  */
 100 struct test_config {
 101         char *name;
 102         bool into_buf;
 103         size_t buf_size;
 104         size_t file_offset;
 105         bool partial;
 106         bool sync_direct;
 107         bool send_uevent;
 108         u8 num_requests;
 109         u8 read_fw_idx;
 110         char *upload_name;
 111
 112         /*
 113          * These below don't belong her but we'll move them once we create
 114          * a struct fw_test_device and stuff the misc_dev under there later.
 115          */
 116         struct test_batched_req *reqs;
 117         int test_result;
 118         int (*req_firmware)(const struct firmware **fw, const char *name,
 119                             struct device *device);
 120 };
 121
 122 struct upload_inject_err {
 123         const char *prog;
 124         enum fw_upload_err err_code;
 125 };
 126
 127 struct test_firmware_upload {
 128         char *name;
 129         struct list_head node;
 130         char *buf;
 131         size_t size;
 132         bool cancel_request;
 133         struct upload_inject_err inject;
 134         struct fw_upload *fwl;
 135 };
 136
 137 static struct test_config *test_fw_config;
 138
 139 static struct test_firmware_upload *upload_lookup_name(const char *name)
 140 {
 141         struct test_firmware_upload *tst;
 142
 143         list_for_each_entry(tst, &test_upload_list, node)
 144                 if (strncmp(name, tst->name, strlen(tst->name)) == 0)
 145                         return tst;
 146
 147         return NULL;
 148 }
 149
 150 static ssize_t test_fw_misc_read(struct file *f, char __user *buf,
 151                                  size_t size, loff_t *offset)
 152 {
 153         ssize_t rc = 0;
 154
 155         mutex_lock(&test_fw_mutex);
 156         if (test_firmware)
 157                 rc = simple_read_from_buffer(buf, size, offset,
 158                                              test_firmware->data,
 159                                              test_firmware->size);
 160         mutex_unlock(&test_fw_mutex);
 161         return rc;
 162 }
 163
 164 static const struct file_operations test_fw_fops = {
 165         .owner          = THIS_MODULE,
 166         .read           = test_fw_misc_read,
 167 };
 168
 169 static void __test_release_all_firmware(void)
 170 {
 171         struct test_batched_req *req;
 172         u8 i;
 173
 174         if (!test_fw_config->reqs)
 175                 return;
 176
 177         for (i = 0; i < test_fw_config->num_requests; i++) {
 178                 req = &test_fw_config->reqs[i];
 179                 if (req->fw) {
 180                         if (req->fw_buf) {
 181                                 kfree_const(req->fw_buf);
 182                                 req->fw_buf = NULL;
 183                         }
 184                         release_firmware(req->fw);
 185                         req->fw = NULL;
 186                 }
 187         }
 188
 189         vfree(test_fw_config->reqs);
 190         test_fw_config->reqs = NULL;
 191 }
 192
 193 static void test_release_all_firmware(void)
 194 {
 195         mutex_lock(&test_fw_mutex);
 196         __test_release_all_firmware();
 197         mutex_unlock(&test_fw_mutex);
 198 }
 199
 200
 201 static void __test_firmware_config_free(void)
 202 {
 203         __test_release_all_firmware();
 204         kfree_const(test_fw_config->name);
 205         test_fw_config->name = NULL;
 206 }
 207
 208 /*
 209  * XXX: move to kstrncpy() once merged.
 210  *
 211  * Users should use kfree_const() when freeing these.
 212  */
 213 static int __kstrncpy(char **dst, const char *name, size_t count, gfp_t gfp)
 214 {
 215         *dst = kstrndup(name, count, gfp);
 216         if (!*dst)
 217                 return -ENOMEM;
 218         return count;
 219 }
 220
 221 static int __test_firmware_config_init(void)
 222 {
 223         int ret;
 224
 225         ret = __kstrncpy(&test_fw_config->name, TEST_FIRMWARE_NAME,
 226                          strlen(TEST_FIRMWARE_NAME), GFP_KERNEL);
 227         if (ret < 0)
 228                 goto out;
 229
 230         test_fw_config->num_requests = TEST_FIRMWARE_NUM_REQS;
 231         test_fw_config->send_uevent = true;
 232         test_fw_config->into_buf = false;
 233         test_fw_config->buf_size = TEST_FIRMWARE_BUF_SIZE;
 234         test_fw_config->file_offset = 0;
 235         test_fw_config->partial = false;
 236         test_fw_config->sync_direct = false;
 237         test_fw_config->req_firmware = request_firmware;
 238         test_fw_config->test_result = 0;
 239         test_fw_config->reqs = NULL;
 240         test_fw_config->upload_name = NULL;
 241
 242         return 0;
 243
 244 out:
 245         __test_firmware_config_free();
 246         return ret;
 247 }
 248
 249 static ssize_t reset_store(struct device *dev,
 250                            struct device_attribute *attr,
 251                            const char *buf, size_t count)
 252 {
 253         int ret;
 254
 255         mutex_lock(&test_fw_mutex);
 256
 257         __test_firmware_config_free();
 258
 259         ret = __test_firmware_config_init();
 260         if (ret < 0) {
 261                 ret = -ENOMEM;
 262                 pr_err("could not alloc settings for config trigger: %d\n",
 263                        ret);
 264                 goto out;
 265         }
 266
 267         pr_info("reset\n");
 268         ret = count;
 269
 270 out:
 271         mutex_unlock(&test_fw_mutex);
 272
 273         return ret;
 274 }
 275 static DEVICE_ATTR_WO(reset);
 276
 277 static ssize_t config_show(struct device *dev,
 278                            struct device_attribute *attr,
 279                            char *buf)
 280 {
 281         int len = 0;
 282
 283         mutex_lock(&test_fw_mutex);
 284
 285         len += scnprintf(buf, PAGE_SIZE - len,
 286                         "Custom trigger configuration for: %s\n",
 287                         dev_name(dev));
 288
 289         if (test_fw_config->name)
 290                 len += scnprintf(buf + len, PAGE_SIZE - len,
 291                                 "name:\t%s\n",
 292                                 test_fw_config->name);
 293         else
 294                 len += scnprintf(buf + len, PAGE_SIZE - len,
 295                                 "name:\tEMPTY\n");
 296
 297         len += scnprintf(buf + len, PAGE_SIZE - len,
 298                         "num_requests:\t%u\n", test_fw_config->num_requests);
 299
 300         len += scnprintf(buf + len, PAGE_SIZE - len,
 301                         "send_uevent:\t\t%s\n",
 302                         test_fw_config->send_uevent ?
 303                         "FW_ACTION_UEVENT" :
 304                         "FW_ACTION_NOUEVENT");
 305         len += scnprintf(buf + len, PAGE_SIZE - len,
 306                         "into_buf:\t\t%s\n",
 307                         test_fw_config->into_buf ? "true" : "false");
 308         len += scnprintf(buf + len, PAGE_SIZE - len,
 309                         "buf_size:\t%zu\n", test_fw_config->buf_size);
 310         len += scnprintf(buf + len, PAGE_SIZE - len,
 311                         "file_offset:\t%zu\n", test_fw_config->file_offset);
 312         len += scnprintf(buf + len, PAGE_SIZE - len,
 313                         "partial:\t\t%s\n",
 314                         test_fw_config->partial ? "true" : "false");
 315         len += scnprintf(buf + len, PAGE_SIZE - len,
 316                         "sync_direct:\t\t%s\n",
 317                         test_fw_config->sync_direct ? "true" : "false");
 318         len += scnprintf(buf + len, PAGE_SIZE - len,
 319                         "read_fw_idx:\t%u\n", test_fw_config->read_fw_idx);
 320         if (test_fw_config->upload_name)
 321                 len += scnprintf(buf + len, PAGE_SIZE - len,
 322                                 "upload_name:\t%s\n",
 323                                 test_fw_config->upload_name);
 324         else
 325                 len += scnprintf(buf + len, PAGE_SIZE - len,
 326                                 "upload_name:\tEMPTY\n");
 327
 328         mutex_unlock(&test_fw_mutex);
 329
 330         return len;
 331 }
 332 static DEVICE_ATTR_RO(config);
 333
 334 static ssize_t config_name_store(struct device *dev,
 335                                  struct device_attribute *attr,
 336                                  const char *buf, size_t count)
 337 {
 338         int ret;
 339
 340         mutex_lock(&test_fw_mutex);
 341         kfree_const(test_fw_config->name);
 342         ret = __kstrncpy(&test_fw_config->name, buf, count, GFP_KERNEL);
 343         mutex_unlock(&test_fw_mutex);
 344
 345         return ret;
 346 }
 347
 348 /*
 349  * As per sysfs_kf_seq_show() the buf is max PAGE_SIZE.
 350  */
 351 static ssize_t config_test_show_str(char *dst,
 352                                     char *src)
 353 {
 354         int len;
 355
 356         mutex_lock(&test_fw_mutex);
 357         len = snprintf(dst, PAGE_SIZE, "%s\n", src);
 358         mutex_unlock(&test_fw_mutex);
 359
 360         return len;
 361 }
 362
 363 static inline int __test_dev_config_update_bool(const char *buf, size_t size,
 364                                        bool *cfg)
 365 {
 366         int ret;
 367
 368         if (kstrtobool(buf, cfg) < 0)
 369                 ret = -EINVAL;
 370         else
 371                 ret = size;
 372
 373         return ret;
 374 }
 375
 376 static int test_dev_config_update_bool(const char *buf, size_t size,
 377                                        bool *cfg)
 378 {
 379         int ret;
 380
 381         mutex_lock(&test_fw_mutex);
 382         ret = __test_dev_config_update_bool(buf, size, cfg);
 383         mutex_unlock(&test_fw_mutex);
 384
 385         return ret;
 386 }
 387
 388 static ssize_t test_dev_config_show_bool(char *buf, bool val)
 389 {
 390         return snprintf(buf, PAGE_SIZE, "%d\n", val);
 391 }
 392
 393 static int __test_dev_config_update_size_t(
 394                                          const char *buf,
 395                                          size_t size,
 396                                          size_t *cfg)
 397 {
 398         int ret;
 399         long new;
 400
 401         ret = kstrtol(buf, 10, &new);
 402         if (ret)
 403                 return ret;
 404
 405         *(size_t *)cfg = new;
 406
 407         /* Always return full write size even if we didn't consume all */
 408         return size;
 409 }
 410
 411 static ssize_t test_dev_config_show_size_t(char *buf, size_t val)
 412 {
 413         return snprintf(buf, PAGE_SIZE, "%zu\n", val);
 414 }
 415
 416 static ssize_t test_dev_config_show_int(char *buf, int val)
 417 {
 418         return snprintf(buf, PAGE_SIZE, "%d\n", val);
 419 }
 420
 421 static int __test_dev_config_update_u8(const char *buf, size_t size, u8 *cfg)
 422 {
 423         u8 val;
 424         int ret;
 425
 426         ret = kstrtou8(buf, 10, &val);
 427         if (ret)
 428                 return ret;
 429
 430         *(u8 *)cfg = val;
 431
 432         /* Always return full write size even if we didn't consume all */
 433         return size;
 434 }
 435
 436 static int test_dev_config_update_u8(const char *buf, size_t size, u8 *cfg)
 437 {
 438         int ret;
 439
 440         mutex_lock(&test_fw_mutex);
 441         ret = __test_dev_config_update_u8(buf, size, cfg);
 442         mutex_unlock(&test_fw_mutex);
 443
 444         return ret;
 445 }
 446
 447 static ssize_t test_dev_config_show_u8(char *buf, u8 val)
 448 {
 449         return snprintf(buf, PAGE_SIZE, "%u\n", val);
 450 }
 451
 452 static ssize_t config_name_show(struct device *dev,
 453                                 struct device_attribute *attr,
 454                                 char *buf)
 455 {
 456         return config_test_show_str(buf, test_fw_config->name);
 457 }
 458 static DEVICE_ATTR_RW(config_name);
 459
 460 static ssize_t config_upload_name_store(struct device *dev,
 461                                         struct device_attribute *attr,
 462                                         const char *buf, size_t count)
 463 {
 464         struct test_firmware_upload *tst;
 465         int ret = count;
 466
 467         mutex_lock(&test_fw_mutex);
 468         tst = upload_lookup_name(buf);
 469         if (tst)
 470                 test_fw_config->upload_name = tst->name;
 471         else
 472                 ret = -EINVAL;
 473         mutex_unlock(&test_fw_mutex);
 474
 475         return ret;
 476 }
 477
 478 static ssize_t config_upload_name_show(struct device *dev,
 479                                        struct device_attribute *attr,
 480                                        char *buf)
 481 {
 482         return config_test_show_str(buf, test_fw_config->upload_name);
 483 }
 484 static DEVICE_ATTR_RW(config_upload_name);
 485
 486 static ssize_t config_num_requests_store(struct device *dev,
 487                                          struct device_attribute *attr,
 488                                          const char *buf, size_t count)
 489 {
 490         int rc;
 491
 492         mutex_lock(&test_fw_mutex);
 493         if (test_fw_config->reqs) {
 494                 pr_err("Must call release_all_firmware prior to changing config\n");
 495                 rc = -EINVAL;
 496                 mutex_unlock(&test_fw_mutex);
 497                 goto out;
 498         }
 499
 500         rc = __test_dev_config_update_u8(buf, count,
 501                                          &test_fw_config->num_requests);
 502         mutex_unlock(&test_fw_mutex);
 503
 504 out:
 505         return rc;
 506 }
 507
 508 static ssize_t config_num_requests_show(struct device *dev,
 509                                         struct device_attribute *attr,
 510                                         char *buf)
 511 {
 512         return test_dev_config_show_u8(buf, test_fw_config->num_requests);
 513 }
 514 static DEVICE_ATTR_RW(config_num_requests);
 515
 516 static ssize_t config_into_buf_store(struct device *dev,
 517                                      struct device_attribute *attr,
 518                                      const char *buf, size_t count)
 519 {
 520         return test_dev_config_update_bool(buf,
 521                                            count,
 522                                            &test_fw_config->into_buf);
 523 }
 524
 525 static ssize_t config_into_buf_show(struct device *dev,
 526                                     struct device_attribute *attr,
 527                                     char *buf)
 528 {
 529         return test_dev_config_show_bool(buf, test_fw_config->into_buf);
 530 }
 531 static DEVICE_ATTR_RW(config_into_buf);
 532
 533 static ssize_t config_buf_size_store(struct device *dev,
 534                                      struct device_attribute *attr,
 535                                      const char *buf, size_t count)
 536 {
 537         int rc;
 538
 539         mutex_lock(&test_fw_mutex);
 540         if (test_fw_config->reqs) {
 541                 pr_err("Must call release_all_firmware prior to changing config\n");
 542                 rc = -EINVAL;
 543                 mutex_unlock(&test_fw_mutex);
 544                 goto out;
 545         }
 546
 547         rc = __test_dev_config_update_size_t(buf, count,
 548                                              &test_fw_config->buf_size);
 549         mutex_unlock(&test_fw_mutex);
 550
 551 out:
 552         return rc;
 553 }
 554
 555 static ssize_t config_buf_size_show(struct device *dev,
 556                                     struct device_attribute *attr,
 557                                     char *buf)
 558 {
 559         return test_dev_config_show_size_t(buf, test_fw_config->buf_size);
 560 }
 561 static DEVICE_ATTR_RW(config_buf_size);
 562
 563 static ssize_t config_file_offset_store(struct device *dev,
 564                                         struct device_attribute *attr,
 565                                         const char *buf, size_t count)
 566 {
 567         int rc;
 568
 569         mutex_lock(&test_fw_mutex);
 570         if (test_fw_config->reqs) {
 571                 pr_err("Must call release_all_firmware prior to changing config\n");
 572                 rc = -EINVAL;
 573                 mutex_unlock(&test_fw_mutex);
 574                 goto out;
 575         }
 576
 577         rc = __test_dev_config_update_size_t(buf, count,
 578                                              &test_fw_config->file_offset);
 579         mutex_unlock(&test_fw_mutex);
 580
 581 out:
 582         return rc;
 583 }
 584
 585 static ssize_t config_file_offset_show(struct device *dev,
 586                                        struct device_attribute *attr,
 587                                        char *buf)
 588 {
 589         return test_dev_config_show_size_t(buf, test_fw_config->file_offset);
 590 }
 591 static DEVICE_ATTR_RW(config_file_offset);
 592
 593 static ssize_t config_partial_store(struct device *dev,
 594                                     struct device_attribute *attr,
 595                                     const char *buf, size_t count)
 596 {
 597         return test_dev_config_update_bool(buf,
 598                                            count,
 599                                            &test_fw_config->partial);
 600 }
 601
 602 static ssize_t config_partial_show(struct device *dev,
 603                                    struct device_attribute *attr,
 604                                    char *buf)
 605 {
 606         return test_dev_config_show_bool(buf, test_fw_config->partial);
 607 }
 608 static DEVICE_ATTR_RW(config_partial);
 609
 610 static ssize_t config_sync_direct_store(struct device *dev,
 611                                         struct device_attribute *attr,
 612                                         const char *buf, size_t count)
 613 {
 614         int rc = test_dev_config_update_bool(buf, count,
 615                                              &test_fw_config->sync_direct);
 616
 617         if (rc == count)
 618                 test_fw_config->req_firmware = test_fw_config->sync_direct ?
 619                                        request_firmware_direct :
 620                                        request_firmware;
 621         return rc;
 622 }
 623
 624 static ssize_t config_sync_direct_show(struct device *dev,
 625                                        struct device_attribute *attr,
 626                                        char *buf)
 627 {
 628         return test_dev_config_show_bool(buf, test_fw_config->sync_direct);
 629 }
 630 static DEVICE_ATTR_RW(config_sync_direct);
 631
 632 static ssize_t config_send_uevent_store(struct device *dev,
 633                                         struct device_attribute *attr,
 634                                         const char *buf, size_t count)
 635 {
 636         return test_dev_config_update_bool(buf, count,
 637                                            &test_fw_config->send_uevent);
 638 }
 639
 640 static ssize_t config_send_uevent_show(struct device *dev,
 641                                        struct device_attribute *attr,
 642                                        char *buf)
 643 {
 644         return test_dev_config_show_bool(buf, test_fw_config->send_uevent);
 645 }
 646 static DEVICE_ATTR_RW(config_send_uevent);
 647
 648 static ssize_t config_read_fw_idx_store(struct device *dev,
 649                                         struct device_attribute *attr,
 650                                         const char *buf, size_t count)
 651 {
 652         return test_dev_config_update_u8(buf, count,
 653                                          &test_fw_config->read_fw_idx);
 654 }
 655
 656 static ssize_t config_read_fw_idx_show(struct device *dev,
 657                                        struct device_attribute *attr,
 658                                        char *buf)
 659 {
 660         return test_dev_config_show_u8(buf, test_fw_config->read_fw_idx);
 661 }
 662 static DEVICE_ATTR_RW(config_read_fw_idx);
 663
 664
 665 static ssize_t trigger_request_store(struct device *dev,
 666                                      struct device_attribute *attr,
 667                                      const char *buf, size_t count)
 668 {
 669         int rc;
 670         char *name;
 671
 672         name = kstrndup(buf, count, GFP_KERNEL);
 673         if (!name)
 674                 return -ENOMEM;
 675
 676         pr_info("loading '%s'\n", name);
 677
 678         mutex_lock(&test_fw_mutex);
 679         release_firmware(test_firmware);
 680         if (test_fw_config->reqs)
 681                 __test_release_all_firmware();
 682         test_firmware = NULL;
 683         rc = request_firmware(&test_firmware, name, dev);
 684         if (rc) {
 685                 pr_info("load of '%s' failed: %d\n", name, rc);
 686                 goto out;
 687         }
 688         pr_info("loaded: %zu\n", test_firmware->size);
 689         rc = count;
 690
 691 out:
 692         mutex_unlock(&test_fw_mutex);
 693
 694         kfree(name);
 695
 696         return rc;
 697 }
 698 static DEVICE_ATTR_WO(trigger_request);
 699
 700 #ifdef CONFIG_EFI_EMBEDDED_FIRMWARE
 701 extern struct list_head efi_embedded_fw_list;
 702 extern bool efi_embedded_fw_checked;
 703
 704 static ssize_t trigger_request_platform_store(struct device *dev,
 705                                               struct device_attribute *attr,
 706                                               const char *buf, size_t count)
 707 {
 708         static const u8 test_data[] = {
 709                 0x55, 0xaa, 0x55, 0xaa, 0x01, 0x02, 0x03, 0x04,
 710                 0x55, 0xaa, 0x55, 0xaa, 0x05, 0x06, 0x07, 0x08,
 711                 0x55, 0xaa, 0x55, 0xaa, 0x10, 0x20, 0x30, 0x40,
 712                 0x55, 0xaa, 0x55, 0xaa, 0x50, 0x60, 0x70, 0x80
 713         };
 714         struct efi_embedded_fw efi_embedded_fw;
 715         const struct firmware *firmware = NULL;
 716         bool saved_efi_embedded_fw_checked;
 717         char *name;
 718         int rc;
 719
 720         name = kstrndup(buf, count, GFP_KERNEL);
 721         if (!name)
 722                 return -ENOMEM;
 723
 724         pr_info("inserting test platform fw '%s'\n", name);
 725         efi_embedded_fw.name = name;
 726         efi_embedded_fw.data = (void *)test_data;
 727         efi_embedded_fw.length = sizeof(test_data);
 728         list_add(&efi_embedded_fw.list, &efi_embedded_fw_list);
 729         saved_efi_embedded_fw_checked = efi_embedded_fw_checked;
 730         efi_embedded_fw_checked = true;
 731
 732         pr_info("loading '%s'\n", name);
 733         rc = firmware_request_platform(&firmware, name, dev);
 734         if (rc) {
 735                 pr_info("load of '%s' failed: %d\n", name, rc);
 736                 goto out;
 737         }
 738         if (firmware->size != sizeof(test_data) ||
 739             memcmp(firmware->data, test_data, sizeof(test_data)) != 0) {
 740                 pr_info("firmware contents mismatch for '%s'\n", name);
 741                 rc = -EINVAL;
 742                 goto out;
 743         }
 744         pr_info("loaded: %zu\n", firmware->size);
 745         rc = count;
 746
 747 out:
 748         efi_embedded_fw_checked = saved_efi_embedded_fw_checked;
 749         release_firmware(firmware);
 750         list_del(&efi_embedded_fw.list);
 751         kfree(name);
 752
 753         return rc;
 754 }
 755 static DEVICE_ATTR_WO(trigger_request_platform);
 756 #endif
 757
 758 static DECLARE_COMPLETION(async_fw_done);
 759
 760 static void trigger_async_request_cb(const struct firmware *fw, void *context)
 761 {
 762         test_firmware = fw;
 763         complete(&async_fw_done);
 764 }
 765
 766 static ssize_t trigger_async_request_store(struct device *dev,
 767                                            struct device_attribute *attr,
 768                                            const char *buf, size_t count)
 769 {
 770         int rc;
 771         char *name;
 772
 773         name = kstrndup(buf, count, GFP_KERNEL);
 774         if (!name)
 775                 return -ENOMEM;
 776
 777         pr_info("loading '%s'\n", name);
 778
 779         mutex_lock(&test_fw_mutex);
 780         release_firmware(test_firmware);
 781         test_firmware = NULL;
 782         if (test_fw_config->reqs)
 783                 __test_release_all_firmware();
 784         rc = request_firmware_nowait(THIS_MODULE, 1, name, dev, GFP_KERNEL,
 785                                      NULL, trigger_async_request_cb);
 786         if (rc) {
 787                 pr_info("async load of '%s' failed: %d\n", name, rc);
 788                 kfree(name);
 789                 goto out;
 790         }
 791         /* Free 'name' ASAP, to test for race conditions */
 792         kfree(name);
 793
 794         wait_for_completion(&async_fw_done);
 795
 796         if (test_firmware) {
 797                 pr_info("loaded: %zu\n", test_firmware->size);
 798                 rc = count;
 799         } else {
 800                 pr_err("failed to async load firmware\n");
 801                 rc = -ENOMEM;
 802         }
 803
 804 out:
 805         mutex_unlock(&test_fw_mutex);
 806
 807         return rc;
 808 }
 809 static DEVICE_ATTR_WO(trigger_async_request);
 810
 811 static ssize_t trigger_custom_fallback_store(struct device *dev,
 812                                              struct device_attribute *attr,
 813                                              const char *buf, size_t count)
 814 {
 815         int rc;
 816         char *name;
 817
 818         name = kstrndup(buf, count, GFP_KERNEL);
 819         if (!name)
 820                 return -ENOMEM;
 821
 822         pr_info("loading '%s' using custom fallback mechanism\n", name);
 823
 824         mutex_lock(&test_fw_mutex);
 825         release_firmware(test_firmware);
 826         if (test_fw_config->reqs)
 827                 __test_release_all_firmware();
 828         test_firmware = NULL;
 829         rc = request_firmware_nowait(THIS_MODULE, FW_ACTION_NOUEVENT, name,
 830                                      dev, GFP_KERNEL, NULL,
 831                                      trigger_async_request_cb);
 832         if (rc) {
 833                 pr_info("async load of '%s' failed: %d\n", name, rc);
 834                 kfree(name);
 835                 goto out;
 836         }
 837         /* Free 'name' ASAP, to test for race conditions */
 838         kfree(name);
 839
 840         wait_for_completion(&async_fw_done);
 841
 842         if (test_firmware) {
 843                 pr_info("loaded: %zu\n", test_firmware->size);
 844                 rc = count;
 845         } else {
 846                 pr_err("failed to async load firmware\n");
 847                 rc = -ENODEV;
 848         }
 849
 850 out:
 851         mutex_unlock(&test_fw_mutex);
 852
 853         return rc;
 854 }
 855 static DEVICE_ATTR_WO(trigger_custom_fallback);
 856
 857 static int test_fw_run_batch_request(void *data)
 858 {
 859         struct test_batched_req *req = data;
 860
 861         if (!req) {
 862                 test_fw_config->test_result = -EINVAL;
 863                 return -EINVAL;
 864         }
 865
 866         if (test_fw_config->into_buf) {
 867                 void *test_buf;
 868
 869                 test_buf = kzalloc(TEST_FIRMWARE_BUF_SIZE, GFP_KERNEL);
 870                 if (!test_buf)
 871                         return -ENOMEM;
 872
 873                 if (test_fw_config->partial)
 874                         req->rc = request_partial_firmware_into_buf
 875                                                 (&req->fw,
 876                                                  req->name,
 877                                                  req->dev,
 878                                                  test_buf,
 879                                                  test_fw_config->buf_size,
 880                                                  test_fw_config->file_offset);
 881                 else
 882                         req->rc = request_firmware_into_buf
 883                                                 (&req->fw,
 884                                                  req->name,
 885                                                  req->dev,
 886                                                  test_buf,
 887                                                  test_fw_config->buf_size);
 888                 if (!req->fw)
 889                         kfree(test_buf);
 890                 else
 891                         req->fw_buf = test_buf;
 892         } else {
 893                 req->rc = test_fw_config->req_firmware(&req->fw,
 894                                                        req->name,
 895                                                        req->dev);
 896         }
 897
 898         if (req->rc) {
 899                 pr_info("#%u: batched sync load failed: %d\n",
 900                         req->idx, req->rc);
 901                 if (!test_fw_config->test_result)
 902                         test_fw_config->test_result = req->rc;
 903         } else if (req->fw) {
 904                 req->sent = true;
 905                 pr_info("#%u: batched sync loaded %zu\n",
 906                         req->idx, req->fw->size);
 907         }
 908         complete(&req->completion);
 909
 910         req->task = NULL;
 911
 912         return 0;
 913 }
 914
 915 /*
 916  * We use a kthread as otherwise the kernel serializes all our sync requests
 917  * and we would not be able to mimic batched requests on a sync call. Batched
 918  * requests on a sync call can for instance happen on a device driver when
 919  * multiple cards are used and firmware loading happens outside of probe.
 920  */
 921 static ssize_t trigger_batched_requests_store(struct device *dev,
 922                                               struct device_attribute *attr,
 923                                               const char *buf, size_t count)
 924 {
 925         struct test_batched_req *req;
 926         int rc;
 927         u8 i;
 928
 929         mutex_lock(&test_fw_mutex);
 930
 931         if (test_fw_config->reqs) {
 932                 rc = -EBUSY;
 933                 goto out_bail;
 934         }
 935
 936         test_fw_config->reqs =
 937                 vzalloc(array3_size(sizeof(struct test_batched_req),
 938                                     test_fw_config->num_requests, 2));
 939         if (!test_fw_config->reqs) {
 940                 rc = -ENOMEM;
 941                 goto out_unlock;
 942         }
 943
 944         pr_info("batched sync firmware loading '%s' %u times\n",
 945                 test_fw_config->name, test_fw_config->num_requests);
 946
 947         for (i = 0; i < test_fw_config->num_requests; i++) {
 948                 req = &test_fw_config->reqs[i];
 949                 req->fw = NULL;
 950                 req->idx = i;
 951                 req->name = test_fw_config->name;
 952                 req->fw_buf = NULL;
 953                 req->dev = dev;
 954                 init_completion(&req->completion);
 955                 req->task = kthread_run(test_fw_run_batch_request, req,
 956                                              "%s-%u", KBUILD_MODNAME, req->idx);
 957                 if (!req->task || IS_ERR(req->task)) {
 958                         pr_err("Setting up thread %u failed\n", req->idx);
 959                         req->task = NULL;
 960                         rc = -ENOMEM;
 961                         goto out_bail;
 962                 }
 963         }
 964
 965         rc = count;
 966
 967         /*
 968          * We require an explicit release to enable more time and delay of
 969          * calling release_firmware() to improve our chances of forcing a
 970          * batched request. If we instead called release_firmware() right away
 971          * then we might miss on an opportunity of having a successful firmware
 972          * request pass on the opportunity to be come a batched request.
 973          */
 974
 975 out_bail:
 976         for (i = 0; i < test_fw_config->num_requests; i++) {
 977                 req = &test_fw_config->reqs[i];
 978                 if (req->task || req->sent)
 979                         wait_for_completion(&req->completion);
 980         }
 981
 982         /* Override any worker error if we had a general setup error */
 983         if (rc < 0)
 984                 test_fw_config->test_result = rc;
 985
 986 out_unlock:
 987         mutex_unlock(&test_fw_mutex);
 988
 989         return rc;
 990 }
 991 static DEVICE_ATTR_WO(trigger_batched_requests);
 992
 993 /*
 994  * We wait for each callback to return with the lock held, no need to lock here
 995  */
 996 static void trigger_batched_cb(const struct firmware *fw, void *context)
 997 {
 998         struct test_batched_req *req = context;
 999
1000         if (!req) {
1001                 test_fw_config->test_result = -EINVAL;
1002                 return;
1003         }
1004
1005         /* forces *some* batched requests to queue up */
1006         if (!req->idx)
1007                 ssleep(2);
1008
1009         req->fw = fw;
1010
1011         /*
1012          * Unfortunately the firmware API gives us nothing other than a null FW
1013          * if the firmware was not found on async requests.  Best we can do is
1014          * just assume -ENOENT. A better API would pass the actual return
1015          * value to the callback.
1016          */
1017         if (!fw && !test_fw_config->test_result)
1018                 test_fw_config->test_result = -ENOENT;
1019
1020         complete(&req->completion);
1021 }
1022
1023 static
1024 ssize_t trigger_batched_requests_async_store(struct device *dev,
1025                                              struct device_attribute *attr,
1026                                              const char *buf, size_t count)
1027 {
1028         struct test_batched_req *req;
1029         bool send_uevent;
1030         int rc;
1031         u8 i;
1032
1033         mutex_lock(&test_fw_mutex);
1034
1035         if (test_fw_config->reqs) {
1036                 rc = -EBUSY;
1037                 goto out_bail;
1038         }
1039
1040         test_fw_config->reqs =
1041                 vzalloc(array3_size(sizeof(struct test_batched_req),
1042                                     test_fw_config->num_requests, 2));
1043         if (!test_fw_config->reqs) {
1044                 rc = -ENOMEM;
1045                 goto out;
1046         }
1047
1048         pr_info("batched loading '%s' custom fallback mechanism %u times\n",
1049                 test_fw_config->name, test_fw_config->num_requests);
1050
1051         send_uevent = test_fw_config->send_uevent ? FW_ACTION_UEVENT :
1052                 FW_ACTION_NOUEVENT;
1053
1054         for (i = 0; i < test_fw_config->num_requests; i++) {
1055                 req = &test_fw_config->reqs[i];
1056                 req->name = test_fw_config->name;
1057                 req->fw_buf = NULL;
1058                 req->fw = NULL;
1059                 req->idx = i;
1060                 init_completion(&req->completion);
1061                 rc = request_firmware_nowait(THIS_MODULE, send_uevent,
1062                                              req->name,
1063                                              dev, GFP_KERNEL, req,
1064                                              trigger_batched_cb);
1065                 if (rc) {
1066                         pr_info("#%u: batched async load failed setup: %d\n",
1067                                 i, rc);
1068                         req->rc = rc;
1069                         goto out_bail;
1070                 } else
1071                         req->sent = true;
1072         }
1073
1074         rc = count;
1075
1076 out_bail:
1077
1078         /*
1079          * We require an explicit release to enable more time and delay of
1080          * calling release_firmware() to improve our chances of forcing a
1081          * batched request. If we instead called release_firmware() right away
1082          * then we might miss on an opportunity of having a successful firmware
1083          * request pass on the opportunity to be come a batched request.
1084          */
1085
1086         for (i = 0; i < test_fw_config->num_requests; i++) {
1087                 req = &test_fw_config->reqs[i];
1088                 if (req->sent)
1089                         wait_for_completion(&req->completion);
1090         }
1091
1092         /* Override any worker error if we had a general setup error */
1093         if (rc < 0)
1094                 test_fw_config->test_result = rc;
1095
1096 out:
1097         mutex_unlock(&test_fw_mutex);
1098
1099         return rc;
1100 }
1101 static DEVICE_ATTR_WO(trigger_batched_requests_async);
1102
1103 static void upload_release(struct test_firmware_upload *tst)
1104 {
1105         firmware_upload_unregister(tst->fwl);
1106         kfree(tst->buf);
1107         kfree(tst->name);
1108         kfree(tst);
1109 }
1110
1111 static void upload_release_all(void)
1112 {
1113         struct test_firmware_upload *tst, *tmp;
1114
1115         list_for_each_entry_safe(tst, tmp, &test_upload_list, node) {
1116                 list_del(&tst->node);
1117                 upload_release(tst);
1118         }
1119         test_fw_config->upload_name = NULL;
1120 }
1121
1122 /*
1123  * This table is replicated from .../firmware_loader/sysfs_upload.c
1124  * and needs to be kept in sync.
1125  */
1126 static const char * const fw_upload_err_str[] = {
1127         [FW_UPLOAD_ERR_NONE]         = "none",
1128         [FW_UPLOAD_ERR_HW_ERROR]     = "hw-error",
1129         [FW_UPLOAD_ERR_TIMEOUT]      = "timeout",
1130         [FW_UPLOAD_ERR_CANCELED]     = "user-abort",
1131         [FW_UPLOAD_ERR_BUSY]         = "device-busy",
1132         [FW_UPLOAD_ERR_INVALID_SIZE] = "invalid-file-size",
1133         [FW_UPLOAD_ERR_RW_ERROR]     = "read-write-error",
1134         [FW_UPLOAD_ERR_WEAROUT]      = "flash-wearout",
1135 };
1136
1137 static void upload_err_inject_error(struct test_firmware_upload *tst,
1138                                     const u8 *p, const char *prog)
1139 {
1140         enum fw_upload_err err;
1141
1142         for (err = FW_UPLOAD_ERR_NONE + 1; err < FW_UPLOAD_ERR_MAX; err++) {
1143                 if (strncmp(p, fw_upload_err_str[err],
1144                             strlen(fw_upload_err_str[err])) == 0) {
1145                         tst->inject.prog = prog;
1146                         tst->inject.err_code = err;
1147                         return;
1148                 }
1149         }
1150 }
1151
1152 static void upload_err_inject_prog(struct test_firmware_upload *tst,
1153                                    const u8 *p)
1154 {
1155         static const char * const progs[] = {
1156                 "preparing:", "transferring:", "programming:"
1157         };
1158         int i;
1159
1160         for (i = 0; i < ARRAY_SIZE(progs); i++) {
1161                 if (strncmp(p, progs[i], strlen(progs[i])) == 0) {
1162                         upload_err_inject_error(tst, p + strlen(progs[i]),
1163                                                 progs[i]);
1164                         return;
1165                 }
1166         }
1167 }
1168
1169 #define FIVE_MINUTES_MS (5 * 60 * 1000)
1170 static enum fw_upload_err
1171 fw_upload_wait_on_cancel(struct test_firmware_upload *tst)
1172 {
1173         int ms_delay;
1174
1175         for (ms_delay = 0; ms_delay < FIVE_MINUTES_MS; ms_delay += 100) {
1176                 msleep(100);
1177                 if (tst->cancel_request)
1178                         return FW_UPLOAD_ERR_CANCELED;
1179         }
1180         return FW_UPLOAD_ERR_NONE;
1181 }
1182
1183 static enum fw_upload_err test_fw_upload_prepare(struct fw_upload *fwl,
1184                                                  const u8 *data, u32 size)
1185 {
1186         struct test_firmware_upload *tst = fwl->dd_handle;
1187         enum fw_upload_err ret = FW_UPLOAD_ERR_NONE;
1188         const char *progress = "preparing:";
1189
1190         tst->cancel_request = false;
1191
1192         if (!size || size > TEST_UPLOAD_MAX_SIZE) {
1193                 ret = FW_UPLOAD_ERR_INVALID_SIZE;
1194                 goto err_out;
1195         }
1196
1197         if (strncmp(data, "inject:", strlen("inject:")) == 0)
1198                 upload_err_inject_prog(tst, data + strlen("inject:"));
1199
1200         memset(tst->buf, 0, TEST_UPLOAD_MAX_SIZE);
1201         tst->size = size;
1202
1203         if (tst->inject.err_code == FW_UPLOAD_ERR_NONE ||
1204             strncmp(tst->inject.prog, progress, strlen(progress)) != 0)
1205                 return FW_UPLOAD_ERR_NONE;
1206
1207         if (tst->inject.err_code == FW_UPLOAD_ERR_CANCELED)
1208                 ret = fw_upload_wait_on_cancel(tst);
1209         else
1210                 ret = tst->inject.err_code;
1211
1212 err_out:
1213         /*
1214          * The cleanup op only executes if the prepare op succeeds.
1215          * If the prepare op fails, it must do it's own clean-up.
1216          */
1217         tst->inject.err_code = FW_UPLOAD_ERR_NONE;
1218         tst->inject.prog = NULL;
1219
1220         return ret;
1221 }
1222
1223 static enum fw_upload_err test_fw_upload_write(struct fw_upload *fwl,
1224                                                const u8 *data, u32 offset,
1225                                                u32 size, u32 *written)
1226 {
1227         struct test_firmware_upload *tst = fwl->dd_handle;
1228         const char *progress = "transferring:";
1229         u32 blk_size;
1230
1231         if (tst->cancel_request)
1232                 return FW_UPLOAD_ERR_CANCELED;
1233
1234         blk_size = min_t(u32, TEST_UPLOAD_BLK_SIZE, size);
1235         memcpy(tst->buf + offset, data + offset, blk_size);
1236
1237         *written = blk_size;
1238
1239         if (tst->inject.err_code == FW_UPLOAD_ERR_NONE ||
1240             strncmp(tst->inject.prog, progress, strlen(progress)) != 0)
1241                 return FW_UPLOAD_ERR_NONE;
1242
1243         if (tst->inject.err_code == FW_UPLOAD_ERR_CANCELED)
1244                 return fw_upload_wait_on_cancel(tst);
1245
1246         return tst->inject.err_code;
1247 }
1248
1249 static enum fw_upload_err test_fw_upload_complete(struct fw_upload *fwl)
1250 {
1251         struct test_firmware_upload *tst = fwl->dd_handle;
1252         const char *progress = "programming:";
1253
1254         if (tst->cancel_request)
1255                 return FW_UPLOAD_ERR_CANCELED;
1256
1257         if (tst->inject.err_code == FW_UPLOAD_ERR_NONE ||
1258             strncmp(tst->inject.prog, progress, strlen(progress)) != 0)
1259                 return FW_UPLOAD_ERR_NONE;
1260
1261         if (tst->inject.err_code == FW_UPLOAD_ERR_CANCELED)
1262                 return fw_upload_wait_on_cancel(tst);
1263
1264         return tst->inject.err_code;
1265 }
1266
1267 static void test_fw_upload_cancel(struct fw_upload *fwl)
1268 {
1269         struct test_firmware_upload *tst = fwl->dd_handle;
1270
1271         tst->cancel_request = true;
1272 }
1273
1274 static void test_fw_cleanup(struct fw_upload *fwl)
1275 {
1276         struct test_firmware_upload *tst = fwl->dd_handle;
1277
1278         tst->inject.err_code = FW_UPLOAD_ERR_NONE;
1279         tst->inject.prog = NULL;
1280 }
1281
1282 static const struct fw_upload_ops upload_test_ops = {
1283         .prepare = test_fw_upload_prepare,
1284         .write = test_fw_upload_write,
1285         .poll_complete = test_fw_upload_complete,
1286         .cancel = test_fw_upload_cancel,
1287         .cleanup = test_fw_cleanup
1288 };
1289
1290 static ssize_t upload_register_store(struct device *dev,
1291                                      struct device_attribute *attr,
1292                                      const char *buf, size_t count)
1293 {
1294         struct test_firmware_upload *tst;
1295         struct fw_upload *fwl;
1296         char *name;
1297         int ret;
1298
1299         name = kstrndup(buf, count, GFP_KERNEL);
1300         if (!name)
1301                 return -ENOMEM;
1302
1303         mutex_lock(&test_fw_mutex);
1304         tst = upload_lookup_name(name);
1305         if (tst) {
1306                 ret = -EEXIST;
1307                 goto free_name;
1308         }
1309
1310         tst = kzalloc(sizeof(*tst), GFP_KERNEL);
1311         if (!tst) {
1312                 ret = -ENOMEM;
1313                 goto free_name;
1314         }
1315
1316         tst->name = name;
1317         tst->buf = kzalloc(TEST_UPLOAD_MAX_SIZE, GFP_KERNEL);
1318         if (!tst->buf) {
1319                 ret = -ENOMEM;
1320                 goto free_tst;
1321         }
1322
1323         fwl = firmware_upload_register(THIS_MODULE, dev, tst->name,
1324                                        &upload_test_ops, tst);
1325         if (IS_ERR(fwl)) {
1326                 ret = PTR_ERR(fwl);
1327                 goto free_buf;
1328         }
1329
1330         tst->fwl = fwl;
1331         list_add_tail(&tst->node, &test_upload_list);
1332         mutex_unlock(&test_fw_mutex);
1333         return count;
1334
1335 free_buf:
1336         kfree(tst->buf);
1337
1338 free_tst:
1339         kfree(tst);
1340
1341 free_name:
1342         mutex_unlock(&test_fw_mutex);
1343         kfree(name);
1344
1345         return ret;
1346 }
1347 static DEVICE_ATTR_WO(upload_register);
1348
1349 static ssize_t upload_unregister_store(struct device *dev,
1350                                        struct device_attribute *attr,
1351                                        const char *buf, size_t count)
1352 {
1353         struct test_firmware_upload *tst;
1354         int ret = count;
1355
1356         mutex_lock(&test_fw_mutex);
1357         tst = upload_lookup_name(buf);
1358         if (!tst) {
1359                 ret = -EINVAL;
1360                 goto out;
1361         }
1362
1363         if (test_fw_config->upload_name == tst->name)
1364                 test_fw_config->upload_name = NULL;
1365
1366         list_del(&tst->node);
1367         upload_release(tst);
1368
1369 out:
1370         mutex_unlock(&test_fw_mutex);
1371         return ret;
1372 }
1373 static DEVICE_ATTR_WO(upload_unregister);
1374
1375 static ssize_t test_result_show(struct device *dev,
1376                                 struct device_attribute *attr,
1377                                 char *buf)
1378 {
1379         return test_dev_config_show_int(buf, test_fw_config->test_result);
1380 }
1381 static DEVICE_ATTR_RO(test_result);
1382
1383 static ssize_t release_all_firmware_store(struct device *dev,
1384                                           struct device_attribute *attr,
1385                                           const char *buf, size_t count)
1386 {
1387         test_release_all_firmware();
1388         return count;
1389 }
1390 static DEVICE_ATTR_WO(release_all_firmware);
1391
1392 static ssize_t read_firmware_show(struct device *dev,
1393                                   struct device_attribute *attr,
1394                                   char *buf)
1395 {
1396         struct test_batched_req *req;
1397         u8 idx;
1398         ssize_t rc = 0;
1399
1400         mutex_lock(&test_fw_mutex);
1401
1402         idx = test_fw_config->read_fw_idx;
1403         if (idx >= test_fw_config->num_requests) {
1404                 rc = -ERANGE;
1405                 goto out;
1406         }
1407
1408         if (!test_fw_config->reqs) {
1409                 rc = -EINVAL;
1410                 goto out;
1411         }
1412
1413         req = &test_fw_config->reqs[idx];
1414         if (!req->fw) {
1415                 pr_err("#%u: failed to async load firmware\n", idx);
1416                 rc = -ENOENT;
1417                 goto out;
1418         }
1419
1420         pr_info("#%u: loaded %zu\n", idx, req->fw->size);
1421
1422         if (req->fw->size > PAGE_SIZE) {
1423                 pr_err("Testing interface must use PAGE_SIZE firmware for now\n");
1424                 rc = -EINVAL;
1425                 goto out;
1426         }
1427         memcpy(buf, req->fw->data, req->fw->size);
1428
1429         rc = req->fw->size;
1430 out:
1431         mutex_unlock(&test_fw_mutex);
1432
1433         return rc;
1434 }
1435 static DEVICE_ATTR_RO(read_firmware);
1436
1437 static ssize_t upload_read_show(struct device *dev,
1438                                 struct device_attribute *attr,
1439                                 char *buf)
1440 {
1441         struct test_firmware_upload *tst = NULL;
1442         struct test_firmware_upload *tst_iter;
1443         int ret = -EINVAL;
1444
1445         if (!test_fw_config->upload_name) {
1446                 pr_err("Set config_upload_name before using upload_read\n");
1447                 return -EINVAL;
1448         }
1449
1450         mutex_lock(&test_fw_mutex);
1451         list_for_each_entry(tst_iter, &test_upload_list, node)
1452                 if (tst_iter->name == test_fw_config->upload_name) {
1453                         tst = tst_iter;
1454                         break;
1455                 }
1456
1457         if (!tst) {
1458                 pr_err("Firmware name not found: %s\n",
1459                        test_fw_config->upload_name);
1460                 goto out;
1461         }
1462
1463         if (tst->size > PAGE_SIZE) {
1464                 pr_err("Testing interface must use PAGE_SIZE firmware for now\n");
1465                 goto out;
1466         }
1467
1468         memcpy(buf, tst->buf, tst->size);
1469         ret = tst->size;
1470 out:
1471         mutex_unlock(&test_fw_mutex);
1472         return ret;
1473 }
1474 static DEVICE_ATTR_RO(upload_read);
1475
1476 #define TEST_FW_DEV_ATTR(name)          &dev_attr_##name.attr
1477
1478 static struct attribute *test_dev_attrs[] = {
1479         TEST_FW_DEV_ATTR(reset),
1480
1481         TEST_FW_DEV_ATTR(config),
1482         TEST_FW_DEV_ATTR(config_name),
1483         TEST_FW_DEV_ATTR(config_num_requests),
1484         TEST_FW_DEV_ATTR(config_into_buf),
1485         TEST_FW_DEV_ATTR(config_buf_size),
1486         TEST_FW_DEV_ATTR(config_file_offset),
1487         TEST_FW_DEV_ATTR(config_partial),
1488         TEST_FW_DEV_ATTR(config_sync_direct),
1489         TEST_FW_DEV_ATTR(config_send_uevent),
1490         TEST_FW_DEV_ATTR(config_read_fw_idx),
1491         TEST_FW_DEV_ATTR(config_upload_name),
1492
1493         /* These don't use the config at all - they could be ported! */
1494         TEST_FW_DEV_ATTR(trigger_request),
1495         TEST_FW_DEV_ATTR(trigger_async_request),
1496         TEST_FW_DEV_ATTR(trigger_custom_fallback),
1497 #ifdef CONFIG_EFI_EMBEDDED_FIRMWARE
1498         TEST_FW_DEV_ATTR(trigger_request_platform),
1499 #endif
1500
1501         /* These use the config and can use the test_result */
1502         TEST_FW_DEV_ATTR(trigger_batched_requests),
1503         TEST_FW_DEV_ATTR(trigger_batched_requests_async),
1504
1505         TEST_FW_DEV_ATTR(release_all_firmware),
1506         TEST_FW_DEV_ATTR(test_result),
1507         TEST_FW_DEV_ATTR(read_firmware),
1508         TEST_FW_DEV_ATTR(upload_read),
1509         TEST_FW_DEV_ATTR(upload_register),
1510         TEST_FW_DEV_ATTR(upload_unregister),
1511         NULL,
1512 };
1513
1514 ATTRIBUTE_GROUPS(test_dev);
1515
1516 static struct miscdevice test_fw_misc_device = {
1517         .minor          = MISC_DYNAMIC_MINOR,
1518         .name           = "test_firmware",
1519         .fops           = &test_fw_fops,
1520         .groups         = test_dev_groups,
1521 };
1522
1523 static int __init test_firmware_init(void)
1524 {
1525         int rc;
1526
1527         test_fw_config = kzalloc(sizeof(struct test_config), GFP_KERNEL);
1528         if (!test_fw_config)
1529                 return -ENOMEM;
1530
1531         rc = __test_firmware_config_init();
1532         if (rc) {
1533                 kfree(test_fw_config);
1534                 pr_err("could not init firmware test config: %d\n", rc);
1535                 return rc;
1536         }
1537
1538         rc = misc_register(&test_fw_misc_device);
1539         if (rc) {
1540                 __test_firmware_config_free();
1541                 kfree(test_fw_config);
1542                 pr_err("could not register misc device: %d\n", rc);
1543                 return rc;
1544         }
1545
1546         pr_warn("interface ready\n");
1547
1548         return 0;
1549 }
1550
1551 module_init(test_firmware_init);
1552
1553 static void __exit test_firmware_exit(void)
1554 {
1555         mutex_lock(&test_fw_mutex);
1556         release_firmware(test_firmware);
1557         misc_deregister(&test_fw_misc_device);
1558         upload_release_all();
1559         __test_firmware_config_free();
1560         kfree(test_fw_config);
1561         mutex_unlock(&test_fw_mutex);
1562
1563         pr_warn("removed interface\n");
1564 }
1565
1566 module_exit(test_firmware_exit);
1567
1568 MODULE_AUTHOR("Kees Cook <keescook@chromium.org>");
1569 MODULE_LICENSE("GPL");