]>
Commit | Line | Data |
---|---|---|
2874c5fd | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
50bd6153 VH |
2 | /* |
3 | * PowerNV OPAL Firmware Update Interface | |
4 | * | |
5 | * Copyright 2013 IBM Corp. | |
50bd6153 VH |
6 | */ |
7 | ||
8 | #define DEBUG | |
9 | ||
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> | |
16 | #include <linux/mm.h> | |
17 | #include <linux/vmalloc.h> | |
18 | #include <linux/pagemap.h> | |
2196c6f1 | 19 | #include <linux/delay.h> |
50bd6153 VH |
20 | |
21 | #include <asm/opal.h> | |
22 | ||
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 */ | |
26 | ||
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 */ | |
30 | ||
31 | /* Manage image status values */ | |
32 | #define MANAGE_ACTIVE_ERR -9001 /* Cannot overwrite active img */ | |
33 | ||
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 */ | |
39 | ||
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 */ | |
43 | ||
44 | /* Update tokens */ | |
45 | #define FLASH_UPDATE_CANCEL 0 /* Cancel update request */ | |
46 | #define FLASH_UPDATE_INIT 1 /* Initiate update */ | |
47 | ||
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 */ | |
53 | /* | |
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 | |
56 | */ | |
57 | #define VALIDATE_TMP_COMMIT_DL 4 | |
58 | /* | |
59 | * Current T side will be committed to P side before being replaced with new | |
60 | * image | |
61 | */ | |
62 | #define VALIDATE_TMP_COMMIT 5 | |
63 | /* | |
64 | * T side will be updated with a downlevel image | |
65 | */ | |
66 | #define VALIDATE_TMP_UPDATE_DL 6 | |
67 | /* | |
68 | * The candidate image's release date is later than the system's firmware | |
69 | * service entitlement date - service warranty period has expired | |
70 | */ | |
71 | #define VALIDATE_OUT_OF_WRNTY 7 | |
72 | ||
73 | /* Validate buffer size */ | |
74 | #define VALIDATE_BUF_SIZE 4096 | |
75 | ||
bf16a4c2 VH |
76 | /* XXX: Assume candidate image size is <= 1GB */ |
77 | #define MAX_IMAGE_SIZE 0x40000000 | |
50bd6153 | 78 | |
50bd6153 VH |
79 | /* Image status */ |
80 | enum { | |
81 | IMAGE_INVALID, | |
82 | IMAGE_LOADING, | |
83 | IMAGE_READY, | |
84 | }; | |
85 | ||
86 | /* Candidate image data */ | |
87 | struct image_data_t { | |
88 | int status; | |
89 | void *data; | |
90 | uint32_t size; | |
91 | }; | |
92 | ||
93 | /* Candidate image header */ | |
94 | struct image_header_t { | |
95 | uint16_t magic; | |
96 | uint16_t version; | |
97 | uint32_t size; | |
98 | }; | |
99 | ||
50bd6153 VH |
100 | struct validate_flash_t { |
101 | int status; /* Return status */ | |
8faaaead | 102 | void *buf; /* Candidate image buffer */ |
50bd6153 VH |
103 | uint32_t buf_size; /* Image size */ |
104 | uint32_t result; /* Update results token */ | |
105 | }; | |
106 | ||
107 | struct manage_flash_t { | |
108 | int status; /* Return status */ | |
109 | }; | |
110 | ||
111 | struct update_flash_t { | |
112 | int status; /* Return status */ | |
113 | }; | |
114 | ||
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; | |
3f77df7f VH |
119 | |
120 | /* Initialize update_flash_data status to No Operation */ | |
121 | static struct update_flash_t update_flash_data = { | |
122 | .status = FLASH_NO_OP, | |
123 | }; | |
50bd6153 VH |
124 | |
125 | static DEFINE_MUTEX(image_data_mutex); | |
126 | ||
127 | /* | |
128 | * Validate candidate image | |
129 | */ | |
130 | static inline void opal_flash_validate(void) | |
131 | { | |
cc146d1d AB |
132 | long ret; |
133 | void *buf = validate_flash_data.buf; | |
8b8f7bf4 VH |
134 | __be32 size = cpu_to_be32(validate_flash_data.buf_size); |
135 | __be32 result; | |
cc146d1d AB |
136 | |
137 | ret = opal_validate_flash(__pa(buf), &size, &result); | |
50bd6153 | 138 | |
cc146d1d AB |
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); | |
50bd6153 VH |
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 | ||
50bd6153 VH |
273 | /* |
274 | * OPAL update flash | |
275 | */ | |
276 | static int opal_flash_update(int op) | |
277 | { | |
3441f04b | 278 | struct opal_sg_list *list; |
50bd6153 VH |
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 | ||
3441f04b | 288 | list = opal_vmalloc_to_sg_list(image_data.data, image_data.size); |
50bd6153 VH |
289 | if (!list) |
290 | goto invalid_img; | |
291 | ||
292 | /* First entry address */ | |
293 | addr = __pa(list); | |
294 | ||
50bd6153 VH |
295 | flash: |
296 | rc = opal_update_flash(addr); | |
297 | ||
298 | invalid_img: | |
299 | return rc; | |
300 | } | |
301 | ||
2196c6f1 | 302 | /* This gets called just before system reboots */ |
f2748bdf | 303 | void opal_flash_update_print_message(void) |
2196c6f1 | 304 | { |
2196c6f1 VH |
305 | if (update_flash_data.status != FLASH_IMG_READY) |
306 | return; | |
307 | ||
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"); | |
312 | ||
313 | /* Small delay to help getting the above message out */ | |
314 | msleep(500); | |
2196c6f1 VH |
315 | } |
316 | ||
50bd6153 VH |
317 | /* |
318 | * Show candidate image status | |
319 | */ | |
320 | static ssize_t update_show(struct kobject *kobj, | |
321 | struct kobj_attribute *attr, char *buf) | |
322 | { | |
323 | struct update_flash_t *const args_buf = &update_flash_data; | |
324 | return sprintf(buf, "%d\n", args_buf->status); | |
325 | } | |
326 | ||
327 | /* | |
328 | * Set update image flag | |
329 | * 1 - Flash new image | |
330 | * 0 - Cancel flash request | |
331 | */ | |
332 | static ssize_t update_store(struct kobject *kobj, | |
333 | struct kobj_attribute *attr, | |
334 | const char *buf, size_t count) | |
335 | { | |
336 | struct update_flash_t *const args_buf = &update_flash_data; | |
337 | int rc = count; | |
338 | ||
339 | mutex_lock(&image_data_mutex); | |
340 | ||
341 | switch (buf[0]) { | |
342 | case '0': | |
343 | if (args_buf->status == FLASH_IMG_READY) | |
344 | opal_flash_update(FLASH_UPDATE_CANCEL); | |
345 | args_buf->status = FLASH_NO_OP; | |
346 | break; | |
347 | case '1': | |
348 | /* Image is loaded? */ | |
349 | if (image_data.status == IMAGE_READY) | |
350 | args_buf->status = | |
351 | opal_flash_update(FLASH_UPDATE_INIT); | |
352 | else | |
353 | args_buf->status = FLASH_INVALID_IMG; | |
354 | break; | |
355 | default: | |
356 | rc = -EINVAL; | |
357 | } | |
358 | ||
359 | mutex_unlock(&image_data_mutex); | |
360 | return rc; | |
361 | } | |
362 | ||
363 | /* | |
364 | * Free image buffer | |
365 | */ | |
366 | static void free_image_buf(void) | |
367 | { | |
368 | void *addr; | |
369 | int size; | |
370 | ||
371 | addr = image_data.data; | |
372 | size = PAGE_ALIGN(image_data.size); | |
373 | while (size > 0) { | |
374 | ClearPageReserved(vmalloc_to_page(addr)); | |
375 | addr += PAGE_SIZE; | |
376 | size -= PAGE_SIZE; | |
377 | } | |
378 | vfree(image_data.data); | |
379 | image_data.data = NULL; | |
380 | image_data.status = IMAGE_INVALID; | |
381 | } | |
382 | ||
383 | /* | |
384 | * Allocate image buffer. | |
385 | */ | |
386 | static int alloc_image_buf(char *buffer, size_t count) | |
387 | { | |
388 | void *addr; | |
389 | int size; | |
390 | ||
a0828cf5 | 391 | if (count < sizeof(image_header)) { |
50bd6153 VH |
392 | pr_warn("FLASH: Invalid candidate image\n"); |
393 | return -EINVAL; | |
394 | } | |
395 | ||
a0828cf5 | 396 | memcpy(&image_header, (void *)buffer, sizeof(image_header)); |
50bd6153 | 397 | image_data.size = be32_to_cpu(image_header.size); |
8faaaead | 398 | pr_debug("FLASH: Candidate image size = %u\n", image_data.size); |
50bd6153 VH |
399 | |
400 | if (image_data.size > MAX_IMAGE_SIZE) { | |
401 | pr_warn("FLASH: Too large image\n"); | |
402 | return -EINVAL; | |
403 | } | |
404 | if (image_data.size < VALIDATE_BUF_SIZE) { | |
405 | pr_warn("FLASH: Image is shorter than expected\n"); | |
406 | return -EINVAL; | |
407 | } | |
408 | ||
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__); | |
412 | return -ENOMEM; | |
413 | } | |
414 | ||
415 | /* Pin memory */ | |
416 | addr = image_data.data; | |
417 | size = PAGE_ALIGN(image_data.size); | |
418 | while (size > 0) { | |
419 | SetPageReserved(vmalloc_to_page(addr)); | |
420 | addr += PAGE_SIZE; | |
421 | size -= PAGE_SIZE; | |
422 | } | |
423 | ||
424 | image_data.status = IMAGE_LOADING; | |
425 | return 0; | |
426 | } | |
427 | ||
428 | /* | |
429 | * Copy candidate image | |
430 | * | |
431 | * Parse candidate image header to get total image size | |
432 | * and pre-allocate required memory. | |
433 | */ | |
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) | |
437 | { | |
438 | int rc; | |
439 | ||
440 | mutex_lock(&image_data_mutex); | |
441 | ||
442 | /* New image ? */ | |
443 | if (pos == 0) { | |
444 | /* Free memory, if already allocated */ | |
445 | if (image_data.data) | |
446 | free_image_buf(); | |
447 | ||
448 | /* Cancel outstanding image update request */ | |
449 | if (update_flash_data.status == FLASH_IMG_READY) | |
450 | opal_flash_update(FLASH_UPDATE_CANCEL); | |
451 | ||
452 | /* Allocate memory */ | |
453 | rc = alloc_image_buf(buffer, count); | |
454 | if (rc) | |
455 | goto out; | |
456 | } | |
457 | ||
458 | if (image_data.status != IMAGE_LOADING) { | |
459 | rc = -ENOMEM; | |
460 | goto out; | |
461 | } | |
462 | ||
463 | if ((pos + count) > image_data.size) { | |
464 | rc = -EINVAL; | |
465 | goto out; | |
466 | } | |
467 | ||
468 | memcpy(image_data.data + pos, (void *)buffer, count); | |
469 | rc = count; | |
470 | ||
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; | |
475 | } | |
476 | ||
477 | out: | |
478 | mutex_unlock(&image_data_mutex); | |
479 | return rc; | |
480 | } | |
481 | ||
482 | /* | |
483 | * sysfs interface : | |
484 | * OPAL uses below sysfs files for code update. | |
485 | * We create these files under /sys/firmware/opal. | |
486 | * | |
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 | |
491 | * | |
492 | */ | |
8bfa42ab | 493 | static const struct bin_attribute image_data_attr = { |
50bd6153 VH |
494 | .attr = {.name = "image", .mode = 0200}, |
495 | .size = MAX_IMAGE_SIZE, /* Limit image size */ | |
496 | .write = image_data_write, | |
497 | }; | |
498 | ||
499 | static struct kobj_attribute validate_attribute = | |
500 | __ATTR(validate_flash, 0600, validate_show, validate_store); | |
501 | ||
502 | static struct kobj_attribute manage_attribute = | |
503 | __ATTR(manage_flash, 0600, manage_show, manage_store); | |
504 | ||
505 | static struct kobj_attribute update_attribute = | |
506 | __ATTR(update_flash, 0600, update_show, update_store); | |
507 | ||
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 */ | |
513 | }; | |
514 | ||
515 | static struct attribute_group image_op_attr_group = { | |
516 | .attrs = image_op_attrs, | |
517 | }; | |
518 | ||
ed59190e | 519 | void __init opal_flash_update_init(void) |
50bd6153 VH |
520 | { |
521 | int ret; | |
522 | ||
523 | /* Allocate validate image buffer */ | |
524 | validate_flash_data.buf = kzalloc(VALIDATE_BUF_SIZE, GFP_KERNEL); | |
525 | if (!validate_flash_data.buf) { | |
526 | pr_err("%s : Failed to allocate memory\n", __func__); | |
527 | return; | |
528 | } | |
529 | ||
530 | /* Make sure /sys/firmware/opal directory is created */ | |
531 | if (!opal_kobj) { | |
532 | pr_warn("FLASH: opal kobject is not available\n"); | |
533 | goto nokobj; | |
534 | } | |
535 | ||
536 | /* Create the sysfs files */ | |
537 | ret = sysfs_create_group(opal_kobj, &image_op_attr_group); | |
538 | if (ret) { | |
539 | pr_warn("FLASH: Failed to create sysfs files\n"); | |
540 | goto nokobj; | |
541 | } | |
542 | ||
543 | ret = sysfs_create_bin_file(opal_kobj, &image_data_attr); | |
544 | if (ret) { | |
545 | pr_warn("FLASH: Failed to create sysfs files\n"); | |
546 | goto nosysfs_file; | |
547 | } | |
548 | ||
549 | /* Set default status */ | |
550 | validate_flash_data.status = FLASH_NO_OP; | |
551 | manage_flash_data.status = FLASH_NO_OP; | |
552 | update_flash_data.status = FLASH_NO_OP; | |
553 | image_data.status = IMAGE_INVALID; | |
554 | return; | |
555 | ||
556 | nosysfs_file: | |
557 | sysfs_remove_group(opal_kobj, &image_op_attr_group); | |
558 | ||
559 | nokobj: | |
560 | kfree(validate_flash_data.buf); | |
561 | return; | |
562 | } |