arch/powerpc/platforms/powernv/opal-flash.c

   1 /*
   2  * PowerNV OPAL Firmware Update Interface
   3  *
   4  * Copyright 2013 IBM Corp.
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version
   9  * 2 of the License, or (at your option) any later version.
  10  */
  11
  12 #define DEBUG
  13
  14 #include <linux/kernel.h>
  15 #include <linux/reboot.h>
  16 #include <linux/init.h>
  17 #include <linux/kobject.h>
  18 #include <linux/sysfs.h>
  19 #include <linux/slab.h>
  20 #include <linux/mm.h>
  21 #include <linux/vmalloc.h>
  22 #include <linux/pagemap.h>
  23 #include <linux/delay.h>
  24
  25 #include <asm/opal.h>
  26
  27 /* FLASH status codes */
  28 #define FLASH_NO_OP             -1099   /* No operation initiated by user */
  29 #define FLASH_NO_AUTH           -9002   /* Not a service authority partition */
  30
  31 /* Validate image status values */
  32 #define VALIDATE_IMG_READY      -1001   /* Image ready for validation */
  33 #define VALIDATE_IMG_INCOMPLETE -1002   /* User copied < VALIDATE_BUF_SIZE */
  34
  35 /* Manage image status values */
  36 #define MANAGE_ACTIVE_ERR       -9001   /* Cannot overwrite active img */
  37
  38 /* Flash image status values */
  39 #define FLASH_IMG_READY         0       /* Img ready for flash on reboot */
  40 #define FLASH_INVALID_IMG       -1003   /* Flash image shorter than expected */
  41 #define FLASH_IMG_NULL_DATA     -1004   /* Bad data in sg list entry */
  42 #define FLASH_IMG_BAD_LEN       -1005   /* Bad length in sg list entry */
  43
  44 /* Manage operation tokens */
  45 #define FLASH_REJECT_TMP_SIDE   0       /* Reject temporary fw image */
  46 #define FLASH_COMMIT_TMP_SIDE   1       /* Commit temporary fw image */
  47
  48 /* Update tokens */
  49 #define FLASH_UPDATE_CANCEL     0       /* Cancel update request */
  50 #define FLASH_UPDATE_INIT       1       /* Initiate update */
  51
  52 /* Validate image update result tokens */
  53 #define VALIDATE_TMP_UPDATE     0     /* T side will be updated */
  54 #define VALIDATE_FLASH_AUTH     1     /* Partition does not have authority */
  55 #define VALIDATE_INVALID_IMG    2     /* Candidate image is not valid */
  56 #define VALIDATE_CUR_UNKNOWN    3     /* Current fixpack level is unknown */
  57 /*
  58  * Current T side will be committed to P side before being replace with new
  59  * image, and the new image is downlevel from current image
  60  */
  61 #define VALIDATE_TMP_COMMIT_DL  4
  62 /*
  63  * Current T side will be committed to P side before being replaced with new
  64  * image
  65  */
  66 #define VALIDATE_TMP_COMMIT     5
  67 /*
  68  * T side will be updated with a downlevel image
  69  */
  70 #define VALIDATE_TMP_UPDATE_DL  6
  71 /*
  72  * The candidate image's release date is later than the system's firmware
  73  * service entitlement date - service warranty period has expired
  74  */
  75 #define VALIDATE_OUT_OF_WRNTY   7
  76
  77 /* Validate buffer size */
  78 #define VALIDATE_BUF_SIZE       4096
  79
  80 /* XXX: Assume candidate image size is <= 1GB */
  81 #define MAX_IMAGE_SIZE  0x40000000
  82
  83 /* Image status */
  84 enum {
  85         IMAGE_INVALID,
  86         IMAGE_LOADING,
  87         IMAGE_READY,
  88 };
  89
  90 /* Candidate image data */
  91 struct image_data_t {
  92         int             status;
  93         void            *data;
  94         uint32_t        size;
  95 };
  96
  97 /* Candidate image header */
  98 struct image_header_t {
  99         uint16_t        magic;
 100         uint16_t        version;
 101         uint32_t        size;
 102 };
 103
 104 struct validate_flash_t {
 105         int             status;         /* Return status */
 106         void            *buf;           /* Candidate image buffer */
 107         uint32_t        buf_size;       /* Image size */
 108         uint32_t        result;         /* Update results token */
 109 };
 110
 111 struct manage_flash_t {
 112         int status;             /* Return status */
 113 };
 114
 115 struct update_flash_t {
 116         int status;             /* Return status */
 117 };
 118
 119 static struct image_header_t    image_header;
 120 static struct image_data_t      image_data;
 121 static struct validate_flash_t  validate_flash_data;
 122 static struct manage_flash_t    manage_flash_data;
 123
 124 /* Initialize update_flash_data status to No Operation */
 125 static struct update_flash_t    update_flash_data = {
 126         .status = FLASH_NO_OP,
 127 };
 128
 129 static DEFINE_MUTEX(image_data_mutex);
 130
 131 /*
 132  * Validate candidate image
 133  */
 134 static inline void opal_flash_validate(void)
 135 {
 136         long ret;
 137         void *buf = validate_flash_data.buf;
 138         __be32 size = cpu_to_be32(validate_flash_data.buf_size);
 139         __be32 result;
 140
 141         ret = opal_validate_flash(__pa(buf), &size, &result);
 142
 143         validate_flash_data.status = ret;
 144         validate_flash_data.buf_size = be32_to_cpu(size);
 145         validate_flash_data.result = be32_to_cpu(result);
 146 }
 147
 148 /*
 149  * Validate output format:
 150  *     validate result token
 151  *     current image version details
 152  *     new image version details
 153  */
 154 static ssize_t validate_show(struct kobject *kobj,
 155                              struct kobj_attribute *attr, char *buf)
 156 {
 157         struct validate_flash_t *args_buf = &validate_flash_data;
 158         int len;
 159
 160         /* Candidate image is not validated */
 161         if (args_buf->status < VALIDATE_TMP_UPDATE) {
 162                 len = sprintf(buf, "%d\n", args_buf->status);
 163                 goto out;
 164         }
 165
 166         /* Result token */
 167         len = sprintf(buf, "%d\n", args_buf->result);
 168
 169         /* Current and candidate image version details */
 170         if ((args_buf->result != VALIDATE_TMP_UPDATE) &&
 171             (args_buf->result < VALIDATE_CUR_UNKNOWN))
 172                 goto out;
 173
 174         if (args_buf->buf_size > (VALIDATE_BUF_SIZE - len)) {
 175                 memcpy(buf + len, args_buf->buf, VALIDATE_BUF_SIZE - len);
 176                 len = VALIDATE_BUF_SIZE;
 177         } else {
 178                 memcpy(buf + len, args_buf->buf, args_buf->buf_size);
 179                 len += args_buf->buf_size;
 180         }
 181 out:
 182         /* Set status to default */
 183         args_buf->status = FLASH_NO_OP;
 184         return len;
 185 }
 186
 187 /*
 188  * Validate candidate firmware image
 189  *
 190  * Note:
 191  *   We are only interested in first 4K bytes of the
 192  *   candidate image.
 193  */
 194 static ssize_t validate_store(struct kobject *kobj,
 195                               struct kobj_attribute *attr,
 196                               const char *buf, size_t count)
 197 {
 198         struct validate_flash_t *args_buf = &validate_flash_data;
 199
 200         if (buf[0] != '1')
 201                 return -EINVAL;
 202
 203         mutex_lock(&image_data_mutex);
 204
 205         if (image_data.status != IMAGE_READY ||
 206             image_data.size < VALIDATE_BUF_SIZE) {
 207                 args_buf->result = VALIDATE_INVALID_IMG;
 208                 args_buf->status = VALIDATE_IMG_INCOMPLETE;
 209                 goto out;
 210         }
 211
 212         /* Copy first 4k bytes of candidate image */
 213         memcpy(args_buf->buf, image_data.data, VALIDATE_BUF_SIZE);
 214
 215         args_buf->status = VALIDATE_IMG_READY;
 216         args_buf->buf_size = VALIDATE_BUF_SIZE;
 217
 218         /* Validate candidate image */
 219         opal_flash_validate();
 220
 221 out:
 222         mutex_unlock(&image_data_mutex);
 223         return count;
 224 }
 225
 226 /*
 227  * Manage flash routine
 228  */
 229 static inline void opal_flash_manage(uint8_t op)
 230 {
 231         struct manage_flash_t *const args_buf = &manage_flash_data;
 232
 233         args_buf->status = opal_manage_flash(op);
 234 }
 235
 236 /*
 237  * Show manage flash status
 238  */
 239 static ssize_t manage_show(struct kobject *kobj,
 240                            struct kobj_attribute *attr, char *buf)
 241 {
 242         struct manage_flash_t *const args_buf = &manage_flash_data;
 243         int rc;
 244
 245         rc = sprintf(buf, "%d\n", args_buf->status);
 246         /* Set status to default*/
 247         args_buf->status = FLASH_NO_OP;
 248         return rc;
 249 }
 250
 251 /*
 252  * Manage operations:
 253  *   0 - Reject
 254  *   1 - Commit
 255  */
 256 static ssize_t manage_store(struct kobject *kobj,
 257                             struct kobj_attribute *attr,
 258                             const char *buf, size_t count)
 259 {
 260         uint8_t op;
 261         switch (buf[0]) {
 262         case '0':
 263                 op = FLASH_REJECT_TMP_SIDE;
 264                 break;
 265         case '1':
 266                 op = FLASH_COMMIT_TMP_SIDE;
 267                 break;
 268         default:
 269                 return -EINVAL;
 270         }
 271
 272         /* commit/reject temporary image */
 273         opal_flash_manage(op);
 274         return count;
 275 }
 276
 277 /*
 278  * OPAL update flash
 279  */
 280 static int opal_flash_update(int op)
 281 {
 282         struct opal_sg_list *list;
 283         unsigned long addr;
 284         int64_t rc = OPAL_PARAMETER;
 285
 286         if (op == FLASH_UPDATE_CANCEL) {
 287                 pr_alert("FLASH: Image update cancelled\n");
 288                 addr = '\0';
 289                 goto flash;
 290         }
 291
 292         list = opal_vmalloc_to_sg_list(image_data.data, image_data.size);
 293         if (!list)
 294                 goto invalid_img;
 295
 296         /* First entry address */
 297         addr = __pa(list);
 298
 299 flash:
 300         rc = opal_update_flash(addr);
 301
 302 invalid_img:
 303         return rc;
 304 }
 305
 306 /* Return CPUs to OPAL before starting FW update */
 307 static void flash_return_cpu(void *info)
 308 {
 309         int cpu = smp_processor_id();
 310
 311         if (!cpu_online(cpu))
 312                 return;
 313
 314         /* Disable IRQ */
 315         hard_irq_disable();
 316
 317         /* Return the CPU to OPAL */
 318         opal_return_cpu();
 319 }
 320
 321 /* This gets called just before system reboots */
 322 void opal_flash_term_callback(void)
 323 {
 324         struct cpumask mask;
 325
 326         if (update_flash_data.status != FLASH_IMG_READY)
 327                 return;
 328
 329         pr_alert("FLASH: Flashing new firmware\n");
 330         pr_alert("FLASH: Image is %u bytes\n", image_data.size);
 331         pr_alert("FLASH: Performing flash and reboot/shutdown\n");
 332         pr_alert("FLASH: This will take several minutes. Do not power off!\n");
 333
 334         /* Small delay to help getting the above message out */
 335         msleep(500);
 336
 337         /* Return secondary CPUs to firmware */
 338         cpumask_copy(&mask, cpu_online_mask);
 339         cpumask_clear_cpu(smp_processor_id(), &mask);
 340         if (!cpumask_empty(&mask))
 341                 smp_call_function_many(&mask,
 342                                        flash_return_cpu, NULL, false);
 343         /* Hard disable interrupts */
 344         hard_irq_disable();
 345 }
 346
 347 /*
 348  * Show candidate image status
 349  */
 350 static ssize_t update_show(struct kobject *kobj,
 351                            struct kobj_attribute *attr, char *buf)
 352 {
 353         struct update_flash_t *const args_buf = &update_flash_data;
 354         return sprintf(buf, "%d\n", args_buf->status);
 355 }
 356
 357 /*
 358  * Set update image flag
 359  *  1 - Flash new image
 360  *  0 - Cancel flash request
 361  */
 362 static ssize_t update_store(struct kobject *kobj,
 363                             struct kobj_attribute *attr,
 364                             const char *buf, size_t count)
 365 {
 366         struct update_flash_t *const args_buf = &update_flash_data;
 367         int rc = count;
 368
 369         mutex_lock(&image_data_mutex);
 370
 371         switch (buf[0]) {
 372         case '0':
 373                 if (args_buf->status == FLASH_IMG_READY)
 374                         opal_flash_update(FLASH_UPDATE_CANCEL);
 375                 args_buf->status = FLASH_NO_OP;
 376                 break;
 377         case '1':
 378                 /* Image is loaded? */
 379                 if (image_data.status == IMAGE_READY)
 380                         args_buf->status =
 381                                 opal_flash_update(FLASH_UPDATE_INIT);
 382                 else
 383                         args_buf->status = FLASH_INVALID_IMG;
 384                 break;
 385         default:
 386                 rc = -EINVAL;
 387         }
 388
 389         mutex_unlock(&image_data_mutex);
 390         return rc;
 391 }
 392
 393 /*
 394  * Free image buffer
 395  */
 396 static void free_image_buf(void)
 397 {
 398         void *addr;
 399         int size;
 400
 401         addr = image_data.data;
 402         size = PAGE_ALIGN(image_data.size);
 403         while (size > 0) {
 404                 ClearPageReserved(vmalloc_to_page(addr));
 405                 addr += PAGE_SIZE;
 406                 size -= PAGE_SIZE;
 407         }
 408         vfree(image_data.data);
 409         image_data.data = NULL;
 410         image_data.status = IMAGE_INVALID;
 411 }
 412
 413 /*
 414  * Allocate image buffer.
 415  */
 416 static int alloc_image_buf(char *buffer, size_t count)
 417 {
 418         void *addr;
 419         int size;
 420
 421         if (count < sizeof(struct image_header_t)) {
 422                 pr_warn("FLASH: Invalid candidate image\n");
 423                 return -EINVAL;
 424         }
 425
 426         memcpy(&image_header, (void *)buffer, sizeof(struct image_header_t));
 427         image_data.size = be32_to_cpu(image_header.size);
 428         pr_debug("FLASH: Candidate image size = %u\n", image_data.size);
 429
 430         if (image_data.size > MAX_IMAGE_SIZE) {
 431                 pr_warn("FLASH: Too large image\n");
 432                 return -EINVAL;
 433         }
 434         if (image_data.size < VALIDATE_BUF_SIZE) {
 435                 pr_warn("FLASH: Image is shorter than expected\n");
 436                 return -EINVAL;
 437         }
 438
 439         image_data.data = vzalloc(PAGE_ALIGN(image_data.size));
 440         if (!image_data.data) {
 441                 pr_err("%s : Failed to allocate memory\n", __func__);
 442                 return -ENOMEM;
 443         }
 444
 445         /* Pin memory */
 446         addr = image_data.data;
 447         size = PAGE_ALIGN(image_data.size);
 448         while (size > 0) {
 449                 SetPageReserved(vmalloc_to_page(addr));
 450                 addr += PAGE_SIZE;
 451                 size -= PAGE_SIZE;
 452         }
 453
 454         image_data.status = IMAGE_LOADING;
 455         return 0;
 456 }
 457
 458 /*
 459  * Copy candidate image
 460  *
 461  * Parse candidate image header to get total image size
 462  * and pre-allocate required memory.
 463  */
 464 static ssize_t image_data_write(struct file *filp, struct kobject *kobj,
 465                                 struct bin_attribute *bin_attr,
 466                                 char *buffer, loff_t pos, size_t count)
 467 {
 468         int rc;
 469
 470         mutex_lock(&image_data_mutex);
 471
 472         /* New image ? */
 473         if (pos == 0) {
 474                 /* Free memory, if already allocated */
 475                 if (image_data.data)
 476                         free_image_buf();
 477
 478                 /* Cancel outstanding image update request */
 479                 if (update_flash_data.status == FLASH_IMG_READY)
 480                         opal_flash_update(FLASH_UPDATE_CANCEL);
 481
 482                 /* Allocate memory */
 483                 rc = alloc_image_buf(buffer, count);
 484                 if (rc)
 485                         goto out;
 486         }
 487
 488         if (image_data.status != IMAGE_LOADING) {
 489                 rc = -ENOMEM;
 490                 goto out;
 491         }
 492
 493         if ((pos + count) > image_data.size) {
 494                 rc = -EINVAL;
 495                 goto out;
 496         }
 497
 498         memcpy(image_data.data + pos, (void *)buffer, count);
 499         rc = count;
 500
 501         /* Set image status */
 502         if ((pos + count) == image_data.size) {
 503                 pr_debug("FLASH: Candidate image loaded....\n");
 504                 image_data.status = IMAGE_READY;
 505         }
 506
 507 out:
 508         mutex_unlock(&image_data_mutex);
 509         return rc;
 510 }
 511
 512 /*
 513  * sysfs interface :
 514  *  OPAL uses below sysfs files for code update.
 515  *  We create these files under /sys/firmware/opal.
 516  *
 517  *   image              : Interface to load candidate firmware image
 518  *   validate_flash     : Validate firmware image
 519  *   manage_flash       : Commit/Reject firmware image
 520  *   update_flash       : Flash new firmware image
 521  *
 522  */
 523 static const struct bin_attribute image_data_attr = {
 524         .attr = {.name = "image", .mode = 0200},
 525         .size = MAX_IMAGE_SIZE, /* Limit image size */
 526         .write = image_data_write,
 527 };
 528
 529 static struct kobj_attribute validate_attribute =
 530         __ATTR(validate_flash, 0600, validate_show, validate_store);
 531
 532 static struct kobj_attribute manage_attribute =
 533         __ATTR(manage_flash, 0600, manage_show, manage_store);
 534
 535 static struct kobj_attribute update_attribute =
 536         __ATTR(update_flash, 0600, update_show, update_store);
 537
 538 static struct attribute *image_op_attrs[] = {
 539         &validate_attribute.attr,
 540         &manage_attribute.attr,
 541         &update_attribute.attr,
 542         NULL    /* need to NULL terminate the list of attributes */
 543 };
 544
 545 static struct attribute_group image_op_attr_group = {
 546         .attrs = image_op_attrs,
 547 };
 548
 549 void __init opal_flash_update_init(void)
 550 {
 551         int ret;
 552
 553         /* Allocate validate image buffer */
 554         validate_flash_data.buf = kzalloc(VALIDATE_BUF_SIZE, GFP_KERNEL);
 555         if (!validate_flash_data.buf) {
 556                 pr_err("%s : Failed to allocate memory\n", __func__);
 557                 return;
 558         }
 559
 560         /* Make sure /sys/firmware/opal directory is created */
 561         if (!opal_kobj) {
 562                 pr_warn("FLASH: opal kobject is not available\n");
 563                 goto nokobj;
 564         }
 565
 566         /* Create the sysfs files */
 567         ret = sysfs_create_group(opal_kobj, &image_op_attr_group);
 568         if (ret) {
 569                 pr_warn("FLASH: Failed to create sysfs files\n");
 570                 goto nokobj;
 571         }
 572
 573         ret = sysfs_create_bin_file(opal_kobj, &image_data_attr);
 574         if (ret) {
 575                 pr_warn("FLASH: Failed to create sysfs files\n");
 576                 goto nosysfs_file;
 577         }
 578
 579         /* Set default status */
 580         validate_flash_data.status = FLASH_NO_OP;
 581         manage_flash_data.status = FLASH_NO_OP;
 582         update_flash_data.status = FLASH_NO_OP;
 583         image_data.status = IMAGE_INVALID;
 584         return;
 585
 586 nosysfs_file:
 587         sysfs_remove_group(opal_kobj, &image_op_attr_group);
 588
 589 nokobj:
 590         kfree(validate_flash_data.buf);
 591         return;
 592 }