nand.h 20.7 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7
/*
 *  linux/include/linux/mtd/nand.h
 *
 *  Copyright (c) 2000 David Woodhouse <dwmw2@mvhi.com>
 *                     Steven J. Hill <sjhill@realitydiluted.com>
 *		       Thomas Gleixner <tglx@linutronix.de>
 *
8
 * $Id: nand.h,v 1.74 2005/09/15 13:58:50 vwool Exp $
L
Linus Torvalds 已提交
9 10 11 12 13
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
14 15
 * Info:
 *	Contains standard defines and IDs for NAND flash devices
L
Linus Torvalds 已提交
16
 *
17 18
 * Changelog:
 *	See git changelog.
L
Linus Torvalds 已提交
19 20 21 22 23 24 25 26 27 28 29
 */
#ifndef __LINUX_MTD_NAND_H
#define __LINUX_MTD_NAND_H

#include <linux/wait.h>
#include <linux/spinlock.h>
#include <linux/mtd/mtd.h>

struct mtd_info;
/* Scan and identify a NAND device */
extern int nand_scan (struct mtd_info *mtd, int max_chips);
30 31 32 33 34
/* Separate phases of nand_scan(), allowing board driver to intervene
 * and override command or ECC setup according to flash type */
extern int nand_scan_ident(struct mtd_info *mtd, int max_chips);
extern int nand_scan_tail(struct mtd_info *mtd);

L
Linus Torvalds 已提交
35 36 37
/* Free resources held by the NAND device */
extern void nand_release (struct mtd_info *mtd);

38 39 40
/* Internal helper for board drivers which need to override command function */
extern void nand_wait_ready(struct mtd_info *mtd);

L
Linus Torvalds 已提交
41 42 43 44 45 46 47 48
/* The maximum number of NAND chips in an array */
#define NAND_MAX_CHIPS		8

/* This constant declares the max. oobsize / page, which
 * is supported now. If you add a chip with bigger oobsize/page
 * adjust this accordingly.
 */
#define NAND_MAX_OOBSIZE	64
49
#define NAND_MAX_PAGESIZE	2048
L
Linus Torvalds 已提交
50 51 52

/*
 * Constants for hardware specific CLE/ALE/NCE function
53 54 55 56
 *
 * These are bits which can be or'ed to set/clear multiple
 * bits in one go.
 */
L
Linus Torvalds 已提交
57
/* Select the chip by setting nCE to low */
58
#define NAND_NCE		0x01
L
Linus Torvalds 已提交
59
/* Select the command latch by setting CLE to high */
60
#define NAND_CLE		0x02
L
Linus Torvalds 已提交
61
/* Select the address latch by setting ALE to high */
62 63 64 65 66
#define NAND_ALE		0x04

#define NAND_CTRL_CLE		(NAND_NCE | NAND_CLE)
#define NAND_CTRL_ALE		(NAND_NCE | NAND_ALE)
#define NAND_CTRL_CHANGE	0x80
L
Linus Torvalds 已提交
67 68 69 70 71 72

/*
 * Standard NAND flash commands
 */
#define NAND_CMD_READ0		0
#define NAND_CMD_READ1		1
73
#define NAND_CMD_RNDOUT		5
L
Linus Torvalds 已提交
74 75 76 77 78 79
#define NAND_CMD_PAGEPROG	0x10
#define NAND_CMD_READOOB	0x50
#define NAND_CMD_ERASE1		0x60
#define NAND_CMD_STATUS		0x70
#define NAND_CMD_STATUS_MULTI	0x71
#define NAND_CMD_SEQIN		0x80
80
#define NAND_CMD_RNDIN		0x85
L
Linus Torvalds 已提交
81 82 83 84 85 86
#define NAND_CMD_READID		0x90
#define NAND_CMD_ERASE2		0xd0
#define NAND_CMD_RESET		0xff

/* Extended commands for large page devices */
#define NAND_CMD_READSTART	0x30
87
#define NAND_CMD_RNDOUTSTART	0xE0
L
Linus Torvalds 已提交
88 89
#define NAND_CMD_CACHEDPROG	0x15

90
/* Extended commands for AG-AND device */
91 92
/*
 * Note: the command for NAND_CMD_DEPLETE1 is really 0x00 but
93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108
 *       there is no way to distinguish that from NAND_CMD_READ0
 *       until the remaining sequence of commands has been completed
 *       so add a high order bit and mask it off in the command.
 */
