1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * PowerNV OPAL Firmware Update Interface
5 * Copyright 2013 IBM Corp.
10 #include <linux/kernel.h>
11 #include <linux/reboot.h>
12 #include <linux/init.h>
13 #include <linux/kobject.h>
14 #include <linux/sysfs.h>
15 #include <linux/slab.h>
17 #include <linux/vmalloc.h>
18 #include <linux/pagemap.h>
19 #include <linux/delay.h>
23 /* FLASH status codes */
24 #define FLASH_NO_OP -1099 /* No operation initiated by user */
25 #define FLASH_NO_AUTH -9002 /* Not a service authority partition */
27 /* Validate image status values */
28 #define VALIDATE_IMG_READY -1001 /* Image ready for validation */
29 #define VALIDATE_IMG_INCOMPLETE -1002 /* User copied < VALIDATE_BUF_SIZE */
31 /* Manage image status values */
32 #define MANAGE_ACTIVE_ERR -9001 /* Cannot overwrite active img */
34 /* Flash image status values */
35 #define FLASH_IMG_READY 0 /* Img ready for flash on reboot */
36 #define FLASH_INVALID_IMG -1003 /* Flash image shorter than expected */
37 #define FLASH_IMG_NULL_DATA -1004 /* Bad data in sg list entry */
38 #define FLASH_IMG_BAD_LEN -1005 /* Bad length in sg list entry */
40 /* Manage operation tokens */
41 #define FLASH_REJECT_TMP_SIDE 0 /* Reject temporary fw image */
42 #define FLASH_COMMIT_TMP_SIDE 1 /* Commit temporary fw image */
45 #define FLASH_UPDATE_CANCEL 0 /* Cancel update request */
46 #define FLASH_UPDATE_INIT 1 /* Initiate update */
48 /* Validate image update result tokens */
49 #define VALIDATE_TMP_UPDATE 0 /* T side will be updated */
50 #define VALIDATE_FLASH_AUTH 1 /* Partition does not have authority */
51 #define VALIDATE_INVALID_IMG 2 /* Candidate image is not valid */
52 #define VALIDATE_CUR_UNKNOWN 3 /* Current fixpack level is unknown */
54 * Current T side will be committed to P side before being replace with new
55 * image, and the new image is downlevel from current image
57 #define VALIDATE_TMP_COMMIT_DL 4
59 * Current T side will be committed to P side before being replaced with new
62 #define VALIDATE_TMP_COMMIT 5
64 * T side will be updated with a downlevel image
66 #define VALIDATE_TMP_UPDATE_DL 6
68 * The candidate image's release date is later than the system's firmware
69 * service entitlement date - service warranty period has expired
71 #define VALIDATE_OUT_OF_WRNTY 7
73 /* Validate buffer size */
74 #define VALIDATE_BUF_SIZE 4096
76 /* XXX: Assume candidate image size is <= 1GB */
77 #define MAX_IMAGE_SIZE 0x40000000
86 /* Candidate image data */
93 /* Candidate image header */
94 struct image_header_t {
100 struct validate_flash_t {
101 int status; /* Return status */
102 void *buf; /* Candidate image buffer */
103 uint32_t buf_size; /* Image size */
104 uint32_t result; /* Update results token */
107 struct manage_flash_t {
108 int status; /* Return status */
111 struct update_flash_t {
112 int status; /* Return status */
115 static struct image_header_t image_header;
116 static struct image_data_t image_data;
117 static struct validate_flash_t validate_flash_data;
118 static struct manage_flash_t manage_flash_data;
120 /* Initialize update_flash_data status to No Operation */
121 static struct update_flash_t update_flash_data = {
122 .status = FLASH_NO_OP,
125 static DEFINE_MUTEX(image_data_mutex);
128 * Validate candidate image
130 static inline void opal_flash_validate(void)
133 void *buf = validate_flash_data.buf;
134 __be32 size = cpu_to_be32(validate_flash_data.buf_size);
137 ret = opal_validate_flash(__pa(buf), &size, &result);
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);
145 * Validate output format:
146 * validate result token
147 * current image version details
148 * new image version details
150 static ssize_t validate_show(struct kobject *kobj,
151 struct kobj_attribute *attr, char *buf)
153 struct validate_flash_t *args_buf = &validate_flash_data;
156 /* Candidate image is not validated */
157 if (args_buf->status < VALIDATE_TMP_UPDATE) {
158 len = sprintf(buf, "%d\n", args_buf->status);
163 len = sprintf(buf, "%d\n", args_buf->result);
165 /* Current and candidate image version details */
166 if ((args_buf->result != VALIDATE_TMP_UPDATE) &&
167 (args_buf->result < VALIDATE_CUR_UNKNOWN))
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;
174 memcpy(buf + len, args_buf->buf, args_buf->buf_size);
175 len += args_buf->buf_size;
178 /* Set status to default */
179 args_buf->status = FLASH_NO_OP;
184 * Validate candidate firmware image
187 * We are only interested in first 4K bytes of the
190 static ssize_t validate_store(struct kobject *kobj,
191 struct kobj_attribute *attr,
192 const char *buf, size_t count)
194 struct validate_flash_t *args_buf = &validate_flash_data;
199 mutex_lock(&image_data_mutex);
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;
208 /* Copy first 4k bytes of candidate image */
209 memcpy(args_buf->buf, image_data.data, VALIDATE_BUF_SIZE);
211 args_buf->status = VALIDATE_IMG_READY;
212 args_buf->buf_size = VALIDATE_BUF_SIZE;
214 /* Validate candidate image */
215 opal_flash_validate();
218 mutex_unlock(&image_data_mutex);
223 * Manage flash routine
225 static inline void opal_flash_manage(uint8_t op)
227 struct manage_flash_t *const args_buf = &manage_flash_data;
229 args_buf->status = opal_manage_flash(op);
233 * Show manage flash status
235 static ssize_t manage_show(struct kobject *kobj,
236 struct kobj_attribute *attr, char *buf)
238 struct manage_flash_t *const args_buf = &manage_flash_data;
241 rc = sprintf(buf, "%d\n", args_buf->status);
242 /* Set status to default*/
243 args_buf->status = FLASH_NO_OP;
252 static ssize_t manage_store(struct kobject *kobj,
253 struct kobj_attribute *attr,
254 const char *buf, size_t count)
259 op = FLASH_REJECT_TMP_SIDE;
262 op = FLASH_COMMIT_TMP_SIDE;
268 /* commit/reject temporary image */
269 opal_flash_manage(op);
276 static int opal_flash_update(int op)
278 struct opal_sg_list *list;
280 int64_t rc = OPAL_PARAMETER;
282 if (op == FLASH_UPDATE_CANCEL) {
283 pr_alert("FLASH: Image update cancelled\n");
288 list = opal_vmalloc_to_sg_list(image_data.data, image_data.size);
292 /* First entry address */
296 rc = opal_update_flash(addr);
302 /* This gets called just before system reboots */
303 void opal_flash_update_print_message(void)
305 if (update_flash_data.status != FLASH_IMG_READY)
308 pr_alert("FLASH: Flashing new firmware\n");
309 pr_alert("FLASH: Image is %u bytes\n", image_data.size);
310 pr_alert("FLASH: Performing flash and reboot/shutdown\n");
311 pr_alert("FLASH: This will take several minutes. Do not power off!\n");
313 /* Small delay to help getting the above message out */
318 * Show candidate image status
320 static ssize_t update_show(struct kobject *kobj,
321 struct kobj_attribute *attr, char *buf)
323 struct update_flash_t *const args_buf = &update_flash_data;
324 return sprintf(buf, "%d\n", args_buf->status);
328 * Set update image flag
329 * 1 - Flash new image
330 * 0 - Cancel flash request
332 static ssize_t update_store(struct kobject *kobj,
333 struct kobj_attribute *attr,
334 const char *buf, size_t count)
336 struct update_flash_t *const args_buf = &update_flash_data;
339 mutex_lock(&image_data_mutex);
343 if (args_buf->status == FLASH_IMG_READY)
344 opal_flash_update(FLASH_UPDATE_CANCEL);
345 args_buf->status = FLASH_NO_OP;
348 /* Image is loaded? */
349 if (image_data.status == IMAGE_READY)
351 opal_flash_update(FLASH_UPDATE_INIT);
353 args_buf->status = FLASH_INVALID_IMG;
359 mutex_unlock(&image_data_mutex);
366 static void free_image_buf(void)
371 addr = image_data.data;
372 size = PAGE_ALIGN(image_data.size);
374 ClearPageReserved(vmalloc_to_page(addr));
378 vfree(image_data.data);
379 image_data.data = NULL;
380 image_data.status = IMAGE_INVALID;
384 * Allocate image buffer.
386 static int alloc_image_buf(char *buffer, size_t count)
391 if (count < sizeof(image_header)) {
392 pr_warn("FLASH: Invalid candidate image\n");
396 memcpy(&image_header, (void *)buffer, sizeof(image_header));
397 image_data.size = be32_to_cpu(image_header.size);
398 pr_debug("FLASH: Candidate image size = %u\n", image_data.size);
400 if (image_data.size > MAX_IMAGE_SIZE) {
401 pr_warn("FLASH: Too large image\n");
404 if (image_data.size < VALIDATE_BUF_SIZE) {
405 pr_warn("FLASH: Image is shorter than expected\n");
409 image_data.data = vzalloc(PAGE_ALIGN(image_data.size));
410 if (!image_data.data) {
411 pr_err("%s : Failed to allocate memory\n", __func__);
416 addr = image_data.data;
417 size = PAGE_ALIGN(image_data.size);
419 SetPageReserved(vmalloc_to_page(addr));
424 image_data.status = IMAGE_LOADING;
429 * Copy candidate image
431 * Parse candidate image header to get total image size
432 * and pre-allocate required memory.
434 static ssize_t image_data_write(struct file *filp, struct kobject *kobj,
435 struct bin_attribute *bin_attr,
436 char *buffer, loff_t pos, size_t count)
440 mutex_lock(&image_data_mutex);
444 /* Free memory, if already allocated */
448 /* Cancel outstanding image update request */
449 if (update_flash_data.status == FLASH_IMG_READY)
450 opal_flash_update(FLASH_UPDATE_CANCEL);
452 /* Allocate memory */
453 rc = alloc_image_buf(buffer, count);
458 if (image_data.status != IMAGE_LOADING) {
463 if ((pos + count) > image_data.size) {
468 memcpy(image_data.data + pos, (void *)buffer, count);
471 /* Set image status */
472 if ((pos + count) == image_data.size) {
473 pr_debug("FLASH: Candidate image loaded....\n");
474 image_data.status = IMAGE_READY;
478 mutex_unlock(&image_data_mutex);
484 * OPAL uses below sysfs files for code update.
485 * We create these files under /sys/firmware/opal.
487 * image : Interface to load candidate firmware image
488 * validate_flash : Validate firmware image
489 * manage_flash : Commit/Reject firmware image
490 * update_flash : Flash new firmware image
493 static const struct bin_attribute image_data_attr = {
494 .attr = {.name = "image", .mode = 0200},
495 .size = MAX_IMAGE_SIZE, /* Limit image size */
496 .write = image_data_write,
499 static struct kobj_attribute validate_attribute =
500 __ATTR(validate_flash, 0600, validate_show, validate_store);
502 static struct kobj_attribute manage_attribute =
503 __ATTR(manage_flash, 0600, manage_show, manage_store);
505 static struct kobj_attribute update_attribute =
506 __ATTR(update_flash, 0600, update_show, update_store);
508 static struct attribute *image_op_attrs[] = {
509 &validate_attribute.attr,
510 &manage_attribute.attr,
511 &update_attribute.attr,
512 NULL /* need to NULL terminate the list of attributes */
515 static const struct attribute_group image_op_attr_group = {
516 .attrs = image_op_attrs,
519 void __init opal_flash_update_init(void)
523 /* Firmware update is not supported by firmware */
524 if (!opal_check_token(OPAL_FLASH_VALIDATE))
527 /* Allocate validate image buffer */
528 validate_flash_data.buf = kzalloc(VALIDATE_BUF_SIZE, GFP_KERNEL);
529 if (!validate_flash_data.buf) {
530 pr_err("%s : Failed to allocate memory\n", __func__);
534 /* Make sure /sys/firmware/opal directory is created */
536 pr_warn("FLASH: opal kobject is not available\n");
540 /* Create the sysfs files */
541 ret = sysfs_create_group(opal_kobj, &image_op_attr_group);
543 pr_warn("FLASH: Failed to create sysfs files\n");
547 ret = sysfs_create_bin_file(opal_kobj, &image_data_attr);
549 pr_warn("FLASH: Failed to create sysfs files\n");
553 /* Set default status */
554 validate_flash_data.status = FLASH_NO_OP;
555 manage_flash_data.status = FLASH_NO_OP;
556 update_flash_data.status = FLASH_NO_OP;
557 image_data.status = IMAGE_INVALID;
561 sysfs_remove_group(opal_kobj, &image_op_attr_group);
564 kfree(validate_flash_data.buf);