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