#define NAND_CMD_DEPLETE1	0x100
#define NAND_CMD_DEPLETE2	0x38
#define NAND_CMD_STATUS_MULTI	0x71
#define NAND_CMD_STATUS_ERROR	0x72
/* multi-bank error status (banks 0-3) */
#define NAND_CMD_STATUS_ERROR0	0x73
#define NAND_CMD_STATUS_ERROR1	0x74
#define NAND_CMD_STATUS_ERROR2	0x75
#define NAND_CMD_STATUS_ERROR3	0x76
#define NAND_CMD_STATUS_RESET	0x7f
#define NAND_CMD_STATUS_CLEAR	0xff

109 110
#define NAND_CMD_NONE		-1

L
Linus Torvalds 已提交
111 112 113 114 115 116 117
/* Status bits */
#define NAND_STATUS_FAIL	0x01
#define NAND_STATUS_FAIL_N1	0x02
#define NAND_STATUS_TRUE_READY	0x20
#define NAND_STATUS_READY	0x40
#define NAND_STATUS_WP		0x80

118
/*
L
Linus Torvalds 已提交
119 120
 * Constants for ECC_MODES
 */
T
Thomas Gleixner 已提交
121 122 123 124 125 126
typedef enum {
	NAND_ECC_NONE,
	NAND_ECC_SOFT,
	NAND_ECC_HW,
	NAND_ECC_HW_SYNDROME,
} nand_ecc_modes_t;
L
Linus Torvalds 已提交
127 128 129

/*
 * Constants for Hardware ECC
130
 */
L
Linus Torvalds 已提交
131 132 133 134 135 136 137
/* Reset Hardware ECC for read */
#define NAND_ECC_READ		0
/* Reset Hardware ECC for write */
#define NAND_ECC_WRITE		1
/* Enable Hardware ECC before syndrom is read back from flash */
#define NAND_ECC_READSYN	2

138 139 140 141
/* Bit mask for flags passed to do_nand_read_ecc */
#define NAND_GET_DEVICE		0x80


L
Linus Torvalds 已提交
142 143 144 145 146 147 148 149 150 151 152 153 154
/* Option constants for bizarre disfunctionality and real
*  features
*/
/* Chip can not auto increment pages */
#define NAND_NO_AUTOINCR	0x00000001
/* Buswitdh is 16 bit */
#define NAND_BUSWIDTH_16	0x00000002
/* Device supports partial programming without padding */
#define NAND_NO_PADDING		0x00000004
/* Chip has cache program function */
#define NAND_CACHEPRG		0x00000008
/* Chip has copy back function */
#define NAND_COPYBACK		0x00000010
155
/* AND Chip which has 4 banks and a confusing page / block
L
Linus Torvalds 已提交
156 157 158 159
 * assignment. See Renesas datasheet for further information */
#define NAND_IS_AND		0x00000020
/* Chip has a array of 4 pages which can be read without
 * additional ready /busy waits */
160
#define NAND_4PAGE_ARRAY	0x00000040
161 162 163 164
/* Chip requires that BBT is periodically rewritten to prevent
 * bits from adjacent blocks from 'leaking' in altering data.
 * This happens with the Renesas AG-AND chips, possibly others.  */
#define BBT_AUTO_REFRESH	0x00000080
165 166 167 168
/* Chip does not require ready check on read. True
 * for all large page devices, as they do not support
 * autoincrement.*/
#define NAND_NO_READRDY		0x00000100
169 170 171
/* Chip does not allow subpage writes */
#define NAND_NO_SUBPAGE_WRITE	0x00000200

L
Linus Torvalds 已提交
172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189

/* Options valid for Samsung large page devices */
#define NAND_SAMSUNG_LP_OPTIONS \
	(NAND_NO_PADDING | NAND_CACHEPRG | NAND_COPYBACK)

/* Macros to identify the above */
#define NAND_CANAUTOINCR(chip) (!(chip->options & NAND_NO_AUTOINCR))
#define NAND_MUST_PAD(chip) (!(chip->options & NAND_NO_PADDING))
#define NAND_HAS_CACHEPROG(chip) ((chip->options & NAND_CACHEPRG))
#define NAND_HAS_COPYBACK(chip) ((chip->options & NAND_COPYBACK))

/* Mask to zero out the chip options, which come from the id table */
#define NAND_CHIPOPTIONS_MSK	(0x0000ffff & ~NAND_NO_AUTOINCR)

