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