Support -i partition:file feature for both read and write.

layout.c

 /*
  * This file is part of the flashrom project.
  *
  * Copyright (C) 2005-2008 coresystems GmbH
  * (Written by Stefan Reinauer <stepan@coresystems.de> for coresystems GmbH)
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2 of the License.
  *
@@ skipping 21 matching lines @@
 #endif
 static int romimages = 0;
 
 #define MAX_ROMLAYOUT   64
 
 typedef struct {
         unsigned int start;
         unsigned int end;
         unsigned int included;
         char name[256];
+        char file[256];  /* file[0]=='\0' means not specified. */
 } romlayout_t;
 
 static romlayout_t rom_entries[MAX_ROMLAYOUT];
 
 #if CONFIG_INTERNAL == 1 /* FIXME: Move the whole block to cbtable.c? */
 static char *def_name = "DEFAULT";
 
 int show_id(uint8_t *bios, int size, int force)
 {
         unsigned int *walk;
@@ skipping 119 matching lines @@
                 tstr1 = strtok(tempstr, ":");
                 tstr2 = strtok(NULL, ":");
                 if (!tstr1 || !tstr2) {
                         msg_gerr("Error parsing layout file.\n");
                         fclose(romlayout);
                         return 1;
                 }
                 rom_entries[romimages].start = strtol(tstr1, (char **)NULL, 16);
                 rom_entries[romimages].end = strtol(tstr2, (char **)NULL, 16);
                 rom_entries[romimages].included = 0;
+                strcpy(rom_entries[romimages].file, "");
                 romimages++;
         }
 
         for (i = 0; i < romimages; i++) {
                 msg_gdbg("romlayout %08x - %08x named %s\n",
                              rom_entries[i].start,
                              rom_entries[i].end, rom_entries[i].name);
         }
 
         fclose(romlayout);
 
         return 0;
 }
 #endif
 
 int find_romentry(char *name)
 {
         int i;
+        char *file = NULL;
 
         if (!romimages)
                 return -1;
 
-        msg_gdbg("Looking for \"%s\"... ", name);
+        /* -i <image>[:<file>] */
+        if (strtok(name, ":")) {
+                file = strtok(NULL, "");
+        }
+        msg_gdbg("Looking for \"%s\" (file=\"%s\")... ",
+                 name, file ? file : "<not specified>");
 
         for (i = 0; i < romimages; i++) {
                 if (!strcmp(rom_entries[i].name, name)) {
                         rom_entries[i].included = 1;
+                        snprintf(rom_entries[i].file,
+                                 sizeof(rom_entries[i].file),
+                                 "%s", file ? file : "");
                         msg_gdbg("found.\n");
                         return i;
                 }
         }
         msg_gdbg("not found.\n");       // Not found. Error.
 
         return -1;
 }
 
 int find_next_included_romentry(unsigned int start)
@@ skipping 14 matching lines @@
                         return i;
                 /* Entry begins after start. */
                 if (best_start > rom_entries[i].start) {
                         best_start = rom_entries[i].start;
                         best_entry = i;
                 }
         }
         return best_entry;
 }
 
+static int read_content_from_file(int entry, uint8_t *newcontents) {
+        char *file;
+        FILE *fp;
+        int len;
+
+        /* If file name is specified for this partition, read file
+         * content to overwrite. */
+        file = rom_entries[entry].file;
+        len = rom_entries[entry].end - rom_entries[entry].start + 1;
+        if (file[0]) {
+                int numbytes;
+                if ((fp = fopen(file, "rb")) == NULL) {
+                        perror(file);
+                        return -1;
+                }
+                numbytes = fread(newcontents + rom_entries[entry].start,
+                                 1, len, fp);
+                fclose(fp);
+                if (numbytes == -1) {
+                        perror(file);
+                        return -1;
+                }
+        }
+        return 0;
+}
+
 int handle_romentries(struct flashchip *flash, uint8_t *oldcontents, uint8_t *newcontents)
 {
         unsigned int start = 0;
         int entry;
         unsigned int size = flash->total_size * 1024;
 
         /* If no layout file was specified or the layout file was empty, assume
          * that the user wants to flash the complete new image.
          */
         if (!romimages)
                 return 0;
         /* Non-included romentries are ignored.
          * The union of all included romentries is used from the new image.
          */
         while (start < size) {
+
                 entry = find_next_included_romentry(start);
                 /* No more romentries for remaining region? */
                 if (entry < 0) {
                         memcpy(newcontents + start, oldcontents + start,
                                size - start);
                         break;
                 }
+
+                /* For non-included region, copy from old content. */
                 if (rom_entries[entry].start > start)
                         memcpy(newcontents + start, oldcontents + start,
                                rom_entries[entry].start - start);
+                /* For included region, copy from file if specified. */
+                if (read_content_from_file(entry, newcontents) < 0) return -1;
+
                 /* Skip to location after current romentry. */
                 start = rom_entries[entry].end + 1;
                 /* Catch overflow. */
                 if (!start)
                         break;
         }
                         
         return 0;
 }
+
+static int write_content_to_file(int entry, uint8_t *buf) {
+        char *file;
+        FILE *fp;
+        int len = rom_entries[entry].end - rom_entries[entry].start + 1;
+
+        file = rom_entries[entry].file;
+        if (file[0]) {  /* save to file if name is specified. */
+                int numbytes;
+                if ((fp = fopen(file, "wb")) == NULL) {
+                        perror(file);
+                        return -1;
+                }
+                numbytes = fwrite(buf + rom_entries[entry].start, 1, len, fp);
+                fclose(fp);
+                if (numbytes != len) {
+                        perror(file);
+                        return -1;
+                }
+        }
+        return 0;
+}
+
+int handle_partial_read(
+    struct flashchip *flash,
+    uint8_t *buf,
+    int (*read) (struct flashchip *flash, uint8_t *buf, int start, int len)) {
+
+        unsigned int start = 0;
+        int entry;
+        unsigned int size = flash->total_size * 1024;
+        int count = 0;
+
+        /* If no layout file was specified or the layout file was empty, assume
+         * that the user wants to flash the complete new image.
+         */
+        if (!romimages)
+                return 0;
+        /* Walk through the table and write content to file for those included
+         * partition. */
+        while (start < size) {
+                int len;
+
+                entry = find_next_included_romentry(start);
+                /* No more romentries for remaining region? */
+                if (entry < 0) {
+                        break;
+                }
+                ++count;
+
+                /* read content from flash. */
+                len = rom_entries[entry].end - rom_entries[entry].start + 1;
+                if (read(flash, buf + rom_entries[entry].start,
+                         rom_entries[entry].start, len)) {
+                        perror("flash partial read failed.");
+                        return -1;
+                }
+                /* If file is specified, write this partition to file. */
+                if (write_content_to_file(entry, buf) < 0) return -1;
+
+                /* Skip to location after current romentry. */
+                start = rom_entries[entry].end + 1;
+                /* Catch overflow. */
+                if (!start)
+                        break;
+        }
+
+        return count;
+}