/* Non chip related options */
/* Use a flash based bad block table. This option is passed to the
 * default bad block table function. */
#define NAND_USE_FLASH_BBT	0x00010000
190
/* This option skips the bbt scan during initialization. */
191
#define NAND_SKIP_BBTSCAN	0x00020000
192 193 194
/* This option is defined if the board driver allocates its own buffers
   (e.g. because it needs them DMA-coherent */
#define NAND_OWN_BUFFERS	0x00040000
L
Linus Torvalds 已提交
195
/* Options set by nand scan */
T
Thomas Gleixner 已提交
196
/* Nand scan has allocated controller struct */
197
#define NAND_CONTROLLER_ALLOC	0x80000000
L
Linus Torvalds 已提交
198

199 200 201
/* Cell info constants */
#define NAND_CI_CHIPNR_MSK	0x03
#define NAND_CI_CELLTYPE_MSK	0x0C
L
Linus Torvalds 已提交
202 203 204 205 206 207 208 209 210 211 212 213

/*
 * nand_state_t - chip states
 * Enumeration for NAND flash chip state
 */
typedef enum {
	FL_READY,
	FL_READING,
	FL_WRITING,
	FL_ERASING,
	FL_SYNCING,
	FL_CACHEDPRG,
214
	FL_PM_SUSPENDED,
L
Linus Torvalds 已提交
215 216 217 218 219 220
} nand_state_t;

/* Keep gcc happy */
struct nand_chip;

/**
R
Randy Dunlap 已提交
221
 * struct nand_hw_control - Control structure for hardware controller (e.g ECC generator) shared among independent devices
222
 * @lock:               protection lock
L
Linus Torvalds 已提交
223
 * @active:		the mtd device which holds the controller currently
224 225
 * @wq:			wait queue to sleep on if a NAND operation is in progress
 *                      used instead of the per chip wait queue when a hw controller is available
L
Linus Torvalds 已提交
226 227 228 229
 */
struct nand_hw_control {
	spinlock_t	 lock;
	struct nand_chip *active;
230
	wait_queue_head_t wq;
L
Linus Torvalds 已提交
231 232
};

T
Thomas Gleixner 已提交
233 234 235 236 237 238
/**
 * struct nand_ecc_ctrl - Control structure for ecc
 * @mode:	ecc mode
 * @steps:	number of ecc steps per page
 * @size:	data bytes per ecc step
 * @bytes:	ecc bytes per step
239 240 241
 * @total:	total number of ecc bytes per page
 * @prepad:	padding information for syndrome based ecc generators
 * @postpad:	padding information for syndrome based ecc generators
R
Randy Dunlap 已提交
242
 * @layout:	ECC layout control struct pointer
T
Thomas Gleixner 已提交
243 244 245 246
 * @hwctl:	function to control hardware ecc generator. Must only
 *		be provided if an hardware ECC is available
 * @calculate:	function for ecc calculation or readback from ecc hardware
 * @correct:	function for ecc correction, matching to ecc generator (sw/hw)
247 248
 * @read_page_raw:	function to read a raw page without ECC
 * @write_page_raw:	function to write a raw page without ECC
249
 * @read_page:	function to read a page according to the ecc generator requirements
250
 * @write_page:	function to write a page according to the ecc generator requirements
R
Randy Dunlap 已提交
251 252
 * @read_oob:	function to read chip OOB data
 * @write_oob:	function to write chip OOB data
T
Thomas Gleixner 已提交
253 254 255 256 257 258
 */
struct nand_ecc_ctrl {
	nand_ecc_modes_t	mode;
	int			steps;
	int			size;
	int			bytes;
259 260 261
	int			total;
	int			prepad;
	int			postpad;
262
	struct nand_ecclayout	*layout;
263
	void			(*hwctl)(struct mtd_info *mtd, int mode);
T
Thomas Gleixner 已提交
264 265 266 267 268 269
	int			(*calculate)(struct mtd_info *mtd,
					     const uint8_t *dat,
					     uint8_t *ecc_code);
	int			(*correct)(struct mtd_info *mtd, uint8_t *dat,
					   uint8_t *read_ecc,
					   uint8_t *calc_ecc);
270 271 272 273 274 275
	int			(*read_page_raw)(struct mtd_info *mtd,
						 struct nand_chip *chip,
						 uint8_t *buf);
	void			(*write_page_raw)(struct mtd_info *mtd,
						  struct nand_chip *chip,
						  const uint8_t *buf);
276 277 278
	int			(*read_page)(struct mtd_info *mtd,
					     struct nand_chip *chip,
					     uint8_t *buf);
279
	void			(*write_page)(struct mtd_info *mtd,
280
					      struct nand_chip *chip,
281
					      const uint8_t *buf);
282 283 284 285 286 287 288
	int			(*read_oob)(struct mtd_info *mtd,
					    struct nand_chip *chip,
					    int page,
					    int sndcmd);
	int			(*write_oob)(struct mtd_info *mtd,
					     struct nand_chip *chip,
					     int page);
289 290 291 292 293 294 295 296 297 298 299 300 301 302
};

