git.sur5r.net Git - u-boot/blob - include/linux/mtd/mtd.h

   1 /*
   2  * Copyright (C) 1999-2003 David Woodhouse <dwmw2@infradead.org> et al.
   3  *
   4  * Released under GPL
   5  */
   6
   7 #ifndef __MTD_MTD_H__
   8 #define __MTD_MTD_H__
   9
  10 #include <linux/types.h>
  11 #include <div64.h>
  12 #include <linux/mtd/mtd-abi.h>
  13
  14 #define MTD_CHAR_MAJOR 90
  15 #define MTD_BLOCK_MAJOR 31
  16 #define MAX_MTD_DEVICES 32
  17
  18 #define MTD_ERASE_PENDING       0x01
  19 #define MTD_ERASING             0x02
  20 #define MTD_ERASE_SUSPEND       0x04
  21 #define MTD_ERASE_DONE          0x08
  22 #define MTD_ERASE_FAILED        0x10
  23
  24 #define MTD_FAIL_ADDR_UNKNOWN   -1LL
  25
  26 /*
  27  * Enumeration for NAND/OneNAND flash chip state
  28  */
  29 enum {
  30         FL_READY,
  31         FL_READING,
  32         FL_WRITING,
  33         FL_ERASING,
  34         FL_SYNCING,
  35         FL_CACHEDPRG,
  36         FL_RESETING,
  37         FL_UNLOCKING,
  38         FL_LOCKING,
  39         FL_PM_SUSPENDED,
  40 };
  41
  42 /* If the erase fails, fail_addr might indicate exactly which block failed.  If
  43    fail_addr = MTD_FAIL_ADDR_UNKNOWN, the failure was not at the device level or was not
  44    specific to any particular block. */
  45 struct erase_info {
  46         struct mtd_info *mtd;
  47         uint64_t addr;
  48         uint64_t len;
  49         uint64_t fail_addr;
  50         u_long time;
  51         u_long retries;
  52         u_int dev;
  53         u_int cell;
  54         void (*callback) (struct erase_info *self);
  55         u_long priv;
  56         u_char state;
  57         struct erase_info *next;
  58         int scrub;
  59 };
  60
  61 struct mtd_erase_region_info {
  62         uint64_t offset;                        /* At which this region starts, from the beginning of the MTD */
  63         u_int32_t erasesize;            /* For this region */
  64         u_int32_t numblocks;            /* Number of blocks of erasesize in this region */
  65         unsigned long *lockmap;         /* If keeping bitmap of locks */
  66 };
  67
  68 /*
  69  * oob operation modes
  70  *
  71  * MTD_OOB_PLACE:       oob data are placed at the given offset
  72  * MTD_OOB_AUTO:        oob data are automatically placed at the free areas
  73  *                      which are defined by the ecclayout
  74  * MTD_OOB_RAW:         mode to read raw data+oob in one chunk. The oob data
  75  *                      is inserted into the data. Thats a raw image of the
  76  *                      flash contents.
  77  */
  78 typedef enum {
  79         MTD_OOB_PLACE,
  80         MTD_OOB_AUTO,
  81         MTD_OOB_RAW,
  82 } mtd_oob_mode_t;
  83
  84 /**
  85  * struct mtd_oob_ops - oob operation operands
  86  * @mode:       operation mode
  87  *
  88  * @len:        number of data bytes to write/read
  89  *
  90  * @retlen:     number of data bytes written/read
  91  *
  92  * @ooblen:     number of oob bytes to write/read
  93  * @oobretlen:  number of oob bytes written/read
  94  * @ooboffs:    offset of oob data in the oob area (only relevant when
  95  *              mode = MTD_OOB_PLACE)
  96  * @datbuf:     data buffer - if NULL only oob data are read/written
  97  * @oobbuf:     oob data buffer
  98  *
  99  * Note, it is allowed to read more then one OOB area at one go, but not write.
 100  * The interface assumes that the OOB write requests program only one page's
 101  * OOB area.
 102  */
 103 struct mtd_oob_ops {
 104         mtd_oob_mode_t  mode;
 105         size_t          len;
 106         size_t          retlen;
 107         size_t          ooblen;
 108         size_t          oobretlen;
 109         uint32_t        ooboffs;
 110         uint8_t         *datbuf;
 111         uint8_t         *oobbuf;
 112 };
 113
 114 struct mtd_info {
 115         u_char type;
 116         u_int32_t flags;
 117         uint64_t size;   /* Total size of the MTD */
 118
 119         /* "Major" erase size for the device. Naïve users may take this
 120          * to be the only erase size available, or may use the more detailed
 121          * information below if they desire
 122          */
 123         u_int32_t erasesize;
 124         /* Minimal writable flash unit size. In case of NOR flash it is 1 (even
 125          * though individual bits can be cleared), in case of NAND flash it is
 126          * one NAND page (or half, or one-fourths of it), in case of ECC-ed NOR
 127          * it is of ECC block size, etc. It is illegal to have writesize = 0.
 128          * Any driver registering a struct mtd_info must ensure a writesize of
 129          * 1 or larger.
 130          */
 131         u_int32_t writesize;
 132
 133         u_int32_t oobsize;   /* Amount of OOB data per block (e.g. 16) */
 134         u_int32_t oobavail;  /* Available OOB bytes per block */
 135
 136         /* Kernel-only stuff starts here. */
 137         const char *name;
 138         int index;
 139
 140         /* ecc layout structure pointer - read only ! */
 141         struct nand_ecclayout *ecclayout;
 142
 143         /* Data for variable erase regions. If numeraseregions is zero,
 144          * it means that the whole device has erasesize as given above.
 145          */
 146         int numeraseregions;
 147         struct mtd_erase_region_info *eraseregions;
 148
 149         /*
 150          * Erase is an asynchronous operation.  Device drivers are supposed
 151          * to call instr->callback() whenever the operation completes, even
 152          * if it completes with a failure.
 153          * Callers are supposed to pass a callback function and wait for it
 154          * to be called before writing to the block.
 155          */
 156         int (*erase) (struct mtd_info *mtd, struct erase_info *instr);
 157
 158         /* This stuff for eXecute-In-Place */
 159         /* phys is optional and may be set to NULL */
 160         int (*point) (struct mtd_info *mtd, loff_t from, size_t len,
 161                         size_t *retlen, void **virt, phys_addr_t *phys);
 162
 163         /* We probably shouldn't allow XIP if the unpoint isn't a NULL */
 164         void (*unpoint) (struct mtd_info *mtd, loff_t from, size_t len);
 165
 166
 167         int (*read) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf);
 168         int (*write) (struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf);
 169
 170         /* In blackbox flight recorder like scenarios we want to make successful
 171            writes in interrupt context. panic_write() is only intended to be
 172            called when its known the kernel is about to panic and we need the
 173            write to succeed. Since the kernel is not going to be running for much
 174            longer, this function can break locks and delay to ensure the write
 175            succeeds (but not sleep). */
 176
 177         int (*panic_write) (struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf);
 178
 179         int (*read_oob) (struct mtd_info *mtd, loff_t from,
 180                          struct mtd_oob_ops *ops);
 181         int (*write_oob) (struct mtd_info *mtd, loff_t to,
 182                          struct mtd_oob_ops *ops);
 183
 184         /*
 185          * Methods to access the protection register area, present in some
 186          * flash devices. The user data is one time programmable but the
 187          * factory data is read only.
 188          */
 189         int (*get_fact_prot_info) (struct mtd_info *mtd, struct otp_info *buf, size_t len);
 190         int (*read_fact_prot_reg) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf);
 191         int (*get_user_prot_info) (struct mtd_info *mtd, struct otp_info *buf, size_t len);
 192         int (*read_user_prot_reg) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf);
 193         int (*write_user_prot_reg) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf);
 194         int (*lock_user_prot_reg) (struct mtd_info *mtd, loff_t from, size_t len);
 195
 196 /* XXX U-BOOT XXX */
 197 #if 0
 198         /* kvec-based read/write methods.
 199            NB: The 'count' parameter is the number of _vectors_, each of
 200            which contains an (ofs, len) tuple.
 201         */
 202         int (*writev) (struct mtd_info *mtd, const struct kvec *vecs, unsigned long count, loff_t to, size_t *retlen);
 203 #endif
 204
 205         /* Sync */
 206         void (*sync) (struct mtd_info *mtd);
 207
 208         /* Chip-supported device locking */
 209         int (*lock) (struct mtd_info *mtd, loff_t ofs, uint64_t len);
 210         int (*unlock) (struct mtd_info *mtd, loff_t ofs, uint64_t len);
 211
 212         /* Bad block management functions */
 213         int (*block_isbad) (struct mtd_info *mtd, loff_t ofs);
 214         int (*block_markbad) (struct mtd_info *mtd, loff_t ofs);
 215
 216 /* XXX U-BOOT XXX */
 217 #if 0
 218         struct notifier_block reboot_notifier;  /* default mode before reboot */
 219 #endif
 220
 221         /* ECC status information */
 222         struct mtd_ecc_stats ecc_stats;
 223         /* Subpage shift (NAND) */
 224         int subpage_sft;
 225
 226         void *priv;
 227
 228         struct module *owner;
 229         int usecount;
 230
 231         /* If the driver is something smart, like UBI, it may need to maintain
 232          * its own reference counting. The below functions are only for driver.
 233          * The driver may register its callbacks. These callbacks are not
 234          * supposed to be called by MTD users */
 235         int (*get_device) (struct mtd_info *mtd);
 236         void (*put_device) (struct mtd_info *mtd);
 237 };
 238
 239 static inline uint32_t mtd_div_by_eb(uint64_t sz, struct mtd_info *mtd)
 240 {
 241         do_div(sz, mtd->erasesize);
 242         return sz;
 243 }
 244
 245 static inline uint32_t mtd_mod_by_eb(uint64_t sz, struct mtd_info *mtd)
 246 {
 247         return do_div(sz, mtd->erasesize);
 248 }
 249
 250         /* Kernel-side ioctl definitions */
 251
 252 extern int add_mtd_device(struct mtd_info *mtd);
 253 extern int del_mtd_device (struct mtd_info *mtd);
 254
 255 extern struct mtd_info *get_mtd_device(struct mtd_info *mtd, int num);
 256 extern struct mtd_info *get_mtd_device_nm(const char *name);
 257
 258 extern void put_mtd_device(struct mtd_info *mtd);
 259 extern void mtd_get_len_incl_bad(struct mtd_info *mtd, uint64_t offset,
 260                                  const uint64_t length, uint64_t *len_incl_bad,
 261                                  int *truncated);
 262 /* XXX U-BOOT XXX */
 263 #if 0
 264 struct mtd_notifier {
 265         void (*add)(struct mtd_info *mtd);
 266         void (*remove)(struct mtd_info *mtd);
 267         struct list_head list;
 268 };
 269
 270 extern void register_mtd_user (struct mtd_notifier *new);
 271 extern int unregister_mtd_user (struct mtd_notifier *old);
 272
 273 int default_mtd_writev(struct mtd_info *mtd, const struct kvec *vecs,
 274                        unsigned long count, loff_t to, size_t *retlen);
 275
 276 int default_mtd_readv(struct mtd_info *mtd, struct kvec *vecs,
 277                       unsigned long count, loff_t from, size_t *retlen);
 278 #endif
 279
 280 #ifdef CONFIG_MTD_PARTITIONS
 281 void mtd_erase_callback(struct erase_info *instr);
 282 #else
 283 static inline void mtd_erase_callback(struct erase_info *instr)
 284 {
 285         if (instr->callback)
 286                 instr->callback(instr);
 287 }
 288 #endif
 289
 290 /*
 291  * Debugging macro and defines
 292  */
 293 #define MTD_DEBUG_LEVEL0        (0)     /* Quiet   */
 294 #define MTD_DEBUG_LEVEL1        (1)     /* Audible */
 295 #define MTD_DEBUG_LEVEL2        (2)     /* Loud    */
 296 #define MTD_DEBUG_LEVEL3        (3)     /* Noisy   */
 297
 298 #ifdef CONFIG_MTD_DEBUG
 299 #define MTDDEBUG(n, args...)                            \
 300         do {                                            \
 301                 if (n <= CONFIG_MTD_DEBUG_VERBOSE)      \
 302                         printk(KERN_INFO args);         \
 303         } while(0)
 304 #else /* CONFIG_MTD_DEBUG */
 305 #define MTDDEBUG(n, args...)                            \
 306         do {                                            \
 307                 if (0)                                  \
 308                         printk(KERN_INFO args);         \
 309         } while(0)
 310 #endif /* CONFIG_MTD_DEBUG */
 311
 312 #endif /* __MTD_MTD_H__ */