diff options
Diffstat (limited to 'external')
| -rw-r--r-- | external/gard/.gitignore | 3 | ||||
| -rw-r--r-- | external/gard/Makefile | 26 | ||||
| -rw-r--r-- | external/gard/config.h | 19 | ||||
| -rw-r--r-- | external/gard/gard.c | 777 | ||||
| -rw-r--r-- | external/gard/gard.h | 95 |
5 files changed, 920 insertions, 0 deletions
diff --git a/external/gard/.gitignore b/external/gard/.gitignore new file mode 100644 index 0000000..df7d675 --- /dev/null +++ b/external/gard/.gitignore @@ -0,0 +1,3 @@ +*.o +*.d +gard diff --git a/external/gard/Makefile b/external/gard/Makefile new file mode 100644 index 0000000..318501e --- /dev/null +++ b/external/gard/Makefile @@ -0,0 +1,26 @@ +# This tool is a linux userland tool and should be completely stand alone + +CC = $(CROSS_COMPILE)gcc +CFLAGS = -m64 -Werror -Wall -g2 -ggdb +LDFLAGS = -m64 +ASFLAGS = -m64 +CPPFLAGS = -I. -I../../ + +OBJS = file_flash.o gard.o libflash.o libffs.o ecc.o + +EXE = gard + +all: $(EXE) + +%.o: %.c + $(COMPILE.c) $< -o $@ + +%.o: ../../libflash/%.c + $(COMPILE.c) $< -o $@ + +$(EXE): $(OBJS) + $(LINK.o) -o $@ $^ + +clean: + rm -f $(OBJS) $(EXE) *.d + diff --git a/external/gard/config.h b/external/gard/config.h new file mode 100644 index 0000000..a132a01 --- /dev/null +++ b/external/gard/config.h @@ -0,0 +1,19 @@ +/* For CCAN */ + +#include <endian.h> +#include <byteswap.h> + +#define HAVE_TYPEOF 1 +#define HAVE_BUILTIN_TYPES_COMPATIBLE_P 1 + + +#if __BYTE_ORDER == __LITTLE_ENDIAN +#define HAVE_BIG_ENDIAN 0 +#define HAVE_LITTLE_ENDIAN 1 +#else +#define HAVE_BIG_ENDIAN 1 +#define HAVE_LITTLE_ENDIAN 0 +#endif + +#define HAVE_BYTESWAP_H 1 +#define HAVE_BSWAP_64 1 diff --git a/external/gard/gard.c b/external/gard/gard.c new file mode 100644 index 0000000..c43e05a --- /dev/null +++ b/external/gard/gard.c @@ -0,0 +1,777 @@ +/* Copyright 2013-2015 IBM Corp. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + * implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <err.h> +#include <fcntl.h> +#include <stdio.h> +#include <stdlib.h> +#include <errno.h> +#include <string.h> +#include <unistd.h> +#include <sys/mman.h> +#include <sys/stat.h> +#include <dirent.h> +#include <limits.h> + +#include <mtd/mtd-abi.h> + +#include <getopt.h> + +#include <libflash/libflash.h> +#include <libflash/libffs.h> +#include <libflash/file_flash.h> +#include <libflash/ecc.h> + +#include "gard.h" + +#define FDT_ACTIVE_FLASH_PATH "/proc/device-tree/chosen/ibm,system-flash" +#define SYSFS_MTD_PATH "/sys/class/mtd/" +#define FLASH_GARD_PART "GUARD" + +struct gard_ctx { + int fd; + bool readonly; + bool ecc; + uint32_t f_size; + uint32_t f_pos; + + uint32_t gard_part_idx; + uint32_t gard_data_pos; + uint32_t gard_data_len; + + struct spi_flash_ctrl *fct; + struct flash_chip *fch; + struct ffs_handle *ffs; +}; + +/* + * Return the size of a struct gard_ctx depending on if the buffer contains + * ECC bits + */ +static inline size_t sizeof_gard(struct gard_ctx *ctx) +{ + return ctx->ecc ? ECC_BUFFER_SIZE(sizeof(struct gard_record)) : sizeof(struct gard_record); +} + +static void show_flash_err(int rc) +{ + switch (rc) { + case FFS_ERR_BAD_MAGIC: + fprintf(stderr, "libffs bad magic\n"); + break; + case FFS_ERR_BAD_VERSION: + fprintf(stderr, "libffs bad version\n"); + break; + case FFS_ERR_BAD_CKSUM: + fprintf(stderr, "libffs bad check sum\n"); + break; + case FFS_ERR_PART_NOT_FOUND: + fprintf(stderr, "libffs flash partition not found\n"); + break; + /* ------- */ + case FLASH_ERR_MALLOC_FAILED: + fprintf(stderr, "libflash malloc failed\n"); + break; + case FLASH_ERR_CHIP_UNKNOWN: + fprintf(stderr, "libflash unknown flash chip\n"); + break; + case FLASH_ERR_PARM_ERROR: + fprintf(stderr, "libflash parameter error\n"); + break; + case FLASH_ERR_ERASE_BOUNDARY: + fprintf(stderr, "libflash erase boundary error\n"); + break; + case FLASH_ERR_WREN_TIMEOUT: + fprintf(stderr, "libflash WREN timeout\n"); + break; + case FLASH_ERR_WIP_TIMEOUT: + fprintf(stderr, "libflash WIP timeout\n"); + break; + case FLASH_ERR_VERIFY_FAILURE: + fprintf(stderr, "libflash verification failure\n"); + break; + case FLASH_ERR_4B_NOT_SUPPORTED: + fprintf(stderr, "libflash 4byte mode not supported\n"); + break; + case FLASH_ERR_CTRL_CONFIG_MISMATCH: + fprintf(stderr, "libflash control config mismatch\n"); + break; + case FLASH_ERR_CHIP_ER_NOT_SUPPORTED: + fprintf(stderr, "libflash chip not supported\n"); + break; + case FLASH_ERR_CTRL_CMD_UNSUPPORTED: + fprintf(stderr, "libflash unsupported control command\n"); + break; + case FLASH_ERR_CTRL_TIMEOUT: + fprintf(stderr, "libflash control timeout\n"); + break; + case FLASH_ERR_ECC_INVALID: + fprintf(stderr, "libflash ecc invalid\n"); + break; + default: + fprintf(stderr, "A libflash/libffs error has occured %d\n", rc); + } +} + +static const char *target_type_to_str(enum target_type t) +{ + switch (t) { + case TYPE_NA: + return "Not applicable"; + case TYPE_SYS: + return "System"; + case TYPE_NODE: + return "Node"; + case TYPE_DIMM: + return "Dimm"; + case TYPE_MEMBUF: + return "Memory Buffer"; + case TYPE_PROC: + return "Processor"; + case TYPE_EX: + return "EX"; + case TYPE_CORE: + return "Core"; + case TYPE_L2: + return "L2 cache"; + case TYPE_L3: + return "L3 cache"; + case TYPE_L4: + return "L4 cache"; + case TYPE_MCS: + return "MSC"; + case TYPE_MBA: + return "MBA"; + case TYPE_XBUS: + return "XBUS"; + case TYPE_ABUS: + return "ABUS"; + case TYPE_PCI: + return "PCI"; + case TYPE_DPSS: + return "DPSS"; + case TYPE_APSS: + return "APSS"; + case TYPE_OCC: + return "OCC"; + case TYPE_PSI: + return "PSI"; + case TYPE_FSP: + return "FSP"; + case TYPE_PNOR: + return "PNOR"; + case TYPE_OSC: + return "OSC"; + case TYPE_TODCLK: + return "Time of day clock"; + case TYPE_CONTROL_NODE: + return "Control Node"; + case TYPE_OSCREFCLK: + return "OSC Ref Clock"; + case TYPE_OSCPCICLK: + return "OSC PCI Clock"; + case TYPE_REFCLKENDPT: + return "Ref Clock"; + case TYPE_PCICLKENDPT: + return "PCI Clock"; + case TYPE_NX: + return "NX"; + case TYPE_PORE: + return "PORE"; + case TYPE_PCIESWITCH: + return "PCIE Switch"; + case TYPE_CAPP: + return "CAPP"; + case TYPE_FSI: + return "FSI"; + case TYPE_TEST_FAIL: + return "Test Fail"; + case TYPE_LAST_IN_RANGE: + return "Last"; + } + return "Unknown"; +} + +static const char *path_type_to_str(enum path_type t) +{ + switch (t) { + case PATH_NA: + return "not applicable"; + case PATH_AFFINITY: + return "affinity"; + case PATH_PHYSICAL: + return "physical"; + case PATH_DEVICE: + return "device"; + case PATH_POWER: + return "power"; + } + return "Unknown"; +} + +static bool get_dev_attr(const char *dev, const char *attr_file, uint32_t *attr) +{ + char dev_path[PATH_MAX] = SYSFS_MTD_PATH; + /* + * Needs to be large enough to hold at most uint32_t represented as a + * string in hex with leading 0x + */ + char attr_buf[10]; + int fd, rc; + + /* + * sizeof(dev_path) - (strlen(dev_path) + 1) is the remaining space in + * dev_path, + 1 to account for the '\0'. As strncat could write n+1 bytes + * to dev_path the correct calulcation for n is: + * (sizeof(dev_path) - (strlen(dev_path) + 1) - 1) + */ + strncat(dev_path, dev, (sizeof(dev_path) - (strlen(dev_path) + 1) - 1)); + strncat(dev_path, "/", (sizeof(dev_path) - (strlen(dev_path) + 1) - 1)); + strncat(dev_path, attr_file, (sizeof(dev_path) - (strlen(dev_path) + 1) - 1)); + fd = open(dev_path, O_RDONLY); + if (fd == -1) + goto out; + + rc = read(fd, attr_buf, sizeof(attr_buf)); + close(fd); + if (rc == -1) + goto out; + + if (attr) + *attr = strtol(attr_buf, NULL, 0); + + return 0; + +out: + fprintf(stderr, "Couldn't get MTD device attribute '%s' from '%s'\n", dev, attr_file); + return -1; +} + +static int open_from_dev(struct gard_ctx *ctx, const char *fdt_flash_path) +{ + struct dirent **namelist; + char fdt_node_path[PATH_MAX]; + int count, i, rc, fd; + bool done; + + if (!fdt_flash_path) + return -1; + + fd = open(fdt_flash_path, O_RDONLY); + if (fd == -1) { + fprintf(stderr, "Couldn't open '%s' FDT attribute to determine which flash device to use\n", + fdt_flash_path); + return -1; + } + + rc = read(fd, fdt_node_path, sizeof(fdt_node_path)); + close(fd); + if (rc == -1) { + fprintf(stderr, "Couldn't read flash FDT node from '%s'\n", fdt_flash_path); + return -1; + } + + count = scandir(SYSFS_MTD_PATH, &namelist, NULL, alphasort); + if (count == -1) { + fprintf(stderr, "Couldn't scan '%s' for MTD devices\n", SYSFS_MTD_PATH); + return -1; + } + + rc = 0; + done = false; + for (i = 0; i < count; i++) { + struct dirent *dirent; + char dev_path[PATH_MAX] = SYSFS_MTD_PATH; + char fdt_node_path_tmp[PATH_MAX]; + + dirent = namelist[i]; + if (dirent->d_name[0] == '.' || rc || done) { + free(namelist[i]); + continue; + } + + strncat(dev_path, dirent->d_name, sizeof(dev_path) - strlen(dev_path) - 2); + strncat(dev_path, "/device/of_node", sizeof(dev_path) - strlen(dev_path) - 2); + + rc = readlink(dev_path, fdt_node_path_tmp, sizeof(fdt_node_path_tmp) - 1); + if (rc == -1) { + /* + * This might fail because it could not exist if the system has flash + * devices that present as mtd but don't have corresponding FDT + * nodes, just continue silently. + */ + free(namelist[i]); + /* Should still try the next dir so reset rc */ + rc = 0; + continue; + } + fdt_node_path_tmp[rc] = '\0'; + + if (strstr(fdt_node_path_tmp, fdt_node_path)) { + uint32_t flags, size; + + /* + * size and flags could perhaps have be gotten another way but this + * method is super unlikely to fail so it will do. + */ + + /* Check to see if device is writeable */ + rc = get_dev_attr(dirent->d_name, "flags", &flags); + if (rc) { + free(namelist[i]); + continue; + } + + /* Get the size of the mtd device while we're at it */ + rc = get_dev_attr(dirent->d_name, "size", &size); + if (rc) { + free(namelist[i]); + continue; + } + + strcpy(dev_path, "/dev/"); + strncat(dev_path, dirent->d_name, sizeof(dev_path) - strlen(dev_path) - 2); + ctx->readonly = !(flags && MTD_WRITEABLE); + ctx->f_size = size; + ctx->fd = open(dev_path, ctx->readonly ? O_RDONLY : O_RDWR); + if (ctx->fd == -1) { + fprintf(stderr, "Couldn't open MTD device '%s' for %s as the system flash device\n", + dev_path, ctx->readonly ? "reading" : "read/write"); + rc = -1; + } + done = true; + } + + free(namelist[i]); + } + free(namelist); + + if (!done) + fprintf(stderr, "Couldn't find '%s' corresponding MTD\n", fdt_flash_path); + + /* explicit negative value so as to not return a libflash code */ + return done ? rc : -1; +} + +static int open_from_file(struct gard_ctx *ctx, const char *filename) +{ + struct stat sbuf; + int rc; + + rc = stat(filename, &sbuf); + if (rc == -1) { + fprintf(stderr, "Couldn't stat '%s' to use as flash data\n", filename); + return -1; + } + + ctx->fd = open(filename, O_RDWR); + if (ctx->fd == -1) { + fprintf(stderr, "Couldn't open '%s' to use as flash data\n", filename); + return -1; + } + + ctx->readonly = 0; + ctx->f_size = sbuf.st_size; + return 0; +} + +static int do_iterate(struct gard_ctx *ctx, + int (*func)(struct gard_ctx *ctx, int pos, + struct gard_record *gard, void *priv), + void *priv) +{ + int rc = 0; + unsigned int i; + struct gard_record gard, null_gard; + + memset(&null_gard, INT_MAX, sizeof(gard)); + for (i = 0; i * sizeof_gard(ctx) < ctx->gard_data_len && rc == 0; i++) { + memset(&gard, 0, sizeof(gard)); + + rc = flash_read_corrected(ctx->fch, ctx->gard_data_pos + + (i * sizeof_gard(ctx)), &gard, + sizeof(gard), ctx->ecc); + + /* It isn't super clear what constitutes the end, this should do */ + if (rc || memcmp(&gard, &null_gard, sizeof(gard)) == 0) + break; + + rc = func(ctx, i, &gard, priv); + } + + return rc; +} + +static int get_largest_pos_i(struct gard_ctx *ctx, int pos, struct gard_record *gard, void *priv) +{ + if (!priv) + return -1; + + *(int *)priv = pos; + + return 0; +} + +static int get_largest_pos(struct gard_ctx *ctx) +{ + int rc, largest = -1; + + rc = do_iterate(ctx, &get_largest_pos_i, &largest); + if (rc) + return -1; + + return largest; +} + +static int do_list_i(struct gard_ctx *ctx, int pos, struct gard_record *gard, void *priv) +{ + if (!gard) + return -1; + + printf("| %08x | %08x | %-15s |\n", be32toh(gard->record_id), + be32toh(gard->errlog_eid), path_type_to_str(gard->target_id.type_size >> PATH_TYPE_SHIFT)); + + return 0; +} + +static int do_list(struct gard_ctx *ctx, int argc, char **argv) +{ + int rc; + + /* No entries */ + if (get_largest_pos(ctx) == -1) { + printf("No GARD entries to display\n"); + rc = 0; + } else { + printf("| ID | Error | Type |\n"); + printf("+---------------------------------------+\n"); + rc = do_iterate(ctx, &do_list_i, NULL); + printf("+=======================================+\n"); + } + + return rc; +} + +static int do_show_i(struct gard_ctx *ctx, int pos, struct gard_record *gard, void *priv) +{ + uint32_t id; + + if (!priv || !gard) + return -1; + + id = *(uint32_t *)priv; + + if (be32toh(gard->record_id) == id) { + unsigned int count, i; + + printf("Record ID: 0x%08x\n", id); + printf("========================\n"); + printf("Error ID: 0x%08x\n", be32toh(gard->errlog_eid)); + printf("Error Type: 0x%02x\n", gard->error_type); + printf("Res Recovery: 0x%02x\n", gard->resource_recovery); + printf("Path Type: %s\n", path_type_to_str(gard->target_id.type_size >> PATH_TYPE_SHIFT)); + count = gard->target_id.type_size & PATH_ELEMENTS_MASK; + for (i = 0; i < count && i < MAX_PATH_ELEMENTS; i++) + printf("%*c%s, Instance #%d\n", i + 1, '>', target_type_to_str(gard->target_id.path_elements[i].target_type), + gard->target_id.path_elements[i].instance); + } + + return 0; +} + +static int do_show(struct gard_ctx *ctx, int argc, char **argv) +{ + uint32_t id; + int rc; + + if (argc != 2) { + fprintf(stderr, "%s option requires a GARD record\n", argv[0]); + return -1; + } + + id = strtoul(argv[1], NULL, 16); + + rc = do_iterate(ctx, &do_show_i, &id); + + return rc; +} + +static int do_clear_i(struct gard_ctx *ctx, int pos, struct gard_record *gard, void *priv) +{ + int largest, rc = 0; + char *buf; + struct gard_record null_gard; + + if (!gard || !ctx) + return -1; + + memset(&null_gard, INT_MAX, sizeof(null_gard)); + + if (!priv) { + if (pos != 0) + /* We erased everything on the first iteration, don't bother */ + return 0; + + printf("Erasing the entire gard partition..."); + rc = flash_erase(ctx->fch, ctx->gard_data_pos, ctx->gard_data_len); + if (rc) { + fprintf(stderr, "\nCouldn't erase flash partition at 0x%08x for size %u\n", + ctx->gard_data_pos, ctx->gard_data_len); + return rc; + } + printf("done\n"); + + largest = 0; + } else if (be32toh(gard->record_id) == *(uint32_t *)priv) { + largest = get_largest_pos(ctx); + if (largest < 0 || pos > largest) { + /* Something went horribly wrong */ + fprintf(stderr, "largest index out of range %d\n", largest); + return -1; + } + + if (pos < largest) { + /* We're not clearing the last record, shift all the records up */ + int buf_len = ((largest - pos) * sizeof(struct gard_record)); + int buf_pos = ctx->gard_data_pos + ((pos + 1) * sizeof_gard(ctx)); + buf = malloc(buf_len); + if (!buf) + return -ENOMEM; + + rc = flash_read_corrected(ctx->fch, buf_pos, buf, buf_len, ctx->ecc); + if (rc) { + free(buf); + fprintf(stderr, "Couldn't read from flash at 0x%08x for len 0x%08x\n", buf_pos, buf_len); + return rc; + } + + rc = flash_smart_write_corrected(ctx->fch, buf_pos - sizeof_gard(ctx), buf, buf_len, ctx->ecc); + free(buf); + if (rc) { + fprintf(stderr, "Couldn't write to flash at 0x%08lx for len 0x%08x\n", + buf_pos - sizeof_gard(ctx), buf_len); + return rc; + } + } + + printf("Cleared gard record with id ID 0x%08x\n", be32toh(gard->record_id)); + } + + /* Now wipe the last record */ + rc = flash_smart_write_corrected(ctx->fch, ctx->gard_data_pos + (largest * sizeof_gard(ctx)), + &null_gard, sizeof(null_gard), ctx->ecc); + + return rc; +} + +static int do_clear(struct gard_ctx *ctx, int argc, char **argv) +{ + int rc; + uint32_t id; + + if (argc != 2) { + fprintf(stderr, "%s option requires a GARD record or 'all'\n", argv[0]); + return -1; + } + + if (strncmp(argv[1], "all", strlen("all")) == 0) { + rc = do_iterate(ctx, do_clear_i, NULL); + } else { + id = strtoul(argv[1], NULL, 16); + rc = do_iterate(ctx, do_clear_i, &id); + } + + return rc; +} + +__attribute__ ((unused)) +static int do_nop(struct gard_ctx *ctx, int argc, char **argv) +{ + fprintf(stderr, "Unimplemented action '%s'\n", argv[0]); + return EXIT_SUCCESS; +} + +struct { + const char *name; + const char *desc; + int (*fn)(struct gard_ctx *, int, char **); +} actions[] = { + { "list", "List current GARD records", do_list }, + { "show", "Show details of a GARD record", do_show }, + { "clear", "Clear GARD records", do_clear }, +}; + +static void usage(const char *progname) +{ + unsigned int i; + + fprintf(stderr, "Usage: %s [-a -e -f <file> -p] <command> [<args>]\n\n", + progname); + fprintf(stderr, "-e --ecc\n\tForce reading/writing with ECC bytes.\n\n"); + fprintf(stderr, "-f --file <file>\n\tDon't search for MTD device," + " read from <file>.\n\n"); + fprintf(stderr, "-p --part\n\tUsed in conjunction with -f to specify" + "that just\n"); + fprintf(stderr, "\tthe GUARD partition is in <file> and libffs\n"); + fprintf(stderr, "\tshouldn't be used.\n\n"); + + + fprintf(stderr, "Where <command> is one of:\n\n"); + + for (i = 0; i < ARRAY_SIZE(actions); i++) { + fprintf(stderr, "\t%-7s\t%s\n", + actions[i].name, actions[i].desc); + } +} + +static struct option global_options[] = { + { "file", required_argument, 0, 'f' }, + { "part", no_argument, 0, 'p' }, + { "ecc", no_argument, 0, 'e' }, + { 0 }, +}; +static const char *global_optstring = "+ef:p"; + +int main(int argc, char **argv) +{ + const char *action, *progname, *filename = NULL; + const char *fdt_flash_path = FDT_ACTIVE_FLASH_PATH; + struct gard_ctx _ctx, *ctx; + int i, rc; + bool part = 0; + bool ecc = 0; + + progname = argv[0]; + + ctx = &_ctx; + memset(ctx, 0, sizeof(*ctx)); + + /* process global options */ + for (;;) { + int c; + + c = getopt_long(argc, argv, global_optstring, global_options, + NULL); + if (c == -1) + break; + switch (c) { + case 'e': + ecc = true; + break; + case 'f': + filename = optarg; + break; + case 'p': + part = true; + break; + case '?': + usage(progname); + return EXIT_FAILURE; + } + } + + /* + * It doesn't make sense to specify that we have the gard partition but + * read from flash + */ + if (part && !filename) { + usage(progname); + return EXIT_FAILURE; + } + + /* do we have a command? */ + if (optind == argc) { + usage(progname); + return EXIT_FAILURE; + } + + argc -= optind; + argv += optind; + action = argv[0]; + + if (!filename) + rc = open_from_dev(ctx, fdt_flash_path); + else + rc = open_from_file(ctx, filename); + + if (rc) + return EXIT_FAILURE; + + ctx->fct = build_flash_ctrl(ctx->fd); + if (!ctx->fct) + goto out; + + rc = flash_init(ctx->fct, &ctx->fch); + if (rc) + goto out1; + + if (!part) { + rc = ffs_open_flash(ctx->fch, 0, ctx->f_size, &ctx->ffs); + if (rc) + goto out2; + + rc = ffs_lookup_part(ctx->ffs, FLASH_GARD_PART, &ctx->gard_part_idx); + if (rc) + goto out3; + + rc = ffs_part_info(ctx->ffs, ctx->gard_part_idx, NULL, &(ctx->gard_data_pos), + &(ctx->gard_data_len), NULL, &(ctx->ecc)); + if (rc) + goto out3; + } else { + ctx->ecc = ecc; + ctx->gard_data_pos = 0; + ctx->gard_data_len = ctx->f_size; + } + + if (ctx->gard_data_len == 0 || ctx->gard_data_len % sizeof(struct gard_record) != 0) + /* Just warn for now */ + fprintf(stderr, "The %s partition doesn't appear to be an exact multiple of" + "gard records in size: %lu vs %u (or partition is zero in length)\n", + FLASH_GARD_PART, sizeof(struct gard_record), ctx->gard_data_len); + + for (i = 0; i < ARRAY_SIZE(actions); i++) { + if (!strcmp(actions[i].name, action)) { + rc = actions[i].fn(ctx, argc, argv); + break; + } + } + + if (i == ARRAY_SIZE(actions)) { + fprintf(stderr, "%s: '%s' isn't a valid command\n", progname, action); + usage(progname); + rc = EXIT_FAILURE; + } + +out3: + if (ctx->ffs) + ffs_close(ctx->ffs); +out2: + if (ctx->fch) + flash_exit(ctx->fch); +out1: + if (ctx->fch) + free_flash_ctrl(ctx->fct); +out: + close(ctx->fd); + + if (rc > 0) { + show_flash_err(rc); + if (filename && rc == FFS_ERR_BAD_MAGIC) + fprintf(stderr, "Maybe you didn't give a full flash image file?\nDid you mean '--part'?\n"); + } + return rc; +} diff --git a/external/gard/gard.h b/external/gard/gard.h new file mode 100644 index 0000000..26997ca --- /dev/null +++ b/external/gard/gard.h @@ -0,0 +1,95 @@ +/* Copyright 2013-2014 IBM Corp. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + * implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <stdint.h> + +#define MAX_PATH_ELEMENTS 10 +#define PATH_TYPE_SHIFT 4 +#define PATH_ELEMENTS_MASK (0x0F) + + +enum target_type { + TYPE_NA = 0x00000000, + TYPE_SYS = 0x00000001, + TYPE_NODE = 0x00000002, + TYPE_DIMM = 0x00000003, + TYPE_MEMBUF = 0x00000004, + TYPE_PROC = 0x00000005, + TYPE_EX = 0x00000006, + TYPE_CORE = 0x00000007, + TYPE_L2 = 0x00000008, + TYPE_L3 = 0x00000009, + TYPE_L4 = 0x0000000A, + TYPE_MCS = 0x0000000B, + TYPE_MBA = 0x0000000D, + TYPE_XBUS = 0x0000000E, + TYPE_ABUS = 0x0000000F, + TYPE_PCI = 0x00000010, + TYPE_DPSS = 0x00000011, + TYPE_APSS = 0x00000012, + TYPE_OCC = 0x00000013, + TYPE_PSI = 0x00000014, + TYPE_FSP = 0x00000015, + TYPE_PNOR = 0x00000016, + TYPE_OSC = 0x00000017, + TYPE_TODCLK = 0x00000018, + TYPE_CONTROL_NODE = 0x00000019, + TYPE_OSCREFCLK = 0x0000001A, + TYPE_OSCPCICLK = 0x0000001B, + TYPE_REFCLKENDPT = 0x0000001C, + TYPE_PCICLKENDPT = 0x0000001D, + TYPE_NX = 0x0000001E, + TYPE_PORE = 0x0000001F, + TYPE_PCIESWITCH = 0x00000020, + TYPE_CAPP = 0x00000021, + TYPE_FSI = 0x00000022, + TYPE_TEST_FAIL = 0x00000023, + TYPE_LAST_IN_RANGE = 0x00000024, +}; + +enum path_type { + PATH_NA = 0x00, + PATH_AFFINITY = 0x01, + PATH_PHYSICAL = 0x02, + PATH_DEVICE = 0x03, + PATH_POWER = 0x04, +}; + +struct path_element { + uint8_t target_type; + uint8_t instance; +} __attribute__((packed)); + +struct entity_path { + /* First 4 bits are a path_type enum */ + /* Second 4 bits are the amount of path_elements */ + uint8_t type_size; + struct path_element path_elements[MAX_PATH_ELEMENTS]; + +} __attribute__((packed)); + + +/* defined by hostboot */ +struct gard_record { + uint32_t record_id; + struct entity_path target_id; + uint8_t pad0[3]; + uint32_t errlog_eid; + uint8_t error_type; + uint8_t resource_recovery; + uint8_t pad1[6]; +} __attribute__((packed)); + |