/**
 * struct nand_buffers - buffer structure for read/write
 * @ecccalc:	buffer for calculated ecc
 * @ecccode:	buffer for ecc read from flash
 * @databuf:	buffer for data - dynamically sized
 *
 * Do not change the order of buffers. databuf and oobrbuf must be in
 * consecutive order.
 */
struct nand_buffers {
	uint8_t	ecccalc[NAND_MAX_OOBSIZE];
	uint8_t	ecccode[NAND_MAX_OOBSIZE];
303
	uint8_t databuf[NAND_MAX_PAGESIZE + NAND_MAX_OOBSIZE];
T
Thomas Gleixner 已提交
304 305
};

L
Linus Torvalds 已提交
306 307
/**
 * struct nand_chip - NAND Private Flash Chip Data
308 309
 * @IO_ADDR_R:		[BOARDSPECIFIC] address to read the 8 I/O lines of the flash device
 * @IO_ADDR_W:		[BOARDSPECIFIC] address to write the 8 I/O lines of the flash device
L
Linus Torvalds 已提交
310 311 312 313 314 315 316 317
 * @read_byte:		[REPLACEABLE] read one byte from the chip
 * @read_word:		[REPLACEABLE] read one word from the chip
 * @write_buf:		[REPLACEABLE] write data from the buffer to the chip
 * @read_buf:		[REPLACEABLE] read data from the chip into the buffer
 * @verify_buf:		[REPLACEABLE] verify buffer contents against the chip data
 * @select_chip:	[REPLACEABLE] select chip nr
 * @block_bad:		[REPLACEABLE] check, if the block is bad
 * @block_markbad:	[REPLACEABLE] mark the block bad
318 319
 * @cmd_ctrl:		[BOARDSPECIFIC] hardwarespecific funtion for controlling
 *			ALE/CLE/nCE. Also used to write command and address
L
Linus Torvalds 已提交
320 321 322 323 324
 * @dev_ready:		[BOARDSPECIFIC] hardwarespecific function for accesing device ready/busy line
 *			If set to NULL no access to ready/busy is available and the ready/busy information
 *			is read from the chip status register
 * @cmdfunc:		[REPLACEABLE] hardwarespecific function for writing commands to the chip
 * @waitfunc:		[REPLACEABLE] hardwarespecific function for wait on ready
T
Thomas Gleixner 已提交
325
 * @ecc:		[BOARDSPECIFIC] ecc control ctructure
R
Randy Dunlap 已提交
326 327 328
 * @buffers:		buffer structure for read/write
 * @hwcontrol:		platform-specific hardware control structure
 * @ops:		oob operation operands
L
Linus Torvalds 已提交
329 330 331 332
 * @erase_cmd:		[INTERN] erase command write function, selectable due to AND support
 * @scan_bbt:		[REPLACEABLE] function to scan bad block table
 * @chip_delay:		[BOARDSPECIFIC] chip dependent delay for transfering data from array to read regs (tR)
 * @wq:			[INTERN] wait queue to sleep on if a NAND operation is in progress
333
 * @state:		[INTERN] the current state of the NAND device
R
Randy Dunlap 已提交
334
 * @oob_poi:		poison value buffer
L
Linus Torvalds 已提交
335 336 337 338
 * @page_shift:		[INTERN] number of address bits in a page (column address bits)
 * @phys_erase_shift:	[INTERN] number of address bits in a physical eraseblock
 * @bbt_erase_shift:	[INTERN] number of address bits in a bbt entry
 * @chip_shift:		[INTERN] number of address bits in one chip
339 340
 * @datbuf:		[INTERN] internal buffer for one page + oob
 * @oobbuf:		[INTERN] oob buffer for one eraseblock
L
Linus Torvalds 已提交
341 342 343 344 345
 * @oobdirty:		[INTERN] indicates that oob_buf must be reinitialized
 * @data_poi:		[INTERN] pointer to a data buffer
 * @options:		[BOARDSPECIFIC] various chip options. They can partly be set to inform nand_scan about
 *			special functionality. See the defines for further explanation
 * @badblockpos:	[INTERN] position of the bad block marker in the oob area
346
 * @cellinfo:		[INTERN] MLC/multichip data from chip ident
L
Linus Torvalds 已提交
347 348 349 350
 * @numchips:		[INTERN] number of physical chips
 * @chipsize:		[INTERN] the size of one chip for multichip arrays
 * @pagemask:		[INTERN] page number mask = number of (pages / chip) - 1
 * @pagebuf:		[INTERN] holds the pagenumber which is currently in data_buf
351
 * @subpagesize:	[INTERN] holds the subpagesize
352
 * @ecclayout:		[REPLACEABLE] the default ecc placement scheme
L
Linus Torvalds 已提交
353 354 355
 * @bbt:		[INTERN] bad block table pointer
 * @bbt_td:		[REPLACEABLE] bad block table descriptor for flash lookup
 * @bbt_md:		[REPLACEABLE] bad block table mirror descriptor
356
 * @badblock_pattern:	[REPLACEABLE] bad block scan pattern used for initial bad block scan
T
Thomas Gleixner 已提交
357 358
 * @controller:		[REPLACEABLE] a pointer to a hardware controller structure
 *			which is shared among multiple independend devices
L
Linus Torvalds 已提交
359
 * @priv:		[OPTIONAL] pointer to private chip date
360
 * @errstat:		[OPTIONAL] hardware specific function to perform additional error status checks
361
 *			(determine if errors are correctable)
362
 * @write_page:		[REPLACEABLE] High-level page write function
L
Linus Torvalds 已提交
363
 */
