1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 * Handles the M-Systems DiskOnChip G3 chip
   4 *
   5 * Copyright (C) 2011 Robert Jarzmik
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
   6 */
   7
   8#include <linux/kernel.h>
   9#include <linux/module.h>
  10#include <linux/errno.h>
  11#include <linux/of.h>
  12#include <linux/platform_device.h>
  13#include <linux/string.h>
  14#include <linux/slab.h>
  15#include <linux/io.h>
  16#include <linux/delay.h>
  17#include <linux/mtd/mtd.h>
  18#include <linux/mtd/partitions.h>
  19#include <linux/bitmap.h>
  20#include <linux/bitrev.h>
  21#include <linux/bch.h>
  22
  23#include <linux/debugfs.h>
  24#include <linux/seq_file.h>
  25
  26#define CREATE_TRACE_POINTS
  27#include "docg3.h"
  28
  29/*
  30 * This driver handles the DiskOnChip G3 flash memory.
  31 *
  32 * As no specification is available from M-Systems/Sandisk, this drivers lacks
  33 * several functions available on the chip, as :
  34 *  - IPL write
  35 *
  36 * The bus data width (8bits versus 16bits) is not handled (if_cfg flag), and
  37 * the driver assumes a 16bits data bus.
  38 *
  39 * DocG3 relies on 2 ECC algorithms, which are handled in hardware :
  40 *  - a 1 byte Hamming code stored in the OOB for each page
  41 *  - a 7 bytes BCH code stored in the OOB for each page
  42 * The BCH ECC is :
  43 *  - BCH is in GF(2^14)
  44 *  - BCH is over data of 520 bytes (512 page + 7 page_info bytes
  45 *                                   + 1 hamming byte)
  46 *  - BCH can correct up to 4 bits (t = 4)
  47 *  - BCH syndroms are calculated in hardware, and checked in hardware as well
  48 *
  49 */
  50
  51static unsigned int reliable_mode;
  52module_param(reliable_mode, uint, 0);
  53MODULE_PARM_DESC(reliable_mode, "Set the docg3 mode (0=normal MLC, 1=fast, "
  54		 "2=reliable) : MLC normal operations are in normal mode");
  55
  56static int docg3_ooblayout_ecc(struct mtd_info *mtd, int section,
  57			       struct mtd_oob_region *oobregion)
  58{
  59	if (section)
  60		return -ERANGE;
  61
  62	/* byte 7 is Hamming ECC, byte 8-14 are BCH ECC */
  63	oobregion->offset = 7;
  64	oobregion->length = 8;
  65
  66	return 0;
  67}
  68
  69static int docg3_ooblayout_free(struct mtd_info *mtd, int section,
  70				struct mtd_oob_region *oobregion)
  71{
  72	if (section > 1)
  73		return -ERANGE;
  74
  75	/* free bytes: byte 0 until byte 6, byte 15 */
  76	if (!section) {
  77		oobregion->offset = 0;
  78		oobregion->length = 7;
  79	} else {
  80		oobregion->offset = 15;
  81		oobregion->length = 1;
  82	}
  83
  84	return 0;
  85}
  86
  87static const struct mtd_ooblayout_ops nand_ooblayout_docg3_ops = {
  88	.ecc = docg3_ooblayout_ecc,
  89	.free = docg3_ooblayout_free,
  90};
  91
  92static inline u8 doc_readb(struct docg3 *docg3, u16 reg)
  93{
  94	u8 val = readb(docg3->cascade->base + reg);
  95
  96	trace_docg3_io(0, 8, reg, (int)val);
  97	return val;
  98}
  99
 100static inline u16 doc_readw(struct docg3 *docg3, u16 reg)
 101{
 102	u16 val = readw(docg3->cascade->base + reg);
 103
 104	trace_docg3_io(0, 16, reg, (int)val);
 105	return val;
 106}
 107
 108static inline void doc_writeb(struct docg3 *docg3, u8 val, u16 reg)
 109{
 110	writeb(val, docg3->cascade->base + reg);
 111	trace_docg3_io(1, 8, reg, val);
 112}
 113
 114static inline void doc_writew(struct docg3 *docg3, u16 val, u16 reg)
 115{
 116	writew(val, docg3->cascade->base + reg);
 117	trace_docg3_io(1, 16, reg, val);
 118}
 119
 120static inline void doc_flash_command(struct docg3 *docg3, u8 cmd)
 121{
 122	doc_writeb(docg3, cmd, DOC_FLASHCOMMAND);
 123}
 124
 125static inline void doc_flash_sequence(struct docg3 *docg3, u8 seq)
 126{
 127	doc_writeb(docg3, seq, DOC_FLASHSEQUENCE);
 128}
 129
 130static inline void doc_flash_address(struct docg3 *docg3, u8 addr)
 131{
 132	doc_writeb(docg3, addr, DOC_FLASHADDRESS);
 133}
 134
 135static char const * const part_probes[] = { "cmdlinepart", "saftlpart", NULL };
 136
 137static int doc_register_readb(struct docg3 *docg3, int reg)
 138{
 139	u8 val;
 140
 141	doc_writew(docg3, reg, DOC_READADDRESS);
 142	val = doc_readb(docg3, reg);
 143	doc_vdbg("Read register %04x : %02x\n", reg, val);
 144	return val;
 145}
 146
 147static int doc_register_readw(struct docg3 *docg3, int reg)
 148{
 149	u16 val;
 150
 151	doc_writew(docg3, reg, DOC_READADDRESS);
 152	val = doc_readw(docg3, reg);
 153	doc_vdbg("Read register %04x : %04x\n", reg, val);
 154	return val;
 155}
 156
 157/**
 158 * doc_delay - delay docg3 operations
 159 * @docg3: the device
 160 * @nbNOPs: the number of NOPs to issue
 161 *
 162 * As no specification is available, the right timings between chip commands are
 163 * unknown. The only available piece of information are the observed nops on a
 164 * working docg3 chip.
 165 * Therefore, doc_delay relies on a busy loop of NOPs, instead of scheduler
 166 * friendlier msleep() functions or blocking mdelay().
 167 */
 168static void doc_delay(struct docg3 *docg3, int nbNOPs)
 169{
 170	int i;
 171
 172	doc_vdbg("NOP x %d\n", nbNOPs);
 173	for (i = 0; i < nbNOPs; i++)
 174		doc_writeb(docg3, 0, DOC_NOP);
 175}
 176
 177static int is_prot_seq_error(struct docg3 *docg3)
 178{
 179	int ctrl;
 180
 181	ctrl = doc_register_readb(docg3, DOC_FLASHCONTROL);
 182	return ctrl & (DOC_CTRL_PROTECTION_ERROR | DOC_CTRL_SEQUENCE_ERROR);
 183}
 184
 185static int doc_is_ready(struct docg3 *docg3)
 186{
 187	int ctrl;
 188
 189	ctrl = doc_register_readb(docg3, DOC_FLASHCONTROL);
 190	return ctrl & DOC_CTRL_FLASHREADY;
 191}
 192
 193static int doc_wait_ready(struct docg3 *docg3)
 194{
 195	int maxWaitCycles = 100;
 196
 197	do {
 198		doc_delay(docg3, 4);
 199		cpu_relax();
 200	} while (!doc_is_ready(docg3) && maxWaitCycles--);
 201	doc_delay(docg3, 2);
 202	if (maxWaitCycles > 0)
 203		return 0;
 204	else
 205		return -EIO;
 206}
 207
 208static int doc_reset_seq(struct docg3 *docg3)
 209{
 210	int ret;
 211
 212	doc_writeb(docg3, 0x10, DOC_FLASHCONTROL);
 213	doc_flash_sequence(docg3, DOC_SEQ_RESET);
 214	doc_flash_command(docg3, DOC_CMD_RESET);
 215	doc_delay(docg3, 2);
 216	ret = doc_wait_ready(docg3);
 217
 218	doc_dbg("doc_reset_seq() -> isReady=%s\n", ret ? "false" : "true");
 219	return ret;
 220}
 221
 222/**
 223 * doc_read_data_area - Read data from data area
 224 * @docg3: the device
 225 * @buf: the buffer to fill in (might be NULL is dummy reads)
 226 * @len: the length to read
 227 * @first: first time read, DOC_READADDRESS should be set
 228 *
 229 * Reads bytes from flash data. Handles the single byte / even bytes reads.
 230 */
 231static void doc_read_data_area(struct docg3 *docg3, void *buf, int len,
 232			       int first)
 233{
 234	int i, cdr, len4;
 235	u16 data16, *dst16;
 236	u8 data8, *dst8;
 237
 238	doc_dbg("doc_read_data_area(buf=%p, len=%d)\n", buf, len);
 239	cdr = len & 0x1;
 240	len4 = len - cdr;
 241
 242	if (first)
 243		doc_writew(docg3, DOC_IOSPACE_DATA, DOC_READADDRESS);
 244	dst16 = buf;
 245	for (i = 0; i < len4; i += 2) {
 246		data16 = doc_readw(docg3, DOC_IOSPACE_DATA);
 247		if (dst16) {
 248			*dst16 = data16;
 249			dst16++;
 250		}
 251	}
 252
 253	if (cdr) {
 254		doc_writew(docg3, DOC_IOSPACE_DATA | DOC_READADDR_ONE_BYTE,
 255			   DOC_READADDRESS);
 256		doc_delay(docg3, 1);
 257		dst8 = (u8 *)dst16;
 258		for (i = 0; i < cdr; i++) {
 259			data8 = doc_readb(docg3, DOC_IOSPACE_DATA);
 260			if (dst8) {
 261				*dst8 = data8;
 262				dst8++;
 263			}
 264		}
 265	}
 266}
 267
 268/**
 269 * doc_write_data_area - Write data into data area
 270 * @docg3: the device
 271 * @buf: the buffer to get input bytes from
 272 * @len: the length to write
 273 *
 274 * Writes bytes into flash data. Handles the single byte / even bytes writes.
 275 */
 276static void doc_write_data_area(struct docg3 *docg3, const void *buf, int len)
 277{
 278	int i, cdr, len4;
 279	u16 *src16;
 280	u8 *src8;
 281
 282	doc_dbg("doc_write_data_area(buf=%p, len=%d)\n", buf, len);
 283	cdr = len & 0x3;
 284	len4 = len - cdr;
 285
 286	doc_writew(docg3, DOC_IOSPACE_DATA, DOC_READADDRESS);
 287	src16 = (u16 *)buf;
 288	for (i = 0; i < len4; i += 2) {
 289		doc_writew(docg3, *src16, DOC_IOSPACE_DATA);
 290		src16++;
 291	}
 292
 293	src8 = (u8 *)src16;
 294	for (i = 0; i < cdr; i++) {
 295		doc_writew(docg3, DOC_IOSPACE_DATA | DOC_READADDR_ONE_BYTE,
 296			   DOC_READADDRESS);
 297		doc_writeb(docg3, *src8, DOC_IOSPACE_DATA);
 298		src8++;
 299	}
 300}
 301
 302/**
 303 * doc_set_reliable_mode - Sets the flash to normal or reliable data mode
 304 * @docg3: the device
 305 *
 306 * The reliable data mode is a bit slower than the fast mode, but less errors
 307 * occur.  Entering the reliable mode cannot be done without entering the fast
 308 * mode first.
 309 *
 310 * In reliable mode, pages 2*n and 2*n+1 are clones. Writing to page 0 of blocks
 311 * (4,5) make the hardware write also to page 1 of blocks blocks(4,5). Reading
 312 * from page 0 of blocks (4,5) or from page 1 of blocks (4,5) gives the same
 313 * result, which is a logical and between bytes from page 0 and page 1 (which is
 314 * consistent with the fact that writing to a page is _clearing_ bits of that
 315 * page).
 316 */
 317static void doc_set_reliable_mode(struct docg3 *docg3)
 318{
 319	static char *strmode[] = { "normal", "fast", "reliable", "invalid" };
 320
 321	doc_dbg("doc_set_reliable_mode(%s)\n", strmode[docg3->reliable]);
 322	switch (docg3->reliable) {
 323	case 0:
 324		break;
 325	case 1:
 326		doc_flash_sequence(docg3, DOC_SEQ_SET_FASTMODE);
 327		doc_flash_command(docg3, DOC_CMD_FAST_MODE);
 328		break;
 329	case 2:
 330		doc_flash_sequence(docg3, DOC_SEQ_SET_RELIABLEMODE);
 331		doc_flash_command(docg3, DOC_CMD_FAST_MODE);
 332		doc_flash_command(docg3, DOC_CMD_RELIABLE_MODE);
 333		break;
 334	default:
 335		doc_err("doc_set_reliable_mode(): invalid mode\n");
 336		break;
 337	}
 338	doc_delay(docg3, 2);
 339}
 340
 341/**
 342 * doc_set_asic_mode - Set the ASIC mode
 343 * @docg3: the device
 344 * @mode: the mode
 345 *
 346 * The ASIC can work in 3 modes :
 347 *  - RESET: all registers are zeroed
 348 *  - NORMAL: receives and handles commands
 349 *  - POWERDOWN: minimal poweruse, flash parts shut off
 350 */
 351static void doc_set_asic_mode(struct docg3 *docg3, u8 mode)
 352{
 353	int i;
 354
 355	for (i = 0; i < 12; i++)
 356		doc_readb(docg3, DOC_IOSPACE_IPL);
 357
 358	mode |= DOC_ASICMODE_MDWREN;
 359	doc_dbg("doc_set_asic_mode(%02x)\n", mode);
 360	doc_writeb(docg3, mode, DOC_ASICMODE);
 361	doc_writeb(docg3, ~mode, DOC_ASICMODECONFIRM);
 362	doc_delay(docg3, 1);
 363}
 364
 365/**
 366 * doc_set_device_id - Sets the devices id for cascaded G3 chips
 367 * @docg3: the device
 368 * @id: the chip to select (amongst 0, 1, 2, 3)
 369 *
 370 * There can be 4 cascaded G3 chips. This function selects the one which will
 371 * should be the active one.
 372 */
 373static void doc_set_device_id(struct docg3 *docg3, int id)
 374{
 375	u8 ctrl;
 376
 377	doc_dbg("doc_set_device_id(%d)\n", id);
 378	doc_writeb(docg3, id, DOC_DEVICESELECT);
 379	ctrl = doc_register_readb(docg3, DOC_FLASHCONTROL);
 380
 381	ctrl &= ~DOC_CTRL_VIOLATION;
 382	ctrl |= DOC_CTRL_CE;
 383	doc_writeb(docg3, ctrl, DOC_FLASHCONTROL);
 384}
 385
 386/**
 387 * doc_set_extra_page_mode - Change flash page layout
 388 * @docg3: the device
 389 *
 390 * Normally, the flash page is split into the data (512 bytes) and the out of
 391 * band data (16 bytes). For each, 4 more bytes can be accessed, where the wear
 392 * leveling counters are stored.  To access this last area of 4 bytes, a special
 393 * mode must be input to the flash ASIC.
 394 *
 395 * Returns 0 if no error occurred, -EIO else.
 396 */
 397static int doc_set_extra_page_mode(struct docg3 *docg3)
 398{
 399	int fctrl;
 400
 401	doc_dbg("doc_set_extra_page_mode()\n");
 402	doc_flash_sequence(docg3, DOC_SEQ_PAGE_SIZE_532);
 403	doc_flash_command(docg3, DOC_CMD_PAGE_SIZE_532);
 404	doc_delay(docg3, 2);
 405
 406	fctrl = doc_register_readb(docg3, DOC_FLASHCONTROL);
 407	if (fctrl & (DOC_CTRL_PROTECTION_ERROR | DOC_CTRL_SEQUENCE_ERROR))
 408		return -EIO;
 409	else
 410		return 0;
 411}
 412
 413/**
 414 * doc_setup_addr_sector - Setup blocks/page/ofs address for one plane
 415 * @docg3: the device
 416 * @sector: the sector
 417 */
 418static void doc_setup_addr_sector(struct docg3 *docg3, int sector)
 419{
 420	doc_delay(docg3, 1);
 421	doc_flash_address(docg3, sector & 0xff);
 422	doc_flash_address(docg3, (sector >> 8) & 0xff);
 423	doc_flash_address(docg3, (sector >> 16) & 0xff);
 424	doc_delay(docg3, 1);
 425}
 426
 427/**
 428 * doc_setup_writeaddr_sector - Setup blocks/page/ofs address for one plane
 429 * @docg3: the device
 430 * @sector: the sector
 431 * @ofs: the offset in the page, between 0 and (512 + 16 + 512)
 432 */
 433static void doc_setup_writeaddr_sector(struct docg3 *docg3, int sector, int ofs)
 434{
 435	ofs = ofs >> 2;
 436	doc_delay(docg3, 1);
 437	doc_flash_address(docg3, ofs & 0xff);
 438	doc_flash_address(docg3, sector & 0xff);
 439	doc_flash_address(docg3, (sector >> 8) & 0xff);
 440	doc_flash_address(docg3, (sector >> 16) & 0xff);
 441	doc_delay(docg3, 1);
 442}
 443
 444/**
 445 * doc_read_seek - Set both flash planes to the specified block, page for reading
 446 * @docg3: the device
 447 * @block0: the first plane block index
 448 * @block1: the second plane block index
 449 * @page: the page index within the block
 450 * @wear: if true, read will occur on the 4 extra bytes of the wear area
 451 * @ofs: offset in page to read
 452 *
 453 * Programs the flash even and odd planes to the specific block and page.
 454 * Alternatively, programs the flash to the wear area of the specified page.
 455 */
 456static int doc_read_seek(struct docg3 *docg3, int block0, int block1, int page,
 457			 int wear, int ofs)
 458{
 459	int sector, ret = 0;
 460
 461	doc_dbg("doc_seek(blocks=(%d,%d), page=%d, ofs=%d, wear=%d)\n",
 462		block0, block1, page, ofs, wear);
 463
 464	if (!wear && (ofs < 2 * DOC_LAYOUT_PAGE_SIZE)) {
 465		doc_flash_sequence(docg3, DOC_SEQ_SET_PLANE1);
 466		doc_flash_command(docg3, DOC_CMD_READ_PLANE1);
 467		doc_delay(docg3, 2);
 468	} else {
 469		doc_flash_sequence(docg3, DOC_SEQ_SET_PLANE2);
 470		doc_flash_command(docg3, DOC_CMD_READ_PLANE2);
 471		doc_delay(docg3, 2);
 472	}
 473
 474	doc_set_reliable_mode(docg3);
 475	if (wear)
 476		ret = doc_set_extra_page_mode(docg3);
 477	if (ret)
 478		goto out;
 479
 480	doc_flash_sequence(docg3, DOC_SEQ_READ);
 481	sector = (block0 << DOC_ADDR_BLOCK_SHIFT) + (page & DOC_ADDR_PAGE_MASK);
 482	doc_flash_command(docg3, DOC_CMD_PROG_BLOCK_ADDR);
 483	doc_setup_addr_sector(docg3, sector);
 484
 485	sector = (block1 << DOC_ADDR_BLOCK_SHIFT) + (page & DOC_ADDR_PAGE_MASK);
 486	doc_flash_command(docg3, DOC_CMD_PROG_BLOCK_ADDR);
 487	doc_setup_addr_sector(docg3, sector);
 488	doc_delay(docg3, 1);
 489
 490out:
 491	return ret;
 492}
 493
 494/**
 495 * doc_write_seek - Set both flash planes to the specified block, page for writing
 496 * @docg3: the device
 497 * @block0: the first plane block index
 498 * @block1: the second plane block index
 499 * @page: the page index within the block
 500 * @ofs: offset in page to write
 501 *
 502 * Programs the flash even and odd planes to the specific block and page.
 503 * Alternatively, programs the flash to the wear area of the specified page.
 504 */
 505static int doc_write_seek(struct docg3 *docg3, int block0, int block1, int page,
 506			 int ofs)
 507{
 508	int ret = 0, sector;
 509
 510	doc_dbg("doc_write_seek(blocks=(%d,%d), page=%d, ofs=%d)\n",
 511		block0, block1, page, ofs);
 512
 513	doc_set_reliable_mode(docg3);
 514
 515	if (ofs < 2 * DOC_LAYOUT_PAGE_SIZE) {
 516		doc_flash_sequence(docg3, DOC_SEQ_SET_PLANE1);
 517		doc_flash_command(docg3, DOC_CMD_READ_PLANE1);
 518		doc_delay(docg3, 2);
 519	} else {
 520		doc_flash_sequence(docg3, DOC_SEQ_SET_PLANE2);
 521		doc_flash_command(docg3, DOC_CMD_READ_PLANE2);
 522		doc_delay(docg3, 2);
 523	}
 524
 525	doc_flash_sequence(docg3, DOC_SEQ_PAGE_SETUP);
 526	doc_flash_command(docg3, DOC_CMD_PROG_CYCLE1);
 527
 528	sector = (block0 << DOC_ADDR_BLOCK_SHIFT) + (page & DOC_ADDR_PAGE_MASK);
 529	doc_setup_writeaddr_sector(docg3, sector, ofs);
 530
 531	doc_flash_command(docg3, DOC_CMD_PROG_CYCLE3);
 532	doc_delay(docg3, 2);
 533	ret = doc_wait_ready(docg3);
 534	if (ret)
 535		goto out;
 536
 537	doc_flash_command(docg3, DOC_CMD_PROG_CYCLE1);
 538	sector = (block1 << DOC_ADDR_BLOCK_SHIFT) + (page & DOC_ADDR_PAGE_MASK);
 539	doc_setup_writeaddr_sector(docg3, sector, ofs);
 540	doc_delay(docg3, 1);
 541
 542out:
 543	return ret;
 544}
 545
 546
 547/**
 548 * doc_read_page_ecc_init - Initialize hardware ECC engine
 549 * @docg3: the device
 550 * @len: the number of bytes covered by the ECC (BCH covered)
 551 *
 552 * The function does initialize the hardware ECC engine to compute the Hamming
 553 * ECC (on 1 byte) and the BCH hardware ECC (on 7 bytes).
 554 *
 555 * Return 0 if succeeded, -EIO on error
 556 */
 557static int doc_read_page_ecc_init(struct docg3 *docg3, int len)
 558{
 559	doc_writew(docg3, DOC_ECCCONF0_READ_MODE
 560		   | DOC_ECCCONF0_BCH_ENABLE | DOC_ECCCONF0_HAMMING_ENABLE
 561		   | (len & DOC_ECCCONF0_DATA_BYTES_MASK),
 562		   DOC_ECCCONF0);
 563	doc_delay(docg3, 4);
 564	doc_register_readb(docg3, DOC_FLASHCONTROL);
 565	return doc_wait_ready(docg3);
 566}
 567
 568/**
 569 * doc_write_page_ecc_init - Initialize hardware BCH ECC engine
 570 * @docg3: the device
 571 * @len: the number of bytes covered by the ECC (BCH covered)
 572 *
 573 * The function does initialize the hardware ECC engine to compute the Hamming
 574 * ECC (on 1 byte) and the BCH hardware ECC (on 7 bytes).
 575 *
 576 * Return 0 if succeeded, -EIO on error
 577 */
 578static int doc_write_page_ecc_init(struct docg3 *docg3, int len)
 579{
 580	doc_writew(docg3, DOC_ECCCONF0_WRITE_MODE
 581		   | DOC_ECCCONF0_BCH_ENABLE | DOC_ECCCONF0_HAMMING_ENABLE
 582		   | (len & DOC_ECCCONF0_DATA_BYTES_MASK),
 583		   DOC_ECCCONF0);
 584	doc_delay(docg3, 4);
 585	doc_register_readb(docg3, DOC_FLASHCONTROL);
 586	return doc_wait_ready(docg3);
 587}
 588
 589/**
 590 * doc_ecc_disable - Disable Hamming and BCH ECC hardware calculator
 591 * @docg3: the device
 592 *
 593 * Disables the hardware ECC generator and checker, for unchecked reads (as when
 594 * reading OOB only or write status byte).
 595 */
 596static void doc_ecc_disable(struct docg3 *docg3)
 597{
 598	doc_writew(docg3, DOC_ECCCONF0_READ_MODE, DOC_ECCCONF0);
 599	doc_delay(docg3, 4);
 600}
 601
 602/**
 603 * doc_hamming_ecc_init - Initialize hardware Hamming ECC engine
 604 * @docg3: the device
 605 * @nb_bytes: the number of bytes covered by the ECC (Hamming covered)
 606 *
 607 * This function programs the ECC hardware to compute the hamming code on the
 608 * last provided N bytes to the hardware generator.
 609 */
 610static void doc_hamming_ecc_init(struct docg3 *docg3, int nb_bytes)
 611{
 612	u8 ecc_conf1;
 613
 614	ecc_conf1 = doc_register_readb(docg3, DOC_ECCCONF1);
 615	ecc_conf1 &= ~DOC_ECCCONF1_HAMMING_BITS_MASK;
 616	ecc_conf1 |= (nb_bytes & DOC_ECCCONF1_HAMMING_BITS_MASK);
 617	doc_writeb(docg3, ecc_conf1, DOC_ECCCONF1);
 618}
 619
 620/**
 621 * doc_ecc_bch_fix_data - Fix if need be read data from flash
 622 * @docg3: the device
 623 * @buf: the buffer of read data (512 + 7 + 1 bytes)
 624 * @hwecc: the hardware calculated ECC.
 625 *         It's in fact recv_ecc ^ calc_ecc, where recv_ecc was read from OOB
 626 *         area data, and calc_ecc the ECC calculated by the hardware generator.
 627 *
 628 * Checks if the received data matches the ECC, and if an error is detected,
 629 * tries to fix the bit flips (at most 4) in the buffer buf.  As the docg3
 630 * understands the (data, ecc, syndroms) in an inverted order in comparison to
 631 * the BCH library, the function reverses the order of bits (ie. bit7 and bit0,
 632 * bit6 and bit 1, ...) for all ECC data.
 633 *
 634 * The hardware ecc unit produces oob_ecc ^ calc_ecc.  The kernel's bch
 635 * algorithm is used to decode this.  However the hw operates on page
 636 * data in a bit order that is the reverse of that of the bch alg,
 637 * requiring that the bits be reversed on the result.  Thanks to Ivan
 638 * Djelic for his analysis.
 639 *
 640 * Returns number of fixed bits (0, 1, 2, 3, 4) or -EBADMSG if too many bit
 641 * errors were detected and cannot be fixed.
 642 */
 643static int doc_ecc_bch_fix_data(struct docg3 *docg3, void *buf, u8 *hwecc)
 644{
 645	u8 ecc[DOC_ECC_BCH_SIZE];
 646	int errorpos[DOC_ECC_BCH_T], i, numerrs;
 647
 648	for (i = 0; i < DOC_ECC_BCH_SIZE; i++)
 649		ecc[i] = bitrev8(hwecc[i]);
 650	numerrs = bch_decode(docg3->cascade->bch, NULL,
 651			     DOC_ECC_BCH_COVERED_BYTES,
 652			     NULL, ecc, NULL, errorpos);
 653	BUG_ON(numerrs == -EINVAL);
 654	if (numerrs < 0)
 655		goto out;
 656
 657	for (i = 0; i < numerrs; i++)
 658		errorpos[i] = (errorpos[i] & ~7) | (7 - (errorpos[i] & 7));
 659	for (i = 0; i < numerrs; i++)
 660		if (errorpos[i] < DOC_ECC_BCH_COVERED_BYTES*8)
 661			/* error is located in data, correct it */
 662			change_bit(errorpos[i], buf);
 663out:
 664	doc_dbg("doc_ecc_bch_fix_data: flipped %d bits\n", numerrs);
 665	return numerrs;
 666}
 667
 668
 669/**
 670 * doc_read_page_prepare - Prepares reading data from a flash page
 671 * @docg3: the device
 672 * @block0: the first plane block index on flash memory
 673 * @block1: the second plane block index on flash memory
 674 * @page: the page index in the block
 675 * @offset: the offset in the page (must be a multiple of 4)
 676 *
 677 * Prepares the page to be read in the flash memory :
 678 *   - tell ASIC to map the flash pages
 679 *   - tell ASIC to be in read mode
 680 *
 681 * After a call to this method, a call to doc_read_page_finish is mandatory,
 682 * to end the read cycle of the flash.
 683 *
 684 * Read data from a flash page. The length to be read must be between 0 and
 685 * (page_size + oob_size + wear_size), ie. 532, and a multiple of 4 (because
 686 * the extra bytes reading is not implemented).
 687 *
 688 * As pages are grouped by 2 (in 2 planes), reading from a page must be done
 689 * in two steps:
 690 *  - one read of 512 bytes at offset 0
 691 *  - one read of 512 bytes at offset 512 + 16
 692 *
 693 * Returns 0 if successful, -EIO if a read error occurred.
 694 */
 695static int doc_read_page_prepare(struct docg3 *docg3, int block0, int block1,
 696				 int page, int offset)
 697{
 698	int wear_area = 0, ret = 0;
 699
 700	doc_dbg("doc_read_page_prepare(blocks=(%d,%d), page=%d, ofsInPage=%d)\n",
 701		block0, block1, page, offset);
 702	if (offset >= DOC_LAYOUT_WEAR_OFFSET)
 703		wear_area = 1;
 704	if (!wear_area && offset > (DOC_LAYOUT_PAGE_OOB_SIZE * 2))
 705		return -EINVAL;
 706
 707	doc_set_device_id(docg3, docg3->device_id);
 708	ret = doc_reset_seq(docg3);
 709	if (ret)
 710		goto err;
 711
 712	/* Program the flash address block and page */
 713	ret = doc_read_seek(docg3, block0, block1, page, wear_area, offset);
 714	if (ret)
 715		goto err;
 716
 717	doc_flash_command(docg3, DOC_CMD_READ_ALL_PLANES);
 718	doc_delay(docg3, 2);
 719	doc_wait_ready(docg3);
 720
 721	doc_flash_command(docg3, DOC_CMD_SET_ADDR_READ);
 722	doc_delay(docg3, 1);
 723	if (offset >= DOC_LAYOUT_PAGE_SIZE * 2)
 724		offset -= 2 * DOC_LAYOUT_PAGE_SIZE;
 725	doc_flash_address(docg3, offset >> 2);
 726	doc_delay(docg3, 1);
 727	doc_wait_ready(docg3);
 728
 729	doc_flash_command(docg3, DOC_CMD_READ_FLASH);
 730
 731	return 0;
 732err:
 733	doc_writeb(docg3, 0, DOC_DATAEND);
 734	doc_delay(docg3, 2);
 735	return -EIO;
 736}
 737
 738/**
 739 * doc_read_page_getbytes - Reads bytes from a prepared page
 740 * @docg3: the device
 741 * @len: the number of bytes to be read (must be a multiple of 4)
 742 * @buf: the buffer to be filled in (or NULL is forget bytes)
 743 * @first: 1 if first time read, DOC_READADDRESS should be set
 744 * @last_odd: 1 if last read ended up on an odd byte
 745 *
 746 * Reads bytes from a prepared page. There is a trickery here : if the last read
 747 * ended up on an odd offset in the 1024 bytes double page, ie. between the 2
 748 * planes, the first byte must be read apart. If a word (16bit) read was used,
 749 * the read would return the byte of plane 2 as low *and* high endian, which
 750 * will mess the read.
 751 *
 752 */
 753static int doc_read_page_getbytes(struct docg3 *docg3, int len, u_char *buf,
 754				  int first, int last_odd)
 755{
 756	if (last_odd && len > 0) {
 757		doc_read_data_area(docg3, buf, 1, first);
 758		doc_read_data_area(docg3, buf ? buf + 1 : buf, len - 1, 0);
 759	} else {
 760		doc_read_data_area(docg3, buf, len, first);
 761	}
 762	doc_delay(docg3, 2);
 763	return len;
 764}
 765
 766/**
 767 * doc_write_page_putbytes - Writes bytes into a prepared page
 768 * @docg3: the device
 769 * @len: the number of bytes to be written
 770 * @buf: the buffer of input bytes
 771 *
 772 */
 773static void doc_write_page_putbytes(struct docg3 *docg3, int len,
 774				    const u_char *buf)
 775{
 776	doc_write_data_area(docg3, buf, len);
 777	doc_delay(docg3, 2);
 778}
 779
 780/**
 781 * doc_get_bch_hw_ecc - Get hardware calculated BCH ECC
 782 * @docg3: the device
 783 * @hwecc:  the array of 7 integers where the hardware ecc will be stored
 784 */
 785static void doc_get_bch_hw_ecc(struct docg3 *docg3, u8 *hwecc)
 786{
 787	int i;
 788
 789	for (i = 0; i < DOC_ECC_BCH_SIZE; i++)
 790		hwecc[i] = doc_register_readb(docg3, DOC_BCH_HW_ECC(i));
 791}
 792
 793/**
 794 * doc_page_finish - Ends reading/writing of a flash page
 795 * @docg3: the device
 796 */
 797static void doc_page_finish(struct docg3 *docg3)
 798{
 799	doc_writeb(docg3, 0, DOC_DATAEND);
 800	doc_delay(docg3, 2);
 801}
 802
 803/**
 804 * doc_read_page_finish - Ends reading of a flash page
 805 * @docg3: the device
 806 *
 807 * As a side effect, resets the chip selector to 0. This ensures that after each
 808 * read operation, the floor 0 is selected. Therefore, if the systems halts, the
 809 * reboot will boot on floor 0, where the IPL is.
 810 */
 811static void doc_read_page_finish(struct docg3 *docg3)
 812{
 813	doc_page_finish(docg3);
 814	doc_set_device_id(docg3, 0);
 815}
 816
 817/**
 818 * calc_block_sector - Calculate blocks, pages and ofs.
 819 *
 820 * @from: offset in flash
 821 * @block0: first plane block index calculated
 822 * @block1: second plane block index calculated
 823 * @page: page calculated
 824 * @ofs: offset in page
 825 * @reliable: 0 if docg3 in normal mode, 1 if docg3 in fast mode, 2 if docg3 in
 826 * reliable mode.
 827 *
 828 * The calculation is based on the reliable/normal mode. In normal mode, the 64
 829 * pages of a block are available. In reliable mode, as pages 2*n and 2*n+1 are
 830 * clones, only 32 pages per block are available.
 831 */
 832static void calc_block_sector(loff_t from, int *block0, int *block1, int *page,
 833			      int *ofs, int reliable)
 834{
 835	uint sector, pages_biblock;
 836
 837	pages_biblock = DOC_LAYOUT_PAGES_PER_BLOCK * DOC_LAYOUT_NBPLANES;
 838	if (reliable == 1 || reliable == 2)
 839		pages_biblock /= 2;
 840
 841	sector = from / DOC_LAYOUT_PAGE_SIZE;
 842	*block0 = sector / pages_biblock * DOC_LAYOUT_NBPLANES;
 843	*block1 = *block0 + 1;
 844	*page = sector % pages_biblock;
 845	*page /= DOC_LAYOUT_NBPLANES;
 846	if (reliable == 1 || reliable == 2)
 847		*page *= 2;
 848	if (sector % 2)
 849		*ofs = DOC_LAYOUT_PAGE_OOB_SIZE;
 850	else
 851		*ofs = 0;
 852}
 853
 854/**
 855 * doc_read_oob - Read out of band bytes from flash
 856 * @mtd: the device
 857 * @from: the offset from first block and first page, in bytes, aligned on page
 858 *        size
 859 * @ops: the mtd oob structure
 860 *
 861 * Reads flash memory OOB area of pages.
 862 *
 863 * Returns 0 if read successful, of -EIO, -EINVAL if an error occurred
 864 */
 865static int doc_read_oob(struct mtd_info *mtd, loff_t from,
 866			struct mtd_oob_ops *ops)
 867{
 868	struct docg3 *docg3 = mtd->priv;
 869	int block0, block1, page, ret, skip, ofs = 0;
 870	u8 *oobbuf = ops->oobbuf;
 871	u8 *buf = ops->datbuf;
 872	size_t len, ooblen, nbdata, nboob;
 873	u8 hwecc[DOC_ECC_BCH_SIZE], eccconf1;
 874	struct mtd_ecc_stats old_stats;
 875	int max_bitflips = 0;
 876
 877	if (buf)
 878		len = ops->len;
 879	else
 880		len = 0;
 881	if (oobbuf)
 882		ooblen = ops->ooblen;
 883	else
 884		ooblen = 0;
 885
 886	if (oobbuf && ops->mode == MTD_OPS_PLACE_OOB)
 887		oobbuf += ops->ooboffs;
 888
 889	doc_dbg("doc_read_oob(from=%lld, mode=%d, data=(%p:%zu), oob=(%p:%zu))\n",
 890		from, ops->mode, buf, len, oobbuf, ooblen);
 891	if (ooblen % DOC_LAYOUT_OOB_SIZE)
 892		return -EINVAL;
 893
 
 
 
 894	ops->oobretlen = 0;
 895	ops->retlen = 0;
 896	ret = 0;
 897	skip = from % DOC_LAYOUT_PAGE_SIZE;
 898	mutex_lock(&docg3->cascade->lock);
 899	old_stats = mtd->ecc_stats;
 900	while (ret >= 0 && (len > 0 || ooblen > 0)) {
 901		calc_block_sector(from - skip, &block0, &block1, &page, &ofs,
 902			docg3->reliable);
 903		nbdata = min_t(size_t, len, DOC_LAYOUT_PAGE_SIZE - skip);
 904		nboob = min_t(size_t, ooblen, (size_t)DOC_LAYOUT_OOB_SIZE);
 905		ret = doc_read_page_prepare(docg3, block0, block1, page, ofs);
 906		if (ret < 0)
 907			goto out;
 908		ret = doc_read_page_ecc_init(docg3, DOC_ECC_BCH_TOTAL_BYTES);
 909		if (ret < 0)
 910			goto err_in_read;
 911		ret = doc_read_page_getbytes(docg3, skip, NULL, 1, 0);
 912		if (ret < skip)
 913			goto err_in_read;
 914		ret = doc_read_page_getbytes(docg3, nbdata, buf, 0, skip % 2);
 915		if (ret < nbdata)
 916			goto err_in_read;
 917		doc_read_page_getbytes(docg3,
 918				       DOC_LAYOUT_PAGE_SIZE - nbdata - skip,
 919				       NULL, 0, (skip + nbdata) % 2);
 920		ret = doc_read_page_getbytes(docg3, nboob, oobbuf, 0, 0);
 921		if (ret < nboob)
 922			goto err_in_read;
 923		doc_read_page_getbytes(docg3, DOC_LAYOUT_OOB_SIZE - nboob,
 924				       NULL, 0, nboob % 2);
 925
 926		doc_get_bch_hw_ecc(docg3, hwecc);
 927		eccconf1 = doc_register_readb(docg3, DOC_ECCCONF1);
 928
 929		if (nboob >= DOC_LAYOUT_OOB_SIZE) {
 930			doc_dbg("OOB - INFO: %*phC\n", 7, oobbuf);
 931			doc_dbg("OOB - HAMMING: %02x\n", oobbuf[7]);
 932			doc_dbg("OOB - BCH_ECC: %*phC\n", 7, oobbuf + 8);
 933			doc_dbg("OOB - UNUSED: %02x\n", oobbuf[15]);
 934		}
 935		doc_dbg("ECC checks: ECCConf1=%x\n", eccconf1);
 936		doc_dbg("ECC HW_ECC: %*phC\n", 7, hwecc);
 937
 938		ret = -EIO;
 939		if (is_prot_seq_error(docg3))
 940			goto err_in_read;
 941		ret = 0;
 942		if ((block0 >= DOC_LAYOUT_BLOCK_FIRST_DATA) &&
 943		    (eccconf1 & DOC_ECCCONF1_BCH_SYNDROM_ERR) &&
 944		    (eccconf1 & DOC_ECCCONF1_PAGE_IS_WRITTEN) &&
 945		    (ops->mode != MTD_OPS_RAW) &&
 946		    (nbdata == DOC_LAYOUT_PAGE_SIZE)) {
 947			ret = doc_ecc_bch_fix_data(docg3, buf, hwecc);
 948			if (ret < 0) {
 949				mtd->ecc_stats.failed++;
 950				ret = -EBADMSG;
 951			}
 952			if (ret > 0) {
 953				mtd->ecc_stats.corrected += ret;
 954				max_bitflips = max(max_bitflips, ret);
 955				ret = max_bitflips;
 956			}
 957		}
 958
 959		doc_read_page_finish(docg3);
 960		ops->retlen += nbdata;
 961		ops->oobretlen += nboob;
 962		buf += nbdata;
 963		oobbuf += nboob;
 964		len -= nbdata;
 965		ooblen -= nboob;
 966		from += DOC_LAYOUT_PAGE_SIZE;
 967		skip = 0;
 968	}
 969
 970out:
 971	if (ops->stats) {
 972		ops->stats->uncorrectable_errors +=
 973			mtd->ecc_stats.failed - old_stats.failed;
 974		ops->stats->corrected_bitflips +=
 975			mtd->ecc_stats.corrected - old_stats.corrected;
 976	}
 977	mutex_unlock(&docg3->cascade->lock);
 978	return ret;
 979err_in_read:
 980	doc_read_page_finish(docg3);
 981	goto out;
 982}
 983
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 984static int doc_reload_bbt(struct docg3 *docg3)
 985{
 986	int block = DOC_LAYOUT_BLOCK_BBT;
 987	int ret = 0, nbpages, page;
 988	u_char *buf = docg3->bbt;
 989
 990	nbpages = DIV_ROUND_UP(docg3->max_block + 1, 8 * DOC_LAYOUT_PAGE_SIZE);
 991	for (page = 0; !ret && (page < nbpages); page++) {
 992		ret = doc_read_page_prepare(docg3, block, block + 1,
 993					    page + DOC_LAYOUT_PAGE_BBT, 0);
 994		if (!ret)
 995			ret = doc_read_page_ecc_init(docg3,
 996						     DOC_LAYOUT_PAGE_SIZE);
 997		if (!ret)
 998			doc_read_page_getbytes(docg3, DOC_LAYOUT_PAGE_SIZE,
 999					       buf, 1, 0);
1000		buf += DOC_LAYOUT_PAGE_SIZE;
1001	}
1002	doc_read_page_finish(docg3);
1003	return ret;
1004}
1005
1006/**
1007 * doc_block_isbad - Checks whether a block is good or not
1008 * @mtd: the device
1009 * @from: the offset to find the correct block
1010 *
1011 * Returns 1 if block is bad, 0 if block is good
1012 */
1013static int doc_block_isbad(struct mtd_info *mtd, loff_t from)
1014{
1015	struct docg3 *docg3 = mtd->priv;
1016	int block0, block1, page, ofs, is_good;
1017
1018	calc_block_sector(from, &block0, &block1, &page, &ofs,
1019		docg3->reliable);
1020	doc_dbg("doc_block_isbad(from=%lld) => block=(%d,%d), page=%d, ofs=%d\n",
1021		from, block0, block1, page, ofs);
1022
1023	if (block0 < DOC_LAYOUT_BLOCK_FIRST_DATA)
1024		return 0;
1025	if (block1 > docg3->max_block)
1026		return -EINVAL;
1027
1028	is_good = docg3->bbt[block0 >> 3] & (1 << (block0 & 0x7));
1029	return !is_good;
1030}
1031
1032#if 0
1033/**
1034 * doc_get_erase_count - Get block erase count
1035 * @docg3: the device
1036 * @from: the offset in which the block is.
1037 *
1038 * Get the number of times a block was erased. The number is the maximum of
1039 * erase times between first and second plane (which should be equal normally).
1040 *
1041 * Returns The number of erases, or -EINVAL or -EIO on error.
1042 */
1043static int doc_get_erase_count(struct docg3 *docg3, loff_t from)
1044{
1045	u8 buf[DOC_LAYOUT_WEAR_SIZE];
1046	int ret, plane1_erase_count, plane2_erase_count;
1047	int block0, block1, page, ofs;
1048
1049	doc_dbg("doc_get_erase_count(from=%lld, buf=%p)\n", from, buf);
1050	if (from % DOC_LAYOUT_PAGE_SIZE)
1051		return -EINVAL;
1052	calc_block_sector(from, &block0, &block1, &page, &ofs, docg3->reliable);
1053	if (block1 > docg3->max_block)
1054		return -EINVAL;
1055
1056	ret = doc_reset_seq(docg3);
1057	if (!ret)
1058		ret = doc_read_page_prepare(docg3, block0, block1, page,
1059					    ofs + DOC_LAYOUT_WEAR_OFFSET, 0);
1060	if (!ret)
1061		ret = doc_read_page_getbytes(docg3, DOC_LAYOUT_WEAR_SIZE,
1062					     buf, 1, 0);
1063	doc_read_page_finish(docg3);
1064
1065	if (ret || (buf[0] != DOC_ERASE_MARK) || (buf[2] != DOC_ERASE_MARK))
1066		return -EIO;
1067	plane1_erase_count = (u8)(~buf[1]) | ((u8)(~buf[4]) << 8)
1068		| ((u8)(~buf[5]) << 16);
1069	plane2_erase_count = (u8)(~buf[3]) | ((u8)(~buf[6]) << 8)
1070		| ((u8)(~buf[7]) << 16);
1071
1072	return max(plane1_erase_count, plane2_erase_count);
1073}
1074#endif
1075
1076/**
1077 * doc_get_op_status - get erase/write operation status
1078 * @docg3: the device
1079 *
1080 * Queries the status from the chip, and returns it
1081 *
1082 * Returns the status (bits DOC_PLANES_STATUS_*)
1083 */
1084static int doc_get_op_status(struct docg3 *docg3)
1085{
1086	u8 status;
1087
1088	doc_flash_sequence(docg3, DOC_SEQ_PLANES_STATUS);
1089	doc_flash_command(docg3, DOC_CMD_PLANES_STATUS);
1090	doc_delay(docg3, 5);
1091
1092	doc_ecc_disable(docg3);
1093	doc_read_data_area(docg3, &status, 1, 1);
1094	return status;
1095}
1096
1097/**
1098 * doc_write_erase_wait_status - wait for write or erase completion
1099 * @docg3: the device
1100 *
1101 * Wait for the chip to be ready again after erase or write operation, and check
1102 * erase/write status.
1103 *
1104 * Returns 0 if erase successful, -EIO if erase/write issue, -ETIMEOUT if
1105 * timeout
1106 */
1107static int doc_write_erase_wait_status(struct docg3 *docg3)
1108{
1109	int i, status, ret = 0;
1110
1111	for (i = 0; !doc_is_ready(docg3) && i < 5; i++)
1112		msleep(20);
1113	if (!doc_is_ready(docg3)) {
1114		doc_dbg("Timeout reached and the chip is still not ready\n");
1115		ret = -EAGAIN;
1116		goto out;
1117	}
1118
1119	status = doc_get_op_status(docg3);
1120	if (status & DOC_PLANES_STATUS_FAIL) {
1121		doc_dbg("Erase/Write failed on (a) plane(s), status = %x\n",
1122			status);
1123		ret = -EIO;
1124	}
1125
1126out:
1127	doc_page_finish(docg3);
1128	return ret;
1129}
1130
1131/**
1132 * doc_erase_block - Erase a couple of blocks
1133 * @docg3: the device
1134 * @block0: the first block to erase (leftmost plane)
1135 * @block1: the second block to erase (rightmost plane)
1136 *
1137 * Erase both blocks, and return operation status
1138 *
1139 * Returns 0 if erase successful, -EIO if erase issue, -ETIMEOUT if chip not
1140 * ready for too long
1141 */
1142static int doc_erase_block(struct docg3 *docg3, int block0, int block1)
1143{
1144	int ret, sector;
1145
1146	doc_dbg("doc_erase_block(blocks=(%d,%d))\n", block0, block1);
1147	ret = doc_reset_seq(docg3);
1148	if (ret)
1149		return -EIO;
1150
1151	doc_set_reliable_mode(docg3);
1152	doc_flash_sequence(docg3, DOC_SEQ_ERASE);
1153
1154	sector = block0 << DOC_ADDR_BLOCK_SHIFT;
1155	doc_flash_command(docg3, DOC_CMD_PROG_BLOCK_ADDR);
1156	doc_setup_addr_sector(docg3, sector);
1157	sector = block1 << DOC_ADDR_BLOCK_SHIFT;
1158	doc_flash_command(docg3, DOC_CMD_PROG_BLOCK_ADDR);
1159	doc_setup_addr_sector(docg3, sector);
1160	doc_delay(docg3, 1);
1161
1162	doc_flash_command(docg3, DOC_CMD_ERASECYCLE2);
1163	doc_delay(docg3, 2);
1164
1165	if (is_prot_seq_error(docg3)) {
1166		doc_err("Erase blocks %d,%d error\n", block0, block1);
1167		return -EIO;
1168	}
1169
1170	return doc_write_erase_wait_status(docg3);
1171}
1172
1173/**
1174 * doc_erase - Erase a portion of the chip
1175 * @mtd: the device
1176 * @info: the erase info
1177 *
1178 * Erase a bunch of contiguous blocks, by pairs, as a "mtd" page of 1024 is
1179 * split into 2 pages of 512 bytes on 2 contiguous blocks.
1180 *
1181 * Returns 0 if erase successful, -EINVAL if addressing error, -EIO if erase
1182 * issue
1183 */
1184static int doc_erase(struct mtd_info *mtd, struct erase_info *info)
1185{
1186	struct docg3 *docg3 = mtd->priv;
1187	uint64_t len;
1188	int block0, block1, page, ret = 0, ofs = 0;
1189
1190	doc_dbg("doc_erase(from=%lld, len=%lld\n", info->addr, info->len);
1191
 
1192	calc_block_sector(info->addr + info->len, &block0, &block1, &page,
1193			  &ofs, docg3->reliable);
 
1194	if (info->addr + info->len > mtd->size || page || ofs)
1195		return -EINVAL;
1196
 
1197	calc_block_sector(info->addr, &block0, &block1, &page, &ofs,
1198			  docg3->reliable);
1199	mutex_lock(&docg3->cascade->lock);
1200	doc_set_device_id(docg3, docg3->device_id);
1201	doc_set_reliable_mode(docg3);
1202	for (len = info->len; !ret && len > 0; len -= mtd->erasesize) {
 
1203		ret = doc_erase_block(docg3, block0, block1);
1204		block0 += 2;
1205		block1 += 2;
1206	}
1207	mutex_unlock(&docg3->cascade->lock);
1208
 
 
 
 
 
 
 
 
1209	return ret;
1210}
1211
1212/**
1213 * doc_write_page - Write a single page to the chip
1214 * @docg3: the device
1215 * @to: the offset from first block and first page, in bytes, aligned on page
1216 *      size
1217 * @buf: buffer to get bytes from
1218 * @oob: buffer to get out of band bytes from (can be NULL if no OOB should be
1219 *       written)
1220 * @autoecc: if 0, all 16 bytes from OOB are taken, regardless of HW Hamming or
1221 *           BCH computations. If 1, only bytes 0-7 and byte 15 are taken,
1222 *           remaining ones are filled with hardware Hamming and BCH
1223 *           computations. Its value is not meaningfull is oob == NULL.
1224 *
1225 * Write one full page (ie. 1 page split on two planes), of 512 bytes, with the
1226 * OOB data. The OOB ECC is automatically computed by the hardware Hamming and
1227 * BCH generator if autoecc is not null.
1228 *
1229 * Returns 0 if write successful, -EIO if write error, -EAGAIN if timeout
1230 */
1231static int doc_write_page(struct docg3 *docg3, loff_t to, const u_char *buf,
1232			  const u_char *oob, int autoecc)
1233{
1234	int block0, block1, page, ret, ofs = 0;
1235	u8 hwecc[DOC_ECC_BCH_SIZE], hamming;
1236
1237	doc_dbg("doc_write_page(to=%lld)\n", to);
1238	calc_block_sector(to, &block0, &block1, &page, &ofs, docg3->reliable);
1239
1240	doc_set_device_id(docg3, docg3->device_id);
1241	ret = doc_reset_seq(docg3);
1242	if (ret)
1243		goto err;
1244
1245	/* Program the flash address block and page */
1246	ret = doc_write_seek(docg3, block0, block1, page, ofs);
1247	if (ret)
1248		goto err;
1249
1250	doc_write_page_ecc_init(docg3, DOC_ECC_BCH_TOTAL_BYTES);
1251	doc_delay(docg3, 2);
1252	doc_write_page_putbytes(docg3, DOC_LAYOUT_PAGE_SIZE, buf);
1253
1254	if (oob && autoecc) {
1255		doc_write_page_putbytes(docg3, DOC_LAYOUT_OOB_PAGEINFO_SZ, oob);
1256		doc_delay(docg3, 2);
1257		oob += DOC_LAYOUT_OOB_UNUSED_OFS;
1258
1259		hamming = doc_register_readb(docg3, DOC_HAMMINGPARITY);
1260		doc_delay(docg3, 2);
1261		doc_write_page_putbytes(docg3, DOC_LAYOUT_OOB_HAMMING_SZ,
1262					&hamming);
1263		doc_delay(docg3, 2);
1264
1265		doc_get_bch_hw_ecc(docg3, hwecc);
1266		doc_write_page_putbytes(docg3, DOC_LAYOUT_OOB_BCH_SZ, hwecc);
1267		doc_delay(docg3, 2);
1268
1269		doc_write_page_putbytes(docg3, DOC_LAYOUT_OOB_UNUSED_SZ, oob);
1270	}
1271	if (oob && !autoecc)
1272		doc_write_page_putbytes(docg3, DOC_LAYOUT_OOB_SIZE, oob);
1273
1274	doc_delay(docg3, 2);
1275	doc_page_finish(docg3);
1276	doc_delay(docg3, 2);
1277	doc_flash_command(docg3, DOC_CMD_PROG_CYCLE2);
1278	doc_delay(docg3, 2);
1279
1280	/*
1281	 * The wait status will perform another doc_page_finish() call, but that
1282	 * seems to please the docg3, so leave it.
1283	 */
1284	ret = doc_write_erase_wait_status(docg3);
1285	return ret;
1286err:
1287	doc_read_page_finish(docg3);
1288	return ret;
1289}
1290
1291/**
1292 * doc_guess_autoecc - Guess autoecc mode from mbd_oob_ops
1293 * @ops: the oob operations
1294 *
1295 * Returns 0 or 1 if success, -EINVAL if invalid oob mode
1296 */
1297static int doc_guess_autoecc(struct mtd_oob_ops *ops)
1298{
1299	int autoecc;
1300
1301	switch (ops->mode) {
1302	case MTD_OPS_PLACE_OOB:
1303	case MTD_OPS_AUTO_OOB:
1304		autoecc = 1;
1305		break;
1306	case MTD_OPS_RAW:
1307		autoecc = 0;
1308		break;
1309	default:
1310		autoecc = -EINVAL;
1311	}
1312	return autoecc;
1313}
1314
1315/**
1316 * doc_fill_autooob - Fill a 16 bytes OOB from 8 non-ECC bytes
1317 * @dst: the target 16 bytes OOB buffer
1318 * @oobsrc: the source 8 bytes non-ECC OOB buffer
1319 *
1320 */
1321static void doc_fill_autooob(u8 *dst, u8 *oobsrc)
1322{
1323	memcpy(dst, oobsrc, DOC_LAYOUT_OOB_PAGEINFO_SZ);
1324	dst[DOC_LAYOUT_OOB_UNUSED_OFS] = oobsrc[DOC_LAYOUT_OOB_PAGEINFO_SZ];
1325}
1326
1327/**
1328 * doc_backup_oob - Backup OOB into docg3 structure
1329 * @docg3: the device
1330 * @to: the page offset in the chip
1331 * @ops: the OOB size and buffer
1332 *
1333 * As the docg3 should write a page with its OOB in one pass, and some userland
1334 * applications do write_oob() to setup the OOB and then write(), store the OOB
1335 * into a temporary storage. This is very dangerous, as 2 concurrent
1336 * applications could store an OOB, and then write their pages (which will
1337 * result into one having its OOB corrupted).
1338 *
1339 * The only reliable way would be for userland to call doc_write_oob() with both
1340 * the page data _and_ the OOB area.
1341 *
1342 * Returns 0 if success, -EINVAL if ops content invalid
1343 */
1344static int doc_backup_oob(struct docg3 *docg3, loff_t to,
1345			  struct mtd_oob_ops *ops)
1346{
1347	int ooblen = ops->ooblen, autoecc;
1348
1349	if (ooblen != DOC_LAYOUT_OOB_SIZE)
1350		return -EINVAL;
1351	autoecc = doc_guess_autoecc(ops);
1352	if (autoecc < 0)
1353		return autoecc;
1354
1355	docg3->oob_write_ofs = to;
1356	docg3->oob_autoecc = autoecc;
1357	if (ops->mode == MTD_OPS_AUTO_OOB) {
1358		doc_fill_autooob(docg3->oob_write_buf, ops->oobbuf);
1359		ops->oobretlen = 8;
1360	} else {
1361		memcpy(docg3->oob_write_buf, ops->oobbuf, DOC_LAYOUT_OOB_SIZE);
1362		ops->oobretlen = DOC_LAYOUT_OOB_SIZE;
1363	}
1364	return 0;
1365}
1366
1367/**
1368 * doc_write_oob - Write out of band bytes to flash
1369 * @mtd: the device
1370 * @ofs: the offset from first block and first page, in bytes, aligned on page
1371 *       size
1372 * @ops: the mtd oob structure
1373 *
1374 * Either write OOB data into a temporary buffer, for the subsequent write
1375 * page. The provided OOB should be 16 bytes long. If a data buffer is provided
1376 * as well, issue the page write.
1377 * Or provide data without OOB, and then a all zeroed OOB will be used (ECC will
1378 * still be filled in if asked for).
1379 *
1380 * Returns 0 is successful, EINVAL if length is not 14 bytes
1381 */
1382static int doc_write_oob(struct mtd_info *mtd, loff_t ofs,
1383			 struct mtd_oob_ops *ops)
1384{
1385	struct docg3 *docg3 = mtd->priv;
1386	int ret, autoecc, oobdelta;
1387	u8 *oobbuf = ops->oobbuf;
1388	u8 *buf = ops->datbuf;
1389	size_t len, ooblen;
1390	u8 oob[DOC_LAYOUT_OOB_SIZE];
1391
1392	if (buf)
1393		len = ops->len;
1394	else
1395		len = 0;
1396	if (oobbuf)
1397		ooblen = ops->ooblen;
1398	else
1399		ooblen = 0;
1400
1401	if (oobbuf && ops->mode == MTD_OPS_PLACE_OOB)
1402		oobbuf += ops->ooboffs;
1403
1404	doc_dbg("doc_write_oob(from=%lld, mode=%d, data=(%p:%zu), oob=(%p:%zu))\n",
1405		ofs, ops->mode, buf, len, oobbuf, ooblen);
1406	switch (ops->mode) {
1407	case MTD_OPS_PLACE_OOB:
1408	case MTD_OPS_RAW:
1409		oobdelta = mtd->oobsize;
1410		break;
1411	case MTD_OPS_AUTO_OOB:
1412		oobdelta = mtd->oobavail;
1413		break;
1414	default:
1415		return -EINVAL;
1416	}
1417	if ((len % DOC_LAYOUT_PAGE_SIZE) || (ooblen % oobdelta) ||
1418	    (ofs % DOC_LAYOUT_PAGE_SIZE))
1419		return -EINVAL;
1420	if (len && ooblen &&
1421	    (len / DOC_LAYOUT_PAGE_SIZE) != (ooblen / oobdelta))
1422		return -EINVAL;
 
 
1423
1424	ops->oobretlen = 0;
1425	ops->retlen = 0;
1426	ret = 0;
1427	if (len == 0 && ooblen == 0)
1428		return -EINVAL;
1429	if (len == 0 && ooblen > 0)
1430		return doc_backup_oob(docg3, ofs, ops);
1431
1432	autoecc = doc_guess_autoecc(ops);
1433	if (autoecc < 0)
1434		return autoecc;
1435
1436	mutex_lock(&docg3->cascade->lock);
1437	while (!ret && len > 0) {
1438		memset(oob, 0, sizeof(oob));
1439		if (ofs == docg3->oob_write_ofs)
1440			memcpy(oob, docg3->oob_write_buf, DOC_LAYOUT_OOB_SIZE);
1441		else if (ooblen > 0 && ops->mode == MTD_OPS_AUTO_OOB)
1442			doc_fill_autooob(oob, oobbuf);
1443		else if (ooblen > 0)
1444			memcpy(oob, oobbuf, DOC_LAYOUT_OOB_SIZE);
1445		ret = doc_write_page(docg3, ofs, buf, oob, autoecc);
1446
1447		ofs += DOC_LAYOUT_PAGE_SIZE;
1448		len -= DOC_LAYOUT_PAGE_SIZE;
1449		buf += DOC_LAYOUT_PAGE_SIZE;
1450		if (ooblen) {
1451			oobbuf += oobdelta;
1452			ooblen -= oobdelta;
1453			ops->oobretlen += oobdelta;
1454		}
1455		ops->retlen += DOC_LAYOUT_PAGE_SIZE;
1456	}
1457
1458	doc_set_device_id(docg3, 0);
1459	mutex_unlock(&docg3->cascade->lock);
1460	return ret;
1461}
1462
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1463static struct docg3 *sysfs_dev2docg3(struct device *dev,
1464				     struct device_attribute *attr)
1465{
1466	int floor;
1467	struct mtd_info **docg3_floors = dev_get_drvdata(dev);
 
1468
1469	floor = attr->attr.name[1] - '0';
1470	if (floor < 0 || floor >= DOC_MAX_NBFLOORS)
1471		return NULL;
1472	else
1473		return docg3_floors[floor]->priv;
1474}
1475
1476static ssize_t dps0_is_key_locked(struct device *dev,
1477				  struct device_attribute *attr, char *buf)
1478{
1479	struct docg3 *docg3 = sysfs_dev2docg3(dev, attr);
1480	int dps0;
1481
1482	mutex_lock(&docg3->cascade->lock);
1483	doc_set_device_id(docg3, docg3->device_id);
1484	dps0 = doc_register_readb(docg3, DOC_DPS0_STATUS);
1485	doc_set_device_id(docg3, 0);
1486	mutex_unlock(&docg3->cascade->lock);
1487
1488	return sprintf(buf, "%d\n", !(dps0 & DOC_DPS_KEY_OK));
1489}
1490
1491static ssize_t dps1_is_key_locked(struct device *dev,
1492				  struct device_attribute *attr, char *buf)
1493{
1494	struct docg3 *docg3 = sysfs_dev2docg3(dev, attr);
1495	int dps1;
1496
1497	mutex_lock(&docg3->cascade->lock);
1498	doc_set_device_id(docg3, docg3->device_id);
1499	dps1 = doc_register_readb(docg3, DOC_DPS1_STATUS);
1500	doc_set_device_id(docg3, 0);
1501	mutex_unlock(&docg3->cascade->lock);
1502
1503	return sprintf(buf, "%d\n", !(dps1 & DOC_DPS_KEY_OK));
1504}
1505
1506static ssize_t dps0_insert_key(struct device *dev,
1507			       struct device_attribute *attr,
1508			       const char *buf, size_t count)
1509{
1510	struct docg3 *docg3 = sysfs_dev2docg3(dev, attr);
1511	int i;
1512
1513	if (count != DOC_LAYOUT_DPS_KEY_LENGTH)
1514		return -EINVAL;
1515
1516	mutex_lock(&docg3->cascade->lock);
1517	doc_set_device_id(docg3, docg3->device_id);
1518	for (i = 0; i < DOC_LAYOUT_DPS_KEY_LENGTH; i++)
1519		doc_writeb(docg3, buf[i], DOC_DPS0_KEY);
1520	doc_set_device_id(docg3, 0);
1521	mutex_unlock(&docg3->cascade->lock);
1522	return count;
1523}
1524
1525static ssize_t dps1_insert_key(struct device *dev,
1526			       struct device_attribute *attr,
1527			       const char *buf, size_t count)
1528{
1529	struct docg3 *docg3 = sysfs_dev2docg3(dev, attr);
1530	int i;
1531
1532	if (count != DOC_LAYOUT_DPS_KEY_LENGTH)
1533		return -EINVAL;
1534
1535	mutex_lock(&docg3->cascade->lock);
1536	doc_set_device_id(docg3, docg3->device_id);
1537	for (i = 0; i < DOC_LAYOUT_DPS_KEY_LENGTH; i++)
1538		doc_writeb(docg3, buf[i], DOC_DPS1_KEY);
1539	doc_set_device_id(docg3, 0);
1540	mutex_unlock(&docg3->cascade->lock);
1541	return count;
1542}
1543
1544#define FLOOR_SYSFS(id) { \
1545	__ATTR(f##id##_dps0_is_keylocked, S_IRUGO, dps0_is_key_locked, NULL), \
1546	__ATTR(f##id##_dps1_is_keylocked, S_IRUGO, dps1_is_key_locked, NULL), \
1547	__ATTR(f##id##_dps0_protection_key, S_IWUSR|S_IWGRP, NULL, dps0_insert_key), \
1548	__ATTR(f##id##_dps1_protection_key, S_IWUSR|S_IWGRP, NULL, dps1_insert_key), \
1549}
1550
1551static struct device_attribute doc_sys_attrs[DOC_MAX_NBFLOORS][4] = {
1552	FLOOR_SYSFS(0), FLOOR_SYSFS(1), FLOOR_SYSFS(2), FLOOR_SYSFS(3)
1553};
1554
1555static int doc_register_sysfs(struct platform_device *pdev,
1556			      struct docg3_cascade *cascade)
1557{
 
1558	struct device *dev = &pdev->dev;
1559	int floor;
1560	int ret;
1561	int i;
1562
1563	for (floor = 0;
1564	     floor < DOC_MAX_NBFLOORS && cascade->floors[floor];
1565	     floor++) {
1566		for (i = 0; i < 4; i++) {
1567			ret = device_create_file(dev, &doc_sys_attrs[floor][i]);
1568			if (ret)
1569				goto remove_files;
1570		}
1571	}
1572
1573	return 0;
1574
1575remove_files:
1576	do {
1577		while (--i >= 0)
1578			device_remove_file(dev, &doc_sys_attrs[floor][i]);
1579		i = 4;
1580	} while (--floor >= 0);
1581
1582	return ret;
1583}
1584
1585static void doc_unregister_sysfs(struct platform_device *pdev,
1586				 struct docg3_cascade *cascade)
1587{
1588	struct device *dev = &pdev->dev;
1589	int floor, i;
1590
1591	for (floor = 0; floor < DOC_MAX_NBFLOORS && cascade->floors[floor];
1592	     floor++)
1593		for (i = 0; i < 4; i++)
1594			device_remove_file(dev, &doc_sys_attrs[floor][i]);
1595}
1596
1597/*
1598 * Debug sysfs entries
1599 */
1600static int flashcontrol_show(struct seq_file *s, void *p)
1601{
1602	struct docg3 *docg3 = s->private;
1603
 
1604	u8 fctrl;
1605
1606	mutex_lock(&docg3->cascade->lock);
1607	fctrl = doc_register_readb(docg3, DOC_FLASHCONTROL);
1608	mutex_unlock(&docg3->cascade->lock);
1609
1610	seq_printf(s, "FlashControl : 0x%02x (%s,CE# %s,%s,%s,flash %s)\n",
1611		   fctrl,
1612		   fctrl & DOC_CTRL_VIOLATION ? "protocol violation" : "-",
1613		   fctrl & DOC_CTRL_CE ? "active" : "inactive",
1614		   fctrl & DOC_CTRL_PROTECTION_ERROR ? "protection error" : "-",
1615		   fctrl & DOC_CTRL_SEQUENCE_ERROR ? "sequence error" : "-",
1616		   fctrl & DOC_CTRL_FLASHREADY ? "ready" : "not ready");
1617
1618	return 0;
1619}
1620DEFINE_SHOW_ATTRIBUTE(flashcontrol);
1621
1622static int asic_mode_show(struct seq_file *s, void *p)
1623{
1624	struct docg3 *docg3 = s->private;
1625
1626	int pctrl, mode;
1627
1628	mutex_lock(&docg3->cascade->lock);
1629	pctrl = doc_register_readb(docg3, DOC_ASICMODE);
1630	mode = pctrl & 0x03;
1631	mutex_unlock(&docg3->cascade->lock);
1632
1633	seq_printf(s,
1634		   "%04x : RAM_WE=%d,RSTIN_RESET=%d,BDETCT_RESET=%d,WRITE_ENABLE=%d,POWERDOWN=%d,MODE=%d%d (",
1635		   pctrl,
1636		   pctrl & DOC_ASICMODE_RAM_WE ? 1 : 0,
1637		   pctrl & DOC_ASICMODE_RSTIN_RESET ? 1 : 0,
1638		   pctrl & DOC_ASICMODE_BDETCT_RESET ? 1 : 0,
1639		   pctrl & DOC_ASICMODE_MDWREN ? 1 : 0,
1640		   pctrl & DOC_ASICMODE_POWERDOWN ? 1 : 0,
1641		   mode >> 1, mode & 0x1);
1642
1643	switch (mode) {
1644	case DOC_ASICMODE_RESET:
1645		seq_puts(s, "reset");
1646		break;
1647	case DOC_ASICMODE_NORMAL:
1648		seq_puts(s, "normal");
1649		break;
1650	case DOC_ASICMODE_POWERDOWN:
1651		seq_puts(s, "powerdown");
1652		break;
1653	}
1654	seq_puts(s, ")\n");
1655	return 0;
1656}
1657DEFINE_SHOW_ATTRIBUTE(asic_mode);
1658
1659static int device_id_show(struct seq_file *s, void *p)
1660{
1661	struct docg3 *docg3 = s->private;
 
1662	int id;
1663
1664	mutex_lock(&docg3->cascade->lock);
1665	id = doc_register_readb(docg3, DOC_DEVICESELECT);
1666	mutex_unlock(&docg3->cascade->lock);
1667
1668	seq_printf(s, "DeviceId = %d\n", id);
1669	return 0;
1670}
1671DEFINE_SHOW_ATTRIBUTE(device_id);
1672
1673static int protection_show(struct seq_file *s, void *p)
1674{
1675	struct docg3 *docg3 = s->private;
 
1676	int protect, dps0, dps0_low, dps0_high, dps1, dps1_low, dps1_high;
1677
1678	mutex_lock(&docg3->cascade->lock);
1679	protect = doc_register_readb(docg3, DOC_PROTECTION);
1680	dps0 = doc_register_readb(docg3, DOC_DPS0_STATUS);
1681	dps0_low = doc_register_readw(docg3, DOC_DPS0_ADDRLOW);
1682	dps0_high = doc_register_readw(docg3, DOC_DPS0_ADDRHIGH);
1683	dps1 = doc_register_readb(docg3, DOC_DPS1_STATUS);
1684	dps1_low = doc_register_readw(docg3, DOC_DPS1_ADDRLOW);
1685	dps1_high = doc_register_readw(docg3, DOC_DPS1_ADDRHIGH);
1686	mutex_unlock(&docg3->cascade->lock);
1687
1688	seq_printf(s, "Protection = 0x%02x (", protect);
 
1689	if (protect & DOC_PROTECT_FOUNDRY_OTP_LOCK)
1690		seq_puts(s, "FOUNDRY_OTP_LOCK,");
1691	if (protect & DOC_PROTECT_CUSTOMER_OTP_LOCK)
1692		seq_puts(s, "CUSTOMER_OTP_LOCK,");
1693	if (protect & DOC_PROTECT_LOCK_INPUT)
1694		seq_puts(s, "LOCK_INPUT,");
1695	if (protect & DOC_PROTECT_STICKY_LOCK)
1696		seq_puts(s, "STICKY_LOCK,");
1697	if (protect & DOC_PROTECT_PROTECTION_ENABLED)
1698		seq_puts(s, "PROTECTION ON,");
1699	if (protect & DOC_PROTECT_IPL_DOWNLOAD_LOCK)
1700		seq_puts(s, "IPL_DOWNLOAD_LOCK,");
1701	if (protect & DOC_PROTECT_PROTECTION_ERROR)
1702		seq_puts(s, "PROTECT_ERR,");
1703	else
1704		seq_puts(s, "NO_PROTECT_ERR");
1705	seq_puts(s, ")\n");
1706
1707	seq_printf(s, "DPS0 = 0x%02x : Protected area [0x%x - 0x%x] : OTP=%d, READ=%d, WRITE=%d, HW_LOCK=%d, KEY_OK=%d\n",
1708		   dps0, dps0_low, dps0_high,
1709		   !!(dps0 & DOC_DPS_OTP_PROTECTED),
1710		   !!(dps0 & DOC_DPS_READ_PROTECTED),
1711		   !!(dps0 & DOC_DPS_WRITE_PROTECTED),
1712		   !!(dps0 & DOC_DPS_HW_LOCK_ENABLED),
1713		   !!(dps0 & DOC_DPS_KEY_OK));
1714	seq_printf(s, "DPS1 = 0x%02x : Protected area [0x%x - 0x%x] : OTP=%d, READ=%d, WRITE=%d, HW_LOCK=%d, KEY_OK=%d\n",
1715		   dps1, dps1_low, dps1_high,
1716		   !!(dps1 & DOC_DPS_OTP_PROTECTED),
1717		   !!(dps1 & DOC_DPS_READ_PROTECTED),
1718		   !!(dps1 & DOC_DPS_WRITE_PROTECTED),
1719		   !!(dps1 & DOC_DPS_HW_LOCK_ENABLED),
1720		   !!(dps1 & DOC_DPS_KEY_OK));
1721	return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1722}
1723DEFINE_SHOW_ATTRIBUTE(protection);
1724
1725static void __init doc_dbg_register(struct mtd_info *floor)
1726{
1727	struct dentry *root = floor->dbg.dfs_dir;
1728	struct docg3 *docg3 = floor->priv;
1729
1730	if (IS_ERR_OR_NULL(root)) {
1731		if (IS_ENABLED(CONFIG_DEBUG_FS) &&
1732		    !IS_ENABLED(CONFIG_MTD_PARTITIONED_MASTER))
1733			dev_warn(floor->dev.parent,
1734				 "CONFIG_MTD_PARTITIONED_MASTER must be enabled to expose debugfs stuff\n");
1735		return;
1736	}
1737
1738	debugfs_create_file("docg3_flashcontrol", S_IRUSR, root, docg3,
1739			    &flashcontrol_fops);
1740	debugfs_create_file("docg3_asic_mode", S_IRUSR, root, docg3,
1741			    &asic_mode_fops);
1742	debugfs_create_file("docg3_device_id", S_IRUSR, root, docg3,
1743			    &device_id_fops);
1744	debugfs_create_file("docg3_protection", S_IRUSR, root, docg3,
1745			    &protection_fops);
1746}
1747
1748/**
1749 * doc_set_driver_info - Fill the mtd_info structure and docg3 structure
1750 * @chip_id: The chip ID of the supported chip
1751 * @mtd: The structure to fill
1752 */
1753static int __init doc_set_driver_info(int chip_id, struct mtd_info *mtd)
1754{
1755	struct docg3 *docg3 = mtd->priv;
1756	int cfg;
1757
1758	cfg = doc_register_readb(docg3, DOC_CONFIGURATION);
1759	docg3->if_cfg = (cfg & DOC_CONF_IF_CFG ? 1 : 0);
1760	docg3->reliable = reliable_mode;
1761
1762	switch (chip_id) {
1763	case DOC_CHIPID_G3:
1764		mtd->name = devm_kasprintf(docg3->dev, GFP_KERNEL, "docg3.%d",
1765					   docg3->device_id);
1766		if (!mtd->name)
1767			return -ENOMEM;
1768		docg3->max_block = 2047;
1769		break;
1770	}
1771	mtd->type = MTD_NANDFLASH;
1772	mtd->flags = MTD_CAP_NANDFLASH;
1773	mtd->size = (docg3->max_block + 1) * DOC_LAYOUT_BLOCK_SIZE;
1774	if (docg3->reliable == 2)
1775		mtd->size /= 2;
1776	mtd->erasesize = DOC_LAYOUT_BLOCK_SIZE * DOC_LAYOUT_NBPLANES;
1777	if (docg3->reliable == 2)
1778		mtd->erasesize /= 2;
1779	mtd->writebufsize = mtd->writesize = DOC_LAYOUT_PAGE_SIZE;
1780	mtd->oobsize = DOC_LAYOUT_OOB_SIZE;
 
1781	mtd->_erase = doc_erase;
 
 
1782	mtd->_read_oob = doc_read_oob;
1783	mtd->_write_oob = doc_write_oob;
1784	mtd->_block_isbad = doc_block_isbad;
1785	mtd_set_ooblayout(mtd, &nand_ooblayout_docg3_ops);
1786	mtd->oobavail = 8;
1787	mtd->ecc_strength = DOC_ECC_BCH_T;
1788
1789	return 0;
1790}
1791
1792/**
1793 * doc_probe_device - Check if a device is available
1794 * @cascade: the cascade of chips this devices will belong to
1795 * @floor: the floor of the probed device
1796 * @dev: the device
 
1797 *
1798 * Checks whether a device at the specified IO range, and floor is available.
1799 *
1800 * Returns a mtd_info struct if there is a device, ENODEV if none found, ENOMEM
1801 * if a memory allocation failed. If floor 0 is checked, a reset of the ASIC is
1802 * launched.
1803 */
1804static struct mtd_info * __init
1805doc_probe_device(struct docg3_cascade *cascade, int floor, struct device *dev)
1806{
1807	int ret, bbt_nbpages;
1808	u16 chip_id, chip_id_inv;
1809	struct docg3 *docg3;
1810	struct mtd_info *mtd;
1811
1812	ret = -ENOMEM;
1813	docg3 = kzalloc(sizeof(struct docg3), GFP_KERNEL);
1814	if (!docg3)
1815		goto nomem1;
1816	mtd = kzalloc(sizeof(struct mtd_info), GFP_KERNEL);
1817	if (!mtd)
1818		goto nomem2;
1819	mtd->priv = docg3;
1820	mtd->dev.parent = dev;
1821	bbt_nbpages = DIV_ROUND_UP(docg3->max_block + 1,
1822				   8 * DOC_LAYOUT_PAGE_SIZE);
1823	docg3->bbt = kcalloc(DOC_LAYOUT_PAGE_SIZE, bbt_nbpages, GFP_KERNEL);
1824	if (!docg3->bbt)
1825		goto nomem3;
1826
1827	docg3->dev = dev;
1828	docg3->device_id = floor;
1829	docg3->cascade = cascade;
1830	doc_set_device_id(docg3, docg3->device_id);
1831	if (!floor)
1832		doc_set_asic_mode(docg3, DOC_ASICMODE_RESET);
1833	doc_set_asic_mode(docg3, DOC_ASICMODE_NORMAL);
1834
1835	chip_id = doc_register_readw(docg3, DOC_CHIPID);
1836	chip_id_inv = doc_register_readw(docg3, DOC_CHIPID_INV);
1837
1838	ret = 0;
1839	if (chip_id != (u16)(~chip_id_inv)) {
1840		goto nomem4;
1841	}
1842
1843	switch (chip_id) {
1844	case DOC_CHIPID_G3:
1845		doc_info("Found a G3 DiskOnChip at addr %p, floor %d\n",
1846			 docg3->cascade->base, floor);
1847		break;
1848	default:
1849		doc_err("Chip id %04x is not a DiskOnChip G3 chip\n", chip_id);
1850		goto nomem4;
1851	}
1852
1853	ret = doc_set_driver_info(chip_id, mtd);
1854	if (ret)
1855		goto nomem4;
1856
1857	doc_hamming_ecc_init(docg3, DOC_LAYOUT_OOB_PAGEINFO_SZ);
1858	doc_reload_bbt(docg3);
1859	return mtd;
1860
1861nomem4:
1862	kfree(docg3->bbt);
1863nomem3:
1864	kfree(mtd);
1865nomem2:
1866	kfree(docg3);
1867nomem1:
1868	return ret ? ERR_PTR(ret) : NULL;
1869}
1870
1871/**
1872 * doc_release_device - Release a docg3 floor
1873 * @mtd: the device
1874 */
1875static void doc_release_device(struct mtd_info *mtd)
1876{
1877	struct docg3 *docg3 = mtd->priv;
1878
1879	mtd_device_unregister(mtd);
1880	kfree(docg3->bbt);
1881	kfree(docg3);
 
1882	kfree(mtd);
1883}
1884
1885/**
1886 * docg3_resume - Awakens docg3 floor
1887 * @pdev: platfrom device
1888 *
1889 * Returns 0 (always successful)
1890 */
1891static int docg3_resume(struct platform_device *pdev)
1892{
1893	int i;
1894	struct docg3_cascade *cascade;
1895	struct mtd_info **docg3_floors, *mtd;
1896	struct docg3 *docg3;
1897
1898	cascade = platform_get_drvdata(pdev);
1899	docg3_floors = cascade->floors;
1900	mtd = docg3_floors[0];
1901	docg3 = mtd->priv;
1902
1903	doc_dbg("docg3_resume()\n");
1904	for (i = 0; i < 12; i++)
1905		doc_readb(docg3, DOC_IOSPACE_IPL);
1906	return 0;
1907}
1908
1909/**
1910 * docg3_suspend - Put in low power mode the docg3 floor
1911 * @pdev: platform device
1912 * @state: power state
1913 *
1914 * Shuts off most of docg3 circuitery to lower power consumption.
1915 *
1916 * Returns 0 if suspend succeeded, -EIO if chip refused suspend
1917 */
1918static int docg3_suspend(struct platform_device *pdev, pm_message_t state)
1919{
1920	int floor, i;
1921	struct docg3_cascade *cascade;
1922	struct mtd_info **docg3_floors, *mtd;
1923	struct docg3 *docg3;
1924	u8 ctrl, pwr_down;
1925
1926	cascade = platform_get_drvdata(pdev);
1927	docg3_floors = cascade->floors;
1928	for (floor = 0; floor < DOC_MAX_NBFLOORS; floor++) {
1929		mtd = docg3_floors[floor];
1930		if (!mtd)
1931			continue;
1932		docg3 = mtd->priv;
1933
1934		doc_writeb(docg3, floor, DOC_DEVICESELECT);
1935		ctrl = doc_register_readb(docg3, DOC_FLASHCONTROL);
1936		ctrl &= ~DOC_CTRL_VIOLATION & ~DOC_CTRL_CE;
1937		doc_writeb(docg3, ctrl, DOC_FLASHCONTROL);
1938
1939		for (i = 0; i < 10; i++) {
1940			usleep_range(3000, 4000);
1941			pwr_down = doc_register_readb(docg3, DOC_POWERMODE);
1942			if (pwr_down & DOC_POWERDOWN_READY)
1943				break;
1944		}
1945		if (pwr_down & DOC_POWERDOWN_READY) {
1946			doc_dbg("docg3_suspend(): floor %d powerdown ok\n",
1947				floor);
1948		} else {
1949			doc_err("docg3_suspend(): floor %d powerdown failed\n",
1950				floor);
1951			return -EIO;
1952		}
1953	}
1954
1955	mtd = docg3_floors[0];
1956	docg3 = mtd->priv;
1957	doc_set_asic_mode(docg3, DOC_ASICMODE_POWERDOWN);
1958	return 0;
1959}
1960
1961/**
1962 * docg3_probe - Probe the IO space for a DiskOnChip G3 chip
1963 * @pdev: platform device
1964 *
1965 * Probes for a G3 chip at the specified IO space in the platform data
1966 * ressources. The floor 0 must be available.
1967 *
1968 * Returns 0 on success, -ENOMEM, -ENXIO on error
1969 */
1970static int __init docg3_probe(struct platform_device *pdev)
1971{
1972	struct device *dev = &pdev->dev;
1973	struct mtd_info *mtd;
1974	struct resource *ress;
1975	void __iomem *base;
1976	int ret, floor;
1977	struct docg3_cascade *cascade;
1978
1979	ret = -ENXIO;
1980	ress = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1981	if (!ress) {
1982		dev_err(dev, "No I/O memory resource defined\n");
1983		return ret;
1984	}
1985
1986	ret = -ENOMEM;
1987	base = devm_ioremap(dev, ress->start, DOC_IOSPACE_SIZE);
1988	if (!base) {
1989		dev_err(dev, "devm_ioremap dev failed\n");
1990		return ret;
1991	}
1992
1993	cascade = devm_kcalloc(dev, DOC_MAX_NBFLOORS, sizeof(*cascade),
 
1994			       GFP_KERNEL);
1995	if (!cascade)
1996		return ret;
1997	cascade->base = base;
1998	mutex_init(&cascade->lock);
1999	cascade->bch = bch_init(DOC_ECC_BCH_M, DOC_ECC_BCH_T,
2000				DOC_ECC_BCH_PRIMPOLY, false);
2001	if (!cascade->bch)
2002		return ret;
2003
2004	for (floor = 0; floor < DOC_MAX_NBFLOORS; floor++) {
2005		mtd = doc_probe_device(cascade, floor, dev);
2006		if (IS_ERR(mtd)) {
2007			ret = PTR_ERR(mtd);
2008			goto err_probe;
2009		}
2010		if (!mtd) {
2011			if (floor == 0)
2012				goto notfound;
2013			else
2014				continue;
2015		}
2016		cascade->floors[floor] = mtd;
2017		ret = mtd_device_parse_register(mtd, part_probes, NULL, NULL,
2018						0);
2019		if (ret)
2020			goto err_probe;
2021
2022		doc_dbg_register(cascade->floors[floor]);
2023	}
2024
2025	ret = doc_register_sysfs(pdev, cascade);
2026	if (ret)
2027		goto err_probe;
 
 
2028
2029	platform_set_drvdata(pdev, cascade);
 
2030	return 0;
2031
2032notfound:
2033	ret = -ENODEV;
2034	dev_info(dev, "No supported DiskOnChip found\n");
2035err_probe:
2036	bch_free(cascade->bch);
2037	for (floor = 0; floor < DOC_MAX_NBFLOORS; floor++)
2038		if (cascade->floors[floor])
2039			doc_release_device(cascade->floors[floor]);
2040	return ret;
2041}
2042
2043/**
2044 * docg3_release - Release the driver
2045 * @pdev: the platform device
2046 *
2047 * Returns 0
2048 */
2049static void docg3_release(struct platform_device *pdev)
2050{
2051	struct docg3_cascade *cascade = platform_get_drvdata(pdev);
2052	struct docg3 *docg3 = cascade->floors[0]->priv;
2053	int floor;
2054
2055	doc_unregister_sysfs(pdev, cascade);
 
2056	for (floor = 0; floor < DOC_MAX_NBFLOORS; floor++)
2057		if (cascade->floors[floor])
2058			doc_release_device(cascade->floors[floor]);
2059
2060	bch_free(docg3->cascade->bch);
 
2061}
2062
2063#ifdef CONFIG_OF
2064static const struct of_device_id docg3_dt_ids[] = {
2065	{ .compatible = "m-systems,diskonchip-g3" },
2066	{}
2067};
2068MODULE_DEVICE_TABLE(of, docg3_dt_ids);
2069#endif
2070
2071static struct platform_driver g3_driver = {
2072	.driver		= {
2073		.name	= "docg3",
2074		.of_match_table = of_match_ptr(docg3_dt_ids),
2075	},
2076	.suspend	= docg3_suspend,
2077	.resume		= docg3_resume,
2078	.remove_new	= docg3_release,
2079};
2080
2081module_platform_driver_probe(g3_driver, docg3_probe);
2082
2083MODULE_LICENSE("GPL");
2084MODULE_AUTHOR("Robert Jarzmik <robert.jarzmik@free.fr>");
2085MODULE_DESCRIPTION("MTD driver for DiskOnChip G3");