开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
doc2000.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：32k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

doc2000.c：源码内容
  2. /*
  3.  * Linux driver for Disk-On-Chip 2000 and Millennium
  4.  * (c) 1999 Machine Vision Holdings, Inc.
  5.  * (c) 1999, 2000 David Woodhouse <dwmw2@infradead.org>
  6.  *
  7.  * $Id: doc2000.c,v 1.46 2001/10/02 15:05:13 dwmw2 Exp $
  8.  */
  10. #include <linux/kernel.h>
  11. #include <linux/module.h>
  12. #include <asm/errno.h>
  13. #include <asm/io.h>
  14. #include <asm/uaccess.h>
  15. #include <linux/miscdevice.h>
  16. #include <linux/pci.h>
  17. #include <linux/delay.h>
  18. #include <linux/slab.h>
  19. #include <linux/sched.h>
  20. #include <linux/init.h>
  21. #include <linux/types.h>
  23. #include <linux/mtd/mtd.h>
  24. #include <linux/mtd/nand.h>
  25. #include <linux/mtd/nand_ids.h>
  26. #include <linux/mtd/doc2000.h>
  28. #define DOC_SUPPORT_2000
  29. #define DOC_SUPPORT_MILLENNIUM
  31. #ifdef DOC_SUPPORT_2000
  32. #define DoC_is_2000(doc) (doc->ChipID == DOC_ChipID_Doc2k)
  33. #else
  34. #define DoC_is_2000(doc) (0)
  35. #endif
  37. #ifdef DOC_SUPPORT_MILLENNIUM
  38. #define DoC_is_Millennium(doc) (doc->ChipID == DOC_ChipID_DocMil)
  39. #else
  40. #define DoC_is_Millennium(doc) (0)
  41. #endif
  43. /* #define ECC_DEBUG */
  45. /* I have no idea why some DoC chips can not use memcpy_from|to_io().
  46.  * This may be due to the different revisions of the ASIC controller built-in or
  47.  * simplily a QA/Bug issue. Who knows ?? If you have trouble, please uncomment
  48.  * this:
  49.  #undef USE_MEMCPY
  50. */
  52. static int doc_read(struct mtd_info *mtd, loff_t from, size_t len,
  53.     size_t *retlen, u_char *buf);
  54. static int doc_write(struct mtd_info *mtd, loff_t to, size_t len,
  55.      size_t *retlen, const u_char *buf);
  56. static int doc_read_ecc(struct mtd_info *mtd, loff_t from, size_t len,
  57. size_t *retlen, u_char *buf, u_char *eccbuf);
  58. static int doc_write_ecc(struct mtd_info *mtd, loff_t to, size_t len,
  59.  size_t *retlen, const u_char *buf, u_char *eccbuf);
  60. static int doc_read_oob(struct mtd_info *mtd, loff_t ofs, size_t len,
  61. size_t *retlen, u_char *buf);
  62. static int doc_write_oob(struct mtd_info *mtd, loff_t ofs, size_t len,
  63.  size_t *retlen, const u_char *buf);
  64. static int doc_write_oob_nolock(struct mtd_info *mtd, loff_t ofs, size_t len,
  65.  size_t *retlen, const u_char *buf);
  66. static int doc_erase (struct mtd_info *mtd, struct erase_info *instr);
  68. static struct mtd_info *doc2klist = NULL;
  70. /* Perform the required delay cycles by reading from the appropriate register */
  71. static void DoC_Delay(struct DiskOnChip *doc, unsigned short cycles)
  72. {
  73. volatile char dummy;
  74. int i;
  76. for (i = 0; i < cycles; i++) {
  77. if (DoC_is_Millennium(doc))
  78. dummy = ReadDOC(doc->virtadr, NOP);
  79. else
  80. dummy = ReadDOC(doc->virtadr, DOCStatus);
  81. }
  83. }
  85. /* DOC_WaitReady: Wait for RDY line to be asserted by the flash chip */
  86. static int _DoC_WaitReady(struct DiskOnChip *doc)
  87. {
  88. unsigned long docptr = doc->virtadr;
  89. unsigned long timeo = jiffies + (HZ * 10);
  91. DEBUG(MTD_DEBUG_LEVEL3,
  92.       "_DoC_WaitReady called for out-of-line waitn");
  94. /* Out-of-line routine to wait for chip response */
  95. while (!(ReadDOC(docptr, CDSNControl) & CDSN_CTRL_FR_B)) {
  96. if (time_after(jiffies, timeo)) {
  97. DEBUG(MTD_DEBUG_LEVEL2, "_DoC_WaitReady timed out.n");
  98. return -EIO;
  99. }
  100. if (current->need_resched) {
  101. set_current_state(TASK_UNINTERRUPTIBLE);
  102. schedule_timeout(1);
  103. }
  104. else
  105. udelay(1);
  106. }
  108. return 0;
  109. }
  111. static inline int DoC_WaitReady(struct DiskOnChip *doc)
  112. {
  113. unsigned long docptr = doc->virtadr;
  114. /* This is inline, to optimise the common case, where it's ready instantly */
  115. int ret = 0;
  117. /* 4 read form NOP register should be issued in prior to the read from CDSNControl
  118.    see Software Requirement 11.4 item 2. */
  119. DoC_Delay(doc, 4);
  121. if (!(ReadDOC(docptr, CDSNControl) & CDSN_CTRL_FR_B))
  122. /* Call the out-of-line routine to wait */
  123. ret = _DoC_WaitReady(doc);
  125. /* issue 2 read from NOP register after reading from CDSNControl register
  126.    see Software Requirement 11.4 item 2. */
  127. DoC_Delay(doc, 2);
  129. return ret;
  130. }
  132. /* DoC_Command: Send a flash command to the flash chip through the CDSN Slow IO register to
  133.    bypass the internal pipeline. Each of 4 delay cycles (read from the NOP register) is
  134.    required after writing to CDSN Control register, see Software Requirement 11.4 item 3. */
  136. static inline int DoC_Command(struct DiskOnChip *doc, unsigned char command,
  137.       unsigned char xtraflags)
  138. {
  139. unsigned long docptr = doc->virtadr;
  141. if (DoC_is_2000(doc))
  142. xtraflags |= CDSN_CTRL_FLASH_IO;
  144. /* Assert the CLE (Command Latch Enable) line to the flash chip */
  145. WriteDOC(xtraflags | CDSN_CTRL_CLE | CDSN_CTRL_CE, docptr, CDSNControl);
  146. DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
  148. if (DoC_is_Millennium(doc))
  149. WriteDOC(command, docptr, CDSNSlowIO);
  151. /* Send the command */
  152. WriteDOC_(command, docptr, doc->ioreg);
  154. /* Lower the CLE line */
  155. WriteDOC(xtraflags | CDSN_CTRL_CE, docptr, CDSNControl);
  156. DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
  158. /* Wait for the chip to respond - Software requirement 11.4.1 (extended for any command) */
  159. return DoC_WaitReady(doc);
  160. }
  162. /* DoC_Address: Set the current address for the flash chip through the CDSN Slow IO register to
  163.    bypass the internal pipeline. Each of 4 delay cycles (read from the NOP register) is
  164.    required after writing to CDSN Control register, see Software Requirement 11.4 item 3. */
  166. static int DoC_Address(struct DiskOnChip *doc, int numbytes, unsigned long ofs,
  167.        unsigned char xtraflags1, unsigned char xtraflags2)
  168. {
  169. unsigned long docptr;
  170. int i;
  172. docptr = doc->virtadr;
  174. if (DoC_is_2000(doc))
  175. xtraflags1 |= CDSN_CTRL_FLASH_IO;
  177. /* Assert the ALE (Address Latch Enable) line to the flash chip */
  178. WriteDOC(xtraflags1 | CDSN_CTRL_ALE | CDSN_CTRL_CE, docptr, CDSNControl);
  180. DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
  182. /* Send the address */
  183. /* Devices with 256-byte page are addressed as:
  184.    Column (bits 0-7), Page (bits 8-15, 16-23, 24-31)
  185.    * there is no device on the market with page256
  186.    and more than 24 bits.
  187.    Devices with 512-byte page are addressed as:
  188.    Column (bits 0-7), Page (bits 9-16, 17-24, 25-31)
  189.    * 25-31 is sent only if the chip support it.
  190.    * bit 8 changes the read command to be sent
  191.    (NAND_CMD_READ0 or NAND_CMD_READ1).
  192.  */
  194. if (numbytes == ADDR_COLUMN || numbytes == ADDR_COLUMN_PAGE) {
  195. if (DoC_is_Millennium(doc))
  196. WriteDOC(ofs & 0xff, docptr, CDSNSlowIO);
  197. WriteDOC_(ofs & 0xff, docptr, doc->ioreg);
  198. }
  200. if (doc->page256) {
  201. ofs = ofs >> 8;
  202. } else {
  203. ofs = ofs >> 9;
  204. }
  206. if (numbytes == ADDR_PAGE || numbytes == ADDR_COLUMN_PAGE) {
  207. for (i = 0; i < doc->pageadrlen; i++, ofs = ofs >> 8) {
  208. if (DoC_is_Millennium(doc))
  209. WriteDOC(ofs & 0xff, docptr, CDSNSlowIO);
  210. WriteDOC_(ofs & 0xff, docptr, doc->ioreg);
  211. }
  212. }
  214. DoC_Delay(doc, 2); /* Needed for some slow flash chips. mf. */
  216. /* FIXME: The SlowIO's for millennium could be replaced by 
  217.    a single WritePipeTerm here. mf. */
  219. /* Lower the ALE line */
  220. WriteDOC(xtraflags1 | xtraflags2 | CDSN_CTRL_CE, docptr,
  221.  CDSNControl);
  223. DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
  225. /* Wait for the chip to respond - Software requirement 11.4.1 */
  226. return DoC_WaitReady(doc);
  227. }
  229. /* Read a buffer from DoC, taking care of Millennium odditys */
  230. static void DoC_ReadBuf(struct DiskOnChip *doc, u_char * buf, int len)
  231. {
  232. volatile int dummy;
  233. int modulus = 0xffff;
  234. unsigned long docptr;
  235. int i;
  237. docptr = doc->virtadr;
  239. if (len <= 0)
  240. return;
  242. if (DoC_is_Millennium(doc)) {
  243. /* Read the data via the internal pipeline through CDSN IO register,
  244.    see Pipelined Read Operations 11.3 */
  245. dummy = ReadDOC(docptr, ReadPipeInit);
  247. /* Millennium should use the LastDataRead register - Pipeline Reads */
  248. len--;
  250. /* This is needed for correctly ECC calculation */
  251. modulus = 0xff;
  252. }
  254. for (i = 0; i < len; i++)
  255. buf[i] = ReadDOC_(docptr, doc->ioreg + (i & modulus));
  257. if (DoC_is_Millennium(doc)) {
  258. buf[i] = ReadDOC(docptr, LastDataRead);
  259. }
  260. }
  262. /* Write a buffer to DoC, taking care of Millennium odditys */
  263. static void DoC_WriteBuf(struct DiskOnChip *doc, const u_char * buf, int len)
  264. {
  265. unsigned long docptr;
  266. int i;
  268. docptr = doc->virtadr;
  270. if (len <= 0)
  271. return;
  273. for (i = 0; i < len; i++)
  274. WriteDOC_(buf[i], docptr, doc->ioreg + i);
  276. if (DoC_is_Millennium(doc)) {
  277. WriteDOC(0x00, docptr, WritePipeTerm);
  278. }
  279. }
  282. /* DoC_SelectChip: Select a given flash chip within the current floor */
  284. static inline int DoC_SelectChip(struct DiskOnChip *doc, int chip)
  285. {
  286. unsigned long docptr = doc->virtadr;
  288. /* Software requirement 11.4.4 before writing DeviceSelect */
  289. /* Deassert the CE line to eliminate glitches on the FCE# outputs */
  290. WriteDOC(CDSN_CTRL_WP, docptr, CDSNControl);
  291. DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
  293. /* Select the individual flash chip requested */
  294. WriteDOC(chip, docptr, CDSNDeviceSelect);
  295. DoC_Delay(doc, 4);
  297. /* Reassert the CE line */
  298. WriteDOC(CDSN_CTRL_CE | CDSN_CTRL_FLASH_IO | CDSN_CTRL_WP, docptr,
  299.  CDSNControl);
  300. DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
  302. /* Wait for it to be ready */
  303. return DoC_WaitReady(doc);
  304. }
  306. /* DoC_SelectFloor: Select a given floor (bank of flash chips) */
  308. static inline int DoC_SelectFloor(struct DiskOnChip *doc, int floor)
  309. {
  310. unsigned long docptr = doc->virtadr;
  312. /* Select the floor (bank) of chips required */
  313. WriteDOC(floor, docptr, FloorSelect);
  315. /* Wait for the chip to be ready */
  316. return DoC_WaitReady(doc);
  317. }
  319. /* DoC_IdentChip: Identify a given NAND chip given {floor,chip} */
  321. static int DoC_IdentChip(struct DiskOnChip *doc, int floor, int chip)
  322. {
  323. int mfr, id, i;
  324. volatile char dummy;
  326. /* Page in the required floor/chip */
  327. DoC_SelectFloor(doc, floor);
  328. DoC_SelectChip(doc, chip);
  330. /* Reset the chip */
  331. if (DoC_Command(doc, NAND_CMD_RESET, CDSN_CTRL_WP)) {
  332. DEBUG(MTD_DEBUG_LEVEL2,
  333.       "DoC_Command (reset) for %d,%d returned truen",
  334.       floor, chip);
  335. return 0;
  336. }
  339. /* Read the NAND chip ID: 1. Send ReadID command */
  340. if (DoC_Command(doc, NAND_CMD_READID, CDSN_CTRL_WP)) {
  341. DEBUG(MTD_DEBUG_LEVEL2,
  342.       "DoC_Command (ReadID) for %d,%d returned truen",
  343.       floor, chip);
  344. return 0;
  345. }
  347. /* Read the NAND chip ID: 2. Send address byte zero */
  348. DoC_Address(doc, ADDR_COLUMN, 0, CDSN_CTRL_WP, 0);
  350. /* Read the manufacturer and device id codes from the device */
  352. /* CDSN Slow IO register see Software Requirement 11.4 item 5. */
  353. dummy = ReadDOC(doc->virtadr, CDSNSlowIO);
  354. DoC_Delay(doc, 2);
  355. mfr = ReadDOC_(doc->virtadr, doc->ioreg);
  357. /* CDSN Slow IO register see Software Requirement 11.4 item 5. */
  358. dummy = ReadDOC(doc->virtadr, CDSNSlowIO);
  359. DoC_Delay(doc, 2);
  360. id = ReadDOC_(doc->virtadr, doc->ioreg);
  362. /* No response - return failure */
  363. if (mfr == 0xff || mfr == 0)
  364. return 0;
  366. /* Check it's the same as the first chip we identified. 
  367.  * M-Systems say that any given DiskOnChip device should only
  368.  * contain _one_ type of flash part, although that's not a 
  369.  * hardware restriction. */
  370. if (doc->mfr) {
  371. if (doc->mfr == mfr && doc->id == id)
  372. return 1; /* This is another the same the first */
  373. else
  374. printk(KERN_WARNING
  375.        "Flash chip at floor %d, chip %d is different:n",
  376.        floor, chip);
  377. }
  379. /* Print and store the manufacturer and ID codes. */
  380. for (i = 0; nand_flash_ids[i].name != NULL; i++) {
  381. if (mfr == nand_flash_ids[i].manufacture_id &&
  382.     id == nand_flash_ids[i].model_id) {
  383. printk(KERN_INFO
  384.        "Flash chip found: Manufacturer ID: %2.2X, "
  385.        "Chip ID: %2.2X (%s)n", mfr, id,
  386.        nand_flash_ids[i].name);
  387. if (!doc->mfr) {
  388. doc->mfr = mfr;
  389. doc->id = id;
  390. doc->chipshift =
  391.     nand_flash_ids[i].chipshift;
  392. doc->page256 = nand_flash_ids[i].page256;
  393. doc->pageadrlen =
  394.     nand_flash_ids[i].pageadrlen;
  395. doc->erasesize =
  396.     nand_flash_ids[i].erasesize;
  397. return 1;
  398. }
  399. return 0;
  400. }
  401. }
  404. /* We haven't fully identified the chip. Print as much as we know. */
  405. printk(KERN_WARNING "Unknown flash chip found: %2.2X %2.2Xn",
  406.        id, mfr);
  408. printk(KERN_WARNING "Please report to dwmw2@infradead.orgn");
  409. return 0;
  410. }
  412. /* DoC_ScanChips: Find all NAND chips present in a DiskOnChip, and identify them */
  414. static void DoC_ScanChips(struct DiskOnChip *this)
  415. {
  416. int floor, chip;
  417. int numchips[MAX_FLOORS];
  418. int maxchips = MAX_CHIPS;
  419. int ret = 1;
  421. this->numchips = 0;
  422. this->mfr = 0;
  423. this->id = 0;
  425. if (DoC_is_Millennium(this))
  426. maxchips = MAX_CHIPS_MIL;
  428. /* For each floor, find the number of valid chips it contains */
  429. for (floor = 0; floor < MAX_FLOORS; floor++) {
  430. ret = 1;
  431. numchips[floor] = 0;
  432. for (chip = 0; chip < maxchips && ret != 0; chip++) {
  434. ret = DoC_IdentChip(this, floor, chip);
  435. if (ret) {
  436. numchips[floor]++;
  437. this->numchips++;
  438. }
  439. }
  440. }
  442. /* If there are none at all that we recognise, bail */
  443. if (!this->numchips) {
  444. printk(KERN_NOTICE "No flash chips recognised.n");
  445. return;
  446. }
  448. /* Allocate an array to hold the information for each chip */
  449. this->chips = kmalloc(sizeof(struct Nand) * this->numchips, GFP_KERNEL);
  450. if (!this->chips) {
  451. printk(KERN_NOTICE "No memory for allocating chip info structuresn");
  452. return;
  453. }
  455. ret = 0;
  457. /* Fill out the chip array with {floor, chipno} for each 
  458.  * detected chip in the device. */
  459. for (floor = 0; floor < MAX_FLOORS; floor++) {
  460. for (chip = 0; chip < numchips[floor]; chip++) {
  461. this->chips[ret].floor = floor;
  462. this->chips[ret].chip = chip;
  463. this->chips[ret].curadr = 0;
  464. this->chips[ret].curmode = 0x50;
  465. ret++;
  466. }
  467. }
  469. /* Calculate and print the total size of the device */
  470. this->totlen = this->numchips * (1 << this->chipshift);
  472. printk(KERN_INFO "%d flash chips found. Total DiskOnChip size: %ld MiBn",
  473.        this->numchips, this->totlen >> 20);
  474. }
  476. static int DoC2k_is_alias(struct DiskOnChip *doc1, struct DiskOnChip *doc2)
  477. {
  478. int tmp1, tmp2, retval;
  479. if (doc1->physadr == doc2->physadr)
  480. return 1;
  482. /* Use the alias resolution register which was set aside for this
  483.  * purpose. If it's value is the same on both chips, they might
  484.  * be the same chip, and we write to one and check for a change in
  485.  * the other. It's unclear if this register is usuable in the
  486.  * DoC 2000 (it's in the Millennium docs), but it seems to work. */
  487. tmp1 = ReadDOC(doc1->virtadr, AliasResolution);
  488. tmp2 = ReadDOC(doc2->virtadr, AliasResolution);
  489. if (tmp1 != tmp2)
  490. return 0;
  492. WriteDOC((tmp1 + 1) % 0xff, doc1->virtadr, AliasResolution);
  493. tmp2 = ReadDOC(doc2->virtadr, AliasResolution);
  494. if (tmp2 == (tmp1 + 1) % 0xff)
  495. retval = 1;
  496. else
  497. retval = 0;
  499. /* Restore register contents.  May not be necessary, but do it just to
  500.  * be safe. */
  501. WriteDOC(tmp1, doc1->virtadr, AliasResolution);
  503. return retval;
  504. }
  506. static const char im_name[] = "DoC2k_init";
  508. /* This routine is made available to other mtd code via
  509.  * inter_module_register.  It must only be accessed through
  510.  * inter_module_get which will bump the use count of this module.  The
  511.  * addresses passed back in mtd are valid as long as the use count of
  512.  * this module is non-zero, i.e. between inter_module_get and
  513.  * inter_module_put.  Keith Owens <kaos@ocs.com.au> 29 Oct 2000.
  514.  */
  515. static void DoC2k_init(struct mtd_info *mtd)
  516. {
  517. struct DiskOnChip *this = (struct DiskOnChip *) mtd->priv;
  518. struct DiskOnChip *old = NULL;
  520. /* We must avoid being called twice for the same device. */
  522. if (doc2klist)
  523. old = (struct DiskOnChip *) doc2klist->priv;
  525. while (old) {
  526. if (DoC2k_is_alias(old, this)) {
  527. printk(KERN_NOTICE
  528.        "Ignoring DiskOnChip 2000 at 0x%lX - already configuredn",
  529.        this->physadr);
  530. iounmap((void *) this->virtadr);
  531. kfree(mtd);
  532. return;
  533. }
  534. if (old->nextdoc)
  535. old = (struct DiskOnChip *) old->nextdoc->priv;
  536. else
  537. old = NULL;
  538. }
  541. switch (this->ChipID) {
  542. case DOC_ChipID_Doc2k:
  543. mtd->name = "DiskOnChip 2000";
  544. this->ioreg = DoC_2k_CDSN_IO;
  545. break;
  546. case DOC_ChipID_DocMil:
  547. mtd->name = "DiskOnChip Millennium";
  548. this->ioreg = DoC_Mil_CDSN_IO;
  549. break;
  550. }
  552. printk(KERN_NOTICE "%s found at address 0x%lXn", mtd->name,
  553.        this->physadr);
  555. mtd->type = MTD_NANDFLASH;
  556. mtd->flags = MTD_CAP_NANDFLASH;
  557. mtd->size = 0;
  558. mtd->erasesize = 0;
  559. mtd->oobblock = 512;
  560. mtd->oobsize = 16;
  561. mtd->module = THIS_MODULE;
  562. mtd->erase = doc_erase;
  563. mtd->point = NULL;
  564. mtd->unpoint = NULL;
  565. mtd->read = doc_read;
  566. mtd->write = doc_write;
  567. mtd->read_ecc = doc_read_ecc;
  568. mtd->write_ecc = doc_write_ecc;
  569. mtd->read_oob = doc_read_oob;
  570. mtd->write_oob = doc_write_oob;
  571. mtd->sync = NULL;
  573. this->totlen = 0;
  574. this->numchips = 0;
  576. this->curfloor = -1;
  577. this->curchip = -1;
  578. init_MUTEX(&this->lock);
  580. /* Ident all the chips present. */
  581. DoC_ScanChips(this);
  583. if (!this->totlen) {
  584. kfree(mtd);
  585. iounmap((void *) this->virtadr);
  586. } else {
  587. this->nextdoc = doc2klist;
  588. doc2klist = mtd;
  589. mtd->size = this->totlen;
  590. mtd->erasesize = this->erasesize;
  591. add_mtd_device(mtd);
  592. return;
  593. }
  594. }
  596. static int doc_read(struct mtd_info *mtd, loff_t from, size_t len,
  597.     size_t * retlen, u_char * buf)
  598. {
  599. /* Just a special case of doc_read_ecc */
  600. return doc_read_ecc(mtd, from, len, retlen, buf, NULL);
  601. }
  603. static int doc_read_ecc(struct mtd_info *mtd, loff_t from, size_t len,
  604. size_t * retlen, u_char * buf, u_char * eccbuf)
  605. {
  606. struct DiskOnChip *this = (struct DiskOnChip *) mtd->priv;
  607. unsigned long docptr;
  608. struct Nand *mychip;
  609. unsigned char syndrome[6];
  610. volatile char dummy;
  611. int i, len256 = 0, ret=0;
  613. docptr = this->virtadr;
  615. /* Don't allow read past end of device */
  616. if (from >= this->totlen)
  617. return -EINVAL;
  619. down(&this->lock);
  621. /* Don't allow a single read to cross a 512-byte block boundary */
  622. if (from + len > ((from | 0x1ff) + 1))
  623. len = ((from | 0x1ff) + 1) - from;
  625. /* The ECC will not be calculated correctly if less than 512 is read */
  626. if (len != 0x200 && eccbuf)
  627. printk(KERN_WARNING
  628.        "ECC needs a full sector read (adr: %lx size %lx)n",
  629.        (long) from, (long) len);
  631. /* printk("DoC_Read (adr: %lx size %lx)n", (long) from, (long) len); */
  634. /* Find the chip which is to be used and select it */
  635. mychip = &this->chips[from >> (this->chipshift)];
  637. if (this->curfloor != mychip->floor) {
  638. DoC_SelectFloor(this, mychip->floor);
  639. DoC_SelectChip(this, mychip->chip);
  640. } else if (this->curchip != mychip->chip) {
  641. DoC_SelectChip(this, mychip->chip);
  642. }
  644. this->curfloor = mychip->floor;
  645. this->curchip = mychip->chip;
  647. DoC_Command(this,
  648.     (!this->page256
  649.      && (from & 0x100)) ? NAND_CMD_READ1 : NAND_CMD_READ0,
  650.     CDSN_CTRL_WP);
  651. DoC_Address(this, ADDR_COLUMN_PAGE, from, CDSN_CTRL_WP,
  652.     CDSN_CTRL_ECC_IO);
  654. if (eccbuf) {
  655. /* Prime the ECC engine */
  656. WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
  657. WriteDOC(DOC_ECC_EN, docptr, ECCConf);
  658. } else {
  659. /* disable the ECC engine */
  660. WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
  661. WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
  662. }
  664. /* treat crossing 256-byte sector for 2M x 8bits devices */
  665. if (this->page256 && from + len > (from | 0xff) + 1) {
  666. len256 = (from | 0xff) + 1 - from;
  667. DoC_ReadBuf(this, buf, len256);
  669. DoC_Command(this, NAND_CMD_READ0, CDSN_CTRL_WP);
  670. DoC_Address(this, ADDR_COLUMN_PAGE, from + len256,
  671.     CDSN_CTRL_WP, CDSN_CTRL_ECC_IO);
  672. }
  674. DoC_ReadBuf(this, &buf[len256], len - len256);
  676. /* Let the caller know we completed it */
  677. *retlen = len;
  679. if (eccbuf) {
  680. /* Read the ECC data through the DiskOnChip ECC logic */
  681. /* Note: this will work even with 2M x 8bit devices as   */
  682. /*       they have 8 bytes of OOB per 256 page. mf.      */
  683. DoC_ReadBuf(this, eccbuf, 6);
  685. /* Flush the pipeline */
  686. if (DoC_is_Millennium(this)) {
  687. dummy = ReadDOC(docptr, ECCConf);
  688. dummy = ReadDOC(docptr, ECCConf);
  689. i = ReadDOC(docptr, ECCConf);
  690. } else {
  691. dummy = ReadDOC(docptr, 2k_ECCStatus);
  692. dummy = ReadDOC(docptr, 2k_ECCStatus);
  693. i = ReadDOC(docptr, 2k_ECCStatus);
  694. }
  696. /* Check the ECC Status */
  697. if (i & 0x80) {
  698. int nb_errors;
  699. /* There was an ECC error */
  700. #ifdef ECC_DEBUG
  701. printk(KERN_ERR "DiskOnChip ECC Error: Read at %lxn", (long)from);
  702. #endif
  703. /* Read the ECC syndrom through the DiskOnChip ECC logic.
  704.    These syndrome will be all ZERO when there is no error */
  705. for (i = 0; i < 6; i++) {
  706. syndrome[i] =
  707.     ReadDOC(docptr, ECCSyndrome0 + i);
  708. }
  709.                         nb_errors = doc_decode_ecc(buf, syndrome);
  711. #ifdef ECC_DEBUG
  712. printk(KERN_ERR "Errors corrected: %xn", nb_errors);
  713. #endif
  714.                         if (nb_errors < 0) {
  715. /* We return error, but have actually done the read. Not that
  716.    this can be told to user-space, via sys_read(), but at least
  717.    MTD-aware stuff can know about it by checking *retlen */
  718. ret = -EIO;
  719.                         }
  720. }
  722. #ifdef PSYCHO_DEBUG
  723. printk(KERN_DEBUG "ECC DATA at %lxB: %2.2X %2.2X %2.2X %2.2X %2.2X %2.2Xn",
  724.      (long)from, eccbuf[0], eccbuf[1], eccbuf[2],
  725.      eccbuf[3], eccbuf[4], eccbuf[5]);
  726. #endif
  728. /* disable the ECC engine */
  729. WriteDOC(DOC_ECC_DIS, docptr , ECCConf);
  730. }
  732. /* according to 11.4.1, we need to wait for the busy line 
  733.          * drop if we read to the end of the page.  */
  734. if(0 == ((from + *retlen) & 0x1ff))
  735. {
  736.     DoC_WaitReady(this);
  737. }
  739. up(&this->lock);
  741. return ret;
  742. }
  744. static int doc_write(struct mtd_info *mtd, loff_t to, size_t len,
  745.      size_t * retlen, const u_char * buf)
  746. {
  747. char eccbuf[6];
  748. return doc_write_ecc(mtd, to, len, retlen, buf, eccbuf);
  749. }
  751. static int doc_write_ecc(struct mtd_info *mtd, loff_t to, size_t len,
  752.  size_t * retlen, const u_char * buf,
  753.  u_char * eccbuf)
  754. {
  755. struct DiskOnChip *this = (struct DiskOnChip *) mtd->priv;
  756. int di; /* Yes, DI is a hangover from when I was disassembling the binary driver */
  757. unsigned long docptr;
  758. volatile char dummy;
  759. int len256 = 0;
  760. struct Nand *mychip;
  762. docptr = this->virtadr;
  764. /* Don't allow write past end of device */
  765. if (to >= this->totlen)
  766. return -EINVAL;
  768. down(&this->lock);
  770. /* Don't allow a single write to cross a 512-byte block boundary */
  771. if (to + len > ((to | 0x1ff) + 1))
  772. len = ((to | 0x1ff) + 1) - to;
  774. /* The ECC will not be calculated correctly if less than 512 is written */
  775. if (len != 0x200 && eccbuf)
  776. printk(KERN_WARNING
  777.        "ECC needs a full sector write (adr: %lx size %lx)n",
  778.        (long) to, (long) len);
  780. /* printk("DoC_Write (adr: %lx size %lx)n", (long) to, (long) len); */
  782. /* Find the chip which is to be used and select it */
  783. mychip = &this->chips[to >> (this->chipshift)];
  785. if (this->curfloor != mychip->floor) {
  786. DoC_SelectFloor(this, mychip->floor);
  787. DoC_SelectChip(this, mychip->chip);
  788. } else if (this->curchip != mychip->chip) {
  789. DoC_SelectChip(this, mychip->chip);
  790. }
  792. this->curfloor = mychip->floor;
  793. this->curchip = mychip->chip;
  795. /* Set device to main plane of flash */
  796. DoC_Command(this, NAND_CMD_RESET, CDSN_CTRL_WP);
  797. DoC_Command(this,
  798.     (!this->page256
  799.      && (to & 0x100)) ? NAND_CMD_READ1 : NAND_CMD_READ0,
  800.     CDSN_CTRL_WP);
  802. DoC_Command(this, NAND_CMD_SEQIN, 0);
  803. DoC_Address(this, ADDR_COLUMN_PAGE, to, 0, CDSN_CTRL_ECC_IO);
  805. if (eccbuf) {
  806. /* Prime the ECC engine */
  807. WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
  808. WriteDOC(DOC_ECC_EN | DOC_ECC_RW, docptr, ECCConf);
  809. } else {
  810. /* disable the ECC engine */
  811. WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
  812. WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
  813. }
  815. /* treat crossing 256-byte sector for 2M x 8bits devices */
  816. if (this->page256 && to + len > (to | 0xff) + 1) {
  817. len256 = (to | 0xff) + 1 - to;
  818. DoC_WriteBuf(this, buf, len256);
  820. DoC_Command(this, NAND_CMD_PAGEPROG, 0);
  822. DoC_Command(this, NAND_CMD_STATUS, CDSN_CTRL_WP);
  823. /* There's an implicit DoC_WaitReady() in DoC_Command */
  825. dummy = ReadDOC(docptr, CDSNSlowIO);
  826. DoC_Delay(this, 2);
  828. if (ReadDOC_(docptr, this->ioreg) & 1) {
  829. printk(KERN_ERR "Error programming flashn");
  830. /* Error in programming */
  831. *retlen = 0;
  832. up(&this->lock);
  833. return -EIO;
  834. }
  836. DoC_Command(this, NAND_CMD_SEQIN, 0);
  837. DoC_Address(this, ADDR_COLUMN_PAGE, to + len256, 0,
  838.     CDSN_CTRL_ECC_IO);
  839. }
  841. DoC_WriteBuf(this, &buf[len256], len - len256);
  843. if (eccbuf) {
  844. WriteDOC(CDSN_CTRL_ECC_IO | CDSN_CTRL_CE, docptr,
  845.  CDSNControl);
  847. if (DoC_is_Millennium(this)) {
  848. WriteDOC(0, docptr, NOP);
  849. WriteDOC(0, docptr, NOP);
  850. WriteDOC(0, docptr, NOP);
  851. } else {
  852. WriteDOC_(0, docptr, this->ioreg);
  853. WriteDOC_(0, docptr, this->ioreg);
  854. WriteDOC_(0, docptr, this->ioreg);
  855. }
  857. /* Read the ECC data through the DiskOnChip ECC logic */
  858. for (di = 0; di < 6; di++) {
  859. eccbuf[di] = ReadDOC(docptr, ECCSyndrome0 + di);
  860. }
  862. /* Reset the ECC engine */
  863. WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
  865. #ifdef PSYCHO_DEBUG
  866. printk
  867.     ("OOB data at %lx is %2.2X %2.2X %2.2X %2.2X %2.2X %2.2Xn",
  868.      (long) to, eccbuf[0], eccbuf[1], eccbuf[2], eccbuf[3],
  869.      eccbuf[4], eccbuf[5]);
  870. #endif
  871. }
  873. DoC_Command(this, NAND_CMD_PAGEPROG, 0);
  875. DoC_Command(this, NAND_CMD_STATUS, CDSN_CTRL_WP);
  876. /* There's an implicit DoC_WaitReady() in DoC_Command */
  878. dummy = ReadDOC(docptr, CDSNSlowIO);
  879. DoC_Delay(this, 2);
  881. if (ReadDOC_(docptr, this->ioreg) & 1) {
  882. printk(KERN_ERR "Error programming flashn");
  883. /* Error in programming */
  884. *retlen = 0;
  885. up(&this->lock);
  886. return -EIO;
  887. }
  889. /* Let the caller know we completed it */
  890. *retlen = len;
  892. if (eccbuf) {
  893. unsigned char x[8];
  894. size_t dummy;
  895. int ret;
  897. /* Write the ECC data to flash */
  898. for (di=0; di<6; di++)
  899. x[di] = eccbuf[di];
  901. x[6]=0x55;
  902. x[7]=0x55;
  904. ret = doc_write_oob_nolock(mtd, to, 8, &dummy, x);
  905. up(&this->lock);
  906. return ret;
  907. }
  908. up(&this->lock);
  909. return 0;
  910. }
  912. static int doc_read_oob(struct mtd_info *mtd, loff_t ofs, size_t len,
  913. size_t * retlen, u_char * buf)
  914. {
  915. struct DiskOnChip *this = (struct DiskOnChip *) mtd->priv;
  916. int len256 = 0, ret;
  917. unsigned long docptr;
  918. struct Nand *mychip;
  920. down(&this->lock);
  922. docptr = this->virtadr;
  924. mychip = &this->chips[ofs >> this->chipshift];
  926. if (this->curfloor != mychip->floor) {
  927. DoC_SelectFloor(this, mychip->floor);
  928. DoC_SelectChip(this, mychip->chip);
  929. } else if (this->curchip != mychip->chip) {
  930. DoC_SelectChip(this, mychip->chip);
  931. }
  932. this->curfloor = mychip->floor;
  933. this->curchip = mychip->chip;
  935. /* update address for 2M x 8bit devices. OOB starts on the second */
  936. /* page to maintain compatibility with doc_read_ecc. */
  937. if (this->page256) {
  938. if (!(ofs & 0x8))
  939. ofs += 0x100;
  940. else
  941. ofs -= 0x8;
  942. }
  944. DoC_Command(this, NAND_CMD_READOOB, CDSN_CTRL_WP);
  945. DoC_Address(this, ADDR_COLUMN_PAGE, ofs, CDSN_CTRL_WP, 0);
  947. /* treat crossing 8-byte OOB data for 2M x 8bit devices */
  948. /* Note: datasheet says it should automaticaly wrap to the */
  949. /*       next OOB block, but it didn't work here. mf.      */
  950. if (this->page256 && ofs + len > (ofs | 0x7) + 1) {
  951. len256 = (ofs | 0x7) + 1 - ofs;
  952. DoC_ReadBuf(this, buf, len256);
  954. DoC_Command(this, NAND_CMD_READOOB, CDSN_CTRL_WP);
  955. DoC_Address(this, ADDR_COLUMN_PAGE, ofs & (~0x1ff),
  956.     CDSN_CTRL_WP, 0);
  957. }
  959. DoC_ReadBuf(this, &buf[len256], len - len256);
  961. *retlen = len;
  962. /* Reading the full OOB data drops us off of the end of the page,
  963.          * causing the flash device to go into busy mode, so we need
  964.          * to wait until ready 11.4.1 and Toshiba TC58256FT docs */
  966. ret = DoC_WaitReady(this);
  968. up(&this->lock);
  969. return ret;
  971. }
  973. static int doc_write_oob_nolock(struct mtd_info *mtd, loff_t ofs, size_t len,
  974. size_t * retlen, const u_char * buf)
  975. {
  976. struct DiskOnChip *this = (struct DiskOnChip *) mtd->priv;
  977. int len256 = 0;
  978. unsigned long docptr = this->virtadr;
  979. struct Nand *mychip = &this->chips[ofs >> this->chipshift];
  980. volatile int dummy;
  982. //      printk("doc_write_oob(%lx, %d): %2.2X %2.2X %2.2X %2.2X ... %2.2X %2.2X .. %2.2X %2.2Xn",(long)ofs, len,
  983. //   buf[0], buf[1], buf[2], buf[3], buf[8], buf[9], buf[14],buf[15]);
  985. /* Find the chip which is to be used and select it */
  986. if (this->curfloor != mychip->floor) {
  987. DoC_SelectFloor(this, mychip->floor);
  988. DoC_SelectChip(this, mychip->chip);
  989. } else if (this->curchip != mychip->chip) {
  990. DoC_SelectChip(this, mychip->chip);
  991. }
  992. this->curfloor = mychip->floor;
  993. this->curchip = mychip->chip;
  995. /* disable the ECC engine */
  996. WriteDOC (DOC_ECC_RESET, docptr, ECCConf);
  997. WriteDOC (DOC_ECC_DIS, docptr, ECCConf);
  999. /* Reset the chip, see Software Requirement 11.4 item 1. */
  1000. DoC_Command(this, NAND_CMD_RESET, CDSN_CTRL_WP);
  1002. /* issue the Read2 command to set the pointer to the Spare Data Area. */
  1003. DoC_Command(this, NAND_CMD_READOOB, CDSN_CTRL_WP);
  1005. /* update address for 2M x 8bit devices. OOB starts on the second */
  1006. /* page to maintain compatibility with doc_read_ecc. */
  1007. if (this->page256) {
  1008. if (!(ofs & 0x8))
  1009. ofs += 0x100;
  1010. else
  1011. ofs -= 0x8;
  1012. }
  1014. /* issue the Serial Data In command to initial the Page Program process */
  1015. DoC_Command(this, NAND_CMD_SEQIN, 0);
  1016. DoC_Address(this, ADDR_COLUMN_PAGE, ofs, 0, 0);
  1018. /* treat crossing 8-byte OOB data for 2M x 8bit devices */
  1019. /* Note: datasheet says it should automaticaly wrap to the */
  1020. /*       next OOB block, but it didn't work here. mf.      */
  1021. if (this->page256 && ofs + len > (ofs | 0x7) + 1) {
  1022. len256 = (ofs | 0x7) + 1 - ofs;
  1023. DoC_WriteBuf(this, buf, len256);
  1025. DoC_Command(this, NAND_CMD_PAGEPROG, 0);
  1026. DoC_Command(this, NAND_CMD_STATUS, 0);
  1027. /* DoC_WaitReady() is implicit in DoC_Command */
  1029. dummy = ReadDOC(docptr, CDSNSlowIO);
  1030. DoC_Delay(this, 2);
  1032. if (ReadDOC_(docptr, this->ioreg) & 1) {
  1033. printk(KERN_ERR "Error programming oob datan");
  1034. /* There was an error */
  1035. *retlen = 0;
  1036. return -EIO;
  1037. }
  1038. DoC_Command(this, NAND_CMD_SEQIN, 0);
  1039. DoC_Address(this, ADDR_COLUMN_PAGE, ofs & (~0x1ff), 0, 0);
  1040. }
  1042. DoC_WriteBuf(this, &buf[len256], len - len256);
  1044. DoC_Command(this, NAND_CMD_PAGEPROG, 0);
  1045. DoC_Command(this, NAND_CMD_STATUS, 0);
  1046. /* DoC_WaitReady() is implicit in DoC_Command */
  1048. dummy = ReadDOC(docptr, CDSNSlowIO);
  1049. DoC_Delay(this, 2);
  1051. if (ReadDOC_(docptr, this->ioreg) & 1) {
  1052. printk(KERN_ERR "Error programming oob datan");
  1053. /* There was an error */
  1054. *retlen = 0;
  1055. return -EIO;
  1056. }
  1058. *retlen = len;
  1059. return 0;
  1061. }
  1062.  
  1063. static int doc_write_oob(struct mtd_info *mtd, loff_t ofs, size_t len,
  1064.    size_t * retlen, const u_char * buf)
  1065. {
  1066.   struct DiskOnChip *this = (struct DiskOnChip *) mtd->priv;
  1067.   int ret;
  1069.   down(&this->lock);
  1070.   ret = doc_write_oob_nolock(mtd, ofs, len, retlen, buf);
  1072.   up(&this->lock);
  1073.   return ret;
  1074. }
  1076. static int doc_erase(struct mtd_info *mtd, struct erase_info *instr)
  1077. {
  1078. struct DiskOnChip *this = (struct DiskOnChip *) mtd->priv;
  1079. __u32 ofs = instr->addr;
  1080. __u32 len = instr->len;
  1081. volatile int dummy;
  1082. unsigned long docptr;
  1083. struct Nand *mychip;
  1085.   down(&this->lock);
  1087. if (ofs & (mtd->erasesize-1) || len & (mtd->erasesize-1)) {
  1088. up(&this->lock);
  1089. return -EINVAL;
  1090. }
  1092. instr->state = MTD_ERASING;
  1094. docptr = this->virtadr;
  1096. /* FIXME: Do this in the background. Use timers or schedule_task() */
  1097. while(len) {
  1098. mychip = &this->chips[ofs >> this->chipshift];
  1100. if (this->curfloor != mychip->floor) {
  1101. DoC_SelectFloor(this, mychip->floor);
  1102. DoC_SelectChip(this, mychip->chip);
  1103. } else if (this->curchip != mychip->chip) {
  1104. DoC_SelectChip(this, mychip->chip);
  1105. }
  1106. this->curfloor = mychip->floor;
  1107. this->curchip = mychip->chip;
  1109. DoC_Command(this, NAND_CMD_ERASE1, 0);
  1110. DoC_Address(this, ADDR_PAGE, ofs, 0, 0);
  1111. DoC_Command(this, NAND_CMD_ERASE2, 0);
  1113. DoC_Command(this, NAND_CMD_STATUS, CDSN_CTRL_WP);
  1115. dummy = ReadDOC(docptr, CDSNSlowIO);
  1116. DoC_Delay(this, 2);
  1118. if (ReadDOC_(docptr, this->ioreg) & 1) {
  1119. printk(KERN_ERR "Error erasing at 0x%xn", ofs);
  1120. /* There was an error */
  1121. instr->state = MTD_ERASE_FAILED;
  1122. goto callback;
  1123. }
  1124. ofs += mtd->erasesize;
  1125. len -= mtd->erasesize;
  1126. }
  1127. instr->state = MTD_ERASE_DONE;
  1129.  callback:
  1130. if (instr->callback)
  1131. instr->callback(instr);
  1133. up(&this->lock);
  1134. return 0;
  1135. }
  1138. /****************************************************************************
  1139.  *
  1140.  * Module stuff
  1141.  *
  1142.  ****************************************************************************/
  1144. int __init init_doc2000(void)
  1145. {
  1146.        inter_module_register(im_name, THIS_MODULE, &DoC2k_init);
  1147.        return 0;
  1148. }
  1150. static void __exit cleanup_doc2000(void)
  1151. {
  1152. struct mtd_info *mtd;
  1153. struct DiskOnChip *this;
  1155. while ((mtd = doc2klist)) {
  1156. this = (struct DiskOnChip *) mtd->priv;
  1157. doc2klist = this->nextdoc;
  1159. del_mtd_device(mtd);
  1161. iounmap((void *) this->virtadr);
  1162. kfree(this->chips);
  1163. kfree(mtd);
  1164. }
  1165. inter_module_unregister(im_name);
  1166. }
  1168. module_exit(cleanup_doc2000);
  1169. module_init(init_doc2000);
  1171. MODULE_LICENSE("GPL");
  1172. MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org> et al.");
  1173. MODULE_DESCRIPTION("MTD driver for DiskOnChip 2000 and Millennium");