~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/powerpc/platforms/powernv/opal-flash.c

Version: ~ [ linux-5.7-rc7 ] ~ [ linux-5.6.14 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.42 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.124 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.181 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.224 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.224 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.84 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp