225 lines
5.9 KiB
C
225 lines
5.9 KiB
C
/* 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.
|
|
*/
|
|
/*
|
|
* Copyright (c) International Business Machines Corp., 2012
|
|
*
|
|
* FSP Flash Structure
|
|
*
|
|
* This header defines the layout for the FSP Flash Structure.
|
|
*/
|
|
|
|
#ifndef __FFS_H__
|
|
#define __FFS_H__
|
|
|
|
/* Pull in the correct header depending on what is being built */
|
|
#ifndef __SKIBOOT__
|
|
#include <linux/types.h>
|
|
#else
|
|
#include <stdint.h>
|
|
#endif
|
|
#include <ccan/short_types/short_types.h>
|
|
#include <ccan/endian/endian.h>
|
|
#include <ccan/list/list.h>
|
|
|
|
#include "libffs.h"
|
|
|
|
/* The version of this partition implementation */
|
|
#define FFS_VERSION_1 1
|
|
|
|
/* Magic number for the partition header (ASCII 'PART') */
|
|
#define FFS_MAGIC 0x50415254
|
|
|
|
/* pid of logical partitions/containers */
|
|
#define FFS_PID_TOPLEVEL 0xFFFFFFFF
|
|
|
|
/*
|
|
* Type of image contained w/in partition
|
|
*/
|
|
enum ffs_type {
|
|
FFS_TYPE_DATA = 1,
|
|
FFS_TYPE_LOGICAL = 2,
|
|
FFS_TYPE_PARTITION = 3,
|
|
};
|
|
|
|
/*
|
|
* Flag bit definitions
|
|
*/
|
|
#define FFS_FLAGS_PROTECTED 0x0001
|
|
#define FFS_FLAGS_U_BOOT_ENV 0x0002
|
|
|
|
/* Data integrity flags */
|
|
#define FFS_ENRY_INTEG_ECC 0x8000
|
|
|
|
/*
|
|
* User verCheck definitions
|
|
*/
|
|
#define FFS_VERCHECK_SHA512V 0x80
|
|
#define FFS_VERCHECK_SHA512EC 0x40
|
|
|
|
/*
|
|
* User miscFlags
|
|
*/
|
|
#define FFS_MISCFLAGS_PRESERVED 0x80
|
|
#define FFS_MISCFLAGS_READONLY 0x40
|
|
#define FFS_MISCFLAGS_BACKUP 0x20
|
|
#define FFS_MISCFLAGS_REPROVISION 0x10
|
|
#define FFS_MISCFLAGS_VOLATILE 0x08
|
|
#define FFS_MISCFLAGS_CLEARECC 0x04
|
|
#define FFS_MISCFLAGS_GOLDEN 0x01
|
|
|
|
/**
|
|
* struct __ffs_entry_user - On flash user data entries
|
|
*
|
|
* Represents the on flash layout of FFS structures
|
|
*
|
|
* @chip: Chip Select (0,1)
|
|
* @compressType: Compression Indication/alg (0=not compressed)
|
|
* @dataInteg: Indicates Data Integrity mechanism
|
|
* @verCheck: Indicates Version check type
|
|
* @miscFlags: Misc Partition related Flags
|
|
* @freeMisc[2]: Unused Miscellaneious Info
|
|
* @freeUser[14]: Unused User Data
|
|
*/
|
|
struct __ffs_entry_user {
|
|
uint8_t chip;
|
|
uint8_t compresstype;
|
|
be16 datainteg;
|
|
uint8_t vercheck;
|
|
uint8_t miscflags;
|
|
uint8_t freemisc[2];
|
|
be32 reserved[14];
|
|
} __attribute__ ((packed));
|
|
|
|
/**
|
|
* struct __ffs_entry - On flash partition entry
|
|
*
|
|
* Represents the on flash layout of FFS structures
|
|
* Note: Unlike the in memory structures base and size of the entry are in
|
|
* units of block_size and the actual size is in bytes
|
|
*
|
|
* @name: Opaque null terminated string
|
|
* @base: Starting offset of partition in flash (in hdr.block_size)
|
|
* @size: Partition size (in hdr.block_size)
|
|
* @pid: Parent partition entry (FFS_PID_TOPLEVEL for toplevel)
|
|
* @id: Partition entry ID [1..65536]
|
|
* @type: Describe type of partition
|
|
* @flags: Partition attributes (optional)
|
|
* @actual: Actual partition size (in bytes)
|
|
* @resvd: Reserved words for future use
|
|
* @user: User data (optional)
|
|
* @checksum: Partition entry checksum (includes all above)
|
|
*/
|
|
struct __ffs_entry {
|
|
char name[FFS_PART_NAME_MAX + 1];
|
|
be32 base;
|
|
be32 size;
|
|
be32 pid;
|
|
be32 id;
|
|
be32 type;
|
|
be32 flags;
|
|
be32 actual;
|
|
be32 resvd[4];
|
|
struct __ffs_entry_user user;
|
|
/* The checksum is actually endian agnostic */
|
|
uint32_t checksum;
|
|
} __attribute__ ((packed));
|
|
|
|
/**
|
|
* struct ffs_entry - Partition entry
|
|
*
|
|
* Useable in memory representation of a struct __ffs_entry
|
|
* Note: Unlike the on flash structure, all sizes here are in bytes!
|
|
*
|
|
* @name: Opaque null terminated string
|
|
* @base: Starting offset of partition in flash (in bytes)
|
|
* @size: Partition size (in bytes)
|
|
* @actual: Actual partition size (in bytes)
|
|
* @pid: Parent partition entry (FFS_PID_TOPLEVEL for toplevel)
|
|
* @type: Describe type of partition
|
|
* @flags: Partition attributes (optional)
|
|
* @user: User data (optional)
|
|
* @ref: Refcount
|
|
*/
|
|
struct ffs_entry {
|
|
char name[FFS_PART_NAME_MAX + 1];
|
|
uint32_t base;
|
|
uint32_t size;
|
|
uint32_t actual;
|
|
uint32_t pid;
|
|
enum ffs_type type;
|
|
uint32_t flags;
|
|
struct ffs_entry_user user;
|
|
unsigned int ref;
|
|
};
|
|
|
|
|
|
/**
|
|
* struct __ffs_hdr - On flash FSP Flash Structure header
|
|
*
|
|
* Represents the on flash layout of FFS structures
|
|
* Note: Beware that the size of the partition table is in units of block_size
|
|
*
|
|
* @magic: Eye catcher/corruption detector
|
|
* @version: Version of the structure
|
|
* @size: Size of partition table (in block_size)
|
|
* @entry_size: Size of struct ffs_entry element (in bytes)
|
|
* @entry_count: Number of struct ffs_entry elements in @entries array
|
|
* @block_size: Size of block on device (in bytes)
|
|
* @block_count: Number of blocks on device
|
|
* @resvd[4]: Reserved words for future use
|
|
* @checksum: Header checksum
|
|
* @entries: Pointer to array of partition entries
|
|
*/
|
|
struct __ffs_hdr {
|
|
be32 magic;
|
|
be32 version;
|
|
be32 size;
|
|
be32 entry_size;
|
|
be32 entry_count;
|
|
be32 block_size;
|
|
be32 block_count;
|
|
be32 resvd[4];
|
|
/* The checksum is actually endian agnostic */
|
|
uint32_t checksum;
|
|
struct __ffs_entry entries[];
|
|
} __attribute__ ((packed));
|
|
|
|
/**
|
|
* struct ffs_hdr - FSP Flash Structure header
|
|
*
|
|
* Useable in memory representation of a struct __ffs_hdr
|
|
* Note: All sizes here are in bytes
|
|
*
|
|
* @version: Version of the structure
|
|
* @size: Size of partition table (in bytes)
|
|
* @block_size: Size of block on device (in bytes)
|
|
* @block_count: Number of blocks on device.
|
|
* @count: Count of the number of entires
|
|
* @entries: Array of partition entries.
|
|
*/
|
|
struct ffs_hdr {
|
|
uint32_t version;
|
|
uint32_t size;
|
|
uint32_t block_size;
|
|
uint32_t block_count;
|
|
uint32_t count;
|
|
struct ffs_entry *part;
|
|
struct ffs_entry **entries;
|
|
unsigned int entries_size;
|
|
};
|
|
|
|
#endif /* __FFS_H__ */
|