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 */
opal_flash_validate(void)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 */
validate_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)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 */
validate_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)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 */
opal_flash_manage(uint8_t op)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 */
manage_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)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 */
manage_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)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 */
opal_flash_update(int op)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 */
flash_return_cpu(void * info)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 */
opal_flash_term_callback(void)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 */
update_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)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 */
update_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)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 */
free_image_buf(void)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 */
alloc_image_buf(char * buffer,size_t count)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 */
image_data_write(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buffer,loff_t pos,size_t count)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
opal_flash_init(void)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 }
589