364

L
Linus Torvalds 已提交
365 366
struct nand_chip {
	void  __iomem	*IO_ADDR_R;
367
	void  __iomem	*IO_ADDR_W;
368

369
	uint8_t		(*read_byte)(struct mtd_info *mtd);
L
Linus Torvalds 已提交
370
	u16		(*read_word)(struct mtd_info *mtd);
371 372 373
	void		(*write_buf)(struct mtd_info *mtd, const uint8_t *buf, int len);
	void		(*read_buf)(struct mtd_info *mtd, uint8_t *buf, int len);
	int		(*verify_buf)(struct mtd_info *mtd, const uint8_t *buf, int len);
L
Linus Torvalds 已提交
374 375 376
	void		(*select_chip)(struct mtd_info *mtd, int chip);
	int		(*block_bad)(struct mtd_info *mtd, loff_t ofs, int getchip);
	int		(*block_markbad)(struct mtd_info *mtd, loff_t ofs);
377 378
	void		(*cmd_ctrl)(struct mtd_info *mtd, int dat,
				    unsigned int ctrl);
379 380
	int		(*dev_ready)(struct mtd_info *mtd);
	void		(*cmdfunc)(struct mtd_info *mtd, unsigned command, int column, int page_addr);
381
	int		(*waitfunc)(struct mtd_info *mtd, struct nand_chip *this);
L
Linus Torvalds 已提交
382 383
	void		(*erase_cmd)(struct mtd_info *mtd, int page);
	int		(*scan_bbt)(struct mtd_info *mtd);
384
	int		(*errstat)(struct mtd_info *mtd, struct nand_chip *this, int state, int status, int page);
385 386
	int		(*write_page)(struct mtd_info *mtd, struct nand_chip *chip,
				      const uint8_t *buf, int page, int cached, int raw);
387

388
	int		chip_delay;
389 390
	unsigned int	options;

391
	int		page_shift;
L
Linus Torvalds 已提交
392 393 394 395 396 397 398
	int		phys_erase_shift;
	int		bbt_erase_shift;
	int		chip_shift;
	int		numchips;
	unsigned long	chipsize;
	int		pagemask;
	int		pagebuf;
399 400
	int		subpagesize;
	uint8_t		cellinfo;
401 402 403 404 405 406
	int		badblockpos;

	nand_state_t	state;

	uint8_t		*oob_poi;
	struct nand_hw_control  *controller;
407
	struct nand_ecclayout	*ecclayout;
408 409

