A lot changed in the Linux MTD code, since it was last ported from Linux to U-Boot. This patch takes U-Boot NAND support to the level of Linux 2.6.22.1 and will enable support for very large NAND devices (4KB pages) and ease the compatibility between U-Boot and Linux filesystems. This patch is tested on two custom boards with PPC and ARM processors running YAFFS in U-Boot and Linux using gcc-4.1.2 cross compilers. MAKEALL ppc/arm has some issues: * DOC/OneNand/nand_spl is not building (I have not tried porting these parts, and since I do not have any HW and I am not familiar with this code/HW I think its best left to someone else.) Except for the issues mentioned above, I have ported all drivers necessary to run MAKEALL ppc/arm without errors and warnings. Many drivers were trivial to port, but some were not so trivial. The following drivers must be examined carefully and maybe rewritten to some degree: cpu/ppc4xx/ndfc.c cpu/arm926ejs/davinci/nand.c board/delta/nand.c board/zylonite/nand.c Signed-off-by: William Juul <william.juul@tandberg.com> Signed-off-by: Stig Olsen <stig.olsen@tandberg.com> Signed-off-by: Scott Wood <scottwood@freescale.com>master
William Juul
17 years ago
committed by
Scott Wood
parent
cd82919e6c
commit
cfa460adfd
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,45 @@ |
||||
#ifndef _LINUX_ERR_H |
||||
#define _LINUX_ERR_H |
||||
|
||||
/* XXX U-BOOT XXX */ |
||||
#if 0 |
||||
#include <linux/compiler.h> |
||||
#else |
||||
#include <linux/mtd/compat.h> |
||||
#endif |
||||
|
||||
#include <asm/errno.h> |
||||
|
||||
|
||||
/*
|
||||
* Kernel pointers have redundant information, so we can use a |
||||
* scheme where we can return either an error code or a dentry |
||||
* pointer with the same return value. |
||||
* |
||||
* This should be a per-architecture thing, to allow different |
||||
* error and pointer decisions. |
||||
*/ |
||||
#define MAX_ERRNO 4095 |
||||
|
||||
#ifndef __ASSEMBLY__ |
||||
|
||||
#define IS_ERR_VALUE(x) unlikely((x) >= (unsigned long)-MAX_ERRNO) |
||||
|
||||
static inline void *ERR_PTR(long error) |
||||
{ |
||||
return (void *) error; |
||||
} |
||||
|
||||
static inline long PTR_ERR(const void *ptr) |
||||
{ |
||||
return (long) ptr; |
||||
} |
||||
|
||||
static inline long IS_ERR(const void *ptr) |
||||
{ |
||||
return IS_ERR_VALUE((unsigned long)ptr); |
||||
} |
||||
|
||||
#endif |
||||
|
||||
#endif /* _LINUX_ERR_H */ |
||||
@ -0,0 +1,81 @@ |
||||
/*
|
||||
* $Id: blktrans.h,v 1.6 2005/11/07 11:14:54 gleixner Exp $ |
||||
* |
||||
* (C) 2003 David Woodhouse <dwmw2@infradead.org> |
||||
* |
||||
* Interface to Linux block layer for MTD 'translation layers'. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef __MTD_TRANS_H__ |
||||
#define __MTD_TRANS_H__ |
||||
|
||||
/* XXX U-BOOT XXX */ |
||||
#if 0 |
||||
#include <linux/mutex.h> |
||||
#else |
||||
#include <linux/list.h> |
||||
#endif |
||||
|
||||
struct hd_geometry; |
||||
struct mtd_info; |
||||
struct mtd_blktrans_ops; |
||||
struct file; |
||||
struct inode; |
||||
|
||||
struct mtd_blktrans_dev { |
||||
struct mtd_blktrans_ops *tr; |
||||
struct list_head list; |
||||
struct mtd_info *mtd; |
||||
/* XXX U-BOOT XXX */ |
||||
#if 0 |
||||
struct mutex lock; |
||||
#endif |
||||
int devnum; |
||||
unsigned long size; |
||||
int readonly; |
||||
void *blkcore_priv; /* gendisk in 2.5, devfs_handle in 2.4 */ |
||||
}; |
||||
|
||||
struct blkcore_priv; /* Differs for 2.4 and 2.5 kernels; private */ |
||||
|
||||
struct mtd_blktrans_ops { |
||||
char *name; |
||||
int major; |
||||
int part_bits; |
||||
int blksize; |
||||
int blkshift; |
||||
|
||||
/* Access functions */ |
||||
int (*readsect)(struct mtd_blktrans_dev *dev, |
||||
unsigned long block, char *buffer); |
||||
int (*writesect)(struct mtd_blktrans_dev *dev, |
||||
unsigned long block, char *buffer); |
||||
|
||||
/* Block layer ioctls */ |
||||
int (*getgeo)(struct mtd_blktrans_dev *dev, struct hd_geometry *geo); |
||||
int (*flush)(struct mtd_blktrans_dev *dev); |
||||
|
||||
/* Called with mtd_table_mutex held; no race with add/remove */ |
||||
int (*open)(struct mtd_blktrans_dev *dev); |
||||
int (*release)(struct mtd_blktrans_dev *dev); |
||||
|
||||
/* Called on {de,}registration and on subsequent addition/removal
|
||||
of devices, with mtd_table_mutex held. */ |
||||
void (*add_mtd)(struct mtd_blktrans_ops *tr, struct mtd_info *mtd); |
||||
void (*remove_dev)(struct mtd_blktrans_dev *dev); |
||||
|
||||
struct list_head devs; |
||||
struct list_head list; |
||||
struct module *owner; |
||||
|
||||
struct mtd_blkcore_priv *blkcore_priv; |
||||
}; |
||||
|
||||
extern int register_mtd_blktrans(struct mtd_blktrans_ops *tr); |
||||
extern int deregister_mtd_blktrans(struct mtd_blktrans_ops *tr); |
||||
extern int add_mtd_blktrans_dev(struct mtd_blktrans_dev *dev); |
||||
extern int del_mtd_blktrans_dev(struct mtd_blktrans_dev *dev); |
||||
|
||||
|
||||
#endif /* __MTD_TRANS_H__ */ |
||||
@ -0,0 +1,91 @@ |
||||
/*
|
||||
* $Id: inftl-user.h,v 1.2 2005/11/07 11:14:56 gleixner Exp $ |
||||
* |
||||
* Parts of INFTL headers shared with userspace |
||||
* |
||||
*/ |
||||
|
||||
#ifndef __MTD_INFTL_USER_H__ |
||||
#define __MTD_INFTL_USER_H__ |
||||
|
||||
#define OSAK_VERSION 0x5120 |
||||
#define PERCENTUSED 98 |
||||
|
||||
#define SECTORSIZE 512 |
||||
|
||||
/* Block Control Information */ |
||||
|
||||
struct inftl_bci { |
||||
uint8_t ECCsig[6]; |
||||
uint8_t Status; |
||||
uint8_t Status1; |
||||
} __attribute__((packed)); |
||||
|
||||
struct inftl_unithead1 { |
||||
uint16_t virtualUnitNo; |
||||
uint16_t prevUnitNo; |
||||
uint8_t ANAC; |
||||
uint8_t NACs; |
||||
uint8_t parityPerField; |
||||
uint8_t discarded; |
||||
} __attribute__((packed)); |
||||
|
||||
struct inftl_unithead2 { |
||||
uint8_t parityPerField; |
||||
uint8_t ANAC; |
||||
uint16_t prevUnitNo; |
||||
uint16_t virtualUnitNo; |
||||
uint8_t NACs; |
||||
uint8_t discarded; |
||||
} __attribute__((packed)); |
||||
|
||||
struct inftl_unittail { |
||||
uint8_t Reserved[4]; |
||||
uint16_t EraseMark; |
||||
uint16_t EraseMark1; |
||||
} __attribute__((packed)); |
||||
|
||||
union inftl_uci { |
||||
struct inftl_unithead1 a; |
||||
struct inftl_unithead2 b; |
||||
struct inftl_unittail c; |
||||
}; |
||||
|
||||
struct inftl_oob { |
||||
struct inftl_bci b; |
||||
union inftl_uci u; |
||||
}; |
||||
|
||||
|
||||
/* INFTL Media Header */ |
||||
|
||||
struct INFTLPartition { |
||||
__u32 virtualUnits; |
||||
__u32 firstUnit; |
||||
__u32 lastUnit; |
||||
__u32 flags; |
||||
__u32 spareUnits; |
||||
__u32 Reserved0; |
||||
__u32 Reserved1; |
||||
} __attribute__((packed)); |
||||
|
||||
struct INFTLMediaHeader { |
||||
char bootRecordID[8]; |
||||
__u32 NoOfBootImageBlocks; |
||||
__u32 NoOfBinaryPartitions; |
||||
__u32 NoOfBDTLPartitions; |
||||
__u32 BlockMultiplierBits; |
||||
__u32 FormatFlags; |
||||
__u32 OsakVersion; |
||||
__u32 PercentUsed; |
||||
struct INFTLPartition Partitions[4]; |
||||
} __attribute__((packed)); |
||||
|
||||
/* Partition flag types */ |
||||
#define INFTL_BINARY 0x20000000 |
||||
#define INFTL_BDTL 0x40000000 |
||||
#define INFTL_LAST 0x80000000 |
||||
|
||||
#endif /* __MTD_INFTL_USER_H__ */ |
||||
|
||||
|
||||
@ -0,0 +1,35 @@ |
||||
/*
|
||||
* $Id: jffs2-user.h,v 1.1 2004/05/05 11:57:54 dwmw2 Exp $ |
||||
* |
||||
* JFFS2 definitions for use in user space only |
||||
*/ |
||||
|
||||
#ifndef __JFFS2_USER_H__ |
||||
#define __JFFS2_USER_H__ |
||||
|
||||
/* This file is blessed for inclusion by userspace */ |
||||
#include <linux/jffs2.h> |
||||
#include <endian.h> |
||||
#include <byteswap.h> |
||||
|
||||
#undef cpu_to_je16 |
||||
#undef cpu_to_je32 |
||||
#undef cpu_to_jemode |
||||
#undef je16_to_cpu |
||||
#undef je32_to_cpu |
||||
#undef jemode_to_cpu |
||||
|
||||
extern int target_endian; |
||||
|
||||
#define t16(x) ({ uint16_t __b = (x); (target_endian==__BYTE_ORDER)?__b:bswap_16(__b); }) |
||||
#define t32(x) ({ uint32_t __b = (x); (target_endian==__BYTE_ORDER)?__b:bswap_32(__b); }) |
||||
|
||||
#define cpu_to_je16(x) ((jint16_t){t16(x)}) |
||||
#define cpu_to_je32(x) ((jint32_t){t32(x)}) |
||||
#define cpu_to_jemode(x) ((jmode_t){t32(x)}) |
||||
|
||||
#define je16_to_cpu(x) (t16((x).v16)) |
||||
#define je32_to_cpu(x) (t32((x).v32)) |
||||
#define jemode_to_cpu(x) (t32((x).m)) |
||||
|
||||
#endif /* __JFFS2_USER_H__ */ |
||||
@ -0,0 +1,76 @@ |
||||
/*
|
||||
* $Id: nftl-user.h,v 1.2 2005/11/07 11:14:56 gleixner Exp $ |
||||
* |
||||
* Parts of NFTL headers shared with userspace |
||||
* |
||||
*/ |
||||
|
||||
#ifndef __MTD_NFTL_USER_H__ |
||||
#define __MTD_NFTL_USER_H__ |
||||
|
||||
/* Block Control Information */ |
||||
|
||||
struct nftl_bci { |
||||
unsigned char ECCSig[6]; |
||||
uint8_t Status; |
||||
uint8_t Status1; |
||||
}__attribute__((packed)); |
||||
|
||||
/* Unit Control Information */ |
||||
|
||||
struct nftl_uci0 { |
||||
uint16_t VirtUnitNum; |
||||
uint16_t ReplUnitNum; |
||||
uint16_t SpareVirtUnitNum; |
||||
uint16_t SpareReplUnitNum; |
||||
} __attribute__((packed)); |
||||
|
||||
struct nftl_uci1 { |
||||
uint32_t WearInfo; |
||||
uint16_t EraseMark; |
||||
uint16_t EraseMark1; |
||||
} __attribute__((packed)); |
||||
|
||||
struct nftl_uci2 { |
||||
uint16_t FoldMark; |
||||
uint16_t FoldMark1; |
||||
uint32_t unused; |
||||
} __attribute__((packed)); |
||||
|
||||
union nftl_uci { |
||||
struct nftl_uci0 a; |
||||
struct nftl_uci1 b; |
||||
struct nftl_uci2 c; |
||||
}; |
||||
|
||||
struct nftl_oob { |
||||
struct nftl_bci b; |
||||
union nftl_uci u; |
||||
}; |
||||
|
||||
/* NFTL Media Header */ |
||||
|
||||
struct NFTLMediaHeader { |
||||
char DataOrgID[6]; |
||||
uint16_t NumEraseUnits; |
||||
uint16_t FirstPhysicalEUN; |
||||
uint32_t FormattedSize; |
||||
unsigned char UnitSizeFactor; |
||||
} __attribute__((packed)); |
||||
|
||||
#define MAX_ERASE_ZONES (8192 - 512) |
||||
|
||||
#define ERASE_MARK 0x3c69 |
||||
#define SECTOR_FREE 0xff |
||||
#define SECTOR_USED 0x55 |
||||
#define SECTOR_IGNORE 0x11 |
||||
#define SECTOR_DELETED 0x00 |
||||
|
||||
#define FOLD_MARK_IN_PROGRESS 0x5555 |
||||
|
||||
#define ZONE_GOOD 0xff |
||||
#define ZONE_BAD_ORIGINAL 0 |
||||
#define ZONE_BAD_MARKED 7 |
||||
|
||||
|
||||
#endif /* __MTD_NFTL_USER_H__ */ |
||||
@ -0,0 +1,360 @@ |
||||
/*
|
||||
* Copyright (c) International Business Machines Corp., 2006 |
||||
* |
||||
* 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; either version 2 of the License, or |
||||
* (at your option) any later version. |
||||
* |
||||
* This program is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See |
||||
* the GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with this program; if not, write to the Free Software |
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
||||
* |
||||
* Authors: Artem Bityutskiy (Битюцкий Артём) |
||||
* Thomas Gleixner |
||||
* Frank Haverkamp |
||||
* Oliver Lohmann |
||||
* Andreas Arnez |
||||
*/ |
||||
|
||||
/*
|
||||
* This file defines the layout of UBI headers and all the other UBI on-flash |
||||
* data structures. May be included by user-space. |
||||
*/ |
||||
|
||||
#ifndef __UBI_HEADER_H__ |
||||
#define __UBI_HEADER_H__ |
||||
|
||||
#include <asm/byteorder.h> |
||||
|
||||
/* The version of UBI images supported by this implementation */ |
||||
#define UBI_VERSION 1 |
||||
|
||||
/* The highest erase counter value supported by this implementation */ |
||||
#define UBI_MAX_ERASECOUNTER 0x7FFFFFFF |
||||
|
||||
/* The initial CRC32 value used when calculating CRC checksums */ |
||||
#define UBI_CRC32_INIT 0xFFFFFFFFU |
||||
|
||||
/* Erase counter header magic number (ASCII "UBI#") */ |
||||
#define UBI_EC_HDR_MAGIC 0x55424923 |
||||
/* Volume identifier header magic number (ASCII "UBI!") */ |
||||
#define UBI_VID_HDR_MAGIC 0x55424921 |
||||
|
||||
/*
|
||||
* Volume type constants used in the volume identifier header. |
||||
* |
||||
* @UBI_VID_DYNAMIC: dynamic volume |
||||
* @UBI_VID_STATIC: static volume |
||||
*/ |
||||
enum { |
||||
UBI_VID_DYNAMIC = 1, |
||||
UBI_VID_STATIC = 2 |
||||
}; |
||||
|
||||
/*
|
||||
* Compatibility constants used by internal volumes. |
||||
* |
||||
* @UBI_COMPAT_DELETE: delete this internal volume before anything is written |
||||
* to the flash |
||||
* @UBI_COMPAT_RO: attach this device in read-only mode |
||||
* @UBI_COMPAT_PRESERVE: preserve this internal volume - do not touch its |
||||
* physical eraseblocks, don't allow the wear-leveling unit to move them |
||||
* @UBI_COMPAT_REJECT: reject this UBI image |
||||
*/ |
||||
enum { |
||||
UBI_COMPAT_DELETE = 1, |
||||
UBI_COMPAT_RO = 2, |
||||
UBI_COMPAT_PRESERVE = 4, |
||||
UBI_COMPAT_REJECT = 5 |
||||
}; |
||||
|
||||
/*
|
||||
* ubi16_t/ubi32_t/ubi64_t - 16, 32, and 64-bit integers used in UBI on-flash |
||||
* data structures. |
||||
*/ |
||||
typedef struct { |
||||
uint16_t int16; |
||||
} __attribute__ ((packed)) ubi16_t; |
||||
|
||||
typedef struct { |
||||
uint32_t int32; |
||||
} __attribute__ ((packed)) ubi32_t; |
||||
|
||||
typedef struct { |
||||
uint64_t int64; |
||||
} __attribute__ ((packed)) ubi64_t; |
||||
|
||||
/*
|
||||
* In this implementation of UBI uses the big-endian format for on-flash |
||||
* integers. The below are the corresponding conversion macros. |
||||
*/ |
||||
#define cpu_to_ubi16(x) ((ubi16_t){__cpu_to_be16(x)}) |
||||
#define ubi16_to_cpu(x) ((uint16_t)__be16_to_cpu((x).int16)) |
||||
|
||||
#define cpu_to_ubi32(x) ((ubi32_t){__cpu_to_be32(x)}) |
||||
#define ubi32_to_cpu(x) ((uint32_t)__be32_to_cpu((x).int32)) |
||||
|
||||
#define cpu_to_ubi64(x) ((ubi64_t){__cpu_to_be64(x)}) |
||||
#define ubi64_to_cpu(x) ((uint64_t)__be64_to_cpu((x).int64)) |
||||
|
||||
/* Sizes of UBI headers */ |
||||
#define UBI_EC_HDR_SIZE sizeof(struct ubi_ec_hdr) |
||||
#define UBI_VID_HDR_SIZE sizeof(struct ubi_vid_hdr) |
||||
|
||||
/* Sizes of UBI headers without the ending CRC */ |
||||
#define UBI_EC_HDR_SIZE_CRC (UBI_EC_HDR_SIZE - sizeof(ubi32_t)) |
||||
#define UBI_VID_HDR_SIZE_CRC (UBI_VID_HDR_SIZE - sizeof(ubi32_t)) |
||||
|
||||
/**
|
||||
* struct ubi_ec_hdr - UBI erase counter header. |
||||
* @magic: erase counter header magic number (%UBI_EC_HDR_MAGIC) |
||||
* @version: version of UBI implementation which is supposed to accept this |
||||
* UBI image |
||||
* @padding1: reserved for future, zeroes |
||||
* @ec: the erase counter |
||||
* @vid_hdr_offset: where the VID header starts |
||||
* @data_offset: where the user data start |
||||
* @padding2: reserved for future, zeroes |
||||
* @hdr_crc: erase counter header CRC checksum |
||||
* |
||||
* The erase counter header takes 64 bytes and has a plenty of unused space for |
||||
* future usage. The unused fields are zeroed. The @version field is used to |
||||
* indicate the version of UBI implementation which is supposed to be able to |
||||
* work with this UBI image. If @version is greater then the current UBI |
||||
* version, the image is rejected. This may be useful in future if something |
||||
* is changed radically. This field is duplicated in the volume identifier |
||||
* header. |
||||
* |
||||
* The @vid_hdr_offset and @data_offset fields contain the offset of the the |
||||
* volume identifier header and user data, relative to the beginning of the |
||||
* physical eraseblock. These values have to be the same for all physical |
||||
* eraseblocks. |
||||
*/ |
||||
struct ubi_ec_hdr { |
||||
ubi32_t magic; |
||||
uint8_t version; |
||||
uint8_t padding1[3]; |
||||
ubi64_t ec; /* Warning: the current limit is 31-bit anyway! */ |
||||
ubi32_t vid_hdr_offset; |
||||
ubi32_t data_offset; |
||||
uint8_t padding2[36]; |
||||
ubi32_t hdr_crc; |
||||
} __attribute__ ((packed)); |
||||
|
||||
/**
|
||||
* struct ubi_vid_hdr - on-flash UBI volume identifier header. |
||||
* @magic: volume identifier header magic number (%UBI_VID_HDR_MAGIC) |
||||
* @version: UBI implementation version which is supposed to accept this UBI |
||||
* image (%UBI_VERSION) |
||||
* @vol_type: volume type (%UBI_VID_DYNAMIC or %UBI_VID_STATIC) |
||||
* @copy_flag: if this logical eraseblock was copied from another physical |
||||
* eraseblock (for wear-leveling reasons) |
||||
* @compat: compatibility of this volume (%0, %UBI_COMPAT_DELETE, |
||||
* %UBI_COMPAT_IGNORE, %UBI_COMPAT_PRESERVE, or %UBI_COMPAT_REJECT) |
||||
* @vol_id: ID of this volume |
||||
* @lnum: logical eraseblock number |
||||
* @leb_ver: version of this logical eraseblock (IMPORTANT: obsolete, to be |
||||
* removed, kept only for not breaking older UBI users) |
||||
* @data_size: how many bytes of data this logical eraseblock contains |
||||
* @used_ebs: total number of used logical eraseblocks in this volume |
||||
* @data_pad: how many bytes at the end of this physical eraseblock are not |
||||
* used |
||||
* @data_crc: CRC checksum of the data stored in this logical eraseblock |
||||
* @padding1: reserved for future, zeroes |
||||
* @sqnum: sequence number |
||||
* @padding2: reserved for future, zeroes |
||||
* @hdr_crc: volume identifier header CRC checksum |
||||
* |
||||
* The @sqnum is the value of the global sequence counter at the time when this |
||||
* VID header was created. The global sequence counter is incremented each time |
||||
* UBI writes a new VID header to the flash, i.e. when it maps a logical |
||||
* eraseblock to a new physical eraseblock. The global sequence counter is an |
||||
* unsigned 64-bit integer and we assume it never overflows. The @sqnum |
||||
* (sequence number) is used to distinguish between older and newer versions of |
||||
* logical eraseblocks. |
||||
* |
||||
* There are 2 situations when there may be more then one physical eraseblock |
||||
* corresponding to the same logical eraseblock, i.e., having the same @vol_id |
||||
* and @lnum values in the volume identifier header. Suppose we have a logical |
||||
* eraseblock L and it is mapped to the physical eraseblock P. |
||||
* |
||||
* 1. Because UBI may erase physical eraseblocks asynchronously, the following |
||||
* situation is possible: L is asynchronously erased, so P is scheduled for |
||||
* erasure, then L is written to,i.e. mapped to another physical eraseblock P1, |
||||
* so P1 is written to, then an unclean reboot happens. Result - there are 2 |
||||
* physical eraseblocks P and P1 corresponding to the same logical eraseblock |
||||
* L. But P1 has greater sequence number, so UBI picks P1 when it attaches the |
||||
* flash. |
||||
* |
||||
* 2. From time to time UBI moves logical eraseblocks to other physical |
||||
* eraseblocks for wear-leveling reasons. If, for example, UBI moves L from P |
||||
* to P1, and an unclean reboot happens before P is physically erased, there |
||||
* are two physical eraseblocks P and P1 corresponding to L and UBI has to |
||||
* select one of them when the flash is attached. The @sqnum field says which |
||||
* PEB is the original (obviously P will have lower @sqnum) and the copy. But |
||||
* it is not enough to select the physical eraseblock with the higher sequence |
||||
* number, because the unclean reboot could have happen in the middle of the |
||||
* copying process, so the data in P is corrupted. It is also not enough to |
||||
* just select the physical eraseblock with lower sequence number, because the |
||||
* data there may be old (consider a case if more data was added to P1 after |
||||
* the copying). Moreover, the unclean reboot may happen when the erasure of P |
||||
* was just started, so it result in unstable P, which is "mostly" OK, but |
||||
* still has unstable bits. |
||||
* |
||||
* UBI uses the @copy_flag field to indicate that this logical eraseblock is a |
||||
* copy. UBI also calculates data CRC when the data is moved and stores it at |
||||
* the @data_crc field of the copy (P1). So when UBI needs to pick one physical |
||||
* eraseblock of two (P or P1), the @copy_flag of the newer one (P1) is |
||||
* examined. If it is cleared, the situation* is simple and the newer one is |
||||
* picked. If it is set, the data CRC of the copy (P1) is examined. If the CRC |
||||
* checksum is correct, this physical eraseblock is selected (P1). Otherwise |
||||
* the older one (P) is selected. |
||||
* |
||||
* Note, there is an obsolete @leb_ver field which was used instead of @sqnum |
||||
* in the past. But it is not used anymore and we keep it in order to be able |
||||
* to deal with old UBI images. It will be removed at some point. |
||||
* |
||||
* There are 2 sorts of volumes in UBI: user volumes and internal volumes. |
||||
* Internal volumes are not seen from outside and are used for various internal |
||||
* UBI purposes. In this implementation there is only one internal volume - the |
||||
* layout volume. Internal volumes are the main mechanism of UBI extensions. |
||||
* For example, in future one may introduce a journal internal volume. Internal |
||||
* volumes have their own reserved range of IDs. |
||||
* |
||||
* The @compat field is only used for internal volumes and contains the "degree |
||||
* of their compatibility". It is always zero for user volumes. This field |
||||
* provides a mechanism to introduce UBI extensions and to be still compatible |
||||
* with older UBI binaries. For example, if someone introduced a journal in |
||||
* future, he would probably use %UBI_COMPAT_DELETE compatibility for the |
||||
* journal volume. And in this case, older UBI binaries, which know nothing |
||||
* about the journal volume, would just delete this volume and work perfectly |
||||
* fine. This is similar to what Ext2fs does when it is fed by an Ext3fs image |
||||
* - it just ignores the Ext3fs journal. |
||||
* |
||||
* The @data_crc field contains the CRC checksum of the contents of the logical |
||||
* eraseblock if this is a static volume. In case of dynamic volumes, it does |
||||
* not contain the CRC checksum as a rule. The only exception is when the |
||||
* data of the physical eraseblock was moved by the wear-leveling unit, then |
||||
* the wear-leveling unit calculates the data CRC and stores it in the |
||||
* @data_crc field. And of course, the @copy_flag is %in this case. |
||||
* |
||||
* The @data_size field is used only for static volumes because UBI has to know |
||||
* how many bytes of data are stored in this eraseblock. For dynamic volumes, |
||||
* this field usually contains zero. The only exception is when the data of the |
||||
* physical eraseblock was moved to another physical eraseblock for |
||||
* wear-leveling reasons. In this case, UBI calculates CRC checksum of the |
||||
* contents and uses both @data_crc and @data_size fields. In this case, the |
||||
* @data_size field contains data size. |
||||
* |
||||
* The @used_ebs field is used only for static volumes and indicates how many |
||||
* eraseblocks the data of the volume takes. For dynamic volumes this field is |
||||
* not used and always contains zero. |
||||
* |
||||
* The @data_pad is calculated when volumes are created using the alignment |
||||
* parameter. So, effectively, the @data_pad field reduces the size of logical |
||||
* eraseblocks of this volume. This is very handy when one uses block-oriented |
||||
* software (say, cramfs) on top of the UBI volume. |
||||
*/ |
||||
struct ubi_vid_hdr { |
||||
ubi32_t magic; |
||||
uint8_t version; |
||||
uint8_t vol_type; |
||||
uint8_t copy_flag; |
||||
uint8_t compat; |
||||
ubi32_t vol_id; |
||||
ubi32_t lnum; |
||||
ubi32_t leb_ver; /* obsolete, to be removed, don't use */ |
||||
ubi32_t data_size; |
||||
ubi32_t used_ebs; |
||||
ubi32_t data_pad; |
||||
ubi32_t data_crc; |
||||
uint8_t padding1[4]; |
||||
ubi64_t sqnum; |
||||
uint8_t padding2[12]; |
||||
ubi32_t hdr_crc; |
||||
} __attribute__ ((packed)); |
||||
|
||||
/* Internal UBI volumes count */ |
||||
#define UBI_INT_VOL_COUNT 1 |
||||
|
||||
/*
|
||||
* Starting ID of internal volumes. There is reserved room for 4096 internal |
||||
* volumes. |
||||
*/ |
||||
#define UBI_INTERNAL_VOL_START (0x7FFFFFFF - 4096) |
||||
|
||||
/* The layout volume contains the volume table */ |
||||
|
||||
#define UBI_LAYOUT_VOL_ID UBI_INTERNAL_VOL_START |
||||
#define UBI_LAYOUT_VOLUME_EBS 2 |
||||
#define UBI_LAYOUT_VOLUME_NAME "layout volume" |
||||
#define UBI_LAYOUT_VOLUME_COMPAT UBI_COMPAT_REJECT |
||||
|
||||
/* The maximum number of volumes per one UBI device */ |
||||
#define UBI_MAX_VOLUMES 128 |
||||
|
||||
/* The maximum volume name length */ |
||||
#define UBI_VOL_NAME_MAX 127 |
||||
|
||||
/* Size of the volume table record */ |
||||
#define UBI_VTBL_RECORD_SIZE sizeof(struct ubi_vtbl_record) |
||||
|
||||
/* Size of the volume table record without the ending CRC */ |
||||
#define UBI_VTBL_RECORD_SIZE_CRC (UBI_VTBL_RECORD_SIZE - sizeof(ubi32_t)) |
||||
|
||||
/**
|
||||
* struct ubi_vtbl_record - a record in the volume table. |
||||
* @reserved_pebs: how many physical eraseblocks are reserved for this volume |
||||
* @alignment: volume alignment |
||||
* @data_pad: how many bytes are unused at the end of the each physical |
||||
* eraseblock to satisfy the requested alignment |
||||
* @vol_type: volume type (%UBI_DYNAMIC_VOLUME or %UBI_STATIC_VOLUME) |
||||
* @upd_marker: if volume update was started but not finished |
||||
* @name_len: volume name length |
||||
* @name: the volume name |
||||
* @padding2: reserved, zeroes |
||||
* @crc: a CRC32 checksum of the record |
||||
* |
||||
* The volume table records are stored in the volume table, which is stored in |
||||
* the layout volume. The layout volume consists of 2 logical eraseblock, each |
||||
* of which contains a copy of the volume table (i.e., the volume table is |
||||
* duplicated). The volume table is an array of &struct ubi_vtbl_record |
||||
* objects indexed by the volume ID. |
||||
* |
||||
* If the size of the logical eraseblock is large enough to fit |
||||
* %UBI_MAX_VOLUMES records, the volume table contains %UBI_MAX_VOLUMES |
||||
* records. Otherwise, it contains as many records as it can fit (i.e., size of |
||||
* logical eraseblock divided by sizeof(struct ubi_vtbl_record)). |
||||
* |
||||
* The @upd_marker flag is used to implement volume update. It is set to %1 |
||||
* before update and set to %0 after the update. So if the update operation was |
||||
* interrupted, UBI knows that the volume is corrupted. |
||||
* |
||||
* The @alignment field is specified when the volume is created and cannot be |
||||
* later changed. It may be useful, for example, when a block-oriented file |
||||
* system works on top of UBI. The @data_pad field is calculated using the |
||||
* logical eraseblock size and @alignment. The alignment must be multiple to the |
||||
* minimal flash I/O unit. If @alignment is 1, all the available space of |
||||
* the physical eraseblocks is used. |
||||
* |
||||
* Empty records contain all zeroes and the CRC checksum of those zeroes. |
||||
*/ |
||||
struct ubi_vtbl_record { |
||||
ubi32_t reserved_pebs; |
||||
ubi32_t alignment; |
||||
ubi32_t data_pad; |
||||
uint8_t vol_type; |
||||
uint8_t upd_marker; |
||||
ubi16_t name_len; |
||||
uint8_t name[UBI_VOL_NAME_MAX+1]; |
||||
uint8_t padding2[24]; |
||||
ubi32_t crc; |
||||
} __attribute__ ((packed)); |
||||
|
||||
#endif /* !__UBI_HEADER_H__ */ |
||||
@ -0,0 +1,161 @@ |
||||
/*
|
||||
* Copyright (c) International Business Machines Corp., 2006 |
||||
* |
||||
* 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; either version 2 of the License, or |
||||
* (at your option) any later version. |
||||
* |
||||
* This program is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See |
||||
* the GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with this program; if not, write to the Free Software |
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
||||
* |
||||
* Author: Artem Bityutskiy (Битюцкий Артём) |
||||
*/ |
||||
|
||||
#ifndef __UBI_USER_H__ |
||||
#define __UBI_USER_H__ |
||||
|
||||
/*
|
||||
* UBI volume creation |
||||
* ~~~~~~~~~~~~~~~~~~~ |
||||
* |
||||
* UBI volumes are created via the %UBI_IOCMKVOL IOCTL command of UBI character |
||||
* device. A &struct ubi_mkvol_req object has to be properly filled and a |
||||
* pointer to it has to be passed to the IOCTL. |
||||
* |
||||
* UBI volume deletion |
||||
* ~~~~~~~~~~~~~~~~~~~ |
||||
* |
||||
* To delete a volume, the %UBI_IOCRMVOL IOCTL command of the UBI character |
||||
* device should be used. A pointer to the 32-bit volume ID hast to be passed |
||||
* to the IOCTL. |
||||
* |
||||
* UBI volume re-size |
||||
* ~~~~~~~~~~~~~~~~~~ |
||||
* |
||||
* To re-size a volume, the %UBI_IOCRSVOL IOCTL command of the UBI character |
||||
* device should be used. A &struct ubi_rsvol_req object has to be properly |
||||
* filled and a pointer to it has to be passed to the IOCTL. |
||||
* |
||||
* UBI volume update |
||||
* ~~~~~~~~~~~~~~~~~ |
||||
* |
||||
* Volume update should be done via the %UBI_IOCVOLUP IOCTL command of the |
||||
* corresponding UBI volume character device. A pointer to a 64-bit update |
||||
* size should be passed to the IOCTL. After then, UBI expects user to write |
||||
* this number of bytes to the volume character device. The update is finished |
||||
* when the claimed number of bytes is passed. So, the volume update sequence |
||||
* is something like: |
||||
* |
||||
* fd = open("/dev/my_volume"); |
||||
* ioctl(fd, UBI_IOCVOLUP, &image_size); |
||||
* write(fd, buf, image_size); |
||||
* close(fd); |
||||
*/ |
||||
|
||||
/*
|
||||
* When a new volume is created, users may either specify the volume number they |
||||
* want to create or to let UBI automatically assign a volume number using this |
||||
* constant. |
||||
*/ |
||||
#define UBI_VOL_NUM_AUTO (-1) |
||||
|
||||
/* Maximum volume name length */ |
||||
#define UBI_MAX_VOLUME_NAME 127 |
||||
|
||||
/* IOCTL commands of UBI character devices */ |
||||
|
||||
#define UBI_IOC_MAGIC 'o' |
||||
|
||||
/* Create an UBI volume */ |
||||
#define UBI_IOCMKVOL _IOW(UBI_IOC_MAGIC, 0, struct ubi_mkvol_req) |
||||
/* Remove an UBI volume */ |
||||
#define UBI_IOCRMVOL _IOW(UBI_IOC_MAGIC, 1, int32_t) |
||||
/* Re-size an UBI volume */ |
||||
#define UBI_IOCRSVOL _IOW(UBI_IOC_MAGIC, 2, struct ubi_rsvol_req) |
||||
|
||||
/* IOCTL commands of UBI volume character devices */ |
||||
|
||||
#define UBI_VOL_IOC_MAGIC 'O' |
||||
|
||||
/* Start UBI volume update */ |
||||
#define UBI_IOCVOLUP _IOW(UBI_VOL_IOC_MAGIC, 0, int64_t) |
||||
/* An eraseblock erasure command, used for debugging, disabled by default */ |
||||
#define UBI_IOCEBER _IOW(UBI_VOL_IOC_MAGIC, 1, int32_t) |
||||
|
||||
/*
|
||||
* UBI volume type constants. |
||||
* |
||||
* @UBI_DYNAMIC_VOLUME: dynamic volume |
||||
* @UBI_STATIC_VOLUME: static volume |
||||
*/ |
||||
enum { |
||||
UBI_DYNAMIC_VOLUME = 3, |
||||
UBI_STATIC_VOLUME = 4 |
||||
}; |
||||
|
||||
/**
|
||||
* struct ubi_mkvol_req - volume description data structure used in |
||||
* volume creation requests. |
||||
* @vol_id: volume number |
||||
* @alignment: volume alignment |
||||
* @bytes: volume size in bytes |
||||
* @vol_type: volume type (%UBI_DYNAMIC_VOLUME or %UBI_STATIC_VOLUME) |
||||
* @padding1: reserved for future, not used |
||||
* @name_len: volume name length |
||||
* @padding2: reserved for future, not used |
||||
* @name: volume name |
||||
* |
||||
* This structure is used by userspace programs when creating new volumes. The |
||||
* @used_bytes field is only necessary when creating static volumes. |
||||
* |
||||
* The @alignment field specifies the required alignment of the volume logical |
||||
* eraseblock. This means, that the size of logical eraseblocks will be aligned |
||||
* to this number, i.e., |
||||
* (UBI device logical eraseblock size) mod (@alignment) = 0. |
||||
* |
||||
* To put it differently, the logical eraseblock of this volume may be slightly |
||||
* shortened in order to make it properly aligned. The alignment has to be |
||||
* multiple of the flash minimal input/output unit, or %1 to utilize the entire |
||||
* available space of logical eraseblocks. |
||||
* |
||||
* The @alignment field may be useful, for example, when one wants to maintain |
||||
* a block device on top of an UBI volume. In this case, it is desirable to fit |
||||
* an integer number of blocks in logical eraseblocks of this UBI volume. With |
||||
* alignment it is possible to update this volume using plane UBI volume image |
||||
* BLOBs, without caring about how to properly align them. |
||||
*/ |
||||
struct ubi_mkvol_req { |
||||
int32_t vol_id; |
||||
int32_t alignment; |
||||
int64_t bytes; |
||||
int8_t vol_type; |
||||
int8_t padding1; |
||||
int16_t name_len; |
||||
int8_t padding2[4]; |
||||
char name[UBI_MAX_VOLUME_NAME+1]; |
||||
} __attribute__ ((packed)); |
||||
|
||||
/**
|
||||
* struct ubi_rsvol_req - a data structure used in volume re-size requests. |
||||
* @vol_id: ID of the volume to re-size |
||||
* @bytes: new size of the volume in bytes |
||||
* |
||||
* Re-sizing is possible for both dynamic and static volumes. But while dynamic |
||||
* volumes may be re-sized arbitrarily, static volumes cannot be made to be |
||||
* smaller then the number of bytes they bear. To arbitrarily shrink a static |
||||
* volume, it must be wiped out first (by means of volume update operation with |
||||
* zero number of bytes). |
||||
*/ |
||||
struct ubi_rsvol_req { |
||||
int64_t bytes; |
||||
int32_t vol_id; |
||||
} __attribute__ ((packed)); |
||||
|
||||
#endif /* __UBI_USER_H__ */ |
||||
Loading…
Reference in new issue