home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / src / linux-headers-2.6.17-6 / include / linux / mtd / nand.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  19.4 KB  |  512 lines
  1. /*
  2.  *  linux/include/linux/mtd/nand.h
  3.  *
  4.  *  Copyright (c) 2000 David Woodhouse <dwmw2@mvhi.com>
  5.  *                     Steven J. Hill <sjhill@realitydiluted.com>
  6.  *               Thomas Gleixner <tglx@linutronix.de>
  7.  *
  8.  * $Id: nand.h,v 1.74 2005/09/15 13:58:50 vwool Exp $
  9.  *
  10.  * This program is free software; you can redistribute it and/or modify
  11.  * it under the terms of the GNU General Public License version 2 as
  12.  * published by the Free Software Foundation.
  13.  *
  14.  *  Info:
  15.  *   Contains standard defines and IDs for NAND flash devices
  16.  *
  17.  *  Changelog:
  18.  *   01-31-2000 DMW     Created
  19.  *   09-18-2000 SJH     Moved structure out of the Disk-On-Chip drivers
  20.  *            so it can be used by other NAND flash device
  21.  *            drivers. I also changed the copyright since none
  22.  *            of the original contents of this file are specific
  23.  *            to DoC devices. David can whack me with a baseball
  24.  *            bat later if I did something naughty.
  25.  *   10-11-2000 SJH     Added private NAND flash structure for driver
  26.  *   10-24-2000 SJH     Added prototype for 'nand_scan' function
  27.  *   10-29-2001 TG    changed nand_chip structure to support
  28.  *            hardwarespecific function for accessing control lines
  29.  *   02-21-2002 TG    added support for different read/write adress and
  30.  *            ready/busy line access function
  31.  *   02-26-2002 TG    added chip_delay to nand_chip structure to optimize
  32.  *            command delay times for different chips
  33.  *   04-28-2002 TG    OOB config defines moved from nand.c to avoid duplicate
  34.  *            defines in jffs2/wbuf.c
  35.  *   08-07-2002 TG    forced bad block location to byte 5 of OOB, even if
  36.  *            CONFIG_MTD_NAND_ECC_JFFS2 is not set
  37.  *   08-10-2002 TG    extensions to nand_chip structure to support HW-ECC
  38.  *
  39.  *   08-29-2002 tglx     nand_chip structure: data_poi for selecting
  40.  *            internal / fs-driver buffer
  41.  *            support for 6byte/512byte hardware ECC
  42.  *            read_ecc, write_ecc extended for different oob-layout
  43.  *            oob layout selections: NAND_NONE_OOB, NAND_JFFS2_OOB,
  44.  *            NAND_YAFFS_OOB
  45.  *  11-25-2002 tglx    Added Manufacturer code FUJITSU, NATIONAL
  46.  *            Split manufacturer and device ID structures
  47.  *
  48.  *  02-08-2004 tglx     added option field to nand structure for chip anomalities
  49.  *  05-25-2004 tglx     added bad block table support, ST-MICRO manufacturer id
  50.  *            update of nand_chip structure description
  51.  *  01-17-2005 dmarlin    added extended commands for AG-AND device and added option
  52.  *             for BBT_AUTO_REFRESH.
  53.  *  01-20-2005 dmarlin    added optional pointer to hardware specific callback for
  54.  *            extra error status checks.
  55.  */
  56. #ifndef __LINUX_MTD_NAND_H
  57. #define __LINUX_MTD_NAND_H
  58.  
  59. #include <linux/wait.h>
  60. #include <linux/spinlock.h>
  61. #include <linux/mtd/mtd.h>
  62.  
  63. struct mtd_info;
  64. /* Scan and identify a NAND device */
  65. extern int nand_scan (struct mtd_info *mtd, int max_chips);
  66. /* Free resources held by the NAND device */
  67. extern void nand_release (struct mtd_info *mtd);
  68.  
  69. /* Read raw data from the device without ECC */
  70. extern int nand_read_raw (struct mtd_info *mtd, uint8_t *buf, loff_t from, size_t len, size_t ooblen);
  71.  
  72.  
  73. /* The maximum number of NAND chips in an array */
  74. #define NAND_MAX_CHIPS        8
  75.  
  76. /* This constant declares the max. oobsize / page, which
  77.  * is supported now. If you add a chip with bigger oobsize/page
  78.  * adjust this accordingly.
  79.  */
  80. #define NAND_MAX_OOBSIZE    64
  81.  
  82. /*
  83.  * Constants for hardware specific CLE/ALE/NCE function
  84. */
  85. /* Select the chip by setting nCE to low */
  86. #define NAND_CTL_SETNCE     1
  87. /* Deselect the chip by setting nCE to high */
  88. #define NAND_CTL_CLRNCE        2
  89. /* Select the command latch by setting CLE to high */
  90. #define NAND_CTL_SETCLE        3
  91. /* Deselect the command latch by setting CLE to low */
  92. #define NAND_CTL_CLRCLE        4
  93. /* Select the address latch by setting ALE to high */
  94. #define NAND_CTL_SETALE        5
  95. /* Deselect the address latch by setting ALE to low */
  96. #define NAND_CTL_CLRALE        6
  97. /* Set write protection by setting WP to high. Not used! */
  98. #define NAND_CTL_SETWP        7
  99. /* Clear write protection by setting WP to low. Not used! */
  100. #define NAND_CTL_CLRWP        8
  101.  
  102. /*
  103.  * Standard NAND flash commands
  104.  */
  105. #define NAND_CMD_READ0        0
  106. #define NAND_CMD_READ1        1
  107. #define NAND_CMD_PAGEPROG    0x10
  108. #define NAND_CMD_READOOB    0x50
  109. #define NAND_CMD_ERASE1        0x60
  110. #define NAND_CMD_STATUS        0x70
  111. #define NAND_CMD_STATUS_MULTI    0x71
  112. #define NAND_CMD_SEQIN        0x80
  113. #define NAND_CMD_READID        0x90
  114. #define NAND_CMD_ERASE2        0xd0
  115. #define NAND_CMD_RESET        0xff
  116.  
  117. /* Extended commands for large page devices */
  118. #define NAND_CMD_READSTART    0x30
  119. #define NAND_CMD_CACHEDPROG    0x15
  120.  
  121. /* Extended commands for AG-AND device */
  122. /*
  123.  * Note: the command for NAND_CMD_DEPLETE1 is really 0x00 but
  124.  *       there is no way to distinguish that from NAND_CMD_READ0
  125.  *       until the remaining sequence of commands has been completed
  126.  *       so add a high order bit and mask it off in the command.
  127.  */
  128. #define NAND_CMD_DEPLETE1    0x100
  129. #define NAND_CMD_DEPLETE2    0x38
  130. #define NAND_CMD_STATUS_MULTI    0x71
  131. #define NAND_CMD_STATUS_ERROR    0x72
  132. /* multi-bank error status (banks 0-3) */
  133. #define NAND_CMD_STATUS_ERROR0    0x73
  134. #define NAND_CMD_STATUS_ERROR1    0x74
  135. #define NAND_CMD_STATUS_ERROR2    0x75
  136. #define NAND_CMD_STATUS_ERROR3    0x76
  137. #define NAND_CMD_STATUS_RESET    0x7f
  138. #define NAND_CMD_STATUS_CLEAR    0xff
  139.  
  140. /* Status bits */
  141. #define NAND_STATUS_FAIL    0x01
  142. #define NAND_STATUS_FAIL_N1    0x02
  143. #define NAND_STATUS_TRUE_READY    0x20
  144. #define NAND_STATUS_READY    0x40
  145. #define NAND_STATUS_WP        0x80
  146.  
  147. /*
  148.  * Constants for ECC_MODES
  149.  */
  150.  
  151. /* No ECC. Usage is not recommended ! */
  152. #define NAND_ECC_NONE        0
  153. /* Software ECC 3 byte ECC per 256 Byte data */
  154. #define NAND_ECC_SOFT        1
  155. /* Hardware ECC 3 byte ECC per 256 Byte data */
  156. #define NAND_ECC_HW3_256    2
  157. /* Hardware ECC 3 byte ECC per 512 Byte data */
  158. #define NAND_ECC_HW3_512    3
  159. /* Hardware ECC 3 byte ECC per 512 Byte data */
  160. #define NAND_ECC_HW6_512    4
  161. /* Hardware ECC 8 byte ECC per 512 Byte data */
  162. #define NAND_ECC_HW8_512    6
  163. /* Hardware ECC 12 byte ECC per 2048 Byte data */
  164. #define NAND_ECC_HW12_2048    7
  165.  
  166. /*
  167.  * Constants for Hardware ECC
  168.  */
  169. /* Reset Hardware ECC for read */
  170. #define NAND_ECC_READ        0
  171. /* Reset Hardware ECC for write */
  172. #define NAND_ECC_WRITE        1
  173. /* Enable Hardware ECC before syndrom is read back from flash */
  174. #define NAND_ECC_READSYN    2
  175.  
  176. /* Bit mask for flags passed to do_nand_read_ecc */
  177. #define NAND_GET_DEVICE        0x80
  178.  
  179.  
  180. /* Option constants for bizarre disfunctionality and real
  181. *  features
  182. */
  183. /* Chip can not auto increment pages */
  184. #define NAND_NO_AUTOINCR    0x00000001
  185. /* Buswitdh is 16 bit */
  186. #define NAND_BUSWIDTH_16    0x00000002
  187. /* Device supports partial programming without padding */
  188. #define NAND_NO_PADDING        0x00000004
  189. /* Chip has cache program function */
  190. #define NAND_CACHEPRG        0x00000008
  191. /* Chip has copy back function */
  192. #define NAND_COPYBACK        0x00000010
  193. /* AND Chip which has 4 banks and a confusing page / block
  194.  * assignment. See Renesas datasheet for further information */
  195. #define NAND_IS_AND        0x00000020
  196. /* Chip has a array of 4 pages which can be read without
  197.  * additional ready /busy waits */
  198. #define NAND_4PAGE_ARRAY    0x00000040
  199. /* Chip requires that BBT is periodically rewritten to prevent
  200.  * bits from adjacent blocks from 'leaking' in altering data.
  201.  * This happens with the Renesas AG-AND chips, possibly others.  */
  202. #define BBT_AUTO_REFRESH    0x00000080
  203.  
  204. /* Options valid for Samsung large page devices */
  205. #define NAND_SAMSUNG_LP_OPTIONS \
  206.     (NAND_NO_PADDING | NAND_CACHEPRG | NAND_COPYBACK)
  207.  
  208. /* Macros to identify the above */
  209. #define NAND_CANAUTOINCR(chip) (!(chip->options & NAND_NO_AUTOINCR))
  210. #define NAND_MUST_PAD(chip) (!(chip->options & NAND_NO_PADDING))
  211. #define NAND_HAS_CACHEPROG(chip) ((chip->options & NAND_CACHEPRG))
  212. #define NAND_HAS_COPYBACK(chip) ((chip->options & NAND_COPYBACK))
  213.  
  214. /* Mask to zero out the chip options, which come from the id table */
  215. #define NAND_CHIPOPTIONS_MSK    (0x0000ffff & ~NAND_NO_AUTOINCR)
  216.  
  217. /* Non chip related options */
  218. /* Use a flash based bad block table. This option is passed to the
  219.  * default bad block table function. */
  220. #define NAND_USE_FLASH_BBT    0x00010000
  221. /* The hw ecc generator provides a syndrome instead a ecc value on read
  222.  * This can only work if we have the ecc bytes directly behind the
  223.  * data bytes. Applies for DOC and AG-AND Renesas HW Reed Solomon generators */
  224. #define NAND_HWECC_SYNDROME    0x00020000
  225. /* This option skips the bbt scan during initialization. */
  226. #define NAND_SKIP_BBTSCAN    0x00040000
  227.  
  228. /* Options set by nand scan */
  229. /* Nand scan has allocated oob_buf */
  230. #define NAND_OOBBUF_ALLOC    0x40000000
  231. /* Nand scan has allocated data_buf */
  232. #define NAND_DATABUF_ALLOC    0x80000000
  233.  
  234.  
  235. /*
  236.  * nand_state_t - chip states
  237.  * Enumeration for NAND flash chip state
  238.  */
  239. typedef enum {
  240.     FL_READY,
  241.     FL_READING,
  242.     FL_WRITING,
  243.     FL_ERASING,
  244.     FL_SYNCING,
  245.     FL_CACHEDPRG,
  246.     FL_PM_SUSPENDED,
  247. } nand_state_t;
  248.  
  249. /* Keep gcc happy */
  250. struct nand_chip;
  251.  
  252. /**
  253.  * struct nand_hw_control - Control structure for hardware controller (e.g ECC generator) shared among independend devices
  254.  * @lock:               protection lock
  255.  * @active:        the mtd device which holds the controller currently
  256.  * @wq:            wait queue to sleep on if a NAND operation is in progress
  257.  *                      used instead of the per chip wait queue when a hw controller is available
  258.  */
  259. struct nand_hw_control {
  260.     spinlock_t     lock;
  261.     struct nand_chip *active;
  262.     wait_queue_head_t wq;
  263. };
  264.  
  265. /**
  266.  * struct nand_chip - NAND Private Flash Chip Data
  267.  * @IO_ADDR_R:        [BOARDSPECIFIC] address to read the 8 I/O lines of the flash device
  268.  * @IO_ADDR_W:        [BOARDSPECIFIC] address to write the 8 I/O lines of the flash device
  269.  * @read_byte:        [REPLACEABLE] read one byte from the chip
  270.  * @write_byte:        [REPLACEABLE] write one byte to the chip
  271.  * @read_word:        [REPLACEABLE] read one word from the chip
  272.  * @write_word:        [REPLACEABLE] write one word to the chip
  273.  * @write_buf:        [REPLACEABLE] write data from the buffer to the chip
  274.  * @read_buf:        [REPLACEABLE] read data from the chip into the buffer
  275.  * @verify_buf:        [REPLACEABLE] verify buffer contents against the chip data
  276.  * @select_chip:    [REPLACEABLE] select chip nr
  277.  * @block_bad:        [REPLACEABLE] check, if the block is bad
  278.  * @block_markbad:    [REPLACEABLE] mark the block bad
  279.  * @hwcontrol:        [BOARDSPECIFIC] hardwarespecific function for accesing control-lines
  280.  * @dev_ready:        [BOARDSPECIFIC] hardwarespecific function for accesing device ready/busy line
  281.  *            If set to NULL no access to ready/busy is available and the ready/busy information
  282.  *            is read from the chip status register
  283.  * @cmdfunc:        [REPLACEABLE] hardwarespecific function for writing commands to the chip
  284.  * @waitfunc:        [REPLACEABLE] hardwarespecific function for wait on ready
  285.  * @calculate_ecc:     [REPLACEABLE] function for ecc calculation or readback from ecc hardware
  286.  * @correct_data:    [REPLACEABLE] function for ecc correction, matching to ecc generator (sw/hw)
  287.  * @enable_hwecc:    [BOARDSPECIFIC] function to enable (reset) hardware ecc generator. Must only
  288.  *            be provided if a hardware ECC is available
  289.  * @erase_cmd:        [INTERN] erase command write function, selectable due to AND support
  290.  * @scan_bbt:        [REPLACEABLE] function to scan bad block table
  291.  * @eccmode:        [BOARDSPECIFIC] mode of ecc, see defines
  292.  * @eccsize:         [INTERN] databytes used per ecc-calculation
  293.  * @eccbytes:         [INTERN] number of ecc bytes per ecc-calculation step
  294.  * @eccsteps:        [INTERN] number of ecc calculation steps per page
  295.  * @chip_delay:        [BOARDSPECIFIC] chip dependent delay for transfering data from array to read regs (tR)
  296.  * @chip_lock:        [INTERN] spinlock used to protect access to this structure and the chip
  297.  * @wq:            [INTERN] wait queue to sleep on if a NAND operation is in progress
  298.  * @state:         [INTERN] the current state of the NAND device
  299.  * @page_shift:        [INTERN] number of address bits in a page (column address bits)
  300.  * @phys_erase_shift:    [INTERN] number of address bits in a physical eraseblock
  301.  * @bbt_erase_shift:    [INTERN] number of address bits in a bbt entry
  302.  * @chip_shift:        [INTERN] number of address bits in one chip
  303.  * @data_buf:        [INTERN] internal buffer for one page + oob
  304.  * @oob_buf:        [INTERN] oob buffer for one eraseblock
  305.  * @oobdirty:        [INTERN] indicates that oob_buf must be reinitialized
  306.  * @data_poi:        [INTERN] pointer to a data buffer
  307.  * @options:        [BOARDSPECIFIC] various chip options. They can partly be set to inform nand_scan about
  308.  *            special functionality. See the defines for further explanation
  309.  * @badblockpos:    [INTERN] position of the bad block marker in the oob area
  310.  * @numchips:        [INTERN] number of physical chips
  311.  * @chipsize:        [INTERN] the size of one chip for multichip arrays
  312.  * @pagemask:        [INTERN] page number mask = number of (pages / chip) - 1
  313.  * @pagebuf:        [INTERN] holds the pagenumber which is currently in data_buf
  314.  * @autooob:        [REPLACEABLE] the default (auto)placement scheme
  315.  * @bbt:        [INTERN] bad block table pointer
  316.  * @bbt_td:        [REPLACEABLE] bad block table descriptor for flash lookup
  317.  * @bbt_md:        [REPLACEABLE] bad block table mirror descriptor
  318.  * @badblock_pattern:    [REPLACEABLE] bad block scan pattern used for initial bad block scan
  319.  * @controller:        [OPTIONAL] a pointer to a hardware controller structure which is shared among multiple independend devices
  320.  * @priv:        [OPTIONAL] pointer to private chip date
  321.  * @errstat:        [OPTIONAL] hardware specific function to perform additional error status checks
  322.  *            (determine if errors are correctable)
  323.  */
  324.  
  325. struct nand_chip {
  326.     void  __iomem    *IO_ADDR_R;
  327.     void  __iomem     *IO_ADDR_W;
  328.  
  329.     u_char        (*read_byte)(struct mtd_info *mtd);
  330.     void        (*write_byte)(struct mtd_info *mtd, u_char byte);
  331.     u16        (*read_word)(struct mtd_info *mtd);
  332.     void        (*write_word)(struct mtd_info *mtd, u16 word);
  333.  
  334.     void        (*write_buf)(struct mtd_info *mtd, const u_char *buf, int len);
  335.     void        (*read_buf)(struct mtd_info *mtd, u_char *buf, int len);
  336.     int        (*verify_buf)(struct mtd_info *mtd, const u_char *buf, int len);
  337.     void        (*select_chip)(struct mtd_info *mtd, int chip);
  338.     int        (*block_bad)(struct mtd_info *mtd, loff_t ofs, int getchip);
  339.     int        (*block_markbad)(struct mtd_info *mtd, loff_t ofs);
  340.     void         (*hwcontrol)(struct mtd_info *mtd, int cmd);
  341.     int          (*dev_ready)(struct mtd_info *mtd);
  342.     void         (*cmdfunc)(struct mtd_info *mtd, unsigned command, int column, int page_addr);
  343.     int         (*waitfunc)(struct mtd_info *mtd, struct nand_chip *this, int state);
  344.     int        (*calculate_ecc)(struct mtd_info *mtd, const u_char *dat, u_char *ecc_code);
  345.     int         (*correct_data)(struct mtd_info *mtd, u_char *dat, u_char *read_ecc, u_char *calc_ecc);
  346.     void        (*enable_hwecc)(struct mtd_info *mtd, int mode);
  347.     void        (*erase_cmd)(struct mtd_info *mtd, int page);
  348.     int        (*scan_bbt)(struct mtd_info *mtd);
  349.     int        eccmode;
  350.     int        eccsize;
  351.     int        eccbytes;
  352.     int        eccsteps;
  353.     int         chip_delay;
  354.     spinlock_t    chip_lock;
  355.     wait_queue_head_t wq;
  356.     nand_state_t     state;
  357.     int         page_shift;
  358.     int        phys_erase_shift;
  359.     int        bbt_erase_shift;
  360.     int        chip_shift;
  361.     u_char         *data_buf;
  362.     u_char        *oob_buf;
  363.     int        oobdirty;
  364.     u_char        *data_poi;
  365.     unsigned int    options;
  366.     int        badblockpos;
  367.     int        numchips;
  368.     unsigned long    chipsize;
  369.     int        pagemask;
  370.     int        pagebuf;
  371.     struct nand_oobinfo    *autooob;
  372.     uint8_t        *bbt;
  373.     struct nand_bbt_descr    *bbt_td;
  374.     struct nand_bbt_descr    *bbt_md;
  375.     struct nand_bbt_descr    *badblock_pattern;
  376.     struct nand_hw_control  *controller;
  377.     void        *priv;
  378.     int        (*errstat)(struct mtd_info *mtd, struct nand_chip *this, int state, int status, int page);
  379. };
  380.  
  381. /*
  382.  * NAND Flash Manufacturer ID Codes
  383.  */
  384. #define NAND_MFR_TOSHIBA    0x98
  385. #define NAND_MFR_SAMSUNG    0xec
  386. #define NAND_MFR_FUJITSU    0x04
  387. #define NAND_MFR_NATIONAL    0x8f
  388. #define NAND_MFR_RENESAS    0x07
  389. #define NAND_MFR_STMICRO    0x20
  390. #define NAND_MFR_HYNIX          0xad
  391.  
  392. /**
  393.  * struct nand_flash_dev - NAND Flash Device ID Structure
  394.  *
  395.  * @name:      Identify the device type
  396.  * @id:       device ID code
  397.  * @pagesize:      Pagesize in bytes. Either 256 or 512 or 0
  398.  *        If the pagesize is 0, then the real pagesize
  399.  *        and the eraseize are determined from the
  400.  *        extended id bytes in the chip
  401.  * @erasesize:     Size of an erase block in the flash device.
  402.  * @chipsize:      Total chipsize in Mega Bytes
  403.  * @options:    Bitfield to store chip relevant options
  404.  */
  405. struct nand_flash_dev {
  406.     char *name;
  407.     int id;
  408.     unsigned long pagesize;
  409.     unsigned long chipsize;
  410.     unsigned long erasesize;
  411.     unsigned long options;
  412. };
  413.  
  414. /**
  415.  * struct nand_manufacturers - NAND Flash Manufacturer ID Structure
  416.  * @name:    Manufacturer name
  417.  * @id:     manufacturer ID code of device.
  418. */
  419. struct nand_manufacturers {
  420.     int id;
  421.     char * name;
  422. };
  423.  
  424. extern struct nand_flash_dev nand_flash_ids[];
  425. extern struct nand_manufacturers nand_manuf_ids[];
  426.  
  427. /**
  428.  * struct nand_bbt_descr - bad block table descriptor
  429.  * @options:    options for this descriptor
  430.  * @pages:    the page(s) where we find the bbt, used with option BBT_ABSPAGE
  431.  *        when bbt is searched, then we store the found bbts pages here.
  432.  *        Its an array and supports up to 8 chips now
  433.  * @offs:    offset of the pattern in the oob area of the page
  434.  * @veroffs:    offset of the bbt version counter in the oob are of the page
  435.  * @version:    version read from the bbt page during scan
  436.  * @len:    length of the pattern, if 0 no pattern check is performed
  437.  * @maxblocks:    maximum number of blocks to search for a bbt. This number of
  438.  *        blocks is reserved at the end of the device where the tables are
  439.  *        written.
  440.  * @reserved_block_code: if non-0, this pattern denotes a reserved (rather than
  441.  *              bad) block in the stored bbt
  442.  * @pattern:    pattern to identify bad block table or factory marked good /
  443.  *        bad blocks, can be NULL, if len = 0
  444.  *
  445.  * Descriptor for the bad block table marker and the descriptor for the
  446.  * pattern which identifies good and bad blocks. The assumption is made
  447.  * that the pattern and the version count are always located in the oob area
  448.  * of the first block.
  449.  */
  450. struct nand_bbt_descr {
  451.     int    options;
  452.     int    pages[NAND_MAX_CHIPS];
  453.     int    offs;
  454.     int    veroffs;
  455.     uint8_t    version[NAND_MAX_CHIPS];
  456.     int    len;
  457.     int     maxblocks;
  458.     int    reserved_block_code;
  459.     uint8_t    *pattern;
  460. };
  461.  
  462. /* Options for the bad block table descriptors */
  463.  
  464. /* The number of bits used per block in the bbt on the device */
  465. #define NAND_BBT_NRBITS_MSK    0x0000000F
  466. #define NAND_BBT_1BIT        0x00000001
  467. #define NAND_BBT_2BIT        0x00000002
  468. #define NAND_BBT_4BIT        0x00000004
  469. #define NAND_BBT_8BIT        0x00000008
  470. /* The bad block table is in the last good block of the device */
  471. #define    NAND_BBT_LASTBLOCK    0x00000010
  472. /* The bbt is at the given page, else we must scan for the bbt */
  473. #define NAND_BBT_ABSPAGE    0x00000020
  474. /* The bbt is at the given page, else we must scan for the bbt */
  475. #define NAND_BBT_SEARCH        0x00000040
  476. /* bbt is stored per chip on multichip devices */
  477. #define NAND_BBT_PERCHIP    0x00000080
  478. /* bbt has a version counter at offset veroffs */
  479. #define NAND_BBT_VERSION    0x00000100
  480. /* Create a bbt if none axists */
  481. #define NAND_BBT_CREATE        0x00000200
  482. /* Search good / bad pattern through all pages of a block */
  483. #define NAND_BBT_SCANALLPAGES    0x00000400
  484. /* Scan block empty during good / bad block scan */
  485. #define NAND_BBT_SCANEMPTY    0x00000800
  486. /* Write bbt if neccecary */
  487. #define NAND_BBT_WRITE        0x00001000
  488. /* Read and write back block contents when writing bbt */
  489. #define NAND_BBT_SAVECONTENT    0x00002000
  490. /* Search good / bad pattern on the first and the second page */
  491. #define NAND_BBT_SCAN2NDPAGE    0x00004000
  492.  
  493. /* The maximum number of blocks to scan for a bbt */
  494. #define NAND_BBT_SCAN_MAXBLOCKS    4
  495.  
  496. extern int nand_scan_bbt (struct mtd_info *mtd, struct nand_bbt_descr *bd);
  497. extern int nand_update_bbt (struct mtd_info *mtd, loff_t offs);
  498. extern int nand_default_bbt (struct mtd_info *mtd);
  499. extern int nand_isbad_bbt (struct mtd_info *mtd, loff_t offs, int allowbbt);
  500. extern int nand_erase_nand (struct mtd_info *mtd, struct erase_info *instr, int allowbbt);
  501. extern int nand_do_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
  502.                              size_t * retlen, u_char * buf, u_char * oob_buf,
  503.                              struct nand_oobinfo *oobsel, int flags);
  504.  
  505. /*
  506. * Constants for oob configuration
  507. */
  508. #define NAND_SMALL_BADBLOCK_POS        5
  509. #define NAND_LARGE_BADBLOCK_POS        0
  510.  
  511. #endif /* __LINUX_MTD_NAND_H */
  512.