	struct nand_ecc_ctrl ecc;
410
	struct nand_buffers *buffers;
411 412
	struct nand_hw_control hwcontrol;

413 414
	struct mtd_oob_ops ops;

L
Linus Torvalds 已提交
415 416 417
	uint8_t		*bbt;
	struct nand_bbt_descr	*bbt_td;
	struct nand_bbt_descr	*bbt_md;
418

L
Linus Torvalds 已提交
419
	struct nand_bbt_descr	*badblock_pattern;
420

L
Linus Torvalds 已提交
421 422 423 424 425 426 427 428 429 430 431 432
	void		*priv;
};

/*
 * NAND Flash Manufacturer ID Codes
 */
#define NAND_MFR_TOSHIBA	0x98
#define NAND_MFR_SAMSUNG	0xec
#define NAND_MFR_FUJITSU	0x04
#define NAND_MFR_NATIONAL	0x8f
#define NAND_MFR_RENESAS	0x07
#define NAND_MFR_STMICRO	0x20
433
#define NAND_MFR_HYNIX		0xad
434
#define NAND_MFR_MICRON		0x2c
L
Linus Torvalds 已提交
435 436 437

/**
 * struct nand_flash_dev - NAND Flash Device ID Structure
438 439 440
 * @name:	Identify the device type
 * @id:		device ID code
 * @pagesize:	Pagesize in bytes. Either 256 or 512 or 0
441
 *		If the pagesize is 0, then the real pagesize
L
Linus Torvalds 已提交
442 443
 *		and the eraseize are determined from the
 *		extended id bytes in the chip
444 445
 * @erasesize:	Size of an erase block in the flash device.
 * @chipsize:	Total chipsize in Mega Bytes
L
Linus Torvalds 已提交
446 447 448 449 450 451 452 453 454 455 456 457 458 459
 * @options:	Bitfield to store chip relevant options
 */
struct nand_flash_dev {
	char *name;
	int id;
	unsigned long pagesize;
	unsigned long chipsize;
	unsigned long erasesize;
	unsigned long options;
};

/**
 * struct nand_manufacturers - NAND Flash Manufacturer ID Structure
 * @name:	Manufacturer name
460
 * @id:		manufacturer ID code of device.
L
Linus Torvalds 已提交
461 462 463 464 465 466 467 468 469
*/
struct nand_manufacturers {
	int id;
	char * name;
};

extern struct nand_flash_dev nand_flash_ids[];
extern struct nand_manufacturers nand_manuf_ids[];

470
/**
L
Linus Torvalds 已提交
471 472 473 474 475 476 477 478 479 480
 * struct nand_bbt_descr - bad block table descriptor
 * @options:	options for this descriptor
 * @pages:	the page(s) where we find the bbt, used with option BBT_ABSPAGE
 *		when bbt is searched, then we store the found bbts pages here.
 *		Its an array and supports up to 8 chips now
 * @offs:	offset of the pattern in the oob area of the page
 * @veroffs:	offset of the bbt version counter in the oob are of the page
 * @version:	version read from the bbt page during scan
 * @len:	length of the pattern, if 0 no pattern check is performed
 * @maxblocks:	maximum number of blocks to search for a bbt. This number of
481
 *		blocks is reserved at the end of the device where the tables are
L
Linus Torvalds 已提交
482 483 484
 *		written.
 * @reserved_block_code: if non-0, this pattern denotes a reserved (rather than
 *              bad) block in the stored bbt
485
 * @pattern:	pattern to identify bad block table or factory marked good /
L
Linus Torvalds 已提交
486 487
 *		bad blocks, can be NULL, if len = 0
 *
488
 * Descriptor for the bad block table marker and the descriptor for the
L
Linus Torvalds 已提交
489 490 491 492 493 494 495 496 497 498 499
 * pattern which identifies good and bad blocks. The assumption is made
 * that the pattern and the version count are always located in the oob area
 * of the first block.
 */
struct nand_bbt_descr {
	int	options;
	int	pages[NAND_MAX_CHIPS];
	int	offs;
	int	veroffs;
	uint8_t	version[NAND_MAX_CHIPS];
	int	len;
500
	int	maxblocks;
L
Linus Torvalds 已提交
501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538
	int	reserved_block_code;
	uint8_t	*pattern;
};

/* Options for the bad block table descriptors */

