drivers/mtd/nand/denali.c

   1 /*
   2  * NAND Flash Controller Device Driver
   3  * Copyright © 2009-2010, Intel Corporation and its suppliers.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms and conditions of the GNU General Public License,
   7  * version 2, as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along with
  15  * this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  17  *
  18  */
  19 #include <linux/interrupt.h>
  20 #include <linux/delay.h>
  21 #include <linux/dma-mapping.h>
  22 #include <linux/wait.h>
  23 #include <linux/mutex.h>
  24 #include <linux/mtd/mtd.h>
  25 #include <linux/module.h>
  26
  27 #include "denali.h"
  28
  29 MODULE_LICENSE("GPL");
  30
  31 /*
  32  * We define a module parameter that allows the user to override
  33  * the hardware and decide what timing mode should be used.
  34  */
  35 #define NAND_DEFAULT_TIMINGS    -1
  36
  37 static int onfi_timing_mode = NAND_DEFAULT_TIMINGS;
  38 module_param(onfi_timing_mode, int, S_IRUGO);
  39 MODULE_PARM_DESC(onfi_timing_mode,
  40            "Overrides default ONFI setting. -1 indicates use default timings");
  41
  42 #define DENALI_NAND_NAME    "denali-nand"
  43
  44 /*
  45  * We define a macro here that combines all interrupts this driver uses into
  46  * a single constant value, for convenience.
  47  */
  48 #define DENALI_IRQ_ALL  (INTR__DMA_CMD_COMP | \
  49                         INTR__ECC_TRANSACTION_DONE | \
  50                         INTR__ECC_ERR | \
  51                         INTR__PROGRAM_FAIL | \
  52                         INTR__LOAD_COMP | \
  53                         INTR__PROGRAM_COMP | \
  54                         INTR__TIME_OUT | \
  55                         INTR__ERASE_FAIL | \
  56                         INTR__RST_COMP | \
  57                         INTR__ERASE_COMP)
  58
  59 /*
  60  * indicates whether or not the internal value for the flash bank is
  61  * valid or not
  62  */
  63 #define CHIP_SELECT_INVALID     -1
  64
  65 #define SUPPORT_8BITECC         1
  66
  67 /*
  68  * This macro divides two integers and rounds fractional values up
  69  * to the nearest integer value.
  70  */
  71 #define CEIL_DIV(X, Y) (((X)%(Y)) ? ((X)/(Y)+1) : ((X)/(Y)))
  72
  73 /*
  74  * this macro allows us to convert from an MTD structure to our own
  75  * device context (denali) structure.
  76  */
  77 static inline struct denali_nand_info *mtd_to_denali(struct mtd_info *mtd)
  78 {
  79         return container_of(mtd_to_nand(mtd), struct denali_nand_info, nand);
  80 }
  81
  82 /*
  83  * These constants are defined by the driver to enable common driver
  84  * configuration options.
  85  */
  86 #define SPARE_ACCESS            0x41
  87 #define MAIN_ACCESS             0x42
  88 #define MAIN_SPARE_ACCESS       0x43
  89 #define PIPELINE_ACCESS         0x2000
  90
  91 #define DENALI_READ     0
  92 #define DENALI_WRITE    0x100
  93
  94 /*
  95  * this is a helper macro that allows us to
  96  * format the bank into the proper bits for the controller
  97  */
  98 #define BANK(x) ((x) << 24)
  99
 100 /* forward declarations */
 101 static void clear_interrupts(struct denali_nand_info *denali);
 102 static uint32_t wait_for_irq(struct denali_nand_info *denali,
 103                                                         uint32_t irq_mask);
 104 static void denali_irq_enable(struct denali_nand_info *denali,
 105                                                         uint32_t int_mask);
 106 static uint32_t read_interrupt_status(struct denali_nand_info *denali);
 107
 108 /*
 109  * Certain operations for the denali NAND controller use an indexed mode to
 110  * read/write data. The operation is performed by writing the address value
 111  * of the command to the device memory followed by the data. This function
 112  * abstracts this common operation.
 113  */
 114 static void index_addr(struct denali_nand_info *denali,
 115                                 uint32_t address, uint32_t data)
 116 {
 117         iowrite32(address, denali->flash_mem);
 118         iowrite32(data, denali->flash_mem + 0x10);
 119 }
 120
 121 /* Perform an indexed read of the device */
 122 static void index_addr_read_data(struct denali_nand_info *denali,
 123                                  uint32_t address, uint32_t *pdata)
 124 {
 125         iowrite32(address, denali->flash_mem);
 126         *pdata = ioread32(denali->flash_mem + 0x10);
 127 }
 128
 129 /*
 130  * We need to buffer some data for some of the NAND core routines.
 131  * The operations manage buffering that data.
 132  */
 133 static void reset_buf(struct denali_nand_info *denali)
 134 {
 135         denali->buf.head = denali->buf.tail = 0;
 136 }
 137
 138 static void write_byte_to_buf(struct denali_nand_info *denali, uint8_t byte)
 139 {
 140         denali->buf.buf[denali->buf.tail++] = byte;
 141 }
 142
 143 /* reads the status of the device */
 144 static void read_status(struct denali_nand_info *denali)
 145 {
 146         uint32_t cmd;
 147
 148         /* initialize the data buffer to store status */
 149         reset_buf(denali);
 150
 151         cmd = ioread32(denali->flash_reg + WRITE_PROTECT);
 152         if (cmd)
 153                 write_byte_to_buf(denali, NAND_STATUS_WP);
 154         else
 155                 write_byte_to_buf(denali, 0);
 156 }
 157
 158 /* resets a specific device connected to the core */
 159 static void reset_bank(struct denali_nand_info *denali)
 160 {
 161         uint32_t irq_status;
 162         uint32_t irq_mask = INTR__RST_COMP | INTR__TIME_OUT;
 163
 164         clear_interrupts(denali);
 165
 166         iowrite32(1 << denali->flash_bank, denali->flash_reg + DEVICE_RESET);
 167
 168         irq_status = wait_for_irq(denali, irq_mask);
 169
 170         if (irq_status & INTR__TIME_OUT)
 171                 dev_err(denali->dev, "reset bank failed.\n");
 172 }
 173
 174 /* Reset the flash controller */
 175 static uint16_t denali_nand_reset(struct denali_nand_info *denali)
 176 {
 177         int i;
 178
 179         for (i = 0; i < denali->max_banks; i++)
 180                 iowrite32(INTR__RST_COMP | INTR__TIME_OUT,
 181                 denali->flash_reg + INTR_STATUS(i));
 182
 183         for (i = 0; i < denali->max_banks; i++) {
 184                 iowrite32(1 << i, denali->flash_reg + DEVICE_RESET);
 185                 while (!(ioread32(denali->flash_reg + INTR_STATUS(i)) &
 186                         (INTR__RST_COMP | INTR__TIME_OUT)))
 187                         cpu_relax();
 188                 if (ioread32(denali->flash_reg + INTR_STATUS(i)) &
 189                         INTR__TIME_OUT)
 190                         dev_dbg(denali->dev,
 191                         "NAND Reset operation timed out on bank %d\n", i);
 192         }
 193
 194         for (i = 0; i < denali->max_banks; i++)
 195                 iowrite32(INTR__RST_COMP | INTR__TIME_OUT,
 196                           denali->flash_reg + INTR_STATUS(i));
 197
 198         return PASS;
 199 }
 200
 201 /*
 202  * this routine calculates the ONFI timing values for a given mode and
 203  * programs the clocking register accordingly. The mode is determined by
 204  * the get_onfi_nand_para routine.
 205  */
 206 static void nand_onfi_timing_set(struct denali_nand_info *denali,
 207                                                                 uint16_t mode)
 208 {
 209         uint16_t Trea[6] = {40, 30, 25, 20, 20, 16};
 210         uint16_t Trp[6] = {50, 25, 17, 15, 12, 10};
 211         uint16_t Treh[6] = {30, 15, 15, 10, 10, 7};
 212         uint16_t Trc[6] = {100, 50, 35, 30, 25, 20};
 213         uint16_t Trhoh[6] = {0, 15, 15, 15, 15, 15};
 214         uint16_t Trloh[6] = {0, 0, 0, 0, 5, 5};
 215         uint16_t Tcea[6] = {100, 45, 30, 25, 25, 25};
 216         uint16_t Tadl[6] = {200, 100, 100, 100, 70, 70};
 217         uint16_t Trhw[6] = {200, 100, 100, 100, 100, 100};
 218         uint16_t Trhz[6] = {200, 100, 100, 100, 100, 100};
 219         uint16_t Twhr[6] = {120, 80, 80, 60, 60, 60};
 220         uint16_t Tcs[6] = {70, 35, 25, 25, 20, 15};
 221
 222         uint16_t data_invalid_rhoh, data_invalid_rloh, data_invalid;
 223         uint16_t dv_window = 0;
 224         uint16_t en_lo, en_hi;
 225         uint16_t acc_clks;
 226         uint16_t addr_2_data, re_2_we, re_2_re, we_2_re, cs_cnt;
 227
 228         en_lo = CEIL_DIV(Trp[mode], CLK_X);
 229         en_hi = CEIL_DIV(Treh[mode], CLK_X);
 230 #if ONFI_BLOOM_TIME
 231         if ((en_hi * CLK_X) < (Treh[mode] + 2))
 232                 en_hi++;
 233 #endif
 234
 235         if ((en_lo + en_hi) * CLK_X < Trc[mode])
 236                 en_lo += CEIL_DIV((Trc[mode] - (en_lo + en_hi) * CLK_X), CLK_X);
 237
 238         if ((en_lo + en_hi) < CLK_MULTI)
 239                 en_lo += CLK_MULTI - en_lo - en_hi;
 240
 241         while (dv_window < 8) {
 242                 data_invalid_rhoh = en_lo * CLK_X + Trhoh[mode];
 243
 244                 data_invalid_rloh = (en_lo + en_hi) * CLK_X + Trloh[mode];
 245
 246                 data_invalid = data_invalid_rhoh < data_invalid_rloh ?
 247                                         data_invalid_rhoh : data_invalid_rloh;
 248
 249                 dv_window = data_invalid - Trea[mode];
 250
 251                 if (dv_window < 8)
 252                         en_lo++;
 253         }
 254
 255         acc_clks = CEIL_DIV(Trea[mode], CLK_X);
 256
 257         while (acc_clks * CLK_X - Trea[mode] < 3)
 258                 acc_clks++;
 259
 260         if (data_invalid - acc_clks * CLK_X < 2)
 261                 dev_warn(denali->dev, "%s, Line %d: Warning!\n",
 262                          __FILE__, __LINE__);
 263
 264         addr_2_data = CEIL_DIV(Tadl[mode], CLK_X);
 265         re_2_we = CEIL_DIV(Trhw[mode], CLK_X);
 266         re_2_re = CEIL_DIV(Trhz[mode], CLK_X);
 267         we_2_re = CEIL_DIV(Twhr[mode], CLK_X);
 268         cs_cnt = CEIL_DIV((Tcs[mode] - Trp[mode]), CLK_X);
 269         if (cs_cnt == 0)
 270                 cs_cnt = 1;
 271
 272         if (Tcea[mode]) {
 273                 while (cs_cnt * CLK_X + Trea[mode] < Tcea[mode])
 274                         cs_cnt++;
 275         }
 276
 277 #if MODE5_WORKAROUND
 278         if (mode == 5)
 279                 acc_clks = 5;
 280 #endif
 281
 282         /* Sighting 3462430: Temporary hack for MT29F128G08CJABAWP:B */
 283         if (ioread32(denali->flash_reg + MANUFACTURER_ID) == 0 &&
 284                 ioread32(denali->flash_reg + DEVICE_ID) == 0x88)
 285                 acc_clks = 6;
 286
 287         iowrite32(acc_clks, denali->flash_reg + ACC_CLKS);
 288         iowrite32(re_2_we, denali->flash_reg + RE_2_WE);
 289         iowrite32(re_2_re, denali->flash_reg + RE_2_RE);
 290         iowrite32(we_2_re, denali->flash_reg + WE_2_RE);
 291         iowrite32(addr_2_data, denali->flash_reg + ADDR_2_DATA);
 292         iowrite32(en_lo, denali->flash_reg + RDWR_EN_LO_CNT);
 293         iowrite32(en_hi, denali->flash_reg + RDWR_EN_HI_CNT);
 294         iowrite32(cs_cnt, denali->flash_reg + CS_SETUP_CNT);
 295 }
 296
 297 /* queries the NAND device to see what ONFI modes it supports. */
 298 static uint16_t get_onfi_nand_para(struct denali_nand_info *denali)
 299 {
 300         int i;
 301
 302         /*
 303          * we needn't to do a reset here because driver has already
 304          * reset all the banks before
 305          */
 306         if (!(ioread32(denali->flash_reg + ONFI_TIMING_MODE) &
 307                 ONFI_TIMING_MODE__VALUE))
 308                 return FAIL;
 309
 310         for (i = 5; i > 0; i--) {
 311                 if (ioread32(denali->flash_reg + ONFI_TIMING_MODE) &
 312                         (0x01 << i))
 313                         break;
 314         }
 315
 316         nand_onfi_timing_set(denali, i);
 317
 318         /*
 319          * By now, all the ONFI devices we know support the page cache
 320          * rw feature. So here we enable the pipeline_rw_ahead feature
 321          */
 322         /* iowrite32(1, denali->flash_reg + CACHE_WRITE_ENABLE); */
 323         /* iowrite32(1, denali->flash_reg + CACHE_READ_ENABLE);  */
 324
 325         return PASS;
 326 }
 327
 328 static void get_samsung_nand_para(struct denali_nand_info *denali,
 329                                                         uint8_t device_id)
 330 {
 331         if (device_id == 0xd3) { /* Samsung K9WAG08U1A */
 332                 /* Set timing register values according to datasheet */
 333                 iowrite32(5, denali->flash_reg + ACC_CLKS);
 334                 iowrite32(20, denali->flash_reg + RE_2_WE);
 335                 iowrite32(12, denali->flash_reg + WE_2_RE);
 336                 iowrite32(14, denali->flash_reg + ADDR_2_DATA);
 337                 iowrite32(3, denali->flash_reg + RDWR_EN_LO_CNT);
 338                 iowrite32(2, denali->flash_reg + RDWR_EN_HI_CNT);
 339                 iowrite32(2, denali->flash_reg + CS_SETUP_CNT);
 340         }
 341 }
 342
 343 static void get_toshiba_nand_para(struct denali_nand_info *denali)
 344 {
 345         uint32_t tmp;
 346
 347         /*
 348          * Workaround to fix a controller bug which reports a wrong
 349          * spare area size for some kind of Toshiba NAND device
 350          */
 351         if ((ioread32(denali->flash_reg + DEVICE_MAIN_AREA_SIZE) == 4096) &&
 352                 (ioread32(denali->flash_reg + DEVICE_SPARE_AREA_SIZE) == 64)) {
 353                 iowrite32(216, denali->flash_reg + DEVICE_SPARE_AREA_SIZE);
 354                 tmp = ioread32(denali->flash_reg + DEVICES_CONNECTED) *
 355                         ioread32(denali->flash_reg + DEVICE_SPARE_AREA_SIZE);
 356                 iowrite32(tmp,
 357                                 denali->flash_reg + LOGICAL_PAGE_SPARE_SIZE);
 358 #if SUPPORT_15BITECC
 359                 iowrite32(15, denali->flash_reg + ECC_CORRECTION);
 360 #elif SUPPORT_8BITECC
 361                 iowrite32(8, denali->flash_reg + ECC_CORRECTION);
 362 #endif
 363         }
 364 }
 365
 366 static void get_hynix_nand_para(struct denali_nand_info *denali,
 367                                                         uint8_t device_id)
 368 {
 369         uint32_t main_size, spare_size;
 370
 371         switch (device_id) {
 372         case 0xD5: /* Hynix H27UAG8T2A, H27UBG8U5A or H27UCG8VFA */
 373         case 0xD7: /* Hynix H27UDG8VEM, H27UCG8UDM or H27UCG8V5A */
 374                 iowrite32(128, denali->flash_reg + PAGES_PER_BLOCK);
 375                 iowrite32(4096, denali->flash_reg + DEVICE_MAIN_AREA_SIZE);
 376                 iowrite32(224, denali->flash_reg + DEVICE_SPARE_AREA_SIZE);
 377                 main_size = 4096 *
 378                         ioread32(denali->flash_reg + DEVICES_CONNECTED);
 379                 spare_size = 224 *
 380                         ioread32(denali->flash_reg + DEVICES_CONNECTED);
 381                 iowrite32(main_size,
 382                                 denali->flash_reg + LOGICAL_PAGE_DATA_SIZE);
 383                 iowrite32(spare_size,
 384                                 denali->flash_reg + LOGICAL_PAGE_SPARE_SIZE);
 385                 iowrite32(0, denali->flash_reg + DEVICE_WIDTH);
 386 #if SUPPORT_15BITECC
 387                 iowrite32(15, denali->flash_reg + ECC_CORRECTION);
 388 #elif SUPPORT_8BITECC
 389                 iowrite32(8, denali->flash_reg + ECC_CORRECTION);
 390 #endif
 391                 break;
 392         default:
 393                 dev_warn(denali->dev,
 394                          "Unknown Hynix NAND (Device ID: 0x%x).\n"
 395                          "Will use default parameter values instead.\n",
 396                          device_id);
 397         }
 398 }
 399
 400 /*
 401  * determines how many NAND chips are connected to the controller. Note for
 402  * Intel CE4100 devices we don't support more than one device.
 403  */
 404 static void find_valid_banks(struct denali_nand_info *denali)
 405 {
 406         uint32_t id[denali->max_banks];
 407         int i;
 408
 409         denali->total_used_banks = 1;
 410         for (i = 0; i < denali->max_banks; i++) {
 411                 index_addr(denali, MODE_11 | (i << 24) | 0, 0x90);
 412                 index_addr(denali, MODE_11 | (i << 24) | 1, 0);
 413                 index_addr_read_data(denali, MODE_11 | (i << 24) | 2, &id[i]);
 414
 415                 dev_dbg(denali->dev,
 416                         "Return 1st ID for bank[%d]: %x\n", i, id[i]);
 417
 418                 if (i == 0) {
 419                         if (!(id[i] & 0x0ff))
 420                                 break; /* WTF? */
 421                 } else {
 422                         if ((id[i] & 0x0ff) == (id[0] & 0x0ff))
 423                                 denali->total_used_banks++;
 424                         else
 425                                 break;
 426                 }
 427         }
 428
 429         if (denali->platform == INTEL_CE4100) {
 430                 /*
 431                  * Platform limitations of the CE4100 device limit
 432                  * users to a single chip solution for NAND.
 433                  * Multichip support is not enabled.
 434                  */
 435                 if (denali->total_used_banks != 1) {
 436                         dev_err(denali->dev,
 437                                 "Sorry, Intel CE4100 only supports a single NAND device.\n");
 438                         BUG();
 439                 }
 440         }
 441         dev_dbg(denali->dev,
 442                 "denali->total_used_banks: %d\n", denali->total_used_banks);
 443 }
 444
 445 /*
 446  * Use the configuration feature register to determine the maximum number of
 447  * banks that the hardware supports.
 448  */
 449 static void detect_max_banks(struct denali_nand_info *denali)
 450 {
 451         uint32_t features = ioread32(denali->flash_reg + FEATURES);
 452         /*
 453          * Read the revision register, so we can calculate the max_banks
 454          * properly: the encoding changed from rev 5.0 to 5.1
 455          */
 456         u32 revision = MAKE_COMPARABLE_REVISION(
 457                                 ioread32(denali->flash_reg + REVISION));
 458
 459         if (revision < REVISION_5_1)
 460                 denali->max_banks = 2 << (features & FEATURES__N_BANKS);
 461         else
 462                 denali->max_banks = 1 << (features & FEATURES__N_BANKS);
 463 }
 464
 465 static uint16_t denali_nand_timing_set(struct denali_nand_info *denali)
 466 {
 467         uint16_t status = PASS;
 468         uint32_t id_bytes[8], addr;
 469         uint8_t maf_id, device_id;
 470         int i;
 471
 472         /*
 473          * Use read id method to get device ID and other params.
 474          * For some NAND chips, controller can't report the correct
 475          * device ID by reading from DEVICE_ID register
 476          */
 477         addr = MODE_11 | BANK(denali->flash_bank);
 478         index_addr(denali, addr | 0, 0x90);
 479         index_addr(denali, addr | 1, 0);
 480         for (i = 0; i < 8; i++)
 481                 index_addr_read_data(denali, addr | 2, &id_bytes[i]);
 482         maf_id = id_bytes[0];
 483         device_id = id_bytes[1];
 484
 485         if (ioread32(denali->flash_reg + ONFI_DEVICE_NO_OF_LUNS) &
 486                 ONFI_DEVICE_NO_OF_LUNS__ONFI_DEVICE) { /* ONFI 1.0 NAND */
 487                 if (FAIL == get_onfi_nand_para(denali))
 488                         return FAIL;
 489         } else if (maf_id == 0xEC) { /* Samsung NAND */
 490                 get_samsung_nand_para(denali, device_id);
 491         } else if (maf_id == 0x98) { /* Toshiba NAND */
 492                 get_toshiba_nand_para(denali);
 493         } else if (maf_id == 0xAD) { /* Hynix NAND */
 494                 get_hynix_nand_para(denali, device_id);
 495         }
 496
 497         dev_info(denali->dev,
 498                         "Dump timing register values:\n"
 499                         "acc_clks: %d, re_2_we: %d, re_2_re: %d\n"
 500                         "we_2_re: %d, addr_2_data: %d, rdwr_en_lo_cnt: %d\n"
 501                         "rdwr_en_hi_cnt: %d, cs_setup_cnt: %d\n",
 502                         ioread32(denali->flash_reg + ACC_CLKS),
 503                         ioread32(denali->flash_reg + RE_2_WE),
 504                         ioread32(denali->flash_reg + RE_2_RE),
 505                         ioread32(denali->flash_reg + WE_2_RE),
 506                         ioread32(denali->flash_reg + ADDR_2_DATA),
 507                         ioread32(denali->flash_reg + RDWR_EN_LO_CNT),
 508                         ioread32(denali->flash_reg + RDWR_EN_HI_CNT),
 509                         ioread32(denali->flash_reg + CS_SETUP_CNT));
 510
 511         find_valid_banks(denali);
 512
 513         /*
 514          * If the user specified to override the default timings
 515          * with a specific ONFI mode, we apply those changes here.
 516          */
 517         if (onfi_timing_mode != NAND_DEFAULT_TIMINGS)
 518                 nand_onfi_timing_set(denali, onfi_timing_mode);
 519
 520         return status;
 521 }
 522
 523 static void denali_set_intr_modes(struct denali_nand_info *denali,
 524                                         uint16_t INT_ENABLE)
 525 {
 526         if (INT_ENABLE)
 527                 iowrite32(1, denali->flash_reg + GLOBAL_INT_ENABLE);
 528         else
 529                 iowrite32(0, denali->flash_reg + GLOBAL_INT_ENABLE);
 530 }
 531
 532 /*
 533  * validation function to verify that the controlling software is making
 534  * a valid request
 535  */
 536 static inline bool is_flash_bank_valid(int flash_bank)
 537 {
 538         return flash_bank >= 0 && flash_bank < 4;
 539 }
 540
 541 static void denali_irq_init(struct denali_nand_info *denali)
 542 {
 543         uint32_t int_mask;
 544         int i;
 545
 546         /* Disable global interrupts */
 547         denali_set_intr_modes(denali, false);
 548
 549         int_mask = DENALI_IRQ_ALL;
 550
 551         /* Clear all status bits */
 552         for (i = 0; i < denali->max_banks; ++i)
 553                 iowrite32(0xFFFF, denali->flash_reg + INTR_STATUS(i));
 554
 555         denali_irq_enable(denali, int_mask);
 556 }
 557
 558 static void denali_irq_cleanup(int irqnum, struct denali_nand_info *denali)
 559 {
 560         denali_set_intr_modes(denali, false);
 561 }
 562
 563 static void denali_irq_enable(struct denali_nand_info *denali,
 564                                                         uint32_t int_mask)
 565 {
 566         int i;
 567
 568         for (i = 0; i < denali->max_banks; ++i)
 569                 iowrite32(int_mask, denali->flash_reg + INTR_EN(i));
 570 }
 571
 572 /*
 573  * This function only returns when an interrupt that this driver cares about
 574  * occurs. This is to reduce the overhead of servicing interrupts
 575  */
 576 static inline uint32_t denali_irq_detected(struct denali_nand_info *denali)
 577 {
 578         return read_interrupt_status(denali) & DENALI_IRQ_ALL;
 579 }
 580
 581 /* Interrupts are cleared by writing a 1 to the appropriate status bit */
 582 static inline void clear_interrupt(struct denali_nand_info *denali,
 583                                                         uint32_t irq_mask)
 584 {
 585         uint32_t intr_status_reg;
 586
 587         intr_status_reg = INTR_STATUS(denali->flash_bank);
 588
 589         iowrite32(irq_mask, denali->flash_reg + intr_status_reg);
 590 }
 591
 592 static void clear_interrupts(struct denali_nand_info *denali)
 593 {
 594         uint32_t status;
 595
 596         spin_lock_irq(&denali->irq_lock);
 597
 598         status = read_interrupt_status(denali);
 599         clear_interrupt(denali, status);
 600
 601         denali->irq_status = 0x0;
 602         spin_unlock_irq(&denali->irq_lock);
 603 }
 604
 605 static uint32_t read_interrupt_status(struct denali_nand_info *denali)
 606 {
 607         uint32_t intr_status_reg;
 608
 609         intr_status_reg = INTR_STATUS(denali->flash_bank);
 610
 611         return ioread32(denali->flash_reg + intr_status_reg);
 612 }
 613
 614 /*
 615  * This is the interrupt service routine. It handles all interrupts
 616  * sent to this device. Note that on CE4100, this is a shared interrupt.
 617  */
 618 static irqreturn_t denali_isr(int irq, void *dev_id)
 619 {
 620         struct denali_nand_info *denali = dev_id;
 621         uint32_t irq_status;
 622         irqreturn_t result = IRQ_NONE;
 623
 624         spin_lock(&denali->irq_lock);
 625
 626         /* check to see if a valid NAND chip has been selected. */
 627         if (is_flash_bank_valid(denali->flash_bank)) {
 628                 /*
 629                  * check to see if controller generated the interrupt,
 630                  * since this is a shared interrupt
 631                  */
 632                 irq_status = denali_irq_detected(denali);
 633                 if (irq_status != 0) {
 634                         /* handle interrupt */
 635                         /* first acknowledge it */
 636                         clear_interrupt(denali, irq_status);
 637                         /*
 638                          * store the status in the device context for someone
 639                          * to read
 640                          */
 641                         denali->irq_status |= irq_status;
 642                         /* notify anyone who cares that it happened */
 643                         complete(&denali->complete);
 644                         /* tell the OS that we've handled this */
 645                         result = IRQ_HANDLED;
 646                 }
 647         }
 648         spin_unlock(&denali->irq_lock);
 649         return result;
 650 }
 651
 652 static uint32_t wait_for_irq(struct denali_nand_info *denali, uint32_t irq_mask)
 653 {
 654         unsigned long comp_res;
 655         uint32_t intr_status;
 656         unsigned long timeout = msecs_to_jiffies(1000);
 657
 658         do {
 659                 comp_res =
 660                         wait_for_completion_timeout(&denali->complete, timeout);
 661                 spin_lock_irq(&denali->irq_lock);
 662                 intr_status = denali->irq_status;
 663
 664                 if (intr_status & irq_mask) {
 665                         denali->irq_status &= ~irq_mask;
 666                         spin_unlock_irq(&denali->irq_lock);
 667                         /* our interrupt was detected */
 668                         break;
 669                 }
 670
 671                 /*
 672                  * these are not the interrupts you are looking for -
 673                  * need to wait again
 674                  */
 675                 spin_unlock_irq(&denali->irq_lock);
 676         } while (comp_res != 0);
 677
 678         if (comp_res == 0) {
 679                 /* timeout */
 680                 pr_err("timeout occurred, status = 0x%x, mask = 0x%x\n",
 681                                 intr_status, irq_mask);
 682
 683                 intr_status = 0;
 684         }
 685         return intr_status;
 686 }
 687
 688 /*
 689  * This helper function setups the registers for ECC and whether or not
 690  * the spare area will be transferred.
 691  */
 692 static void setup_ecc_for_xfer(struct denali_nand_info *denali, bool ecc_en,
 693                                 bool transfer_spare)
 694 {
 695         int ecc_en_flag, transfer_spare_flag;
 696
 697         /* set ECC, transfer spare bits if needed */
 698         ecc_en_flag = ecc_en ? ECC_ENABLE__FLAG : 0;
 699         transfer_spare_flag = transfer_spare ? TRANSFER_SPARE_REG__FLAG : 0;
 700
 701         /* Enable spare area/ECC per user's request. */
 702         iowrite32(ecc_en_flag, denali->flash_reg + ECC_ENABLE);
 703         iowrite32(transfer_spare_flag, denali->flash_reg + TRANSFER_SPARE_REG);
 704 }
 705
 706 /*
 707  * sends a pipeline command operation to the controller. See the Denali NAND
 708  * controller's user guide for more information (section 4.2.3.6).
 709  */
 710 static int denali_send_pipeline_cmd(struct denali_nand_info *denali,
 711                                     bool ecc_en, bool transfer_spare,
 712                                     int access_type, int op)
 713 {
 714         int status = PASS;
 715         uint32_t page_count = 1;
 716         uint32_t addr, cmd, irq_status, irq_mask;
 717
 718         if (op == DENALI_READ)
 719                 irq_mask = INTR__LOAD_COMP;
 720         else if (op == DENALI_WRITE)
 721                 irq_mask = 0;
 722         else
 723                 BUG();
 724
 725         setup_ecc_for_xfer(denali, ecc_en, transfer_spare);
 726
 727         clear_interrupts(denali);
 728
 729         addr = BANK(denali->flash_bank) | denali->page;
 730
 731         if (op == DENALI_WRITE && access_type != SPARE_ACCESS) {
 732                 cmd = MODE_01 | addr;
 733                 iowrite32(cmd, denali->flash_mem);
 734         } else if (op == DENALI_WRITE && access_type == SPARE_ACCESS) {
 735                 /* read spare area */
 736                 cmd = MODE_10 | addr;
 737                 index_addr(denali, cmd, access_type);
 738
 739                 cmd = MODE_01 | addr;
 740                 iowrite32(cmd, denali->flash_mem);
 741         } else if (op == DENALI_READ) {
 742                 /* setup page read request for access type */
 743                 cmd = MODE_10 | addr;
 744                 index_addr(denali, cmd, access_type);
 745
 746                 /*
 747                  * page 33 of the NAND controller spec indicates we should not
 748                  * use the pipeline commands in Spare area only mode.
 749                  * So we don't.
 750                  */
 751                 if (access_type == SPARE_ACCESS) {
 752                         cmd = MODE_01 | addr;
 753                         iowrite32(cmd, denali->flash_mem);
 754                 } else {
 755                         index_addr(denali, cmd,
 756                                         PIPELINE_ACCESS | op | page_count);
 757
 758                         /*
 759                          * wait for command to be accepted
 760                          * can always use status0 bit as the
 761                          * mask is identical for each bank.
 762                          */
 763                         irq_status = wait_for_irq(denali, irq_mask);
 764
 765                         if (irq_status == 0) {
 766                                 dev_err(denali->dev,
 767                                         "cmd, page, addr on timeout (0x%x, 0x%x, 0x%x)\n",
 768                                         cmd, denali->page, addr);
 769                                 status = FAIL;
 770                         } else {
 771                                 cmd = MODE_01 | addr;
 772                                 iowrite32(cmd, denali->flash_mem);
 773                         }
 774                 }
 775         }
 776         return status;
 777 }
 778
 779 /* helper function that simply writes a buffer to the flash */
 780 static int write_data_to_flash_mem(struct denali_nand_info *denali,
 781                                    const uint8_t *buf, int len)
 782 {
 783         uint32_t *buf32;
 784         int i;
 785
 786         /*
 787          * verify that the len is a multiple of 4.
 788          * see comment in read_data_from_flash_mem()
 789          */
 790         BUG_ON((len % 4) != 0);
 791
 792         /* write the data to the flash memory */
 793         buf32 = (uint32_t *)buf;
 794         for (i = 0; i < len / 4; i++)
 795                 iowrite32(*buf32++, denali->flash_mem + 0x10);
 796         return i * 4; /* intent is to return the number of bytes read */
 797 }
 798
 799 /* helper function that simply reads a buffer from the flash */
 800 static int read_data_from_flash_mem(struct denali_nand_info *denali,
 801                                     uint8_t *buf, int len)
 802 {
 803         uint32_t *buf32;
 804         int i;
 805
 806         /*
 807          * we assume that len will be a multiple of 4, if not it would be nice
 808          * to know about it ASAP rather than have random failures...
 809          * This assumption is based on the fact that this function is designed
 810          * to be used to read flash pages, which are typically multiples of 4.
 811          */
 812         BUG_ON((len % 4) != 0);
 813
 814         /* transfer the data from the flash */
 815         buf32 = (uint32_t *)buf;
 816         for (i = 0; i < len / 4; i++)
 817                 *buf32++ = ioread32(denali->flash_mem + 0x10);
 818         return i * 4; /* intent is to return the number of bytes read */
 819 }
 820
 821 /* writes OOB data to the device */
 822 static int write_oob_data(struct mtd_info *mtd, uint8_t *buf, int page)
 823 {
 824         struct denali_nand_info *denali = mtd_to_denali(mtd);
 825         uint32_t irq_status;
 826         uint32_t irq_mask = INTR__PROGRAM_COMP | INTR__PROGRAM_FAIL;
 827         int status = 0;
 828
 829         denali->page = page;
 830
 831         if (denali_send_pipeline_cmd(denali, false, false, SPARE_ACCESS,
 832                                                         DENALI_WRITE) == PASS) {
 833                 write_data_to_flash_mem(denali, buf, mtd->oobsize);
 834
 835                 /* wait for operation to complete */
 836                 irq_status = wait_for_irq(denali, irq_mask);
 837
 838                 if (irq_status == 0) {
 839                         dev_err(denali->dev, "OOB write failed\n");
 840                         status = -EIO;
 841                 }
 842         } else {
 843                 dev_err(denali->dev, "unable to send pipeline command\n");
 844                 status = -EIO;
 845         }
 846         return status;
 847 }
 848
 849 /* reads OOB data from the device */
 850 static void read_oob_data(struct mtd_info *mtd, uint8_t *buf, int page)
 851 {
 852         struct denali_nand_info *denali = mtd_to_denali(mtd);
 853         uint32_t irq_mask = INTR__LOAD_COMP;
 854         uint32_t irq_status, addr, cmd;
 855
 856         denali->page = page;
 857
 858         if (denali_send_pipeline_cmd(denali, false, true, SPARE_ACCESS,
 859                                                         DENALI_READ) == PASS) {
 860                 read_data_from_flash_mem(denali, buf, mtd->oobsize);
 861
 862                 /*
 863                  * wait for command to be accepted
 864                  * can always use status0 bit as the
 865                  * mask is identical for each bank.
 866                  */
 867                 irq_status = wait_for_irq(denali, irq_mask);
 868
 869                 if (irq_status == 0)
 870                         dev_err(denali->dev, "page on OOB timeout %d\n",
 871                                         denali->page);
 872
 873                 /*
 874                  * We set the device back to MAIN_ACCESS here as I observed
 875                  * instability with the controller if you do a block erase
 876                  * and the last transaction was a SPARE_ACCESS. Block erase
 877                  * is reliable (according to the MTD test infrastructure)
 878                  * if you are in MAIN_ACCESS.
 879                  */
 880                 addr = BANK(denali->flash_bank) | denali->page;
 881                 cmd = MODE_10 | addr;
 882                 index_addr(denali, cmd, MAIN_ACCESS);
 883         }
 884 }
 885
 886 /*
 887  * this function examines buffers to see if they contain data that
 888  * indicate that the buffer is part of an erased region of flash.
 889  */
 890 static bool is_erased(uint8_t *buf, int len)
 891 {
 892         int i;
 893
 894         for (i = 0; i < len; i++)
 895                 if (buf[i] != 0xFF)
 896                         return false;
 897         return true;
 898 }
 899 #define ECC_SECTOR_SIZE 512
 900
 901 #define ECC_SECTOR(x)   (((x) & ECC_ERROR_ADDRESS__SECTOR_NR) >> 12)
 902 #define ECC_BYTE(x)     (((x) & ECC_ERROR_ADDRESS__OFFSET))
 903 #define ECC_CORRECTION_VALUE(x) ((x) & ERR_CORRECTION_INFO__BYTEMASK)
 904 #define ECC_ERROR_CORRECTABLE(x) (!((x) & ERR_CORRECTION_INFO__ERROR_TYPE))
 905 #define ECC_ERR_DEVICE(x)       (((x) & ERR_CORRECTION_INFO__DEVICE_NR) >> 8)
 906 #define ECC_LAST_ERR(x)         ((x) & ERR_CORRECTION_INFO__LAST_ERR_INFO)
 907
 908 static bool handle_ecc(struct denali_nand_info *denali, uint8_t *buf,
 909                        uint32_t irq_status, unsigned int *max_bitflips)
 910 {
 911         bool check_erased_page = false;
 912         unsigned int bitflips = 0;
 913
 914         if (irq_status & INTR__ECC_ERR) {
 915                 /* read the ECC errors. we'll ignore them for now */
 916                 uint32_t err_address, err_correction_info, err_byte,
 917                          err_sector, err_device, err_correction_value;
 918                 denali_set_intr_modes(denali, false);
 919
 920                 do {
 921                         err_address = ioread32(denali->flash_reg +
 922                                                 ECC_ERROR_ADDRESS);
 923                         err_sector = ECC_SECTOR(err_address);
 924                         err_byte = ECC_BYTE(err_address);
 925
 926                         err_correction_info = ioread32(denali->flash_reg +
 927                                                 ERR_CORRECTION_INFO);
 928                         err_correction_value =
 929                                 ECC_CORRECTION_VALUE(err_correction_info);
 930                         err_device = ECC_ERR_DEVICE(err_correction_info);
 931
 932                         if (ECC_ERROR_CORRECTABLE(err_correction_info)) {
 933                                 /*
 934                                  * If err_byte is larger than ECC_SECTOR_SIZE,
 935                                  * means error happened in OOB, so we ignore
 936                                  * it. It's no need for us to correct it
 937                                  * err_device is represented the NAND error
 938                                  * bits are happened in if there are more
 939                                  * than one NAND connected.
 940                                  */
 941                                 if (err_byte < ECC_SECTOR_SIZE) {
 942                                         struct mtd_info *mtd =
 943                                                 nand_to_mtd(&denali->nand);
 944                                         int offset;
 945
 946                                         offset = (err_sector *
 947                                                         ECC_SECTOR_SIZE +
 948                                                         err_byte) *
 949                                                         denali->devnum +
 950                                                         err_device;
 951                                         /* correct the ECC error */
 952                                         buf[offset] ^= err_correction_value;
 953                                         mtd->ecc_stats.corrected++;
 954                                         bitflips++;
 955                                 }
 956                         } else {
 957                                 /*
 958                                  * if the error is not correctable, need to
 959                                  * look at the page to see if it is an erased
 960                                  * page. if so, then it's not a real ECC error
 961                                  */
 962                                 check_erased_page = true;
 963                         }
 964                 } while (!ECC_LAST_ERR(err_correction_info));
 965                 /*
 966                  * Once handle all ecc errors, controller will triger
 967                  * a ECC_TRANSACTION_DONE interrupt, so here just wait
 968                  * for a while for this interrupt
 969                  */
 970                 while (!(read_interrupt_status(denali) &
 971                                 INTR__ECC_TRANSACTION_DONE))
 972                         cpu_relax();
 973                 clear_interrupts(denali);
 974                 denali_set_intr_modes(denali, true);
 975         }
 976         *max_bitflips = bitflips;
 977         return check_erased_page;
 978 }
 979
 980 /* programs the controller to either enable/disable DMA transfers */
 981 static void denali_enable_dma(struct denali_nand_info *denali, bool en)
 982 {
 983         iowrite32(en ? DMA_ENABLE__FLAG : 0, denali->flash_reg + DMA_ENABLE);
 984         ioread32(denali->flash_reg + DMA_ENABLE);
 985 }
 986
 987 /* setups the HW to perform the data DMA */
 988 static void denali_setup_dma(struct denali_nand_info *denali, int op)
 989 {
 990         uint32_t mode;
 991         const int page_count = 1;
 992         uint32_t addr = denali->buf.dma_buf;
 993
 994         mode = MODE_10 | BANK(denali->flash_bank);
 995
 996         /* DMA is a four step process */
 997
 998         /* 1. setup transfer type and # of pages */
 999         index_addr(denali, mode | denali->page, 0x2000 | op | page_count);
1000
1001         /* 2. set memory high address bits 23:8 */
1002         index_addr(denali, mode | ((addr >> 16) << 8), 0x2200);
1003
1004         /* 3. set memory low address bits 23:8 */
1005         index_addr(denali, mode | ((addr & 0xffff) << 8), 0x2300);
1006
1007         /* 4. interrupt when complete, burst len = 64 bytes */
1008         index_addr(denali, mode | 0x14000, 0x2400);
1009 }
1010
1011 /*
1012  * writes a page. user specifies type, and this function handles the
1013  * configuration details.
1014  */
1015 static int write_page(struct mtd_info *mtd, struct nand_chip *chip,
1016                         const uint8_t *buf, bool raw_xfer)
1017 {
1018         struct denali_nand_info *denali = mtd_to_denali(mtd);
1019         dma_addr_t addr = denali->buf.dma_buf;
1020         size_t size = mtd->writesize + mtd->oobsize;
1021         uint32_t irq_status;
1022         uint32_t irq_mask = INTR__DMA_CMD_COMP | INTR__PROGRAM_FAIL;
1023
1024         /*
1025          * if it is a raw xfer, we want to disable ecc and send the spare area.
1026          * !raw_xfer - enable ecc
1027          * raw_xfer - transfer spare
1028          */
1029         setup_ecc_for_xfer(denali, !raw_xfer, raw_xfer);
1030
1031         /* copy buffer into DMA buffer */
1032         memcpy(denali->buf.buf, buf, mtd->writesize);
1033
1034         if (raw_xfer) {
1035                 /* transfer the data to the spare area */
1036                 memcpy(denali->buf.buf + mtd->writesize,
1037                         chip->oob_poi,
1038                         mtd->oobsize);
1039         }
1040
1041         dma_sync_single_for_device(denali->dev, addr, size, DMA_TO_DEVICE);
1042
1043         clear_interrupts(denali);
1044         denali_enable_dma(denali, true);
1045
1046         denali_setup_dma(denali, DENALI_WRITE);
1047
1048         /* wait for operation to complete */
1049         irq_status = wait_for_irq(denali, irq_mask);
1050
1051         if (irq_status == 0) {
1052                 dev_err(denali->dev, "timeout on write_page (type = %d)\n",
1053                         raw_xfer);
1054                 denali->status = NAND_STATUS_FAIL;
1055         }
1056
1057         denali_enable_dma(denali, false);
1058         dma_sync_single_for_cpu(denali->dev, addr, size, DMA_TO_DEVICE);
1059
1060         return 0;
1061 }
1062
1063 /* NAND core entry points */
1064
1065 /*
1066  * this is the callback that the NAND core calls to write a page. Since
1067  * writing a page with ECC or without is similar, all the work is done
1068  * by write_page above.
1069  */
1070 static int denali_write_page(struct mtd_info *mtd, struct nand_chip *chip,
1071                                 const uint8_t *buf, int oob_required, int page)
1072 {
1073         /*
1074          * for regular page writes, we let HW handle all the ECC
1075          * data written to the device.
1076          */
1077         return write_page(mtd, chip, buf, false);
1078 }
1079
1080 /*
1081  * This is the callback that the NAND core calls to write a page without ECC.
1082  * raw access is similar to ECC page writes, so all the work is done in the
1083  * write_page() function above.
1084  */
1085 static int denali_write_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
1086                                  const uint8_t *buf, int oob_required,
1087                                  int page)
1088 {
1089         /*
1090          * for raw page writes, we want to disable ECC and simply write
1091          * whatever data is in the buffer.
1092          */
1093         return write_page(mtd, chip, buf, true);
1094 }
1095
1096 static int denali_write_oob(struct mtd_info *mtd, struct nand_chip *chip,
1097                             int page)
1098 {
1099         return write_oob_data(mtd, chip->oob_poi, page);
1100 }
1101
1102 static int denali_read_oob(struct mtd_info *mtd, struct nand_chip *chip,
1103                            int page)
1104 {
1105         read_oob_data(mtd, chip->oob_poi, page);
1106
1107         return 0;
1108 }
1109
1110 static int denali_read_page(struct mtd_info *mtd, struct nand_chip *chip,
1111                             uint8_t *buf, int oob_required, int page)
1112 {
1113         unsigned int max_bitflips;
1114         struct denali_nand_info *denali = mtd_to_denali(mtd);
1115
1116         dma_addr_t addr = denali->buf.dma_buf;
1117         size_t size = mtd->writesize + mtd->oobsize;
1118
1119         uint32_t irq_status;
1120         uint32_t irq_mask = INTR__ECC_TRANSACTION_DONE | INTR__ECC_ERR;
1121         bool check_erased_page = false;
1122
1123         if (page != denali->page) {
1124                 dev_err(denali->dev,
1125                         "IN %s: page %d is not equal to denali->page %d",
1126                         __func__, page, denali->page);
1127                 BUG();
1128         }
1129
1130         setup_ecc_for_xfer(denali, true, false);
1131
1132         denali_enable_dma(denali, true);
1133         dma_sync_single_for_device(denali->dev, addr, size, DMA_FROM_DEVICE);
1134
1135         clear_interrupts(denali);
1136         denali_setup_dma(denali, DENALI_READ);
1137
1138         /* wait for operation to complete */
1139         irq_status = wait_for_irq(denali, irq_mask);
1140
1141         dma_sync_single_for_cpu(denali->dev, addr, size, DMA_FROM_DEVICE);
1142
1143         memcpy(buf, denali->buf.buf, mtd->writesize);
1144
1145         check_erased_page = handle_ecc(denali, buf, irq_status, &max_bitflips);
1146         denali_enable_dma(denali, false);
1147
1148         if (check_erased_page) {
1149                 read_oob_data(mtd, chip->oob_poi, denali->page);
1150
1151                 /* check ECC failures that may have occurred on erased pages */
1152                 if (check_erased_page) {
1153                         if (!is_erased(buf, mtd->writesize))
1154                                 mtd->ecc_stats.failed++;
1155                         if (!is_erased(buf, mtd->oobsize))
1156                                 mtd->ecc_stats.failed++;
1157                 }
1158         }
1159         return max_bitflips;
1160 }
1161
1162 static int denali_read_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
1163                                 uint8_t *buf, int oob_required, int page)
1164 {
1165         struct denali_nand_info *denali = mtd_to_denali(mtd);
1166         dma_addr_t addr = denali->buf.dma_buf;
1167         size_t size = mtd->writesize + mtd->oobsize;
1168         uint32_t irq_mask = INTR__DMA_CMD_COMP;
1169
1170         if (page != denali->page) {
1171                 dev_err(denali->dev,
1172                         "IN %s: page %d is not equal to denali->page %d",
1173                         __func__, page, denali->page);
1174                 BUG();
1175         }
1176
1177         setup_ecc_for_xfer(denali, false, true);
1178         denali_enable_dma(denali, true);
1179
1180         dma_sync_single_for_device(denali->dev, addr, size, DMA_FROM_DEVICE);
1181
1182         clear_interrupts(denali);
1183         denali_setup_dma(denali, DENALI_READ);
1184
1185         /* wait for operation to complete */
1186         wait_for_irq(denali, irq_mask);
1187
1188         dma_sync_single_for_cpu(denali->dev, addr, size, DMA_FROM_DEVICE);
1189
1190         denali_enable_dma(denali, false);
1191
1192         memcpy(buf, denali->buf.buf, mtd->writesize);
1193         memcpy(chip->oob_poi, denali->buf.buf + mtd->writesize, mtd->oobsize);
1194
1195         return 0;
1196 }
1197
1198 static uint8_t denali_read_byte(struct mtd_info *mtd)
1199 {
1200         struct denali_nand_info *denali = mtd_to_denali(mtd);
1201         uint8_t result = 0xff;
1202
1203         if (denali->buf.head < denali->buf.tail)
1204                 result = denali->buf.buf[denali->buf.head++];
1205
1206         return result;
1207 }
1208
1209 static void denali_select_chip(struct mtd_info *mtd, int chip)
1210 {
1211         struct denali_nand_info *denali = mtd_to_denali(mtd);
1212
1213         spin_lock_irq(&denali->irq_lock);
1214         denali->flash_bank = chip;
1215         spin_unlock_irq(&denali->irq_lock);
1216 }
1217
1218 static int denali_waitfunc(struct mtd_info *mtd, struct nand_chip *chip)
1219 {
1220         struct denali_nand_info *denali = mtd_to_denali(mtd);
1221         int status = denali->status;
1222
1223         denali->status = 0;
1224
1225         return status;
1226 }
1227
1228 static int denali_erase(struct mtd_info *mtd, int page)
1229 {
1230         struct denali_nand_info *denali = mtd_to_denali(mtd);
1231
1232         uint32_t cmd, irq_status;
1233
1234         clear_interrupts(denali);
1235
1236         /* setup page read request for access type */
1237         cmd = MODE_10 | BANK(denali->flash_bank) | page;
1238         index_addr(denali, cmd, 0x1);
1239
1240         /* wait for erase to complete or failure to occur */
1241         irq_status = wait_for_irq(denali, INTR__ERASE_COMP | INTR__ERASE_FAIL);
1242
1243         return irq_status & INTR__ERASE_FAIL ? NAND_STATUS_FAIL : PASS;
1244 }
1245
1246 static void denali_cmdfunc(struct mtd_info *mtd, unsigned int cmd, int col,
1247                            int page)
1248 {
1249         struct denali_nand_info *denali = mtd_to_denali(mtd);
1250         uint32_t addr, id;
1251         int i;
1252
1253         switch (cmd) {
1254         case NAND_CMD_PAGEPROG:
1255                 break;
1256         case NAND_CMD_STATUS:
1257                 read_status(denali);
1258                 break;
1259         case NAND_CMD_READID:
1260         case NAND_CMD_PARAM:
1261                 reset_buf(denali);
1262                 /*
1263                  * sometimes ManufactureId read from register is not right
1264                  * e.g. some of Micron MT29F32G08QAA MLC NAND chips
1265                  * So here we send READID cmd to NAND insteand
1266                  */
1267                 addr = MODE_11 | BANK(denali->flash_bank);
1268                 index_addr(denali, addr | 0, 0x90);
1269                 index_addr(denali, addr | 1, col);
1270                 for (i = 0; i < 8; i++) {
1271                         index_addr_read_data(denali, addr | 2, &id);
1272                         write_byte_to_buf(denali, id);
1273                 }
1274                 break;
1275         case NAND_CMD_READ0:
1276         case NAND_CMD_SEQIN:
1277                 denali->page = page;
1278                 break;
1279         case NAND_CMD_RESET:
1280                 reset_bank(denali);
1281                 break;
1282         case NAND_CMD_READOOB:
1283                 /* TODO: Read OOB data */
1284                 break;
1285         default:
1286                 pr_err(": unsupported command received 0x%x\n", cmd);
1287                 break;
1288         }
1289 }
1290 /* end NAND core entry points */
1291
1292 /* Initialization code to bring the device up to a known good state */
1293 static void denali_hw_init(struct denali_nand_info *denali)
1294 {
1295         /*
1296          * tell driver how many bit controller will skip before
1297          * writing ECC code in OOB, this register may be already
1298          * set by firmware. So we read this value out.
1299          * if this value is 0, just let it be.
1300          */
1301         denali->bbtskipbytes = ioread32(denali->flash_reg +
1302                                                 SPARE_AREA_SKIP_BYTES);
1303         detect_max_banks(denali);
1304         denali_nand_reset(denali);
1305         iowrite32(0x0F, denali->flash_reg + RB_PIN_ENABLED);
1306         iowrite32(CHIP_EN_DONT_CARE__FLAG,
1307                         denali->flash_reg + CHIP_ENABLE_DONT_CARE);
1308
1309         iowrite32(0xffff, denali->flash_reg + SPARE_AREA_MARKER);
1310
1311         /* Should set value for these registers when init */
1312         iowrite32(0, denali->flash_reg + TWO_ROW_ADDR_CYCLES);
1313         iowrite32(1, denali->flash_reg + ECC_ENABLE);
1314         denali_nand_timing_set(denali);
1315         denali_irq_init(denali);
1316 }
1317
1318 /*
1319  * Althogh controller spec said SLC ECC is forceb to be 4bit,
1320  * but denali controller in MRST only support 15bit and 8bit ECC
1321  * correction
1322  */
1323 #define ECC_8BITS       14
1324 #define ECC_15BITS      26
1325
1326 static int denali_ooblayout_ecc(struct mtd_info *mtd, int section,
1327                                 struct mtd_oob_region *oobregion)
1328 {
1329         struct denali_nand_info *denali = mtd_to_denali(mtd);
1330         struct nand_chip *chip = mtd_to_nand(mtd);
1331
1332         if (section)
1333                 return -ERANGE;
1334
1335         oobregion->offset = denali->bbtskipbytes;
1336         oobregion->length = chip->ecc.total;
1337
1338         return 0;
1339 }
1340
1341 static int denali_ooblayout_free(struct mtd_info *mtd, int section,
1342                                  struct mtd_oob_region *oobregion)
1343 {
1344         struct denali_nand_info *denali = mtd_to_denali(mtd);
1345         struct nand_chip *chip = mtd_to_nand(mtd);
1346
1347         if (section)
1348                 return -ERANGE;
1349
1350         oobregion->offset = chip->ecc.total + denali->bbtskipbytes;
1351         oobregion->length = mtd->oobsize - oobregion->offset;
1352
1353         return 0;
1354 }
1355
1356 static const struct mtd_ooblayout_ops denali_ooblayout_ops = {
1357         .ecc = denali_ooblayout_ecc,
1358         .free = denali_ooblayout_free,
1359 };
1360
1361 static uint8_t bbt_pattern[] = {'B', 'b', 't', '0' };
1362 static uint8_t mirror_pattern[] = {'1', 't', 'b', 'B' };
1363
1364 static struct nand_bbt_descr bbt_main_descr = {
1365         .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
1366                 | NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP,
1367         .offs = 8,
1368         .len = 4,
1369         .veroffs = 12,
1370         .maxblocks = 4,
1371         .pattern = bbt_pattern,
1372 };
1373
1374 static struct nand_bbt_descr bbt_mirror_descr = {
1375         .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
1376                 | NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP,
1377         .offs = 8,
1378         .len = 4,
1379         .veroffs = 12,
1380         .maxblocks = 4,
1381         .pattern = mirror_pattern,
1382 };
1383
1384 /* initialize driver data structures */
1385 static void denali_drv_init(struct denali_nand_info *denali)
1386 {
1387         /*
1388          * the completion object will be used to notify
1389          * the callee that the interrupt is done
1390          */
1391         init_completion(&denali->complete);
1392
1393         /*
1394          * the spinlock will be used to synchronize the ISR with any
1395          * element that might be access shared data (interrupt status)
1396          */
1397         spin_lock_init(&denali->irq_lock);
1398
1399         /* indicate that MTD has not selected a valid bank yet */
1400         denali->flash_bank = CHIP_SELECT_INVALID;
1401
1402         /* initialize our irq_status variable to indicate no interrupts */
1403         denali->irq_status = 0;
1404 }
1405
1406 static int denali_multidev_fixup(struct denali_nand_info *denali)
1407 {
1408         struct nand_chip *chip = &denali->nand;
1409         struct mtd_info *mtd = nand_to_mtd(chip);
1410
1411         /*
1412          * Support for multi device:
1413          * When the IP configuration is x16 capable and two x8 chips are
1414          * connected in parallel, DEVICES_CONNECTED should be set to 2.
1415          * In this case, the core framework knows nothing about this fact,
1416          * so we should tell it the _logical_ pagesize and anything necessary.
1417          */
1418         denali->devnum = ioread32(denali->flash_reg + DEVICES_CONNECTED);
1419
1420         /*
1421          * On some SoCs, DEVICES_CONNECTED is not auto-detected.
1422          * For those, DEVICES_CONNECTED is left to 0.  Set 1 if it is the case.
1423          */
1424         if (denali->devnum == 0) {
1425                 denali->devnum = 1;
1426                 iowrite32(1, denali->flash_reg + DEVICES_CONNECTED);
1427         }
1428
1429         if (denali->devnum == 1)
1430                 return 0;
1431
1432         if (denali->devnum != 2) {
1433                 dev_err(denali->dev, "unsupported number of devices %d\n",
1434                         denali->devnum);
1435                 return -EINVAL;
1436         }
1437
1438         /* 2 chips in parallel */
1439         mtd->size <<= 1;
1440         mtd->erasesize <<= 1;
1441         mtd->writesize <<= 1;
1442         mtd->oobsize <<= 1;
1443         chip->chipsize <<= 1;
1444         chip->page_shift += 1;
1445         chip->phys_erase_shift += 1;
1446         chip->bbt_erase_shift += 1;
1447         chip->chip_shift += 1;
1448         chip->pagemask <<= 1;
1449         chip->ecc.size <<= 1;
1450         chip->ecc.bytes <<= 1;
1451         chip->ecc.strength <<= 1;
1452         denali->bbtskipbytes <<= 1;
1453
1454         return 0;
1455 }
1456
1457 int denali_init(struct denali_nand_info *denali)
1458 {
1459         struct nand_chip *chip = &denali->nand;
1460         struct mtd_info *mtd = nand_to_mtd(chip);
1461         int ret;
1462
1463         if (denali->platform == INTEL_CE4100) {
1464                 /*
1465                  * Due to a silicon limitation, we can only support
1466                  * ONFI timing mode 1 and below.
1467                  */
1468                 if (onfi_timing_mode < -1 || onfi_timing_mode > 1) {
1469                         pr_err("Intel CE4100 only supports ONFI timing mode 1 or below\n");
1470                         return -EINVAL;
1471                 }
1472         }
1473
1474         /* allocate a temporary buffer for nand_scan_ident() */
1475         denali->buf.buf = devm_kzalloc(denali->dev, PAGE_SIZE,
1476                                         GFP_DMA | GFP_KERNEL);
1477         if (!denali->buf.buf)
1478                 return -ENOMEM;
1479
1480         mtd->dev.parent = denali->dev;
1481         denali_hw_init(denali);
1482         denali_drv_init(denali);
1483
1484         /* Request IRQ after all the hardware initialization is finished */
1485         ret = devm_request_irq(denali->dev, denali->irq, denali_isr,
1486                                IRQF_SHARED, DENALI_NAND_NAME, denali);
1487         if (ret) {
1488                 dev_err(denali->dev, "Unable to request IRQ\n");
1489                 return ret;
1490         }
1491
1492         /* now that our ISR is registered, we can enable interrupts */
1493         denali_set_intr_modes(denali, true);
1494         mtd->name = "denali-nand";
1495         nand_set_flash_node(chip, denali->dev->of_node);
1496
1497         /* register the driver with the NAND core subsystem */
1498         chip->select_chip = denali_select_chip;
1499         chip->cmdfunc = denali_cmdfunc;
1500         chip->read_byte = denali_read_byte;
1501         chip->waitfunc = denali_waitfunc;
1502
1503         /*
1504          * scan for NAND devices attached to the controller
1505          * this is the first stage in a two step process to register
1506          * with the nand subsystem
1507          */
1508         ret = nand_scan_ident(mtd, denali->max_banks, NULL);
1509         if (ret)
1510                 goto failed_req_irq;
1511
1512         /* allocate the right size buffer now */
1513         devm_kfree(denali->dev, denali->buf.buf);
1514         denali->buf.buf = devm_kzalloc(denali->dev,
1515                              mtd->writesize + mtd->oobsize,
1516                              GFP_KERNEL);
1517         if (!denali->buf.buf) {
1518                 ret = -ENOMEM;
1519                 goto failed_req_irq;
1520         }
1521
1522         /* Is 32-bit DMA supported? */
1523         ret = dma_set_mask(denali->dev, DMA_BIT_MASK(32));
1524         if (ret) {
1525                 dev_err(denali->dev, "No usable DMA configuration\n");
1526                 goto failed_req_irq;
1527         }
1528
1529         denali->buf.dma_buf = dma_map_single(denali->dev, denali->buf.buf,
1530                              mtd->writesize + mtd->oobsize,
1531                              DMA_BIDIRECTIONAL);
1532         if (dma_mapping_error(denali->dev, denali->buf.dma_buf)) {
1533                 dev_err(denali->dev, "Failed to map DMA buffer\n");
1534                 ret = -EIO;
1535                 goto failed_req_irq;
1536         }
1537
1538         /*
1539          * second stage of the NAND scan
1540          * this stage requires information regarding ECC and
1541          * bad block management.
1542          */
1543
1544         /* Bad block management */
1545         chip->bbt_td = &bbt_main_descr;
1546         chip->bbt_md = &bbt_mirror_descr;
1547
1548         /* skip the scan for now until we have OOB read and write support */
1549         chip->bbt_options |= NAND_BBT_USE_FLASH;
1550         chip->options |= NAND_SKIP_BBTSCAN;
1551         chip->ecc.mode = NAND_ECC_HW_SYNDROME;
1552
1553         /* no subpage writes on denali */
1554         chip->options |= NAND_NO_SUBPAGE_WRITE;
1555
1556         /*
1557          * Denali Controller only support 15bit and 8bit ECC in MRST,
1558          * so just let controller do 15bit ECC for MLC and 8bit ECC for
1559          * SLC if possible.
1560          * */
1561         if (!nand_is_slc(chip) &&
1562                         (mtd->oobsize > (denali->bbtskipbytes +
1563                         ECC_15BITS * (mtd->writesize /
1564                         ECC_SECTOR_SIZE)))) {
1565                 /* if MLC OOB size is large enough, use 15bit ECC*/
1566                 chip->ecc.strength = 15;
1567                 chip->ecc.bytes = ECC_15BITS;
1568                 iowrite32(15, denali->flash_reg + ECC_CORRECTION);
1569         } else if (mtd->oobsize < (denali->bbtskipbytes +
1570                         ECC_8BITS * (mtd->writesize /
1571                         ECC_SECTOR_SIZE))) {
1572                 pr_err("Your NAND chip OOB is not large enough to contain 8bit ECC correction codes");
1573                 goto failed_req_irq;
1574         } else {
1575                 chip->ecc.strength = 8;
1576                 chip->ecc.bytes = ECC_8BITS;
1577                 iowrite32(8, denali->flash_reg + ECC_CORRECTION);
1578         }
1579
1580         mtd_set_ooblayout(mtd, &denali_ooblayout_ops);
1581
1582         /* override the default read operations */
1583         chip->ecc.size = ECC_SECTOR_SIZE;
1584         chip->ecc.read_page = denali_read_page;
1585         chip->ecc.read_page_raw = denali_read_page_raw;
1586         chip->ecc.write_page = denali_write_page;
1587         chip->ecc.write_page_raw = denali_write_page_raw;
1588         chip->ecc.read_oob = denali_read_oob;
1589         chip->ecc.write_oob = denali_write_oob;
1590         chip->erase = denali_erase;
1591
1592         ret = denali_multidev_fixup(denali);
1593         if (ret)
1594                 goto failed_req_irq;
1595
1596         ret = nand_scan_tail(mtd);
1597         if (ret)
1598                 goto failed_req_irq;
1599
1600         ret = mtd_device_register(mtd, NULL, 0);
1601         if (ret) {
1602                 dev_err(denali->dev, "Failed to register MTD: %d\n", ret);
1603                 goto failed_req_irq;
1604         }
1605         return 0;
1606
1607 failed_req_irq:
1608         denali_irq_cleanup(denali->irq, denali);
1609
1610         return ret;
1611 }
1612 EXPORT_SYMBOL(denali_init);
1613
1614 /* driver exit point */
1615 void denali_remove(struct denali_nand_info *denali)
1616 {
1617         struct mtd_info *mtd = nand_to_mtd(&denali->nand);
1618         /*
1619          * Pre-compute DMA buffer size to avoid any problems in case
1620          * nand_release() ever changes in a way that mtd->writesize and
1621          * mtd->oobsize are not reliable after this call.
1622          */
1623         int bufsize = mtd->writesize + mtd->oobsize;
1624
1625         nand_release(mtd);
1626         denali_irq_cleanup(denali->irq, denali);
1627         dma_unmap_single(denali->dev, denali->buf.dma_buf, bufsize,
1628                          DMA_BIDIRECTIONAL);
1629 }
1630 EXPORT_SYMBOL(denali_remove);