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 static struct update_flash_t    update_flash_data;
 124
 125 static DEFINE_MUTEX(image_data_mutex);
 126
 127 /*
 128  * Validate candidate image
 129  */
 130 static inline void opal_flash_validate(void)
 131 {
 132         long ret;
 133         void *buf = validate_flash_data.buf;
 134         __be32 size = cpu_to_be32(validate_flash_data.buf_size);
 135         __be32 result;
 136
 137         ret = opal_validate_flash(__pa(buf), &size, &result);
 138
 139         validate_flash_data.status = ret;
 140         validate_flash_data.buf_size = be32_to_cpu(size);
 141         validate_flash_data.result = be32_to_cpu(result);
 142 }
 143
 144 /*
 145  * Validate output format:
 146  *     validate result token
 147  *     current image version details
 148  *     new image version details
 149  */
 150 static ssize_t validate_show(struct kobject *kobj,
 151                              struct kobj_attribute *attr, char *buf)
 152 {
 153         struct validate_flash_t *args_buf = &validate_flash_data;
 154         int len;
 155
 156         /* Candidate image is not validated */
 157         if (args_buf->status < VALIDATE_TMP_UPDATE) {
 158                 len = sprintf(buf, "%d\n", args_buf->status);
 159                 goto out;
 160         }
 161
 162         /* Result token */
 163         len = sprintf(buf, "%d\n", args_buf->result);
 164
 165         /* Current and candidate image version details */
 166         if ((args_buf->result != VALIDATE_TMP_UPDATE) &&
 167             (args_buf->result < VALIDATE_CUR_UNKNOWN))
 168                 goto out;
 169
 170         if (args_buf->buf_size > (VALIDATE_BUF_SIZE - len)) {
 171                 memcpy(buf + len, args_buf->buf, VALIDATE_BUF_SIZE - len);
 172                 len = VALIDATE_BUF_SIZE;
 173         } else {
 174                 memcpy(buf + len, args_buf->buf, args_buf->buf_size);
 175                 len += args_buf->buf_size;
 176         }
 177 out:
 178         /* Set status to default */
 179         args_buf->status = FLASH_NO_OP;
 180         return len;
 181 }
 182
 183 /*
 184  * Validate candidate firmware image
 185  *
 186  * Note:
 187  *   We are only interested in first 4K bytes of the
 188  *   candidate image.
 189  */
 190 static ssize_t validate_store(struct kobject *kobj,
 191                               struct kobj_attribute *attr,
 192                               const char *buf, size_t count)
 193 {
 194         struct validate_flash_t *args_buf = &validate_flash_data;
 195
 196         if (buf[0] != '1')
 197                 return -EINVAL;
 198
 199         mutex_lock(&image_data_mutex);
 200
 201         if (image_data.status != IMAGE_READY ||
 202             image_data.size < VALIDATE_BUF_SIZE) {
 203                 args_buf->result = VALIDATE_INVALID_IMG;
 204                 args_buf->status = VALIDATE_IMG_INCOMPLETE;
 205                 goto out;
 206         }
 207
 208         /* Copy first 4k bytes of candidate image */
 209         memcpy(args_buf->buf, image_data.data, VALIDATE_BUF_SIZE);
 210
 211         args_buf->status = VALIDATE_IMG_READY;
 212         args_buf->buf_size = VALIDATE_BUF_SIZE;
 213
 214         /* Validate candidate image */
 215         opal_flash_validate();
 216
 217 out:
 218         mutex_unlock(&image_data_mutex);
 219         return count;
 220 }
 221
 222 /*
 223  * Manage flash routine
 224  */
 225 static inline void opal_flash_manage(uint8_t op)
 226 {
 227         struct manage_flash_t *const args_buf = &manage_flash_data;
 228
 229         args_buf->status = opal_manage_flash(op);
 230 }
 231
 232 /*
 233  * Show manage flash status
 234  */
 235 static ssize_t manage_show(struct kobject *kobj,
 236                            struct kobj_attribute *attr, char *buf)
 237 {
 238         struct manage_flash_t *const args_buf = &manage_flash_data;
 239         int rc;
 240
 241         rc = sprintf(buf, "%d\n", args_buf->status);
 242         /* Set status to default*/
 243         args_buf->status = FLASH_NO_OP;
 244         return rc;
 245 }
 246
 247 /*
 248  * Manage operations:
 249  *   0 - Reject
 250  *   1 - Commit
 251  */
 252 static ssize_t manage_store(struct kobject *kobj,
 253                             struct kobj_attribute *attr,
 254                             const char *buf, size_t count)
 255 {
 256         uint8_t op;
 257         switch (buf[0]) {
 258         case '0':
 259                 op = FLASH_REJECT_TMP_SIDE;
 260                 break;
 261         case '1':
 262                 op = FLASH_COMMIT_TMP_SIDE;
 263                 break;
 264         default:
 265                 return -EINVAL;
 266         }
 267
 268         /* commit/reject temporary image */
 269         opal_flash_manage(op);
 270         return count;
 271 }
 272
 273 /*
 274  * OPAL update flash
 275  */
 276 static int opal_flash_update(int op)
 277 {
 278         struct opal_sg_list *list;
 279         unsigned long addr;
 280         int64_t rc = OPAL_PARAMETER;
 281
 282         if (op == FLASH_UPDATE_CANCEL) {
 283                 pr_alert("FLASH: Image update cancelled\n");
 284                 addr = '\0';
 285                 goto flash;
 286         }
 287
 288         list = opal_vmalloc_to_sg_list(image_data.data, image_data.size);
 289         if (!list)
 290                 goto invalid_img;
 291
 292         /* First entry address */
 293         addr = __pa(list);
 294
 295 flash:
 296         rc = opal_update_flash(addr);
 297
 298 invalid_img:
 299         return rc;
 300 }
 301
 302 /* Return CPUs to OPAL before starting FW update */
 303 static void flash_return_cpu(void *info)
 304 {
 305         int cpu = smp_processor_id();
 306
 307         if (!cpu_online(cpu))
 308                 return;
 309
 310         /* Disable IRQ */
 311         hard_irq_disable();
 312
 313         /* Return the CPU to OPAL */
 314         opal_return_cpu();
 315 }
 316
 317 /* This gets called just before system reboots */
 318 void opal_flash_term_callback(void)
 319 {
 320         struct cpumask mask;
 321
 322         if (update_flash_data.status != FLASH_IMG_READY)
 323                 return;
 324
 325         pr_alert("FLASH: Flashing new firmware\n");
 326         pr_alert("FLASH: Image is %u bytes\n", image_data.size);
 327         pr_alert("FLASH: Performing flash and reboot/shutdown\n");
 328         pr_alert("FLASH: This will take several minutes. Do not power off!\n");
 329
 330         /* Small delay to help getting the above message out */
 331         msleep(500);
 332
 333         /* Return secondary CPUs to firmware */
 334         cpumask_copy(&mask, cpu_online_mask);
 335         cpumask_clear_cpu(smp_processor_id(), &mask);
 336         if (!cpumask_empty(&mask))
 337                 smp_call_function_many(&mask,
 338                                        flash_return_cpu, NULL, false);
 339         /* Hard disable interrupts */
 340         hard_irq_disable();
 341 }
 342
 343 /*
 344  * Show candidate image status
 345  */
 346 static ssize_t update_show(struct kobject *kobj,
 347                            struct kobj_attribute *attr, char *buf)
 348 {
 349         struct update_flash_t *const args_buf = &update_flash_data;
 350         return sprintf(buf, "%d\n", args_buf->status);
 351 }
 352
 353 /*
 354  * Set update image flag
 355  *  1 - Flash new image
 356  *  0 - Cancel flash request
 357  */
 358 static ssize_t update_store(struct kobject *kobj,
 359                             struct kobj_attribute *attr,
 360                             const char *buf, size_t count)
 361 {
 362         struct update_flash_t *const args_buf = &update_flash_data;
 363         int rc = count;
 364
 365         mutex_lock(&image_data_mutex);
 366
 367         switch (buf[0]) {
 368         case '0':
 369                 if (args_buf->status == FLASH_IMG_READY)
 370                         opal_flash_update(FLASH_UPDATE_CANCEL);
 371                 args_buf->status = FLASH_NO_OP;
 372                 break;
 373         case '1':
 374                 /* Image is loaded? */
 375                 if (image_data.status == IMAGE_READY)
 376                         args_buf->status =
 377                                 opal_flash_update(FLASH_UPDATE_INIT);
 378                 else
 379                         args_buf->status = FLASH_INVALID_IMG;
 380                 break;
 381         default:
 382                 rc = -EINVAL;
 383         }
 384
 385         mutex_unlock(&image_data_mutex);
 386         return rc;
 387 }
 388
 389 /*
 390  * Free image buffer
 391  */
 392 static void free_image_buf(void)
 393 {
 394         void *addr;
 395         int size;
 396
 397         addr = image_data.data;
 398         size = PAGE_ALIGN(image_data.size);
 399         while (size > 0) {
 400                 ClearPageReserved(vmalloc_to_page(addr));
 401                 addr += PAGE_SIZE;
 402                 size -= PAGE_SIZE;
 403         }
 404         vfree(image_data.data);
 405         image_data.data = NULL;
 406         image_data.status = IMAGE_INVALID;
 407 }
 408
 409 /*
 410  * Allocate image buffer.
 411  */
 412 static int alloc_image_buf(char *buffer, size_t count)
 413 {
 414         void *addr;
 415         int size;
 416
 417         if (count < sizeof(struct image_header_t)) {
 418                 pr_warn("FLASH: Invalid candidate image\n");
 419                 return -EINVAL;
 420         }
 421
 422         memcpy(&image_header, (void *)buffer, sizeof(struct image_header_t));
 423         image_data.size = be32_to_cpu(image_header.size);
 424         pr_debug("FLASH: Candidate image size = %u\n", image_data.size);
 425
 426         if (image_data.size > MAX_IMAGE_SIZE) {
 427                 pr_warn("FLASH: Too large image\n");
 428                 return -EINVAL;
 429         }
 430         if (image_data.size < VALIDATE_BUF_SIZE) {
 431                 pr_warn("FLASH: Image is shorter than expected\n");
 432                 return -EINVAL;
 433         }
 434
 435         image_data.data = vzalloc(PAGE_ALIGN(image_data.size));
 436         if (!image_data.data) {
 437                 pr_err("%s : Failed to allocate memory\n", __func__);
 438                 return -ENOMEM;
 439         }
 440
 441         /* Pin memory */
 442         addr = image_data.data;
 443         size = PAGE_ALIGN(image_data.size);
 444         while (size > 0) {
 445                 SetPageReserved(vmalloc_to_page(addr));
 446                 addr += PAGE_SIZE;
 447                 size -= PAGE_SIZE;
 448         }
 449
 450         image_data.status = IMAGE_LOADING;
 451         return 0;
 452 }
 453
 454 /*
 455  * Copy candidate image
 456  *
 457  * Parse candidate image header to get total image size
 458  * and pre-allocate required memory.
 459  */
 460 static ssize_t image_data_write(struct file *filp, struct kobject *kobj,
 461                                 struct bin_attribute *bin_attr,
 462                                 char *buffer, loff_t pos, size_t count)
 463 {
 464         int rc;
 465
 466         mutex_lock(&image_data_mutex);
 467
 468         /* New image ? */
 469         if (pos == 0) {
 470                 /* Free memory, if already allocated */
 471                 if (image_data.data)
 472                         free_image_buf();
 473
 474                 /* Cancel outstanding image update request */
 475                 if (update_flash_data.status == FLASH_IMG_READY)
 476                         opal_flash_update(FLASH_UPDATE_CANCEL);
 477
 478                 /* Allocate memory */
 479                 rc = alloc_image_buf(buffer, count);
 480                 if (rc)
 481                         goto out;
 482         }
 483
 484         if (image_data.status != IMAGE_LOADING) {
 485                 rc = -ENOMEM;
 486                 goto out;
 487         }
 488
 489         if ((pos + count) > image_data.size) {
 490                 rc = -EINVAL;
 491                 goto out;
 492         }
 493
 494         memcpy(image_data.data + pos, (void *)buffer, count);
 495         rc = count;
 496
 497         /* Set image status */
 498         if ((pos + count) == image_data.size) {
 499                 pr_debug("FLASH: Candidate image loaded....\n");
 500                 image_data.status = IMAGE_READY;
 501         }
 502
 503 out:
 504         mutex_unlock(&image_data_mutex);
 505         return rc;
 506 }
 507
 508 /*
 509  * sysfs interface :
 510  *  OPAL uses below sysfs files for code update.
 511  *  We create these files under /sys/firmware/opal.
 512  *
 513  *   image              : Interface to load candidate firmware image
 514  *   validate_flash     : Validate firmware image
 515  *   manage_flash       : Commit/Reject firmware image
 516  *   update_flash       : Flash new firmware image
 517  *
 518  */
 519 static struct bin_attribute image_data_attr = {
 520         .attr = {.name = "image", .mode = 0200},
 521         .size = MAX_IMAGE_SIZE, /* Limit image size */
 522         .write = image_data_write,
 523 };
 524
 525 static struct kobj_attribute validate_attribute =
 526         __ATTR(validate_flash, 0600, validate_show, validate_store);
 527
 528 static struct kobj_attribute manage_attribute =
 529         __ATTR(manage_flash, 0600, manage_show, manage_store);
 530
 531 static struct kobj_attribute update_attribute =
 532         __ATTR(update_flash, 0600, update_show, update_store);
 533
 534 static struct attribute *image_op_attrs[] = {
 535         &validate_attribute.attr,
 536         &manage_attribute.attr,
 537         &update_attribute.attr,
 538         NULL    /* need to NULL terminate the list of attributes */
 539 };
 540
 541 static struct attribute_group image_op_attr_group = {
 542         .attrs = image_op_attrs,
 543 };
 544
 545 void __init opal_flash_init(void)
 546 {
 547         int ret;
 548
 549         /* Allocate validate image buffer */
 550         validate_flash_data.buf = kzalloc(VALIDATE_BUF_SIZE, GFP_KERNEL);
 551         if (!validate_flash_data.buf) {
 552                 pr_err("%s : Failed to allocate memory\n", __func__);
 553                 return;
 554         }
 555
 556         /* Make sure /sys/firmware/opal directory is created */
 557         if (!opal_kobj) {
 558                 pr_warn("FLASH: opal kobject is not available\n");
 559                 goto nokobj;
 560         }
 561
 562         /* Create the sysfs files */
 563         ret = sysfs_create_group(opal_kobj, &image_op_attr_group);
 564         if (ret) {
 565                 pr_warn("FLASH: Failed to create sysfs files\n");
 566                 goto nokobj;
 567         }
 568
 569         ret = sysfs_create_bin_file(opal_kobj, &image_data_attr);
 570         if (ret) {
 571                 pr_warn("FLASH: Failed to create sysfs files\n");
 572                 goto nosysfs_file;
 573         }
 574
 575         /* Set default status */
 576         validate_flash_data.status = FLASH_NO_OP;
 577         manage_flash_data.status = FLASH_NO_OP;
 578         update_flash_data.status = FLASH_NO_OP;
 579         image_data.status = IMAGE_INVALID;
 580         return;
 581
 582 nosysfs_file:
 583         sysfs_remove_group(opal_kobj, &image_op_attr_group);
 584
 585 nokobj:
 586         kfree(validate_flash_data.buf);
 587         return;
 588 }