/* The number of bits used per block in the bbt on the device */
#define NAND_BBT_NRBITS_MSK	0x0000000F
#define NAND_BBT_1BIT		0x00000001
#define NAND_BBT_2BIT		0x00000002
#define NAND_BBT_4BIT		0x00000004
#define NAND_BBT_8BIT		0x00000008
/* The bad block table is in the last good block of the device */
#define	NAND_BBT_LASTBLOCK	0x00000010
/* The bbt is at the given page, else we must scan for the bbt */
#define NAND_BBT_ABSPAGE	0x00000020
/* The bbt is at the given page, else we must scan for the bbt */
#define NAND_BBT_SEARCH		0x00000040
/* bbt is stored per chip on multichip devices */
#define NAND_BBT_PERCHIP	0x00000080
/* bbt has a version counter at offset veroffs */
#define NAND_BBT_VERSION	0x00000100
/* Create a bbt if none axists */
#define NAND_BBT_CREATE		0x00000200
/* Search good / bad pattern through all pages of a block */
#define NAND_BBT_SCANALLPAGES	0x00000400
/* Scan block empty during good / bad block scan */
#define NAND_BBT_SCANEMPTY	0x00000800
/* Write bbt if neccecary */
#define NAND_BBT_WRITE		0x00001000
/* Read and write back block contents when writing bbt */
#define NAND_BBT_SAVECONTENT	0x00002000
/* Search good / bad pattern on the first and the second page */
#define NAND_BBT_SCAN2NDPAGE	0x00004000

/* The maximum number of blocks to scan for a bbt */
#define NAND_BBT_SCAN_MAXBLOCKS	4

539 540 541 542 543 544 545 546
extern int nand_scan_bbt(struct mtd_info *mtd, struct nand_bbt_descr *bd);
extern int nand_update_bbt(struct mtd_info *mtd, loff_t offs);
extern int nand_default_bbt(struct mtd_info *mtd);
extern int nand_isbad_bbt(struct mtd_info *mtd, loff_t offs, int allowbbt);
extern int nand_erase_nand(struct mtd_info *mtd, struct erase_info *instr,
			   int allowbbt);
extern int nand_do_read(struct mtd_info *mtd, loff_t from, size_t len,
			size_t * retlen, uint8_t * buf);
L
Linus Torvalds 已提交
547 548 549 550 551 552 553

/*
* Constants for oob configuration
*/
#define NAND_SMALL_BADBLOCK_POS		5
#define NAND_LARGE_BADBLOCK_POS		0

554 555 556
/**
 * struct platform_nand_chip - chip level device structure
 * @nr_chips:		max. number of chips to scan for
R
Randy Dunlap 已提交
557
 * @chip_offset:	chip number offset
558
 * @nr_partitions:	number of partitions pointed to by partitions (or zero)
559 560 561
 * @partitions:		mtd partition list
 * @chip_delay:		R/B delay value in us
 * @options:		Option flags, e.g. 16bit buswidth
562
 * @ecclayout:		ecc layout info structure
563 564 565 566 567 568 569
 * @priv:		hardware controller specific settings
 */
struct platform_nand_chip {
	int			nr_chips;
	int			chip_offset;
	int			nr_partitions;
	struct mtd_partition	*partitions;
570
	struct nand_ecclayout	*ecclayout;
571
	int			chip_delay;
572 573 574 575 576 577 578 579 580
	unsigned int		options;
	void			*priv;
};

/**
 * struct platform_nand_ctrl - controller level device structure
 * @hwcontrol:		platform specific hardware control structure
 * @dev_ready:		platform specific function to read ready/busy pin
 * @select_chip:	platform specific chip select function
R
Randy Dunlap 已提交
581
 * @priv:		private data to transport driver specific settings
582 583 584 585
 *
 * All fields are optional and depend on the hardware driver requirements
 */
struct platform_nand_ctrl {
586 587
	void		(*hwcontrol)(struct mtd_info *mtd, int cmd);
	int		(*dev_ready)(struct mtd_info *mtd);
588 589 590 591 592 593 594 595 596 597 598 599 600
	void		(*select_chip)(struct mtd_info *mtd, int chip);
	void		*priv;
};

/* Some helpers to access the data structures */
static inline
struct platform_nand_chip *get_platform_nandchip(struct mtd_info *mtd)
{
	struct nand_chip *chip = mtd->priv;

	return chip->priv;
}

L
Linus Torvalds 已提交
601
#endif /* __LINUX_MTD_NAND_H */