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_data_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_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         int max_bitflips = 0;
 875
 876         if (buf)
 877                 len = ops->len;
 878         else
 879                 len = 0;
 880         if (oobbuf)
 881                 ooblen = ops->ooblen;
 882         else
 883                 ooblen = 0;
 884
 885         if (oobbuf && ops->mode == MTD_OPS_PLACE_OOB)
 886                 oobbuf += ops->ooboffs;
 887
 888         doc_dbg("doc_read_oob(from=%lld, mode=%d, data=(%p:%zu), oob=(%p:%zu))\n",
 889                 from, ops->mode, buf, len, oobbuf, ooblen);
 890         if (ooblen % DOC_LAYOUT_OOB_SIZE)
 891                 return -EINVAL;
 892
 893         ops->oobretlen = 0;
 894         ops->retlen = 0;
 895         ret = 0;
 896         skip = from % DOC_LAYOUT_PAGE_SIZE;
 897         mutex_lock(&docg3->cascade->lock);
 898         while (ret >= 0 && (len > 0 || ooblen > 0)) {
 899                 calc_block_sector(from - skip, &block0, &block1, &page, &ofs,
 900                         docg3->reliable);
 901                 nbdata = min_t(size_t, len, DOC_LAYOUT_PAGE_SIZE - skip);
 902                 nboob = min_t(size_t, ooblen, (size_t)DOC_LAYOUT_OOB_SIZE);
 903                 ret = doc_read_page_prepare(docg3, block0, block1, page, ofs);
 904                 if (ret < 0)
 905                         goto out;
 906                 ret = doc_read_page_ecc_init(docg3, DOC_ECC_BCH_TOTAL_BYTES);
 907                 if (ret < 0)
 908                         goto err_in_read;
 909                 ret = doc_read_page_getbytes(docg3, skip, NULL, 1, 0);
 910                 if (ret < skip)
 911                         goto err_in_read;
 912                 ret = doc_read_page_getbytes(docg3, nbdata, buf, 0, skip % 2);
 913                 if (ret < nbdata)
 914                         goto err_in_read;
 915                 doc_read_page_getbytes(docg3,
 916                                        DOC_LAYOUT_PAGE_SIZE - nbdata - skip,
 917                                        NULL, 0, (skip + nbdata) % 2);
 918                 ret = doc_read_page_getbytes(docg3, nboob, oobbuf, 0, 0);
 919                 if (ret < nboob)
 920                         goto err_in_read;
 921                 doc_read_page_getbytes(docg3, DOC_LAYOUT_OOB_SIZE - nboob,
 922                                        NULL, 0, nboob % 2);
 923
 924                 doc_get_bch_hw_ecc(docg3, hwecc);
 925                 eccconf1 = doc_register_readb(docg3, DOC_ECCCONF1);
 926
 927                 if (nboob >= DOC_LAYOUT_OOB_SIZE) {
 928                         doc_dbg("OOB - INFO: %*phC\n", 7, oobbuf);
 929                         doc_dbg("OOB - HAMMING: %02x\n", oobbuf[7]);
 930                         doc_dbg("OOB - BCH_ECC: %*phC\n", 7, oobbuf + 8);
 931                         doc_dbg("OOB - UNUSED: %02x\n", oobbuf[15]);
 932                 }
 933                 doc_dbg("ECC checks: ECCConf1=%x\n", eccconf1);
 934                 doc_dbg("ECC HW_ECC: %*phC\n", 7, hwecc);
 935
 936                 ret = -EIO;
 937                 if (is_prot_seq_error(docg3))
 938                         goto err_in_read;
 939                 ret = 0;
 940                 if ((block0 >= DOC_LAYOUT_BLOCK_FIRST_DATA) &&
 941                     (eccconf1 & DOC_ECCCONF1_BCH_SYNDROM_ERR) &&
 942                     (eccconf1 & DOC_ECCCONF1_PAGE_IS_WRITTEN) &&
 943                     (ops->mode != MTD_OPS_RAW) &&
 944                     (nbdata == DOC_LAYOUT_PAGE_SIZE)) {
 945                         ret = doc_ecc_bch_fix_data(docg3, buf, hwecc);
 946                         if (ret < 0) {
 947                                 mtd->ecc_stats.failed++;
 948                                 ret = -EBADMSG;
 949                         }
 950                         if (ret > 0) {
 951                                 mtd->ecc_stats.corrected += ret;
 952                                 max_bitflips = max(max_bitflips, ret);
 953                                 ret = max_bitflips;
 954                         }
 955                 }
 956
 957                 doc_read_page_finish(docg3);
 958                 ops->retlen += nbdata;
 959                 ops->oobretlen += nboob;
 960                 buf += nbdata;
 961                 oobbuf += nboob;
 962                 len -= nbdata;
 963                 ooblen -= nboob;
 964                 from += DOC_LAYOUT_PAGE_SIZE;
 965                 skip = 0;
 966         }
 967
 968 out:
 969         mutex_unlock(&docg3->cascade->lock);
 970         return ret;
 971 err_in_read:
 972         doc_read_page_finish(docg3);
 973         goto out;
 974 }
 975
 976 static int doc_reload_bbt(struct docg3 *docg3)
 977 {
 978         int block = DOC_LAYOUT_BLOCK_BBT;
 979         int ret = 0, nbpages, page;
 980         u_char *buf = docg3->bbt;
 981
 982         nbpages = DIV_ROUND_UP(docg3->max_block + 1, 8 * DOC_LAYOUT_PAGE_SIZE);
 983         for (page = 0; !ret && (page < nbpages); page++) {
 984                 ret = doc_read_page_prepare(docg3, block, block + 1,
 985                                             page + DOC_LAYOUT_PAGE_BBT, 0);
 986                 if (!ret)
 987                         ret = doc_read_page_ecc_init(docg3,
 988                                                      DOC_LAYOUT_PAGE_SIZE);
 989                 if (!ret)
 990                         doc_read_page_getbytes(docg3, DOC_LAYOUT_PAGE_SIZE,
 991                                                buf, 1, 0);
 992                 buf += DOC_LAYOUT_PAGE_SIZE;
 993         }
 994         doc_read_page_finish(docg3);
 995         return ret;
 996 }
 997
 998 /**
 999  * doc_block_isbad - Checks whether a block is good or not
1000  * @mtd: the device
1001  * @from: the offset to find the correct block
1002  *
1003  * Returns 1 if block is bad, 0 if block is good
1004  */
1005 static int doc_block_isbad(struct mtd_info *mtd, loff_t from)
1006 {
1007         struct docg3 *docg3 = mtd->priv;
1008         int block0, block1, page, ofs, is_good;
1009
1010         calc_block_sector(from, &block0, &block1, &page, &ofs,
1011                 docg3->reliable);
1012         doc_dbg("doc_block_isbad(from=%lld) => block=(%d,%d), page=%d, ofs=%d\n",
1013                 from, block0, block1, page, ofs);
1014
1015         if (block0 < DOC_LAYOUT_BLOCK_FIRST_DATA)
1016                 return 0;
1017         if (block1 > docg3->max_block)
1018                 return -EINVAL;
1019
1020         is_good = docg3->bbt[block0 >> 3] & (1 << (block0 & 0x7));
1021         return !is_good;
1022 }
1023
1024 #if 0
1025 /**
1026  * doc_get_erase_count - Get block erase count
1027  * @docg3: the device
1028  * @from: the offset in which the block is.
1029  *
1030  * Get the number of times a block was erased. The number is the maximum of
1031  * erase times between first and second plane (which should be equal normally).
1032  *
1033  * Returns The number of erases, or -EINVAL or -EIO on error.
1034  */
1035 static int doc_get_erase_count(struct docg3 *docg3, loff_t from)
1036 {
1037         u8 buf[DOC_LAYOUT_WEAR_SIZE];
1038         int ret, plane1_erase_count, plane2_erase_count;
1039         int block0, block1, page, ofs;
1040
1041         doc_dbg("doc_get_erase_count(from=%lld, buf=%p)\n", from, buf);
1042         if (from % DOC_LAYOUT_PAGE_SIZE)
1043                 return -EINVAL;
1044         calc_block_sector(from, &block0, &block1, &page, &ofs, docg3->reliable);
1045         if (block1 > docg3->max_block)
1046                 return -EINVAL;
1047
1048         ret = doc_reset_seq(docg3);
1049         if (!ret)
1050                 ret = doc_read_page_prepare(docg3, block0, block1, page,
1051                                             ofs + DOC_LAYOUT_WEAR_OFFSET, 0);
1052         if (!ret)
1053                 ret = doc_read_page_getbytes(docg3, DOC_LAYOUT_WEAR_SIZE,
1054                                              buf, 1, 0);
1055         doc_read_page_finish(docg3);
1056
1057         if (ret || (buf[0] != DOC_ERASE_MARK) || (buf[2] != DOC_ERASE_MARK))
1058                 return -EIO;
1059         plane1_erase_count = (u8)(~buf[1]) | ((u8)(~buf[4]) << 8)
1060                 | ((u8)(~buf[5]) << 16);
1061         plane2_erase_count = (u8)(~buf[3]) | ((u8)(~buf[6]) << 8)
1062                 | ((u8)(~buf[7]) << 16);
1063
1064         return max(plane1_erase_count, plane2_erase_count);
1065 }
1066 #endif
1067
1068 /**
1069  * doc_get_op_status - get erase/write operation status
1070  * @docg3: the device
1071  *
1072  * Queries the status from the chip, and returns it
1073  *
1074  * Returns the status (bits DOC_PLANES_STATUS_*)
1075  */
1076 static int doc_get_op_status(struct docg3 *docg3)
1077 {
1078         u8 status;
1079
1080         doc_flash_sequence(docg3, DOC_SEQ_PLANES_STATUS);
1081         doc_flash_command(docg3, DOC_CMD_PLANES_STATUS);
1082         doc_delay(docg3, 5);
1083
1084         doc_ecc_disable(docg3);
1085         doc_read_data_area(docg3, &status, 1, 1);
1086         return status;
1087 }
1088
1089 /**
1090  * doc_write_erase_wait_status - wait for write or erase completion
1091  * @docg3: the device
1092  *
1093  * Wait for the chip to be ready again after erase or write operation, and check
1094  * erase/write status.
1095  *
1096  * Returns 0 if erase successful, -EIO if erase/write issue, -ETIMEOUT if
1097  * timeout
1098  */
1099 static int doc_write_erase_wait_status(struct docg3 *docg3)
1100 {
1101         int i, status, ret = 0;
1102
1103         for (i = 0; !doc_is_ready(docg3) && i < 5; i++)
1104                 msleep(20);
1105         if (!doc_is_ready(docg3)) {
1106                 doc_dbg("Timeout reached and the chip is still not ready\n");
1107                 ret = -EAGAIN;
1108                 goto out;
1109         }
1110
1111         status = doc_get_op_status(docg3);
1112         if (status & DOC_PLANES_STATUS_FAIL) {
1113                 doc_dbg("Erase/Write failed on (a) plane(s), status = %x\n",
1114                         status);
1115                 ret = -EIO;
1116         }
1117
1118 out:
1119         doc_page_finish(docg3);
1120         return ret;
1121 }
1122
1123 /**
1124  * doc_erase_block - Erase a couple of blocks
1125  * @docg3: the device
1126  * @block0: the first block to erase (leftmost plane)
1127  * @block1: the second block to erase (rightmost plane)
1128  *
1129  * Erase both blocks, and return operation status
1130  *
1131  * Returns 0 if erase successful, -EIO if erase issue, -ETIMEOUT if chip not
1132  * ready for too long
1133  */
1134 static int doc_erase_block(struct docg3 *docg3, int block0, int block1)
1135 {
1136         int ret, sector;
1137
1138         doc_dbg("doc_erase_block(blocks=(%d,%d))\n", block0, block1);
1139         ret = doc_reset_seq(docg3);
1140         if (ret)
1141                 return -EIO;
1142
1143         doc_set_reliable_mode(docg3);
1144         doc_flash_sequence(docg3, DOC_SEQ_ERASE);
1145
1146         sector = block0 << DOC_ADDR_BLOCK_SHIFT;
1147         doc_flash_command(docg3, DOC_CMD_PROG_BLOCK_ADDR);
1148         doc_setup_addr_sector(docg3, sector);
1149         sector = block1 << DOC_ADDR_BLOCK_SHIFT;
1150         doc_flash_command(docg3, DOC_CMD_PROG_BLOCK_ADDR);
1151         doc_setup_addr_sector(docg3, sector);
1152         doc_delay(docg3, 1);
1153
1154         doc_flash_command(docg3, DOC_CMD_ERASECYCLE2);
1155         doc_delay(docg3, 2);
1156
1157         if (is_prot_seq_error(docg3)) {
1158                 doc_err("Erase blocks %d,%d error\n", block0, block1);
1159                 return -EIO;
1160         }
1161
1162         return doc_write_erase_wait_status(docg3);
1163 }
1164
1165 /**
1166  * doc_erase - Erase a portion of the chip
1167  * @mtd: the device
1168  * @info: the erase info
1169  *
1170  * Erase a bunch of contiguous blocks, by pairs, as a "mtd" page of 1024 is
1171  * split into 2 pages of 512 bytes on 2 contiguous blocks.
1172  *
1173  * Returns 0 if erase successful, -EINVAL if addressing error, -EIO if erase
1174  * issue
1175  */
1176 static int doc_erase(struct mtd_info *mtd, struct erase_info *info)
1177 {
1178         struct docg3 *docg3 = mtd->priv;
1179         uint64_t len;
1180         int block0, block1, page, ret = 0, ofs = 0;
1181
1182         doc_dbg("doc_erase(from=%lld, len=%lld\n", info->addr, info->len);
1183
1184         calc_block_sector(info->addr + info->len, &block0, &block1, &page,
1185                           &ofs, docg3->reliable);
1186         if (info->addr + info->len > mtd->size || page || ofs)
1187                 return -EINVAL;
1188
1189         calc_block_sector(info->addr, &block0, &block1, &page, &ofs,
1190                           docg3->reliable);
1191         mutex_lock(&docg3->cascade->lock);
1192         doc_set_device_id(docg3, docg3->device_id);
1193         doc_set_reliable_mode(docg3);
1194         for (len = info->len; !ret && len > 0; len -= mtd->erasesize) {
1195                 ret = doc_erase_block(docg3, block0, block1);
1196                 block0 += 2;
1197                 block1 += 2;
1198         }
1199         mutex_unlock(&docg3->cascade->lock);
1200
1201         return ret;
1202 }
1203
1204 /**
1205  * doc_write_page - Write a single page to the chip
1206  * @docg3: the device
1207  * @to: the offset from first block and first page, in bytes, aligned on page
1208  *      size
1209  * @buf: buffer to get bytes from
1210  * @oob: buffer to get out of band bytes from (can be NULL if no OOB should be
1211  *       written)
1212  * @autoecc: if 0, all 16 bytes from OOB are taken, regardless of HW Hamming or
1213  *           BCH computations. If 1, only bytes 0-7 and byte 15 are taken,
1214  *           remaining ones are filled with hardware Hamming and BCH
1215  *           computations. Its value is not meaningfull is oob == NULL.
1216  *
1217  * Write one full page (ie. 1 page split on two planes), of 512 bytes, with the
1218  * OOB data. The OOB ECC is automatically computed by the hardware Hamming and
1219  * BCH generator if autoecc is not null.
1220  *
1221  * Returns 0 if write successful, -EIO if write error, -EAGAIN if timeout
1222  */
1223 static int doc_write_page(struct docg3 *docg3, loff_t to, const u_char *buf,
1224                           const u_char *oob, int autoecc)
1225 {
1226         int block0, block1, page, ret, ofs = 0;
1227         u8 hwecc[DOC_ECC_BCH_SIZE], hamming;
1228
1229         doc_dbg("doc_write_page(to=%lld)\n", to);
1230         calc_block_sector(to, &block0, &block1, &page, &ofs, docg3->reliable);
1231
1232         doc_set_device_id(docg3, docg3->device_id);
1233         ret = doc_reset_seq(docg3);
1234         if (ret)
1235                 goto err;
1236
1237         /* Program the flash address block and page */
1238         ret = doc_write_seek(docg3, block0, block1, page, ofs);
1239         if (ret)
1240                 goto err;
1241
1242         doc_write_page_ecc_init(docg3, DOC_ECC_BCH_TOTAL_BYTES);
1243         doc_delay(docg3, 2);
1244         doc_write_page_putbytes(docg3, DOC_LAYOUT_PAGE_SIZE, buf);
1245
1246         if (oob && autoecc) {
1247                 doc_write_page_putbytes(docg3, DOC_LAYOUT_OOB_PAGEINFO_SZ, oob);
1248                 doc_delay(docg3, 2);
1249                 oob += DOC_LAYOUT_OOB_UNUSED_OFS;
1250
1251                 hamming = doc_register_readb(docg3, DOC_HAMMINGPARITY);
1252                 doc_delay(docg3, 2);
1253                 doc_write_page_putbytes(docg3, DOC_LAYOUT_OOB_HAMMING_SZ,
1254                                         &hamming);
1255                 doc_delay(docg3, 2);
1256
1257                 doc_get_bch_hw_ecc(docg3, hwecc);
1258                 doc_write_page_putbytes(docg3, DOC_LAYOUT_OOB_BCH_SZ, hwecc);
1259                 doc_delay(docg3, 2);
1260
1261                 doc_write_page_putbytes(docg3, DOC_LAYOUT_OOB_UNUSED_SZ, oob);
1262         }
1263         if (oob && !autoecc)
1264                 doc_write_page_putbytes(docg3, DOC_LAYOUT_OOB_SIZE, oob);
1265
1266         doc_delay(docg3, 2);
1267         doc_page_finish(docg3);
1268         doc_delay(docg3, 2);
1269         doc_flash_command(docg3, DOC_CMD_PROG_CYCLE2);
1270         doc_delay(docg3, 2);
1271
1272         /*
1273          * The wait status will perform another doc_page_finish() call, but that
1274          * seems to please the docg3, so leave it.
1275          */
1276         ret = doc_write_erase_wait_status(docg3);
1277         return ret;
1278 err:
1279         doc_read_page_finish(docg3);
1280         return ret;
1281 }
1282
1283 /**
1284  * doc_guess_autoecc - Guess autoecc mode from mbd_oob_ops
1285  * @ops: the oob operations
1286  *
1287  * Returns 0 or 1 if success, -EINVAL if invalid oob mode
1288  */
1289 static int doc_guess_autoecc(struct mtd_oob_ops *ops)
1290 {
1291         int autoecc;
1292
1293         switch (ops->mode) {
1294         case MTD_OPS_PLACE_OOB:
1295         case MTD_OPS_AUTO_OOB:
1296                 autoecc = 1;
1297                 break;
1298         case MTD_OPS_RAW:
1299                 autoecc = 0;
1300                 break;
1301         default:
1302                 autoecc = -EINVAL;
1303         }
1304         return autoecc;
1305 }
1306
1307 /**
1308  * doc_fill_autooob - Fill a 16 bytes OOB from 8 non-ECC bytes
1309  * @dst: the target 16 bytes OOB buffer
1310  * @oobsrc: the source 8 bytes non-ECC OOB buffer
1311  *
1312  */
1313 static void doc_fill_autooob(u8 *dst, u8 *oobsrc)
1314 {
1315         memcpy(dst, oobsrc, DOC_LAYOUT_OOB_PAGEINFO_SZ);
1316         dst[DOC_LAYOUT_OOB_UNUSED_OFS] = oobsrc[DOC_LAYOUT_OOB_PAGEINFO_SZ];
1317 }
1318
1319 /**
1320  * doc_backup_oob - Backup OOB into docg3 structure
1321  * @docg3: the device
1322  * @to: the page offset in the chip
1323  * @ops: the OOB size and buffer
1324  *
1325  * As the docg3 should write a page with its OOB in one pass, and some userland
1326  * applications do write_oob() to setup the OOB and then write(), store the OOB
1327  * into a temporary storage. This is very dangerous, as 2 concurrent
1328  * applications could store an OOB, and then write their pages (which will
1329  * result into one having its OOB corrupted).
1330  *
1331  * The only reliable way would be for userland to call doc_write_oob() with both
1332  * the page data _and_ the OOB area.
1333  *
1334  * Returns 0 if success, -EINVAL if ops content invalid
1335  */
1336 static int doc_backup_oob(struct docg3 *docg3, loff_t to,
1337                           struct mtd_oob_ops *ops)
1338 {
1339         int ooblen = ops->ooblen, autoecc;
1340
1341         if (ooblen != DOC_LAYOUT_OOB_SIZE)
1342                 return -EINVAL;
1343         autoecc = doc_guess_autoecc(ops);
1344         if (autoecc < 0)
1345                 return autoecc;
1346
1347         docg3->oob_write_ofs = to;
1348         docg3->oob_autoecc = autoecc;
1349         if (ops->mode == MTD_OPS_AUTO_OOB) {
1350                 doc_fill_autooob(docg3->oob_write_buf, ops->oobbuf);
1351                 ops->oobretlen = 8;
1352         } else {
1353                 memcpy(docg3->oob_write_buf, ops->oobbuf, DOC_LAYOUT_OOB_SIZE);
1354                 ops->oobretlen = DOC_LAYOUT_OOB_SIZE;
1355         }
1356         return 0;
1357 }
1358
1359 /**
1360  * doc_write_oob - Write out of band bytes to flash
1361  * @mtd: the device
1362  * @ofs: the offset from first block and first page, in bytes, aligned on page
1363  *       size
1364  * @ops: the mtd oob structure
1365  *
1366  * Either write OOB data into a temporary buffer, for the subsequent write
1367  * page. The provided OOB should be 16 bytes long. If a data buffer is provided
1368  * as well, issue the page write.
1369  * Or provide data without OOB, and then a all zeroed OOB will be used (ECC will
1370  * still be filled in if asked for).
1371  *
1372  * Returns 0 is successful, EINVAL if length is not 14 bytes
1373  */
1374 static int doc_write_oob(struct mtd_info *mtd, loff_t ofs,
1375                          struct mtd_oob_ops *ops)
1376 {
1377         struct docg3 *docg3 = mtd->priv;
1378         int ret, autoecc, oobdelta;
1379         u8 *oobbuf = ops->oobbuf;
1380         u8 *buf = ops->datbuf;
1381         size_t len, ooblen;
1382         u8 oob[DOC_LAYOUT_OOB_SIZE];
1383
1384         if (buf)
1385                 len = ops->len;
1386         else
1387                 len = 0;
1388         if (oobbuf)
1389                 ooblen = ops->ooblen;
1390         else
1391                 ooblen = 0;
1392
1393         if (oobbuf && ops->mode == MTD_OPS_PLACE_OOB)
1394                 oobbuf += ops->ooboffs;
1395
1396         doc_dbg("doc_write_oob(from=%lld, mode=%d, data=(%p:%zu), oob=(%p:%zu))\n",
1397                 ofs, ops->mode, buf, len, oobbuf, ooblen);
1398         switch (ops->mode) {
1399         case MTD_OPS_PLACE_OOB:
1400         case MTD_OPS_RAW:
1401                 oobdelta = mtd->oobsize;
1402                 break;
1403         case MTD_OPS_AUTO_OOB:
1404                 oobdelta = mtd->oobavail;
1405                 break;
1406         default:
1407                 return -EINVAL;
1408         }
1409         if ((len % DOC_LAYOUT_PAGE_SIZE) || (ooblen % oobdelta) ||
1410             (ofs % DOC_LAYOUT_PAGE_SIZE))
1411                 return -EINVAL;
1412         if (len && ooblen &&
1413             (len / DOC_LAYOUT_PAGE_SIZE) != (ooblen / oobdelta))
1414                 return -EINVAL;
1415
1416         ops->oobretlen = 0;
1417         ops->retlen = 0;
1418         ret = 0;
1419         if (len == 0 && ooblen == 0)
1420                 return -EINVAL;
1421         if (len == 0 && ooblen > 0)
1422                 return doc_backup_oob(docg3, ofs, ops);
1423
1424         autoecc = doc_guess_autoecc(ops);
1425         if (autoecc < 0)
1426                 return autoecc;
1427
1428         mutex_lock(&docg3->cascade->lock);
1429         while (!ret && len > 0) {
1430                 memset(oob, 0, sizeof(oob));
1431                 if (ofs == docg3->oob_write_ofs)
1432                         memcpy(oob, docg3->oob_write_buf, DOC_LAYOUT_OOB_SIZE);
1433                 else if (ooblen > 0 && ops->mode == MTD_OPS_AUTO_OOB)
1434                         doc_fill_autooob(oob, oobbuf);
1435                 else if (ooblen > 0)
1436                         memcpy(oob, oobbuf, DOC_LAYOUT_OOB_SIZE);
1437                 ret = doc_write_page(docg3, ofs, buf, oob, autoecc);
1438
1439                 ofs += DOC_LAYOUT_PAGE_SIZE;
1440                 len -= DOC_LAYOUT_PAGE_SIZE;
1441                 buf += DOC_LAYOUT_PAGE_SIZE;
1442                 if (ooblen) {
1443                         oobbuf += oobdelta;
1444                         ooblen -= oobdelta;
1445                         ops->oobretlen += oobdelta;
1446                 }
1447                 ops->retlen += DOC_LAYOUT_PAGE_SIZE;
1448         }
1449
1450         doc_set_device_id(docg3, 0);
1451         mutex_unlock(&docg3->cascade->lock);
1452         return ret;
1453 }
1454
1455 static struct docg3 *sysfs_dev2docg3(struct device *dev,
1456                                      struct device_attribute *attr)
1457 {
1458         int floor;
1459         struct mtd_info **docg3_floors = dev_get_drvdata(dev);
1460
1461         floor = attr->attr.name[1] - '0';
1462         if (floor < 0 || floor >= DOC_MAX_NBFLOORS)
1463                 return NULL;
1464         else
1465                 return docg3_floors[floor]->priv;
1466 }
1467
1468 static ssize_t dps0_is_key_locked(struct device *dev,
1469                                   struct device_attribute *attr, char *buf)
1470 {
1471         struct docg3 *docg3 = sysfs_dev2docg3(dev, attr);
1472         int dps0;
1473
1474         mutex_lock(&docg3->cascade->lock);
1475         doc_set_device_id(docg3, docg3->device_id);
1476         dps0 = doc_register_readb(docg3, DOC_DPS0_STATUS);
1477         doc_set_device_id(docg3, 0);
1478         mutex_unlock(&docg3->cascade->lock);
1479
1480         return sprintf(buf, "%d\n", !(dps0 & DOC_DPS_KEY_OK));
1481 }
1482
1483 static ssize_t dps1_is_key_locked(struct device *dev,
1484                                   struct device_attribute *attr, char *buf)
1485 {
1486         struct docg3 *docg3 = sysfs_dev2docg3(dev, attr);
1487         int dps1;
1488
1489         mutex_lock(&docg3->cascade->lock);
1490         doc_set_device_id(docg3, docg3->device_id);
1491         dps1 = doc_register_readb(docg3, DOC_DPS1_STATUS);
1492         doc_set_device_id(docg3, 0);
1493         mutex_unlock(&docg3->cascade->lock);
1494
1495         return sprintf(buf, "%d\n", !(dps1 & DOC_DPS_KEY_OK));
1496 }
1497
1498 static ssize_t dps0_insert_key(struct device *dev,
1499                                struct device_attribute *attr,
1500                                const char *buf, size_t count)
1501 {
1502         struct docg3 *docg3 = sysfs_dev2docg3(dev, attr);
1503         int i;
1504
1505         if (count != DOC_LAYOUT_DPS_KEY_LENGTH)
1506                 return -EINVAL;
1507
1508         mutex_lock(&docg3->cascade->lock);
1509         doc_set_device_id(docg3, docg3->device_id);
1510         for (i = 0; i < DOC_LAYOUT_DPS_KEY_LENGTH; i++)
1511                 doc_writeb(docg3, buf[i], DOC_DPS0_KEY);
1512         doc_set_device_id(docg3, 0);
1513         mutex_unlock(&docg3->cascade->lock);
1514         return count;
1515 }
1516
1517 static ssize_t dps1_insert_key(struct device *dev,
1518                                struct device_attribute *attr,
1519                                const char *buf, size_t count)
1520 {
1521         struct docg3 *docg3 = sysfs_dev2docg3(dev, attr);
1522         int i;
1523
1524         if (count != DOC_LAYOUT_DPS_KEY_LENGTH)
1525                 return -EINVAL;
1526
1527         mutex_lock(&docg3->cascade->lock);
1528         doc_set_device_id(docg3, docg3->device_id);
1529         for (i = 0; i < DOC_LAYOUT_DPS_KEY_LENGTH; i++)
1530                 doc_writeb(docg3, buf[i], DOC_DPS1_KEY);
1531         doc_set_device_id(docg3, 0);
1532         mutex_unlock(&docg3->cascade->lock);
1533         return count;
1534 }
1535
1536 #define FLOOR_SYSFS(id) { \
1537         __ATTR(f##id##_dps0_is_keylocked, S_IRUGO, dps0_is_key_locked, NULL), \
1538         __ATTR(f##id##_dps1_is_keylocked, S_IRUGO, dps1_is_key_locked, NULL), \
1539         __ATTR(f##id##_dps0_protection_key, S_IWUSR|S_IWGRP, NULL, dps0_insert_key), \
1540         __ATTR(f##id##_dps1_protection_key, S_IWUSR|S_IWGRP, NULL, dps1_insert_key), \
1541 }
1542
1543 static struct device_attribute doc_sys_attrs[DOC_MAX_NBFLOORS][4] = {
1544         FLOOR_SYSFS(0), FLOOR_SYSFS(1), FLOOR_SYSFS(2), FLOOR_SYSFS(3)
1545 };
1546
1547 static int doc_register_sysfs(struct platform_device *pdev,
1548                               struct docg3_cascade *cascade)
1549 {
1550         struct device *dev = &pdev->dev;
1551         int floor;
1552         int ret;
1553         int i;
1554
1555         for (floor = 0;
1556              floor < DOC_MAX_NBFLOORS && cascade->floors[floor];
1557              floor++) {
1558                 for (i = 0; i < 4; i++) {
1559                         ret = device_create_file(dev, &doc_sys_attrs[floor][i]);
1560                         if (ret)
1561                                 goto remove_files;
1562                 }
1563         }
1564
1565         return 0;
1566
1567 remove_files:
1568         do {
1569                 while (--i >= 0)
1570                         device_remove_file(dev, &doc_sys_attrs[floor][i]);
1571                 i = 4;
1572         } while (--floor >= 0);
1573
1574         return ret;
1575 }
1576
1577 static void doc_unregister_sysfs(struct platform_device *pdev,
1578                                  struct docg3_cascade *cascade)
1579 {
1580         struct device *dev = &pdev->dev;
1581         int floor, i;
1582
1583         for (floor = 0; floor < DOC_MAX_NBFLOORS && cascade->floors[floor];
1584              floor++)
1585                 for (i = 0; i < 4; i++)
1586                         device_remove_file(dev, &doc_sys_attrs[floor][i]);
1587 }
1588
1589 /*
1590  * Debug sysfs entries
1591  */
1592 static int flashcontrol_show(struct seq_file *s, void *p)
1593 {
1594         struct docg3 *docg3 = (struct docg3 *)s->private;
1595
1596         u8 fctrl;
1597
1598         mutex_lock(&docg3->cascade->lock);
1599         fctrl = doc_register_readb(docg3, DOC_FLASHCONTROL);
1600         mutex_unlock(&docg3->cascade->lock);
1601
1602         seq_printf(s, "FlashControl : 0x%02x (%s,CE# %s,%s,%s,flash %s)\n",
1603                    fctrl,
1604                    fctrl & DOC_CTRL_VIOLATION ? "protocol violation" : "-",
1605                    fctrl & DOC_CTRL_CE ? "active" : "inactive",
1606                    fctrl & DOC_CTRL_PROTECTION_ERROR ? "protection error" : "-",
1607                    fctrl & DOC_CTRL_SEQUENCE_ERROR ? "sequence error" : "-",
1608                    fctrl & DOC_CTRL_FLASHREADY ? "ready" : "not ready");
1609
1610         return 0;
1611 }
1612 DEFINE_SHOW_ATTRIBUTE(flashcontrol);
1613
1614 static int asic_mode_show(struct seq_file *s, void *p)
1615 {
1616         struct docg3 *docg3 = (struct docg3 *)s->private;
1617
1618         int pctrl, mode;
1619
1620         mutex_lock(&docg3->cascade->lock);
1621         pctrl = doc_register_readb(docg3, DOC_ASICMODE);
1622         mode = pctrl & 0x03;
1623         mutex_unlock(&docg3->cascade->lock);
1624
1625         seq_printf(s,
1626                    "%04x : RAM_WE=%d,RSTIN_RESET=%d,BDETCT_RESET=%d,WRITE_ENABLE=%d,POWERDOWN=%d,MODE=%d%d (",
1627                    pctrl,
1628                    pctrl & DOC_ASICMODE_RAM_WE ? 1 : 0,
1629                    pctrl & DOC_ASICMODE_RSTIN_RESET ? 1 : 0,
1630                    pctrl & DOC_ASICMODE_BDETCT_RESET ? 1 : 0,
1631                    pctrl & DOC_ASICMODE_MDWREN ? 1 : 0,
1632                    pctrl & DOC_ASICMODE_POWERDOWN ? 1 : 0,
1633                    mode >> 1, mode & 0x1);
1634
1635         switch (mode) {
1636         case DOC_ASICMODE_RESET:
1637                 seq_puts(s, "reset");
1638                 break;
1639         case DOC_ASICMODE_NORMAL:
1640                 seq_puts(s, "normal");
1641                 break;
1642         case DOC_ASICMODE_POWERDOWN:
1643                 seq_puts(s, "powerdown");
1644                 break;
1645         }
1646         seq_puts(s, ")\n");
1647         return 0;
1648 }
1649 DEFINE_SHOW_ATTRIBUTE(asic_mode);
1650
1651 static int device_id_show(struct seq_file *s, void *p)
1652 {
1653         struct docg3 *docg3 = (struct docg3 *)s->private;
1654         int id;
1655
1656         mutex_lock(&docg3->cascade->lock);
1657         id = doc_register_readb(docg3, DOC_DEVICESELECT);
1658         mutex_unlock(&docg3->cascade->lock);
1659
1660         seq_printf(s, "DeviceId = %d\n", id);
1661         return 0;
1662 }
1663 DEFINE_SHOW_ATTRIBUTE(device_id);
1664
1665 static int protection_show(struct seq_file *s, void *p)
1666 {
1667         struct docg3 *docg3 = (struct docg3 *)s->private;
1668         int protect, dps0, dps0_low, dps0_high, dps1, dps1_low, dps1_high;
1669
1670         mutex_lock(&docg3->cascade->lock);
1671         protect = doc_register_readb(docg3, DOC_PROTECTION);
1672         dps0 = doc_register_readb(docg3, DOC_DPS0_STATUS);
1673         dps0_low = doc_register_readw(docg3, DOC_DPS0_ADDRLOW);
1674         dps0_high = doc_register_readw(docg3, DOC_DPS0_ADDRHIGH);
1675         dps1 = doc_register_readb(docg3, DOC_DPS1_STATUS);
1676         dps1_low = doc_register_readw(docg3, DOC_DPS1_ADDRLOW);
1677         dps1_high = doc_register_readw(docg3, DOC_DPS1_ADDRHIGH);
1678         mutex_unlock(&docg3->cascade->lock);
1679
1680         seq_printf(s, "Protection = 0x%02x (", protect);
1681         if (protect & DOC_PROTECT_FOUNDRY_OTP_LOCK)
1682                 seq_puts(s, "FOUNDRY_OTP_LOCK,");
1683         if (protect & DOC_PROTECT_CUSTOMER_OTP_LOCK)
1684                 seq_puts(s, "CUSTOMER_OTP_LOCK,");
1685         if (protect & DOC_PROTECT_LOCK_INPUT)
1686                 seq_puts(s, "LOCK_INPUT,");
1687         if (protect & DOC_PROTECT_STICKY_LOCK)
1688                 seq_puts(s, "STICKY_LOCK,");
1689         if (protect & DOC_PROTECT_PROTECTION_ENABLED)
1690                 seq_puts(s, "PROTECTION ON,");
1691         if (protect & DOC_PROTECT_IPL_DOWNLOAD_LOCK)
1692                 seq_puts(s, "IPL_DOWNLOAD_LOCK,");
1693         if (protect & DOC_PROTECT_PROTECTION_ERROR)
1694                 seq_puts(s, "PROTECT_ERR,");
1695         else
1696                 seq_puts(s, "NO_PROTECT_ERR");
1697         seq_puts(s, ")\n");
1698
1699         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",
1700                    dps0, dps0_low, dps0_high,
1701                    !!(dps0 & DOC_DPS_OTP_PROTECTED),
1702                    !!(dps0 & DOC_DPS_READ_PROTECTED),
1703                    !!(dps0 & DOC_DPS_WRITE_PROTECTED),
1704                    !!(dps0 & DOC_DPS_HW_LOCK_ENABLED),
1705                    !!(dps0 & DOC_DPS_KEY_OK));
1706         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",
1707                    dps1, dps1_low, dps1_high,
1708                    !!(dps1 & DOC_DPS_OTP_PROTECTED),
1709                    !!(dps1 & DOC_DPS_READ_PROTECTED),
1710                    !!(dps1 & DOC_DPS_WRITE_PROTECTED),
1711                    !!(dps1 & DOC_DPS_HW_LOCK_ENABLED),
1712                    !!(dps1 & DOC_DPS_KEY_OK));
1713         return 0;
1714 }
1715 DEFINE_SHOW_ATTRIBUTE(protection);
1716
1717 static void __init doc_dbg_register(struct mtd_info *floor)
1718 {
1719         struct dentry *root = floor->dbg.dfs_dir;
1720         struct docg3 *docg3 = floor->priv;
1721
1722         if (IS_ERR_OR_NULL(root)) {
1723                 if (IS_ENABLED(CONFIG_DEBUG_FS) &&
1724                     !IS_ENABLED(CONFIG_MTD_PARTITIONED_MASTER))
1725                         dev_warn(floor->dev.parent,
1726                                  "CONFIG_MTD_PARTITIONED_MASTER must be enabled to expose debugfs stuff\n");
1727                 return;
1728         }
1729
1730         debugfs_create_file("docg3_flashcontrol", S_IRUSR, root, docg3,
1731                             &flashcontrol_fops);
1732         debugfs_create_file("docg3_asic_mode", S_IRUSR, root, docg3,
1733                             &asic_mode_fops);
1734         debugfs_create_file("docg3_device_id", S_IRUSR, root, docg3,
1735                             &device_id_fops);
1736         debugfs_create_file("docg3_protection", S_IRUSR, root, docg3,
1737                             &protection_fops);
1738 }
1739
1740 /**
1741  * doc_set_driver_info - Fill the mtd_info structure and docg3 structure
1742  * @chip_id: The chip ID of the supported chip
1743  * @mtd: The structure to fill
1744  */
1745 static int __init doc_set_driver_info(int chip_id, struct mtd_info *mtd)
1746 {
1747         struct docg3 *docg3 = mtd->priv;
1748         int cfg;
1749
1750         cfg = doc_register_readb(docg3, DOC_CONFIGURATION);
1751         docg3->if_cfg = (cfg & DOC_CONF_IF_CFG ? 1 : 0);
1752         docg3->reliable = reliable_mode;
1753
1754         switch (chip_id) {
1755         case DOC_CHIPID_G3:
1756                 mtd->name = devm_kasprintf(docg3->dev, GFP_KERNEL, "docg3.%d",
1757                                            docg3->device_id);
1758                 if (!mtd->name)
1759                         return -ENOMEM;
1760                 docg3->max_block = 2047;
1761                 break;
1762         }
1763         mtd->type = MTD_NANDFLASH;
1764         mtd->flags = MTD_CAP_NANDFLASH;
1765         mtd->size = (docg3->max_block + 1) * DOC_LAYOUT_BLOCK_SIZE;
1766         if (docg3->reliable == 2)
1767                 mtd->size /= 2;
1768         mtd->erasesize = DOC_LAYOUT_BLOCK_SIZE * DOC_LAYOUT_NBPLANES;
1769         if (docg3->reliable == 2)
1770                 mtd->erasesize /= 2;
1771         mtd->writebufsize = mtd->writesize = DOC_LAYOUT_PAGE_SIZE;
1772         mtd->oobsize = DOC_LAYOUT_OOB_SIZE;
1773         mtd->_erase = doc_erase;
1774         mtd->_read_oob = doc_read_oob;
1775         mtd->_write_oob = doc_write_oob;
1776         mtd->_block_isbad = doc_block_isbad;
1777         mtd_set_ooblayout(mtd, &nand_ooblayout_docg3_ops);
1778         mtd->oobavail = 8;
1779         mtd->ecc_strength = DOC_ECC_BCH_T;
1780
1781         return 0;
1782 }
1783
1784 /**
1785  * doc_probe_device - Check if a device is available
1786  * @cascade: the cascade of chips this devices will belong to
1787  * @floor: the floor of the probed device
1788  * @dev: the device
1789  *
1790  * Checks whether a device at the specified IO range, and floor is available.
1791  *
1792  * Returns a mtd_info struct if there is a device, ENODEV if none found, ENOMEM
1793  * if a memory allocation failed. If floor 0 is checked, a reset of the ASIC is
1794  * launched.
1795  */
1796 static struct mtd_info * __init
1797 doc_probe_device(struct docg3_cascade *cascade, int floor, struct device *dev)
1798 {
1799         int ret, bbt_nbpages;
1800         u16 chip_id, chip_id_inv;
1801         struct docg3 *docg3;
1802         struct mtd_info *mtd;
1803
1804         ret = -ENOMEM;
1805         docg3 = kzalloc(sizeof(struct docg3), GFP_KERNEL);
1806         if (!docg3)
1807                 goto nomem1;
1808         mtd = kzalloc(sizeof(struct mtd_info), GFP_KERNEL);
1809         if (!mtd)
1810                 goto nomem2;
1811         mtd->priv = docg3;
1812         mtd->dev.parent = dev;
1813         bbt_nbpages = DIV_ROUND_UP(docg3->max_block + 1,
1814                                    8 * DOC_LAYOUT_PAGE_SIZE);
1815         docg3->bbt = kcalloc(DOC_LAYOUT_PAGE_SIZE, bbt_nbpages, GFP_KERNEL);
1816         if (!docg3->bbt)
1817                 goto nomem3;
1818
1819         docg3->dev = dev;
1820         docg3->device_id = floor;
1821         docg3->cascade = cascade;
1822         doc_set_device_id(docg3, docg3->device_id);
1823         if (!floor)
1824                 doc_set_asic_mode(docg3, DOC_ASICMODE_RESET);
1825         doc_set_asic_mode(docg3, DOC_ASICMODE_NORMAL);
1826
1827         chip_id = doc_register_readw(docg3, DOC_CHIPID);
1828         chip_id_inv = doc_register_readw(docg3, DOC_CHIPID_INV);
1829
1830         ret = 0;
1831         if (chip_id != (u16)(~chip_id_inv)) {
1832                 goto nomem4;
1833         }
1834
1835         switch (chip_id) {
1836         case DOC_CHIPID_G3:
1837                 doc_info("Found a G3 DiskOnChip at addr %p, floor %d\n",
1838                          docg3->cascade->base, floor);
1839                 break;
1840         default:
1841                 doc_err("Chip id %04x is not a DiskOnChip G3 chip\n", chip_id);
1842                 goto nomem4;
1843         }
1844
1845         ret = doc_set_driver_info(chip_id, mtd);
1846         if (ret)
1847                 goto nomem4;
1848
1849         doc_hamming_ecc_init(docg3, DOC_LAYOUT_OOB_PAGEINFO_SZ);
1850         doc_reload_bbt(docg3);
1851         return mtd;
1852
1853 nomem4:
1854         kfree(docg3->bbt);
1855 nomem3:
1856         kfree(mtd);
1857 nomem2:
1858         kfree(docg3);
1859 nomem1:
1860         return ret ? ERR_PTR(ret) : NULL;
1861 }
1862
1863 /**
1864  * doc_release_device - Release a docg3 floor
1865  * @mtd: the device
1866  */
1867 static void doc_release_device(struct mtd_info *mtd)
1868 {
1869         struct docg3 *docg3 = mtd->priv;
1870
1871         mtd_device_unregister(mtd);
1872         kfree(docg3->bbt);
1873         kfree(docg3);
1874         kfree(mtd);
1875 }
1876
1877 /**
1878  * docg3_resume - Awakens docg3 floor
1879  * @pdev: platfrom device
1880  *
1881  * Returns 0 (always successful)
1882  */
1883 static int docg3_resume(struct platform_device *pdev)
1884 {
1885         int i;
1886         struct docg3_cascade *cascade;
1887         struct mtd_info **docg3_floors, *mtd;
1888         struct docg3 *docg3;
1889
1890         cascade = platform_get_drvdata(pdev);
1891         docg3_floors = cascade->floors;
1892         mtd = docg3_floors[0];
1893         docg3 = mtd->priv;
1894
1895         doc_dbg("docg3_resume()\n");
1896         for (i = 0; i < 12; i++)
1897                 doc_readb(docg3, DOC_IOSPACE_IPL);
1898         return 0;
1899 }
1900
1901 /**
1902  * docg3_suspend - Put in low power mode the docg3 floor
1903  * @pdev: platform device
1904  * @state: power state
1905  *
1906  * Shuts off most of docg3 circuitery to lower power consumption.
1907  *
1908  * Returns 0 if suspend succeeded, -EIO if chip refused suspend
1909  */
1910 static int docg3_suspend(struct platform_device *pdev, pm_message_t state)
1911 {
1912         int floor, i;
1913         struct docg3_cascade *cascade;
1914         struct mtd_info **docg3_floors, *mtd;
1915         struct docg3 *docg3;
1916         u8 ctrl, pwr_down;
1917
1918         cascade = platform_get_drvdata(pdev);
1919         docg3_floors = cascade->floors;
1920         for (floor = 0; floor < DOC_MAX_NBFLOORS; floor++) {
1921                 mtd = docg3_floors[floor];
1922                 if (!mtd)
1923                         continue;
1924                 docg3 = mtd->priv;
1925
1926                 doc_writeb(docg3, floor, DOC_DEVICESELECT);
1927                 ctrl = doc_register_readb(docg3, DOC_FLASHCONTROL);
1928                 ctrl &= ~DOC_CTRL_VIOLATION & ~DOC_CTRL_CE;
1929                 doc_writeb(docg3, ctrl, DOC_FLASHCONTROL);
1930
1931                 for (i = 0; i < 10; i++) {
1932                         usleep_range(3000, 4000);
1933                         pwr_down = doc_register_readb(docg3, DOC_POWERMODE);
1934                         if (pwr_down & DOC_POWERDOWN_READY)
1935                                 break;
1936                 }
1937                 if (pwr_down & DOC_POWERDOWN_READY) {
1938                         doc_dbg("docg3_suspend(): floor %d powerdown ok\n",
1939                                 floor);
1940                 } else {
1941                         doc_err("docg3_suspend(): floor %d powerdown failed\n",
1942                                 floor);
1943                         return -EIO;
1944                 }
1945         }
1946
1947         mtd = docg3_floors[0];
1948         docg3 = mtd->priv;
1949         doc_set_asic_mode(docg3, DOC_ASICMODE_POWERDOWN);
1950         return 0;
1951 }
1952
1953 /**
1954  * doc_probe - Probe the IO space for a DiskOnChip G3 chip
1955  * @pdev: platform device
1956  *
1957  * Probes for a G3 chip at the specified IO space in the platform data
1958  * ressources. The floor 0 must be available.
1959  *
1960  * Returns 0 on success, -ENOMEM, -ENXIO on error
1961  */
1962 static int __init docg3_probe(struct platform_device *pdev)
1963 {
1964         struct device *dev = &pdev->dev;
1965         struct mtd_info *mtd;
1966         struct resource *ress;
1967         void __iomem *base;
1968         int ret, floor;
1969         struct docg3_cascade *cascade;
1970
1971         ret = -ENXIO;
1972         ress = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1973         if (!ress) {
1974                 dev_err(dev, "No I/O memory resource defined\n");
1975                 return ret;
1976         }
1977         base = devm_ioremap(dev, ress->start, DOC_IOSPACE_SIZE);
1978
1979         ret = -ENOMEM;
1980         cascade = devm_kcalloc(dev, DOC_MAX_NBFLOORS, sizeof(*cascade),
1981                                GFP_KERNEL);
1982         if (!cascade)
1983                 return ret;
1984         cascade->base = base;
1985         mutex_init(&cascade->lock);
1986         cascade->bch = bch_init(DOC_ECC_BCH_M, DOC_ECC_BCH_T,
1987                                 DOC_ECC_BCH_PRIMPOLY, false);
1988         if (!cascade->bch)
1989                 return ret;
1990
1991         for (floor = 0; floor < DOC_MAX_NBFLOORS; floor++) {
1992                 mtd = doc_probe_device(cascade, floor, dev);
1993                 if (IS_ERR(mtd)) {
1994                         ret = PTR_ERR(mtd);
1995                         goto err_probe;
1996                 }
1997                 if (!mtd) {
1998                         if (floor == 0)
1999                                 goto notfound;
2000                         else
2001                                 continue;
2002                 }
2003                 cascade->floors[floor] = mtd;
2004                 ret = mtd_device_parse_register(mtd, part_probes, NULL, NULL,
2005                                                 0);
2006                 if (ret)
2007                         goto err_probe;
2008
2009                 doc_dbg_register(cascade->floors[floor]);
2010         }
2011
2012         ret = doc_register_sysfs(pdev, cascade);
2013         if (ret)
2014                 goto err_probe;
2015
2016         platform_set_drvdata(pdev, cascade);
2017         return 0;
2018
2019 notfound:
2020         ret = -ENODEV;
2021         dev_info(dev, "No supported DiskOnChip found\n");
2022 err_probe:
2023         bch_free(cascade->bch);
2024         for (floor = 0; floor < DOC_MAX_NBFLOORS; floor++)
2025                 if (cascade->floors[floor])
2026                         doc_release_device(cascade->floors[floor]);
2027         return ret;
2028 }
2029
2030 /**
2031  * docg3_release - Release the driver
2032  * @pdev: the platform device
2033  *
2034  * Returns 0
2035  */
2036 static int docg3_release(struct platform_device *pdev)
2037 {
2038         struct docg3_cascade *cascade = platform_get_drvdata(pdev);
2039         struct docg3 *docg3 = cascade->floors[0]->priv;
2040         int floor;
2041
2042         doc_unregister_sysfs(pdev, cascade);
2043         for (floor = 0; floor < DOC_MAX_NBFLOORS; floor++)
2044                 if (cascade->floors[floor])
2045                         doc_release_device(cascade->floors[floor]);
2046
2047         bch_free(docg3->cascade->bch);
2048         return 0;
2049 }
2050
2051 #ifdef CONFIG_OF
2052 static const struct of_device_id docg3_dt_ids[] = {
2053         { .compatible = "m-systems,diskonchip-g3" },
2054         {}
2055 };
2056 MODULE_DEVICE_TABLE(of, docg3_dt_ids);
2057 #endif
2058
2059 static struct platform_driver g3_driver = {
2060         .driver         = {
2061                 .name   = "docg3",
2062                 .of_match_table = of_match_ptr(docg3_dt_ids),
2063         },
2064         .suspend        = docg3_suspend,
2065         .resume         = docg3_resume,
2066         .remove         = docg3_release,
2067 };
2068
2069 module_platform_driver_probe(g3_driver, docg3_probe);
2070
2071 MODULE_LICENSE("GPL");
2072 MODULE_AUTHOR("Robert Jarzmik <robert.jarzmik@free.fr>");
2073 MODULE_DESCRIPTION("MTD driver for DiskOnChip G3");