linux/drivers/mtd/nand/raw/diskonchip.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * (C) 2003 Red Hat, Inc.
   4 * (C) 2004 Dan Brown <dan_brown@ieee.org>
   5 * (C) 2004 Kalev Lember <kalev@smartlink.ee>
   6 *
   7 * Author: David Woodhouse <dwmw2@infradead.org>
   8 * Additional Diskonchip 2000 and Millennium support by Dan Brown <dan_brown@ieee.org>
   9 * Diskonchip Millennium Plus support by Kalev Lember <kalev@smartlink.ee>
  10 *
  11 * Error correction code lifted from the old docecc code
  12 * Author: Fabrice Bellard (fabrice.bellard@netgem.com)
  13 * Copyright (C) 2000 Netgem S.A.
  14 * converted to the generic Reed-Solomon library by Thomas Gleixner <tglx@linutronix.de>
  15 *
  16 * Interface to generic NAND code for M-Systems DiskOnChip devices
  17 */
  18
  19#include <linux/kernel.h>
  20#include <linux/init.h>
  21#include <linux/sched.h>
  22#include <linux/delay.h>
  23#include <linux/rslib.h>
  24#include <linux/moduleparam.h>
  25#include <linux/slab.h>
  26#include <linux/io.h>
  27
  28#include <linux/mtd/mtd.h>
  29#include <linux/mtd/rawnand.h>
  30#include <linux/mtd/doc2000.h>
  31#include <linux/mtd/partitions.h>
  32#include <linux/mtd/inftl.h>
  33#include <linux/module.h>
  34
  35/* Where to look for the devices? */
  36#ifndef CONFIG_MTD_NAND_DISKONCHIP_PROBE_ADDRESS
  37#define CONFIG_MTD_NAND_DISKONCHIP_PROBE_ADDRESS 0
  38#endif
  39
  40static unsigned long doc_locations[] __initdata = {
  41#if defined (__alpha__) || defined(__i386__) || defined(__x86_64__)
  42#ifdef CONFIG_MTD_NAND_DISKONCHIP_PROBE_HIGH
  43        0xfffc8000, 0xfffca000, 0xfffcc000, 0xfffce000,
  44        0xfffd0000, 0xfffd2000, 0xfffd4000, 0xfffd6000,
  45        0xfffd8000, 0xfffda000, 0xfffdc000, 0xfffde000,
  46        0xfffe0000, 0xfffe2000, 0xfffe4000, 0xfffe6000,
  47        0xfffe8000, 0xfffea000, 0xfffec000, 0xfffee000,
  48#else
  49        0xc8000, 0xca000, 0xcc000, 0xce000,
  50        0xd0000, 0xd2000, 0xd4000, 0xd6000,
  51        0xd8000, 0xda000, 0xdc000, 0xde000,
  52        0xe0000, 0xe2000, 0xe4000, 0xe6000,
  53        0xe8000, 0xea000, 0xec000, 0xee000,
  54#endif
  55#endif
  56        0xffffffff };
  57
  58static struct mtd_info *doclist = NULL;
  59
  60struct doc_priv {
  61        struct nand_controller base;
  62        void __iomem *virtadr;
  63        unsigned long physadr;
  64        u_char ChipID;
  65        u_char CDSNControl;
  66        int chips_per_floor;    /* The number of chips detected on each floor */
  67        int curfloor;
  68        int curchip;
  69        int mh0_page;
  70        int mh1_page;
  71        struct rs_control *rs_decoder;
  72        struct mtd_info *nextdoc;
  73        bool supports_32b_reads;
  74
  75        /* Handle the last stage of initialization (BBT scan, partitioning) */
  76        int (*late_init)(struct mtd_info *mtd);
  77};
  78
  79/* This is the ecc value computed by the HW ecc generator upon writing an empty
  80   page, one with all 0xff for data. */
  81static u_char empty_write_ecc[6] = { 0x4b, 0x00, 0xe2, 0x0e, 0x93, 0xf7 };
  82
  83#define INFTL_BBT_RESERVED_BLOCKS 4
  84
  85#define DoC_is_MillenniumPlus(doc) ((doc)->ChipID == DOC_ChipID_DocMilPlus16 || (doc)->ChipID == DOC_ChipID_DocMilPlus32)
  86#define DoC_is_Millennium(doc) ((doc)->ChipID == DOC_ChipID_DocMil)
  87#define DoC_is_2000(doc) ((doc)->ChipID == DOC_ChipID_Doc2k)
  88
  89static int debug = 0;
  90module_param(debug, int, 0);
  91
  92static int try_dword = 1;
  93module_param(try_dword, int, 0);
  94
  95static int no_ecc_failures = 0;
  96module_param(no_ecc_failures, int, 0);
  97
  98static int no_autopart = 0;
  99module_param(no_autopart, int, 0);
 100
 101static int show_firmware_partition = 0;
 102module_param(show_firmware_partition, int, 0);
 103
 104#ifdef CONFIG_MTD_NAND_DISKONCHIP_BBTWRITE
 105static int inftl_bbt_write = 1;
 106#else
 107static int inftl_bbt_write = 0;
 108#endif
 109module_param(inftl_bbt_write, int, 0);
 110
 111static unsigned long doc_config_location = CONFIG_MTD_NAND_DISKONCHIP_PROBE_ADDRESS;
 112module_param(doc_config_location, ulong, 0);
 113MODULE_PARM_DESC(doc_config_location, "Physical memory address at which to probe for DiskOnChip");
 114
 115/* Sector size for HW ECC */
 116#define SECTOR_SIZE 512
 117/* The sector bytes are packed into NB_DATA 10 bit words */
 118#define NB_DATA (((SECTOR_SIZE + 1) * 8 + 6) / 10)
 119/* Number of roots */
 120#define NROOTS 4
 121/* First consective root */
 122#define FCR 510
 123/* Number of symbols */
 124#define NN 1023
 125
 126/*
 127 * The HW decoder in the DoC ASIC's provides us a error syndrome,
 128 * which we must convert to a standard syndrome usable by the generic
 129 * Reed-Solomon library code.
 130 *
 131 * Fabrice Bellard figured this out in the old docecc code. I added
 132 * some comments, improved a minor bit and converted it to make use
 133 * of the generic Reed-Solomon library. tglx
 134 */
 135static int doc_ecc_decode(struct rs_control *rs, uint8_t *data, uint8_t *ecc)
 136{
 137        int i, j, nerr, errpos[8];
 138        uint8_t parity;
 139        uint16_t ds[4], s[5], tmp, errval[8], syn[4];
 140        struct rs_codec *cd = rs->codec;
 141
 142        memset(syn, 0, sizeof(syn));
 143        /* Convert the ecc bytes into words */
 144        ds[0] = ((ecc[4] & 0xff) >> 0) | ((ecc[5] & 0x03) << 8);
 145        ds[1] = ((ecc[5] & 0xfc) >> 2) | ((ecc[2] & 0x0f) << 6);
 146        ds[2] = ((ecc[2] & 0xf0) >> 4) | ((ecc[3] & 0x3f) << 4);
 147        ds[3] = ((ecc[3] & 0xc0) >> 6) | ((ecc[0] & 0xff) << 2);
 148        parity = ecc[1];
 149
 150        /* Initialize the syndrome buffer */
 151        for (i = 0; i < NROOTS; i++)
 152                s[i] = ds[0];
 153        /*
 154         *  Evaluate
 155         *  s[i] = ds[3]x^3 + ds[2]x^2 + ds[1]x^1 + ds[0]
 156         *  where x = alpha^(FCR + i)
 157         */
 158        for (j = 1; j < NROOTS; j++) {
 159                if (ds[j] == 0)
 160                        continue;
 161                tmp = cd->index_of[ds[j]];
 162                for (i = 0; i < NROOTS; i++)
 163                        s[i] ^= cd->alpha_to[rs_modnn(cd, tmp + (FCR + i) * j)];
 164        }
 165
 166        /* Calc syn[i] = s[i] / alpha^(v + i) */
 167        for (i = 0; i < NROOTS; i++) {
 168                if (s[i])
 169                        syn[i] = rs_modnn(cd, cd->index_of[s[i]] + (NN - FCR - i));
 170        }
 171        /* Call the decoder library */
 172        nerr = decode_rs16(rs, NULL, NULL, 1019, syn, 0, errpos, 0, errval);
 173
 174        /* Incorrectable errors ? */
 175        if (nerr < 0)
 176                return nerr;
 177
 178        /*
 179         * Correct the errors. The bitpositions are a bit of magic,
 180         * but they are given by the design of the de/encoder circuit
 181         * in the DoC ASIC's.
 182         */
 183        for (i = 0; i < nerr; i++) {
 184                int index, bitpos, pos = 1015 - errpos[i];
 185                uint8_t val;
 186                if (pos >= NB_DATA && pos < 1019)
 187                        continue;
 188                if (pos < NB_DATA) {
 189                        /* extract bit position (MSB first) */
 190                        pos = 10 * (NB_DATA - 1 - pos) - 6;
 191                        /* now correct the following 10 bits. At most two bytes
 192                           can be modified since pos is even */
 193                        index = (pos >> 3) ^ 1;
 194                        bitpos = pos & 7;
 195                        if ((index >= 0 && index < SECTOR_SIZE) || index == (SECTOR_SIZE + 1)) {
 196                                val = (uint8_t) (errval[i] >> (2 + bitpos));
 197                                parity ^= val;
 198                                if (index < SECTOR_SIZE)
 199                                        data[index] ^= val;
 200                        }
 201                        index = ((pos >> 3) + 1) ^ 1;
 202                        bitpos = (bitpos + 10) & 7;
 203                        if (bitpos == 0)
 204                                bitpos = 8;
 205                        if ((index >= 0 && index < SECTOR_SIZE) || index == (SECTOR_SIZE + 1)) {
 206                                val = (uint8_t) (errval[i] << (8 - bitpos));
 207                                parity ^= val;
 208                                if (index < SECTOR_SIZE)
 209                                        data[index] ^= val;
 210                        }
 211                }
 212        }
 213        /* If the parity is wrong, no rescue possible */
 214        return parity ? -EBADMSG : nerr;
 215}
 216
 217static void DoC_Delay(struct doc_priv *doc, unsigned short cycles)
 218{
 219        volatile char __always_unused dummy;
 220        int i;
 221
 222        for (i = 0; i < cycles; i++) {
 223                if (DoC_is_Millennium(doc))
 224                        dummy = ReadDOC(doc->virtadr, NOP);
 225                else if (DoC_is_MillenniumPlus(doc))
 226                        dummy = ReadDOC(doc->virtadr, Mplus_NOP);
 227                else
 228                        dummy = ReadDOC(doc->virtadr, DOCStatus);
 229        }
 230
 231}
 232
 233#define CDSN_CTRL_FR_B_MASK     (CDSN_CTRL_FR_B0 | CDSN_CTRL_FR_B1)
 234
 235/* DOC_WaitReady: Wait for RDY line to be asserted by the flash chip */
 236static int _DoC_WaitReady(struct doc_priv *doc)
 237{
 238        void __iomem *docptr = doc->virtadr;
 239        unsigned long timeo = jiffies + (HZ * 10);
 240
 241        if (debug)
 242                printk("_DoC_WaitReady...\n");
 243        /* Out-of-line routine to wait for chip response */
 244        if (DoC_is_MillenniumPlus(doc)) {
 245                while ((ReadDOC(docptr, Mplus_FlashControl) & CDSN_CTRL_FR_B_MASK) != CDSN_CTRL_FR_B_MASK) {
 246                        if (time_after(jiffies, timeo)) {
 247                                printk("_DoC_WaitReady timed out.\n");
 248                                return -EIO;
 249                        }
 250                        udelay(1);
 251                        cond_resched();
 252                }
 253        } else {
 254                while (!(ReadDOC(docptr, CDSNControl) & CDSN_CTRL_FR_B)) {
 255                        if (time_after(jiffies, timeo)) {
 256                                printk("_DoC_WaitReady timed out.\n");
 257                                return -EIO;
 258                        }
 259                        udelay(1);
 260                        cond_resched();
 261                }
 262        }
 263
 264        return 0;
 265}
 266
 267static inline int DoC_WaitReady(struct doc_priv *doc)
 268{
 269        void __iomem *docptr = doc->virtadr;
 270        int ret = 0;
 271
 272        if (DoC_is_MillenniumPlus(doc)) {
 273                DoC_Delay(doc, 4);
 274
 275                if ((ReadDOC(docptr, Mplus_FlashControl) & CDSN_CTRL_FR_B_MASK) != CDSN_CTRL_FR_B_MASK)
 276                        /* Call the out-of-line routine to wait */
 277                        ret = _DoC_WaitReady(doc);
 278        } else {
 279                DoC_Delay(doc, 4);
 280
 281                if (!(ReadDOC(docptr, CDSNControl) & CDSN_CTRL_FR_B))
 282                        /* Call the out-of-line routine to wait */
 283                        ret = _DoC_WaitReady(doc);
 284                DoC_Delay(doc, 2);
 285        }
 286
 287        if (debug)
 288                printk("DoC_WaitReady OK\n");
 289        return ret;
 290}
 291
 292static void doc2000_write_byte(struct nand_chip *this, u_char datum)
 293{
 294        struct doc_priv *doc = nand_get_controller_data(this);
 295        void __iomem *docptr = doc->virtadr;
 296
 297        if (debug)
 298                printk("write_byte %02x\n", datum);
 299        WriteDOC(datum, docptr, CDSNSlowIO);
 300        WriteDOC(datum, docptr, 2k_CDSN_IO);
 301}
 302
 303static void doc2000_writebuf(struct nand_chip *this, const u_char *buf,
 304                             int len)
 305{
 306        struct doc_priv *doc = nand_get_controller_data(this);
 307        void __iomem *docptr = doc->virtadr;
 308        int i;
 309        if (debug)
 310                printk("writebuf of %d bytes: ", len);
 311        for (i = 0; i < len; i++) {
 312                WriteDOC_(buf[i], docptr, DoC_2k_CDSN_IO + i);
 313                if (debug && i < 16)
 314                        printk("%02x ", buf[i]);
 315        }
 316        if (debug)
 317                printk("\n");
 318}
 319
 320static void doc2000_readbuf(struct nand_chip *this, u_char *buf, int len)
 321{
 322        struct doc_priv *doc = nand_get_controller_data(this);
 323        void __iomem *docptr = doc->virtadr;
 324        u32 *buf32 = (u32 *)buf;
 325        int i;
 326
 327        if (debug)
 328                printk("readbuf of %d bytes: ", len);
 329
 330        if (!doc->supports_32b_reads ||
 331            ((((unsigned long)buf) | len) & 3)) {
 332                for (i = 0; i < len; i++)
 333                        buf[i] = ReadDOC(docptr, 2k_CDSN_IO + i);
 334        } else {
 335                for (i = 0; i < len / 4; i++)
 336                        buf32[i] = readl(docptr + DoC_2k_CDSN_IO + i);
 337        }
 338}
 339
 340/*
 341 * We need our own readid() here because it's called before the NAND chip
 342 * has been initialized, and calling nand_op_readid() would lead to a NULL
 343 * pointer exception when dereferencing the NAND timings.
 344 */
 345static void doc200x_readid(struct nand_chip *this, unsigned int cs, u8 *id)
 346{
 347        u8 addr = 0;
 348        struct nand_op_instr instrs[] = {
 349                NAND_OP_CMD(NAND_CMD_READID, 0),
 350                NAND_OP_ADDR(1, &addr, 50),
 351                NAND_OP_8BIT_DATA_IN(2, id, 0),
 352        };
 353
 354        struct nand_operation op = NAND_OPERATION(cs, instrs);
 355
 356        if (!id)
 357                op.ninstrs--;
 358
 359        this->controller->ops->exec_op(this, &op, false);
 360}
 361
 362static uint16_t __init doc200x_ident_chip(struct mtd_info *mtd, int nr)
 363{
 364        struct nand_chip *this = mtd_to_nand(mtd);
 365        struct doc_priv *doc = nand_get_controller_data(this);
 366        uint16_t ret;
 367        u8 id[2];
 368
 369        doc200x_readid(this, nr, id);
 370
 371        ret = ((u16)id[0] << 8) | id[1];
 372
 373        if (doc->ChipID == DOC_ChipID_Doc2k && try_dword && !nr) {
 374                /* First chip probe. See if we get same results by 32-bit access */
 375                union {
 376                        uint32_t dword;
 377                        uint8_t byte[4];
 378                } ident;
 379                void __iomem *docptr = doc->virtadr;
 380
 381                doc200x_readid(this, nr, NULL);
 382
 383                ident.dword = readl(docptr + DoC_2k_CDSN_IO);
 384                if (((ident.byte[0] << 8) | ident.byte[1]) == ret) {
 385                        pr_info("DiskOnChip 2000 responds to DWORD access\n");
 386                        doc->supports_32b_reads = true;
 387                }
 388        }
 389
 390        return ret;
 391}
 392
 393static void __init doc2000_count_chips(struct mtd_info *mtd)
 394{
 395        struct nand_chip *this = mtd_to_nand(mtd);
 396        struct doc_priv *doc = nand_get_controller_data(this);
 397        uint16_t mfrid;
 398        int i;
 399
 400        /* Max 4 chips per floor on DiskOnChip 2000 */
 401        doc->chips_per_floor = 4;
 402
 403        /* Find out what the first chip is */
 404        mfrid = doc200x_ident_chip(mtd, 0);
 405
 406        /* Find how many chips in each floor. */
 407        for (i = 1; i < 4; i++) {
 408                if (doc200x_ident_chip(mtd, i) != mfrid)
 409                        break;
 410        }
 411        doc->chips_per_floor = i;
 412        pr_debug("Detected %d chips per floor.\n", i);
 413}
 414
 415static void doc2001_write_byte(struct nand_chip *this, u_char datum)
 416{
 417        struct doc_priv *doc = nand_get_controller_data(this);
 418        void __iomem *docptr = doc->virtadr;
 419
 420        WriteDOC(datum, docptr, CDSNSlowIO);
 421        WriteDOC(datum, docptr, Mil_CDSN_IO);
 422        WriteDOC(datum, docptr, WritePipeTerm);
 423}
 424
 425static void doc2001_writebuf(struct nand_chip *this, const u_char *buf, int len)
 426{
 427        struct doc_priv *doc = nand_get_controller_data(this);
 428        void __iomem *docptr = doc->virtadr;
 429        int i;
 430
 431        for (i = 0; i < len; i++)
 432                WriteDOC_(buf[i], docptr, DoC_Mil_CDSN_IO + i);
 433        /* Terminate write pipeline */
 434        WriteDOC(0x00, docptr, WritePipeTerm);
 435}
 436
 437static void doc2001_readbuf(struct nand_chip *this, u_char *buf, int len)
 438{
 439        struct doc_priv *doc = nand_get_controller_data(this);
 440        void __iomem *docptr = doc->virtadr;
 441        int i;
 442
 443        /* Start read pipeline */
 444        ReadDOC(docptr, ReadPipeInit);
 445
 446        for (i = 0; i < len - 1; i++)
 447                buf[i] = ReadDOC(docptr, Mil_CDSN_IO + (i & 0xff));
 448
 449        /* Terminate read pipeline */
 450        buf[i] = ReadDOC(docptr, LastDataRead);
 451}
 452
 453static void doc2001plus_writebuf(struct nand_chip *this, const u_char *buf, int len)
 454{
 455        struct doc_priv *doc = nand_get_controller_data(this);
 456        void __iomem *docptr = doc->virtadr;
 457        int i;
 458
 459        if (debug)
 460                printk("writebuf of %d bytes: ", len);
 461        for (i = 0; i < len; i++) {
 462                WriteDOC_(buf[i], docptr, DoC_Mil_CDSN_IO + i);
 463                if (debug && i < 16)
 464                        printk("%02x ", buf[i]);
 465        }
 466        if (debug)
 467                printk("\n");
 468}
 469
 470static void doc2001plus_readbuf(struct nand_chip *this, u_char *buf, int len)
 471{
 472        struct doc_priv *doc = nand_get_controller_data(this);
 473        void __iomem *docptr = doc->virtadr;
 474        int i;
 475
 476        if (debug)
 477                printk("readbuf of %d bytes: ", len);
 478
 479        /* Start read pipeline */
 480        ReadDOC(docptr, Mplus_ReadPipeInit);
 481        ReadDOC(docptr, Mplus_ReadPipeInit);
 482
 483        for (i = 0; i < len - 2; i++) {
 484                buf[i] = ReadDOC(docptr, Mil_CDSN_IO);
 485                if (debug && i < 16)
 486                        printk("%02x ", buf[i]);
 487        }
 488
 489        /* Terminate read pipeline */
 490        if (len >= 2) {
 491                buf[len - 2] = ReadDOC(docptr, Mplus_LastDataRead);
 492                if (debug && i < 16)
 493                        printk("%02x ", buf[len - 2]);
 494        }
 495
 496        buf[len - 1] = ReadDOC(docptr, Mplus_LastDataRead);
 497        if (debug && i < 16)
 498                printk("%02x ", buf[len - 1]);
 499        if (debug)
 500                printk("\n");
 501}
 502
 503static void doc200x_write_control(struct doc_priv *doc, u8 value)
 504{
 505        WriteDOC(value, doc->virtadr, CDSNControl);
 506        /* 11.4.3 -- 4 NOPs after CSDNControl write */
 507        DoC_Delay(doc, 4);
 508}
 509
 510static void doc200x_exec_instr(struct nand_chip *this,
 511                               const struct nand_op_instr *instr)
 512{
 513        struct doc_priv *doc = nand_get_controller_data(this);
 514        unsigned int i;
 515
 516        switch (instr->type) {
 517        case NAND_OP_CMD_INSTR:
 518                doc200x_write_control(doc, CDSN_CTRL_CE | CDSN_CTRL_CLE);
 519                doc2000_write_byte(this, instr->ctx.cmd.opcode);
 520                break;
 521
 522        case NAND_OP_ADDR_INSTR:
 523                doc200x_write_control(doc, CDSN_CTRL_CE | CDSN_CTRL_ALE);
 524                for (i = 0; i < instr->ctx.addr.naddrs; i++) {
 525                        u8 addr = instr->ctx.addr.addrs[i];
 526
 527                        if (DoC_is_2000(doc))
 528                                doc2000_write_byte(this, addr);
 529                        else
 530                                doc2001_write_byte(this, addr);
 531                }
 532                break;
 533
 534        case NAND_OP_DATA_IN_INSTR:
 535                doc200x_write_control(doc, CDSN_CTRL_CE);
 536                if (DoC_is_2000(doc))
 537                        doc2000_readbuf(this, instr->ctx.data.buf.in,
 538                                        instr->ctx.data.len);
 539                else
 540                        doc2001_readbuf(this, instr->ctx.data.buf.in,
 541                                        instr->ctx.data.len);
 542                break;
 543
 544        case NAND_OP_DATA_OUT_INSTR:
 545                doc200x_write_control(doc, CDSN_CTRL_CE);
 546                if (DoC_is_2000(doc))
 547                        doc2000_writebuf(this, instr->ctx.data.buf.out,
 548                                         instr->ctx.data.len);
 549                else
 550                        doc2001_writebuf(this, instr->ctx.data.buf.out,
 551                                         instr->ctx.data.len);
 552                break;
 553
 554        case NAND_OP_WAITRDY_INSTR:
 555                DoC_WaitReady(doc);
 556                break;
 557        }
 558
 559        if (instr->delay_ns)
 560                ndelay(instr->delay_ns);
 561}
 562
 563static int doc200x_exec_op(struct nand_chip *this,
 564                           const struct nand_operation *op,
 565                           bool check_only)
 566{
 567        struct doc_priv *doc = nand_get_controller_data(this);
 568        unsigned int i;
 569
 570        if (check_only)
 571                return true;
 572
 573        doc->curchip = op->cs % doc->chips_per_floor;
 574        doc->curfloor = op->cs / doc->chips_per_floor;
 575
 576        WriteDOC(doc->curfloor, doc->virtadr, FloorSelect);
 577        WriteDOC(doc->curchip, doc->virtadr, CDSNDeviceSelect);
 578
 579        /* Assert CE pin */
 580        doc200x_write_control(doc, CDSN_CTRL_CE);
 581
 582        for (i = 0; i < op->ninstrs; i++)
 583                doc200x_exec_instr(this, &op->instrs[i]);
 584
 585        /* De-assert CE pin */
 586        doc200x_write_control(doc, 0);
 587
 588        return 0;
 589}
 590
 591static void doc2001plus_write_pipe_term(struct doc_priv *doc)
 592{
 593        WriteDOC(0x00, doc->virtadr, Mplus_WritePipeTerm);
 594        WriteDOC(0x00, doc->virtadr, Mplus_WritePipeTerm);
 595}
 596
 597static void doc2001plus_exec_instr(struct nand_chip *this,
 598                                   const struct nand_op_instr *instr)
 599{
 600        struct doc_priv *doc = nand_get_controller_data(this);
 601        unsigned int i;
 602
 603        switch (instr->type) {
 604        case NAND_OP_CMD_INSTR:
 605                WriteDOC(instr->ctx.cmd.opcode, doc->virtadr, Mplus_FlashCmd);
 606                doc2001plus_write_pipe_term(doc);
 607                break;
 608
 609        case NAND_OP_ADDR_INSTR:
 610                for (i = 0; i < instr->ctx.addr.naddrs; i++) {
 611                        u8 addr = instr->ctx.addr.addrs[i];
 612
 613                        WriteDOC(addr, doc->virtadr, Mplus_FlashAddress);
 614                }
 615                doc2001plus_write_pipe_term(doc);
 616                /* deassert ALE */
 617                WriteDOC(0, doc->virtadr, Mplus_FlashControl);
 618                break;
 619
 620        case NAND_OP_DATA_IN_INSTR:
 621                doc2001plus_readbuf(this, instr->ctx.data.buf.in,
 622                                    instr->ctx.data.len);
 623                break;
 624        case NAND_OP_DATA_OUT_INSTR:
 625                doc2001plus_writebuf(this, instr->ctx.data.buf.out,
 626                                     instr->ctx.data.len);
 627                doc2001plus_write_pipe_term(doc);
 628                break;
 629        case NAND_OP_WAITRDY_INSTR:
 630                DoC_WaitReady(doc);
 631                break;
 632        }
 633
 634        if (instr->delay_ns)
 635                ndelay(instr->delay_ns);
 636}
 637
 638static int doc2001plus_exec_op(struct nand_chip *this,
 639                               const struct nand_operation *op,
 640                               bool check_only)
 641{
 642        struct doc_priv *doc = nand_get_controller_data(this);
 643        unsigned int i;
 644
 645        if (check_only)
 646                return true;
 647
 648        doc->curchip = op->cs % doc->chips_per_floor;
 649        doc->curfloor = op->cs / doc->chips_per_floor;
 650
 651        /* Assert ChipEnable and deassert WriteProtect */
 652        WriteDOC(DOC_FLASH_CE, doc->virtadr, Mplus_FlashSelect);
 653
 654        for (i = 0; i < op->ninstrs; i++)
 655                doc2001plus_exec_instr(this, &op->instrs[i]);
 656
 657        /* De-assert ChipEnable */
 658        WriteDOC(0, doc->virtadr, Mplus_FlashSelect);
 659
 660        return 0;
 661}
 662
 663static void doc200x_enable_hwecc(struct nand_chip *this, int mode)
 664{
 665        struct doc_priv *doc = nand_get_controller_data(this);
 666        void __iomem *docptr = doc->virtadr;
 667
 668        /* Prime the ECC engine */
 669        switch (mode) {
 670        case NAND_ECC_READ:
 671                WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
 672                WriteDOC(DOC_ECC_EN, docptr, ECCConf);
 673                break;
 674        case NAND_ECC_WRITE:
 675                WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
 676                WriteDOC(DOC_ECC_EN | DOC_ECC_RW, docptr, ECCConf);
 677                break;
 678        }
 679}
 680
 681static void doc2001plus_enable_hwecc(struct nand_chip *this, int mode)
 682{
 683        struct doc_priv *doc = nand_get_controller_data(this);
 684        void __iomem *docptr = doc->virtadr;
 685
 686        /* Prime the ECC engine */
 687        switch (mode) {
 688        case NAND_ECC_READ:
 689                WriteDOC(DOC_ECC_RESET, docptr, Mplus_ECCConf);
 690                WriteDOC(DOC_ECC_EN, docptr, Mplus_ECCConf);
 691                break;
 692        case NAND_ECC_WRITE:
 693                WriteDOC(DOC_ECC_RESET, docptr, Mplus_ECCConf);
 694                WriteDOC(DOC_ECC_EN | DOC_ECC_RW, docptr, Mplus_ECCConf);
 695                break;
 696        }
 697}
 698
 699/* This code is only called on write */
 700static int doc200x_calculate_ecc(struct nand_chip *this, const u_char *dat,
 701                                 unsigned char *ecc_code)
 702{
 703        struct doc_priv *doc = nand_get_controller_data(this);
 704        void __iomem *docptr = doc->virtadr;
 705        int i;
 706        int __always_unused emptymatch = 1;
 707
 708        /* flush the pipeline */
 709        if (DoC_is_2000(doc)) {
 710                WriteDOC(doc->CDSNControl & ~CDSN_CTRL_FLASH_IO, docptr, CDSNControl);
 711                WriteDOC(0, docptr, 2k_CDSN_IO);
 712                WriteDOC(0, docptr, 2k_CDSN_IO);
 713                WriteDOC(0, docptr, 2k_CDSN_IO);
 714                WriteDOC(doc->CDSNControl, docptr, CDSNControl);
 715        } else if (DoC_is_MillenniumPlus(doc)) {
 716                WriteDOC(0, docptr, Mplus_NOP);
 717                WriteDOC(0, docptr, Mplus_NOP);
 718                WriteDOC(0, docptr, Mplus_NOP);
 719        } else {
 720                WriteDOC(0, docptr, NOP);
 721                WriteDOC(0, docptr, NOP);
 722                WriteDOC(0, docptr, NOP);
 723        }
 724
 725        for (i = 0; i < 6; i++) {
 726                if (DoC_is_MillenniumPlus(doc))
 727                        ecc_code[i] = ReadDOC_(docptr, DoC_Mplus_ECCSyndrome0 + i);
 728                else
 729                        ecc_code[i] = ReadDOC_(docptr, DoC_ECCSyndrome0 + i);
 730                if (ecc_code[i] != empty_write_ecc[i])
 731                        emptymatch = 0;
 732        }
 733        if (DoC_is_MillenniumPlus(doc))
 734                WriteDOC(DOC_ECC_DIS, docptr, Mplus_ECCConf);
 735        else
 736                WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
 737#if 0
 738        /* If emptymatch=1, we might have an all-0xff data buffer.  Check. */
 739        if (emptymatch) {
 740                /* Note: this somewhat expensive test should not be triggered
 741                   often.  It could be optimized away by examining the data in
 742                   the writebuf routine, and remembering the result. */
 743                for (i = 0; i < 512; i++) {
 744                        if (dat[i] == 0xff)
 745                                continue;
 746                        emptymatch = 0;
 747                        break;
 748                }
 749        }
 750        /* If emptymatch still =1, we do have an all-0xff data buffer.
 751           Return all-0xff ecc value instead of the computed one, so
 752           it'll look just like a freshly-erased page. */
 753        if (emptymatch)
 754                memset(ecc_code, 0xff, 6);
 755#endif
 756        return 0;
 757}
 758
 759static int doc200x_correct_data(struct nand_chip *this, u_char *dat,
 760                                u_char *read_ecc, u_char *isnull)
 761{
 762        int i, ret = 0;
 763        struct doc_priv *doc = nand_get_controller_data(this);
 764        void __iomem *docptr = doc->virtadr;
 765        uint8_t calc_ecc[6];
 766        volatile u_char dummy;
 767
 768        /* flush the pipeline */
 769        if (DoC_is_2000(doc)) {
 770                dummy = ReadDOC(docptr, 2k_ECCStatus);
 771                dummy = ReadDOC(docptr, 2k_ECCStatus);
 772                dummy = ReadDOC(docptr, 2k_ECCStatus);
 773        } else if (DoC_is_MillenniumPlus(doc)) {
 774                dummy = ReadDOC(docptr, Mplus_ECCConf);
 775                dummy = ReadDOC(docptr, Mplus_ECCConf);
 776                dummy = ReadDOC(docptr, Mplus_ECCConf);
 777        } else {
 778                dummy = ReadDOC(docptr, ECCConf);
 779                dummy = ReadDOC(docptr, ECCConf);
 780                dummy = ReadDOC(docptr, ECCConf);
 781        }
 782
 783        /* Error occurred ? */
 784        if (dummy & 0x80) {
 785                for (i = 0; i < 6; i++) {
 786                        if (DoC_is_MillenniumPlus(doc))
 787                                calc_ecc[i] = ReadDOC_(docptr, DoC_Mplus_ECCSyndrome0 + i);
 788                        else
 789                                calc_ecc[i] = ReadDOC_(docptr, DoC_ECCSyndrome0 + i);
 790                }
 791
 792                ret = doc_ecc_decode(doc->rs_decoder, dat, calc_ecc);
 793                if (ret > 0)
 794                        pr_err("doc200x_correct_data corrected %d errors\n",
 795                               ret);
 796        }
 797        if (DoC_is_MillenniumPlus(doc))
 798                WriteDOC(DOC_ECC_DIS, docptr, Mplus_ECCConf);
 799        else
 800                WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
 801        if (no_ecc_failures && mtd_is_eccerr(ret)) {
 802                pr_err("suppressing ECC failure\n");
 803                ret = 0;
 804        }
 805        return ret;
 806}
 807
 808//u_char mydatabuf[528];
 809
 810static int doc200x_ooblayout_ecc(struct mtd_info *mtd, int section,
 811                                 struct mtd_oob_region *oobregion)
 812{
 813        if (section)
 814                return -ERANGE;
 815
 816        oobregion->offset = 0;
 817        oobregion->length = 6;
 818
 819        return 0;
 820}
 821
 822static int doc200x_ooblayout_free(struct mtd_info *mtd, int section,
 823                                  struct mtd_oob_region *oobregion)
 824{
 825        if (section > 1)
 826                return -ERANGE;
 827
 828        /*
 829         * The strange out-of-order free bytes definition is a (possibly
 830         * unneeded) attempt to retain compatibility.  It used to read:
 831         *      .oobfree = { {8, 8} }
 832         * Since that leaves two bytes unusable, it was changed.  But the
 833         * following scheme might affect existing jffs2 installs by moving the
 834         * cleanmarker:
 835         *      .oobfree = { {6, 10} }
 836         * jffs2 seems to handle the above gracefully, but the current scheme
 837         * seems safer. The only problem with it is that any code retrieving
 838         * free bytes position must be able to handle out-of-order segments.
 839         */
 840        if (!section) {
 841                oobregion->offset = 8;
 842                oobregion->length = 8;
 843        } else {
 844                oobregion->offset = 6;
 845                oobregion->length = 2;
 846        }
 847
 848        return 0;
 849}
 850
 851static const struct mtd_ooblayout_ops doc200x_ooblayout_ops = {
 852        .ecc = doc200x_ooblayout_ecc,
 853        .free = doc200x_ooblayout_free,
 854};
 855
 856/* Find the (I)NFTL Media Header, and optionally also the mirror media header.
 857   On successful return, buf will contain a copy of the media header for
 858   further processing.  id is the string to scan for, and will presumably be
 859   either "ANAND" or "BNAND".  If findmirror=1, also look for the mirror media
 860   header.  The page #s of the found media headers are placed in mh0_page and
 861   mh1_page in the DOC private structure. */
 862static int __init find_media_headers(struct mtd_info *mtd, u_char *buf, const char *id, int findmirror)
 863{
 864        struct nand_chip *this = mtd_to_nand(mtd);
 865        struct doc_priv *doc = nand_get_controller_data(this);
 866        unsigned offs;
 867        int ret;
 868        size_t retlen;
 869
 870        for (offs = 0; offs < mtd->size; offs += mtd->erasesize) {
 871                ret = mtd_read(mtd, offs, mtd->writesize, &retlen, buf);
 872                if (retlen != mtd->writesize)
 873                        continue;
 874                if (ret) {
 875                        pr_warn("ECC error scanning DOC at 0x%x\n", offs);
 876                }
 877                if (memcmp(buf, id, 6))
 878                        continue;
 879                pr_info("Found DiskOnChip %s Media Header at 0x%x\n", id, offs);
 880                if (doc->mh0_page == -1) {
 881                        doc->mh0_page = offs >> this->page_shift;
 882                        if (!findmirror)
 883                                return 1;
 884                        continue;
 885                }
 886                doc->mh1_page = offs >> this->page_shift;
 887                return 2;
 888        }
 889        if (doc->mh0_page == -1) {
 890                pr_warn("DiskOnChip %s Media Header not found.\n", id);
 891                return 0;
 892        }
 893        /* Only one mediaheader was found.  We want buf to contain a
 894           mediaheader on return, so we'll have to re-read the one we found. */
 895        offs = doc->mh0_page << this->page_shift;
 896        ret = mtd_read(mtd, offs, mtd->writesize, &retlen, buf);
 897        if (retlen != mtd->writesize) {
 898                /* Insanity.  Give up. */
 899                pr_err("Read DiskOnChip Media Header once, but can't reread it???\n");
 900                return 0;
 901        }
 902        return 1;
 903}
 904
 905static inline int __init nftl_partscan(struct mtd_info *mtd, struct mtd_partition *parts)
 906{
 907        struct nand_chip *this = mtd_to_nand(mtd);
 908        struct doc_priv *doc = nand_get_controller_data(this);
 909        struct nand_memory_organization *memorg;
 910        int ret = 0;
 911        u_char *buf;
 912        struct NFTLMediaHeader *mh;
 913        const unsigned psize = 1 << this->page_shift;
 914        int numparts = 0;
 915        unsigned blocks, maxblocks;
 916        int offs, numheaders;
 917
 918        memorg = nanddev_get_memorg(&this->base);
 919
 920        buf = kmalloc(mtd->writesize, GFP_KERNEL);
 921        if (!buf) {
 922                return 0;
 923        }
 924        if (!(numheaders = find_media_headers(mtd, buf, "ANAND", 1)))
 925                goto out;
 926        mh = (struct NFTLMediaHeader *)buf;
 927
 928        le16_to_cpus(&mh->NumEraseUnits);
 929        le16_to_cpus(&mh->FirstPhysicalEUN);
 930        le32_to_cpus(&mh->FormattedSize);
 931
 932        pr_info("    DataOrgID        = %s\n"
 933                "    NumEraseUnits    = %d\n"
 934                "    FirstPhysicalEUN = %d\n"
 935                "    FormattedSize    = %d\n"
 936                "    UnitSizeFactor   = %d\n",
 937                mh->DataOrgID, mh->NumEraseUnits,
 938                mh->FirstPhysicalEUN, mh->FormattedSize,
 939                mh->UnitSizeFactor);
 940
 941        blocks = mtd->size >> this->phys_erase_shift;
 942        maxblocks = min(32768U, mtd->erasesize - psize);
 943
 944        if (mh->UnitSizeFactor == 0x00) {
 945                /* Auto-determine UnitSizeFactor.  The constraints are:
 946                   - There can be at most 32768 virtual blocks.
 947                   - There can be at most (virtual block size - page size)
 948                   virtual blocks (because MediaHeader+BBT must fit in 1).
 949                 */
 950                mh->UnitSizeFactor = 0xff;
 951                while (blocks > maxblocks) {
 952                        blocks >>= 1;
 953                        maxblocks = min(32768U, (maxblocks << 1) + psize);
 954                        mh->UnitSizeFactor--;
 955                }
 956                pr_warn("UnitSizeFactor=0x00 detected.  Correct value is assumed to be 0x%02x.\n", mh->UnitSizeFactor);
 957        }
 958
 959        /* NOTE: The lines below modify internal variables of the NAND and MTD
 960           layers; variables with have already been configured by nand_scan.
 961           Unfortunately, we didn't know before this point what these values
 962           should be.  Thus, this code is somewhat dependent on the exact
 963           implementation of the NAND layer.  */
 964        if (mh->UnitSizeFactor != 0xff) {
 965                this->bbt_erase_shift += (0xff - mh->UnitSizeFactor);
 966                memorg->pages_per_eraseblock <<= (0xff - mh->UnitSizeFactor);
 967                mtd->erasesize <<= (0xff - mh->UnitSizeFactor);
 968                pr_info("Setting virtual erase size to %d\n", mtd->erasesize);
 969                blocks = mtd->size >> this->bbt_erase_shift;
 970                maxblocks = min(32768U, mtd->erasesize - psize);
 971        }
 972
 973        if (blocks > maxblocks) {
 974                pr_err("UnitSizeFactor of 0x%02x is inconsistent with device size.  Aborting.\n", mh->UnitSizeFactor);
 975                goto out;
 976        }
 977
 978        /* Skip past the media headers. */
 979        offs = max(doc->mh0_page, doc->mh1_page);
 980        offs <<= this->page_shift;
 981        offs += mtd->erasesize;
 982
 983        if (show_firmware_partition == 1) {
 984                parts[0].name = " DiskOnChip Firmware / Media Header partition";
 985                parts[0].offset = 0;
 986                parts[0].size = offs;
 987                numparts = 1;
 988        }
 989
 990        parts[numparts].name = " DiskOnChip BDTL partition";
 991        parts[numparts].offset = offs;
 992        parts[numparts].size = (mh->NumEraseUnits - numheaders) << this->bbt_erase_shift;
 993
 994        offs += parts[numparts].size;
 995        numparts++;
 996
 997        if (offs < mtd->size) {
 998                parts[numparts].name = " DiskOnChip Remainder partition";
 999                parts[numparts].offset = offs;
1000                parts[numparts].size = mtd->size - offs;
1001                numparts++;
1002        }
1003
1004        ret = numparts;
1005 out:
1006        kfree(buf);
1007        return ret;
1008}
1009
1010/* This is a stripped-down copy of the code in inftlmount.c */
1011static inline int __init inftl_partscan(struct mtd_info *mtd, struct mtd_partition *parts)
1012{
1013        struct nand_chip *this = mtd_to_nand(mtd);
1014        struct doc_priv *doc = nand_get_controller_data(this);
1015        int ret = 0;
1016        u_char *buf;
1017        struct INFTLMediaHeader *mh;
1018        struct INFTLPartition *ip;
1019        int numparts = 0;
1020        int blocks;
1021        int vshift, lastvunit = 0;
1022        int i;
1023        int end = mtd->size;
1024
1025        if (inftl_bbt_write)
1026                end -= (INFTL_BBT_RESERVED_BLOCKS << this->phys_erase_shift);
1027
1028        buf = kmalloc(mtd->writesize, GFP_KERNEL);
1029        if (!buf) {
1030                return 0;
1031        }
1032
1033        if (!find_media_headers(mtd, buf, "BNAND", 0))
1034                goto out;
1035        doc->mh1_page = doc->mh0_page + (4096 >> this->page_shift);
1036        mh = (struct INFTLMediaHeader *)buf;
1037
1038        le32_to_cpus(&mh->NoOfBootImageBlocks);
1039        le32_to_cpus(&mh->NoOfBinaryPartitions);
1040        le32_to_cpus(&mh->NoOfBDTLPartitions);
1041        le32_to_cpus(&mh->BlockMultiplierBits);
1042        le32_to_cpus(&mh->FormatFlags);
1043        le32_to_cpus(&mh->PercentUsed);
1044
1045        pr_info("    bootRecordID          = %s\n"
1046                "    NoOfBootImageBlocks   = %d\n"
1047                "    NoOfBinaryPartitions  = %d\n"
1048                "    NoOfBDTLPartitions    = %d\n"
1049                "    BlockMultiplierBits   = %d\n"
1050                "    FormatFlgs            = %d\n"
1051                "    OsakVersion           = %d.%d.%d.%d\n"
1052                "    PercentUsed           = %d\n",
1053                mh->bootRecordID, mh->NoOfBootImageBlocks,
1054                mh->NoOfBinaryPartitions,
1055                mh->NoOfBDTLPartitions,
1056                mh->BlockMultiplierBits, mh->FormatFlags,
1057                ((unsigned char *) &mh->OsakVersion)[0] & 0xf,
1058                ((unsigned char *) &mh->OsakVersion)[1] & 0xf,
1059                ((unsigned char *) &mh->OsakVersion)[2] & 0xf,
1060                ((unsigned char *) &mh->OsakVersion)[3] & 0xf,
1061                mh->PercentUsed);
1062
1063        vshift = this->phys_erase_shift + mh->BlockMultiplierBits;
1064
1065        blocks = mtd->size >> vshift;
1066        if (blocks > 32768) {
1067                pr_err("BlockMultiplierBits=%d is inconsistent with device size.  Aborting.\n", mh->BlockMultiplierBits);
1068                goto out;
1069        }
1070
1071        blocks = doc->chips_per_floor << (this->chip_shift - this->phys_erase_shift);
1072        if (inftl_bbt_write && (blocks > mtd->erasesize)) {
1073                pr_err("Writeable BBTs spanning more than one erase block are not yet supported.  FIX ME!\n");
1074                goto out;
1075        }
1076
1077        /* Scan the partitions */
1078        for (i = 0; (i < 4); i++) {
1079                ip = &(mh->Partitions[i]);
1080                le32_to_cpus(&ip->virtualUnits);
1081                le32_to_cpus(&ip->firstUnit);
1082                le32_to_cpus(&ip->lastUnit);
1083                le32_to_cpus(&ip->flags);
1084                le32_to_cpus(&ip->spareUnits);
1085                le32_to_cpus(&ip->Reserved0);
1086
1087                pr_info("    PARTITION[%d] ->\n"
1088                        "        virtualUnits    = %d\n"
1089                        "        firstUnit       = %d\n"
1090                        "        lastUnit        = %d\n"
1091                        "        flags           = 0x%x\n"
1092                        "        spareUnits      = %d\n",
1093                        i, ip->virtualUnits, ip->firstUnit,
1094                        ip->lastUnit, ip->flags,
1095                        ip->spareUnits);
1096
1097                if ((show_firmware_partition == 1) &&
1098                    (i == 0) && (ip->firstUnit > 0)) {
1099                        parts[0].name = " DiskOnChip IPL / Media Header partition";
1100                        parts[0].offset = 0;
1101                        parts[0].size = mtd->erasesize * ip->firstUnit;
1102                        numparts = 1;
1103                }
1104
1105                if (ip->flags & INFTL_BINARY)
1106                        parts[numparts].name = " DiskOnChip BDK partition";
1107                else
1108                        parts[numparts].name = " DiskOnChip BDTL partition";
1109                parts[numparts].offset = ip->firstUnit << vshift;
1110                parts[numparts].size = (1 + ip->lastUnit - ip->firstUnit) << vshift;
1111                numparts++;
1112                if (ip->lastUnit > lastvunit)
1113                        lastvunit = ip->lastUnit;
1114                if (ip->flags & INFTL_LAST)
1115                        break;
1116        }
1117        lastvunit++;
1118        if ((lastvunit << vshift) < end) {
1119                parts[numparts].name = " DiskOnChip Remainder partition";
1120                parts[numparts].offset = lastvunit << vshift;
1121                parts[numparts].size = end - parts[numparts].offset;
1122                numparts++;
1123        }
1124        ret = numparts;
1125 out:
1126        kfree(buf);
1127        return ret;
1128}
1129
1130static int __init nftl_scan_bbt(struct mtd_info *mtd)
1131{
1132        int ret, numparts;
1133        struct nand_chip *this = mtd_to_nand(mtd);
1134        struct doc_priv *doc = nand_get_controller_data(this);
1135        struct mtd_partition parts[2];
1136
1137        memset((char *)parts, 0, sizeof(parts));
1138        /* On NFTL, we have to find the media headers before we can read the
1139           BBTs, since they're stored in the media header eraseblocks. */
1140        numparts = nftl_partscan(mtd, parts);
1141        if (!numparts)
1142                return -EIO;
1143        this->bbt_td->options = NAND_BBT_ABSPAGE | NAND_BBT_8BIT |
1144                                NAND_BBT_SAVECONTENT | NAND_BBT_WRITE |
1145                                NAND_BBT_VERSION;
1146        this->bbt_td->veroffs = 7;
1147        this->bbt_td->pages[0] = doc->mh0_page + 1;
1148        if (doc->mh1_page != -1) {
1149                this->bbt_md->options = NAND_BBT_ABSPAGE | NAND_BBT_8BIT |
1150                                        NAND_BBT_SAVECONTENT | NAND_BBT_WRITE |
1151                                        NAND_BBT_VERSION;
1152                this->bbt_md->veroffs = 7;
1153                this->bbt_md->pages[0] = doc->mh1_page + 1;
1154        } else {
1155                this->bbt_md = NULL;
1156        }
1157
1158        ret = nand_create_bbt(this);
1159        if (ret)
1160                return ret;
1161
1162        return mtd_device_register(mtd, parts, no_autopart ? 0 : numparts);
1163}
1164
1165static int __init inftl_scan_bbt(struct mtd_info *mtd)
1166{
1167        int ret, numparts;
1168        struct nand_chip *this = mtd_to_nand(mtd);
1169        struct doc_priv *doc = nand_get_controller_data(this);
1170        struct mtd_partition parts[5];
1171
1172        if (nanddev_ntargets(&this->base) > doc->chips_per_floor) {
1173                pr_err("Multi-floor INFTL devices not yet supported.\n");
1174                return -EIO;
1175        }
1176
1177        if (DoC_is_MillenniumPlus(doc)) {
1178                this->bbt_td->options = NAND_BBT_2BIT | NAND_BBT_ABSPAGE;
1179                if (inftl_bbt_write)
1180                        this->bbt_td->options |= NAND_BBT_WRITE;
1181                this->bbt_td->pages[0] = 2;
1182                this->bbt_md = NULL;
1183        } else {
1184                this->bbt_td->options = NAND_BBT_LASTBLOCK | NAND_BBT_8BIT | NAND_BBT_VERSION;
1185                if (inftl_bbt_write)
1186                        this->bbt_td->options |= NAND_BBT_WRITE;
1187                this->bbt_td->offs = 8;
1188                this->bbt_td->len = 8;
1189                this->bbt_td->veroffs = 7;
1190                this->bbt_td->maxblocks = INFTL_BBT_RESERVED_BLOCKS;
1191                this->bbt_td->reserved_block_code = 0x01;
1192                this->bbt_td->pattern = "MSYS_BBT";
1193
1194                this->bbt_md->options = NAND_BBT_LASTBLOCK | NAND_BBT_8BIT | NAND_BBT_VERSION;
1195                if (inftl_bbt_write)
1196                        this->bbt_md->options |= NAND_BBT_WRITE;
1197                this->bbt_md->offs = 8;
1198                this->bbt_md->len = 8;
1199                this->bbt_md->veroffs = 7;
1200                this->bbt_md->maxblocks = INFTL_BBT_RESERVED_BLOCKS;
1201                this->bbt_md->reserved_block_code = 0x01;
1202                this->bbt_md->pattern = "TBB_SYSM";
1203        }
1204
1205        ret = nand_create_bbt(this);
1206        if (ret)
1207                return ret;
1208
1209        memset((char *)parts, 0, sizeof(parts));
1210        numparts = inftl_partscan(mtd, parts);
1211        /* At least for now, require the INFTL Media Header.  We could probably
1212           do without it for non-INFTL use, since all it gives us is
1213           autopartitioning, but I want to give it more thought. */
1214        if (!numparts)
1215                return -EIO;
1216        return mtd_device_register(mtd, parts, no_autopart ? 0 : numparts);
1217}
1218
1219static inline int __init doc2000_init(struct mtd_info *mtd)
1220{
1221        struct nand_chip *this = mtd_to_nand(mtd);
1222        struct doc_priv *doc = nand_get_controller_data(this);
1223
1224        doc->late_init = nftl_scan_bbt;
1225
1226        doc->CDSNControl = CDSN_CTRL_FLASH_IO | CDSN_CTRL_ECC_IO;
1227        doc2000_count_chips(mtd);
1228        mtd->name = "DiskOnChip 2000 (NFTL Model)";
1229        return (4 * doc->chips_per_floor);
1230}
1231
1232static inline int __init doc2001_init(struct mtd_info *mtd)
1233{
1234        struct nand_chip *this = mtd_to_nand(mtd);
1235        struct doc_priv *doc = nand_get_controller_data(this);
1236
1237        ReadDOC(doc->virtadr, ChipID);
1238        ReadDOC(doc->virtadr, ChipID);
1239        ReadDOC(doc->virtadr, ChipID);
1240        if (ReadDOC(doc->virtadr, ChipID) != DOC_ChipID_DocMil) {
1241                /* It's not a Millennium; it's one of the newer
1242                   DiskOnChip 2000 units with a similar ASIC.
1243                   Treat it like a Millennium, except that it
1244                   can have multiple chips. */
1245                doc2000_count_chips(mtd);
1246                mtd->name = "DiskOnChip 2000 (INFTL Model)";
1247                doc->late_init = inftl_scan_bbt;
1248                return (4 * doc->chips_per_floor);
1249        } else {
1250                /* Bog-standard Millennium */
1251                doc->chips_per_floor = 1;
1252                mtd->name = "DiskOnChip Millennium";
1253                doc->late_init = nftl_scan_bbt;
1254                return 1;
1255        }
1256}
1257
1258static inline int __init doc2001plus_init(struct mtd_info *mtd)
1259{
1260        struct nand_chip *this = mtd_to_nand(mtd);
1261        struct doc_priv *doc = nand_get_controller_data(this);
1262
1263        doc->late_init = inftl_scan_bbt;
1264        this->ecc.hwctl = doc2001plus_enable_hwecc;
1265
1266        doc->chips_per_floor = 1;
1267        mtd->name = "DiskOnChip Millennium Plus";
1268
1269        return 1;
1270}
1271
1272static int doc200x_attach_chip(struct nand_chip *chip)
1273{
1274        if (chip->ecc.engine_type != NAND_ECC_ENGINE_TYPE_ON_HOST)
1275                return 0;
1276
1277        chip->ecc.placement = NAND_ECC_PLACEMENT_INTERLEAVED;
1278        chip->ecc.size = 512;
1279        chip->ecc.bytes = 6;
1280        chip->ecc.strength = 2;
1281        chip->ecc.options = NAND_ECC_GENERIC_ERASED_CHECK;
1282        chip->ecc.hwctl = doc200x_enable_hwecc;
1283        chip->ecc.calculate = doc200x_calculate_ecc;
1284        chip->ecc.correct = doc200x_correct_data;
1285
1286        return 0;
1287}
1288
1289static const struct nand_controller_ops doc200x_ops = {
1290        .exec_op = doc200x_exec_op,
1291        .attach_chip = doc200x_attach_chip,
1292};
1293
1294static const struct nand_controller_ops doc2001plus_ops = {
1295        .exec_op = doc2001plus_exec_op,
1296        .attach_chip = doc200x_attach_chip,
1297};
1298
1299static int __init doc_probe(unsigned long physadr)
1300{
1301        struct nand_chip *nand = NULL;
1302        struct doc_priv *doc = NULL;
1303        unsigned char ChipID;
1304        struct mtd_info *mtd;
1305        void __iomem *virtadr;
1306        unsigned char save_control;
1307        unsigned char tmp, tmpb, tmpc;
1308        int reg, len, numchips;
1309        int ret = 0;
1310
1311        if (!request_mem_region(physadr, DOC_IOREMAP_LEN, "DiskOnChip"))
1312                return -EBUSY;
1313        virtadr = ioremap(physadr, DOC_IOREMAP_LEN);
1314        if (!virtadr) {
1315                pr_err("Diskonchip ioremap failed: 0x%x bytes at 0x%lx\n",
1316                       DOC_IOREMAP_LEN, physadr);
1317                ret = -EIO;
1318                goto error_ioremap;
1319        }
1320
1321        /* It's not possible to cleanly detect the DiskOnChip - the
1322         * bootup procedure will put the device into reset mode, and
1323         * it's not possible to talk to it without actually writing
1324         * to the DOCControl register. So we store the current contents
1325         * of the DOCControl register's location, in case we later decide
1326         * that it's not a DiskOnChip, and want to put it back how we
1327         * found it.
1328         */
1329        save_control = ReadDOC(virtadr, DOCControl);
1330
1331        /* Reset the DiskOnChip ASIC */
1332        WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET, virtadr, DOCControl);
1333        WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET, virtadr, DOCControl);
1334
1335        /* Enable the DiskOnChip ASIC */
1336        WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL, virtadr, DOCControl);
1337        WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL, virtadr, DOCControl);
1338
1339        ChipID = ReadDOC(virtadr, ChipID);
1340
1341        switch (ChipID) {
1342        case DOC_ChipID_Doc2k:
1343                reg = DoC_2k_ECCStatus;
1344                break;
1345        case DOC_ChipID_DocMil:
1346                reg = DoC_ECCConf;
1347                break;
1348        case DOC_ChipID_DocMilPlus16:
1349        case DOC_ChipID_DocMilPlus32:
1350        case 0:
1351                /* Possible Millennium Plus, need to do more checks */
1352                /* Possibly release from power down mode */
1353                for (tmp = 0; (tmp < 4); tmp++)
1354                        ReadDOC(virtadr, Mplus_Power);
1355
1356                /* Reset the Millennium Plus ASIC */
1357                tmp = DOC_MODE_RESET | DOC_MODE_MDWREN | DOC_MODE_RST_LAT | DOC_MODE_BDECT;
1358                WriteDOC(tmp, virtadr, Mplus_DOCControl);
1359                WriteDOC(~tmp, virtadr, Mplus_CtrlConfirm);
1360
1361                usleep_range(1000, 2000);
1362                /* Enable the Millennium Plus ASIC */
1363                tmp = DOC_MODE_NORMAL | DOC_MODE_MDWREN | DOC_MODE_RST_LAT | DOC_MODE_BDECT;
1364                WriteDOC(tmp, virtadr, Mplus_DOCControl);
1365                WriteDOC(~tmp, virtadr, Mplus_CtrlConfirm);
1366                usleep_range(1000, 2000);
1367
1368                ChipID = ReadDOC(virtadr, ChipID);
1369
1370                switch (ChipID) {
1371                case DOC_ChipID_DocMilPlus16:
1372                        reg = DoC_Mplus_Toggle;
1373                        break;
1374                case DOC_ChipID_DocMilPlus32:
1375                        pr_err("DiskOnChip Millennium Plus 32MB is not supported, ignoring.\n");
1376                        fallthrough;
1377                default:
1378                        ret = -ENODEV;
1379                        goto notfound;
1380                }
1381                break;
1382
1383        default:
1384                ret = -ENODEV;
1385                goto notfound;
1386        }
1387        /* Check the TOGGLE bit in the ECC register */
1388        tmp = ReadDOC_(virtadr, reg) & DOC_TOGGLE_BIT;
1389        tmpb = ReadDOC_(virtadr, reg) & DOC_TOGGLE_BIT;
1390        tmpc = ReadDOC_(virtadr, reg) & DOC_TOGGLE_BIT;
1391        if ((tmp == tmpb) || (tmp != tmpc)) {
1392                pr_warn("Possible DiskOnChip at 0x%lx failed TOGGLE test, dropping.\n", physadr);
1393                ret = -ENODEV;
1394                goto notfound;
1395        }
1396
1397        for (mtd = doclist; mtd; mtd = doc->nextdoc) {
1398                unsigned char oldval;
1399                unsigned char newval;
1400                nand = mtd_to_nand(mtd);
1401                doc = nand_get_controller_data(nand);
1402                /* Use the alias resolution register to determine if this is
1403                   in fact the same DOC aliased to a new address.  If writes
1404                   to one chip's alias resolution register change the value on
1405                   the other chip, they're the same chip. */
1406                if (ChipID == DOC_ChipID_DocMilPlus16) {
1407                        oldval = ReadDOC(doc->virtadr, Mplus_AliasResolution);
1408                        newval = ReadDOC(virtadr, Mplus_AliasResolution);
1409                } else {
1410                        oldval = ReadDOC(doc->virtadr, AliasResolution);
1411                        newval = ReadDOC(virtadr, AliasResolution);
1412                }
1413                if (oldval != newval)
1414                        continue;
1415                if (ChipID == DOC_ChipID_DocMilPlus16) {
1416                        WriteDOC(~newval, virtadr, Mplus_AliasResolution);
1417                        oldval = ReadDOC(doc->virtadr, Mplus_AliasResolution);
1418                        WriteDOC(newval, virtadr, Mplus_AliasResolution);       // restore it
1419                } else {
1420                        WriteDOC(~newval, virtadr, AliasResolution);
1421                        oldval = ReadDOC(doc->virtadr, AliasResolution);
1422                        WriteDOC(newval, virtadr, AliasResolution);     // restore it
1423                }
1424                newval = ~newval;
1425                if (oldval == newval) {
1426                        pr_debug("Found alias of DOC at 0x%lx to 0x%lx\n",
1427                                 doc->physadr, physadr);
1428                        goto notfound;
1429                }
1430        }
1431
1432        pr_notice("DiskOnChip found at 0x%lx\n", physadr);
1433
1434        len = sizeof(struct nand_chip) + sizeof(struct doc_priv) +
1435              (2 * sizeof(struct nand_bbt_descr));
1436        nand = kzalloc(len, GFP_KERNEL);
1437        if (!nand) {
1438                ret = -ENOMEM;
1439                goto fail;
1440        }
1441
1442        /*
1443         * Allocate a RS codec instance
1444         *
1445         * Symbolsize is 10 (bits)
1446         * Primitve polynomial is x^10+x^3+1
1447         * First consecutive root is 510
1448         * Primitve element to generate roots = 1
1449         * Generator polinomial degree = 4
1450         */
1451        doc = (struct doc_priv *) (nand + 1);
1452        doc->rs_decoder = init_rs(10, 0x409, FCR, 1, NROOTS);
1453        if (!doc->rs_decoder) {
1454                pr_err("DiskOnChip: Could not create a RS codec\n");
1455                ret = -ENOMEM;
1456                goto fail;
1457        }
1458
1459        nand_controller_init(&doc->base);
1460        if (ChipID == DOC_ChipID_DocMilPlus16)
1461                doc->base.ops = &doc2001plus_ops;
1462        else
1463                doc->base.ops = &doc200x_ops;
1464
1465        mtd                     = nand_to_mtd(nand);
1466        nand->bbt_td            = (struct nand_bbt_descr *) (doc + 1);
1467        nand->bbt_md            = nand->bbt_td + 1;
1468
1469        mtd->owner              = THIS_MODULE;
1470        mtd_set_ooblayout(mtd, &doc200x_ooblayout_ops);
1471
1472        nand->controller        = &doc->base;
1473        nand_set_controller_data(nand, doc);
1474        nand->bbt_options       = NAND_BBT_USE_FLASH;
1475        /* Skip the automatic BBT scan so we can run it manually */
1476        nand->options           |= NAND_SKIP_BBTSCAN | NAND_NO_BBM_QUIRK;
1477
1478        doc->physadr            = physadr;
1479        doc->virtadr            = virtadr;
1480        doc->ChipID             = ChipID;
1481        doc->curfloor           = -1;
1482        doc->curchip            = -1;
1483        doc->mh0_page           = -1;
1484        doc->mh1_page           = -1;
1485        doc->nextdoc            = doclist;
1486
1487        if (ChipID == DOC_ChipID_Doc2k)
1488                numchips = doc2000_init(mtd);
1489        else if (ChipID == DOC_ChipID_DocMilPlus16)
1490                numchips = doc2001plus_init(mtd);
1491        else
1492                numchips = doc2001_init(mtd);
1493
1494        if ((ret = nand_scan(nand, numchips)) || (ret = doc->late_init(mtd))) {
1495                /* DBB note: i believe nand_cleanup is necessary here, as
1496                   buffers may have been allocated in nand_base.  Check with
1497                   Thomas. FIX ME! */
1498                nand_cleanup(nand);
1499                goto fail;
1500        }
1501
1502        /* Success! */
1503        doclist = mtd;
1504        return 0;
1505
1506 notfound:
1507        /* Put back the contents of the DOCControl register, in case it's not
1508           actually a DiskOnChip.  */
1509        WriteDOC(save_control, virtadr, DOCControl);
1510 fail:
1511        if (doc)
1512                free_rs(doc->rs_decoder);
1513        kfree(nand);
1514        iounmap(virtadr);
1515
1516error_ioremap:
1517        release_mem_region(physadr, DOC_IOREMAP_LEN);
1518
1519        return ret;
1520}
1521
1522static void release_nanddoc(void)
1523{
1524        struct mtd_info *mtd, *nextmtd;
1525        struct nand_chip *nand;
1526        struct doc_priv *doc;
1527        int ret;
1528
1529        for (mtd = doclist; mtd; mtd = nextmtd) {
1530                nand = mtd_to_nand(mtd);
1531                doc = nand_get_controller_data(nand);
1532
1533                nextmtd = doc->nextdoc;
1534                ret = mtd_device_unregister(mtd);
1535                WARN_ON(ret);
1536                nand_cleanup(nand);
1537                iounmap(doc->virtadr);
1538                release_mem_region(doc->physadr, DOC_IOREMAP_LEN);
1539                free_rs(doc->rs_decoder);
1540                kfree(nand);
1541        }
1542}
1543
1544static int __init init_nanddoc(void)
1545{
1546        int i, ret = 0;
1547
1548        if (doc_config_location) {
1549                pr_info("Using configured DiskOnChip probe address 0x%lx\n",
1550                        doc_config_location);
1551                ret = doc_probe(doc_config_location);
1552                if (ret < 0)
1553                        return ret;
1554        } else {
1555                for (i = 0; (doc_locations[i] != 0xffffffff); i++) {
1556                        doc_probe(doc_locations[i]);
1557                }
1558        }
1559        /* No banner message any more. Print a message if no DiskOnChip
1560           found, so the user knows we at least tried. */
1561        if (!doclist) {
1562                pr_info("No valid DiskOnChip devices found\n");
1563                ret = -ENODEV;
1564        }
1565        return ret;
1566}
1567
1568static void __exit cleanup_nanddoc(void)
1569{
1570        /* Cleanup the nand/DoC resources */
1571        release_nanddoc();
1572}
1573
1574module_init(init_nanddoc);
1575module_exit(cleanup_nanddoc);
1576
1577MODULE_LICENSE("GPL");
1578MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
1579MODULE_DESCRIPTION("M-Systems DiskOnChip 2000, Millennium and Millennium Plus device driver");
1580