--- /dev/null
+/******************************************************************************
+ * Copyright (c) 2004, 2008 IBM Corporation
+ * All rights reserved.
+ * This program and the accompanying materials
+ * are made available under the terms of the BSD License
+ * which accompanies this distribution, and is available at
+ * http://www.opensource.org/licenses/bsd-license.php
+ *
+ * Contributors:
+ * IBM Corporation - initial implementation
+ *****************************************************************************/
+
+#include <cpu.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <hw.h>
+#include <rtas.h>
+#include "rtas_board.h"
+#include <bmc.h>
+#include "rtas_flash.h"
+#include <flash/block_lists.h>
+#include "product.h"
+#include "calculatecrc.h"
+
+#undef DEBUG
+
+#ifdef DEBUG
+#define dprintf(_x ...) printf(_x)
+#else
+#define dprintf(_x ...)
+#endif
+
+static uint64_t size;
+static uint64_t flashOffset;
+
+unsigned char manage_flash_buffer[BUFSIZE*2];
+unsigned long check_flash_image(unsigned long rombase, unsigned long length,
+ unsigned long start_crc);
+
+#ifdef DEBUG
+static void
+dump_blocklist(uint64_t *bl, int version)
+{
+ uint64_t bl_size;
+ uint8_t *addr = (uint8_t *)bl;
+
+ if (version == 1) {
+ /* version 1 blocklist */
+ bl_size = *bl & 0x00FFFFFFFFFFFFFFUL;
+
+ } else {
+ bl_size = *bl;
+ }
+
+ printf("\n\rblocklist_dump %lx", bl_size);
+ while (bl_size) {
+ unsigned int tmpCnt = bl_size;
+ unsigned char x;
+ if (tmpCnt > 8)
+ tmpCnt = 8;
+ printf("\n\r%08x: ", addr);
+ /* print hex */
+ while (tmpCnt--) {
+ set_ci();
+ x = *addr++;
+ clr_ci();
+ printf("%02x ", x);
+ }
+ tmpCnt = bl_size;
+ if (tmpCnt > 8)
+ tmpCnt = 8;
+ bl_size -= tmpCnt;
+ /* reset addr ptr to print ascii */
+ addr = addr - tmpCnt;
+ /* print ascii */
+ while (tmpCnt--) {
+ set_ci();
+ x = *addr++;
+ clr_ci();
+ if ((x < 32) || (x >= 127)) {
+ /* non-printable char */
+ x = '.';
+ }
+ printf("%c", x);
+ }
+ }
+ printf("\r\n");
+}
+#endif
+
+void
+rtas_dump_flash(rtas_args_t *rtas_args)
+{
+ int retVal = 0;
+ unsigned int size = rtas_args->args[0];
+ unsigned int offset = rtas_args->args[1];
+ volatile unsigned char *flash = (volatile unsigned char *)FLASH;
+
+ printf("\n\rflash_dump %x %x", size, offset);
+ flash += offset;
+ while (size) {
+ unsigned int tmpCnt = size;
+ unsigned char x;
+ if (tmpCnt > 16)
+ tmpCnt = 16;
+ printf("\n\r%p: ", flash);
+ /* print hex */
+ while (tmpCnt--) {
+ set_ci();
+ x = *flash++;
+ clr_ci();
+ printf("%02x ", x);
+ }
+ tmpCnt = size;
+ if (tmpCnt > 16)
+ tmpCnt = 16;
+ size -= tmpCnt;
+ /* reset flash ptr to print ascii */
+ flash = flash - tmpCnt;
+ /* print ascii */
+ while (tmpCnt--) {
+ set_ci();
+ x = *flash++;
+ clr_ci();
+ if ((x < 32) || (x >= 127)) {
+ /* non-printable char */
+ x = '.';
+ }
+ printf("%c", x);
+ }
+ }
+ printf("\r\n");
+ rtas_args->args[rtas_args->nargs] = retVal;
+}
+
+
+static void
+print_block(int i)
+{
+ int counter = 8;
+
+ while (counter--)
+ printf("\b");
+ printf("%08x", i);
+}
+
+
+
+/* To enter data mode after flash has been in programming mode
+ * a 0xFF has to be written */
+static void
+enter_data_mode(void)
+{
+ volatile unsigned char *flash = (volatile unsigned char *)FLASH;
+
+ set_ci();
+ *flash = 0xFF;
+ eieio();
+ clr_ci();
+}
+
+
+static void
+erase_flash_block(unsigned long offset)
+{
+ volatile unsigned char *flash = (volatile unsigned char *)FLASH;
+
+ flash += offset;
+ set_ci();
+ *flash = 0x20;
+ eieio();
+ *flash = 0xd0;
+ eieio();
+ while (!(*flash & 0x80)) ;
+ clr_ci();
+}
+
+
+void
+write_flash(unsigned long offset, unsigned char *data)
+{
+ int cnt = 32;
+ volatile unsigned char *flash = (volatile unsigned char *)FLASH;
+
+ flash += (offset + flashOffset);
+ set_ci();
+ while (cnt) {
+ if (!((uint64_t)flash & 0x1F)) {
+ while (cnt) {
+ uint64_t tmpcnt = cnt;
+ if (tmpcnt > 0x20)
+ tmpcnt = 0x20;
+ do {
+ *flash = 0xE8;
+ eieio();
+ } while (!(*flash & 0x80));
+ cnt -= tmpcnt;
+ *flash = tmpcnt - 1;
+ while (tmpcnt--) {
+ *flash++ = *data++;
+ }
+ *flash = 0xD0;
+ eieio();
+ while (!(*flash & 0x80)) ;
+ }
+ break;
+ }
+ *flash = 0x40;
+ eieio();
+ *flash++ = *data++;
+ eieio();
+ while (!(*flash & 0x80)) ;
+ cnt--;
+ }
+ clr_ci();
+}
+
+static void
+write_flash_page(unsigned long offset, unsigned short *data)
+{
+ int i = 0;
+
+ for (i = 0; i < BUFSIZE; i += 32, offset += 32) {
+ write_flash(offset, ((unsigned char *)data + i));
+ }
+}
+
+/*
+ * 0 reject temporary image
+ * 1 commit temporary image
+ * */
+static int
+copy_flash(short mode)
+{
+ volatile unsigned char *flash = (volatile unsigned char *)FLASH;
+ uint64_t blockCnt;
+ uint64_t hash = 0;
+ short notmode = mode ^ 0x1;
+
+ if (bmc_set_flashside(notmode) != notmode) {
+ return -1;
+ }
+ printf("\r\nErasing Flash: 0x ");
+
+ for (blockCnt = 0; blockCnt <= FLASHSIZE; blockCnt += FLASH_BLOCK_SIZE) {
+ print_block(blockCnt);
+ erase_flash_block(blockCnt);
+ }
+ enter_data_mode();
+ progress = FLASHSIZE / 38;
+ print_writing();
+
+ for (blockCnt = 0; blockCnt <= FLASHSIZE; blockCnt += BUFSIZE) {
+ uint64_t *srcPtr = (uint64_t *)(flash + blockCnt);
+ uint64_t *destPtr = (uint64_t *)manage_flash_buffer;
+ uint64_t cnt = BUFSIZE / 8;
+ if (bmc_set_flashside(mode) != mode) {
+ return -1;
+ }
+ enter_data_mode();
+ set_ci();
+ while (cnt--) {
+ *destPtr++ = *srcPtr++;
+ }
+ clr_ci();
+
+ if (bmc_set_flashside(notmode) != notmode) {
+ return -1;
+ }
+ write_flash_page(blockCnt,
+ (unsigned short *)manage_flash_buffer);
+
+ /* progress output... */
+ print_progress();
+ if (blockCnt > hash * progress) {
+ print_hash();
+ hash++;
+ }
+ }
+ enter_data_mode();
+ if (bmc_set_flashside(mode) != mode) {
+ return -1;
+ }
+ printf("\b#\n");
+ return 0;
+}
+
+/*
+ * Function: ibm_manage_flash_image
+ * Input:
+ * r3: rtas parm structure
+ * token: 46
+ * in: 1
+ * out: 1
+ * parm0: 0 reject temporary image
+ * 1 commit temporary image
+ * Output:
+ * parm1: Status (hw -1, busy -2, parameter error -3
+ * -9001 cannot overwrite the active firmware image)
+ *
+ */
+
+void
+rtas_ibm_manage_flash_image(rtas_args_t *rtas_args)
+{
+ int side;
+ int result = 0;
+ short mode = rtas_args->args[0];
+
+ if (mode < 0 || mode > 1) {
+ rtas_args->args[rtas_args->nargs] = -3;
+ return;
+ }
+ side = bmc_get_flashside();
+ if (side == 0) {
+ /* we are on the permanent side */
+ if (mode != 0) {
+ rtas_args->args[rtas_args->nargs] = -9001;
+ return;
+ }
+ } else if (side == 1) {
+ /* we are on the temporary side */
+ if (mode != 1) {
+ rtas_args->args[rtas_args->nargs] = -9001;
+ return;
+ }
+ } else {
+ rtas_args->args[rtas_args->nargs] = -1;
+ return;
+ }
+
+ result = copy_flash(mode);
+ bmc_set_flashside(mode);
+ enter_data_mode();
+ rtas_args->args[rtas_args->nargs] = result;
+}
+
+/**
+ * check, if we find the FLASHFS_MAGIC token in bl
+ **/
+static uint8_t
+check_magic(uint64_t *bl, int version)
+{
+ struct stH *pHeader;
+
+ if (version == 1) {
+ /* version 1 blocklist */
+ /* if block list size <= 0x10, it is only block list header */
+ /* and address of block list extension, so look at the extension... */
+ while ((*bl & 0x00FFFFFFFFFFFFFFUL) <= 0x10)
+ bl = (uint64_t *)bl[1];
+
+ /* block list item 2 _should_ be the address of our flashfs image */
+ pHeader = (struct stH *)(bl[2] + 0x28);
+ /* printf("FlashFS Magic: \"%#s\"\r\n", pHeader->magic); */
+ return strncmp(pHeader->magic, FLASHFS_MAGIC, 8);
+ } else {
+ /* block list item 1 _should_ be the address of our flashfs image */
+ pHeader = (struct stH *)(bl[1] + 0x28);
+ /* printf("FlashFS Magic: \"%#s\"\r\n", pHeader->magic); */
+ return strncmp(pHeader->magic, FLASHFS_MAGIC, 8);
+ }
+}
+
+static void
+get_image_name(char *buffer, int maxsize)
+{
+ volatile struct stH *flash_header = (volatile struct stH *)(SB_FLASH_adr + 0x28);
+ /* since we cannot read the fh_magic directly from flash as a string, we need to copy it to memory */
+ uint64_t magic_val = 0;
+ uint64_t addr;
+
+ /* copy fh_magic to magic_val since, we cannot use it as a string from flash */
+ magic_val = load64_ci((uint64_t)(flash_header->magic));
+ if (strncmp((char *)&magic_val, FLASHFS_MAGIC, 8)) {
+ /* magic does not match */
+ sprintf(buffer, "Unknown");
+ buffer[maxsize - 1] = '\0';
+ return;
+ }
+ addr = (uint64_t)flash_header->version;
+ while (--maxsize) {
+ *buffer = load8_ci(addr++);
+ if (!*buffer++)
+ return;
+ }
+ *buffer = '\0';
+}
+
+/**
+ * validate_flash_image
+ * this function checks if the flash will be updated with the given image
+ * @param args[0] - buffer with minimum 4K of the image to flash
+ * @param args[1] - size of the buffer
+ * @param args[2] - status:
+ * 0 success
+ * -1 hw
+ * -2 busy
+ * -3 parameter error
+ * @param args[3] - update result token
+ */
+void
+rtas_ibm_validate_flash_image(rtas_args_t *rtas_args)
+{
+ dprintf("\nrtas_ibm_validate_flash_image\n");
+ unsigned long new_image = rtas_args->args[0];
+ char *ret_str = (char *)new_image;
+ struct stH *flash_header = (struct stH *)(new_image + 0x28);
+ char current_temp_version[16];
+ char current_perm_version[16];
+ char new_version[16];
+ int side = bmc_get_flashside();
+
+ /* fill args[0] with the current values which is needed
+ * in an error case */
+
+ bmc_set_flashside(0);
+ get_image_name(current_perm_version, sizeof(current_perm_version));
+ bmc_set_flashside(1);
+ get_image_name(current_temp_version, sizeof(current_temp_version));
+ bmc_set_flashside(side);
+
+ /* check if the candidate image if valid for this platform */
+ if (strncmp(flash_header->magic, FLASHFS_MAGIC, 8)) {
+ /* magic does not match */
+ rtas_args->args[rtas_args->nargs] = 0;
+ /* No update done, the candidate image is
+ * not valid for this platform */
+ rtas_args->args[rtas_args->nargs + 1] = 2;
+ sprintf(ret_str, "MI %s %s\xaMI %s %s",
+ current_temp_version, current_perm_version,
+ current_temp_version, current_perm_version);
+ return;
+ }
+
+ if (strncmp(flash_header->platform_name, (char *)sig_org, 32)) {
+ /* this image if for a different board */
+ rtas_args->args[rtas_args->nargs] = 0;
+ /* No update done, the candidate image is
+ * not valid for this platform */
+ rtas_args->args[rtas_args->nargs + 1] = 2;
+ sprintf(ret_str, "MI %s %s\xaMI %s %s",
+ current_temp_version, current_perm_version,
+ current_temp_version, current_perm_version);
+ return;
+ }
+
+ /* check header crc */
+ if (check_flash_image(rtas_args->args[0], 0x88, 0)) {
+ /* header crc failed */
+ rtas_args->args[rtas_args->nargs] = 0;
+ /* No update done, the candidate image is
+ * not valid for this platform */
+ rtas_args->args[rtas_args->nargs + 1] = 2;
+ sprintf(ret_str, "MI %s %s\xaMI %s %s",
+ current_temp_version, current_perm_version,
+ current_temp_version, current_perm_version);
+ return;
+ }
+ memcpy(new_version, flash_header->version, 16);
+ sprintf(ret_str, "MI %s %s\xaMI %s %s", current_temp_version,
+ current_perm_version, new_version, current_perm_version);
+ rtas_args->args[rtas_args->nargs] = 0;
+
+ if (strncmp(new_version, current_temp_version, 16) >= 0)
+ rtas_args->args[rtas_args->nargs + 1] = 0;
+ else
+ rtas_args->args[rtas_args->nargs + 1] = 6;
+}
+
+/*
+ * Function: ibm_update_flash_64
+ * Input:
+ * r3: rtas parm structure
+ * token: 7
+ * in: 1
+ * out: 1
+ * parm0: A real pointer to a block list
+ * Output:
+ * parm1: Status (hw -1, bad image -3, programming failed -4)
+ *
+ * Description: flash if addresses above 4GB have to be addressed
+ */
+void
+rtas_update_flash(rtas_args_t *rtas_args)
+{
+ void *bl = (void *)(uint64_t)rtas_args->args[0];
+ int version = get_block_list_version((unsigned char *)bl);
+ uint64_t erase_size;
+ unsigned int i;
+ int perm_check = 1;
+
+#ifdef DEBUG
+ dump_blocklist(bl, version);
+#endif
+
+ /* from SLOF we pass a second (unofficial) parameter, if this parameter is 1, we do not
+ * check wether we are on permanent side. Needed for update-flash -c to work! */
+ if ((rtas_args->nargs > 1) && (rtas_args->args[1] == 1))
+ perm_check = 0;
+
+ /* check magic string */
+ printf("\r\nChecking magic string : ");
+ if (check_magic(bl, version) != 0) {
+ printf("failed!\n");
+ rtas_args->args[rtas_args->nargs] = -3; /* bad image */
+ return;
+ }
+ printf("succeeded!\n");
+
+ /* check platform */
+ printf("Checking platform : ");
+ if (check_platform(bl, 0x48, version) == -1) {
+ printf("failed!\n");
+ rtas_args->args[rtas_args->nargs] = -3; /* bad image */
+ return;
+ }
+ printf("succeeded!\n");
+
+ /* checkcrc */
+ printf("Checking CRC : ");
+ /* the actual CRC is included at the end of the flash image, thus the resulting CRC must be 0! */
+ if (image_check_crc(bl, version) != 0) {
+ printf("failed!\n");
+ rtas_args->args[1] = -3; /* bad image */
+ return;
+ }
+ printf("succeeded!\n");
+
+ /* check if we are running on P
+ * if so, let's switch to temp and flash temp */
+ if (bmc_get_flashside() == 0 && perm_check) {
+ printf("Set flashside: ");
+ bmc_set_flashside(1);
+ printf("Temp!\n");
+ }
+
+#ifdef DEBUG
+ rtas_args_t ra;
+ ra.args[0] = 0x100; /* size; */
+ ra.args[1] = flashOffset;
+ ra.nargs = 2;
+
+ rtas_dump_flash(&ra);
+ printf("\n");
+#endif
+
+ size = get_size(bl, version);
+ erase_size = (size + (FLASH_BLOCK_SIZE - 1)) & ~(FLASH_BLOCK_SIZE - 1);
+ dprintf("Erasing: size: %#x, erase_size: %#x, FLASH_BLOCK_SIZE: %#x\n",
+ size, erase_size, FLASH_BLOCK_SIZE);
+
+ progress = size / 39;
+ printf("Erasing : 0x%08x", 0);
+ for (i = 0; i < erase_size; i += FLASH_BLOCK_SIZE) {
+ print_block(i);
+ erase_flash_block(i);
+ }
+
+ enter_data_mode();
+#ifdef DEBUG
+ rtas_dump_flash(&ra);
+ printf("\n");
+#endif
+ print_writing();
+ write_block_list(bl, version);
+ printf("\b#\n");
+ enter_data_mode();
+
+#ifdef DEBUG
+ rtas_dump_flash(&ra);
+ printf("\n");
+#endif
+
+ /* checkcrc */
+ printf("Recheck CRC : ");
+ if (check_flash_image(FLASH + flashOffset, size, 0) != 0) {
+ /* failed */
+ printf("failed!\n\r");
+ dprintf("flash_addr: %#x, flashOffset: %#x, size: %#x\n", FLASH,
+ flashOffset, size);
+ dprintf("crc: %#x\n",
+ check_flash_image(FLASH + flashOffset, size, 0));
+ rtas_args->args[rtas_args->nargs] = -4; /* programming failed */
+ return;
+ }
+ printf("succeeded!\n");
+ rtas_args->args[rtas_args->nargs] = 0;
+}
+
+/*
+ * Function: ibm_update_flash_64_and_reboot
+ * Input:
+ * r3: rtas parm structure
+ * token: 27
+ * in: 1
+ * out: 1
+ * parm0: A real pointer to a block list
+ * Output:
+ * parm1: Status (hw -1, bad image -3, programming failed -4)
+ * Currently -4 and -1 are not returned
+ *
+ * Description: flash and reboot if addresses above 4GB have to be addressed
+ */
+void
+rtas_ibm_update_flash_64_and_reboot(rtas_args_t *rtas_args)
+{
+ rtas_update_flash(rtas_args);
+ dprintf("rc: %#d\n", rtas_args->args[rtas_args->nargs]);
+ if (rtas_args->args[rtas_args->nargs] == 0) {
+ rtas_system_reboot(rtas_args);
+ }
+}
Code Review / kvmfornfv.git / blobdiff