drivers/mtd/devices/docg3.c

   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
  51 static unsigned int reliable_mode;
  52 module_param(reliable_mode, uint, 0);
  53 MODULE_PARM_DESC(reliable_mode, "Set the docg3 mode (0=normal MLC, 1=fast, "
  54                  "2=reliable) : MLC normal operations are in normal mode");
  55
  56 static 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
  69 static 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
  87 static const struct mtd_ooblayout_ops nand_ooblayout_docg3_ops = {
  88         .ecc = docg3_ooblayout_ecc,
  89         .free = docg3_ooblayout_free,
  90 };
  91
  92 static 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
 100 static 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
 108 static 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
 114 static 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
 120 static inline void doc_flash_command(struct docg3 *docg3, u8 cmd)
 121 {
 122         doc_writeb(docg3, cmd, DOC_FLASHCOMMAND);
 123 }
 124
 125 static inline void doc_flash_sequence(struct docg3 *docg3, u8 seq)
 126 {
 127         doc_writeb(docg3, seq, DOC_FLASHSEQUENCE);
 128 }
 129
 130 static inline void doc_flash_address(struct docg3 *docg3, u8 addr)
 131 {
 132         doc_writeb(docg3, addr, DOC_FLASHADDRESS);
 133 }
 134
 135 static char const * const part_probes[] = { "cmdlinepart", "saftlpart", NULL };
 136
 137 static 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
 147 static 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  */
 168 static 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
 177 static 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
 185 static 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
 193 static 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
 208 static 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  */
 231 static 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  */
 276 static 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  */
 317 static 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  */
 351 static 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  */
 373 static 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  */
 397 static 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  */
 418 static 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  */
 433 static 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  */
 456 static 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
 490 out:
 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  */
 505 static 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
 542 out:
 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  */
 557 static 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  */
 578 static 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  */
 596 static 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  */
 610 static 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  */
 643 static 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);
 663 out:
 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  */
 695 static 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;
 732 err:
 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  */
 753 static 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  */
 773 static 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  */
 785 static 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  */
 797 static 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  */
 811 static 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  */
 832 static 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  */
 865 static 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
 970 out:
 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;
 979 err_in_read:
 980         doc_read_page_finish(docg3);
 981         goto out;
 982 }
 983
 984 static 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  */
1013 static 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  */
1043 static 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  */
1084 static 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  */
1107 static 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
1126 out:
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  */
1142 static 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  */
1184 static 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  */
1231 static 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;
1286 err:
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  */
1297 static 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  */
1321 static 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  */
1344 static 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  */
1382 static 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
1463 static 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
1476 static 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
1491 static 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
1506 static 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
1525 static 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
1551 static 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
1555 static 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
1575 remove_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
1585 static 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  */
1600 static int flashcontrol_show(struct seq_file *s, void *p)
1601 {
1602         struct docg3 *docg3 = (struct 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 }
1620 DEFINE_SHOW_ATTRIBUTE(flashcontrol);
1621
1622 static int asic_mode_show(struct seq_file *s, void *p)
1623 {
1624         struct docg3 *docg3 = (struct 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 }
1657 DEFINE_SHOW_ATTRIBUTE(asic_mode);
1658
1659 static int device_id_show(struct seq_file *s, void *p)
1660 {
1661         struct docg3 *docg3 = (struct 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 }
1671 DEFINE_SHOW_ATTRIBUTE(device_id);
1672
1673 static int protection_show(struct seq_file *s, void *p)
1674 {
1675         struct docg3 *docg3 = (struct 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 }
1723 DEFINE_SHOW_ATTRIBUTE(protection);
1724
1725 static 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  */
1753 static 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  */
1804 static struct mtd_info * __init
1805 doc_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
1861 nomem4:
1862         kfree(docg3->bbt);
1863 nomem3:
1864         kfree(mtd);
1865 nomem2:
1866         kfree(docg3);
1867 nomem1:
1868         return ret ? ERR_PTR(ret) : NULL;
1869 }
1870
1871 /**
1872  * doc_release_device - Release a docg3 floor
1873  * @mtd: the device
1874  */
1875 static 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  */
1891 static 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  */
1918 static 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  */
1970 static 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
2032 notfound:
2033         ret = -ENODEV;
2034         dev_info(dev, "No supported DiskOnChip found\n");
2035 err_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  */
2049 static int 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         return 0;
2062 }
2063
2064 #ifdef CONFIG_OF
2065 static const struct of_device_id docg3_dt_ids[] = {
2066         { .compatible = "m-systems,diskonchip-g3" },
2067         {}
2068 };
2069 MODULE_DEVICE_TABLE(of, docg3_dt_ids);
2070 #endif
2071
2072 static struct platform_driver g3_driver = {
2073         .driver         = {
2074                 .name   = "docg3",
2075                 .of_match_table = of_match_ptr(docg3_dt_ids),
2076         },
2077         .suspend        = docg3_suspend,
2078         .resume         = docg3_resume,
2079         .remove         = docg3_release,
2080 };
2081
2082 module_platform_driver_probe(g3_driver, docg3_probe);
2083
2084 MODULE_LICENSE("GPL");
2085 MODULE_AUTHOR("Robert Jarzmik <robert.jarzmik@free.fr>");
2086 MODULE_DESCRIPTION("MTD driver for DiskOnChip G3");