git.oblomov.eu Git - linux-2.6/blob - drivers/mtd/nand/au1550nd.c

   1 /*
   2  *  drivers/mtd/nand/au1550nd.c
   3  *
   4  *  Copyright (C) 2004 Embedded Edge, LLC
   5  *
   6  * $Id: au1550nd.c,v 1.13 2005/11/07 11:14:30 gleixner Exp $
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  *
  12  */
  13
  14 #include <linux/slab.h>
  15 #include <linux/init.h>
  16 #include <linux/module.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/mtd/mtd.h>
  19 #include <linux/mtd/nand.h>
  20 #include <linux/mtd/partitions.h>
  21 #include <linux/version.h>
  22 #include <asm/io.h>
  23
  24 #include <asm/mach-au1x00/au1xxx.h>
  25
  26 /*
  27  * MTD structure for NAND controller
  28  */
  29 static struct mtd_info *au1550_mtd = NULL;
  30 static void __iomem *p_nand;
  31 static int nand_width = 1;      /* default x8 */
  32 static void (*au1550_write_byte)(struct mtd_info *, u_char);
  33
  34 /*
  35  * Define partitions for flash device
  36  */
  37 static const struct mtd_partition partition_info[] = {
  38         {
  39          .name = "NAND FS 0",
  40          .offset = 0,
  41          .size = 8 * 1024 * 1024},
  42         {
  43          .name = "NAND FS 1",
  44          .offset = MTDPART_OFS_APPEND,
  45          .size = MTDPART_SIZ_FULL}
  46 };
  47
  48 /**
  49  * au_read_byte -  read one byte from the chip
  50  * @mtd:        MTD device structure
  51  *
  52  *  read function for 8bit buswith
  53  */
  54 static u_char au_read_byte(struct mtd_info *mtd)
  55 {
  56         struct nand_chip *this = mtd->priv;
  57         u_char ret = readb(this->IO_ADDR_R);
  58         au_sync();
  59         return ret;
  60 }
  61
  62 /**
  63  * au_write_byte -  write one byte to the chip
  64  * @mtd:        MTD device structure
  65  * @byte:       pointer to data byte to write
  66  *
  67  *  write function for 8it buswith
  68  */
  69 static void au_write_byte(struct mtd_info *mtd, u_char byte)
  70 {
  71         struct nand_chip *this = mtd->priv;
  72         writeb(byte, this->IO_ADDR_W);
  73         au_sync();
  74 }
  75
  76 /**
  77  * au_read_byte16 -  read one byte endianess aware from the chip
  78  * @mtd:        MTD device structure
  79  *
  80  *  read function for 16bit buswith with
  81  * endianess conversion
  82  */
  83 static u_char au_read_byte16(struct mtd_info *mtd)
  84 {
  85         struct nand_chip *this = mtd->priv;
  86         u_char ret = (u_char) cpu_to_le16(readw(this->IO_ADDR_R));
  87         au_sync();
  88         return ret;
  89 }
  90
  91 /**
  92  * au_write_byte16 -  write one byte endianess aware to the chip
  93  * @mtd:        MTD device structure
  94  * @byte:       pointer to data byte to write
  95  *
  96  *  write function for 16bit buswith with
  97  * endianess conversion
  98  */
  99 static void au_write_byte16(struct mtd_info *mtd, u_char byte)
 100 {
 101         struct nand_chip *this = mtd->priv;
 102         writew(le16_to_cpu((u16) byte), this->IO_ADDR_W);
 103         au_sync();
 104 }
 105
 106 /**
 107  * au_read_word -  read one word from the chip
 108  * @mtd:        MTD device structure
 109  *
 110  *  read function for 16bit buswith without
 111  * endianess conversion
 112  */
 113 static u16 au_read_word(struct mtd_info *mtd)
 114 {
 115         struct nand_chip *this = mtd->priv;
 116         u16 ret = readw(this->IO_ADDR_R);
 117         au_sync();
 118         return ret;
 119 }
 120
 121 /**
 122  * au_write_buf -  write buffer to chip
 123  * @mtd:        MTD device structure
 124  * @buf:        data buffer
 125  * @len:        number of bytes to write
 126  *
 127  *  write function for 8bit buswith
 128  */
 129 static void au_write_buf(struct mtd_info *mtd, const u_char *buf, int len)
 130 {
 131         int i;
 132         struct nand_chip *this = mtd->priv;
 133
 134         for (i = 0; i < len; i++) {
 135                 writeb(buf[i], this->IO_ADDR_W);
 136                 au_sync();
 137         }
 138 }
 139
 140 /**
 141  * au_read_buf -  read chip data into buffer
 142  * @mtd:        MTD device structure
 143  * @buf:        buffer to store date
 144  * @len:        number of bytes to read
 145  *
 146  *  read function for 8bit buswith
 147  */
 148 static void au_read_buf(struct mtd_info *mtd, u_char *buf, int len)
 149 {
 150         int i;
 151         struct nand_chip *this = mtd->priv;
 152
 153         for (i = 0; i < len; i++) {
 154                 buf[i] = readb(this->IO_ADDR_R);
 155                 au_sync();
 156         }
 157 }
 158
 159 /**
 160  * au_verify_buf -  Verify chip data against buffer
 161  * @mtd:        MTD device structure
 162  * @buf:        buffer containing the data to compare
 163  * @len:        number of bytes to compare
 164  *
 165  *  verify function for 8bit buswith
 166  */
 167 static int au_verify_buf(struct mtd_info *mtd, const u_char *buf, int len)
 168 {
 169         int i;
 170         struct nand_chip *this = mtd->priv;
 171
 172         for (i = 0; i < len; i++) {
 173                 if (buf[i] != readb(this->IO_ADDR_R))
 174                         return -EFAULT;
 175                 au_sync();
 176         }
 177
 178         return 0;
 179 }
 180
 181 /**
 182  * au_write_buf16 -  write buffer to chip
 183  * @mtd:        MTD device structure
 184  * @buf:        data buffer
 185  * @len:        number of bytes to write
 186  *
 187  *  write function for 16bit buswith
 188  */
 189 static void au_write_buf16(struct mtd_info *mtd, const u_char *buf, int len)
 190 {
 191         int i;
 192         struct nand_chip *this = mtd->priv;
 193         u16 *p = (u16 *) buf;
 194         len >>= 1;
 195
 196         for (i = 0; i < len; i++) {
 197                 writew(p[i], this->IO_ADDR_W);
 198                 au_sync();
 199         }
 200
 201 }
 202
 203 /**
 204  * au_read_buf16 -  read chip data into buffer
 205  * @mtd:        MTD device structure
 206  * @buf:        buffer to store date
 207  * @len:        number of bytes to read
 208  *
 209  *  read function for 16bit buswith
 210  */
 211 static void au_read_buf16(struct mtd_info *mtd, u_char *buf, int len)
 212 {
 213         int i;
 214         struct nand_chip *this = mtd->priv;
 215         u16 *p = (u16 *) buf;
 216         len >>= 1;
 217
 218         for (i = 0; i < len; i++) {
 219                 p[i] = readw(this->IO_ADDR_R);
 220                 au_sync();
 221         }
 222 }
 223
 224 /**
 225  * au_verify_buf16 -  Verify chip data against buffer
 226  * @mtd:        MTD device structure
 227  * @buf:        buffer containing the data to compare
 228  * @len:        number of bytes to compare
 229  *
 230  *  verify function for 16bit buswith
 231  */
 232 static int au_verify_buf16(struct mtd_info *mtd, const u_char *buf, int len)
 233 {
 234         int i;
 235         struct nand_chip *this = mtd->priv;
 236         u16 *p = (u16 *) buf;
 237         len >>= 1;
 238
 239         for (i = 0; i < len; i++) {
 240                 if (p[i] != readw(this->IO_ADDR_R))
 241                         return -EFAULT;
 242                 au_sync();
 243         }
 244         return 0;
 245 }
 246
 247 /* Select the chip by setting nCE to low */
 248 #define NAND_CTL_SETNCE         1
 249 /* Deselect the chip by setting nCE to high */
 250 #define NAND_CTL_CLRNCE         2
 251 /* Select the command latch by setting CLE to high */
 252 #define NAND_CTL_SETCLE         3
 253 /* Deselect the command latch by setting CLE to low */
 254 #define NAND_CTL_CLRCLE         4
 255 /* Select the address latch by setting ALE to high */
 256 #define NAND_CTL_SETALE         5
 257 /* Deselect the address latch by setting ALE to low */
 258 #define NAND_CTL_CLRALE         6
 259
 260 static void au1550_hwcontrol(struct mtd_info *mtd, int cmd)
 261 {
 262         register struct nand_chip *this = mtd->priv;
 263
 264         switch (cmd) {
 265
 266         case NAND_CTL_SETCLE:
 267                 this->IO_ADDR_W = p_nand + MEM_STNAND_CMD;
 268                 break;
 269
 270         case NAND_CTL_CLRCLE:
 271                 this->IO_ADDR_W = p_nand + MEM_STNAND_DATA;
 272                 break;
 273
 274         case NAND_CTL_SETALE:
 275                 this->IO_ADDR_W = p_nand + MEM_STNAND_ADDR;
 276                 break;
 277
 278         case NAND_CTL_CLRALE:
 279                 this->IO_ADDR_W = p_nand + MEM_STNAND_DATA;
 280                 /* FIXME: Nobody knows why this is necessary,
 281                  * but it works only that way */
 282                 udelay(1);
 283                 break;
 284
 285         case NAND_CTL_SETNCE:
 286                 /* assert (force assert) chip enable */
 287                 au_writel((1 << (4 + NAND_CS)), MEM_STNDCTL);
 288                 break;
 289
 290         case NAND_CTL_CLRNCE:
 291                 /* deassert chip enable */
 292                 au_writel(0, MEM_STNDCTL);
 293                 break;
 294         }
 295
 296         this->IO_ADDR_R = this->IO_ADDR_W;
 297
 298         /* Drain the writebuffer */
 299         au_sync();
 300 }
 301
 302 int au1550_device_ready(struct mtd_info *mtd)
 303 {
 304         int ret = (au_readl(MEM_STSTAT) & 0x1) ? 1 : 0;
 305         au_sync();
 306         return ret;
 307 }
 308
 309 /**
 310  * au1550_select_chip - control -CE line
 311  *      Forbid driving -CE manually permitting the NAND controller to do this.
 312  *      Keeping -CE asserted during the whole sector reads interferes with the
 313  *      NOR flash and PCMCIA drivers as it causes contention on the static bus.
 314  *      We only have to hold -CE low for the NAND read commands since the flash
 315  *      chip needs it to be asserted during chip not ready time but the NAND
 316  *      controller keeps it released.
 317  *
 318  * @mtd:        MTD device structure
 319  * @chip:       chipnumber to select, -1 for deselect
 320  */
 321 static void au1550_select_chip(struct mtd_info *mtd, int chip)
 322 {
 323 }
 324
 325 /**
 326  * au1550_command - Send command to NAND device
 327  * @mtd:        MTD device structure
 328  * @command:    the command to be sent
 329  * @column:     the column address for this command, -1 if none
 330  * @page_addr:  the page address for this command, -1 if none
 331  */
 332 static void au1550_command(struct mtd_info *mtd, unsigned command, int column, int page_addr)
 333 {
 334         register struct nand_chip *this = mtd->priv;
 335         int ce_override = 0, i;
 336         ulong flags;
 337
 338         /* Begin command latch cycle */
 339         au1550_hwcontrol(mtd, NAND_CTL_SETCLE);
 340         /*
 341          * Write out the command to the device.
 342          */
 343         if (command == NAND_CMD_SEQIN) {
 344                 int readcmd;
 345
 346                 if (column >= mtd->writesize) {
 347                         /* OOB area */
 348                         column -= mtd->writesize;
 349                         readcmd = NAND_CMD_READOOB;
 350                 } else if (column < 256) {
 351                         /* First 256 bytes --> READ0 */
 352                         readcmd = NAND_CMD_READ0;
 353                 } else {
 354                         column -= 256;
 355                         readcmd = NAND_CMD_READ1;
 356                 }
 357                 au1550_write_byte(mtd, readcmd);
 358         }
 359         au1550_write_byte(mtd, command);
 360
 361         /* Set ALE and clear CLE to start address cycle */
 362         au1550_hwcontrol(mtd, NAND_CTL_CLRCLE);
 363
 364         if (column != -1 || page_addr != -1) {
 365                 au1550_hwcontrol(mtd, NAND_CTL_SETALE);
 366
 367                 /* Serially input address */
 368                 if (column != -1) {
 369                         /* Adjust columns for 16 bit buswidth */
 370                         if (this->options & NAND_BUSWIDTH_16)
 371                                 column >>= 1;
 372                         au1550_write_byte(mtd, column);
 373                 }
 374                 if (page_addr != -1) {
 375                         au1550_write_byte(mtd, (u8)(page_addr & 0xff));
 376
 377                         if (command == NAND_CMD_READ0 ||
 378                             command == NAND_CMD_READ1 ||
 379                             command == NAND_CMD_READOOB) {
 380                                 /*
 381                                  * NAND controller will release -CE after
 382                                  * the last address byte is written, so we'll
 383                                  * have to forcibly assert it. No interrupts
 384                                  * are allowed while we do this as we don't
 385                                  * want the NOR flash or PCMCIA drivers to
 386                                  * steal our precious bytes of data...
 387                                  */
 388                                 ce_override = 1;
 389                                 local_irq_save(flags);
 390                                 au1550_hwcontrol(mtd, NAND_CTL_SETNCE);
 391                         }
 392
 393                         au1550_write_byte(mtd, (u8)(page_addr >> 8));
 394
 395                         /* One more address cycle for devices > 32MiB */
 396                         if (this->chipsize > (32 << 20))
 397                                 au1550_write_byte(mtd, (u8)((page_addr >> 16) & 0x0f));
 398                 }
 399                 /* Latch in address */
 400                 au1550_hwcontrol(mtd, NAND_CTL_CLRALE);
 401         }
 402
 403         /*
 404          * Program and erase have their own busy handlers.
 405          * Status and sequential in need no delay.
 406          */
 407         switch (command) {
 408
 409         case NAND_CMD_PAGEPROG:
 410         case NAND_CMD_ERASE1:
 411         case NAND_CMD_ERASE2:
 412         case NAND_CMD_SEQIN:
 413         case NAND_CMD_STATUS:
 414                 return;
 415
 416         case NAND_CMD_RESET:
 417                 break;
 418
 419         case NAND_CMD_READ0:
 420         case NAND_CMD_READ1:
 421         case NAND_CMD_READOOB:
 422                 /* Check if we're really driving -CE low (just in case) */
 423                 if (unlikely(!ce_override))
 424                         break;
 425
 426                 /* Apply a short delay always to ensure that we do wait tWB. */
 427                 ndelay(100);
 428                 /* Wait for a chip to become ready... */
 429                 for (i = this->chip_delay; !this->dev_ready(mtd) && i > 0; --i)
 430                         udelay(1);
 431
 432                 /* Release -CE and re-enable interrupts. */
 433                 au1550_hwcontrol(mtd, NAND_CTL_CLRNCE);
 434                 local_irq_restore(flags);
 435                 return;
 436         }
 437         /* Apply this short delay always to ensure that we do wait tWB. */
 438         ndelay(100);
 439
 440         while(!this->dev_ready(mtd));
 441 }
 442
 443
 444 /*
 445  * Main initialization routine
 446  */
 447 static int __init au1xxx_nand_init(void)
 448 {
 449         struct nand_chip *this;
 450         u16 boot_swapboot = 0;  /* default value */
 451         int retval;
 452         u32 mem_staddr;
 453         u32 nand_phys;
 454
 455         /* Allocate memory for MTD device structure and private data */
 456         au1550_mtd = kmalloc(sizeof(struct mtd_info) + sizeof(struct nand_chip), GFP_KERNEL);
 457         if (!au1550_mtd) {
 458                 printk("Unable to allocate NAND MTD dev structure.\n");
 459                 return -ENOMEM;
 460         }
 461
 462         /* Get pointer to private data */
 463         this = (struct nand_chip *)(&au1550_mtd[1]);
 464
 465         /* Initialize structures */
 466         memset(au1550_mtd, 0, sizeof(struct mtd_info));
 467         memset(this, 0, sizeof(struct nand_chip));
 468
 469         /* Link the private data with the MTD structure */
 470         au1550_mtd->priv = this;
 471         au1550_mtd->owner = THIS_MODULE;
 472
 473
 474         /* MEM_STNDCTL: disable ints, disable nand boot */
 475         au_writel(0, MEM_STNDCTL);
 476
 477 #ifdef CONFIG_MIPS_PB1550
 478         /* set gpio206 high */
 479         au_writel(au_readl(GPIO2_DIR) & ~(1 << 6), GPIO2_DIR);
 480
 481         boot_swapboot = (au_readl(MEM_STSTAT) & (0x7 << 1)) | ((bcsr->status >> 6) & 0x1);
 482         switch (boot_swapboot) {
 483         case 0:
 484         case 2:
 485         case 8:
 486         case 0xC:
 487         case 0xD:
 488                 /* x16 NAND Flash */
 489                 nand_width = 0;
 490                 break;
 491         case 1:
 492         case 9:
 493         case 3:
 494         case 0xE:
 495         case 0xF:
 496                 /* x8 NAND Flash */
 497                 nand_width = 1;
 498                 break;
 499         default:
 500                 printk("Pb1550 NAND: bad boot:swap\n");
 501                 retval = -EINVAL;
 502                 goto outmem;
 503         }
 504 #endif
 505
 506         /* Configure chip-select; normally done by boot code, e.g. YAMON */
 507 #ifdef NAND_STCFG
 508         if (NAND_CS == 0) {
 509                 au_writel(NAND_STCFG,  MEM_STCFG0);
 510                 au_writel(NAND_STTIME, MEM_STTIME0);
 511                 au_writel(NAND_STADDR, MEM_STADDR0);
 512         }
 513         if (NAND_CS == 1) {
 514                 au_writel(NAND_STCFG,  MEM_STCFG1);
 515                 au_writel(NAND_STTIME, MEM_STTIME1);
 516                 au_writel(NAND_STADDR, MEM_STADDR1);
 517         }
 518         if (NAND_CS == 2) {
 519                 au_writel(NAND_STCFG,  MEM_STCFG2);
 520                 au_writel(NAND_STTIME, MEM_STTIME2);
 521                 au_writel(NAND_STADDR, MEM_STADDR2);
 522         }
 523         if (NAND_CS == 3) {
 524                 au_writel(NAND_STCFG,  MEM_STCFG3);
 525                 au_writel(NAND_STTIME, MEM_STTIME3);
 526                 au_writel(NAND_STADDR, MEM_STADDR3);
 527         }
 528 #endif
 529
 530         /* Locate NAND chip-select in order to determine NAND phys address */
 531         mem_staddr = 0x00000000;
 532         if (((au_readl(MEM_STCFG0) & 0x7) == 0x5) && (NAND_CS == 0))
 533                 mem_staddr = au_readl(MEM_STADDR0);
 534         else if (((au_readl(MEM_STCFG1) & 0x7) == 0x5) && (NAND_CS == 1))
 535                 mem_staddr = au_readl(MEM_STADDR1);
 536         else if (((au_readl(MEM_STCFG2) & 0x7) == 0x5) && (NAND_CS == 2))
 537                 mem_staddr = au_readl(MEM_STADDR2);
 538         else if (((au_readl(MEM_STCFG3) & 0x7) == 0x5) && (NAND_CS == 3))
 539                 mem_staddr = au_readl(MEM_STADDR3);
 540
 541         if (mem_staddr == 0x00000000) {
 542                 printk("Au1xxx NAND: ERROR WITH NAND CHIP-SELECT\n");
 543                 kfree(au1550_mtd);
 544                 return 1;
 545         }
 546         nand_phys = (mem_staddr << 4) & 0xFFFC0000;
 547
 548         p_nand = (void __iomem *)ioremap(nand_phys, 0x1000);
 549
 550         /* make controller and MTD agree */
 551         if (NAND_CS == 0)
 552                 nand_width = au_readl(MEM_STCFG0) & (1 << 22);
 553         if (NAND_CS == 1)
 554                 nand_width = au_readl(MEM_STCFG1) & (1 << 22);
 555         if (NAND_CS == 2)
 556                 nand_width = au_readl(MEM_STCFG2) & (1 << 22);
 557         if (NAND_CS == 3)
 558                 nand_width = au_readl(MEM_STCFG3) & (1 << 22);
 559
 560         /* Set address of hardware control function */
 561         this->dev_ready = au1550_device_ready;
 562         this->select_chip = au1550_select_chip;
 563         this->cmdfunc = au1550_command;
 564
 565         /* 30 us command delay time */
 566         this->chip_delay = 30;
 567         this->ecc.mode = NAND_ECC_SOFT;
 568
 569         this->options = NAND_NO_AUTOINCR;
 570
 571         if (!nand_width)
 572                 this->options |= NAND_BUSWIDTH_16;
 573
 574         this->read_byte = (!nand_width) ? au_read_byte16 : au_read_byte;
 575         au1550_write_byte = (!nand_width) ? au_write_byte16 : au_write_byte;
 576         this->read_word = au_read_word;
 577         this->write_buf = (!nand_width) ? au_write_buf16 : au_write_buf;
 578         this->read_buf = (!nand_width) ? au_read_buf16 : au_read_buf;
 579         this->verify_buf = (!nand_width) ? au_verify_buf16 : au_verify_buf;
 580
 581         /* Scan to find existence of the device */
 582         if (nand_scan(au1550_mtd, 1)) {
 583                 retval = -ENXIO;
 584                 goto outio;
 585         }
 586
 587         /* Register the partitions */
 588         add_mtd_partitions(au1550_mtd, partition_info, ARRAY_SIZE(partition_info));
 589
 590         return 0;
 591
 592  outio:
 593         iounmap((void *)p_nand);
 594
 595  outmem:
 596         kfree(au1550_mtd);
 597         return retval;
 598 }
 599
 600 module_init(au1xxx_nand_init);
 601
 602 /*
 603  * Clean up routine
 604  */
 605 static void __exit au1550_cleanup(void)
 606 {
 607         struct nand_chip *this = (struct nand_chip *)&au1550_mtd[1];
 608
 609         /* Release resources, unregister device */
 610         nand_release(au1550_mtd);
 611
 612         /* Free the MTD device structure */
 613         kfree(au1550_mtd);
 614
 615         /* Unmap */
 616         iounmap((void *)p_nand);
 617 }
 618
 619 module_exit(au1550_cleanup);
 620
 621 MODULE_LICENSE("GPL");
 622 MODULE_AUTHOR("Embedded Edge, LLC");
 623 MODULE_DESCRIPTION("Board-specific glue layer for NAND flash on Pb1550 board");