LXR uboot/tools/vybridimage.c

   1/*
   2 * Image manipulator for Vybrid SoCs
   3 *
   4 * Derived from vybridimage.c
   5 *
   6 * (C) Copyright 2016  DENX Software Engineering GmbH
   7 * Written-by: Albert ARIBAUD <albert.aribaud@3adev.fr>
   8 *
   9 * SPDX-License-Identifier:     GPL-2.0+
  10 */
  11
  12#include "imagetool.h"
  13#include <compiler.h>
  14#include <image.h>
  15
  16/*
  17 * NAND page 0 boot header
  18 */
  19
  20struct nand_page_0_boot_header {
  21        union {
  22                uint32_t fcb[128];
  23                uint8_t fcb_bytes[512];
  24        };                              /* 0x00000000 - 0x000001ff */
  25        uint8_t  sw_ecc[512];           /* 0x00000200 - 0x000003ff */
  26        uint32_t padding[65280];        /* 0x00000400 - 0x0003ffff */
  27        uint8_t ivt_prefix[1024];       /* 0x00040000 - 0x000403ff */
  28};
  29
  30/* signature byte for a readable block */
  31
  32static struct nand_page_0_boot_header vybridimage_header;
  33
  34static int vybridimage_check_image_types(uint8_t type)
  35{
  36        if (type == IH_TYPE_VYBRIDIMAGE)
  37                return EXIT_SUCCESS;
  38        return EXIT_FAILURE;
  39}
  40
  41static uint8_t vybridimage_sw_ecc(uint8_t byte)
  42{
  43        uint8_t bit0  = (byte & (1 << 0)) ? 1 : 0;
  44        uint8_t bit1  = (byte & (1 << 1)) ? 1 : 0;
  45        uint8_t bit2  = (byte & (1 << 2)) ? 1 : 0;
  46        uint8_t bit3  = (byte & (1 << 3)) ? 1 : 0;
  47        uint8_t bit4  = (byte & (1 << 4)) ? 1 : 0;
  48        uint8_t bit5  = (byte & (1 << 5)) ? 1 : 0;
  49        uint8_t bit6  = (byte & (1 << 6)) ? 1 : 0;
  50        uint8_t bit7  = (byte & (1 << 7)) ? 1 : 0;
  51        uint8_t res = 0;
  52
  53        res |= ((bit6 ^ bit5 ^ bit3 ^ bit2) << 0);
  54        res |= ((bit7 ^ bit5 ^ bit4 ^ bit2 ^ bit1) << 1);
  55        res |= ((bit7 ^ bit6 ^ bit5 ^ bit1 ^ bit0) << 2);
  56        res |= ((bit7 ^ bit4 ^ bit3 ^ bit0) << 3);
  57        res |= ((bit6 ^ bit4 ^ bit3 ^ bit2 ^ bit1 ^ bit0) << 4);
  58
  59        return res;
  60}
  61
  62static int vybridimage_verify_header(unsigned char *ptr, int image_size,
  63                        struct image_tool_params *params)
  64{
  65        struct nand_page_0_boot_header *hdr =
  66                (struct nand_page_0_boot_header *)ptr;
  67        int idx;
  68
  69        if (hdr->fcb[1] != 0x46434220)
  70                return -1;
  71        if (hdr->fcb[2] != 1)
  72                return -1;
  73        if (hdr->fcb[7] != 64)
  74                return -1;
  75        if (hdr->fcb[14] != 6)
  76                return -1;
  77        if (hdr->fcb[30] != 0x0001ff00)
  78                return -1;
  79        if (hdr->fcb[43] != 1)
  80                return -1;
  81        if (hdr->fcb[54] != 0)
  82                return -1;
  83        if (hdr->fcb[55] != 8)
  84                return -1;
  85
  86        /* check software ECC */
  87        for (idx = 0; idx < sizeof(hdr->fcb_bytes); idx++) {
  88                uint8_t sw_ecc = vybridimage_sw_ecc(hdr->fcb_bytes[idx]);
  89                if (sw_ecc != hdr->sw_ecc[idx])
  90                        return -1;
  91        }
  92
  93        return 0;
  94}
  95
  96static void vybridimage_set_header(void *ptr, struct stat *sbuf, int ifd,
  97                                struct image_tool_params *params)
  98{
  99        struct nand_page_0_boot_header *hdr =
 100                (struct nand_page_0_boot_header *)ptr;
 101        int idx;
 102
 103        /* fill header with 0x00 for first 56 entries then 0xff */
 104        memset(&hdr->fcb[0], 0x0, 56*sizeof(uint32_t));
 105        memset(&hdr->fcb[56], 0xff, 72*sizeof(uint32_t));
 106        /* fill SW ecc and padding with 0xff */
 107        memset(&hdr->sw_ecc[0], 0xff, sizeof(hdr->sw_ecc));
 108        memset(&hdr->padding[0], 0xff, sizeof(hdr->padding));
 109        /* fill IVT prefix with 0x00 */
 110        memset(&hdr->ivt_prefix[0], 0x00, sizeof(hdr->ivt_prefix));
 111
 112        /* populate fcb */
 113        hdr->fcb[1] = 0x46434220; /* signature */
 114        hdr->fcb[2] = 0x00000001; /* version */
 115        hdr->fcb[5] = 2048; /* page size */
 116        hdr->fcb[6] = (2048+64); /* page + OOB size */
 117        hdr->fcb[7] = 64; /* pages per block */
 118        hdr->fcb[14] = 6; /* ECC mode 6 */
 119        hdr->fcb[26] = 128; /* fw address (0x40000) in 2K pages */
 120        hdr->fcb[27] = 128; /* fw address (0x40000) in 2K pages */
 121        hdr->fcb[30] = 0x0001ff00; /* DBBT search area start address */
 122        hdr->fcb[33] = 2048; /* BB marker physical offset */
 123        hdr->fcb[43] = 1; /* DISBBM */
 124        hdr->fcb[54] = 0; /* DISBB_Search */
 125        hdr->fcb[55] = 8; /* Bad block search limit */
 126
 127        /* compute software ECC */
 128        for (idx = 0; idx < sizeof(hdr->fcb_bytes); idx++)
 129                hdr->sw_ecc[idx] = vybridimage_sw_ecc(hdr->fcb_bytes[idx]);
 130}
 131
 132static void vybridimage_print_hdr_field(struct nand_page_0_boot_header *hdr,
 133        int idx)
 134{
 135        printf("header.fcb[%d] = %08x\n", idx, hdr->fcb[idx]);
 136}
 137
 138static void vybridimage_print_header(const void *ptr)
 139{
 140        struct nand_page_0_boot_header *hdr =
 141                (struct nand_page_0_boot_header *)ptr;
 142        int idx;
 143
 144        for (idx = 0; idx < 56; idx++)
 145                vybridimage_print_hdr_field(hdr, idx);
 146}
 147
 148/*
 149 * vybridimage parameters
 150 */
 151U_BOOT_IMAGE_TYPE(
 152        vybridimage,
 153        "Vybrid Boot Image",
 154        sizeof(vybridimage_header),
 155        (void *)&vybridimage_header,
 156        NULL,
 157        vybridimage_verify_header,
 158        vybridimage_print_header,
 159        vybridimage_set_header,
 160        NULL,
 161        vybridimage_check_image_types,
 162        NULL,
 163        NULL
 164);
 165