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