drivers/mtd/onenand/onenand_base.c

   1 /*
   2  *  linux/drivers/mtd/onenand/onenand_base.c
   3  *
   4  *  Copyright © 2005-2009 Samsung Electronics
   5  *  Copyright © 2007 Nokia Corporation
   6  *
   7  *  Kyungmin Park <kyungmin.park@samsung.com>
   8  *
   9  *  Credits:
  10  *      Adrian Hunter <ext-adrian.hunter@nokia.com>:
  11  *      auto-placement support, read-while load support, various fixes
  12  *
  13  *      Vishak G <vishak.g at samsung.com>, Rohit Hagargundgi <h.rohit at samsung.com>
  14  *      Flex-OneNAND support
  15  *      Amul Kumar Saha <amul.saha at samsung.com>
  16  *      OTP support
  17  *
  18  * This program is free software; you can redistribute it and/or modify
  19  * it under the terms of the GNU General Public License version 2 as
  20  * published by the Free Software Foundation.
  21  */
  22
  23 #include <linux/kernel.h>
  24 #include <linux/module.h>
  25 #include <linux/moduleparam.h>
  26 #include <linux/slab.h>
  27 #include <linux/init.h>
  28 #include <linux/sched.h>
  29 #include <linux/delay.h>
  30 #include <linux/interrupt.h>
  31 #include <linux/jiffies.h>
  32 #include <linux/mtd/mtd.h>
  33 #include <linux/mtd/onenand.h>
  34 #include <linux/mtd/partitions.h>
  35
  36 #include <asm/io.h>
  37
  38 /*
  39  * Multiblock erase if number of blocks to erase is 2 or more.
  40  * Maximum number of blocks for simultaneous erase is 64.
  41  */
  42 #define MB_ERASE_MIN_BLK_COUNT 2
  43 #define MB_ERASE_MAX_BLK_COUNT 64
  44
  45 /* Default Flex-OneNAND boundary and lock respectively */
  46 static int flex_bdry[MAX_DIES * 2] = { -1, 0, -1, 0 };
  47
  48 module_param_array(flex_bdry, int, NULL, 0400);
  49 MODULE_PARM_DESC(flex_bdry,     "SLC Boundary information for Flex-OneNAND"
  50                                 "Syntax:flex_bdry=DIE_BDRY,LOCK,..."
  51                                 "DIE_BDRY: SLC boundary of the die"
  52                                 "LOCK: Locking information for SLC boundary"
  53                                 "    : 0->Set boundary in unlocked status"
  54                                 "    : 1->Set boundary in locked status");
  55
  56 /* Default OneNAND/Flex-OneNAND OTP options*/
  57 static int otp;
  58
  59 module_param(otp, int, 0400);
  60 MODULE_PARM_DESC(otp,   "Corresponding behaviour of OneNAND in OTP"
  61                         "Syntax : otp=LOCK_TYPE"
  62                         "LOCK_TYPE : Keys issued, for specific OTP Lock type"
  63                         "          : 0 -> Default (No Blocks Locked)"
  64                         "          : 1 -> OTP Block lock"
  65                         "          : 2 -> 1st Block lock"
  66                         "          : 3 -> BOTH OTP Block and 1st Block lock");
  67
  68 /*
  69  * flexonenand_oob_128 - oob info for Flex-Onenand with 4KB page
  70  * For now, we expose only 64 out of 80 ecc bytes
  71  */
  72 static struct nand_ecclayout flexonenand_oob_128 = {
  73         .eccbytes       = 64,
  74         .eccpos         = {
  75                 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
  76                 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
  77                 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
  78                 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
  79                 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
  80                 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
  81                 102, 103, 104, 105
  82                 },
  83         .oobfree        = {
  84                 {2, 4}, {18, 4}, {34, 4}, {50, 4},
  85                 {66, 4}, {82, 4}, {98, 4}, {114, 4}
  86         }
  87 };
  88
  89 /*
  90  * onenand_oob_128 - oob info for OneNAND with 4KB page
  91  *
  92  * Based on specification:
  93  * 4Gb M-die OneNAND Flash (KFM4G16Q4M, KFN8G16Q4M). Rev. 1.3, Apr. 2010
  94  *
  95  * For eccpos we expose only 64 bytes out of 72 (see struct nand_ecclayout)
  96  *
  97  * oobfree uses the spare area fields marked as
  98  * "Managed by internal ECC logic for Logical Sector Number area"
  99  */
 100 static struct nand_ecclayout onenand_oob_128 = {
 101         .eccbytes       = 64,
 102         .eccpos         = {
 103                 7, 8, 9, 10, 11, 12, 13, 14, 15,
 104                 23, 24, 25, 26, 27, 28, 29, 30, 31,
 105                 39, 40, 41, 42, 43, 44, 45, 46, 47,
 106                 55, 56, 57, 58, 59, 60, 61, 62, 63,
 107                 71, 72, 73, 74, 75, 76, 77, 78, 79,
 108                 87, 88, 89, 90, 91, 92, 93, 94, 95,
 109                 103, 104, 105, 106, 107, 108, 109, 110, 111,
 110                 119
 111         },
 112         .oobfree        = {
 113                 {2, 3}, {18, 3}, {34, 3}, {50, 3},
 114                 {66, 3}, {82, 3}, {98, 3}, {114, 3}
 115         }
 116 };
 117
 118 /**
 119  * onenand_oob_64 - oob info for large (2KB) page
 120  */
 121 static struct nand_ecclayout onenand_oob_64 = {
 122         .eccbytes       = 20,
 123         .eccpos         = {
 124                 8, 9, 10, 11, 12,
 125                 24, 25, 26, 27, 28,
 126                 40, 41, 42, 43, 44,
 127                 56, 57, 58, 59, 60,
 128                 },
 129         .oobfree        = {
 130                 {2, 3}, {14, 2}, {18, 3}, {30, 2},
 131                 {34, 3}, {46, 2}, {50, 3}, {62, 2}
 132         }
 133 };
 134
 135 /**
 136  * onenand_oob_32 - oob info for middle (1KB) page
 137  */
 138 static struct nand_ecclayout onenand_oob_32 = {
 139         .eccbytes       = 10,
 140         .eccpos         = {
 141                 8, 9, 10, 11, 12,
 142                 24, 25, 26, 27, 28,
 143                 },
 144         .oobfree        = { {2, 3}, {14, 2}, {18, 3}, {30, 2} }
 145 };
 146
 147 static const unsigned char ffchars[] = {
 148         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 149         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 16 */
 150         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 151         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 32 */
 152         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 153         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 48 */
 154         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 155         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 64 */
 156         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 157         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 80 */
 158         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 159         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 96 */
 160         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 161         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 112 */
 162         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 163         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 128 */
 164 };
 165
 166 /**
 167  * onenand_readw - [OneNAND Interface] Read OneNAND register
 168  * @param addr          address to read
 169  *
 170  * Read OneNAND register
 171  */
 172 static unsigned short onenand_readw(void __iomem *addr)
 173 {
 174         return readw(addr);
 175 }
 176
 177 /**
 178  * onenand_writew - [OneNAND Interface] Write OneNAND register with value
 179  * @param value         value to write
 180  * @param addr          address to write
 181  *
 182  * Write OneNAND register with value
 183  */
 184 static void onenand_writew(unsigned short value, void __iomem *addr)
 185 {
 186         writew(value, addr);
 187 }
 188
 189 /**
 190  * onenand_block_address - [DEFAULT] Get block address
 191  * @param this          onenand chip data structure
 192  * @param block         the block
 193  * @return              translated block address if DDP, otherwise same
 194  *
 195  * Setup Start Address 1 Register (F100h)
 196  */
 197 static int onenand_block_address(struct onenand_chip *this, int block)
 198 {
 199         /* Device Flash Core select, NAND Flash Block Address */
 200         if (block & this->density_mask)
 201                 return ONENAND_DDP_CHIP1 | (block ^ this->density_mask);
 202
 203         return block;
 204 }
 205
 206 /**
 207  * onenand_bufferram_address - [DEFAULT] Get bufferram address
 208  * @param this          onenand chip data structure
 209  * @param block         the block
 210  * @return              set DBS value if DDP, otherwise 0
 211  *
 212  * Setup Start Address 2 Register (F101h) for DDP
 213  */
 214 static int onenand_bufferram_address(struct onenand_chip *this, int block)
 215 {
 216         /* Device BufferRAM Select */
 217         if (block & this->density_mask)
 218                 return ONENAND_DDP_CHIP1;
 219
 220         return ONENAND_DDP_CHIP0;
 221 }
 222
 223 /**
 224  * onenand_page_address - [DEFAULT] Get page address
 225  * @param page          the page address
 226  * @param sector        the sector address
 227  * @return              combined page and sector address
 228  *
 229  * Setup Start Address 8 Register (F107h)
 230  */
 231 static int onenand_page_address(int page, int sector)
 232 {
 233         /* Flash Page Address, Flash Sector Address */
 234         int fpa, fsa;
 235
 236         fpa = page & ONENAND_FPA_MASK;
 237         fsa = sector & ONENAND_FSA_MASK;
 238
 239         return ((fpa << ONENAND_FPA_SHIFT) | fsa);
 240 }
 241
 242 /**
 243  * onenand_buffer_address - [DEFAULT] Get buffer address
 244  * @param dataram1      DataRAM index
 245  * @param sectors       the sector address
 246  * @param count         the number of sectors
 247  * @return              the start buffer value
 248  *
 249  * Setup Start Buffer Register (F200h)
 250  */
 251 static int onenand_buffer_address(int dataram1, int sectors, int count)
 252 {
 253         int bsa, bsc;
 254
 255         /* BufferRAM Sector Address */
 256         bsa = sectors & ONENAND_BSA_MASK;
 257
 258         if (dataram1)
 259                 bsa |= ONENAND_BSA_DATARAM1;    /* DataRAM1 */
 260         else
 261                 bsa |= ONENAND_BSA_DATARAM0;    /* DataRAM0 */
 262
 263         /* BufferRAM Sector Count */
 264         bsc = count & ONENAND_BSC_MASK;
 265
 266         return ((bsa << ONENAND_BSA_SHIFT) | bsc);
 267 }
 268
 269 /**
 270  * flexonenand_block- For given address return block number
 271  * @param this         - OneNAND device structure
 272  * @param addr          - Address for which block number is needed
 273  */
 274 static unsigned flexonenand_block(struct onenand_chip *this, loff_t addr)
 275 {
 276         unsigned boundary, blk, die = 0;
 277
 278         if (ONENAND_IS_DDP(this) && addr >= this->diesize[0]) {
 279                 die = 1;
 280                 addr -= this->diesize[0];
 281         }
 282
 283         boundary = this->boundary[die];
 284
 285         blk = addr >> (this->erase_shift - 1);
 286         if (blk > boundary)
 287                 blk = (blk + boundary + 1) >> 1;
 288
 289         blk += die ? this->density_mask : 0;
 290         return blk;
 291 }
 292
 293 inline unsigned onenand_block(struct onenand_chip *this, loff_t addr)
 294 {
 295         if (!FLEXONENAND(this))
 296                 return addr >> this->erase_shift;
 297         return flexonenand_block(this, addr);
 298 }
 299
 300 /**
 301  * flexonenand_addr - Return address of the block
 302  * @this:               OneNAND device structure
 303  * @block:              Block number on Flex-OneNAND
 304  *
 305  * Return address of the block
 306  */
 307 static loff_t flexonenand_addr(struct onenand_chip *this, int block)
 308 {
 309         loff_t ofs = 0;
 310         int die = 0, boundary;
 311
 312         if (ONENAND_IS_DDP(this) && block >= this->density_mask) {
 313                 block -= this->density_mask;
 314                 die = 1;
 315                 ofs = this->diesize[0];
 316         }
 317
 318         boundary = this->boundary[die];
 319         ofs += (loff_t)block << (this->erase_shift - 1);
 320         if (block > (boundary + 1))
 321                 ofs += (loff_t)(block - boundary - 1) << (this->erase_shift - 1);
 322         return ofs;
 323 }
 324
 325 loff_t onenand_addr(struct onenand_chip *this, int block)
 326 {
 327         if (!FLEXONENAND(this))
 328                 return (loff_t)block << this->erase_shift;
 329         return flexonenand_addr(this, block);
 330 }
 331 EXPORT_SYMBOL(onenand_addr);
 332
 333 /**
 334  * onenand_get_density - [DEFAULT] Get OneNAND density
 335  * @param dev_id        OneNAND device ID
 336  *
 337  * Get OneNAND density from device ID
 338  */
 339 static inline int onenand_get_density(int dev_id)
 340 {
 341         int density = dev_id >> ONENAND_DEVICE_DENSITY_SHIFT;
 342         return (density & ONENAND_DEVICE_DENSITY_MASK);
 343 }
 344
 345 /**
 346  * flexonenand_region - [Flex-OneNAND] Return erase region of addr
 347  * @param mtd           MTD device structure
 348  * @param addr          address whose erase region needs to be identified
 349  */
 350 int flexonenand_region(struct mtd_info *mtd, loff_t addr)
 351 {
 352         int i;
 353
 354         for (i = 0; i < mtd->numeraseregions; i++)
 355                 if (addr < mtd->eraseregions[i].offset)
 356                         break;
 357         return i - 1;
 358 }
 359 EXPORT_SYMBOL(flexonenand_region);
 360
 361 /**
 362  * onenand_command - [DEFAULT] Send command to OneNAND device
 363  * @param mtd           MTD device structure
 364  * @param cmd           the command to be sent
 365  * @param addr          offset to read from or write to
 366  * @param len           number of bytes to read or write
 367  *
 368  * Send command to OneNAND device. This function is used for middle/large page
 369  * devices (1KB/2KB Bytes per page)
 370  */
 371 static int onenand_command(struct mtd_info *mtd, int cmd, loff_t addr, size_t len)
 372 {
 373         struct onenand_chip *this = mtd->priv;
 374         int value, block, page;
 375
 376         /* Address translation */
 377         switch (cmd) {
 378         case ONENAND_CMD_UNLOCK:
 379         case ONENAND_CMD_LOCK:
 380         case ONENAND_CMD_LOCK_TIGHT:
 381         case ONENAND_CMD_UNLOCK_ALL:
 382                 block = -1;
 383                 page = -1;
 384                 break;
 385
 386         case FLEXONENAND_CMD_PI_ACCESS:
 387                 /* addr contains die index */
 388                 block = addr * this->density_mask;
 389                 page = -1;
 390                 break;
 391
 392         case ONENAND_CMD_ERASE:
 393         case ONENAND_CMD_MULTIBLOCK_ERASE:
 394         case ONENAND_CMD_ERASE_VERIFY:
 395         case ONENAND_CMD_BUFFERRAM:
 396         case ONENAND_CMD_OTP_ACCESS:
 397                 block = onenand_block(this, addr);
 398                 page = -1;
 399                 break;
 400
 401         case FLEXONENAND_CMD_READ_PI:
 402                 cmd = ONENAND_CMD_READ;
 403                 block = addr * this->density_mask;
 404                 page = 0;
 405                 break;
 406
 407         default:
 408                 block = onenand_block(this, addr);
 409                 if (FLEXONENAND(this))
 410                         page = (int) (addr - onenand_addr(this, block))>>\
 411                                 this->page_shift;
 412                 else
 413                         page = (int) (addr >> this->page_shift);
 414                 if (ONENAND_IS_2PLANE(this)) {
 415                         /* Make the even block number */
 416                         block &= ~1;
 417                         /* Is it the odd plane? */
 418                         if (addr & this->writesize)
 419                                 block++;
 420                         page >>= 1;
 421                 }
 422                 page &= this->page_mask;
 423                 break;
 424         }
 425
 426         /* NOTE: The setting order of the registers is very important! */
 427         if (cmd == ONENAND_CMD_BUFFERRAM) {
 428                 /* Select DataRAM for DDP */
 429                 value = onenand_bufferram_address(this, block);
 430                 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS2);
 431
 432                 if (ONENAND_IS_2PLANE(this) || ONENAND_IS_4KB_PAGE(this))
 433                         /* It is always BufferRAM0 */
 434                         ONENAND_SET_BUFFERRAM0(this);
 435                 else
 436                         /* Switch to the next data buffer */
 437                         ONENAND_SET_NEXT_BUFFERRAM(this);
 438
 439                 return 0;
 440         }
 441
 442         if (block != -1) {
 443                 /* Write 'DFS, FBA' of Flash */
 444                 value = onenand_block_address(this, block);
 445                 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS1);
 446
 447                 /* Select DataRAM for DDP */
 448                 value = onenand_bufferram_address(this, block);
 449                 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS2);
 450         }
 451
 452         if (page != -1) {
 453                 /* Now we use page size operation */
 454                 int sectors = 0, count = 0;
 455                 int dataram;
 456
 457                 switch (cmd) {
 458                 case FLEXONENAND_CMD_RECOVER_LSB:
 459                 case ONENAND_CMD_READ:
 460                 case ONENAND_CMD_READOOB:
 461                         if (ONENAND_IS_4KB_PAGE(this))
 462                                 /* It is always BufferRAM0 */
 463                                 dataram = ONENAND_SET_BUFFERRAM0(this);
 464                         else
 465                                 dataram = ONENAND_SET_NEXT_BUFFERRAM(this);
 466                         break;
 467
 468                 default:
 469                         if (ONENAND_IS_2PLANE(this) && cmd == ONENAND_CMD_PROG)
 470                                 cmd = ONENAND_CMD_2X_PROG;
 471                         dataram = ONENAND_CURRENT_BUFFERRAM(this);
 472                         break;
 473                 }
 474
 475                 /* Write 'FPA, FSA' of Flash */
 476                 value = onenand_page_address(page, sectors);
 477                 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS8);
 478
 479                 /* Write 'BSA, BSC' of DataRAM */
 480                 value = onenand_buffer_address(dataram, sectors, count);
 481                 this->write_word(value, this->base + ONENAND_REG_START_BUFFER);
 482         }
 483
 484         /* Interrupt clear */
 485         this->write_word(ONENAND_INT_CLEAR, this->base + ONENAND_REG_INTERRUPT);
 486
 487         /* Write command */
 488         this->write_word(cmd, this->base + ONENAND_REG_COMMAND);
 489
 490         return 0;
 491 }
 492
 493 /**
 494  * onenand_read_ecc - return ecc status
 495  * @param this          onenand chip structure
 496  */
 497 static inline int onenand_read_ecc(struct onenand_chip *this)
 498 {
 499         int ecc, i, result = 0;
 500
 501         if (!FLEXONENAND(this) && !ONENAND_IS_4KB_PAGE(this))
 502                 return this->read_word(this->base + ONENAND_REG_ECC_STATUS);
 503
 504         for (i = 0; i < 4; i++) {
 505                 ecc = this->read_word(this->base + ONENAND_REG_ECC_STATUS + i*2);
 506                 if (likely(!ecc))
 507                         continue;
 508                 if (ecc & FLEXONENAND_UNCORRECTABLE_ERROR)
 509                         return ONENAND_ECC_2BIT_ALL;
 510                 else
 511                         result = ONENAND_ECC_1BIT_ALL;
 512         }
 513
 514         return result;
 515 }
 516
 517 /**
 518  * onenand_wait - [DEFAULT] wait until the command is done
 519  * @param mtd           MTD device structure
 520  * @param state         state to select the max. timeout value
 521  *
 522  * Wait for command done. This applies to all OneNAND command
 523  * Read can take up to 30us, erase up to 2ms and program up to 350us
 524  * according to general OneNAND specs
 525  */
 526 static int onenand_wait(struct mtd_info *mtd, int state)
 527 {
 528         struct onenand_chip * this = mtd->priv;
 529         unsigned long timeout;
 530         unsigned int flags = ONENAND_INT_MASTER;
 531         unsigned int interrupt = 0;
 532         unsigned int ctrl;
 533
 534         /* The 20 msec is enough */
 535         timeout = jiffies + msecs_to_jiffies(20);
 536         while (time_before(jiffies, timeout)) {
 537                 interrupt = this->read_word(this->base + ONENAND_REG_INTERRUPT);
 538
 539                 if (interrupt & flags)
 540                         break;
 541
 542                 if (state != FL_READING && state != FL_PREPARING_ERASE)
 543                         cond_resched();
 544         }
 545         /* To get correct interrupt status in timeout case */
 546         interrupt = this->read_word(this->base + ONENAND_REG_INTERRUPT);
 547
 548         ctrl = this->read_word(this->base + ONENAND_REG_CTRL_STATUS);
 549
 550         /*
 551          * In the Spec. it checks the controller status first
 552          * However if you get the correct information in case of
 553          * power off recovery (POR) test, it should read ECC status first
 554          */
 555         if (interrupt & ONENAND_INT_READ) {
 556                 int ecc = onenand_read_ecc(this);
 557                 if (ecc) {
 558                         if (ecc & ONENAND_ECC_2BIT_ALL) {
 559                                 printk(KERN_ERR "%s: ECC error = 0x%04x\n",
 560                                         __func__, ecc);
 561                                 mtd->ecc_stats.failed++;
 562                                 return -EBADMSG;
 563                         } else if (ecc & ONENAND_ECC_1BIT_ALL) {
 564                                 printk(KERN_DEBUG "%s: correctable ECC error = 0x%04x\n",
 565                                         __func__, ecc);
 566                                 mtd->ecc_stats.corrected++;
 567                         }
 568                 }
 569         } else if (state == FL_READING) {
 570                 printk(KERN_ERR "%s: read timeout! ctrl=0x%04x intr=0x%04x\n",
 571                         __func__, ctrl, interrupt);
 572                 return -EIO;
 573         }
 574
 575         if (state == FL_PREPARING_ERASE && !(interrupt & ONENAND_INT_ERASE)) {
 576                 printk(KERN_ERR "%s: mb erase timeout! ctrl=0x%04x intr=0x%04x\n",
 577                        __func__, ctrl, interrupt);
 578                 return -EIO;
 579         }
 580
 581         if (!(interrupt & ONENAND_INT_MASTER)) {
 582                 printk(KERN_ERR "%s: timeout! ctrl=0x%04x intr=0x%04x\n",
 583                        __func__, ctrl, interrupt);
 584                 return -EIO;
 585         }
 586
 587         /* If there's controller error, it's a real error */
 588         if (ctrl & ONENAND_CTRL_ERROR) {
 589                 printk(KERN_ERR "%s: controller error = 0x%04x\n",
 590                         __func__, ctrl);
 591                 if (ctrl & ONENAND_CTRL_LOCK)
 592                         printk(KERN_ERR "%s: it's locked error.\n", __func__);
 593                 return -EIO;
 594         }
 595
 596         return 0;
 597 }
 598
 599 /*
 600  * onenand_interrupt - [DEFAULT] onenand interrupt handler
 601  * @param irq           onenand interrupt number
 602  * @param dev_id        interrupt data
 603  *
 604  * complete the work
 605  */
 606 static irqreturn_t onenand_interrupt(int irq, void *data)
 607 {
 608         struct onenand_chip *this = data;
 609
 610         /* To handle shared interrupt */
 611         if (!this->complete.done)
 612                 complete(&this->complete);
 613
 614         return IRQ_HANDLED;
 615 }
 616
 617 /*
 618  * onenand_interrupt_wait - [DEFAULT] wait until the command is done
 619  * @param mtd           MTD device structure
 620  * @param state         state to select the max. timeout value
 621  *
 622  * Wait for command done.
 623  */
 624 static int onenand_interrupt_wait(struct mtd_info *mtd, int state)
 625 {
 626         struct onenand_chip *this = mtd->priv;
 627
 628         wait_for_completion(&this->complete);
 629
 630         return onenand_wait(mtd, state);
 631 }
 632
 633 /*
 634  * onenand_try_interrupt_wait - [DEFAULT] try interrupt wait
 635  * @param mtd           MTD device structure
 636  * @param state         state to select the max. timeout value
 637  *
 638  * Try interrupt based wait (It is used one-time)
 639  */
 640 static int onenand_try_interrupt_wait(struct mtd_info *mtd, int state)
 641 {
 642         struct onenand_chip *this = mtd->priv;
 643         unsigned long remain, timeout;
 644
 645         /* We use interrupt wait first */
 646         this->wait = onenand_interrupt_wait;
 647
 648         timeout = msecs_to_jiffies(100);
 649         remain = wait_for_completion_timeout(&this->complete, timeout);
 650         if (!remain) {
 651                 printk(KERN_INFO "OneNAND: There's no interrupt. "
 652                                 "We use the normal wait\n");
 653
 654                 /* Release the irq */
 655                 free_irq(this->irq, this);
 656
 657                 this->wait = onenand_wait;
 658         }
 659
 660         return onenand_wait(mtd, state);
 661 }
 662
 663 /*
 664  * onenand_setup_wait - [OneNAND Interface] setup onenand wait method
 665  * @param mtd           MTD device structure
 666  *
 667  * There's two method to wait onenand work
 668  * 1. polling - read interrupt status register
 669  * 2. interrupt - use the kernel interrupt method
 670  */
 671 static void onenand_setup_wait(struct mtd_info *mtd)
 672 {
 673         struct onenand_chip *this = mtd->priv;
 674         int syscfg;
 675
 676         init_completion(&this->complete);
 677
 678         if (this->irq <= 0) {
 679                 this->wait = onenand_wait;
 680                 return;
 681         }
 682
 683         if (request_irq(this->irq, &onenand_interrupt,
 684                                 IRQF_SHARED, "onenand", this)) {
 685                 /* If we can't get irq, use the normal wait */
 686                 this->wait = onenand_wait;
 687                 return;
 688         }
 689
 690         /* Enable interrupt */
 691         syscfg = this->read_word(this->base + ONENAND_REG_SYS_CFG1);
 692         syscfg |= ONENAND_SYS_CFG1_IOBE;
 693         this->write_word(syscfg, this->base + ONENAND_REG_SYS_CFG1);
 694
 695         this->wait = onenand_try_interrupt_wait;
 696 }
 697
 698 /**
 699  * onenand_bufferram_offset - [DEFAULT] BufferRAM offset
 700  * @param mtd           MTD data structure
 701  * @param area          BufferRAM area
 702  * @return              offset given area
 703  *
 704  * Return BufferRAM offset given area
 705  */
 706 static inline int onenand_bufferram_offset(struct mtd_info *mtd, int area)
 707 {
 708         struct onenand_chip *this = mtd->priv;
 709
 710         if (ONENAND_CURRENT_BUFFERRAM(this)) {
 711                 /* Note: the 'this->writesize' is a real page size */
 712                 if (area == ONENAND_DATARAM)
 713                         return this->writesize;
 714                 if (area == ONENAND_SPARERAM)
 715                         return mtd->oobsize;
 716         }
 717
 718         return 0;
 719 }
 720
 721 /**
 722  * onenand_read_bufferram - [OneNAND Interface] Read the bufferram area
 723  * @param mtd           MTD data structure
 724  * @param area          BufferRAM area
 725  * @param buffer        the databuffer to put/get data
 726  * @param offset        offset to read from or write to
 727  * @param count         number of bytes to read/write
 728  *
 729  * Read the BufferRAM area
 730  */
 731 static int onenand_read_bufferram(struct mtd_info *mtd, int area,
 732                 unsigned char *buffer, int offset, size_t count)
 733 {
 734         struct onenand_chip *this = mtd->priv;
 735         void __iomem *bufferram;
 736
 737         bufferram = this->base + area;
 738
 739         bufferram += onenand_bufferram_offset(mtd, area);
 740
 741         if (ONENAND_CHECK_BYTE_ACCESS(count)) {
 742                 unsigned short word;
 743
 744                 /* Align with word(16-bit) size */
 745                 count--;
 746
 747                 /* Read word and save byte */
 748                 word = this->read_word(bufferram + offset + count);
 749                 buffer[count] = (word & 0xff);
 750         }
 751
 752         memcpy(buffer, bufferram + offset, count);
 753
 754         return 0;
 755 }
 756
 757 /**
 758  * onenand_sync_read_bufferram - [OneNAND Interface] Read the bufferram area with Sync. Burst mode
 759  * @param mtd           MTD data structure
 760  * @param area          BufferRAM area
 761  * @param buffer        the databuffer to put/get data
 762  * @param offset        offset to read from or write to
 763  * @param count         number of bytes to read/write
 764  *
 765  * Read the BufferRAM area with Sync. Burst Mode
 766  */
 767 static int onenand_sync_read_bufferram(struct mtd_info *mtd, int area,
 768                 unsigned char *buffer, int offset, size_t count)
 769 {
 770         struct onenand_chip *this = mtd->priv;
 771         void __iomem *bufferram;
 772
 773         bufferram = this->base + area;
 774
 775         bufferram += onenand_bufferram_offset(mtd, area);
 776
 777         this->mmcontrol(mtd, ONENAND_SYS_CFG1_SYNC_READ);
 778
 779         if (ONENAND_CHECK_BYTE_ACCESS(count)) {
 780                 unsigned short word;
 781
 782                 /* Align with word(16-bit) size */
 783                 count--;
 784
 785                 /* Read word and save byte */
 786                 word = this->read_word(bufferram + offset + count);
 787                 buffer[count] = (word & 0xff);
 788         }
 789
 790         memcpy(buffer, bufferram + offset, count);
 791
 792         this->mmcontrol(mtd, 0);
 793
 794         return 0;
 795 }
 796
 797 /**
 798  * onenand_write_bufferram - [OneNAND Interface] Write the bufferram area
 799  * @param mtd           MTD data structure
 800  * @param area          BufferRAM area
 801  * @param buffer        the databuffer to put/get data
 802  * @param offset        offset to read from or write to
 803  * @param count         number of bytes to read/write
 804  *
 805  * Write the BufferRAM area
 806  */
 807 static int onenand_write_bufferram(struct mtd_info *mtd, int area,
 808                 const unsigned char *buffer, int offset, size_t count)
 809 {
 810         struct onenand_chip *this = mtd->priv;
 811         void __iomem *bufferram;
 812
 813         bufferram = this->base + area;
 814
 815         bufferram += onenand_bufferram_offset(mtd, area);
 816
 817         if (ONENAND_CHECK_BYTE_ACCESS(count)) {
 818                 unsigned short word;
 819                 int byte_offset;
 820
 821                 /* Align with word(16-bit) size */
 822                 count--;
 823
 824                 /* Calculate byte access offset */
 825                 byte_offset = offset + count;
 826
 827                 /* Read word and save byte */
 828                 word = this->read_word(bufferram + byte_offset);
 829                 word = (word & ~0xff) | buffer[count];
 830                 this->write_word(word, bufferram + byte_offset);
 831         }
 832
 833         memcpy(bufferram + offset, buffer, count);
 834
 835         return 0;
 836 }
 837
 838 /**
 839  * onenand_get_2x_blockpage - [GENERIC] Get blockpage at 2x program mode
 840  * @param mtd           MTD data structure
 841  * @param addr          address to check
 842  * @return              blockpage address
 843  *
 844  * Get blockpage address at 2x program mode
 845  */
 846 static int onenand_get_2x_blockpage(struct mtd_info *mtd, loff_t addr)
 847 {
 848         struct onenand_chip *this = mtd->priv;
 849         int blockpage, block, page;
 850
 851         /* Calculate the even block number */
 852         block = (int) (addr >> this->erase_shift) & ~1;
 853         /* Is it the odd plane? */
 854         if (addr & this->writesize)
 855                 block++;
 856         page = (int) (addr >> (this->page_shift + 1)) & this->page_mask;
 857         blockpage = (block << 7) | page;
 858
 859         return blockpage;
 860 }
 861
 862 /**
 863  * onenand_check_bufferram - [GENERIC] Check BufferRAM information
 864  * @param mtd           MTD data structure
 865  * @param addr          address to check
 866  * @return              1 if there are valid data, otherwise 0
 867  *
 868  * Check bufferram if there is data we required
 869  */
 870 static int onenand_check_bufferram(struct mtd_info *mtd, loff_t addr)
 871 {
 872         struct onenand_chip *this = mtd->priv;
 873         int blockpage, found = 0;
 874         unsigned int i;
 875
 876         if (ONENAND_IS_2PLANE(this))
 877                 blockpage = onenand_get_2x_blockpage(mtd, addr);
 878         else
 879                 blockpage = (int) (addr >> this->page_shift);
 880
 881         /* Is there valid data? */
 882         i = ONENAND_CURRENT_BUFFERRAM(this);
 883         if (this->bufferram[i].blockpage == blockpage)
 884                 found = 1;
 885         else {
 886                 /* Check another BufferRAM */
 887                 i = ONENAND_NEXT_BUFFERRAM(this);
 888                 if (this->bufferram[i].blockpage == blockpage) {
 889                         ONENAND_SET_NEXT_BUFFERRAM(this);
 890                         found = 1;
 891                 }
 892         }
 893
 894         if (found && ONENAND_IS_DDP(this)) {
 895                 /* Select DataRAM for DDP */
 896                 int block = onenand_block(this, addr);
 897                 int value = onenand_bufferram_address(this, block);
 898                 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS2);
 899         }
 900
 901         return found;
 902 }
 903
 904 /**
 905  * onenand_update_bufferram - [GENERIC] Update BufferRAM information
 906  * @param mtd           MTD data structure
 907  * @param addr          address to update
 908  * @param valid         valid flag
 909  *
 910  * Update BufferRAM information
 911  */
 912 static void onenand_update_bufferram(struct mtd_info *mtd, loff_t addr,
 913                 int valid)
 914 {
 915         struct onenand_chip *this = mtd->priv;
 916         int blockpage;
 917         unsigned int i;
 918
 919         if (ONENAND_IS_2PLANE(this))
 920                 blockpage = onenand_get_2x_blockpage(mtd, addr);
 921         else
 922                 blockpage = (int) (addr >> this->page_shift);
 923
 924         /* Invalidate another BufferRAM */
 925         i = ONENAND_NEXT_BUFFERRAM(this);
 926         if (this->bufferram[i].blockpage == blockpage)
 927                 this->bufferram[i].blockpage = -1;
 928
 929         /* Update BufferRAM */
 930         i = ONENAND_CURRENT_BUFFERRAM(this);
 931         if (valid)
 932                 this->bufferram[i].blockpage = blockpage;
 933         else
 934                 this->bufferram[i].blockpage = -1;
 935 }
 936
 937 /**
 938  * onenand_invalidate_bufferram - [GENERIC] Invalidate BufferRAM information
 939  * @param mtd           MTD data structure
 940  * @param addr          start address to invalidate
 941  * @param len           length to invalidate
 942  *
 943  * Invalidate BufferRAM information
 944  */
 945 static void onenand_invalidate_bufferram(struct mtd_info *mtd, loff_t addr,
 946                 unsigned int len)
 947 {
 948         struct onenand_chip *this = mtd->priv;
 949         int i;
 950         loff_t end_addr = addr + len;
 951
 952         /* Invalidate BufferRAM */
 953         for (i = 0; i < MAX_BUFFERRAM; i++) {
 954                 loff_t buf_addr = this->bufferram[i].blockpage << this->page_shift;
 955                 if (buf_addr >= addr && buf_addr < end_addr)
 956                         this->bufferram[i].blockpage = -1;
 957         }
 958 }
 959
 960 /**
 961  * onenand_get_device - [GENERIC] Get chip for selected access
 962  * @param mtd           MTD device structure
 963  * @param new_state     the state which is requested
 964  *
 965  * Get the device and lock it for exclusive access
 966  */
 967 static int onenand_get_device(struct mtd_info *mtd, int new_state)
 968 {
 969         struct onenand_chip *this = mtd->priv;
 970         DECLARE_WAITQUEUE(wait, current);
 971
 972         /*
 973          * Grab the lock and see if the device is available
 974          */
 975         while (1) {
 976                 spin_lock(&this->chip_lock);
 977                 if (this->state == FL_READY) {
 978                         this->state = new_state;
 979                         spin_unlock(&this->chip_lock);
 980                         if (new_state != FL_PM_SUSPENDED && this->enable)
 981                                 this->enable(mtd);
 982                         break;
 983                 }
 984                 if (new_state == FL_PM_SUSPENDED) {
 985                         spin_unlock(&this->chip_lock);
 986                         return (this->state == FL_PM_SUSPENDED) ? 0 : -EAGAIN;
 987                 }
 988                 set_current_state(TASK_UNINTERRUPTIBLE);
 989                 add_wait_queue(&this->wq, &wait);
 990                 spin_unlock(&this->chip_lock);
 991                 schedule();
 992                 remove_wait_queue(&this->wq, &wait);
 993         }
 994
 995         return 0;
 996 }
 997
 998 /**
 999  * onenand_release_device - [GENERIC] release chip
1000  * @param mtd           MTD device structure
1001  *
1002  * Deselect, release chip lock and wake up anyone waiting on the device
1003  */
1004 static void onenand_release_device(struct mtd_info *mtd)
1005 {
1006         struct onenand_chip *this = mtd->priv;
1007
1008         if (this->state != FL_PM_SUSPENDED && this->disable)
1009                 this->disable(mtd);
1010         /* Release the chip */
1011         spin_lock(&this->chip_lock);
1012         this->state = FL_READY;
1013         wake_up(&this->wq);
1014         spin_unlock(&this->chip_lock);
1015 }
1016
1017 /**
1018  * onenand_transfer_auto_oob - [INTERN] oob auto-placement transfer
1019  * @param mtd           MTD device structure
1020  * @param buf           destination address
1021  * @param column        oob offset to read from
1022  * @param thislen       oob length to read
1023  */
1024 static int onenand_transfer_auto_oob(struct mtd_info *mtd, uint8_t *buf, int column,
1025                                 int thislen)
1026 {
1027         struct onenand_chip *this = mtd->priv;
1028         struct nand_oobfree *free;
1029         int readcol = column;
1030         int readend = column + thislen;
1031         int lastgap = 0;
1032         unsigned int i;
1033         uint8_t *oob_buf = this->oob_buf;
1034
1035         free = this->ecclayout->oobfree;
1036         for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES && free->length; i++, free++) {
1037                 if (readcol >= lastgap)
1038                         readcol += free->offset - lastgap;
1039                 if (readend >= lastgap)
1040                         readend += free->offset - lastgap;
1041                 lastgap = free->offset + free->length;
1042         }
1043         this->read_bufferram(mtd, ONENAND_SPARERAM, oob_buf, 0, mtd->oobsize);
1044         free = this->ecclayout->oobfree;
1045         for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES && free->length; i++, free++) {
1046                 int free_end = free->offset + free->length;
1047                 if (free->offset < readend && free_end > readcol) {
1048                         int st = max_t(int,free->offset,readcol);
1049                         int ed = min_t(int,free_end,readend);
1050                         int n = ed - st;
1051                         memcpy(buf, oob_buf + st, n);
1052                         buf += n;
1053                 } else if (column == 0)
1054                         break;
1055         }
1056         return 0;
1057 }
1058
1059 /**
1060  * onenand_recover_lsb - [Flex-OneNAND] Recover LSB page data
1061  * @param mtd           MTD device structure
1062  * @param addr          address to recover
1063  * @param status        return value from onenand_wait / onenand_bbt_wait
1064  *
1065  * MLC NAND Flash cell has paired pages - LSB page and MSB page. LSB page has
1066  * lower page address and MSB page has higher page address in paired pages.
1067  * If power off occurs during MSB page program, the paired LSB page data can
1068  * become corrupt. LSB page recovery read is a way to read LSB page though page
1069  * data are corrupted. When uncorrectable error occurs as a result of LSB page
1070  * read after power up, issue LSB page recovery read.
1071  */
1072 static int onenand_recover_lsb(struct mtd_info *mtd, loff_t addr, int status)
1073 {
1074         struct onenand_chip *this = mtd->priv;
1075         int i;
1076
1077         /* Recovery is only for Flex-OneNAND */
1078         if (!FLEXONENAND(this))
1079                 return status;
1080
1081         /* check if we failed due to uncorrectable error */
1082         if (!mtd_is_eccerr(status) && status != ONENAND_BBT_READ_ECC_ERROR)
1083                 return status;
1084
1085         /* check if address lies in MLC region */
1086         i = flexonenand_region(mtd, addr);
1087         if (mtd->eraseregions[i].erasesize < (1 << this->erase_shift))
1088                 return status;
1089
1090         /* We are attempting to reread, so decrement stats.failed
1091          * which was incremented by onenand_wait due to read failure
1092          */
1093         printk(KERN_INFO "%s: Attempting to recover from uncorrectable read\n",
1094                 __func__);
1095         mtd->ecc_stats.failed--;
1096
1097         /* Issue the LSB page recovery command */
1098         this->command(mtd, FLEXONENAND_CMD_RECOVER_LSB, addr, this->writesize);
1099         return this->wait(mtd, FL_READING);
1100 }
1101
1102 /**
1103  * onenand_mlc_read_ops_nolock - MLC OneNAND read main and/or out-of-band
1104  * @param mtd           MTD device structure
1105  * @param from          offset to read from
1106  * @param ops:          oob operation description structure
1107  *
1108  * MLC OneNAND / Flex-OneNAND has 4KB page size and 4KB dataram.
1109  * So, read-while-load is not present.
1110  */
1111 static int onenand_mlc_read_ops_nolock(struct mtd_info *mtd, loff_t from,
1112                                 struct mtd_oob_ops *ops)
1113 {
1114         struct onenand_chip *this = mtd->priv;
1115         struct mtd_ecc_stats stats;
1116         size_t len = ops->len;
1117         size_t ooblen = ops->ooblen;
1118         u_char *buf = ops->datbuf;
1119         u_char *oobbuf = ops->oobbuf;
1120         int read = 0, column, thislen;
1121         int oobread = 0, oobcolumn, thisooblen, oobsize;
1122         int ret = 0;
1123         int writesize = this->writesize;
1124
1125         pr_debug("%s: from = 0x%08x, len = %i\n", __func__, (unsigned int)from,
1126                         (int)len);
1127
1128         if (ops->mode == MTD_OPS_AUTO_OOB)
1129                 oobsize = this->ecclayout->oobavail;
1130         else
1131                 oobsize = mtd->oobsize;
1132
1133         oobcolumn = from & (mtd->oobsize - 1);
1134
1135         /* Do not allow reads past end of device */
1136         if (from + len > mtd->size) {
1137                 printk(KERN_ERR "%s: Attempt read beyond end of device\n",
1138                         __func__);
1139                 ops->retlen = 0;
1140                 ops->oobretlen = 0;
1141                 return -EINVAL;
1142         }
1143
1144         stats = mtd->ecc_stats;
1145
1146         while (read < len) {
1147                 cond_resched();
1148
1149                 thislen = min_t(int, writesize, len - read);
1150
1151                 column = from & (writesize - 1);
1152                 if (column + thislen > writesize)
1153                         thislen = writesize - column;
1154
1155                 if (!onenand_check_bufferram(mtd, from)) {
1156                         this->command(mtd, ONENAND_CMD_READ, from, writesize);
1157
1158                         ret = this->wait(mtd, FL_READING);
1159                         if (unlikely(ret))
1160                                 ret = onenand_recover_lsb(mtd, from, ret);
1161                         onenand_update_bufferram(mtd, from, !ret);
1162                         if (mtd_is_eccerr(ret))
1163                                 ret = 0;
1164                         if (ret)
1165                                 break;
1166                 }
1167
1168                 this->read_bufferram(mtd, ONENAND_DATARAM, buf, column, thislen);
1169                 if (oobbuf) {
1170                         thisooblen = oobsize - oobcolumn;
1171                         thisooblen = min_t(int, thisooblen, ooblen - oobread);
1172
1173                         if (ops->mode == MTD_OPS_AUTO_OOB)
1174                                 onenand_transfer_auto_oob(mtd, oobbuf, oobcolumn, thisooblen);
1175                         else
1176                                 this->read_bufferram(mtd, ONENAND_SPARERAM, oobbuf, oobcolumn, thisooblen);
1177                         oobread += thisooblen;
1178                         oobbuf += thisooblen;
1179                         oobcolumn = 0;
1180                 }
1181
1182                 read += thislen;
1183                 if (read == len)
1184                         break;
1185
1186                 from += thislen;
1187                 buf += thislen;
1188         }
1189
1190         /*
1191          * Return success, if no ECC failures, else -EBADMSG
1192          * fs driver will take care of that, because
1193          * retlen == desired len and result == -EBADMSG
1194          */
1195         ops->retlen = read;
1196         ops->oobretlen = oobread;
1197
1198         if (ret)
1199                 return ret;
1200
1201         if (mtd->ecc_stats.failed - stats.failed)
1202                 return -EBADMSG;
1203
1204         return mtd->ecc_stats.corrected - stats.corrected ? -EUCLEAN : 0;
1205 }
1206
1207 /**
1208  * onenand_read_ops_nolock - [OneNAND Interface] OneNAND read main and/or out-of-band
1209  * @param mtd           MTD device structure
1210  * @param from          offset to read from
1211  * @param ops:          oob operation description structure
1212  *
1213  * OneNAND read main and/or out-of-band data
1214  */
1215 static int onenand_read_ops_nolock(struct mtd_info *mtd, loff_t from,
1216                                 struct mtd_oob_ops *ops)
1217 {
1218         struct onenand_chip *this = mtd->priv;
1219         struct mtd_ecc_stats stats;
1220         size_t len = ops->len;
1221         size_t ooblen = ops->ooblen;
1222         u_char *buf = ops->datbuf;
1223         u_char *oobbuf = ops->oobbuf;
1224         int read = 0, column, thislen;
1225         int oobread = 0, oobcolumn, thisooblen, oobsize;
1226         int ret = 0, boundary = 0;
1227         int writesize = this->writesize;
1228
1229         pr_debug("%s: from = 0x%08x, len = %i\n", __func__, (unsigned int)from,
1230                         (int)len);
1231
1232         if (ops->mode == MTD_OPS_AUTO_OOB)
1233                 oobsize = this->ecclayout->oobavail;
1234         else
1235                 oobsize = mtd->oobsize;
1236
1237         oobcolumn = from & (mtd->oobsize - 1);
1238
1239         /* Do not allow reads past end of device */
1240         if ((from + len) > mtd->size) {
1241                 printk(KERN_ERR "%s: Attempt read beyond end of device\n",
1242                         __func__);
1243                 ops->retlen = 0;
1244                 ops->oobretlen = 0;
1245                 return -EINVAL;
1246         }
1247
1248         stats = mtd->ecc_stats;
1249
1250         /* Read-while-load method */
1251
1252         /* Do first load to bufferRAM */
1253         if (read < len) {
1254                 if (!onenand_check_bufferram(mtd, from)) {
1255                         this->command(mtd, ONENAND_CMD_READ, from, writesize);
1256                         ret = this->wait(mtd, FL_READING);
1257                         onenand_update_bufferram(mtd, from, !ret);
1258                         if (mtd_is_eccerr(ret))
1259                                 ret = 0;
1260                 }
1261         }
1262
1263         thislen = min_t(int, writesize, len - read);
1264         column = from & (writesize - 1);
1265         if (column + thislen > writesize)
1266                 thislen = writesize - column;
1267
1268         while (!ret) {
1269                 /* If there is more to load then start next load */
1270                 from += thislen;
1271                 if (read + thislen < len) {
1272                         this->command(mtd, ONENAND_CMD_READ, from, writesize);
1273                         /*
1274                          * Chip boundary handling in DDP
1275                          * Now we issued chip 1 read and pointed chip 1
1276                          * bufferram so we have to point chip 0 bufferram.
1277                          */
1278                         if (ONENAND_IS_DDP(this) &&
1279                             unlikely(from == (this->chipsize >> 1))) {
1280                                 this->write_word(ONENAND_DDP_CHIP0, this->base + ONENAND_REG_START_ADDRESS2);
1281                                 boundary = 1;
1282                         } else
1283                                 boundary = 0;
1284                         ONENAND_SET_PREV_BUFFERRAM(this);
1285                 }
1286                 /* While load is going, read from last bufferRAM */
1287                 this->read_bufferram(mtd, ONENAND_DATARAM, buf, column, thislen);
1288
1289                 /* Read oob area if needed */
1290                 if (oobbuf) {
1291                         thisooblen = oobsize - oobcolumn;
1292                         thisooblen = min_t(int, thisooblen, ooblen - oobread);
1293
1294                         if (ops->mode == MTD_OPS_AUTO_OOB)
1295                                 onenand_transfer_auto_oob(mtd, oobbuf, oobcolumn, thisooblen);
1296                         else
1297                                 this->read_bufferram(mtd, ONENAND_SPARERAM, oobbuf, oobcolumn, thisooblen);
1298                         oobread += thisooblen;
1299                         oobbuf += thisooblen;
1300                         oobcolumn = 0;
1301                 }
1302
1303                 /* See if we are done */
1304                 read += thislen;
1305                 if (read == len)
1306                         break;
1307                 /* Set up for next read from bufferRAM */
1308                 if (unlikely(boundary))
1309                         this->write_word(ONENAND_DDP_CHIP1, this->base + ONENAND_REG_START_ADDRESS2);
1310                 ONENAND_SET_NEXT_BUFFERRAM(this);
1311                 buf += thislen;
1312                 thislen = min_t(int, writesize, len - read);
1313                 column = 0;
1314                 cond_resched();
1315                 /* Now wait for load */
1316                 ret = this->wait(mtd, FL_READING);
1317                 onenand_update_bufferram(mtd, from, !ret);
1318                 if (mtd_is_eccerr(ret))
1319                         ret = 0;
1320         }
1321
1322         /*
1323          * Return success, if no ECC failures, else -EBADMSG
1324          * fs driver will take care of that, because
1325          * retlen == desired len and result == -EBADMSG
1326          */
1327         ops->retlen = read;
1328         ops->oobretlen = oobread;
1329
1330         if (ret)
1331                 return ret;
1332
1333         if (mtd->ecc_stats.failed - stats.failed)
1334                 return -EBADMSG;
1335
1336         return mtd->ecc_stats.corrected - stats.corrected ? -EUCLEAN : 0;
1337 }
1338
1339 /**
1340  * onenand_read_oob_nolock - [MTD Interface] OneNAND read out-of-band
1341  * @param mtd           MTD device structure
1342  * @param from          offset to read from
1343  * @param ops:          oob operation description structure
1344  *
1345  * OneNAND read out-of-band data from the spare area
1346  */
1347 static int onenand_read_oob_nolock(struct mtd_info *mtd, loff_t from,
1348                         struct mtd_oob_ops *ops)
1349 {
1350         struct onenand_chip *this = mtd->priv;
1351         struct mtd_ecc_stats stats;
1352         int read = 0, thislen, column, oobsize;
1353         size_t len = ops->ooblen;
1354         unsigned int mode = ops->mode;
1355         u_char *buf = ops->oobbuf;
1356         int ret = 0, readcmd;
1357
1358         from += ops->ooboffs;
1359
1360         pr_debug("%s: from = 0x%08x, len = %i\n", __func__, (unsigned int)from,
1361                         (int)len);
1362
1363         /* Initialize return length value */
1364         ops->oobretlen = 0;
1365
1366         if (mode == MTD_OPS_AUTO_OOB)
1367                 oobsize = this->ecclayout->oobavail;
1368         else
1369                 oobsize = mtd->oobsize;
1370
1371         column = from & (mtd->oobsize - 1);
1372
1373         if (unlikely(column >= oobsize)) {
1374                 printk(KERN_ERR "%s: Attempted to start read outside oob\n",
1375                         __func__);
1376                 return -EINVAL;
1377         }
1378
1379         /* Do not allow reads past end of device */
1380         if (unlikely(from >= mtd->size ||
1381                      column + len > ((mtd->size >> this->page_shift) -
1382                                      (from >> this->page_shift)) * oobsize)) {
1383                 printk(KERN_ERR "%s: Attempted to read beyond end of device\n",
1384                         __func__);
1385                 return -EINVAL;
1386         }
1387
1388         stats = mtd->ecc_stats;
1389
1390         readcmd = ONENAND_IS_4KB_PAGE(this) ? ONENAND_CMD_READ : ONENAND_CMD_READOOB;
1391
1392         while (read < len) {
1393                 cond_resched();
1394
1395                 thislen = oobsize - column;
1396                 thislen = min_t(int, thislen, len);
1397
1398                 this->command(mtd, readcmd, from, mtd->oobsize);
1399
1400                 onenand_update_bufferram(mtd, from, 0);
1401
1402                 ret = this->wait(mtd, FL_READING);
1403                 if (unlikely(ret))
1404                         ret = onenand_recover_lsb(mtd, from, ret);
1405
1406                 if (ret && !mtd_is_eccerr(ret)) {
1407                         printk(KERN_ERR "%s: read failed = 0x%x\n",
1408                                 __func__, ret);
1409                         break;
1410                 }
1411
1412                 if (mode == MTD_OPS_AUTO_OOB)
1413                         onenand_transfer_auto_oob(mtd, buf, column, thislen);
1414                 else
1415                         this->read_bufferram(mtd, ONENAND_SPARERAM, buf, column, thislen);
1416
1417                 read += thislen;
1418
1419                 if (read == len)
1420                         break;
1421
1422                 buf += thislen;
1423
1424                 /* Read more? */
1425                 if (read < len) {
1426                         /* Page size */
1427                         from += mtd->writesize;
1428                         column = 0;
1429                 }
1430         }
1431
1432         ops->oobretlen = read;
1433
1434         if (ret)
1435                 return ret;
1436
1437         if (mtd->ecc_stats.failed - stats.failed)
1438                 return -EBADMSG;
1439
1440         return 0;
1441 }
1442
1443 /**
1444  * onenand_read - [MTD Interface] Read data from flash
1445  * @param mtd           MTD device structure
1446  * @param from          offset to read from
1447  * @param len           number of bytes to read
1448  * @param retlen        pointer to variable to store the number of read bytes
1449  * @param buf           the databuffer to put data
1450  *
1451  * Read with ecc
1452 */
1453 static int onenand_read(struct mtd_info *mtd, loff_t from, size_t len,
1454         size_t *retlen, u_char *buf)
1455 {
1456         struct onenand_chip *this = mtd->priv;
1457         struct mtd_oob_ops ops = {
1458                 .len    = len,
1459                 .ooblen = 0,
1460                 .datbuf = buf,
1461                 .oobbuf = NULL,
1462         };
1463         int ret;
1464
1465         onenand_get_device(mtd, FL_READING);
1466         ret = ONENAND_IS_4KB_PAGE(this) ?
1467                 onenand_mlc_read_ops_nolock(mtd, from, &ops) :
1468                 onenand_read_ops_nolock(mtd, from, &ops);
1469         onenand_release_device(mtd);
1470
1471         *retlen = ops.retlen;
1472         return ret;
1473 }
1474
1475 /**
1476  * onenand_read_oob - [MTD Interface] Read main and/or out-of-band
1477  * @param mtd:          MTD device structure
1478  * @param from:         offset to read from
1479  * @param ops:          oob operation description structure
1480
1481  * Read main and/or out-of-band
1482  */
1483 static int onenand_read_oob(struct mtd_info *mtd, loff_t from,
1484                             struct mtd_oob_ops *ops)
1485 {
1486         struct onenand_chip *this = mtd->priv;
1487         int ret;
1488
1489         switch (ops->mode) {
1490         case MTD_OPS_PLACE_OOB:
1491         case MTD_OPS_AUTO_OOB:
1492                 break;
1493         case MTD_OPS_RAW:
1494                 /* Not implemented yet */
1495         default:
1496                 return -EINVAL;
1497         }
1498
1499         onenand_get_device(mtd, FL_READING);
1500         if (ops->datbuf)
1501                 ret = ONENAND_IS_4KB_PAGE(this) ?
1502                         onenand_mlc_read_ops_nolock(mtd, from, ops) :
1503                         onenand_read_ops_nolock(mtd, from, ops);
1504         else
1505                 ret = onenand_read_oob_nolock(mtd, from, ops);
1506         onenand_release_device(mtd);
1507
1508         return ret;
1509 }
1510
1511 /**
1512  * onenand_bbt_wait - [DEFAULT] wait until the command is done
1513  * @param mtd           MTD device structure
1514  * @param state         state to select the max. timeout value
1515  *
1516  * Wait for command done.
1517  */
1518 static int onenand_bbt_wait(struct mtd_info *mtd, int state)
1519 {
1520         struct onenand_chip *this = mtd->priv;
1521         unsigned long timeout;
1522         unsigned int interrupt, ctrl, ecc, addr1, addr8;
1523
1524         /* The 20 msec is enough */
1525         timeout = jiffies + msecs_to_jiffies(20);
1526         while (time_before(jiffies, timeout)) {
1527                 interrupt = this->read_word(this->base + ONENAND_REG_INTERRUPT);
1528                 if (interrupt & ONENAND_INT_MASTER)
1529                         break;
1530         }
1531         /* To get correct interrupt status in timeout case */
1532         interrupt = this->read_word(this->base + ONENAND_REG_INTERRUPT);
1533         ctrl = this->read_word(this->base + ONENAND_REG_CTRL_STATUS);
1534         addr1 = this->read_word(this->base + ONENAND_REG_START_ADDRESS1);
1535         addr8 = this->read_word(this->base + ONENAND_REG_START_ADDRESS8);
1536
1537         if (interrupt & ONENAND_INT_READ) {
1538                 ecc = onenand_read_ecc(this);
1539                 if (ecc & ONENAND_ECC_2BIT_ALL) {
1540                         printk(KERN_DEBUG "%s: ecc 0x%04x ctrl 0x%04x "
1541                                "intr 0x%04x addr1 %#x addr8 %#x\n",
1542                                __func__, ecc, ctrl, interrupt, addr1, addr8);
1543                         return ONENAND_BBT_READ_ECC_ERROR;
1544                 }
1545         } else {
1546                 printk(KERN_ERR "%s: read timeout! ctrl 0x%04x "
1547                        "intr 0x%04x addr1 %#x addr8 %#x\n",
1548                        __func__, ctrl, interrupt, addr1, addr8);
1549                 return ONENAND_BBT_READ_FATAL_ERROR;
1550         }
1551
1552         /* Initial bad block case: 0x2400 or 0x0400 */
1553         if (ctrl & ONENAND_CTRL_ERROR) {
1554                 printk(KERN_DEBUG "%s: ctrl 0x%04x intr 0x%04x addr1 %#x "
1555                        "addr8 %#x\n", __func__, ctrl, interrupt, addr1, addr8);
1556                 return ONENAND_BBT_READ_ERROR;
1557         }
1558
1559         return 0;
1560 }
1561
1562 /**
1563  * onenand_bbt_read_oob - [MTD Interface] OneNAND read out-of-band for bbt scan
1564  * @param mtd           MTD device structure
1565  * @param from          offset to read from
1566  * @param ops           oob operation description structure
1567  *
1568  * OneNAND read out-of-band data from the spare area for bbt scan
1569  */
1570 int onenand_bbt_read_oob(struct mtd_info *mtd, loff_t from,
1571                             struct mtd_oob_ops *ops)
1572 {
1573         struct onenand_chip *this = mtd->priv;
1574         int read = 0, thislen, column;
1575         int ret = 0, readcmd;
1576         size_t len = ops->ooblen;
1577         u_char *buf = ops->oobbuf;
1578
1579         pr_debug("%s: from = 0x%08x, len = %zi\n", __func__, (unsigned int)from,
1580                         len);
1581
1582         /* Initialize return value */
1583         ops->oobretlen = 0;
1584
1585         /* Do not allow reads past end of device */
1586         if (unlikely((from + len) > mtd->size)) {
1587                 printk(KERN_ERR "%s: Attempt read beyond end of device\n",
1588                         __func__);
1589                 return ONENAND_BBT_READ_FATAL_ERROR;
1590         }
1591
1592         /* Grab the lock and see if the device is available */
1593         onenand_get_device(mtd, FL_READING);
1594
1595         column = from & (mtd->oobsize - 1);
1596
1597         readcmd = ONENAND_IS_4KB_PAGE(this) ? ONENAND_CMD_READ : ONENAND_CMD_READOOB;
1598
1599         while (read < len) {
1600                 cond_resched();
1601
1602                 thislen = mtd->oobsize - column;
1603                 thislen = min_t(int, thislen, len);
1604
1605                 this->command(mtd, readcmd, from, mtd->oobsize);
1606
1607                 onenand_update_bufferram(mtd, from, 0);
1608
1609                 ret = this->bbt_wait(mtd, FL_READING);
1610                 if (unlikely(ret))
1611                         ret = onenand_recover_lsb(mtd, from, ret);
1612
1613                 if (ret)
1614                         break;
1615
1616                 this->read_bufferram(mtd, ONENAND_SPARERAM, buf, column, thislen);
1617                 read += thislen;
1618                 if (read == len)
1619                         break;
1620
1621                 buf += thislen;
1622
1623                 /* Read more? */
1624                 if (read < len) {
1625                         /* Update Page size */
1626                         from += this->writesize;
1627                         column = 0;
1628                 }
1629         }
1630
1631         /* Deselect and wake up anyone waiting on the device */
1632         onenand_release_device(mtd);
1633
1634         ops->oobretlen = read;
1635         return ret;
1636 }
1637
1638 #ifdef CONFIG_MTD_ONENAND_VERIFY_WRITE
1639 /**
1640  * onenand_verify_oob - [GENERIC] verify the oob contents after a write
1641  * @param mtd           MTD device structure
1642  * @param buf           the databuffer to verify
1643  * @param to            offset to read from
1644  */
1645 static int onenand_verify_oob(struct mtd_info *mtd, const u_char *buf, loff_t to)
1646 {
1647         struct onenand_chip *this = mtd->priv;
1648         u_char *oob_buf = this->oob_buf;
1649         int status, i, readcmd;
1650
1651         readcmd = ONENAND_IS_4KB_PAGE(this) ? ONENAND_CMD_READ : ONENAND_CMD_READOOB;
1652
1653         this->command(mtd, readcmd, to, mtd->oobsize);
1654         onenand_update_bufferram(mtd, to, 0);
1655         status = this->wait(mtd, FL_READING);
1656         if (status)
1657                 return status;
1658
1659         this->read_bufferram(mtd, ONENAND_SPARERAM, oob_buf, 0, mtd->oobsize);
1660         for (i = 0; i < mtd->oobsize; i++)
1661                 if (buf[i] != 0xFF && buf[i] != oob_buf[i])
1662                         return -EBADMSG;
1663
1664         return 0;
1665 }
1666
1667 /**
1668  * onenand_verify - [GENERIC] verify the chip contents after a write
1669  * @param mtd          MTD device structure
1670  * @param buf          the databuffer to verify
1671  * @param addr         offset to read from
1672  * @param len          number of bytes to read and compare
1673  */
1674 static int onenand_verify(struct mtd_info *mtd, const u_char *buf, loff_t addr, size_t len)
1675 {
1676         struct onenand_chip *this = mtd->priv;
1677         int ret = 0;
1678         int thislen, column;
1679
1680         column = addr & (this->writesize - 1);
1681
1682         while (len != 0) {
1683                 thislen = min_t(int, this->writesize - column, len);
1684
1685                 this->command(mtd, ONENAND_CMD_READ, addr, this->writesize);
1686
1687                 onenand_update_bufferram(mtd, addr, 0);
1688
1689                 ret = this->wait(mtd, FL_READING);
1690                 if (ret)
1691                         return ret;
1692
1693                 onenand_update_bufferram(mtd, addr, 1);
1694
1695                 this->read_bufferram(mtd, ONENAND_DATARAM, this->verify_buf, 0, mtd->writesize);
1696
1697                 if (memcmp(buf, this->verify_buf + column, thislen))
1698                         return -EBADMSG;
1699
1700                 len -= thislen;
1701                 buf += thislen;
1702                 addr += thislen;
1703                 column = 0;
1704         }
1705
1706         return 0;
1707 }
1708 #else
1709 #define onenand_verify(...)             (0)
1710 #define onenand_verify_oob(...)         (0)
1711 #endif
1712
1713 #define NOTALIGNED(x)   ((x & (this->subpagesize - 1)) != 0)
1714
1715 static void onenand_panic_wait(struct mtd_info *mtd)
1716 {
1717         struct onenand_chip *this = mtd->priv;
1718         unsigned int interrupt;
1719         int i;
1720
1721         for (i = 0; i < 2000; i++) {
1722                 interrupt = this->read_word(this->base + ONENAND_REG_INTERRUPT);
1723                 if (interrupt & ONENAND_INT_MASTER)
1724                         break;
1725                 udelay(10);
1726         }
1727 }
1728
1729 /**
1730  * onenand_panic_write - [MTD Interface] write buffer to FLASH in a panic context
1731  * @param mtd           MTD device structure
1732  * @param to            offset to write to
1733  * @param len           number of bytes to write
1734  * @param retlen        pointer to variable to store the number of written bytes
1735  * @param buf           the data to write
1736  *
1737  * Write with ECC
1738  */
1739 static int onenand_panic_write(struct mtd_info *mtd, loff_t to, size_t len,
1740                          size_t *retlen, const u_char *buf)
1741 {
1742         struct onenand_chip *this = mtd->priv;
1743         int column, subpage;
1744         int written = 0;
1745         int ret = 0;
1746
1747         if (this->state == FL_PM_SUSPENDED)
1748                 return -EBUSY;
1749
1750         /* Wait for any existing operation to clear */
1751         onenand_panic_wait(mtd);
1752
1753         pr_debug("%s: to = 0x%08x, len = %i\n", __func__, (unsigned int)to,
1754                         (int)len);
1755
1756         /* Initialize retlen, in case of early exit */
1757         *retlen = 0;
1758
1759         /* Do not allow writes past end of device */
1760         if (unlikely((to + len) > mtd->size)) {
1761                 printk(KERN_ERR "%s: Attempt write to past end of device\n",
1762                         __func__);
1763                 return -EINVAL;
1764         }
1765
1766         /* Reject writes, which are not page aligned */
1767         if (unlikely(NOTALIGNED(to) || NOTALIGNED(len))) {
1768                 printk(KERN_ERR "%s: Attempt to write not page aligned data\n",
1769                         __func__);
1770                 return -EINVAL;
1771         }
1772
1773         column = to & (mtd->writesize - 1);
1774
1775         /* Loop until all data write */
1776         while (written < len) {
1777                 int thislen = min_t(int, mtd->writesize - column, len - written);
1778                 u_char *wbuf = (u_char *) buf;
1779
1780                 this->command(mtd, ONENAND_CMD_BUFFERRAM, to, thislen);
1781
1782                 /* Partial page write */
1783                 subpage = thislen < mtd->writesize;
1784                 if (subpage) {
1785                         memset(this->page_buf, 0xff, mtd->writesize);
1786                         memcpy(this->page_buf + column, buf, thislen);
1787                         wbuf = this->page_buf;
1788                 }
1789
1790                 this->write_bufferram(mtd, ONENAND_DATARAM, wbuf, 0, mtd->writesize);
1791                 this->write_bufferram(mtd, ONENAND_SPARERAM, ffchars, 0, mtd->oobsize);
1792
1793                 this->command(mtd, ONENAND_CMD_PROG, to, mtd->writesize);
1794
1795                 onenand_panic_wait(mtd);
1796
1797                 /* In partial page write we don't update bufferram */
1798                 onenand_update_bufferram(mtd, to, !ret && !subpage);
1799                 if (ONENAND_IS_2PLANE(this)) {
1800                         ONENAND_SET_BUFFERRAM1(this);
1801                         onenand_update_bufferram(mtd, to + this->writesize, !ret && !subpage);
1802                 }
1803
1804                 if (ret) {
1805                         printk(KERN_ERR "%s: write failed %d\n", __func__, ret);
1806                         break;
1807                 }
1808
1809                 written += thislen;
1810
1811                 if (written == len)
1812                         break;
1813
1814                 column = 0;
1815                 to += thislen;
1816                 buf += thislen;
1817         }
1818
1819         *retlen = written;
1820         return ret;
1821 }
1822
1823 /**
1824  * onenand_fill_auto_oob - [INTERN] oob auto-placement transfer
1825  * @param mtd           MTD device structure
1826  * @param oob_buf       oob buffer
1827  * @param buf           source address
1828  * @param column        oob offset to write to
1829  * @param thislen       oob length to write
1830  */
1831 static int onenand_fill_auto_oob(struct mtd_info *mtd, u_char *oob_buf,
1832                                   const u_char *buf, int column, int thislen)
1833 {
1834         struct onenand_chip *this = mtd->priv;
1835         struct nand_oobfree *free;
1836         int writecol = column;
1837         int writeend = column + thislen;
1838         int lastgap = 0;
1839         unsigned int i;
1840
1841         free = this->ecclayout->oobfree;
1842         for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES && free->length; i++, free++) {
1843                 if (writecol >= lastgap)
1844                         writecol += free->offset - lastgap;
1845                 if (writeend >= lastgap)
1846                         writeend += free->offset - lastgap;
1847                 lastgap = free->offset + free->length;
1848         }
1849         free = this->ecclayout->oobfree;
1850         for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES && free->length; i++, free++) {
1851                 int free_end = free->offset + free->length;
1852                 if (free->offset < writeend && free_end > writecol) {
1853                         int st = max_t(int,free->offset,writecol);
1854                         int ed = min_t(int,free_end,writeend);
1855                         int n = ed - st;
1856                         memcpy(oob_buf + st, buf, n);
1857                         buf += n;
1858                 } else if (column == 0)
1859                         break;
1860         }
1861         return 0;
1862 }
1863
1864 /**
1865  * onenand_write_ops_nolock - [OneNAND Interface] write main and/or out-of-band
1866  * @param mtd           MTD device structure
1867  * @param to            offset to write to
1868  * @param ops           oob operation description structure
1869  *
1870  * Write main and/or oob with ECC
1871  */
1872 static int onenand_write_ops_nolock(struct mtd_info *mtd, loff_t to,
1873                                 struct mtd_oob_ops *ops)
1874 {
1875         struct onenand_chip *this = mtd->priv;
1876         int written = 0, column, thislen = 0, subpage = 0;
1877         int prev = 0, prevlen = 0, prev_subpage = 0, first = 1;
1878         int oobwritten = 0, oobcolumn, thisooblen, oobsize;
1879         size_t len = ops->len;
1880         size_t ooblen = ops->ooblen;
1881         const u_char *buf = ops->datbuf;
1882         const u_char *oob = ops->oobbuf;
1883         u_char *oobbuf;
1884         int ret = 0, cmd;
1885
1886         pr_debug("%s: to = 0x%08x, len = %i\n", __func__, (unsigned int)to,
1887                         (int)len);
1888
1889         /* Initialize retlen, in case of early exit */
1890         ops->retlen = 0;
1891         ops->oobretlen = 0;
1892
1893         /* Do not allow writes past end of device */
1894         if (unlikely((to + len) > mtd->size)) {
1895                 printk(KERN_ERR "%s: Attempt write to past end of device\n",
1896                         __func__);
1897                 return -EINVAL;
1898         }
1899
1900         /* Reject writes, which are not page aligned */
1901         if (unlikely(NOTALIGNED(to) || NOTALIGNED(len))) {
1902                 printk(KERN_ERR "%s: Attempt to write not page aligned data\n",
1903                         __func__);
1904                 return -EINVAL;
1905         }
1906
1907         /* Check zero length */
1908         if (!len)
1909                 return 0;
1910
1911         if (ops->mode == MTD_OPS_AUTO_OOB)
1912                 oobsize = this->ecclayout->oobavail;
1913         else
1914                 oobsize = mtd->oobsize;
1915
1916         oobcolumn = to & (mtd->oobsize - 1);
1917
1918         column = to & (mtd->writesize - 1);
1919
1920         /* Loop until all data write */
1921         while (1) {
1922                 if (written < len) {
1923                         u_char *wbuf = (u_char *) buf;
1924
1925                         thislen = min_t(int, mtd->writesize - column, len - written);
1926                         thisooblen = min_t(int, oobsize - oobcolumn, ooblen - oobwritten);
1927
1928                         cond_resched();
1929
1930                         this->command(mtd, ONENAND_CMD_BUFFERRAM, to, thislen);
1931
1932                         /* Partial page write */
1933                         subpage = thislen < mtd->writesize;
1934                         if (subpage) {
1935                                 memset(this->page_buf, 0xff, mtd->writesize);
1936                                 memcpy(this->page_buf + column, buf, thislen);
1937                                 wbuf = this->page_buf;
1938                         }
1939
1940                         this->write_bufferram(mtd, ONENAND_DATARAM, wbuf, 0, mtd->writesize);
1941
1942                         if (oob) {
1943                                 oobbuf = this->oob_buf;
1944
1945                                 /* We send data to spare ram with oobsize
1946                                  * to prevent byte access */
1947                                 memset(oobbuf, 0xff, mtd->oobsize);
1948                                 if (ops->mode == MTD_OPS_AUTO_OOB)
1949                                         onenand_fill_auto_oob(mtd, oobbuf, oob, oobcolumn, thisooblen);
1950                                 else
1951                                         memcpy(oobbuf + oobcolumn, oob, thisooblen);
1952
1953                                 oobwritten += thisooblen;
1954                                 oob += thisooblen;
1955                                 oobcolumn = 0;
1956                         } else
1957                                 oobbuf = (u_char *) ffchars;
1958
1959                         this->write_bufferram(mtd, ONENAND_SPARERAM, oobbuf, 0, mtd->oobsize);
1960                 } else
1961                         ONENAND_SET_NEXT_BUFFERRAM(this);
1962
1963                 /*
1964                  * 2 PLANE, MLC, and Flex-OneNAND do not support
1965                  * write-while-program feature.
1966                  */
1967                 if (!ONENAND_IS_2PLANE(this) && !ONENAND_IS_4KB_PAGE(this) && !first) {
1968                         ONENAND_SET_PREV_BUFFERRAM(this);
1969
1970                         ret = this->wait(mtd, FL_WRITING);
1971
1972                         /* In partial page write we don't update bufferram */
1973                         onenand_update_bufferram(mtd, prev, !ret && !prev_subpage);
1974                         if (ret) {
1975                                 written -= prevlen;
1976                                 printk(KERN_ERR "%s: write failed %d\n",
1977                                         __func__, ret);
1978                                 break;
1979                         }
1980
1981                         if (written == len) {
1982                                 /* Only check verify write turn on */
1983                                 ret = onenand_verify(mtd, buf - len, to - len, len);
1984                                 if (ret)
1985                                         printk(KERN_ERR "%s: verify failed %d\n",
1986                                                 __func__, ret);
1987                                 break;
1988                         }
1989
1990                         ONENAND_SET_NEXT_BUFFERRAM(this);
1991                 }
1992
1993                 this->ongoing = 0;
1994                 cmd = ONENAND_CMD_PROG;
1995
1996                 /* Exclude 1st OTP and OTP blocks for cache program feature */
1997                 if (ONENAND_IS_CACHE_PROGRAM(this) &&
1998                     likely(onenand_block(this, to) != 0) &&
1999                     ONENAND_IS_4KB_PAGE(this) &&
2000                     ((written + thislen) < len)) {
2001                         cmd = ONENAND_CMD_2X_CACHE_PROG;
2002                         this->ongoing = 1;
2003                 }
2004
2005                 this->command(mtd, cmd, to, mtd->writesize);
2006
2007                 /*
2008                  * 2 PLANE, MLC, and Flex-OneNAND wait here
2009                  */
2010                 if (ONENAND_IS_2PLANE(this) || ONENAND_IS_4KB_PAGE(this)) {
2011                         ret = this->wait(mtd, FL_WRITING);
2012
2013                         /* In partial page write we don't update bufferram */
2014                         onenand_update_bufferram(mtd, to, !ret && !subpage);
2015                         if (ret) {
2016                                 printk(KERN_ERR "%s: write failed %d\n",
2017                                         __func__, ret);
2018                                 break;
2019                         }
2020
2021                         /* Only check verify write turn on */
2022                         ret = onenand_verify(mtd, buf, to, thislen);
2023                         if (ret) {
2024                                 printk(KERN_ERR "%s: verify failed %d\n",
2025                                         __func__, ret);
2026                                 break;
2027                         }
2028
2029                         written += thislen;
2030
2031                         if (written == len)
2032                                 break;
2033
2034                 } else
2035                         written += thislen;
2036
2037                 column = 0;
2038                 prev_subpage = subpage;
2039                 prev = to;
2040                 prevlen = thislen;
2041                 to += thislen;
2042                 buf += thislen;
2043                 first = 0;
2044         }
2045
2046         /* In error case, clear all bufferrams */
2047         if (written != len)
2048                 onenand_invalidate_bufferram(mtd, 0, -1);
2049
2050         ops->retlen = written;
2051         ops->oobretlen = oobwritten;
2052
2053         return ret;
2054 }
2055
2056
2057 /**
2058  * onenand_write_oob_nolock - [INTERN] OneNAND write out-of-band
2059  * @param mtd           MTD device structure
2060  * @param to            offset to write to
2061  * @param len           number of bytes to write
2062  * @param retlen        pointer to variable to store the number of written bytes
2063  * @param buf           the data to write
2064  * @param mode          operation mode
2065  *
2066  * OneNAND write out-of-band
2067  */
2068 static int onenand_write_oob_nolock(struct mtd_info *mtd, loff_t to,
2069                                     struct mtd_oob_ops *ops)
2070 {
2071         struct onenand_chip *this = mtd->priv;
2072         int column, ret = 0, oobsize;
2073         int written = 0, oobcmd;
2074         u_char *oobbuf;
2075         size_t len = ops->ooblen;
2076         const u_char *buf = ops->oobbuf;
2077         unsigned int mode = ops->mode;
2078
2079         to += ops->ooboffs;
2080
2081         pr_debug("%s: to = 0x%08x, len = %i\n", __func__, (unsigned int)to,
2082                         (int)len);
2083
2084         /* Initialize retlen, in case of early exit */
2085         ops->oobretlen = 0;
2086
2087         if (mode == MTD_OPS_AUTO_OOB)
2088                 oobsize = this->ecclayout->oobavail;
2089         else
2090                 oobsize = mtd->oobsize;
2091
2092         column = to & (mtd->oobsize - 1);
2093
2094         if (unlikely(column >= oobsize)) {
2095                 printk(KERN_ERR "%s: Attempted to start write outside oob\n",
2096                         __func__);
2097                 return -EINVAL;
2098         }
2099
2100         /* For compatibility with NAND: Do not allow write past end of page */
2101         if (unlikely(column + len > oobsize)) {
2102                 printk(KERN_ERR "%s: Attempt to write past end of page\n",
2103                         __func__);
2104                 return -EINVAL;
2105         }
2106
2107         /* Do not allow reads past end of device */
2108         if (unlikely(to >= mtd->size ||
2109                      column + len > ((mtd->size >> this->page_shift) -
2110                                      (to >> this->page_shift)) * oobsize)) {
2111                 printk(KERN_ERR "%s: Attempted to write past end of device\n",
2112                        __func__);
2113                 return -EINVAL;
2114         }
2115
2116         oobbuf = this->oob_buf;
2117
2118         oobcmd = ONENAND_IS_4KB_PAGE(this) ? ONENAND_CMD_PROG : ONENAND_CMD_PROGOOB;
2119
2120         /* Loop until all data write */
2121         while (written < len) {
2122                 int thislen = min_t(int, oobsize, len - written);
2123
2124                 cond_resched();
2125
2126                 this->command(mtd, ONENAND_CMD_BUFFERRAM, to, mtd->oobsize);
2127
2128                 /* We send data to spare ram with oobsize
2129                  * to prevent byte access */
2130                 memset(oobbuf, 0xff, mtd->oobsize);
2131                 if (mode == MTD_OPS_AUTO_OOB)
2132                         onenand_fill_auto_oob(mtd, oobbuf, buf, column, thislen);
2133                 else
2134                         memcpy(oobbuf + column, buf, thislen);
2135                 this->write_bufferram(mtd, ONENAND_SPARERAM, oobbuf, 0, mtd->oobsize);
2136
2137                 if (ONENAND_IS_4KB_PAGE(this)) {
2138                         /* Set main area of DataRAM to 0xff*/
2139                         memset(this->page_buf, 0xff, mtd->writesize);
2140                         this->write_bufferram(mtd, ONENAND_DATARAM,
2141                                          this->page_buf, 0, mtd->writesize);
2142                 }
2143
2144                 this->command(mtd, oobcmd, to, mtd->oobsize);
2145
2146                 onenand_update_bufferram(mtd, to, 0);
2147                 if (ONENAND_IS_2PLANE(this)) {
2148                         ONENAND_SET_BUFFERRAM1(this);
2149                         onenand_update_bufferram(mtd, to + this->writesize, 0);
2150                 }
2151
2152                 ret = this->wait(mtd, FL_WRITING);
2153                 if (ret) {
2154                         printk(KERN_ERR "%s: write failed %d\n", __func__, ret);
2155                         break;
2156                 }
2157
2158                 ret = onenand_verify_oob(mtd, oobbuf, to);
2159                 if (ret) {
2160                         printk(KERN_ERR "%s: verify failed %d\n",
2161                                 __func__, ret);
2162                         break;
2163                 }
2164
2165                 written += thislen;
2166                 if (written == len)
2167                         break;
2168
2169                 to += mtd->writesize;
2170                 buf += thislen;
2171                 column = 0;
2172         }
2173
2174         ops->oobretlen = written;
2175
2176         return ret;
2177 }
2178
2179 /**
2180  * onenand_write - [MTD Interface] write buffer to FLASH
2181  * @param mtd           MTD device structure
2182  * @param to            offset to write to
2183  * @param len           number of bytes to write
2184  * @param retlen        pointer to variable to store the number of written bytes
2185  * @param buf           the data to write
2186  *
2187  * Write with ECC
2188  */
2189 static int onenand_write(struct mtd_info *mtd, loff_t to, size_t len,
2190         size_t *retlen, const u_char *buf)
2191 {
2192         struct mtd_oob_ops ops = {
2193                 .len    = len,
2194                 .ooblen = 0,
2195                 .datbuf = (u_char *) buf,
2196                 .oobbuf = NULL,
2197         };
2198         int ret;
2199
2200         onenand_get_device(mtd, FL_WRITING);
2201         ret = onenand_write_ops_nolock(mtd, to, &ops);
2202         onenand_release_device(mtd);
2203
2204         *retlen = ops.retlen;
2205         return ret;
2206 }
2207
2208 /**
2209  * onenand_write_oob - [MTD Interface] NAND write data and/or out-of-band
2210  * @param mtd:          MTD device structure
2211  * @param to:           offset to write
2212  * @param ops:          oob operation description structure
2213  */
2214 static int onenand_write_oob(struct mtd_info *mtd, loff_t to,
2215                              struct mtd_oob_ops *ops)
2216 {
2217         int ret;
2218
2219         switch (ops->mode) {
2220         case MTD_OPS_PLACE_OOB:
2221         case MTD_OPS_AUTO_OOB:
2222                 break;
2223         case MTD_OPS_RAW:
2224                 /* Not implemented yet */
2225         default:
2226                 return -EINVAL;
2227         }
2228
2229         onenand_get_device(mtd, FL_WRITING);
2230         if (ops->datbuf)
2231                 ret = onenand_write_ops_nolock(mtd, to, ops);
2232         else
2233                 ret = onenand_write_oob_nolock(mtd, to, ops);
2234         onenand_release_device(mtd);
2235
2236         return ret;
2237 }
2238
2239 /**
2240  * onenand_block_isbad_nolock - [GENERIC] Check if a block is marked bad
2241  * @param mtd           MTD device structure
2242  * @param ofs           offset from device start
2243  * @param allowbbt      1, if its allowed to access the bbt area
2244  *
2245  * Check, if the block is bad. Either by reading the bad block table or
2246  * calling of the scan function.
2247  */
2248 static int onenand_block_isbad_nolock(struct mtd_info *mtd, loff_t ofs, int allowbbt)
2249 {
2250         struct onenand_chip *this = mtd->priv;
2251         struct bbm_info *bbm = this->bbm;
2252
2253         /* Return info from the table */
2254         return bbm->isbad_bbt(mtd, ofs, allowbbt);
2255 }
2256
2257
2258 static int onenand_multiblock_erase_verify(struct mtd_info *mtd,
2259                                            struct erase_info *instr)
2260 {
2261         struct onenand_chip *this = mtd->priv;
2262         loff_t addr = instr->addr;
2263         int len = instr->len;
2264         unsigned int block_size = (1 << this->erase_shift);
2265         int ret = 0;
2266
2267         while (len) {
2268                 this->command(mtd, ONENAND_CMD_ERASE_VERIFY, addr, block_size);
2269                 ret = this->wait(mtd, FL_VERIFYING_ERASE);
2270                 if (ret) {
2271                         printk(KERN_ERR "%s: Failed verify, block %d\n",
2272                                __func__, onenand_block(this, addr));
2273                         instr->state = MTD_ERASE_FAILED;
2274                         instr->fail_addr = addr;
2275                         return -1;
2276                 }
2277                 len -= block_size;
2278                 addr += block_size;
2279         }
2280         return 0;
2281 }
2282
2283 /**
2284  * onenand_multiblock_erase - [INTERN] erase block(s) using multiblock erase
2285  * @param mtd           MTD device structure
2286  * @param instr         erase instruction
2287  * @param region        erase region
2288  *
2289  * Erase one or more blocks up to 64 block at a time
2290  */
2291 static int onenand_multiblock_erase(struct mtd_info *mtd,
2292                                     struct erase_info *instr,
2293                                     unsigned int block_size)
2294 {
2295         struct onenand_chip *this = mtd->priv;
2296         loff_t addr = instr->addr;
2297         int len = instr->len;
2298         int eb_count = 0;
2299         int ret = 0;
2300         int bdry_block = 0;
2301
2302         instr->state = MTD_ERASING;
2303
2304         if (ONENAND_IS_DDP(this)) {
2305                 loff_t bdry_addr = this->chipsize >> 1;
2306                 if (addr < bdry_addr && (addr + len) > bdry_addr)
2307                         bdry_block = bdry_addr >> this->erase_shift;
2308         }
2309
2310         /* Pre-check bbs */
2311         while (len) {
2312                 /* Check if we have a bad block, we do not erase bad blocks */
2313                 if (onenand_block_isbad_nolock(mtd, addr, 0)) {
2314                         printk(KERN_WARNING "%s: attempt to erase a bad block "
2315                                "at addr 0x%012llx\n",
2316                                __func__, (unsigned long long) addr);
2317                         instr->state = MTD_ERASE_FAILED;
2318                         return -EIO;
2319                 }
2320                 len -= block_size;
2321                 addr += block_size;
2322         }
2323
2324         len = instr->len;
2325         addr = instr->addr;
2326
2327         /* loop over 64 eb batches */
2328         while (len) {
2329                 struct erase_info verify_instr = *instr;
2330                 int max_eb_count = MB_ERASE_MAX_BLK_COUNT;
2331
2332                 verify_instr.addr = addr;
2333                 verify_instr.len = 0;
2334
2335                 /* do not cross chip boundary */
2336                 if (bdry_block) {
2337                         int this_block = (addr >> this->erase_shift);
2338
2339                         if (this_block < bdry_block) {
2340                                 max_eb_count = min(max_eb_count,
2341                                                    (bdry_block - this_block));
2342                         }
2343                 }
2344
2345                 eb_count = 0;
2346
2347                 while (len > block_size && eb_count < (max_eb_count - 1)) {
2348                         this->command(mtd, ONENAND_CMD_MULTIBLOCK_ERASE,
2349                                       addr, block_size);
2350                         onenand_invalidate_bufferram(mtd, addr, block_size);
2351
2352                         ret = this->wait(mtd, FL_PREPARING_ERASE);
2353                         if (ret) {
2354                                 printk(KERN_ERR "%s: Failed multiblock erase, "
2355                                        "block %d\n", __func__,
2356                                        onenand_block(this, addr));
2357                                 instr->state = MTD_ERASE_FAILED;
2358                                 instr->fail_addr = MTD_FAIL_ADDR_UNKNOWN;
2359                                 return -EIO;
2360                         }
2361
2362                         len -= block_size;
2363                         addr += block_size;
2364                         eb_count++;
2365                 }
2366
2367                 /* last block of 64-eb series */
2368                 cond_resched();
2369                 this->command(mtd, ONENAND_CMD_ERASE, addr, block_size);
2370                 onenand_invalidate_bufferram(mtd, addr, block_size);
2371
2372                 ret = this->wait(mtd, FL_ERASING);
2373                 /* Check if it is write protected */
2374                 if (ret) {
2375                         printk(KERN_ERR "%s: Failed erase, block %d\n",
2376                                __func__, onenand_block(this, addr));
2377                         instr->state = MTD_ERASE_FAILED;
2378                         instr->fail_addr = MTD_FAIL_ADDR_UNKNOWN;
2379                         return -EIO;
2380                 }
2381
2382                 len -= block_size;
2383                 addr += block_size;
2384                 eb_count++;
2385
2386                 /* verify */
2387                 verify_instr.len = eb_count * block_size;
2388                 if (onenand_multiblock_erase_verify(mtd, &verify_instr)) {
2389                         instr->state = verify_instr.state;
2390                         instr->fail_addr = verify_instr.fail_addr;
2391                         return -EIO;
2392                 }
2393
2394         }
2395         return 0;
2396 }
2397
2398
2399 /**
2400  * onenand_block_by_block_erase - [INTERN] erase block(s) using regular erase
2401  * @param mtd           MTD device structure
2402  * @param instr         erase instruction
2403  * @param region        erase region
2404  * @param block_size    erase block size
2405  *
2406  * Erase one or more blocks one block at a time
2407  */
2408 static int onenand_block_by_block_erase(struct mtd_info *mtd,
2409                                         struct erase_info *instr,
2410                                         struct mtd_erase_region_info *region,
2411                                         unsigned int block_size)
2412 {
2413         struct onenand_chip *this = mtd->priv;
2414         loff_t addr = instr->addr;
2415         int len = instr->len;
2416         loff_t region_end = 0;
2417         int ret = 0;
2418
2419         if (region) {
2420                 /* region is set for Flex-OneNAND */
2421                 region_end = region->offset + region->erasesize * region->numblocks;
2422         }
2423
2424         instr->state = MTD_ERASING;
2425
2426         /* Loop through the blocks */
2427         while (len) {
2428                 cond_resched();
2429
2430                 /* Check if we have a bad block, we do not erase bad blocks */
2431                 if (onenand_block_isbad_nolock(mtd, addr, 0)) {
2432                         printk(KERN_WARNING "%s: attempt to erase a bad block "
2433                                         "at addr 0x%012llx\n",
2434                                         __func__, (unsigned long long) addr);
2435                         instr->state = MTD_ERASE_FAILED;
2436                         return -EIO;
2437                 }
2438
2439                 this->command(mtd, ONENAND_CMD_ERASE, addr, block_size);
2440
2441                 onenand_invalidate_bufferram(mtd, addr, block_size);
2442
2443                 ret = this->wait(mtd, FL_ERASING);
2444                 /* Check, if it is write protected */
2445                 if (ret) {
2446                         printk(KERN_ERR "%s: Failed erase, block %d\n",
2447                                 __func__, onenand_block(this, addr));
2448                         instr->state = MTD_ERASE_FAILED;
2449                         instr->fail_addr = addr;
2450                         return -EIO;
2451                 }
2452
2453                 len -= block_size;
2454                 addr += block_size;
2455
2456                 if (region && addr == region_end) {
2457                         if (!len)
2458                                 break;
2459                         region++;
2460
2461                         block_size = region->erasesize;
2462                         region_end = region->offset + region->erasesize * region->numblocks;
2463
2464                         if (len & (block_size - 1)) {
2465                                 /* FIXME: This should be handled at MTD partitioning level. */
2466                                 printk(KERN_ERR "%s: Unaligned address\n",
2467                                         __func__);
2468                                 return -EIO;
2469                         }
2470                 }
2471         }
2472         return 0;
2473 }
2474
2475 /**
2476  * onenand_erase - [MTD Interface] erase block(s)
2477  * @param mtd           MTD device structure
2478  * @param instr         erase instruction
2479  *
2480  * Erase one or more blocks
2481  */
2482 static int onenand_erase(struct mtd_info *mtd, struct erase_info *instr)
2483 {
2484         struct onenand_chip *this = mtd->priv;
2485         unsigned int block_size;
2486         loff_t addr = instr->addr;
2487         loff_t len = instr->len;
2488         int ret = 0;
2489         struct mtd_erase_region_info *region = NULL;
2490         loff_t region_offset = 0;
2491
2492         pr_debug("%s: start=0x%012llx, len=%llu\n", __func__,
2493                         (unsigned long long)instr->addr,
2494                         (unsigned long long)instr->len);
2495
2496         /* Do not allow erase past end of device */
2497         if (unlikely((len + addr) > mtd->size)) {
2498                 printk(KERN_ERR "%s: Erase past end of device\n", __func__);
2499                 return -EINVAL;
2500         }
2501
2502         if (FLEXONENAND(this)) {
2503                 /* Find the eraseregion of this address */
2504                 int i = flexonenand_region(mtd, addr);
2505
2506                 region = &mtd->eraseregions[i];
2507                 block_size = region->erasesize;
2508
2509                 /* Start address within region must align on block boundary.
2510                  * Erase region's start offset is always block start address.
2511                  */
2512                 region_offset = region->offset;
2513         } else
2514                 block_size = 1 << this->erase_shift;
2515
2516         /* Start address must align on block boundary */
2517         if (unlikely((addr - region_offset) & (block_size - 1))) {
2518                 printk(KERN_ERR "%s: Unaligned address\n", __func__);
2519                 return -EINVAL;
2520         }
2521
2522         /* Length must align on block boundary */
2523         if (unlikely(len & (block_size - 1))) {
2524                 printk(KERN_ERR "%s: Length not block aligned\n", __func__);
2525                 return -EINVAL;
2526         }
2527
2528         instr->fail_addr = MTD_FAIL_ADDR_UNKNOWN;
2529
2530         /* Grab the lock and see if the device is available */
2531         onenand_get_device(mtd, FL_ERASING);
2532
2533         if (ONENAND_IS_4KB_PAGE(this) || region ||
2534             instr->len < MB_ERASE_MIN_BLK_COUNT * block_size) {
2535                 /* region is set for Flex-OneNAND (no mb erase) */
2536                 ret = onenand_block_by_block_erase(mtd, instr,
2537                                                    region, block_size);
2538         } else {
2539                 ret = onenand_multiblock_erase(mtd, instr, block_size);
2540         }
2541
2542         /* Deselect and wake up anyone waiting on the device */
2543         onenand_release_device(mtd);
2544
2545         /* Do call back function */
2546         if (!ret) {
2547                 instr->state = MTD_ERASE_DONE;
2548                 mtd_erase_callback(instr);
2549         }
2550
2551         return ret;
2552 }
2553
2554 /**
2555  * onenand_sync - [MTD Interface] sync
2556  * @param mtd           MTD device structure
2557  *
2558  * Sync is actually a wait for chip ready function
2559  */
2560 static void onenand_sync(struct mtd_info *mtd)
2561 {
2562         pr_debug("%s: called\n", __func__);
2563
2564         /* Grab the lock and see if the device is available */
2565         onenand_get_device(mtd, FL_SYNCING);
2566
2567         /* Release it and go back */
2568         onenand_release_device(mtd);
2569 }
2570
2571 /**
2572  * onenand_block_isbad - [MTD Interface] Check whether the block at the given offset is bad
2573  * @param mtd           MTD device structure
2574  * @param ofs           offset relative to mtd start
2575  *
2576  * Check whether the block is bad
2577  */
2578 static int onenand_block_isbad(struct mtd_info *mtd, loff_t ofs)
2579 {
2580         int ret;
2581
2582         /* Check for invalid offset */
2583         if (ofs > mtd->size)
2584                 return -EINVAL;
2585
2586         onenand_get_device(mtd, FL_READING);
2587         ret = onenand_block_isbad_nolock(mtd, ofs, 0);
2588         onenand_release_device(mtd);
2589         return ret;
2590 }
2591
2592 /**
2593  * onenand_default_block_markbad - [DEFAULT] mark a block bad
2594  * @param mtd           MTD device structure
2595  * @param ofs           offset from device start
2596  *
2597  * This is the default implementation, which can be overridden by
2598  * a hardware specific driver.
2599  */
2600 static int onenand_default_block_markbad(struct mtd_info *mtd, loff_t ofs)
2601 {
2602         struct onenand_chip *this = mtd->priv;
2603         struct bbm_info *bbm = this->bbm;
2604         u_char buf[2] = {0, 0};
2605         struct mtd_oob_ops ops = {
2606                 .mode = MTD_OPS_PLACE_OOB,
2607                 .ooblen = 2,
2608                 .oobbuf = buf,
2609                 .ooboffs = 0,
2610         };
2611         int block;
2612
2613         /* Get block number */
2614         block = onenand_block(this, ofs);
2615         if (bbm->bbt)
2616                 bbm->bbt[block >> 2] |= 0x01 << ((block & 0x03) << 1);
2617
2618         /* We write two bytes, so we don't have to mess with 16-bit access */
2619         ofs += mtd->oobsize + (bbm->badblockpos & ~0x01);
2620         /* FIXME : What to do when marking SLC block in partition
2621          *         with MLC erasesize? For now, it is not advisable to
2622          *         create partitions containing both SLC and MLC regions.
2623          */
2624         return onenand_write_oob_nolock(mtd, ofs, &ops);
2625 }
2626
2627 /**
2628  * onenand_block_markbad - [MTD Interface] Mark the block at the given offset as bad
2629  * @param mtd           MTD device structure
2630  * @param ofs           offset relative to mtd start
2631  *
2632  * Mark the block as bad
2633  */
2634 static int onenand_block_markbad(struct mtd_info *mtd, loff_t ofs)
2635 {
2636         struct onenand_chip *this = mtd->priv;
2637         int ret;
2638
2639         ret = onenand_block_isbad(mtd, ofs);
2640         if (ret) {
2641                 /* If it was bad already, return success and do nothing */
2642                 if (ret > 0)
2643                         return 0;
2644                 return ret;
2645         }
2646
2647         onenand_get_device(mtd, FL_WRITING);
2648         ret = this->block_markbad(mtd, ofs);
2649         onenand_release_device(mtd);
2650         return ret;
2651 }
2652
2653 /**
2654  * onenand_do_lock_cmd - [OneNAND Interface] Lock or unlock block(s)
2655  * @param mtd           MTD device structure
2656  * @param ofs           offset relative to mtd start
2657  * @param len           number of bytes to lock or unlock
2658  * @param cmd           lock or unlock command
2659  *
2660  * Lock or unlock one or more blocks
2661  */
2662 static int onenand_do_lock_cmd(struct mtd_info *mtd, loff_t ofs, size_t len, int cmd)
2663 {
2664         struct onenand_chip *this = mtd->priv;
2665         int start, end, block, value, status;
2666         int wp_status_mask;
2667
2668         start = onenand_block(this, ofs);
2669         end = onenand_block(this, ofs + len) - 1;
2670
2671         if (cmd == ONENAND_CMD_LOCK)
2672                 wp_status_mask = ONENAND_WP_LS;
2673         else
2674                 wp_status_mask = ONENAND_WP_US;
2675
2676         /* Continuous lock scheme */
2677         if (this->options & ONENAND_HAS_CONT_LOCK) {
2678                 /* Set start block address */
2679                 this->write_word(start, this->base + ONENAND_REG_START_BLOCK_ADDRESS);
2680                 /* Set end block address */
2681                 this->write_word(end, this->base +  ONENAND_REG_END_BLOCK_ADDRESS);
2682                 /* Write lock command */
2683                 this->command(mtd, cmd, 0, 0);
2684
2685                 /* There's no return value */
2686                 this->wait(mtd, FL_LOCKING);
2687
2688                 /* Sanity check */
2689                 while (this->read_word(this->base + ONENAND_REG_CTRL_STATUS)
2690                     & ONENAND_CTRL_ONGO)
2691                         continue;
2692
2693                 /* Check lock status */
2694                 status = this->read_word(this->base + ONENAND_REG_WP_STATUS);
2695                 if (!(status & wp_status_mask))
2696                         printk(KERN_ERR "%s: wp status = 0x%x\n",
2697                                 __func__, status);
2698
2699                 return 0;
2700         }
2701
2702         /* Block lock scheme */
2703         for (block = start; block < end + 1; block++) {
2704                 /* Set block address */
2705                 value = onenand_block_address(this, block);
2706                 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS1);
2707                 /* Select DataRAM for DDP */
2708                 value = onenand_bufferram_address(this, block);
2709                 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS2);
2710                 /* Set start block address */
2711                 this->write_word(block, this->base + ONENAND_REG_START_BLOCK_ADDRESS);
2712                 /* Write lock command */
2713                 this->command(mtd, cmd, 0, 0);
2714
2715                 /* There's no return value */
2716                 this->wait(mtd, FL_LOCKING);
2717
2718                 /* Sanity check */
2719                 while (this->read_word(this->base + ONENAND_REG_CTRL_STATUS)
2720                     & ONENAND_CTRL_ONGO)
2721                         continue;
2722
2723                 /* Check lock status */
2724                 status = this->read_word(this->base + ONENAND_REG_WP_STATUS);
2725                 if (!(status & wp_status_mask))
2726                         printk(KERN_ERR "%s: block = %d, wp status = 0x%x\n",
2727                                 __func__, block, status);
2728         }
2729
2730         return 0;
2731 }
2732
2733 /**
2734  * onenand_lock - [MTD Interface] Lock block(s)
2735  * @param mtd           MTD device structure
2736  * @param ofs           offset relative to mtd start
2737  * @param len           number of bytes to unlock
2738  *
2739  * Lock one or more blocks
2740  */
2741 static int onenand_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
2742 {
2743         int ret;
2744
2745         onenand_get_device(mtd, FL_LOCKING);
2746         ret = onenand_do_lock_cmd(mtd, ofs, len, ONENAND_CMD_LOCK);
2747         onenand_release_device(mtd);
2748         return ret;
2749 }
2750
2751 /**
2752  * onenand_unlock - [MTD Interface] Unlock block(s)
2753  * @param mtd           MTD device structure
2754  * @param ofs           offset relative to mtd start
2755  * @param len           number of bytes to unlock
2756  *
2757  * Unlock one or more blocks
2758  */
2759 static int onenand_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
2760 {
2761         int ret;
2762
2763         onenand_get_device(mtd, FL_LOCKING);
2764         ret = onenand_do_lock_cmd(mtd, ofs, len, ONENAND_CMD_UNLOCK);
2765         onenand_release_device(mtd);
2766         return ret;
2767 }
2768
2769 /**
2770  * onenand_check_lock_status - [OneNAND Interface] Check lock status
2771  * @param this          onenand chip data structure
2772  *
2773  * Check lock status
2774  */
2775 static int onenand_check_lock_status(struct onenand_chip *this)
2776 {
2777         unsigned int value, block, status;
2778         unsigned int end;
2779
2780         end = this->chipsize >> this->erase_shift;
2781         for (block = 0; block < end; block++) {
2782                 /* Set block address */
2783                 value = onenand_block_address(this, block);
2784                 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS1);
2785                 /* Select DataRAM for DDP */
2786                 value = onenand_bufferram_address(this, block);
2787                 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS2);
2788                 /* Set start block address */
2789                 this->write_word(block, this->base + ONENAND_REG_START_BLOCK_ADDRESS);
2790
2791                 /* Check lock status */
2792                 status = this->read_word(this->base + ONENAND_REG_WP_STATUS);
2793                 if (!(status & ONENAND_WP_US)) {
2794                         printk(KERN_ERR "%s: block = %d, wp status = 0x%x\n",
2795                                 __func__, block, status);
2796                         return 0;
2797                 }
2798         }
2799
2800         return 1;
2801 }
2802
2803 /**
2804  * onenand_unlock_all - [OneNAND Interface] unlock all blocks
2805  * @param mtd           MTD device structure
2806  *
2807  * Unlock all blocks
2808  */
2809 static void onenand_unlock_all(struct mtd_info *mtd)
2810 {
2811         struct onenand_chip *this = mtd->priv;
2812         loff_t ofs = 0;
2813         loff_t len = mtd->size;
2814
2815         if (this->options & ONENAND_HAS_UNLOCK_ALL) {
2816                 /* Set start block address */
2817                 this->write_word(0, this->base + ONENAND_REG_START_BLOCK_ADDRESS);
2818                 /* Write unlock command */
2819                 this->command(mtd, ONENAND_CMD_UNLOCK_ALL, 0, 0);
2820
2821                 /* There's no return value */
2822                 this->wait(mtd, FL_LOCKING);
2823
2824                 /* Sanity check */
2825                 while (this->read_word(this->base + ONENAND_REG_CTRL_STATUS)
2826                     & ONENAND_CTRL_ONGO)
2827                         continue;
2828
2829                 /* Don't check lock status */
2830                 if (this->options & ONENAND_SKIP_UNLOCK_CHECK)
2831                         return;
2832
2833                 /* Check lock status */
2834                 if (onenand_check_lock_status(this))
2835                         return;
2836
2837                 /* Workaround for all block unlock in DDP */
2838                 if (ONENAND_IS_DDP(this) && !FLEXONENAND(this)) {
2839                         /* All blocks on another chip */
2840                         ofs = this->chipsize >> 1;
2841                         len = this->chipsize >> 1;
2842                 }
2843         }
2844
2845         onenand_do_lock_cmd(mtd, ofs, len, ONENAND_CMD_UNLOCK);
2846 }
2847
2848 #ifdef CONFIG_MTD_ONENAND_OTP
2849
2850 /**
2851  * onenand_otp_command - Send OTP specific command to OneNAND device
2852  * @param mtd    MTD device structure
2853  * @param cmd    the command to be sent
2854  * @param addr   offset to read from or write to
2855  * @param len    number of bytes to read or write
2856  */
2857 static int onenand_otp_command(struct mtd_info *mtd, int cmd, loff_t addr,
2858                                 size_t len)
2859 {
2860         struct onenand_chip *this = mtd->priv;
2861         int value, block, page;
2862
2863         /* Address translation */
2864         switch (cmd) {
2865         case ONENAND_CMD_OTP_ACCESS:
2866                 block = (int) (addr >> this->erase_shift);
2867                 page = -1;
2868                 break;
2869
2870         default:
2871                 block = (int) (addr >> this->erase_shift);
2872                 page = (int) (addr >> this->page_shift);
2873
2874                 if (ONENAND_IS_2PLANE(this)) {
2875                         /* Make the even block number */
2876                         block &= ~1;
2877                         /* Is it the odd plane? */
2878                         if (addr & this->writesize)
2879                                 block++;
2880                         page >>= 1;
2881                 }
2882                 page &= this->page_mask;
2883                 break;
2884         }
2885
2886         if (block != -1) {
2887                 /* Write 'DFS, FBA' of Flash */
2888                 value = onenand_block_address(this, block);
2889                 this->write_word(value, this->base +
2890                                 ONENAND_REG_START_ADDRESS1);
2891         }
2892
2893         if (page != -1) {
2894                 /* Now we use page size operation */
2895                 int sectors = 4, count = 4;
2896                 int dataram;
2897
2898                 switch (cmd) {
2899                 default:
2900                         if (ONENAND_IS_2PLANE(this) && cmd == ONENAND_CMD_PROG)
2901                                 cmd = ONENAND_CMD_2X_PROG;
2902                         dataram = ONENAND_CURRENT_BUFFERRAM(this);
2903                         break;
2904                 }
2905
2906                 /* Write 'FPA, FSA' of Flash */
2907                 value = onenand_page_address(page, sectors);
2908                 this->write_word(value, this->base +
2909                                 ONENAND_REG_START_ADDRESS8);
2910
2911                 /* Write 'BSA, BSC' of DataRAM */
2912                 value = onenand_buffer_address(dataram, sectors, count);
2913                 this->write_word(value, this->base + ONENAND_REG_START_BUFFER);
2914         }
2915
2916         /* Interrupt clear */
2917         this->write_word(ONENAND_INT_CLEAR, this->base + ONENAND_REG_INTERRUPT);
2918
2919         /* Write command */
2920         this->write_word(cmd, this->base + ONENAND_REG_COMMAND);
2921
2922         return 0;
2923 }
2924
2925 /**
2926  * onenand_otp_write_oob_nolock - [INTERN] OneNAND write out-of-band, specific to OTP
2927  * @param mtd           MTD device structure
2928  * @param to            offset to write to
2929  * @param len           number of bytes to write
2930  * @param retlen        pointer to variable to store the number of written bytes
2931  * @param buf           the data to write
2932  *
2933  * OneNAND write out-of-band only for OTP
2934  */
2935 static int onenand_otp_write_oob_nolock(struct mtd_info *mtd, loff_t to,
2936                                     struct mtd_oob_ops *ops)
2937 {
2938         struct onenand_chip *this = mtd->priv;
2939         int column, ret = 0, oobsize;
2940         int written = 0;
2941         u_char *oobbuf;
2942         size_t len = ops->ooblen;
2943         const u_char *buf = ops->oobbuf;
2944         int block, value, status;
2945
2946         to += ops->ooboffs;
2947
2948         /* Initialize retlen, in case of early exit */
2949         ops->oobretlen = 0;
2950
2951         oobsize = mtd->oobsize;
2952
2953         column = to & (mtd->oobsize - 1);
2954
2955         oobbuf = this->oob_buf;
2956
2957         /* Loop until all data write */
2958         while (written < len) {
2959                 int thislen = min_t(int, oobsize, len - written);
2960
2961                 cond_resched();
2962
2963                 block = (int) (to >> this->erase_shift);
2964                 /*
2965                  * Write 'DFS, FBA' of Flash
2966                  * Add: F100h DQ=DFS, FBA
2967                  */
2968
2969                 value = onenand_block_address(this, block);
2970                 this->write_word(value, this->base +
2971                                 ONENAND_REG_START_ADDRESS1);
2972
2973                 /*
2974                  * Select DataRAM for DDP
2975                  * Add: F101h DQ=DBS
2976                  */
2977
2978                 value = onenand_bufferram_address(this, block);
2979                 this->write_word(value, this->base +
2980                                 ONENAND_REG_START_ADDRESS2);
2981                 ONENAND_SET_NEXT_BUFFERRAM(this);
2982
2983                 /*
2984                  * Enter OTP access mode
2985                  */
2986                 this->command(mtd, ONENAND_CMD_OTP_ACCESS, 0, 0);
2987                 this->wait(mtd, FL_OTPING);
2988
2989                 /* We send data to spare ram with oobsize
2990                  * to prevent byte access */
2991                 memcpy(oobbuf + column, buf, thislen);
2992
2993                 /*
2994                  * Write Data into DataRAM
2995                  * Add: 8th Word
2996                  * in sector0/spare/page0
2997                  * DQ=XXFCh
2998                  */
2999                 this->write_bufferram(mtd, ONENAND_SPARERAM,
3000                                         oobbuf, 0, mtd->oobsize);
3001
3002                 onenand_otp_command(mtd, ONENAND_CMD_PROGOOB, to, mtd->oobsize);
3003                 onenand_update_bufferram(mtd, to, 0);
3004                 if (ONENAND_IS_2PLANE(this)) {
3005                         ONENAND_SET_BUFFERRAM1(this);
3006                         onenand_update_bufferram(mtd, to + this->writesize, 0);
3007                 }
3008
3009                 ret = this->wait(mtd, FL_WRITING);
3010                 if (ret) {
3011                         printk(KERN_ERR "%s: write failed %d\n", __func__, ret);
3012                         break;
3013                 }
3014
3015                 /* Exit OTP access mode */
3016                 this->command(mtd, ONENAND_CMD_RESET, 0, 0);
3017                 this->wait(mtd, FL_RESETING);
3018
3019                 status = this->read_word(this->base + ONENAND_REG_CTRL_STATUS);
3020                 status &= 0x60;
3021
3022                 if (status == 0x60) {
3023                         printk(KERN_DEBUG "\nBLOCK\tSTATUS\n");
3024                         printk(KERN_DEBUG "1st Block\tLOCKED\n");
3025                         printk(KERN_DEBUG "OTP Block\tLOCKED\n");
3026                 } else if (status == 0x20) {
3027                         printk(KERN_DEBUG "\nBLOCK\tSTATUS\n");
3028                         printk(KERN_DEBUG "1st Block\tLOCKED\n");
3029                         printk(KERN_DEBUG "OTP Block\tUN-LOCKED\n");
3030                 } else if (status == 0x40) {
3031                         printk(KERN_DEBUG "\nBLOCK\tSTATUS\n");
3032                         printk(KERN_DEBUG "1st Block\tUN-LOCKED\n");
3033                         printk(KERN_DEBUG "OTP Block\tLOCKED\n");
3034                 } else {
3035                         printk(KERN_DEBUG "Reboot to check\n");
3036                 }
3037
3038                 written += thislen;
3039                 if (written == len)
3040                         break;
3041
3042                 to += mtd->writesize;
3043                 buf += thislen;
3044                 column = 0;
3045         }
3046
3047         ops->oobretlen = written;
3048
3049         return ret;
3050 }
3051
3052 /* Internal OTP operation */
3053 typedef int (*otp_op_t)(struct mtd_info *mtd, loff_t form, size_t len,
3054                 size_t *retlen, u_char *buf);
3055
3056 /**
3057  * do_otp_read - [DEFAULT] Read OTP block area
3058  * @param mtd           MTD device structure
3059  * @param from          The offset to read
3060  * @param len           number of bytes to read
3061  * @param retlen        pointer to variable to store the number of readbytes
3062  * @param buf           the databuffer to put/get data
3063  *
3064  * Read OTP block area.
3065  */
3066 static int do_otp_read(struct mtd_info *mtd, loff_t from, size_t len,
3067                 size_t *retlen, u_char *buf)
3068 {
3069         struct onenand_chip *this = mtd->priv;
3070         struct mtd_oob_ops ops = {
3071                 .len    = len,
3072                 .ooblen = 0,
3073                 .datbuf = buf,
3074                 .oobbuf = NULL,
3075         };
3076         int ret;
3077
3078         /* Enter OTP access mode */
3079         this->command(mtd, ONENAND_CMD_OTP_ACCESS, 0, 0);
3080         this->wait(mtd, FL_OTPING);
3081
3082         ret = ONENAND_IS_4KB_PAGE(this) ?
3083                 onenand_mlc_read_ops_nolock(mtd, from, &ops) :
3084                 onenand_read_ops_nolock(mtd, from, &ops);
3085
3086         /* Exit OTP access mode */
3087         this->command(mtd, ONENAND_CMD_RESET, 0, 0);
3088         this->wait(mtd, FL_RESETING);
3089
3090         return ret;
3091 }
3092
3093 /**
3094  * do_otp_write - [DEFAULT] Write OTP block area
3095  * @param mtd           MTD device structure
3096  * @param to            The offset to write
3097  * @param len           number of bytes to write
3098  * @param retlen        pointer to variable to store the number of write bytes
3099  * @param buf           the databuffer to put/get data
3100  *
3101  * Write OTP block area.
3102  */
3103 static int do_otp_write(struct mtd_info *mtd, loff_t to, size_t len,
3104                 size_t *retlen, u_char *buf)
3105 {
3106         struct onenand_chip *this = mtd->priv;
3107         unsigned char *pbuf = buf;
3108         int ret;
3109         struct mtd_oob_ops ops;
3110
3111         /* Force buffer page aligned */
3112         if (len < mtd->writesize) {
3113                 memcpy(this->page_buf, buf, len);
3114                 memset(this->page_buf + len, 0xff, mtd->writesize - len);
3115                 pbuf = this->page_buf;
3116                 len = mtd->writesize;
3117         }
3118
3119         /* Enter OTP access mode */
3120         this->command(mtd, ONENAND_CMD_OTP_ACCESS, 0, 0);
3121         this->wait(mtd, FL_OTPING);
3122
3123         ops.len = len;
3124         ops.ooblen = 0;
3125         ops.datbuf = pbuf;
3126         ops.oobbuf = NULL;
3127         ret = onenand_write_ops_nolock(mtd, to, &ops);
3128         *retlen = ops.retlen;
3129
3130         /* Exit OTP access mode */
3131         this->command(mtd, ONENAND_CMD_RESET, 0, 0);
3132         this->wait(mtd, FL_RESETING);
3133
3134         return ret;
3135 }
3136
3137 /**
3138  * do_otp_lock - [DEFAULT] Lock OTP block area
3139  * @param mtd           MTD device structure
3140  * @param from          The offset to lock
3141  * @param len           number of bytes to lock
3142  * @param retlen        pointer to variable to store the number of lock bytes
3143  * @param buf           the databuffer to put/get data
3144  *
3145  * Lock OTP block area.
3146  */
3147 static int do_otp_lock(struct mtd_info *mtd, loff_t from, size_t len,
3148                 size_t *retlen, u_char *buf)
3149 {
3150         struct onenand_chip *this = mtd->priv;
3151         struct mtd_oob_ops ops;
3152         int ret;
3153
3154         if (FLEXONENAND(this)) {
3155
3156                 /* Enter OTP access mode */
3157                 this->command(mtd, ONENAND_CMD_OTP_ACCESS, 0, 0);
3158                 this->wait(mtd, FL_OTPING);
3159                 /*
3160                  * For Flex-OneNAND, we write lock mark to 1st word of sector 4 of
3161                  * main area of page 49.
3162                  */
3163                 ops.len = mtd->writesize;
3164                 ops.ooblen = 0;
3165                 ops.datbuf = buf;
3166                 ops.oobbuf = NULL;
3167                 ret = onenand_write_ops_nolock(mtd, mtd->writesize * 49, &ops);
3168                 *retlen = ops.retlen;
3169
3170                 /* Exit OTP access mode */
3171                 this->command(mtd, ONENAND_CMD_RESET, 0, 0);
3172                 this->wait(mtd, FL_RESETING);
3173         } else {
3174                 ops.mode = MTD_OPS_PLACE_OOB;
3175                 ops.ooblen = len;
3176                 ops.oobbuf = buf;
3177                 ops.ooboffs = 0;
3178                 ret = onenand_otp_write_oob_nolock(mtd, from, &ops);
3179                 *retlen = ops.oobretlen;
3180         }
3181
3182         return ret;
3183 }
3184
3185 /**
3186  * onenand_otp_walk - [DEFAULT] Handle OTP operation
3187  * @param mtd           MTD device structure
3188  * @param from          The offset to read/write
3189  * @param len           number of bytes to read/write
3190  * @param retlen        pointer to variable to store the number of read bytes
3191  * @param buf           the databuffer to put/get data
3192  * @param action        do given action
3193  * @param mode          specify user and factory
3194  *
3195  * Handle OTP operation.
3196  */
3197 static int onenand_otp_walk(struct mtd_info *mtd, loff_t from, size_t len,
3198                         size_t *retlen, u_char *buf,
3199                         otp_op_t action, int mode)
3200 {
3201         struct onenand_chip *this = mtd->priv;
3202         int otp_pages;
3203         int density;
3204         int ret = 0;
3205
3206         *retlen = 0;
3207
3208         density = onenand_get_density(this->device_id);
3209         if (density < ONENAND_DEVICE_DENSITY_512Mb)
3210                 otp_pages = 20;
3211         else
3212                 otp_pages = 50;
3213
3214         if (mode == MTD_OTP_FACTORY) {
3215                 from += mtd->writesize * otp_pages;
3216                 otp_pages = ONENAND_PAGES_PER_BLOCK - otp_pages;
3217         }
3218
3219         /* Check User/Factory boundary */
3220         if (mode == MTD_OTP_USER) {
3221                 if (mtd->writesize * otp_pages < from + len)
3222                         return 0;
3223         } else {
3224                 if (mtd->writesize * otp_pages <  len)
3225                         return 0;
3226         }
3227
3228         onenand_get_device(mtd, FL_OTPING);
3229         while (len > 0 && otp_pages > 0) {
3230                 if (!action) {  /* OTP Info functions */
3231                         struct otp_info *otpinfo;
3232
3233                         len -= sizeof(struct otp_info);
3234                         if (len <= 0) {
3235                                 ret = -ENOSPC;
3236                                 break;
3237                         }
3238
3239                         otpinfo = (struct otp_info *) buf;
3240                         otpinfo->start = from;
3241                         otpinfo->length = mtd->writesize;
3242                         otpinfo->locked = 0;
3243
3244                         from += mtd->writesize;
3245                         buf += sizeof(struct otp_info);
3246                         *retlen += sizeof(struct otp_info);
3247                 } else {
3248                         size_t tmp_retlen;
3249
3250                         ret = action(mtd, from, len, &tmp_retlen, buf);
3251
3252                         buf += tmp_retlen;
3253                         len -= tmp_retlen;
3254                         *retlen += tmp_retlen;
3255
3256                         if (ret)
3257                                 break;
3258                 }
3259                 otp_pages--;
3260         }
3261         onenand_release_device(mtd);
3262
3263         return ret;
3264 }
3265
3266 /**
3267  * onenand_get_fact_prot_info - [MTD Interface] Read factory OTP info
3268  * @param mtd           MTD device structure
3269  * @param buf           the databuffer to put/get data
3270  * @param len           number of bytes to read
3271  *
3272  * Read factory OTP info.
3273  */
3274 static int onenand_get_fact_prot_info(struct mtd_info *mtd,
3275                         struct otp_info *buf, size_t len)
3276 {
3277         size_t retlen;
3278         int ret;
3279
3280         ret = onenand_otp_walk(mtd, 0, len, &retlen, (u_char *) buf, NULL, MTD_OTP_FACTORY);
3281
3282         return ret ? : retlen;
3283 }
3284
3285 /**
3286  * onenand_read_fact_prot_reg - [MTD Interface] Read factory OTP area
3287  * @param mtd           MTD device structure
3288  * @param from          The offset to read
3289  * @param len           number of bytes to read
3290  * @param retlen        pointer to variable to store the number of read bytes
3291  * @param buf           the databuffer to put/get data
3292  *
3293  * Read factory OTP area.
3294  */
3295 static int onenand_read_fact_prot_reg(struct mtd_info *mtd, loff_t from,
3296                         size_t len, size_t *retlen, u_char *buf)
3297 {
3298         return onenand_otp_walk(mtd, from, len, retlen, buf, do_otp_read, MTD_OTP_FACTORY);
3299 }
3300
3301 /**
3302  * onenand_get_user_prot_info - [MTD Interface] Read user OTP info
3303  * @param mtd           MTD device structure
3304  * @param buf           the databuffer to put/get data
3305  * @param len           number of bytes to read
3306  *
3307  * Read user OTP info.
3308  */
3309 static int onenand_get_user_prot_info(struct mtd_info *mtd,
3310                         struct otp_info *buf, size_t len)
3311 {
3312         size_t retlen;
3313         int ret;
3314
3315         ret = onenand_otp_walk(mtd, 0, len, &retlen, (u_char *) buf, NULL, MTD_OTP_USER);
3316
3317         return ret ? : retlen;
3318 }
3319
3320 /**
3321  * onenand_read_user_prot_reg - [MTD Interface] Read user OTP area
3322  * @param mtd           MTD device structure
3323  * @param from          The offset to read
3324  * @param len           number of bytes to read
3325  * @param retlen        pointer to variable to store the number of read bytes
3326  * @param buf           the databuffer to put/get data
3327  *
3328  * Read user OTP area.
3329  */
3330 static int onenand_read_user_prot_reg(struct mtd_info *mtd, loff_t from,
3331                         size_t len, size_t *retlen, u_char *buf)
3332 {
3333         return onenand_otp_walk(mtd, from, len, retlen, buf, do_otp_read, MTD_OTP_USER);
3334 }
3335
3336 /**
3337  * onenand_write_user_prot_reg - [MTD Interface] Write user OTP area
3338  * @param mtd           MTD device structure
3339  * @param from          The offset to write
3340  * @param len           number of bytes to write
3341  * @param retlen        pointer to variable to store the number of write bytes
3342  * @param buf           the databuffer to put/get data
3343  *
3344  * Write user OTP area.
3345  */
3346 static int onenand_write_user_prot_reg(struct mtd_info *mtd, loff_t from,
3347                         size_t len, size_t *retlen, u_char *buf)
3348 {
3349         return onenand_otp_walk(mtd, from, len, retlen, buf, do_otp_write, MTD_OTP_USER);
3350 }
3351
3352 /**
3353  * onenand_lock_user_prot_reg - [MTD Interface] Lock user OTP area
3354  * @param mtd           MTD device structure
3355  * @param from          The offset to lock
3356  * @param len           number of bytes to unlock
3357  *
3358  * Write lock mark on spare area in page 0 in OTP block
3359  */
3360 static int onenand_lock_user_prot_reg(struct mtd_info *mtd, loff_t from,
3361                         size_t len)
3362 {
3363         struct onenand_chip *this = mtd->priv;
3364         u_char *buf = FLEXONENAND(this) ? this->page_buf : this->oob_buf;
3365         size_t retlen;
3366         int ret;
3367         unsigned int otp_lock_offset = ONENAND_OTP_LOCK_OFFSET;
3368
3369         memset(buf, 0xff, FLEXONENAND(this) ? this->writesize
3370                                                  : mtd->oobsize);
3371         /*
3372          * Write lock mark to 8th word of sector0 of page0 of the spare0.
3373          * We write 16 bytes spare area instead of 2 bytes.
3374          * For Flex-OneNAND, we write lock mark to 1st word of sector 4 of
3375          * main area of page 49.
3376          */
3377
3378         from = 0;
3379         len = FLEXONENAND(this) ? mtd->writesize : 16;
3380
3381         /*
3382          * Note: OTP lock operation
3383          *       OTP block : 0xXXFC                     XX 1111 1100
3384          *       1st block : 0xXXF3 (If chip support)   XX 1111 0011
3385          *       Both      : 0xXXF0 (If chip support)   XX 1111 0000
3386          */
3387         if (FLEXONENAND(this))
3388                 otp_lock_offset = FLEXONENAND_OTP_LOCK_OFFSET;
3389
3390         /* ONENAND_OTP_AREA | ONENAND_OTP_BLOCK0 | ONENAND_OTP_AREA_BLOCK0 */
3391         if (otp == 1)
3392                 buf[otp_lock_offset] = 0xFC;
3393         else if (otp == 2)
3394                 buf[otp_lock_offset] = 0xF3;
3395         else if (otp == 3)
3396                 buf[otp_lock_offset] = 0xF0;
3397         else if (otp != 0)
3398                 printk(KERN_DEBUG "[OneNAND] Invalid option selected for OTP\n");
3399
3400         ret = onenand_otp_walk(mtd, from, len, &retlen, buf, do_otp_lock, MTD_OTP_USER);
3401
3402         return ret ? : retlen;
3403 }
3404
3405 #endif  /* CONFIG_MTD_ONENAND_OTP */
3406
3407 /**
3408  * onenand_check_features - Check and set OneNAND features
3409  * @param mtd           MTD data structure
3410  *
3411  * Check and set OneNAND features
3412  * - lock scheme
3413  * - two plane
3414  */
3415 static void onenand_check_features(struct mtd_info *mtd)
3416 {
3417         struct onenand_chip *this = mtd->priv;
3418         unsigned int density, process, numbufs;
3419
3420         /* Lock scheme depends on density and process */
3421         density = onenand_get_density(this->device_id);
3422         process = this->version_id >> ONENAND_VERSION_PROCESS_SHIFT;
3423         numbufs = this->read_word(this->base + ONENAND_REG_NUM_BUFFERS) >> 8;
3424
3425         /* Lock scheme */
3426         switch (density) {
3427         case ONENAND_DEVICE_DENSITY_4Gb:
3428                 if (ONENAND_IS_DDP(this))
3429                         this->options |= ONENAND_HAS_2PLANE;
3430                 else if (numbufs == 1) {
3431                         this->options |= ONENAND_HAS_4KB_PAGE;
3432                         this->options |= ONENAND_HAS_CACHE_PROGRAM;
3433                         /*
3434                          * There are two different 4KiB pagesize chips
3435                          * and no way to detect it by H/W config values.
3436                          *
3437                          * To detect the correct NOP for each chips,
3438                          * It should check the version ID as workaround.
3439                          *
3440                          * Now it has as following
3441                          * KFM4G16Q4M has NOP 4 with version ID 0x0131
3442                          * KFM4G16Q5M has NOP 1 with versoin ID 0x013e
3443                          */
3444                         if ((this->version_id & 0xf) == 0xe)
3445                                 this->options |= ONENAND_HAS_NOP_1;
3446                 }
3447
3448         case ONENAND_DEVICE_DENSITY_2Gb:
3449                 /* 2Gb DDP does not have 2 plane */
3450                 if (!ONENAND_IS_DDP(this))
3451                         this->options |= ONENAND_HAS_2PLANE;
3452                 this->options |= ONENAND_HAS_UNLOCK_ALL;
3453
3454         case ONENAND_DEVICE_DENSITY_1Gb:
3455                 /* A-Die has all block unlock */
3456                 if (process)
3457                         this->options |= ONENAND_HAS_UNLOCK_ALL;
3458                 break;
3459
3460         default:
3461                 /* Some OneNAND has continuous lock scheme */
3462                 if (!process)
3463                         this->options |= ONENAND_HAS_CONT_LOCK;
3464                 break;
3465         }
3466
3467         /* The MLC has 4KiB pagesize. */
3468         if (ONENAND_IS_MLC(this))
3469                 this->options |= ONENAND_HAS_4KB_PAGE;
3470
3471         if (ONENAND_IS_4KB_PAGE(this))
3472                 this->options &= ~ONENAND_HAS_2PLANE;
3473
3474         if (FLEXONENAND(this)) {
3475                 this->options &= ~ONENAND_HAS_CONT_LOCK;
3476                 this->options |= ONENAND_HAS_UNLOCK_ALL;
3477         }
3478
3479         if (this->options & ONENAND_HAS_CONT_LOCK)
3480                 printk(KERN_DEBUG "Lock scheme is Continuous Lock\n");
3481         if (this->options & ONENAND_HAS_UNLOCK_ALL)
3482                 printk(KERN_DEBUG "Chip support all block unlock\n");
3483         if (this->options & ONENAND_HAS_2PLANE)
3484                 printk(KERN_DEBUG "Chip has 2 plane\n");
3485         if (this->options & ONENAND_HAS_4KB_PAGE)
3486                 printk(KERN_DEBUG "Chip has 4KiB pagesize\n");
3487         if (this->options & ONENAND_HAS_CACHE_PROGRAM)
3488                 printk(KERN_DEBUG "Chip has cache program feature\n");
3489 }
3490
3491 /**
3492  * onenand_print_device_info - Print device & version ID
3493  * @param device        device ID
3494  * @param version       version ID
3495  *
3496  * Print device & version ID
3497  */
3498 static void onenand_print_device_info(int device, int version)
3499 {
3500         int vcc, demuxed, ddp, density, flexonenand;
3501
3502         vcc = device & ONENAND_DEVICE_VCC_MASK;
3503         demuxed = device & ONENAND_DEVICE_IS_DEMUX;
3504         ddp = device & ONENAND_DEVICE_IS_DDP;
3505         density = onenand_get_density(device);
3506         flexonenand = device & DEVICE_IS_FLEXONENAND;
3507         printk(KERN_INFO "%s%sOneNAND%s %dMB %sV 16-bit (0x%02x)\n",
3508                 demuxed ? "" : "Muxed ",
3509                 flexonenand ? "Flex-" : "",
3510                 ddp ? "(DDP)" : "",
3511                 (16 << density),
3512                 vcc ? "2.65/3.3" : "1.8",
3513                 device);
3514         printk(KERN_INFO "OneNAND version = 0x%04x\n", version);
3515 }
3516
3517 static const struct onenand_manufacturers onenand_manuf_ids[] = {
3518         {ONENAND_MFR_SAMSUNG, "Samsung"},
3519         {ONENAND_MFR_NUMONYX, "Numonyx"},
3520 };
3521
3522 /**
3523  * onenand_check_maf - Check manufacturer ID
3524  * @param manuf         manufacturer ID
3525  *
3526  * Check manufacturer ID
3527  */
3528 static int onenand_check_maf(int manuf)
3529 {
3530         int size = ARRAY_SIZE(onenand_manuf_ids);
3531         char *name;
3532         int i;
3533
3534         for (i = 0; i < size; i++)
3535                 if (manuf == onenand_manuf_ids[i].id)
3536                         break;
3537
3538         if (i < size)
3539                 name = onenand_manuf_ids[i].name;
3540         else
3541                 name = "Unknown";
3542
3543         printk(KERN_DEBUG "OneNAND Manufacturer: %s (0x%0x)\n", name, manuf);
3544
3545         return (i == size);
3546 }
3547
3548 /**
3549 * flexonenand_get_boundary      - Reads the SLC boundary
3550 * @param onenand_info           - onenand info structure
3551 **/
3552 static int flexonenand_get_boundary(struct mtd_info *mtd)
3553 {
3554         struct onenand_chip *this = mtd->priv;
3555         unsigned die, bdry;
3556         int ret, syscfg, locked;
3557
3558         /* Disable ECC */
3559         syscfg = this->read_word(this->base + ONENAND_REG_SYS_CFG1);
3560         this->write_word((syscfg | 0x0100), this->base + ONENAND_REG_SYS_CFG1);
3561
3562         for (die = 0; die < this->dies; die++) {
3563                 this->command(mtd, FLEXONENAND_CMD_PI_ACCESS, die, 0);
3564                 this->wait(mtd, FL_SYNCING);
3565
3566                 this->command(mtd, FLEXONENAND_CMD_READ_PI, die, 0);
3567                 ret = this->wait(mtd, FL_READING);
3568
3569                 bdry = this->read_word(this->base + ONENAND_DATARAM);
3570                 if ((bdry >> FLEXONENAND_PI_UNLOCK_SHIFT) == 3)
3571                         locked = 0;
3572                 else
3573                         locked = 1;
3574                 this->boundary[die] = bdry & FLEXONENAND_PI_MASK;
3575
3576                 this->command(mtd, ONENAND_CMD_RESET, 0, 0);
3577                 ret = this->wait(mtd, FL_RESETING);
3578
3579                 printk(KERN_INFO "Die %d boundary: %d%s\n", die,
3580                        this->boundary[die], locked ? "(Locked)" : "(Unlocked)");
3581         }
3582
3583         /* Enable ECC */
3584         this->write_word(syscfg, this->base + ONENAND_REG_SYS_CFG1);
3585         return 0;
3586 }
3587
3588 /**
3589  * flexonenand_get_size - Fill up fields in onenand_chip and mtd_info
3590  *                        boundary[], diesize[], mtd->size, mtd->erasesize
3591  * @param mtd           - MTD device structure
3592  */
3593 static void flexonenand_get_size(struct mtd_info *mtd)
3594 {
3595         struct onenand_chip *this = mtd->priv;
3596         int die, i, eraseshift, density;
3597         int blksperdie, maxbdry;
3598         loff_t ofs;
3599
3600         density = onenand_get_density(this->device_id);
3601         blksperdie = ((loff_t)(16 << density) << 20) >> (this->erase_shift);
3602         blksperdie >>= ONENAND_IS_DDP(this) ? 1 : 0;
3603         maxbdry = blksperdie - 1;
3604         eraseshift = this->erase_shift - 1;
3605
3606         mtd->numeraseregions = this->dies << 1;
3607
3608         /* This fills up the device boundary */
3609         flexonenand_get_boundary(mtd);
3610         die = ofs = 0;
3611         i = -1;
3612         for (; die < this->dies; die++) {
3613                 if (!die || this->boundary[die-1] != maxbdry) {
3614                         i++;
3615                         mtd->eraseregions[i].offset = ofs;
3616                         mtd->eraseregions[i].erasesize = 1 << eraseshift;
3617                         mtd->eraseregions[i].numblocks =
3618                                                         this->boundary[die] + 1;
3619                         ofs += mtd->eraseregions[i].numblocks << eraseshift;
3620                         eraseshift++;
3621                 } else {
3622                         mtd->numeraseregions -= 1;
3623                         mtd->eraseregions[i].numblocks +=
3624                                                         this->boundary[die] + 1;
3625                         ofs += (this->boundary[die] + 1) << (eraseshift - 1);
3626                 }
3627                 if (this->boundary[die] != maxbdry) {
3628                         i++;
3629                         mtd->eraseregions[i].offset = ofs;
3630                         mtd->eraseregions[i].erasesize = 1 << eraseshift;
3631                         mtd->eraseregions[i].numblocks = maxbdry ^
3632                                                          this->boundary[die];
3633                         ofs += mtd->eraseregions[i].numblocks << eraseshift;
3634                         eraseshift--;
3635                 } else
3636                         mtd->numeraseregions -= 1;
3637         }
3638
3639         /* Expose MLC erase size except when all blocks are SLC */
3640         mtd->erasesize = 1 << this->erase_shift;
3641         if (mtd->numeraseregions == 1)
3642                 mtd->erasesize >>= 1;
3643
3644         printk(KERN_INFO "Device has %d eraseregions\n", mtd->numeraseregions);
3645         for (i = 0; i < mtd->numeraseregions; i++)
3646                 printk(KERN_INFO "[offset: 0x%08x, erasesize: 0x%05x,"
3647                         " numblocks: %04u]\n",
3648                         (unsigned int) mtd->eraseregions[i].offset,
3649                         mtd->eraseregions[i].erasesize,
3650                         mtd->eraseregions[i].numblocks);
3651
3652         for (die = 0, mtd->size = 0; die < this->dies; die++) {
3653                 this->diesize[die] = (loff_t)blksperdie << this->erase_shift;
3654                 this->diesize[die] -= (loff_t)(this->boundary[die] + 1)
3655                                                  << (this->erase_shift - 1);
3656                 mtd->size += this->diesize[die];
3657         }
3658 }
3659
3660 /**
3661  * flexonenand_check_blocks_erased - Check if blocks are erased
3662  * @param mtd_info      - mtd info structure
3663  * @param start         - first erase block to check
3664  * @param end           - last erase block to check
3665  *
3666  * Converting an unerased block from MLC to SLC
3667  * causes byte values to change. Since both data and its ECC
3668  * have changed, reads on the block give uncorrectable error.
3669  * This might lead to the block being detected as bad.
3670  *
3671  * Avoid this by ensuring that the block to be converted is
3672  * erased.
3673  */
3674 static int flexonenand_check_blocks_erased(struct mtd_info *mtd, int start, int end)
3675 {
3676         struct onenand_chip *this = mtd->priv;
3677         int i, ret;
3678         int block;
3679         struct mtd_oob_ops ops = {
3680                 .mode = MTD_OPS_PLACE_OOB,
3681                 .ooboffs = 0,
3682                 .ooblen = mtd->oobsize,
3683                 .datbuf = NULL,
3684                 .oobbuf = this->oob_buf,
3685         };
3686         loff_t addr;
3687
3688         printk(KERN_DEBUG "Check blocks from %d to %d\n", start, end);
3689
3690         for (block = start; block <= end; block++) {
3691                 addr = flexonenand_addr(this, block);
3692                 if (onenand_block_isbad_nolock(mtd, addr, 0))
3693                         continue;
3694
3695                 /*
3696                  * Since main area write results in ECC write to spare,
3697                  * it is sufficient to check only ECC bytes for change.
3698                  */
3699                 ret = onenand_read_oob_nolock(mtd, addr, &ops);
3700                 if (ret)
3701                         return ret;
3702
3703                 for (i = 0; i < mtd->oobsize; i++)
3704                         if (this->oob_buf[i] != 0xff)
3705                                 break;
3706
3707                 if (i != mtd->oobsize) {
3708                         printk(KERN_WARNING "%s: Block %d not erased.\n",
3709                                 __func__, block);
3710                         return 1;
3711                 }
3712         }
3713
3714         return 0;
3715 }
3716
3717 /**
3718  * flexonenand_set_boundary     - Writes the SLC boundary
3719  * @param mtd                   - mtd info structure
3720  */
3721 int flexonenand_set_boundary(struct mtd_info *mtd, int die,
3722                                     int boundary, int lock)
3723 {
3724         struct onenand_chip *this = mtd->priv;
3725         int ret, density, blksperdie, old, new, thisboundary;
3726         loff_t addr;
3727
3728         /* Change only once for SDP Flex-OneNAND */
3729         if (die && (!ONENAND_IS_DDP(this)))
3730                 return 0;
3731
3732         /* boundary value of -1 indicates no required change */
3733         if (boundary < 0 || boundary == this->boundary[die])
3734                 return 0;
3735
3736         density = onenand_get_density(this->device_id);
3737         blksperdie = ((16 << density) << 20) >> this->erase_shift;
3738         blksperdie >>= ONENAND_IS_DDP(this) ? 1 : 0;
3739
3740         if (boundary >= blksperdie) {
3741                 printk(KERN_ERR "%s: Invalid boundary value. "
3742                                 "Boundary not changed.\n", __func__);
3743                 return -EINVAL;
3744         }
3745
3746         /* Check if converting blocks are erased */
3747         old = this->boundary[die] + (die * this->density_mask);
3748         new = boundary + (die * this->density_mask);
3749         ret = flexonenand_check_blocks_erased(mtd, min(old, new) + 1, max(old, new));
3750         if (ret) {
3751                 printk(KERN_ERR "%s: Please erase blocks "
3752                                 "before boundary change\n", __func__);
3753                 return ret;
3754         }
3755
3756         this->command(mtd, FLEXONENAND_CMD_PI_ACCESS, die, 0);
3757         this->wait(mtd, FL_SYNCING);
3758
3759         /* Check is boundary is locked */
3760         this->command(mtd, FLEXONENAND_CMD_READ_PI, die, 0);
3761         ret = this->wait(mtd, FL_READING);
3762
3763         thisboundary = this->read_word(this->base + ONENAND_DATARAM);
3764         if ((thisboundary >> FLEXONENAND_PI_UNLOCK_SHIFT) != 3) {
3765                 printk(KERN_ERR "%s: boundary locked\n", __func__);
3766                 ret = 1;
3767                 goto out;
3768         }
3769
3770         printk(KERN_INFO "Changing die %d boundary: %d%s\n",
3771                         die, boundary, lock ? "(Locked)" : "(Unlocked)");
3772
3773         addr = die ? this->diesize[0] : 0;
3774
3775         boundary &= FLEXONENAND_PI_MASK;
3776         boundary |= lock ? 0 : (3 << FLEXONENAND_PI_UNLOCK_SHIFT);
3777
3778         this->command(mtd, ONENAND_CMD_ERASE, addr, 0);
3779         ret = this->wait(mtd, FL_ERASING);
3780         if (ret) {
3781                 printk(KERN_ERR "%s: Failed PI erase for Die %d\n",
3782                        __func__, die);
3783                 goto out;
3784         }
3785
3786         this->write_word(boundary, this->base + ONENAND_DATARAM);
3787         this->command(mtd, ONENAND_CMD_PROG, addr, 0);
3788         ret = this->wait(mtd, FL_WRITING);
3789         if (ret) {
3790                 printk(KERN_ERR "%s: Failed PI write for Die %d\n",
3791                         __func__, die);
3792                 goto out;
3793         }
3794
3795         this->command(mtd, FLEXONENAND_CMD_PI_UPDATE, die, 0);
3796         ret = this->wait(mtd, FL_WRITING);
3797 out:
3798         this->write_word(ONENAND_CMD_RESET, this->base + ONENAND_REG_COMMAND);
3799         this->wait(mtd, FL_RESETING);
3800         if (!ret)
3801                 /* Recalculate device size on boundary change*/
3802                 flexonenand_get_size(mtd);
3803
3804         return ret;
3805 }
3806
3807 /**
3808  * onenand_chip_probe - [OneNAND Interface] The generic chip probe
3809  * @param mtd           MTD device structure
3810  *
3811  * OneNAND detection method:
3812  *   Compare the values from command with ones from register
3813  */
3814 static int onenand_chip_probe(struct mtd_info *mtd)
3815 {
3816         struct onenand_chip *this = mtd->priv;
3817         int bram_maf_id, bram_dev_id, maf_id, dev_id;
3818         int syscfg;
3819
3820         /* Save system configuration 1 */
3821         syscfg = this->read_word(this->base + ONENAND_REG_SYS_CFG1);
3822         /* Clear Sync. Burst Read mode to read BootRAM */
3823         this->write_word((syscfg & ~ONENAND_SYS_CFG1_SYNC_READ & ~ONENAND_SYS_CFG1_SYNC_WRITE), this->base + ONENAND_REG_SYS_CFG1);
3824
3825         /* Send the command for reading device ID from BootRAM */
3826         this->write_word(ONENAND_CMD_READID, this->base + ONENAND_BOOTRAM);
3827
3828         /* Read manufacturer and device IDs from BootRAM */
3829         bram_maf_id = this->read_word(this->base + ONENAND_BOOTRAM + 0x0);
3830         bram_dev_id = this->read_word(this->base + ONENAND_BOOTRAM + 0x2);
3831
3832         /* Reset OneNAND to read default register values */
3833         this->write_word(ONENAND_CMD_RESET, this->base + ONENAND_BOOTRAM);
3834         /* Wait reset */
3835         this->wait(mtd, FL_RESETING);
3836
3837         /* Restore system configuration 1 */
3838         this->write_word(syscfg, this->base + ONENAND_REG_SYS_CFG1);
3839
3840         /* Check manufacturer ID */
3841         if (onenand_check_maf(bram_maf_id))
3842                 return -ENXIO;
3843
3844         /* Read manufacturer and device IDs from Register */
3845         maf_id = this->read_word(this->base + ONENAND_REG_MANUFACTURER_ID);
3846         dev_id = this->read_word(this->base + ONENAND_REG_DEVICE_ID);
3847
3848         /* Check OneNAND device */
3849         if (maf_id != bram_maf_id || dev_id != bram_dev_id)
3850                 return -ENXIO;
3851
3852         return 0;
3853 }
3854
3855 /**
3856  * onenand_probe - [OneNAND Interface] Probe the OneNAND device
3857  * @param mtd           MTD device structure
3858  */
3859 static int onenand_probe(struct mtd_info *mtd)
3860 {
3861         struct onenand_chip *this = mtd->priv;
3862         int maf_id, dev_id, ver_id;
3863         int density;
3864         int ret;
3865
3866         ret = this->chip_probe(mtd);
3867         if (ret)
3868                 return ret;
3869
3870         /* Read manufacturer and device IDs from Register */
3871         maf_id = this->read_word(this->base + ONENAND_REG_MANUFACTURER_ID);
3872         dev_id = this->read_word(this->base + ONENAND_REG_DEVICE_ID);
3873         ver_id = this->read_word(this->base + ONENAND_REG_VERSION_ID);
3874         this->technology = this->read_word(this->base + ONENAND_REG_TECHNOLOGY);
3875
3876         /* Flash device information */
3877         onenand_print_device_info(dev_id, ver_id);
3878         this->device_id = dev_id;
3879         this->version_id = ver_id;
3880
3881         /* Check OneNAND features */
3882         onenand_check_features(mtd);
3883
3884         density = onenand_get_density(dev_id);
3885         if (FLEXONENAND(this)) {
3886                 this->dies = ONENAND_IS_DDP(this) ? 2 : 1;
3887                 /* Maximum possible erase regions */
3888                 mtd->numeraseregions = this->dies << 1;
3889                 mtd->eraseregions = kzalloc(sizeof(struct mtd_erase_region_info)
3890                                         * (this->dies << 1), GFP_KERNEL);
3891                 if (!mtd->eraseregions)
3892                         return -ENOMEM;
3893         }
3894
3895         /*
3896          * For Flex-OneNAND, chipsize represents maximum possible device size.
3897          * mtd->size represents the actual device size.
3898          */
3899         this->chipsize = (16 << density) << 20;
3900
3901         /* OneNAND page size & block size */
3902         /* The data buffer size is equal to page size */
3903         mtd->writesize = this->read_word(this->base + ONENAND_REG_DATA_BUFFER_SIZE);
3904         /* We use the full BufferRAM */
3905         if (ONENAND_IS_4KB_PAGE(this))
3906                 mtd->writesize <<= 1;
3907
3908         mtd->oobsize = mtd->writesize >> 5;
3909         /* Pages per a block are always 64 in OneNAND */
3910         mtd->erasesize = mtd->writesize << 6;
3911         /*
3912          * Flex-OneNAND SLC area has 64 pages per block.
3913          * Flex-OneNAND MLC area has 128 pages per block.
3914          * Expose MLC erase size to find erase_shift and page_mask.
3915          */
3916         if (FLEXONENAND(this))
3917                 mtd->erasesize <<= 1;
3918
3919         this->erase_shift = ffs(mtd->erasesize) - 1;
3920         this->page_shift = ffs(mtd->writesize) - 1;
3921         this->page_mask = (1 << (this->erase_shift - this->page_shift)) - 1;
3922         /* Set density mask. it is used for DDP */
3923         if (ONENAND_IS_DDP(this))
3924                 this->density_mask = this->chipsize >> (this->erase_shift + 1);
3925         /* It's real page size */
3926         this->writesize = mtd->writesize;
3927
3928         /* REVISIT: Multichip handling */
3929
3930         if (FLEXONENAND(this))
3931                 flexonenand_get_size(mtd);
3932         else
3933                 mtd->size = this->chipsize;
3934
3935         /*
3936          * We emulate the 4KiB page and 256KiB erase block size
3937          * But oobsize is still 64 bytes.
3938          * It is only valid if you turn on 2X program support,
3939          * Otherwise it will be ignored by compiler.
3940          */
3941         if (ONENAND_IS_2PLANE(this)) {
3942                 mtd->writesize <<= 1;
3943                 mtd->erasesize <<= 1;
3944         }
3945
3946         return 0;
3947 }
3948
3949 /**
3950  * onenand_suspend - [MTD Interface] Suspend the OneNAND flash
3951  * @param mtd           MTD device structure
3952  */
3953 static int onenand_suspend(struct mtd_info *mtd)
3954 {
3955         return onenand_get_device(mtd, FL_PM_SUSPENDED);
3956 }
3957
3958 /**
3959  * onenand_resume - [MTD Interface] Resume the OneNAND flash
3960  * @param mtd           MTD device structure
3961  */
3962 static void onenand_resume(struct mtd_info *mtd)
3963 {
3964         struct onenand_chip *this = mtd->priv;
3965
3966         if (this->state == FL_PM_SUSPENDED)
3967                 onenand_release_device(mtd);
3968         else
3969                 printk(KERN_ERR "%s: resume() called for the chip which is not "
3970                                 "in suspended state\n", __func__);
3971 }
3972
3973 /**
3974  * onenand_scan - [OneNAND Interface] Scan for the OneNAND device
3975  * @param mtd           MTD device structure
3976  * @param maxchips      Number of chips to scan for
3977  *
3978  * This fills out all the not initialized function pointers
3979  * with the defaults.
3980  * The flash ID is read and the mtd/chip structures are
3981  * filled with the appropriate values.
3982  */
3983 int onenand_scan(struct mtd_info *mtd, int maxchips)
3984 {
3985         int i, ret;
3986         struct onenand_chip *this = mtd->priv;
3987
3988         if (!this->read_word)
3989                 this->read_word = onenand_readw;
3990         if (!this->write_word)
3991                 this->write_word = onenand_writew;
3992
3993         if (!this->command)
3994                 this->command = onenand_command;
3995         if (!this->wait)
3996                 onenand_setup_wait(mtd);
3997         if (!this->bbt_wait)
3998                 this->bbt_wait = onenand_bbt_wait;
3999         if (!this->unlock_all)
4000                 this->unlock_all = onenand_unlock_all;
4001
4002         if (!this->chip_probe)
4003                 this->chip_probe = onenand_chip_probe;
4004
4005         if (!this->read_bufferram)
4006                 this->read_bufferram = onenand_read_bufferram;
4007         if (!this->write_bufferram)
4008                 this->write_bufferram = onenand_write_bufferram;
4009
4010         if (!this->block_markbad)
4011                 this->block_markbad = onenand_default_block_markbad;
4012         if (!this->scan_bbt)
4013                 this->scan_bbt = onenand_default_bbt;
4014
4015         if (onenand_probe(mtd))
4016                 return -ENXIO;
4017
4018         /* Set Sync. Burst Read after probing */
4019         if (this->mmcontrol) {
4020                 printk(KERN_INFO "OneNAND Sync. Burst Read support\n");
4021                 this->read_bufferram = onenand_sync_read_bufferram;
4022         }
4023
4024         /* Allocate buffers, if necessary */
4025         if (!this->page_buf) {
4026                 this->page_buf = kzalloc(mtd->writesize, GFP_KERNEL);
4027                 if (!this->page_buf) {
4028                         printk(KERN_ERR "%s: Can't allocate page_buf\n",
4029                                 __func__);
4030                         return -ENOMEM;
4031                 }
4032 #ifdef CONFIG_MTD_ONENAND_VERIFY_WRITE
4033                 this->verify_buf = kzalloc(mtd->writesize, GFP_KERNEL);
4034                 if (!this->verify_buf) {
4035                         kfree(this->page_buf);
4036                         return -ENOMEM;
4037                 }
4038 #endif
4039                 this->options |= ONENAND_PAGEBUF_ALLOC;
4040         }
4041         if (!this->oob_buf) {
4042                 this->oob_buf = kzalloc(mtd->oobsize, GFP_KERNEL);
4043                 if (!this->oob_buf) {
4044                         printk(KERN_ERR "%s: Can't allocate oob_buf\n",
4045                                 __func__);
4046                         if (this->options & ONENAND_PAGEBUF_ALLOC) {
4047                                 this->options &= ~ONENAND_PAGEBUF_ALLOC;
4048                                 kfree(this->page_buf);
4049                         }
4050                         return -ENOMEM;
4051                 }
4052                 this->options |= ONENAND_OOBBUF_ALLOC;
4053         }
4054
4055         this->state = FL_READY;
4056         init_waitqueue_head(&this->wq);
4057         spin_lock_init(&this->chip_lock);
4058
4059         /*
4060          * Allow subpage writes up to oobsize.
4061          */
4062         switch (mtd->oobsize) {
4063         case 128:
4064                 if (FLEXONENAND(this)) {
4065                         this->ecclayout = &flexonenand_oob_128;
4066                         mtd->subpage_sft = 0;
4067                 } else {
4068                         this->ecclayout = &onenand_oob_128;
4069                         mtd->subpage_sft = 2;
4070                 }
4071                 if (ONENAND_IS_NOP_1(this))
4072                         mtd->subpage_sft = 0;
4073                 break;
4074         case 64:
4075                 this->ecclayout = &onenand_oob_64;
4076                 mtd->subpage_sft = 2;
4077                 break;
4078
4079         case 32:
4080                 this->ecclayout = &onenand_oob_32;
4081                 mtd->subpage_sft = 1;
4082                 break;
4083
4084         default:
4085                 printk(KERN_WARNING "%s: No OOB scheme defined for oobsize %d\n",
4086                         __func__, mtd->oobsize);
4087                 mtd->subpage_sft = 0;
4088                 /* To prevent kernel oops */
4089                 this->ecclayout = &onenand_oob_32;
4090                 break;
4091         }
4092
4093         this->subpagesize = mtd->writesize >> mtd->subpage_sft;
4094
4095         /*
4096          * The number of bytes available for a client to place data into
4097          * the out of band area
4098          */
4099         this->ecclayout->oobavail = 0;
4100         for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES &&
4101             this->ecclayout->oobfree[i].length; i++)
4102                 this->ecclayout->oobavail +=
4103                         this->ecclayout->oobfree[i].length;
4104         mtd->oobavail = this->ecclayout->oobavail;
4105
4106         mtd->ecclayout = this->ecclayout;
4107
4108         /* Fill in remaining MTD driver data */
4109         mtd->type = ONENAND_IS_MLC(this) ? MTD_MLCNANDFLASH : MTD_NANDFLASH;
4110         mtd->flags = MTD_CAP_NANDFLASH;
4111         mtd->erase = onenand_erase;
4112         mtd->point = NULL;
4113         mtd->unpoint = NULL;
4114         mtd->read = onenand_read;
4115         mtd->write = onenand_write;
4116         mtd->read_oob = onenand_read_oob;
4117         mtd->write_oob = onenand_write_oob;
4118         mtd->panic_write = onenand_panic_write;
4119 #ifdef CONFIG_MTD_ONENAND_OTP
4120         mtd->get_fact_prot_info = onenand_get_fact_prot_info;
4121         mtd->read_fact_prot_reg = onenand_read_fact_prot_reg;
4122         mtd->get_user_prot_info = onenand_get_user_prot_info;
4123         mtd->read_user_prot_reg = onenand_read_user_prot_reg;
4124         mtd->write_user_prot_reg = onenand_write_user_prot_reg;
4125         mtd->lock_user_prot_reg = onenand_lock_user_prot_reg;
4126 #endif
4127         mtd->sync = onenand_sync;
4128         mtd->lock = onenand_lock;
4129         mtd->unlock = onenand_unlock;
4130         mtd->suspend = onenand_suspend;
4131         mtd->resume = onenand_resume;
4132         mtd->block_isbad = onenand_block_isbad;
4133         mtd->block_markbad = onenand_block_markbad;
4134         mtd->owner = THIS_MODULE;
4135         mtd->writebufsize = mtd->writesize;
4136
4137         /* Unlock whole block */
4138         if (!(this->options & ONENAND_SKIP_INITIAL_UNLOCKING))
4139                 this->unlock_all(mtd);
4140
4141         ret = this->scan_bbt(mtd);
4142         if ((!FLEXONENAND(this)) || ret)
4143                 return ret;
4144
4145         /* Change Flex-OneNAND boundaries if required */
4146         for (i = 0; i < MAX_DIES; i++)
4147                 flexonenand_set_boundary(mtd, i, flex_bdry[2 * i],
4148                                                  flex_bdry[(2 * i) + 1]);
4149
4150         return 0;
4151 }
4152
4153 /**
4154  * onenand_release - [OneNAND Interface] Free resources held by the OneNAND device
4155  * @param mtd           MTD device structure
4156  */
4157 void onenand_release(struct mtd_info *mtd)
4158 {
4159         struct onenand_chip *this = mtd->priv;
4160
4161         /* Deregister partitions */
4162         mtd_device_unregister(mtd);
4163
4164         /* Free bad block table memory, if allocated */
4165         if (this->bbm) {
4166                 struct bbm_info *bbm = this->bbm;
4167                 kfree(bbm->bbt);
4168                 kfree(this->bbm);
4169         }
4170         /* Buffers allocated by onenand_scan */
4171         if (this->options & ONENAND_PAGEBUF_ALLOC) {
4172                 kfree(this->page_buf);
4173 #ifdef CONFIG_MTD_ONENAND_VERIFY_WRITE
4174                 kfree(this->verify_buf);
4175 #endif
4176         }
4177         if (this->options & ONENAND_OOBBUF_ALLOC)
4178                 kfree(this->oob_buf);
4179         kfree(mtd->eraseregions);
4180 }
4181
4182 EXPORT_SYMBOL_GPL(onenand_scan);
4183 EXPORT_SYMBOL_GPL(onenand_release);
4184
4185 MODULE_LICENSE("GPL");
4186 MODULE_AUTHOR("Kyungmin Park <kyungmin.park@samsung.com>");
4187 MODULE_DESCRIPTION("Generic OneNAND flash driver code");