http://www.cnblogs.com/sankye/articles/1638852.html
向作者Sankye致敬
【編寫驅動之前要了解的知識】
1. 硬件特性：
【Flash的硬件實現機制】
Flash全名叫做Flash Memory，屬於非易失性存儲設備(Non-volatile Memory Device)，與此相對應的是易失性存儲設備(Volatile Memory Device)。關於什麼是非易失性/易失性，從名字中就可以看出，非易失性就是不容易丟失，數據存儲在這類設備中，即使斷電了，也不會丟失，這類設備，除了Flash，還有其他比較常見的入硬盤，ROM等，與此相對的，易失性就是斷電了，數據就丟失了，比如大家常用的內存，不論是以前的SDRAM，DDR SDRAM，還是現在的DDR2，DDR3等，都是斷電後，數據就沒了。
Flash的內部存儲是MOSFET，裏面有個懸浮門(Floating Gate)，是真正存儲數據的單元。
在Flash之前，紫外線可擦除(uv-erasable)的EPROM，就已經採用用Floating Gate存儲數據這一技術了。
圖1.典型的Flash內存單元的物理結構
數據在Flash內存單元中是以電荷(electrical charge) 形式存儲的。存儲電荷的多少，取決於圖中的外部門（external gate）所被施加的電壓，其控制了是向存儲單元中衝入電荷還是使其釋放電荷。而數據的表示，以所存儲的電荷的電壓是否超過一個特定的閾值Vth來表示。
【SLC和MLC的實現機制】
Nand Flash按照內部存儲數據單元的電壓的不同層次，也就是單個內存單元中，是存儲1位數據，還是多位數據，可以分爲SLC和MLC：
1. SLC，Single Level Cell:
單個存儲單元，只存儲一位數據，表示成1或0.
就是上面介紹的，對於數據的表示，單個存儲單元中內部所存儲電荷的電壓，和某個特定的閾值電壓Vth，相比，如果大於此Vth值，就是表示1，反之，小於Vth，就表示0.
對於nand Flash的數據的寫入1，就是控制External Gate去充電，使得存儲的電荷夠多，超過閾值Vth，就表示1了。而對於寫入0，就是將其放電，電荷減少到小於Vth，就表示0了。
關於爲何Nand Flash不能從0變成1，我的理解是，物理上來說，是可以實現每一位的，從0變成1的，但是實際上，對於實際的物理實現，出於效率的考慮，如果對於，每一個存儲單元都能單獨控制，即，0變成1就是，對每一個存儲單元單獨去充電，所需要的硬件實現就很複雜和昂貴，同時，所進行對塊擦除的操作，也就無法實現之前的，一閃而過的速度了，也就失去了Flash的衆多特性了。
2. MLC，Multi Level Cell：
與SLC相對應，就是單個存儲單元，可以存儲多個位，比如2位，4位等。其實現機制，說起來比較簡單，就是，通過控制內部電荷的多少，分成多個閾值，通過控制裏面的電荷多少，而達到我們所需要的存儲成不同的數據。比如，假設輸入電壓是Vin＝4V（實際沒有這樣的電壓，此處只是爲了舉例方便），那麼，可以設計出2的2次方＝4個閾值， 1/4的Vin＝1V，2/4的Vin＝2V，3/4的Vin＝3V，Vin＝4V，分別表示2位數據00，01，10，11，對於寫入數據，就是充電，通過控制內部的電荷的多少，對應表示不同的數據。
對於讀取，則是通過對應的內部的電流（與Vth成反比），然後通過一系列解碼電路完成讀取，解析出所存儲的數據。這些具體的物理實現，都是有足夠精確的設備和技術，才能實現精確的數據寫入和讀出的。
單個存儲單元可以存儲2位數據的，稱作2的2次方＝4 Level Cell，而不是2 Level Cell，這點，之前差點搞暈了。。。，同理，對於新出的單個存儲單元可以存儲4位數據的，稱作 2的4次方＝16 Level Cell。
【關於如何識別SLC還是MLC】
Nand Flash設計中，有個命令叫做Read ID，讀取ID，意思是讀取芯片的ID，就像大家的身份證一樣，這裏讀取的ID中，是讀取好幾個字節，一般最少是4個，新的芯片，支持5個甚至更多，從這些字節中，可以解析出很多相關的信息，比如此Nand Flash內部是幾個芯片（chip）所組成的，每個chip包含了幾片（Plane），每一片中的頁大小，塊大小，等等。在這些信息中，其中有一個，就是識別此flash是SLC還是MLC。下面這個就是最常見的Nand Flash的datasheet中所規定的，第3個字節，3rd byte，所表示的信息，其中就有SLC/MLC的識別信息：
|
|
Description |
I/O7 |
I/O6 |
I/O5 I/O4 |
I/O3 I/O2 |
I/O1 I/O0 |
|
Internal Chip Number |
1 2 4 8 |
|
|
|
|
0 0 0 1 1 0 1 1 |
|
Cell Type |
2 Level Cell 4 Level Cell 8 Level Cell 16 Level Cell |
|
|
|
0 0 0 1 1 0 1 1 |
|
|
Number of Simultaneously Programmed Pages |
1 2 4 8 |
|
|
0 0 0 1 1 0 1 1 |
|
|
|
Interleave Program Between multiple chips |
Not Support Support |
|
0 1 |
|
|
|
|
Cache Program |
Not Support Support |
0 1 |
|
|
|
|
表1.Nand Flash 第3個ID的含義
【Nand Flash的物理存儲單元的陣列組織結構】
Nand flash的內部組織結構，此處還是用圖來解釋，比較容易理解：
圖2.Nand Flash物理存儲單元的陣列組織結構
上圖是K9K8G08U0A的datasheet中的描述。
簡單解釋就是:
1.一個nand flash由很多個塊（Block）組成，塊的大小一般是128KB，256KB，512KB，此處是128KB。
2.每個塊裏面又包含了很多頁（page）。每個頁的大小，對於現在常見的nand flash多數是2KB，更新的nand flash是4KB，這類的，頁大小大於2KB的nand flash，被稱作big block，對應的發讀寫命令地址，一共5個週期(cycle)，而老的nand flash，頁大小是256B，512B，這類的nand flash被稱作small block，。地址週期只有4個。
而塊，也是Nand Flash的擦除操作的基本/最小單位。
3.每一個頁，對應還有一塊區域，叫做空閒區域（spare area）/冗餘區域（redundant
area），而Linux系統中，一般叫做OOB（Out
Of Band），這個區域，是最初基於Nand Flash的硬件特性：數據在讀寫時候相對容易錯誤，所以爲了保證數據的正確性，必須要有對應的檢測和糾錯機制，此機制被叫做EDC(Error
Detection Co
頁是Nand Flash的寫入操作的基本/最小的單位。
【Nand Flash數據存儲單元的整體架構】
簡單說就是，常見的nand flash，內部只有一個chip，每個chip只有一個plane。
而有些複雜的，容量更大的nand flash，內部有多個chip，每個chip有多個plane。這類的nand flash，往往也有更加高級的功能，比如下面要介紹的Multi Plane Program和Interleave Page Program等。
比如，型號爲K9K8G08U0A這個芯片（chip），內部有兩個K9F4G08U0A，每個K9F4G08U0A包含了2個Plane，每個Plane是1Gb，所以K9F4G08U0A的大小是1Gb×2＝2Gb＝256MB，因此，K9K8G08U0A內部有2個K9F4G08U0A，即4個Plane，總大小是4×256MB＝1GB。
而型號是K9WAG08U1A的nand flash，內部包含了2個K9K8G08U0A，所以，總容量是K9K8G08U0A的兩倍＝1GB×2＝2GB，類似地K9NBG08U5A，內部包含了4個K9K8G08U0A，總大小就是4×1GB＝4GB。
【Flash名稱的由來】
Flash的擦除操作是以block塊爲單位的，與此相對應的是其他很多存儲設備，是以bit位爲最小讀取/寫入的單位，Flash是一次性地擦除整個塊：在發送一個擦除命令後，一次性地將一個block，常見的塊的大小是128KB/256KB。。，全部擦除爲1，也就是裏面的內容全部都是0xFF了，由於是一下子就擦除了，相對來說，擦除用的時間很短，可以用一閃而過來形容，所以，叫做Flash Memory。中文有的翻譯爲 （快速）閃存。
【Flash相對於普通設備的特殊性】
1. 上面提到過的，Flash最小操作單位，有些特殊。
一般設備，比如硬盤/內存，讀取和寫入都是以bit位爲單位，讀取一個bit的值，將某個值寫入對應的地址的位，都是可以按位操作的。
但是Flash由於物理特性，使得內部存儲的數據，只能從1變成0，這點，可以從前面的內部實現機制瞭解到，只是方便統一充電，不方便單獨的存儲單元去放電，所以才說，只能從1變成0，也就是釋放電荷。
所以，總結一下Flash的特殊性如下：
|
|
普通設備(硬盤/內存等) |
Flash |
|
讀取/寫入的叫法 |
讀取/寫入 |
讀取/編程(Program)① |
|
讀取/寫入的最小單位 |
Bit/位 |
Page/頁 |
|
擦除(Erase)操作的最小單位 |
Bit/位 |
Block/塊 ② |
|
擦除操作的含義 |
將數據刪除/全部寫入0 |
將整個塊都擦除成全是1，也就是裏面的數據都是0xFF ③ |
|
對於寫操作 |
直接寫即可 |
在寫數據之前，要先擦除，然後再寫 |
表2.Flash和普通設備相比所具有的特殊性
注：
① 之所以將寫操作叫做編程，是因爲，flash 和之前的EPROM，EEPROM繼承發展而來，而之前的EEPROM(Electrically
Erasable Programmable Read-On
② 對於目前常見的頁大小是2K/4K的Nand Flash，其塊的大小有128KB/256KB/512KB等。而對於Nor Flash，常見的塊大小有64K/32K等。
③在寫數據之前，要先擦除，內部就都變成0xFF了，然後才能寫入數據，也就是將對應位由1變成0。
【Nand Flash引腳(Pin)的說明】
圖3.Nand Flash引腳功能說明
上圖是常見的Nand Flash所擁有的引腳（Pin）所對應的功能，簡單翻譯如下：
1. I/O0 ~ I/O7：用於輸入地址/數據/命令，輸出數據
2. CLE：Command Latch Enable，命令鎖存使能，在輸入命令之前，要先在模式寄存器中，設置CLE使能
3. ALE：Address Latch Enable，地址鎖存使能，在輸入地址之前，要先在模式寄存器中，設置ALE使能
4. CE#：Chip Enable，芯片使能，在操作Nand Flash之前，要先選中此芯片，才能操作
5. RE#：Read Enable，讀使能，在讀取數據之前，要先使CE＃有效。
6. WE#：Write Enable，寫使能, 在寫取數據之前，要先使WE＃有效。
7. WP#：Write Protect，寫保護
8. R/B#:Ready/Busy Output,就緒/忙,主要用於在發送完編程/擦除命令後,檢測這些操作是否完成,忙,表示編程/擦除操作仍在進行中,就緒表示操作完成.
9. Vcc：Power，電源
10. Vss：Ground，接地
11. N.C：Non-Connection,未定義，未連接。
[小常識]
在數據手冊中，你常會看到，對於一個引腳定義，有些字母上面帶一橫槓的，那是說明此引腳/信號是低電平有效，比如你上面看到的RE頭上有個橫線，就是說明，此RE是低電平有效，此外，爲了書寫方便，在字母后面加“＃”，也是表示低電平有效，比如我上面寫的CE＃；如果字母頭上啥都沒有，就是默認的高電平有效，比如上面的CLE，就是高電平有效。
【爲何需要ALE和CLE】
突然想明白了，Nand Flash中, 爲何設計這麼多的命令,把整個系統搞這麼複雜的原因了:
比如命令鎖存使能(Command Latch Enable,CLE) 和 地址鎖存使能(Address Latch Enable，ALE)，那是因爲，Nand Flash就8個I/O，而且是複用的，也就是，可以傳數據，也可以傳地址，也可以傳命令，爲了區分你當前傳入的到底是啥，所以，先要用發一個CLE（或ALE）命令，告訴nand Flash的控制器一聲，我下面要傳的是命令（或地址），這樣，裏面才能根據傳入的內容，進行對應的動作。否則,nand flash內部,怎麼知道你傳入的是數據,還是地址,還是命令啊,也就無法實現正確的操作了.
【Nand Flash只有8個I/O引腳的好處】
1. 減少外圍引腳：相對於並口(Parellel)的Nor Flash的48或52個引腳來說，的確是大大減小了引腳數目，這樣封裝後的芯片體積，就小很多。現在芯片在向體積更小，功能更強，功耗更低發展，減小芯片體積，就是很大的優勢。同時，減少芯片接口，也意味着使用此芯片的相關的外圍電路會更簡化，避免了繁瑣的硬件連線。
2. 提高系統的可擴展性，因爲沒有像其他設備一樣用物理大小對應的完全數目的addr引腳，在芯片內部換了芯片的大小等的改動，對於用全部的地址addr的引腳，那麼就會引起這些引腳數目的增加，比如容量擴大一倍，地址空間/尋址空間擴大一倍，所以，地址線數目/addr引腳數目，就要多加一個，而對於統一用8個I/O的引腳的Nand Flash，由於對外提供的都是統一的8個引腳，內部的芯片大小的變化或者其他的變化，對於外部使用者(比如編寫nand flash驅動的人)來說，不需要關心，只是保證新的芯片，還是遵循同樣的接口，同樣的時序，同樣的命令，就可以了。這樣就提高了系統的擴展性。
【Nand flash的一些典型(typical)特性】
1.頁擦除時間是200us，有些慢的有800us。
2.塊擦除時間是1.5ms.
3.頁數據讀取到數據寄存器的時間一般是20us。
4.串行訪問（Serial access）讀取一個數據的時間是25ns，而一些舊的nand flash是30ns，甚至是50ns。
5.輸入輸出端口是地址和數據以及命令一起multiplex複用的。
以前老的Nand Flash，編程/擦除時間比較短，比如K9G8G08U0M，才5K次，而後來很多6.nand flash的編程/擦除的壽命，最多允許的次數，以前的nand flash多數是10K次，也就是1萬次，而現在很多新的nand flash，技術提高了，比如，Micron的MT29F1GxxABB，Numonyx的 NAND04G-B2D/NAND08G-BxC，都可以達到100K，也就是10萬次的編程/擦除。和之前常見的Nor Flash達到同樣的使用壽命了。
7.48引腳的TSOP1封裝 或 52引腳的ULGA封裝
【Nand Flash中的特殊硬件結構】
由於nand flash相對其他常見設備來說，比較特殊，所以，特殊的設備，也有特殊的設計，所以，有些特殊的硬件特性，就有比較解釋一下：
1. 頁寄存器（Page Register）：由於Nand Flash讀取和編程操作來說，一般最小單位是頁，所以，nand flash在硬件設計時候，就考慮到這一特性，對於每一片，都有一個對應的區域，專門用於存放，將要寫入到物理存儲單元中去的或者剛從存儲單元中讀取出來的，一頁的數據，這個數據緩存區，本質上就是一個buffer，但是隻是名字叫法不同，datasheet裏面叫做Page Register，此處翻譯爲 頁寄存器，實際理解爲頁緩存，更爲恰當些。而正是因爲有些人不瞭解此內部結構，才容易產生之前遇到的某人的誤解，以爲內存裏面的數據，通過Nand Flash的FIFO，寫入到Nand Flash裏面去，就以爲立刻實現了實際數據寫入到物理存儲單元中了。而實際上，只是寫到了這個頁緩存中，只有等你發了對應的編程第二階段的確認命令0x10之後，實際的編程動作纔開始，纔開始把頁緩存中的數據，一點點寫到物理存儲單元中去。
所以，簡單總結一下就是，對於數據的流向，實際是經過了如下步驟：
圖4 Nand Flash讀寫時的數據流向
【Nand Flash中的壞塊(Bad Block)】
Nand Flash中，一個塊中含有1個或多個位是壞的，就成爲其爲壞塊。
壞塊的穩定性是無法保證的，也就是說，不能保證你寫入的數據是對的，或者寫入對了，讀出來也不一定對的。而正常的塊，肯定是寫入讀出都是正常的。
壞塊有兩種：
（1）一種是出廠的時候，也就是，你買到的新的，還沒用過的Nand Flash，就可以包含了壞塊。此類出廠時就有的壞塊，被稱作factory (masked)bad block或initial bad/invalid block，在出廠之前，就會做對應的標記，標爲壞塊。
具體標記的地方是，對於現在常見的頁大小爲2K的Nand Flash，是塊中第一個頁的oob起始位置（關於什麼是頁和oob，下面會有詳細解釋）的第1個字節（舊的小頁面，pagesize是512B甚至256B的nand flash，壞塊標記是第6個字節），如果不是0xFF，就說明是壞塊。相對應的是，所有正常的塊，好的塊，裏面所有數據都是0xFF的。
（2）第二類叫做在使用過程中產生的，由於使用過程時間長了，在擦塊除的時候，出錯了，說明此塊壞了，也要在程序運行過程中，發現，並且標記成壞塊的。具體標記的位置，和上面一樣。這類塊叫做worn-out bad block。
對於壞塊的管理，在Linux系統中，叫做壞塊管理（BBM，Bad Block Managment），對應的會有一個表去記錄好塊，壞塊的信息，以及壞塊是出廠就有的，還是後來使用產生的，這個表叫做壞塊表（BBT，Bad Block Table）。在Linux 內核MTD架構下的Nand Flash驅動，和Uboot中Nand Flash驅動中，在加載完驅動之後，如果你沒有加入參數主動要求跳過壞塊掃描的話，那麼都會去主動掃描壞塊，建立必要的BBT的，以備後面壞塊管理所使用。
而關於好塊和壞塊，Nand Flash在出廠的時候，會做出保證：
1.關於好的，可以使用的塊的數目達到一定的數目，比如三星的K9G8G08U0M，整個flash一共有4096個塊，出廠的時候，保證好的塊至少大於3996個，也就是意思是，你新買到這個型號的nand flash，最壞的可能， 有3096－3996＝100個壞塊。不過，事實上，現在出廠時的壞塊，比較少，絕大多數，都是使用時間長了，在使用過程中出現的。
2.保證第一個塊是好的，並且一般相對來說比較耐用。做此保證的主要原因是，很多Nand Flash壞塊管理方法中，就是將第一個塊，用來存儲上面提到的BBT，否則，都是出錯機率一樣的塊，那麼也就不太好管理了，連放BBT的地方，都不好找了，^_^。
一般來說，不同型號的Nand Flash的數據手冊中，也會提到，自己的這個nand flash，最多允許多少個壞塊。就比如上面提到的，三星的K9G8G08U0M，最多有100個壞塊。
對於壞塊的標記，本質上，也只是對應的flash上的某些字節的數據是非0xFF而已，所以，只要是數據，就是可以讀取和寫入的。也就意味着，可以寫入其他值，也就把這個壞塊標記信息破壞了。對於出廠時的壞塊，一般是不建議將標記好的信息擦除掉的。
uboot中有個命令是“nand scrub”就可以將塊中所有的內容都擦除了，包括壞塊標記，不論是出廠時的，還是後來使用過程中出現而新標記的。一般來說，不建議用這個。不過，我倒是經常用，其實也沒啥大礙，呵呵。
最好用“nand erase”只擦除好的塊，對於已經標記壞塊的塊，不擦除。
【nand Flash中頁的訪問順序】
在一個塊內，對每一個頁進行編程的話，必須是順序的，而不能是隨機的。比如，一個塊中有128個頁，那麼你只能先對page0編程，再對page1編程，。。。。，而不能隨機的，比如先對page3，再page1，page2.，page0，page4，.。。。
【片選無關(CE don’t-care)技術】
很多Nand flash支持一個叫做CE don’t-care的技術，字面意思就是，不關心是否片選，
那有人會問了，如果不片選，那還能對其操作嗎？答案就是，這個技術，主要用在當時是不需要選中芯片卻還可以繼續操作的這些情況：在某些應用，比如錄音，音頻播放等應用，中，外部使用的微秒（us）級的時鐘週期，此處假設是比較少的2us，在進行讀取一頁或者對頁編程時，是對Nand Flash操作，這樣的串行（Serial Access）訪問的週期都是20/30/50ns，都是納秒（ns）級的，此處假設是50ns，當你已經發了對應的讀或寫的命令之後，接下來只是需要Nand Flash內部去自己操作，將數據讀取除了或寫入進去到內部的數據寄存器中而已，此處，如果可以把片選取消，CE#是低電平有效，取消片選就是拉高電平，這樣會在下一個外部命令發送過來之前，即微秒量級的時間裏面，即2us－50ns≈2us，這段時間的取消片選，可以降低很少的系統功耗，但是多次的操作，就可以在很大程度上降低整體的功耗了。
總結起來簡單解釋就是：由於某些外部應用的頻率比較低，而Nand Flash內部操作速度比較快，所以具體讀寫操作的大部分時間裏面，都是在等待外部命令的輸入，同時卻選中芯片，產生了多餘的功耗，此“不關心片選”技術，就是在Nand Flash的內部的相對快速的操作（讀或寫）完成之後，就取消片選，以節省系統功耗。待下次外部命令/數據/地址輸入來的時候，再選中芯片，即可正常繼續操作了。這樣，整體上，就可以大大降低系統功耗了。
注:Nand Flash的片選與否，功耗差別會有很大。如果數據沒有記錯的話，我之前遇到我們系統裏面的nand flash的片選，大概有5個mA的電流輸出呢，要知道，整個系統優化之後的待機功耗，也才10個mA左右的。
【帶EDC的拷回操作以及Sector的定義（Copy-Back Operation with EDC & Sector Definition for EDC）】
Copy-Back功能，簡單的說就是，將一個頁的數據，拷貝到另一個頁。
如果沒有Copy-Back功能，那麼正常的做法就是，先要將那個頁的數據拷貝出來放到內存的數據buffer中，讀出來之後，再用寫命令將這頁的數據，寫到新的頁裏面。
而Copy-Back功能的好處在於，不需要用到外部的存儲空間，不需要讀出來放到外部的buffer裏面，而是可以直接讀取數據到內部的頁寄存器（page
register）然後寫到新的頁裏面去。而且，爲了保證數據的正確，要硬件支持EDC（Error
Detection Co
而對於錯誤檢測來說，硬件一般支持的是512字節數據，對應有16字節用來存放校驗產生的ECC數值，而這512字節一般叫做一個扇區。對於2K＋64字節大小的頁來說，按照512字節分，分別叫做A，B，C，D區，而後面的64字節的oob區域，按照16字節一個區，分別叫做E，F，G，H區，對應存放A，B，C，D數據區的ECC的值。
Copy-Back編程的主要作用在於，去掉了數據串行讀取出來，再串行寫入進去的時間，所以，而這部分操作，是比較耗時的，所以此技術可以提高編程效率，提高系統整體性能。
【多片同時編程(Simultaneously Program Multi Plane)】
對於有些新出的Nand Flash，支持同時對多個片進行編程，比如上面提到的三星的K9K8G08U0A，內部包含4片(Plane)，分別叫做Plane0，Plane1，Plane2，Plane3。.由於硬件上，對於每一個Plane，都有對應的大小是2048+64=2112字節的頁寄存器（Page Register），使得同時支持多個Plane編程成爲可能。 K9K8G08U0A支持同時對2個Plane進行編程。不過要注意的是，只能對Plane0和Plane1或者Plane2和Plane3，同時編程，而不支持Plane0和Plane2同時編程。
【交錯頁編程（Interleave Page Program）】
多片同時編程，是針對一個chip裏面的多個Plane來說的，
而此處的交錯頁編程，是指對多個chip而言的。
可以先對一個chip，假設叫chip1，裏面的一頁進行編程，然後此時，chip1內部就開始將數據一點點寫到頁裏面，就出於忙的狀態了，而此時可以利用這個時間，對出於就緒狀態的chip2，也進行頁編程，發送對應的命令後，chip2內部也就開始慢慢的寫數據到存儲單元裏面去了，也出於忙的狀態了。此時，再去檢查chip1，如果編程完成了，就可以開始下一頁的編程了，然後發完命令後，就讓其內部慢慢的編程吧，再去檢查chip2，如果也是編程完了，也就可以進行接下來的其他頁的編程了。如此，交互操作chip1和chip2，就可以有效地利用時間，使得整體編程效率提高近2倍，大大提高nand flash的編程/擦寫速度了。
【隨機輸出頁內數據（Random Da
在介紹此特性之前，先要說說，與Random Da
正常情況下，我們讀取數據，都是先發讀命令，然後等待數據從存儲單元到內部的頁數據寄存器中後，我們通過不斷地將RE#(Read Enale，低電平有效)置低，然後從我們開始傳入的列的起始地址，一點點讀出我們要的數據，直到頁的末尾，當然有可能還沒到頁地址的末尾，就不再讀了。所謂的順序（sequential）讀取也就是，根據你之前發送的列地址的起始地址開始，每讀一個字節的數據出來，內部的數據指針就加1，移到下個字節的地址，然後你再讀下一個字節數據，就可以讀出來你要的數據了，直到讀取全部的數據出來爲止。
而此處的隨機（random）讀取，就是在你正常的順序讀取的過程中，先發一個隨機讀取的開始命令0x05命令，再傳入你要將內部那個數據指針定位到具體什麼地址，也就是2個cycle的列地址，然後再發隨機讀取結束命令0xE0，然後，內部那個數據地址指針，就會移動到你所制定的位置了，你接下來再讀取的數據，就是從那個制定地址開始的數據了。
而nand flash數據手冊裏面也說了，這樣的隨機讀取，你可以多次操作，沒限制的。
請注意，上面你所傳入的地址，都是列地址，也就是頁內地址，也就是說，對於頁大小爲2K的nand flash來說，所傳入的地址，應該是小於2048+64＝2112的。
不過，實際在nand flash的使用中，好像這種用法很少的。絕大多數，都是順序讀取數據。
【頁編程】
Nand flash的寫操作叫做編程Program，編程，一般情況下，是以頁爲單位的。
有的Nand Flash，比如K9K8G08U0A，支持部分頁編程，但是有一些限制：在同一個頁內的，連續的部分頁的編程，不能超過4此。一般情況下，很少使用到部分頁編程，都是以頁爲單位進行編程操作的。
一個操作，用兩個命令去實現，看起來是多餘，效率不高，但是實際上，有其特殊考慮，
至少對於塊擦除來說，開始的命令0x60是擦除設置命令(erase setup comman)，然後傳入要擦除的塊地址，然後再傳入擦除確認命令（erase confirm command）0xD0，以開始擦除的操作。
這種，分兩步：開始設置，最後確認的命令方式，是爲了避免由於外部由於無意的/未預料而產生的噪音，比如，由於某種噪音，而產生了0x60命令，此時，即使被nand flash誤認爲是擦除操作，但是沒有之後的確認操作0xD0，nand flash就不會去擦除數據，這樣使得數據更安全，不會由於噪音而誤操作。
【讀（read）操作過程詳解】
以最簡單的read操作爲例，解釋如何理解時序圖，以及將時序圖
中的要求，轉化爲代碼。
解釋時序圖之前，讓我們先要搞清楚，我們要做的事情：那就是，要從nand flash的某個頁裏面，讀取我們要的數據。
要實現此功能，會涉及到幾部分的知識，至少很容易想到的就是：需要用到哪些命令，怎麼發這些命令，怎麼計算所需要的地址，怎麼讀取我們要的數據等等。
下面，就一步步的解釋，需要做什麼，以及如何去做：
1.需要使用何種命令
首先，是要了解，對於讀取數據，要用什麼命令。
下面是datasheet中的命令集合：
圖5.Nand Flash K9K8G08U0A的命令集合
很容易看出，我們要讀取數據，要用到Read命令，該命令需要2個週期，第一個週期發0x00，第二個週期發0x30。
2.發送命令前的準備工作以及時序圖各個信號的具體含義
知道了用何命令後，再去了解如何發送這些命令。
[小常識]
在開始解釋前，多羅嗦一下”使能”這個詞，以便有些讀者和我以前一樣，在聽這類雖然對於某些專業人士說是屬於最基本的詞彙了，但是對於初次接觸，或者接觸不多的人來說，聽多了，容易被搞得一頭霧水：使能（Enable），是指使其（某個信號）有效，使其生效的意思，“使其”“能夠”怎麼怎麼樣。。。。比如，上面圖中的CLE線號，是高電平有效，如果此時將其設爲高電平，我們就叫做，將CLE使能，也就是使其生效的意思。
圖6.Nand Flash數據讀取操作的時序圖
注：此圖來自三星的型號K9K8G08U0A的nand flash的數據手冊(datasheet)。
我們來一起看看，我在圖6中的特意標註的①邊上的黃色豎線。
黃色豎線所處的時刻，是在發送讀操作的第一個週期的命令0x00之前的那一刻。
讓我們看看，在那一刻，其所穿過好幾行都對應什麼值，以及進一步理解，爲何要那個值。
（1）黃色豎線穿過的第一行，是CLE。還記得前面介紹命令所存使能（CLE）那個引腳吧？CLE，將CLE置1，就說明你將要通過I/O複用端口發送進入Nand Flash的，是命令，而不是地址或者其他類型的數據。只有這樣將CLE置1，使其有效，才能去通知了內部硬件邏輯，你接下來將收到的是命令，內部硬件邏輯，纔會將受到的命令，放到命令寄存器中，才能實現後面正確的操作，否則，不去將CLE置1使其有效，硬件會無所適從，不知道你傳入的到底是數據還是命令了。
（2）而第二行，是CE#，那一刻的值是0。這個道理很簡單，你既然要向Nand Flash發命令，那麼先要選中它，所以，要保證CE#爲低電平，使其有效，也就是片選有效。
（3）第三行是WE#，意思是寫使能。因爲接下來是往nand Flash裏面寫命令，所以，要使得WE#有效，所以設爲低電平。
（4）第四行，是ALE是低電平，而ALE是高電平有效，此時意思就是使其無效。而對應地，前面介紹的，使CLE有效，因爲將要數據的是命令，而不是地址。如果在其他某些場合，比如接下來的要輸入地址的時候，就要使其有效，而使CLE無效了。
（5）第五行，RE#，此時是高電平，無效。可以看到，知道後面低6階段，才變成低電平，纔有效，因爲那時候，要發生讀取命令，去讀取數據。
（6）第六行，就是我們重點要介紹的，複用的輸入輸出I/O端口了，此刻，還沒有輸入數據，接下來，在不同的階段，會輸入或輸出不同的數據/地址。
（7）第七行，R/B#,高電平，表示R（Ready）/就緒，因爲到了後面的第5階段，硬件內部，在第四階段，接受了外界的讀取命令後，把該頁的數據一點點送到頁寄存器中，這段時間，屬於系統在忙着幹活，屬於忙的階段，所以，R/B#才變成低，表示Busy忙的狀態的。
介紹了時刻①的各個信號的值，以及爲何是這個值之後，相信，後面的各個時刻，對應的不同信號的各個值，大家就會自己慢慢分析了，也就容易理解具體的操作順序和原理了。
3.如何計算出，我們要傳入的地址
在介紹具體讀取數據的詳細流程之前，還要做一件事，那就是，先要搞懂我們要訪問的地址，以及這些地址，如何分解後，一點點傳入進去，使得硬件能識別才行。
此處還是以K9K8G08U0A爲例，此nand flash，一共有8192個塊，每個塊內有64頁，每個頁是2K+64 Bytes，假設，我們要訪問其中的第7000個塊中的第25頁中的1208字節處的地址，此時，我們就要先把具體的地址算出來：
物理地址=塊大小×塊號+頁大小×頁號+頁內地址=7000×128K+64×2K+1208=0x36B204B8,接下來，我們就看看，怎麼才能把這個實際的物理地址，轉化爲nand Flash所要求的格式。
在解釋地址組成之前，先要來看看其datasheet中關於地址週期的介紹：
圖7 Nand Flash的地址週期組成
結合圖7和圖5中的2，3階段，我們可以看出，此nand flash地址週期共有5個，2個列(Column)週期，3個行（Row）週期。而對於對應地，我們可以看出，實際上，列地址A0~A10，就是頁內地址，地址範圍是從0到2047，而對出的A11，理論上可以表示2048～4095，但是實際上，我們最多也只用到了2048～2011，用於表示頁內的oob區域，其大小是64字節。
對應地，A12～A30，稱作頁號，頁的號碼，可以定位到具體是哪一個頁。而其中，A18～A30，表示對應的塊號，即屬於哪個塊。
簡單解釋完了地址組成，那麼就很容易分析上面例子中的地址了：
0x36B204B8 = 0011 0110 1011 0010 0000 0100 1011 1000，分別分配到5個地址週期就是：
1st 週期，A7～A0 ：1011 1000 = 0x B8
2nd週期，A11～A8 ：0000 0100 = 0x04
3rd週期，A19～A12 ：0010 0000 = 0x20
4th週期，A27～A20 ：0110 1011 = 0x6B
5th週期，A30～A28 ：0000 0011 = 0x03
注意，與圖7中對應的，*L，意思是地電平，由於未用到那些位，datasheet中強制要求設爲0，所以，纔有上面的2nd週期中的高4位是0000.其他的A30之後的位也是類似原理，都是0。
因此，接下來要介紹的，我們要訪問第7000個塊中的第25頁中的1208字節處的話，所要傳入的地址就是分5個週期，分別傳入兩個列地址的：0xB8，0x04，然後再傳3個行地址的：0x20，0x6B，0x03，這樣硬件才能識別。
4.讀操作過程的解釋
準備工作終於完了，下面就可以開始解釋說明，對於讀操作的，上面圖中標出來的，1-6個階段，具體是什麼含義。
（1） 操作準備階段：此處是讀（Read）操作，所以，先發一個圖5中讀命令的第一個階段的0x00,表示，讓硬件先準備一下，接下來的操作是讀。
（2） 發送兩個週期的列地址。也就是頁內地址，表示，我要從一個頁的什麼位置開始讀取數據。
（3） 接下來再傳入三個行地址。對應的也就是頁號。
（4） 然後再發一個讀操作的第二個週期的命令0x30。接下來，就是硬件內部自己的事情了。
（5） Nand Flash內部硬件邏輯，負責去按照你的要求，根據傳入的地址，找到哪個塊中的哪個頁，然後把整個這一頁的數據，都一點點搬運到頁緩存中去。而在此期間，你所能做的事，也就只需要去讀取狀態寄存器，看看對應的位的值，也就是R/B#那一位，是1還是0，0的話，就表示，系統是busy，仍在”忙“（着讀取數據），如果是1，就說系統活幹完了，忙清了，已經把整個頁的數據都搬運到頁緩存裏去了，你可以接下來讀取你要的數據了。
對於這裏。估計有人會問了，這一個頁一共2048+64字節，如果我傳入的頁內地址，就像上面給的1208一類的值，只是想讀取1028到2011這部分數據，而不是頁開始的0地址整個頁的數據，那麼內部硬件卻讀取整個頁的數據出來，豈不是很浪費嗎？答案是，的確很浪費，效率看起來不高，但是實際就是這麼做的，而且本身讀取整個頁的數據，相對時間並不長，而且讀出來之後，內部數據指針會定位到你剛纔所制定的1208的那個位置。
（6） 接下來，就是你“竊取“系統忙了半天之後的勞動成果的時候了，呵呵。通過先去Nand Flash的控制器中的數據寄存器中寫入你要讀取多少個字節(byte)/字(word)，然後就可以去Nand Flash的控制器的FIFO中，一點點讀取你要的數據了。
至此，整個Nand Flash的讀操作就完成了。
對於其他操作，可以根據我上面的分析，一點點自己去看datasheet，根據裏面的時序圖去分析具體的操作過程，然後對照代碼，會更加清楚具體是如何實現的。
【Flash的類型】
Flash的類型主要分兩種，nand flash和nor flash。
除了網上最流行的這個解釋之外：
再多說幾句：
1.nor的成本相對高，具體讀寫數據時候，不容易出錯。總體上，比較適合應用於存儲少量的代碼。
2.Nand flash相對成本低。使用中數據讀寫容易出錯，所以一般都需要有對應的軟件或者硬件的數據校驗算法，統稱爲ECC。由於相對來說，容量大，價格便宜，因此適合用來存儲大量的數據。其在嵌入式系統中的作用，相當於PC上的硬盤，用於存儲大量數據。
所以，一個常見的應用組合就是，用小容量的Nor Flash存儲啓動代碼，比如uboot，系統啓動後,初始化對應的硬件，包括SDRAM等，然後將Nand Flash上的Linux 內核讀取到內存中，做好該做的事情後，就跳轉到SDRAM中去執行內核了，然後內核解壓（如果是壓縮內核的話，否則就直接運行了）後，開始運行，在Linux內核啓動最後，去Nand Flash上，掛載根文件，比如jffs2，yaffs2等，掛載完成，運行初始化腳本，啓動consle交互，才運行你通過console和內核交互。至此完成整個系統啓動過程。
而Nor Flash就分別存放的是Uboot，Nand Flash存放的是Linux的內核鏡像和根文件系統，以及餘下的空間分成一個數據區。
Nor flash，有類似於dram之類的地址總線，因此可以直接和CPU相連，CPU可以直接通過地址總線對nor flash進行訪問，而nand flash沒有這類的總線，只有IO接口，只能通過IO接口發送命令和地址，對nand flash內部數據進行訪問。相比之下，nor flash就像是並行訪問，nand flash就是串行訪問，所以相對來說，前者的速度更快些。
但是由於物理製程/製造方面的原因，導致nor 和nand在一些具體操作方面的特性不同：
|
|
NOR |
NAND |
（備註） |
|
接口 |
總線 |
I/O接口 |
這個兩者最大的區別 |
|
單個cell大小 |
大 |
小 |
|
|
單個Cell成本 |
高 |
低 |
|
|
讀耗時 |
快 |
慢 |
|
|
單字節的編程時間 |
快 |
慢 |
|
|
多字節的編程時間 |
慢 |
快 |
|
|
擦除時間 |
慢 |
快 |
|
|
功耗 |
高 |
低，但是需要額外的RAM |
|
|
是否可以執行代碼 |
是 |
不行, 但是一些新的芯片，可以在第一頁之外執行一些小的loader（1） |
即是否允許，芯片內執行(XIP, eXecute In Place) (2) |
|
位反轉(Bit twiddling/bit flip) |
幾乎無限制 |
1-4次，也稱作 “部分頁編程限制” |
也就是數據錯誤，0->1或1->0 |
|
在芯片出廠時候是否允許壞塊 |
不允許 |
允許 |
|
表3 Nand Flash 和 Nor Flash的區別
1. 理論上是可以的，而且也是有人驗證過可以的，只不過由於nand flash的物理特性，不能完全保證所讀取的數據/代碼是正確的，實際上，很少這麼用而已。因爲，如果真是要用到nand flash做XIP，那麼除了讀出速度慢之外，還要保證有數據的校驗，以保證讀出來的，將要執行的代碼/數據，是正確的。否則，系統很容易就跑飛了。。。
2. 芯片內執行(XIP, eXecute In Place):
http://hi.baidu.com/serial_story/blog/item/adb20a2a3f8ffe3c5243c1df.html
【Nand Flash的種類】
具體再分，又可以分爲
1)Bare NAND chips：裸片，單獨的nand 芯片
2)SmartMediaCards： =裸片+一層薄塑料，常用於數碼相機和MP3播放器中。之所以稱smart，是由於其軟件smart，而不是硬件本身有啥smart之處。^_^
3)DiskOnChip：裸片+glue logic，glue logic=硬件ECC產生器+用於靜態的nand 芯片控制的寄存器+直接訪問一小片地址窗口，那塊地址中包含了引導代碼的stub樁，其可以從nand flash中拷貝真正的引導代碼。
【spare area/oob】
Nand由於最初硬件設計時候考慮到，額外的錯誤校驗等需要空間，專門對應每個頁，額外設計了叫做spare area空區域，在其他地方，比如jffs2文件系統中，也叫做oob（out of band）數據。
其具體用途，總結起來有：
1. 標記是否是壞快
2. 存儲ECC數據
3. 存儲一些和文件系統相關的數據，如jffs2就會用到這些空間存儲一些特定信息，yaffs2文件系統，會在oob中，存放很多和自己文件系統相關的信息。
2. 軟件方面
如果想要在Linux下編寫Nand Flash驅動，那麼就先要搞清楚Linux下，關於此部分的整個框架。弄明白，系統是如何管理你的nand flash的，以及，系統都幫你做了那些準備工作，而剩下的，驅動底層實現部分，你要去實現哪些功能，才能使得硬件正常工作起來。
【內存技術設備，MTD（Memory Technology Device）】
MTD，是Linux的存儲設備中的一個子系統。其設計此係統的目的是，對於內存類的設備，提供一個抽象層，一個接口，使得對於硬件驅動設計者來說，可以儘量少的去關心存儲格式，比如FTL，FFS2等，而只需要去提供最簡單的底層硬件設備的讀/寫/擦除函數就可以了。而對於數據對於上層使用者來說是如何表示的，硬件驅動設計者可以不關心，而MTD存儲設備子系統都幫你做好了。
對於MTD字系統的好處，簡單解釋就是，他幫助你實現了，很多對於以前或者其他系統來說，本來也是你驅動設計者要去實現的很多功能。換句話說，有了MTD，使得你設計Nand Flash的驅動，所要做的事情，要少很多很多，因爲大部分工作，都由MTD幫你做好了。
當然，這個好處的一個“副作用”就是，使得我們不瞭解的人去理解整個Linux驅動架構，以及MTD，變得更加複雜。但是，總的說，覺得是利遠遠大於弊，否則，就不僅需要你理解，而且還是做更多的工作，實現更多的功能了。
此外，還有一個重要的原因，那就是，前面提到的nand flash和普通硬盤等設備的特殊性：
有限的通過出複用來實現輸入輸出命令和地址/數據等的IO接口，最小單位是頁而不是常見的bit，寫前需擦除等，導致了這類設備，不能像平常對待硬盤等操作一樣去操作，只能採取一些特殊方法，這就誕生了MTD設備的統一抽象層。
MTD，將nand flash，nor flash和其他類型的flash等設備，統一抽象成MTD設備來管理，根據這些設備的特點，上層實現了常見的操作函數封裝，底層具體的內部實現，就需要驅動設計者自己來實現了。具體的內部硬件設備的讀/寫/擦除函數，那就是你必須實現的了。
|
HARD drives |
MTD device |
|
連續的扇區 |
連續的可擦除塊 |
|
扇區都很小(512B,1024B) |
可擦除塊比較大 (32KB,128KB) |
|
主要通過兩個操作對其維護操作：讀扇區，寫扇區 |
主要通過三個操作對其維護操作：從擦除塊中讀，寫入擦除塊，擦寫可擦除塊 |
|
壞快被重新映射，並且被硬件隱藏起來了（至少是在如今常見的LBA硬盤設備中是如此） |
壞的可擦除塊沒有被隱藏，軟件中要處理對應的壞塊問題。 |
|
HDD扇區沒有擦寫壽命超出的問題。 |
可擦除塊是有擦除次數限制的，大概是104-105次. |
表4.MTD設備和硬盤設備之間的區別
多說一句，關於MTD更多的內容，感興趣的，去附錄中的MTD的主頁去看。
關於mtd設備驅動，感興趣的可以去參考
那裏，算是比較詳細地介紹了整個流程，方便大家理解整個mtd框架和nand flash驅動。
【Nand flash驅動工作原理】
在介紹具體如何寫Nand Flash驅動之前，我們先要了解，大概的，整個系統，和Nand Flash相關的部分的驅動工作流程，這樣，對於後面的驅動實現，才能更加清楚機制，才更容易實現，否則就是，即使寫完了代碼，也還是沒搞懂系統是如何工作的了。
讓我們以最常見的，Linux內核中已經有的三星的Nand Flash驅動，來解釋Nand Flash驅動具體流程和原理。
此處是參考2.6.29版本的Linux源碼中的\drivers\mtd\nand\s3c2410.c，以2410爲例。
1. 在nand flash驅動加載後，第一步，就是去調用對應的init函數，s3c2410_nand_init,去將在nand flash驅動註冊到Linux驅動框架中。
2. 驅動本身，真正開始，是從probe函數，s3c2410_nand_probe->s3c24xx_nand_probe,
在probe過程中，去用clk_enable打開nand flash控制器的clock時鐘，用request_mem_region去申請驅動所需要的一些內存等相關資源。然後，在s3c2410_nand_inithw中，去初始化硬件相關的部分，主要是關於時鐘頻率的計算，以及啓用nand flash控制器，使得硬件初始化好了，後面才能正常工作。
3. 需要多解釋一下的，是這部分代碼：
for (setno = 0; setno < nr_sets; setno++, nmtd++) {
pr_debug("initialising set %d (%p, info %p)\n", setno, nmtd, info);
/* 調用init chip去掛載你的nand 驅動的底層函數到nand flash的結構體中，以及設置對應的ecc mode，掛載ecc相關的函數 */
s3c2410_nand_init_chip(info, nmtd, sets);
/* scan_ident，掃描nand 設備，設置nand flash的默認函數，獲得物理設備的具體型號以及對應各個特性參數，這部分算出來的一些值，對於nand flash來說，是最主要的參數，比如nand falsh的芯片的大小，塊大小，頁大小等。 */
nmtd->scan_res = nand_scan_ident(&nmtd->mtd,
(sets) ? sets->nr_chips : 1);
if (nmtd->scan_res == 0) {
s3c2410_nand_update_chip(info, nmtd);
/* scan tail，從名字就可以看出來，是掃描的後一階段，此時，經過前面的scan_ident，我們已經獲得對應nand flash的硬件的各個參數，然後就可以在scan tail中，根據這些參數，去設置其他一些重要參數，尤其是ecc的layout，即ecc是如何在oob中擺放的，最後，再去進行一些初始化操作，主要是根據你的驅動，如果沒有實現一些函數的話，那麼就用系統默認的。 */
nand_scan_tail(&nmtd->mtd);
/* add partion，根據你的nand flash的分區設置，去分區 */
s3c2410_nand_add_partition(info, nmtd, sets);
}
if (sets != NULL)
sets++;
}
4. 等所有的參數都計算好了，函數都掛載完畢，系統就可以正常工作了。
上層訪問你的nand falsh中的數據的時候，通過MTD層，一層層調用，最後調用到你所實現的那些底層訪問硬件數據/緩存的函數中。
【Linux下nand flash驅動編寫步驟簡介】
關於上面提到的，在nand_scan_tail的時候，系統會根據你的驅動，如果沒有實現一些函數的話，那麼就用系統默認的。如果實現了自己的函數，就用你的。
估計很多人就會問了，那麼到底我要實現哪些函數呢，而又有哪些是可以不實現，用系統默認的就可以了呢。
此問題的，就是我們下面要介紹的，也就是，你要實現的，你的驅動最少要做哪些工作，才能使整個nand flash工作起來。
1. 對於驅動框架部分
其實，要了解，關於驅動框架部分，你所要做的事情的話，只要看看三星的整個nand flash驅動中的這個結構體，就差不多了：
static struct platform_driver s3c2410_nand_driver = {
.probe = s3c2410_nand_probe,
.remove = s3c2410_nand_remove,
.suspend = s3c24xx_nand_suspend,
.resume = s3c24xx_nand_resume,
.driver = {
.name = "s3c2410-nand",
.owner = THIS_MODULE,
},
};
對於上面這個結構體，沒多少要解釋的。從名字，就能看出來：
（1）probe就是系統“探測”，就是前面解釋的整個過程，這個過程中的多數步驟，都是和你自己的nand flash相關的，尤其是那些硬件初始化部分，是你必須要自己實現的。
（2）remove，就是和probe對應的，“反初始化”相關的動作。主要是釋放系統相關資源和關閉硬件的時鐘等常見操作了。
(3)suspend和resume，對於很多沒用到電源管理的情況下，至少對於我們剛開始寫基本的驅動的時候，可以不用關心，放個空函數即可。
2. 對於nand flash底層操作實現部分
而對於底層硬件操作的有些函數，總體上說，都可以在上面提到的s3c2410_nand_init_chip中找到：
static void s3c2410_nand_init_chip(struct s3c2410_nand_info *info,
struct s3c2410_nand_mtd *nmtd,
struct s3c2410_nand_set *set)
{
struct nand_chip *chip = &nmtd->chip;
void __iomem *regs = info->regs;
chip->write_buf = s3c2410_nand_write_buf;
chip->read_buf = s3c2410_nand_read_buf;
chip->select_chip = s3c2410_nand_select_chip;
chip->chip_delay = 50;
chip->priv = nmtd;
chip->options = 0;
chip->controller = &info->controller;
switch (info->cpu_type) {
case TYPE_S3C2410:
/* nand flash控制器中，一般都有對應的數據寄存器，用於給你往裏面寫數據，表示將要讀取或寫入多少個字節(byte,u8)/字(word,u32) ，所以，此處，你要給出地址，以便後面的操作所使用 */
chip->IO_ADDR_W = regs + S3C2410_NFDATA;
info->sel_reg = regs + S3C2410_NFCONF;
info->sel_bit = S3C2410_NFCONF_nFCE;
chip->cmd_ctrl = s3c2410_nand_hwcontrol;
chip->dev_ready = s3c2410_nand_devready;
break;
。。。。。。
}
chip->IO_ADDR_R = chip->IO_ADDR_W;
nmtd->info = info;
nmtd->mtd.priv = chip;
nmtd->mtd.owner = THIS_MODULE;
nmtd->set = set;
if (hardware_ecc) {
chip->ecc.calculate = s3c2410_nand_calculate_ecc;
chip->ecc.correct = s3c2410_nand_correct_da
/* 此處，多數情況下，你所用的Nand Flash的控制器，都是支持硬件ECC的，所以，此處設置硬件ECC(HW_ECC) ，也是充分利用硬件的特性，而如果此處不用硬件去做的ECC的話，那麼下面也會去設置成NAND_ECC_SOFT，系統會用默認的軟件去做ECC校驗，相比之下，比硬件ECC的效率就低很多，而你的nand flash的讀寫，也會相應地要慢不少*/
chip->ecc.mode = NAND_ECC_HW;
switch (info->cpu_type) {
case TYPE_S3C2410:
chip->ecc.hwctl = s3c2410_nand_enable_hwecc;
chip->ecc.calculate = s3c2410_nand_calculate_ecc;
break;
。。。。。
}
} else {
chip->ecc.mode = NAND_ECC_SOFT;
}
if (set->ecc_layout != NULL)
chip->ecc.layout = set->ecc_layout;
if (set->disable_ecc)
chip->ecc.mode = NAND_ECC_NONE;
}
而我們要實現的底層函數，也就是上面藍色標出來的一些函數而已：
（1）s3c2410_nand_write_buf 和 s3c2410_nand_read_buf：這是兩個最基本的操作函數，其功能，就是往你的nand flash的控制器中的FIFO讀寫數據。一般情況下，是MTD上層的操作，比如要讀取一頁的數據，那麼在發送完相關的讀命令和等待時間之後，就會調用到你底層的read_buf，去nand Flash的FIFO中，一點點把我們要的數據，讀取出來，放到我們制定的內存的緩存中去。寫操作也是類似，將我們內存中的數據，寫到Nand Flash的FIFO中去。具體的數據流向，參考上面的圖4。
（2）s3c2410_nand_select_chip ： 實現Nand Flash的片選。
（3）s3c2410_nand_hwcontrol：給底層發送命令或地址，或者設置具體操作的模式，都是通過此函數。
（4）s3c2410_nand_devready：Nand Flash的一些操作，比如讀一頁數據，寫入（編程）一頁數據，擦除一個塊，都是需要一定時間的，在命發送完成後，就是硬件開始忙着工作的時候了，而硬件什麼時候完成這些操作，什麼時候不忙了，變就緒了，就是通過這個函數去檢查狀態的。一般具體實現都是去讀硬件的一個狀態寄存器，其中某一位是否是1，對應着是出於“就緒/不忙”還是“忙”的狀態。這個寄存器，也就是我們前面分析時序圖中的R/B#。
（5）s3c2410_nand_enable_hwecc： 在硬件支持的前提下，前面設置了硬件ECC的話，要實現這個函數，用於每次在讀寫操作前，通過設置對應的硬件寄存器的某些位，使得啓用硬件ECC，這樣在讀寫操作完成後，就可以去讀取硬件校驗產生出來的ECC數值了。
（6）s3c2410_nand_calculate_ecc：如果是上面提到的硬件ECC的話，就不用我們用軟件去實現校驗算法了，而是直接去讀取硬件產生的ECC數值就可以了。
（7）s3c2410_nand_correct_da
當然，除了這些你必須實現的函數之外，在你更加熟悉整個框架之後，你可以根據你自己的nand flash的特點，去實現其他一些原先用系統默認但是效率不高的函數，而用自己的更高效率的函數替代他們，以提升你的nand flash的整體性能和效率。
【引用文章】
http://hi.baidu.com/serial_story/blog/item/3f1635d1dc041cd7562c84a1.html
2. Samsung的型號爲K9G8G08U0M的Nand Flash的數據手冊
要下載數據手冊，可以去這裏介紹的網站下載：
samsung 4K pagesize SLC Nand Flash K9F8G08U0M datasheet + 推薦一個datasheet搜索的網站
http://hi.baidu.com/serial_story/blog/item/7f25a03def1de309bba167c8.html
http://hi.baidu.com/serial_story/blog/item/f06db3546eced11a3b29356c.html
4. Memory Technology Device (MTD) Subsystem for Linux.
http://www.linux-mtd.infradead.org/index.html
小弟抽空研究了一下，打算從下到上，在從上到下，分兩條主線來研究一下MTD原始設備與FLASH硬件驅動的對話(MTD原始設備與更上層的對話留待以後再研究)。
以下是第一部分，從下到上的介紹FLASH硬件驅動與MTD原始設備是如何建立聯繫的。
1、首先從入口函數開始：
static int s3c24xx_nand_probe(struct device *dev, int is_s3c2440)
{
struct platform_device *pdev = to_platform_device(dev);
struct s3c2410_platform_nand *plat = to_nand_plat(dev);
//獲取nand flash配置用結構體數據(dev.c中定義，詳細見附錄部分)
struct s3c2410_nand_info *info;
struct s3c2410_nand_mtd *nmtd;
struct s3c2410_nand_set *sets;
struct resource *res;
int err = 0;
int size;
int nr_sets;
int setno;
pr_debug("s3c2410_nand_probe(%p)\n", dev);
info = kmalloc(sizeof(*info), GFP_KERNEL);
if (info == NULL) {
printk(KERN_ERR PFX "no memory for flash info\n");
err = -ENOMEM;
goto exit_error;
}
memzero(info, sizeof(*info));
dev_set_drvdata(dev, info); //以後有用
spin_lock_init(&info->controller.lock); //初始化自旋鎖
init_waitqueue_head(&info->controller.wq); //初始化等待隊列
/* get the clock source and enable it */
info->clk = clk_get(dev, "nand");
if (IS_ERR(info->clk)) {
printk(KERN_ERR PFX "failed to get clock");
err = -ENOENT;
goto exit_error;
}
clk_use(info->clk);
clk_enable(info->clk);
/* allocate and map the resource */
/* currently we assume we have the one resource */
res = pdev->resource; //提取dev.c中定義的與設備相關的資源
size = res->end - res->start + 1;
info->area = request_mem_region(res->start, size, pdev->name);
if (info->area == NULL) {
printk(KERN_ERR PFX "cannot reserve register region\n");
err = -ENOENT;
goto exit_error;
}
info->device = dev;
info->platform = plat; //保存好struct s3c2410_platform_nand結構數據
info->regs = ioremap(res->start, size);//映射nand flash用到的寄存器
info->is_s3c2440 = is_s3c2440;
if (info->regs == NULL) {
printk(KERN_ERR PFX "cannot reserve register region\n");
err = -EIO;
goto exit_error;
}
printk(KERN_INFO PFX "mapped registers at %p\n", info->regs);
/* initialise the hardware */
err = s3c2410_nand_inithw(info, dev);
//初始化s3c2410 nand flash控制，主要是配置S3C2410_NFCONF寄存器
if (err != 0)
goto exit_error;
sets = (plat != NULL) ? plat->sets : NULL;
nr_sets = (plat != NULL) ? plat->nr_sets : 1;
info->mtd_count = nr_sets;
//我的板上只有一塊nand flash，配置信息見plat-sets，數目爲1。
/* allocate our information */
size = nr_sets * sizeof(*info->mtds);
info->mtds = kmalloc(size, GFP_KERNEL);
if (info->mtds == NULL) {
printk(KERN_ERR PFX "failed to allocate mtd storage\n");
err = -ENOMEM;
goto exit_error;
}
memzero(info->mtds, size);
/* initialise all possible chips */
nmtd = info->mtds;
for (setno = 0; setno < nr_sets; setno++, nmtd++) {
pr_debug("initialising set %d (%p, info %p)\n",
setno, nmtd, info);
s3c2410_nand_init_chip(info, nmtd, sets);
nmtd->scan_res = nand_scan(&nmtd->mtd,
(sets) ? sets->nr_chips : 1);//爲什麼使用set->nr_chips(還沒配置的東西)？
if (nmtd->scan_res == 0) {
s3c2410_nand_add_partition(info, nmtd, sets);
}
if (sets != NULL)
sets++;
}
pr_debug("initialised ok\n");
return 0;
exit_error:
s3c2410_nand_remove(dev);
if (err == 0)
err = -EINVAL;
return err;
}
//初始化代表一片flash的struct nand_chip結構
static void s3c2410_nand_init_chip(struct s3c2410_nand_info *info,
struct s3c2410_nand_mtd *nmtd,
struct s3c2410_nand_set *set)
{
struct nand_chip *chip = &nmtd->chip;
chip->IO_ADDR_R = info->regs + S3C2410_NFDATA; //讀地址
chip->IO_ADDR_W = info->regs + S3C2410_NFDATA; //寫地址
chip->hwcontrol = s3c2410_nand_hwcontrol;
chip->dev_ready = s3c2410_nand_devready; //ready狀態查詢
chip->write_buf = s3c2410_nand_write_buf; //寫函數
chip->read_buf = s3c2410_nand_read_buf; //讀函數
chip->select_chip = s3c2410_nand_select_chip; //片選函數
chip->chip_delay = 50;
chip->priv = nmtd;
chip->options = 0;
chip->controller = &info->controller;
if (info->is_s3c2440) {
chip->IO_ADDR_R = info->regs + S3C2440_NFDATA;
chip->IO_ADDR_W = info->regs + S3C2440_NFDATA;
chip->hwcontrol = s3c2440_nand_hwcontrol;
}
nmtd->info = info;
nmtd->mtd.priv = chip;
//nand_scan函數中會調用struct nand_chip *this = mtd->priv取出該struct nand_chip結構
nmtd->set = set;
if (hardware_ecc) {
chip->correct_data = s3c2410_nand_correct_data;
chip->enable_hwecc = s3c2410_nand_enable_hwecc;
chip->calculate_ecc = s3c2410_nand_calculate_ecc;
chip->eccmode = NAND_ECC_HW3_512;
chip->autooob = &nand_hw_eccoob;
if (info->is_s3c2440) {
chip->enable_hwecc = s3c2440_nand_enable_hwecc;
chip->calculate_ecc = s3c2440_nand_calculate_ecc;
}
} else {
chip->eccmode = NAND_ECC_SOFT; //ECC的類型
}
}
/* command and control functions
*
* Note, these all use tglx's method of changing the IO_ADDR_W field
* to make the code simpler, and use the nand layer's code to issue the
* command and address sequences via the proper IO ports.
*
*/
static void s3c2410_nand_hwcontrol(struct mtd_info *mtd, int cmd)
{
struct s3c2410_nand_info *info = s3c2410_nand_mtd_toinfo(mtd);
struct nand_chip *chip = mtd->priv;
switch (cmd) {
case NAND_CTL_SETNCE:
case NAND_CTL_CLRNCE:
printk(KERN_ERR "%s: called for NCE\n", __FUNCTION__);
break;
case NAND_CTL_SETCLE:
chip->IO_ADDR_W = info->regs + S3C2410_NFCMD;//寫命令
break;
case NAND_CTL_SETALE:
chip->IO_ADDR_W = info->regs + S3C2410_NFADDR;//寫地址
break;
/* NAND_CTL_CLRCLE: */
/* NAND_CTL_CLRALE: */
default:
chip->IO_ADDR_W = info->regs + S3C2410_NFDATA;//寫數據
break;
}
}
/* s3c2410_nand_devready()
*
* returns 0 if the nand is busy, 1 if it is ready
*/
static int s3c2410_nand_devready(struct mtd_info *mtd)
{
struct s3c2410_nand_info *info = s3c2410_nand_mtd_toinfo(mtd);
if (info->is_s3c2440)
return readb(info->regs + S3C2440_NFSTAT) & S3C2440_NFSTAT_READY;
return readb(info->regs + S3C2410_NFSTAT) & S3C2410_NFSTAT_BUSY;//返回nand flash都忙標誌
}
static void s3c2410_nand_write_buf(struct mtd_info *mtd,
const u_char *buf, int len)
{
struct nand_chip *this = mtd->priv;
writesb(this->IO_ADDR_W, buf, len);//寫操作
}
static void s3c2410_nand_read_buf(struct mtd_info *mtd, u_char *buf, int len)
{
struct nand_chip *this = mtd->priv;
readsb(this->IO_ADDR_R, buf, len);//讀操作
}
/* select chip */
/*
* 根據chip都值設置nand flash都片選信號:
* chip = -1 -- 禁用nand flash
* chip !=-1 -- 選擇對應的nand flash
*/
static void s3c2410_nand_select_chip(struct mtd_info *mtd, int chip)
{
struct s3c2410_nand_info *info;
struct s3c2410_nand_mtd *nmtd;
struct nand_chip *this = mtd->priv;
void __iomem *reg;
unsigned long cur;
unsigned long bit;
nmtd = this->priv;
info = nmtd->info;
bit = (info->is_s3c2440) ? S3C2440_NFCONT_nFCE : S3C2410_NFCONF_nFCE;
reg = info->regs+((info->is_s3c2440) ? S3C2440_NFCONT:S3C2410_NFCONF);
cur = readl(reg);
if (chip == -1) {
cur |= bit;
} else {
if (nmtd->set != NULL && chip > nmtd->set->nr_chips) {
printk(KERN_ERR PFX "chip %d out of range\n", chip);
return;
}
if (info->platform != NULL) {
if (info->platform->select_chip != NULL)
(info->platform->select_chip)(nmtd->set, chip);
}
cur &= ~bit;
}
writel(cur, reg);
}
注：
s3c2410_nand_init_chip填充struct nand_chip的一部分成員，nand_scan以通用nand flash的標準進行檢測，並填充struct nand_chip的其它成員，必要時根據檢測結果進行取捨。
int nand_scan (struct mtd_info *mtd, int maxchips)
{
int i, nand_maf_id, nand_dev_id, busw, maf_id;
struct nand_chip *this = mtd->priv; //取出struct nand_chip結構
/* Get buswidth to select the correct functions*/
busw = this->options & NAND_BUSWIDTH_16; //nand flash的位寬
/* check for proper chip_delay setup, set 20us if not */
if (!this->chip_delay)
this->chip_delay = 20;
/* check, if a user supplied command function given */
if (this->cmdfunc == NULL) //填充命令函數
this->cmdfunc = nand_command;
/* check, if a user supplied wait function given */
if (this->waitfunc == NULL) //填充等待函數
this->waitfunc = nand_wait;
if (!this->select_chip) //s3c2410_nand_init_chip中已定義
this->select_chip = nand_select_chip;
if (!this->write_byte) //使用默認的
this->write_byte = busw ? nand_write_byte16 : nand_write_byte;
if (!this->read_byte) //使用默認的
this->read_byte = busw ? nand_read_byte16 : nand_read_byte;
if (!this->write_word) //使用默認的
this->write_word = nand_write_word;
if (!this->read_word) //使用默認的
this->read_word = nand_read_word;
if (!this->block_bad) //使用默認的
this->block_bad = nand_block_bad;
if (!this->block_markbad) //使用默認的
this->block_markbad = nand_default_block_markbad;
if (!this->write_buf) //s3c2410_nand_init_chip中已定義
this->write_buf = busw ? nand_write_buf16 : nand_write_buf;
if (!this->read_buf) //s3c2410_nand_init_chip中已定義
this->read_buf = busw ? nand_read_buf16 : nand_read_buf;
if (!this->verify_buf) //使用默認的
this->verify_buf = busw ? nand_verify_buf16 : nand_verify_buf;
if (!this->scan_bbt) //使用默認的
this->scan_bbt = nand_default_bbt;
/* Select the device */
this->select_chip(mtd, 0); //片選，可惜在s3c2410 nand flash控制器中此操作爲空
/* Send the command for reading device ID */
this->cmdfunc (mtd, NAND_CMD_READID, 0x00, -1);//發送讀ID命令
/* Read manufacturer and device IDs */
nand_maf_id = this->read_byte(mtd); //讀取生產商ID
nand_dev_id = this->read_byte(mtd); //讀取設備ID
/* Print and store flash device information */
for (i = 0; nand_flash_ids[i].name != NULL; i++) {
//保存着nand flash資料的nand_flash_ids表在include/linux/mtd/nand_ids.c文件中，詳細見附錄
if (nand_dev_id != nand_flash_ids[i].id) //比較設備ID
continue;
if (!mtd->name) mtd->name = nand_flash_ids[i].name; //填充設備名
this->chipsize = nand_flash_ids[i].chipsize << 20; //填充設備大小
/* New devices have all the information in additional id bytes */
if (!nand_flash_ids[i].pagesize) {
int extid;
/* The 3rd id byte contains non relevant data ATM */
extid = this->read_byte(mtd);
/* The 4th id byte is the important one */
extid = this->read_byte(mtd);
/* Calc pagesize */
mtd->oobblock = 1024 << (extid & 0x3);
extid >>= 2;
/* Calc oobsize */
mtd->oobsize = (8 << (extid & 0x03)) * (mtd->oobblock / 512);
extid >>= 2;
/* Calc blocksize. Blocksize is multiples of 64KiB */
mtd->erasesize = (64 * 1024) << (extid & 0x03);
extid >>= 2;
/* Get buswidth information */
busw = (extid & 0x01) ? NAND_BUSWIDTH_16 : 0;
} else {
/* Old devices have this data hardcoded in the
* device id table */
mtd->erasesize = nand_flash_ids[i].erasesize; //填充檫除單元大小(16k)
mtd->oobblock = nand_flash_ids[i].pagesize; //填充頁大小(512)
mtd->oobsize = mtd->oobblock / 32; //oob大小(512/32=16)
busw = nand_flash_ids[i].options & NAND_BUSWIDTH_16;//獲取nand flash表中定義的位寬
}
/* Try to identify manufacturer */ //比較生產商ID
for (maf_id = 0; nand_manuf_ids[maf_id].id != 0x0; maf_id++) {
if (nand_manuf_ids[maf_id].id == nand_maf_id)
break;
}
/* Check, if buswidth is correct. Hardware drivers should set
* this correct ! */
/用戶定義的位寬與芯片實際的位寬不一致，取消nand flash的片選
if (busw != (this->options & NAND_BUSWIDTH_16)) {
printk (KERN_INFO "NAND device: Manufacturer ID:"
" 0x%02x, Chip ID: 0x%02x (%s %s)\n", nand_maf_id, nand_dev_id,
nand_manuf_ids[maf_id].name , mtd->name);
printk (KERN_WARNING
"NAND bus width %d instead %d bit\n",
(this->options & NAND_BUSWIDTH_16) ? 16 : 8,
busw ? 16 : 8);
this->select_chip(mtd, -1);//在s3c2410 nand flash控制器驅動中，此操作爲空操作
return 1;
}
/* Calculate the address shift from the page size */
//計算頁、可檫除單元、nand flash大小的偏移值
this->page_shift = ffs(mtd->oobblock) - 1;
this->bbt_erase_shift = this->phys_erase_shift = ffs(mtd->erasesize) - 1;
this->chip_shift = ffs(this->chipsize) - 1;
/* Set the bad block position */
//標註此nand flash爲大頁還是小頁？
this->badblockpos = mtd->oobblock > 512 ?
NAND_LARGE_BADBLOCK_POS : NAND_SMALL_BADBLOCK_POS;
/* Get chip options, preserve non chip based options */
//用戶沒指定的選項從nand flash表中獲取補上
this->options &= ~NAND_CHIPOPTIONS_MSK;
this->options |= nand_flash_ids[i].options & NAND_CHIPOPTIONS_MSK;
/* Set this as a default. Board drivers can override it, if neccecary */
this->options |= NAND_NO_AUTOINCR;
/* Check if this is a not a samsung device. Do not clear the options
* for chips which are not having an extended id.
*/
if (nand_maf_id != NAND_MFR_SAMSUNG && !nand_flash_ids[i].pagesize)
this->options &= ~NAND_SAMSUNG_LP_OPTIONS;
/* Check for AND chips with 4 page planes */
if (this->options & NAND_4PAGE_ARRAY)
this->erase_cmd = multi_erase_cmd;
else
this->erase_cmd = single_erase_cmd;
/* Do not replace user supplied command function ! */
if (mtd->oobblock > 512 && this->cmdfunc == nand_command)
this->cmdfunc = nand_command_lp;
printk (KERN_INFO "NAND device: Manufacturer ID:"
" 0x%02x, Chip ID: 0x%02x (%s %s)\n", nand_maf_id, nand_dev_id,
nand_manuf_ids[maf_id].name , nand_flash_ids[i].name);
break;
}//好的，檢測結束^_^
if (!nand_flash_ids[i].name) {
printk (KERN_WARNING "No NAND device found!!!\n");
this->select_chip(mtd, -1);
return 1;
}
//統計一下同種類型的nand flash有多少塊(我板上只有一塊)
for (i=1; i < maxchips; i++) {
this->select_chip(mtd, i);
/* Send the command for reading device ID */
this->cmdfunc (mtd, NAND_CMD_READID, 0x00, -1);
/* Read manufacturer and device IDs */
if (nand_maf_id != this->read_byte(mtd) ||
nand_dev_id != this->read_byte(mtd))
break;
}
if (i > 1)
printk(KERN_INFO "%d NAND chips detected\n", i);
/* Allocate buffers, if neccecary */
if (!this->oob_buf) {
size_t len;
//求出一個檫除單元64K中oob所佔用的總空間
len = mtd->oobsize << (this->phys_erase_shift - this->page_shift);
this->oob_buf = kmalloc (len, GFP_KERNEL);
if (!this->oob_buf) {
printk (KERN_ERR "nand_scan(): Cannot allocate oob_buf\n");
return -ENOMEM;
}
this->options |= NAND_OOBBUF_ALLOC;//oob空間已分配，置相應的標誌位
}
if (!this->data_buf) {
size_t len;
len = mtd->oobblock + mtd->oobsize;//512+16=128
this->data_buf = kmalloc (len, GFP_KERNEL);
if (!this->data_buf) {
if (this->options & NAND_OOBBUF_ALLOC)
kfree (this->oob_buf);
printk (KERN_ERR "nand_scan(): Cannot allocate data_buf\n");
return -ENOMEM;
}
this->options |= NAND_DATABUF_ALLOC;//數據空間已分配，置相應的標誌位
}
/* Store the number of chips and calc total size for mtd */
this->numchips = i;//記錄nand flash片數
mtd->size = i * this->chipsize;//計算出nand flash總大小
/* Convert chipsize to number of pages per chip -1. */
this->pagemask = (this->chipsize >> this->page_shift) - 1;//(64M>>9)-1=128k-1=0x1ffff
/* Preset the internal oob buffer */
//oob_buf全部置爲0xff
memset(this->oob_buf, 0xff, mtd->oobsize << (this->phys_erase_shift - this->page_shift));
/* If no default placement scheme is given, select an
* appropriate one */
if (!this->autooob) { //我們選用的是NAND_ECC_SOFT，autooob未設置
/* Select the appropriate default oob placement scheme for
* placement agnostic filesystems */
switch (mtd->oobsize) {
case 8:
this->autooob = &nand_oob_8;
break;
case 16:
this->autooob = &nand_oob_16;//我們的nand flash屬於這一類
break;
case 64:
this->autooob = &nand_oob_64;
break;
default:
printk (KERN_WARNING "No oob scheme defined for oobsize %d\n",
mtd->oobsize);
BUG();
}
}
注：
ECC的東西不是很懂，先跳過^_^
/* The number of bytes available for the filesystem to place fs dependend
* oob data */
mtd->oobavail = 0;
for (i = 0; this->autooob->oobfree[i][1]; i++)
mtd->oobavail += this->autooob->oobfree[i][1];
/*
* check ECC mode, default to software
* if 3byte/512byte hardware ECC is selected and we have 256 byte pagesize
* fallback to software ECC
*/
this->eccsize = 256; /* set default eccsize */
this->eccbytes = 3;
switch (this->eccmode) {
case NAND_ECC_HW12_2048:
if (mtd->oobblock < 2048) {
printk(KERN_WARNING "2048 byte HW ECC not possible on %d byte page size, fallback to SW ECC\n",
mtd->oobblock);
this->eccmode = NAND_ECC_SOFT;
this->calculate_ecc = nand_calculate_ecc;
this->correct_data = nand_correct_data;
} else
this->eccsize = 2048;
break;
case NAND_ECC_HW3_512:
case NAND_ECC_HW6_512:
case NAND_ECC_HW8_512:
if (mtd->oobblock == 256) {
printk (KERN_WARNING "512 byte HW ECC not possible on 256 Byte pagesize, fallback to SW ECC \n");
this->eccmode = NAND_ECC_SOFT;
this->calculate_ecc = nand_calculate_ecc;
this->correct_data = nand_correct_data;
} else
this->eccsize = 512; /* set eccsize to 512 */
break;
case NAND_ECC_HW3_256:
break;
case NAND_ECC_NONE:
printk (KERN_WARNING "NAND_ECC_NONE selected by board driver. This is not recommended !!\n");
this->eccmode = NAND_ECC_NONE;
break;
case NAND_ECC_SOFT:
this->calculate_ecc = nand_calculate_ecc;
this->correct_data = nand_correct_data;
break;
default:
printk (KERN_WARNING "Invalid NAND_ECC_MODE %d\n", this->eccmode);
BUG();
}
/* Check hardware ecc function availability and adjust number of ecc bytes per
* calculation step
*/
switch (this->eccmode) {
case NAND_ECC_HW12_2048:
this->eccbytes += 4;
case NAND_ECC_HW8_512:
this->eccbytes += 2;
case NAND_ECC_HW6_512:
this->eccbytes += 3;
case NAND_ECC_HW3_512:
case NAND_ECC_HW3_256:
if (this->calculate_ecc && this->correct_data && this->enable_hwecc)
break;
printk (KERN_WARNING "No ECC functions supplied, Hardware ECC not possible\n");
BUG();
}
mtd->eccsize = this->eccsize;
/* Set the number of read / write steps for one page to ensure ECC generation */
switch (this->eccmode) {
case NAND_ECC_HW12_2048:
this->eccsteps = mtd->oobblock / 2048;
break;
case NAND_ECC_HW3_512:
case NAND_ECC_HW6_512:
case NAND_ECC_HW8_512:
this->eccsteps = mtd->oobblock / 512;
break;
case NAND_ECC_HW3_256:
case NAND_ECC_SOFT:
this->eccsteps = mtd->oobblock / 256;
break;
case NAND_ECC_NONE:
this->eccsteps = 1;
break;
}
/* Initialize state, waitqueue and spinlock */
this->state = FL_READY;
init_waitqueue_head (&this->wq);
spin_lock_init (&this->chip_lock);
/* De-select the device */
this->select_chip(mtd, -1);
/* Invalidate the pagebuffer reference */
this->pagebuf = -1;
/* Fill in remaining MTD driver data */
//填充mtd結構的其它部分
mtd->type = MTD_NANDFLASH;
mtd->flags = MTD_CAP_NANDFLASH | MTD_ECC;
mtd->ecctype = MTD_ECC_SW;
mtd->erase = nand_erase;
mtd->point = NULL;
mtd->unpoint = NULL;
mtd->read = nand_read;
/* nand_read->nand_do_read_ecc->read_buf->s3c2410_nand_read_buf */
mtd->write = nand_write;
/* nand_write->nand_write_ecc->nand_write_page->write_buf->s3c2410_nand_write_buf */
mtd->read_ecc = nand_read_ecc;
mtd->write_ecc = nand_write_ecc;
mtd->read_oob = nand_read_oob;
mtd->write_oob = nand_write_oob;
mtd->readv = NULL;
mtd->writev = nand_writev;
mtd->writev_ecc = nand_writev_ecc;
mtd->sync = nand_sync;
mtd->lock = NULL;
mtd->unlock = NULL;
mtd->suspend = NULL;
mtd->resume = NULL;
mtd->block_isbad = nand_block_isbad;
mtd->block_markbad = nand_block_markbad;
/* and make the autooob the default one */
memcpy(&mtd->oobinfo, this->autooob, sizeof(mtd->oobinfo));
mtd->owner = THIS_MODULE;
/* Check, if we should skip the bad block table scan */
if (this->options & NAND_SKIP_BBTSCAN)
return 0;
/* Build bad block table */
return this->scan_bbt (mtd);
}
/**
* nand_command - [DEFAULT] Send command to NAND device
* @mtd: MTD device structure
* @command: the command to be sent
* @column: the column address for this command, -1 if none
* @page_addr: the page address for this command, -1 if none
*
* Send command to NAND device. This function is used for small page
* devices (256/512 Bytes per page)
*/
static void nand_command (struct mtd_info *mtd, unsigned command, int column, int page_addr)
{
register struct nand_chip *this = mtd->priv;
/* Begin command latch cycle */
this->hwcontrol(mtd, NAND_CTL_SETCLE); //選擇寫入S3C2410_NFCMD寄存器
/*
* Write out the command to the device.
*/
if (command == NAND_CMD_SEQIN) {
int readcmd;
if (column >= mtd->oobblock) { //讀/寫位置超出512，讀oob_data
/* OOB area */
column -= mtd->oobblock;
readcmd = NAND_CMD_READOOB;
} else if (column < 256) { //讀/寫位置在前512，使用read0命令
/* First 256 bytes --> READ0 */
readcmd = NAND_CMD_READ0;
} else { //讀/寫位置在後512，使用read1命令
column -= 256;
readcmd = NAND_CMD_READ1;
}
this->write_byte(mtd, readcmd); //寫入具體命令
}
this->write_byte(mtd, command);
/* Set ALE and clear CLE to start address cycle */
/* 清楚CLE，鎖存命令；置位ALE，開始傳輸地址 */
this->hwcontrol(mtd, NAND_CTL_CLRCLE); //鎖存命令
if (column != -1 || page_addr != -1) {
this->hwcontrol(mtd, NAND_CTL_SETALE); //選擇寫入S3C2410_NFADDR寄存器
/* Serially input address */
if (column != -1) {
/* Adjust columns for 16 bit buswidth */
if (this->options & NAND_BUSWIDTH_16)
column >>= 1;
this->write_byte(mtd, column); //寫入列地址
}
if (page_addr != -1) { //寫入頁地址(分三個字節寫入)
this->write_byte(mtd, (unsigned char) (page_addr & 0xff));
this->write_byte(mtd, (unsigned char) ((page_addr >> 8) & 0xff));
/* One more address cycle for devices > 32MiB */
if (this->chipsize > (32 << 20))
this->write_byte(mtd, (unsigned char) ((page_addr >> 16) & 0x0f));
}
/* Latch in address */
/* 鎖存地址 */
this->hwcontrol(mtd, NAND_CTL_CLRALE);
}
/*
* program and erase have their own busy handlers
* status and sequential in needs no delay
*/
switch (command) {
case NAND_CMD_PAGEPROG:
case NAND_CMD_ERASE1:
case NAND_CMD_ERASE2:
case NAND_CMD_SEQIN:
case NAND_CMD_STATUS:
return;
case NAND_CMD_RESET: //復位操作
// 等待nand flash become ready
if (this->dev_ready) //判斷nand flash 是否busy(1:ready 0:busy)
break;
udelay(this->chip_delay);
this->hwcontrol(mtd, NAND_CTL_SETCLE);
this->write_byte(mtd, NAND_CMD_STATUS);
this->hwcontrol(mtd, NAND_CTL_CLRCLE);
while ( !(this->read_byte(mtd) & NAND_STATUS_READY));
return;
/* This applies to read commands */
default:
/*
* If we don't have access to the busy pin, we apply the given
* command delay
*/
if (!this->dev_ready) {
udelay (this->chip_delay);//稍作延遲
return;
}
}
/* Apply this short delay always to ensure that we do wait tWB in
* any case on any machine. */
ndelay (100);
nand_wait_ready(mtd);
}
/*
* Wait for the ready pin, after a command
* The timeout is catched later.
*/
static void nand_wait_ready(struct mtd_info *mtd)
{
struct nand_chip *this = mtd->priv;
unsigned long timeo = jiffies + 2;
/* wait until command is processed or timeout occures */
do {
if (this->dev_ready(mtd)) //簡單調用this->dev_ready(s3c2410_nand_devready)函數 等待nand flash become ready
return;
touch_softlockup_watchdog();
} while (time_before(jiffies, timeo));
}
/**
* nand_wait - [DEFAULT] wait until the command is done
* @mtd: MTD device structure
* @this: NAND chip structure
* @state: state to select the max. timeout value
*
* Wait for command done. This applies to erase and program only
* Erase can take up to 400ms and program up to 20ms according to
* general NAND and SmartMedia specs
*
*/
/* 等待知道命令傳輸完成，適用於檫除和寫入命令 */
static int nand_wait(struct mtd_info *mtd, struct nand_chip *this, int state)
{
unsigned long timeo = jiffies;
int status;
if (state == FL_ERASING)
timeo += (HZ * 400) / 1000;//檫除操作的話，時間相對要長一些
else
timeo += (HZ * 20) / 1000;
/* Apply this short delay always to ensure that we do wait tWB in
* any case on any machine. */
ndelay (100);
if ((state == FL_ERASING) && (this->options & NAND_IS_AND))
this->cmdfunc (mtd, NAND_CMD_STATUS_MULTI, -1, -1);
else
this->cmdfunc (mtd, NAND_CMD_STATUS, -1, -1);
while (time_before(jiffies, timeo)) {
/* Check, if we were interrupted */
if (this->state != state)
return 0;
/* 等待nand flash become ready */
if (this->dev_ready) {
if (this->dev_ready(mtd))
break;
} else {
if (this->read_byte(mtd) & NAND_STATUS_READY)
break;
}
cond_resched();
}
status = (int) this->read_byte(mtd);
return status;
}
/**
* nand_block_bad - [DEFAULT] Read bad block marker from the chip
* 檢查nand flash中某一頁是否爲壞塊
* @mtd: MTD device structure
* @ofs: offset from device start
* @getchip: 0, if the chip is already selected
*
* Check, if the block is bad.
*/
static int nand_block_bad(struct mtd_info *mtd, loff_t ofs, int getchip)
{
int page, chipnr, res = 0;
struct nand_chip *this = mtd->priv;
u16 bad;
if (getchip) {
page = (int)(ofs >> this->page_shift);
chipnr = (int)(ofs >> this->chip_shift);
/* Grab the lock and see if the device is available */
nand_get_device (this, mtd, FL_READING);
/* Select the NAND device */
this->select_chip(mtd, chipnr);
} else
page = (int) ofs;
if (this->options & NAND_BUSWIDTH_16) {
this->cmdfunc (mtd, NAND_CMD_READOOB, this->badblockpos & 0xFE, page & this->pagemask);
bad = cpu_to_le16(this->read_word(mtd));
if (this->badblockpos & 0x1)
bad >>= 1;
if ((bad & 0xFF) != 0xff)
res = 1;
} else {
this->cmdfunc (mtd, NAND_CMD_READOOB, this->badblockpos, page & this->pagemask);
/* 發送讀oob_data命令(oob_data的badblockpos (第6)位記錄着壞塊標誌) */
if (this->read_byte(mtd) != 0xff)//壞塊
res = 1;
}
if (getchip) {
/* Deselect and wake up anyone waiting on the device */
nand_release_device(mtd);
}
return res;
}
/**
* nand_default_block_markbad - [DEFAULT] mark a block bad
* 標誌壞塊
* @mtd: MTD device structure
* @ofs: offset from device start
*
* This is the default implementation, which can be overridden by
* a hardware specific driver.
*/
static int nand_default_block_markbad(struct mtd_info *mtd, loff_t ofs)
{
struct nand_chip *this = mtd->priv;
u_char buf[2] = {0, 0};
size_t retlen;
int block;
/* Get block number */
block = ((int) ofs) >> this->bbt_erase_shift;
if (this->bbt)
this->bbt[block >> 2] |= 0x01 << ((block & 0x03) << 1);
/*
這個暫時不是很好說：內核維護一個標誌bad block表，使用2bit來表示1block。
這個表在開機的時候通過掃描nand flash每個block的頭兩頁的oob數據來生成，
發現壞塊後至相應的block標誌位爲非零(有時候至3，但有時候至1，還沒搞明白有什麼不同)
*/
/* Do we have a flash based bad block table ? */
if (this->options & NAND_USE_FLASH_BBT)//samsun nand flash不屬於這種，暫時不去研究，以後同
return nand_update_bbt (mtd, ofs);
/* We write two bytes, so we dont have to mess with 16 bit access */
ofs += mtd->oobsize + (this->badblockpos & ~0x01);//???????????????
return nand_write_oob (mtd, ofs , 2, &retlen, buf);
}
/**
* nand_verify_buf - [DEFAULT] Verify chip data against buffer
* 檢驗nand flash與buffer的數據是否一致
* @mtd: MTD device structure
* @buf: buffer containing the data to compare
* @len: number of bytes to compare
*
* Default verify function for 8bit buswith
*/
static int nand_verify_buf(struct mtd_info *mtd, const u_char *buf, int len)
{
int i;
struct nand_chip *this = mtd->priv;
for (i=0; i<len; i++)
if (buf[i] != readb(this->IO_ADDR_R))
return -EFAULT;
return 0;
}
/**
* nand_default_bbt - [NAND Interface] Select a default bad block table for the device
* @mtd: MTD device structure
*
* This function selects the default bad block table
* support for the device and calls the nand_scan_bbt function
*
*/
int nand_default_bbt (struct mtd_info *mtd)
{
struct nand_chip *this = mtd->priv;
/* Default for AG-AND. We must use a flash based
* bad block table as the devices have factory marked
* _good_ blocks. Erasing those blocks leads to loss
* of the good / bad information, so we _must_ store
* this information in a good / bad table during
* startup
*/
if (this->options & NAND_IS_AND) {
/* Use the default pattern descriptors */
if (!this->bbt_td) {
this->bbt_td = &bbt_main_descr;
this->bbt_md = &bbt_mirror_descr;
}
this->options |= NAND_USE_FLASH_BBT;
return nand_scan_bbt (mtd, &agand_flashbased);
}
/* Is a flash based bad block table requested ? */
if (this->options & NAND_USE_FLASH_BBT) {
/* Use the default pattern descriptors */
if (!this->bbt_td) {
this->bbt_td = &bbt_main_descr;
this->bbt_md = &bbt_mirror_descr;
}
if (!this->badblock_pattern) {
this->badblock_pattern = (mtd->oobblock > 512) ?
&largepage_flashbased : &smallpage_flashbased;
}
} else { //samsun nand flash的壞塊表不存在與nand flash裏面，需要掃描來生成。
this->bbt_td = NULL;
this->bbt_md = NULL;
if (!this->badblock_pattern) {
this->badblock_pattern = (mtd->oobblock > 512) ?
&largepage_memorybased : &smallpage_memorybased;
}
}
return nand_scan_bbt (mtd, this->badblock_pattern);
}
/**
* nand_scan_bbt - [NAND Interface] scan, find, read and maybe create bad block table(s)
* @mtd: MTD device structure
* @bd: descriptor for the good/bad block search pattern
*
* The function checks, if a bad block table(s) is/are already
* available. If not it scans the device for manufacturer
* marked good / bad blocks and writes the bad block table(s) to
* the selected place.
*
* The bad block table memory is allocated here. It must be freed
* by calling the nand_free_bbt function.
*
*/
int nand_scan_bbt (struct mtd_info *mtd, struct nand_bbt_descr *bd)
{
struct nand_chip *this = mtd->priv;
int len, res = 0;
uint8_t *buf;
struct nand_bbt_descr *td = this->bbt_td;
struct nand_bbt_descr *md = this->bbt_md;
len = mtd->size >> (this->bbt_erase_shift + 2);
/* Allocate memory (2bit per block) */
/* 2bit per block=(2/8)byte per block，所以上面要多右移2位 */
this->bbt = kmalloc (len, GFP_KERNEL);
if (!this->bbt) {
printk (KERN_ERR "nand_scan_bbt: Out of memory\n");
return -ENOMEM;
}
/* Clear the memory bad block table */
memset (this->bbt, 0x00, len);
/* If no primary table decriptor is given, scan the device
* to build a memory based bad block table
*/
if (!td) {
if ((res = nand_memory_bbt(mtd, bd))) {
printk (KERN_ERR "nand_bbt: Can't scan flash and build the RAM-based BBT\n");
kfree (this->bbt);
this->bbt = NULL;
}
return res;
}
/* Allocate a temporary buffer for one eraseblock incl. oob */
/* 分配1 block所需要的oob data空間 */
len = (1 << this->bbt_erase_shift);
len += (len >> this->page_shift) * mtd->oobsize;
buf = kmalloc (len, GFP_KERNEL);
if (!buf) {
printk (KERN_ERR "nand_bbt: Out of memory\n");
kfree (this->bbt);
this->bbt = NULL;
return -ENOMEM;
}
//由於td、md均爲NULL，一下函數基本不起作用，先不去研究它
/* Is the bbt at a given page ? */
if (td->options & NAND_BBT_ABSPAGE) {
res = read_abs_bbts (mtd, buf, td, md);
} else {
/* Search the bad block table using a pattern in oob */
res = search_read_bbts (mtd, buf, td, md);
}
if (res)
res = check_create (mtd, buf, bd);
/* Prevent the bbt regions from erasing / writing */
mark_bbt_region (mtd, td);
if (md)
mark_bbt_region (mtd, md);
kfree (buf);
return res;
}
/**
* nand_memory_bbt - [GENERIC] create a memory based bad block table
* @mtd: MTD device structure
* @bd: descriptor for the good/bad block search pattern
*
* The function creates a memory based bbt by scanning the device
* for manufacturer / software marked good / bad blocks
*/
static inline int nand_memory_bbt (struct mtd_info *mtd, struct nand_bbt_descr *bd)
{
struct nand_chip *this = mtd->priv;
bd->options &= ~NAND_BBT_SCANEMPTY;
//我們只需要掃描oob data，不需要掃描全部(512+16bytes的數據)
return create_bbt (mtd, this->data_buf, bd, -1);
}
/**
* create_bbt - [GENERIC] Create a bad block table by scanning the device
* @mtd: MTD device structure
* @buf: temporary buffer
* @bd: descriptor for the good/bad block search pattern
* @chip: create the table for a specific chip, -1 read all chips.
* Applies only if NAND_BBT_PERCHIP option is set
*
* Create a bad block table by scanning the device
* for the given good/bad block identify pattern
*/
static int create_bbt (struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr *bd, int chip)
{
struct nand_chip *this = mtd->priv;
int i, j, numblocks, len, scanlen;
int startblock;
loff_t from;
size_t readlen, ooblen;
printk (KERN_INFO "Scanning device for bad blocks\n");
if (bd->options & NAND_BBT_SCANALLPAGES)//掃描所有都頁
len = 1 << (this->bbt_erase_shift - this->page_shift);//求出每block所含的page數
else {
if (bd->options & NAND_BBT_SCAN2NDPAGE)//只檢查2 page
len = 2;
else
len = 1;//只檢查1 page
}
if (!(bd->options & NAND_BBT_SCANEMPTY)) {
/* We need only read few bytes from the OOB area */
/* 我們只需要檢查OOB的某些數據 */
scanlen = ooblen = 0;
readlen = bd->len;
} else {
/* Full page content should be read */
/* 讀取整頁內容 */
scanlen = mtd->oobblock + mtd->oobsize;
readlen = len * mtd->oobblock;
ooblen = len * mtd->oobsize;
}
if (chip == -1) {
/* Note that numblocks is 2 * (real numblocks) here, see i+=2 below as it
* makes shifting and masking less painful */
/* 計算出nand flash所包含都block數目(注意這裏總數目經過林乘2操作)*/
numblocks = mtd->size >> (this->bbt_erase_shift - 1);
startblock = 0;
from = 0;
} else {
if (chip >= this->numchips) {
printk (KERN_WARNING "create_bbt(): chipnr (%d) > available chips (%d)\n",
chip + 1, this->numchips);
return -EINVAL;
}
numblocks = this->chipsize >> (this->bbt_erase_shift - 1);
startblock = chip * numblocks;
numblocks += startblock;
from = startblock << (this->bbt_erase_shift - 1);
}
for (i = startblock; i < numblocks;) {
int ret;
if (bd->options & NAND_BBT_SCANEMPTY) //整頁數據讀取
if ((ret = nand_read_raw (mtd, buf, from, readlen, ooblen)))
return ret;
for (j = 0; j < len; j++) {
if (!(bd->options & NAND_BBT_SCANEMPTY)) {
size_t retlen;
/* Read the full oob until read_oob is fixed to
* handle single byte reads for 16 bit buswidth */
/* 讀取當前頁的oob區的所有數據 */
ret = mtd->read_oob(mtd, from + j * mtd->oobblock,
mtd->oobsize, &retlen, buf);
if (ret)
return ret;
/* 檢查oob data的bad block標誌位，判斷是否是壞塊 */
if (check_short_pattern (buf, bd)) {
this->bbt[i >> 3] |= 0x03 << (i & 0x6);
/* 注意：這裏i=實際值*2。由於一個block的狀態用2bit來表示，那麼一個字節可以存放4個block的狀態。
這裏i>>3剛好是實際block/4，4個block的狀態剛好存放在this->bbt所指向的一個字節裏面
*/
printk (KERN_WARNING "Bad eraseblock %d at 0x%08x\n",
i >> 1, (unsigned int) from);
break;
}
} else {
if (check_pattern (&buf[j * scanlen], scanlen, mtd->oobblock, bd)) {
this->bbt[i >> 3] |= 0x03 << (i & 0x6);
printk (KERN_WARNING "Bad eraseblock %d at 0x%08x\n",
i >> 1, (unsigned int) from);
break;
}
}
}
i += 2;//更新block的序號
from += (1 << this->bbt_erase_shift);//更新nand flash的地址
}
return 0;
}
/**
* nand_release - [NAND Interface] Free resources held by the NAND device
* @mtd: MTD device structure
*/
void nand_release (struct mtd_info *mtd)
{
struct nand_chip *this = mtd->priv;
#ifdef CONFIG_MTD_PARTITIONS
/* Deregister partitions */
del_mtd_partitions (mtd);
#endif
/* Deregister the device */
del_mtd_device (mtd);
/* Free bad block table memory, if allocated */
if (this->bbt)
kfree (this->bbt);
/* Buffer allocated by nand_scan ? */
if (this->options & NAND_OOBBUF_ALLOC)
kfree (this->oob_buf);
/* Buffer allocated by nand_scan ? */
if (this->options & NAND_DATABUF_ALLOC)
kfree (this->data_buf);
}
附錄：
/arch/arm/mach-s3c2410/dev.c文件：
static struct mtd_partition partition_info[]={
[0]={
name :"vivi",
size :0x20000,
offset :0,
},[1]={
name :"param",
size :0x10000,
offset :0x20000,
},[2]={
name :"kernel",
size :0x1d0000,
offset :0x30000,
},[3]={
name :"root",
size :0x3c00000,
offset :0x200000,
}
};
struct s3c2410_nand_set nandset={
nr_partitions :4,
partitions :partition_info,
};
struct s3c2410_platform_nand superlpplatform={
tacls :0,
twrph0 :30,
twrph1 :0,
sets :&nandset,
nr_sets :1,
};
struct platform_device s3c_device_nand = {
.name = "s3c2410-nand",
.id = -1,
.num_resources = ARRAY_SIZE(s3c_nand_resource),
.resource = s3c_nand_resource,
.dev={
.platform_data=&superlpplatform
}
};
nand_flash_ids表
/driver/mtd/nand/nand_ids.c文件：
struct nand_flash_dev nand_flash_ids[] = {
................................................................................
{"NAND 64MiB 3,3V 8-bit", 0x76, 512, 64, 0x4000, 0},
................................................................................
};
注：
這裏只列出常用的samsun 64M Nand Flash的資料，對應的信息請看該結構體的定義：
struct nand_flash_dev {
char *name;
int id;
unsigned long pagesize;
unsigned long chipsize;
unsigned long erasesize;
unsigned long options;
};
可知該nand flash 設備ID號爲0x76，頁大小爲512，大小爲64(M)，檫除單元大小爲16(K)。
首先分析一下如何通過MTD原始設備進而通過FLASH硬件驅動來讀取FLASH存儲器的數據。
引用自<<Linux系統移植>>一文：
"讀Nand Flash：
當對nand flash的設備文件(nand flash在/dev下對應的文件)執行系統調用read(),或在某個文件系統中對該
設備進行讀操作時. 會調用struct mtd_info中的read方法,他們缺省調用函數爲nand_read(),在
drivers/mtd/nand/nand_base.c中定義.nand_read()調用nand_do_read_ecc(),執行讀操作. 在
nand_do_read_ecc()函數中,主要完成如下幾項工作：
1. 會調用在nand flash驅動中對struct nand_chip重載的select_chip方法,即
s3c2410_nand_select_chip()選擇要操作的MTD芯片.
2. 會調用在struct nand_chip中系統缺省的方法cmdfunc發送讀命令到nand flash.
3. 會調用在nand flash驅動中對struct nand_chip重載的read_buf(),即s3c2410_nand_read_buf()
從Nand Flash的控制器的數據寄存器中讀出數據.
4. 如果有必要的話,會調用在nand flash驅動中對struct nand_chip重載的
enable_hwecc,correct_data以及calculate_ecc方法,進行數據ECC校驗。"
下面研究一下其中的細節：
/**
* nand_read - [MTD Interface] MTD compability function for nand_do_read_ecc
* @mtd: MTD device structure
* @from: offset to read from
* @len: number of bytes to read
* @retlen: pointer to variable to store the number of read bytes
* @buf: the databuffer to put data
*
* This function simply calls nand_do_read_ecc with oob buffer and oobsel = NULL
* and flags = 0xff
*/
static int nand_read (struct mtd_info *mtd, loff_t from, size_t len, size_t * retlen, u_char * buf)
{
return nand_do_read_ecc (mtd, from, len, retlen, buf, NULL, &mtd->oobinfo, 0xff);
}
注：
以參數oob_buf爲NULL，flags爲0xff調用nand_do_read_ecc函數。
/**
* nand_do_read_ecc - [MTD Interface] Read data with ECC
* @mtd: MTD device structure
* @from: offset to read from
* @len: number of bytes to read
* @retlen: pointer to variable to store the number of read bytes
* @buf: the databuffer to put data
* @oob_buf: filesystem supplied oob data buffer (can be NULL)
* @oobsel: oob selection structure
* @flags: flag to indicate if nand_get_device/nand_release_device should be preformed
* and how many corrected error bits are acceptable:
* bits 0..7 - number of tolerable errors
* bit 8 - 0 == do not get/release chip, 1 == get/release chip
*
* NAND read with ECC
*/
int nand_do_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
size_t * retlen, u_char * buf, u_char * oob_buf,
struct nand_oobinfo *oobsel, int flags)
{
int i, j, col, realpage, page, end, ecc, chipnr, sndcmd = 1;
int read = 0, oob = 0, ecc_status = 0, ecc_failed = 0;
struct nand_chip *this = mtd->priv;
u_char *data_poi, *oob_data = oob_buf;//目前oob_data指針爲空，以後會去修改它。
u_char ecc_calc[32];//該數組用於存放計算出來的ecc結果
u_char ecc_code[32];//該數組用於存放oob中ecc部分的數據
int eccmode, eccsteps;//eccmode存放ecc的類型(ECC_SOFT)；
eccsteps用於記錄一個page所需的ecc校驗次數(2)。
int *oob_config, datidx;
int blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1;
int eccbytes;
int compareecc = 1;//是否需要ecc標誌(如果設置成ECC_NONE，這個標誌將被清0)
int oobreadlen;
DEBUG (MTD_DEBUG_LEVEL3, "nand_read_ecc: from = 0x%08x, len = %i\n", (unsigned int) from, (int) len);
/* Do not allow reads past end of device */
/* 不允許超越設備容量的讀操作 */
if ((from + len) > mtd->size) {
DEBUG (MTD_DEBUG_LEVEL0, "nand_read_ecc: Attempt read beyond end of device\n");
*retlen = 0;
return -EINVAL;
}
/* Grab the lock and see if the device is available */
/* 獲取自旋鎖，等待設備可用並獲取其控制權 */
if (flags & NAND_GET_DEVICE)
nand_get_device (this, mtd, FL_READING);
/* Autoplace of oob data ? Use the default placement scheme */
if (oobsel->useecc == MTD_NANDECC_AUTOPLACE)
oobsel = this->autooob;
/*
* 感覺這一步有點多餘，因爲nand_scan中已經調用了以下代碼：
* memcpy(&mtd->oobinfo, this->autooob, sizeof(mtd->oobinfo));
* 把this->autooob的內容拷貝到mtd->oobinfo中了
*/
eccmode = oobsel->useecc ? this->eccmode : NAND_ECC_NONE;
oob_config = oobsel->eccpos;//記錄ecc在oob數據中的位置
/* Select the NAND device */
chipnr = (int)(from >> this->chip_shift);
this->select_chip(mtd, chipnr);//選擇nand flash芯片(在s3c2410 nand flash控制器中爲空操作)
/* First we calculate the starting page */
/* 首先，我們計算出開始頁碼 */
realpage = (int) (from >> this->page_shift);
page = realpage & this->pagemask;
/* Get raw starting column */
/* 其次，我們計算頁內偏址 */
col = from & (mtd->oobblock - 1);
end = mtd->oobblock;//頁大小(512)
ecc = this->eccsize;//ecc保護下的數據大小(256)
eccbytes = this->eccbytes;//ecc所佔的字節數(3)
if ((eccmode == NAND_ECC_NONE) || (this->options & NAND_HWECC_SYNDROME))
compareecc = 0;//如果設置爲關閉ECC或寫操作才需要ECC，那把ecc給禁用(現在可是讀操作^_^)
oobreadlen = mtd->oobsize;//16
if (this->options & NAND_HWECC_SYNDROME)
oobreadlen -= oobsel->eccbytes;
/* Loop until all data read */
while (read < len) {
int aligned = (!col && (len - read) >= end);
/*
* If the read is not page aligned, we have to read into data buffer
* due to ecc, else we read into return buffer direct
* 如果要讀的位置不是頁對齊都話，那麼只要先把整頁讀出來，
* 取出所需要讀取的數據，然後修改讀位置，那麼以後的讀操作都是頁對齊的了。
*/
if (aligned)
data_poi = &buf[read];
else
data_poi = this->data_buf;
/* Check, if we have this page in the buffer
*
* FIXME: Make it work when we must provide oob data too,
* check the usage of data_buf oob field
* 如果我們所需要的數據還存在於緩衝中都話：
* 1 如果讀位置頁對齊，我們只要把緩衝中的數據直接拷貝到data_poi(buf[read])中即可(因爲數據存在與緩存中，所以也無需要考慮ecc問題)
* 2 如果讀位置不是頁對齊，什麼讀不要作，讓其繼續留在緩存(data_buf)中，以後會從data_poi(指向緩存data_buf)中提取所需要的數據。
*/
if (realpage == this->pagebuf && !oob_buf) {
/* aligned read ? */
if (aligned)
memcpy (data_poi, this->data_buf, end);
goto readdata;
}
/* Check, if we must send the read command */
/* 發送讀命令，頁地址爲page，列地址爲0x00 */
if (sndcmd) {
this->cmdfunc (mtd, NAND_CMD_READ0, 0x00, page);
sndcmd = 0;
}
/* get oob area, if we have no oob buffer from fs-driver */
if (!oob_buf || oobsel->useecc == MTD_NANDECC_AUTOPLACE ||
oobsel->useecc == MTD_NANDECC_AUTOPL_USR)
oob_data = &this->data_buf[end];//以上情況，oob_data暫存在data_buf緩存中
eccsteps = this->eccsteps;//2
switch (eccmode) {
case NAND_ECC_NONE: { /* No ECC, Read in a page */
static unsigned long lastwhinge = 0;
if ((lastwhinge / HZ) != (jiffies / HZ)) {
printk (KERN_WARNING "Reading data from NAND FLASH without ECC is not recommended\n");
lastwhinge = jiffies;
}
this->read_buf(mtd, data_poi, end);
break;
}
case NAND_ECC_SOFT: /* Software ECC 3/256: Read in a page + oob data */
this->read_buf(mtd, data_poi, end);//讀取數據到data_poi
for (i = 0, datidx = 0; eccsteps; eccsteps--, i+=3, datidx += ecc)
this->calculate_ecc(mtd, &data_poi[datidx], &ecc_calc[i]);
/* 計算出讀取到data_poi的數據的ecc值，並存放到ecc_calc數組中。
* 因爲讀都數據有一頁大小(512)，需要分別對其上半部和下半部分計算一次ecc值，並分開存放到ecc_calc數組相應都位置中。
*/
break;
default:
for (i = 0, datidx = 0; eccsteps; eccsteps--, i+=eccbytes, datidx += ecc) {
this->enable_hwecc(mtd, NAND_ECC_READ);
this->read_buf(mtd, &data_poi[datidx], ecc);
/* HW ecc with syndrome calculation must read the
* syndrome from flash immidiately after the data */
if (!compareecc) {
/* Some hw ecc generators need to know when the
* syndrome is read from flash */
this->enable_hwecc(mtd, NAND_ECC_READSYN);
this->read_buf(mtd, &oob_data[i], eccbytes);
/* We calc error correction directly, it checks the hw
* generator for an error, reads back the syndrome and
* does the error correction on the fly */
ecc_status = this->correct_data(mtd, &data_poi[datidx], &oob_data[i], &ecc_code[i]);
if ((ecc_status == -1) || (ecc_status > (flags && 0xff))) {
DEBUG (MTD_DEBUG_LEVEL0, "nand_read_ecc: "
"Failed ECC read, page 0x%08x on chip %d\n", page, chipnr);
ecc_failed++;
}
} else {
this->calculate_ecc(mtd, &data_poi[datidx], &ecc_calc[i]);
}
}
break;
}
/* read oobdata */
this->read_buf(mtd, &oob_data[mtd->oobsize - oobreadlen], oobreadlen);
//讀取oob_data存放到oob_data[mtd->oobsize - oobreadlen]，在這裏是data_buf[end]中
/* Skip ECC check, if not requested (ECC_NONE or HW_ECC with syndromes) */
/* 跳過ecc檢測 */
if (!compareecc)
goto readoob;
/* Pick the ECC bytes out of the oob data */
/* 從剛讀出來都oob_data中取出ecc數據(在這裏是前三個字節) */
for (j = 0; j < oobsel->eccbytes; j++)
ecc_code[j] = oob_data[oob_config[j]];
/* correct data, if neccecary */
for (i = 0, j = 0, datidx = 0; i < this->eccsteps; i++, datidx += ecc) {
ecc_status = this->correct_data(mtd, &data_poi[datidx], &ecc_code[j], &ecc_calc[j]);
/* 拿前面計算出來都ecc_cal數組都數據與讀出來的ecc數據作比較，並嘗試修正錯誤(但不保證能修復，具體看返回值) */
/* Get next chunk of ecc bytes */
j += eccbytes;
/* Check, if we have a fs supplied oob-buffer,
* This is the legacy mode. Used by YAFFS1
* Should go away some day
*/
if (oob_buf && oobsel->useecc == MTD_NANDECC_PLACE) {
int *p = (int *)(&oob_data[mtd->oobsize]);
p[i] = ecc_status;
}
/* 很不幸，ecc檢測發現錯誤且未能修復，報告錯誤 */
if ((ecc_status == -1) || (ecc_status > (flags && 0xff))) {
DEBUG (MTD_DEBUG_LEVEL0, "nand_read_ecc: " "Failed ECC read, page 0x%08x\n", page);
ecc_failed++;
}
}
readoob:
/* check, if we have a fs supplied oob-buffer */
if (oob_buf) {
/* without autoplace. Legacy mode used by YAFFS1 */
switch(oobsel->useecc) {
case MTD_NANDECC_AUTOPLACE:
case MTD_NANDECC_AUTOPL_USR:
/* Walk through the autoplace chunks */
for (i = 0; oobsel->oobfree[i][1]; i++) {
int from = oobsel->oobfree[i][0];
int num = oobsel->oobfree[i][1];
memcpy(&oob_buf[oob], &oob_data[from], num);
oob += num;
}
break;
case MTD_NANDECC_PLACE:
/* YAFFS1 legacy mode */
oob_data += this->eccsteps * sizeof (int);
default:
oob_data += mtd->oobsize;
}
}
readdata:
/* Partial page read, transfer data into fs buffer
* 讀位置不是頁對齊，從data_poi(data_buf中)提取所需要都數據
*/
if (!aligned) {
for (j = col; j < end && read < len; j++)
buf[read++] = data_poi[j];//read自增
this->pagebuf = realpage;
} else
read += mtd->oobblock;//整頁讀取，計數值加上整頁的數目(512)
/* Apply delay or wait for ready/busy pin
* Do this before the AUTOINCR check, so no problems
* arise if a chip which does auto increment
* is marked as NOAUTOINCR by the board driver.
*/
if (!this->dev_ready)
udelay (this->chip_delay);
else
nand_wait_ready(mtd);
if (read == len)//所需數據讀完都情況，退出讀循環。
break;
/* For subsequent reads align to page boundary. */
col = 0;//對於讀位置不是頁對齊都情況，前面已對其進行林相應都處理，現在讀位置變得頁對齊了。
/* Increment page address */
realpage++;//頁地址加1,讀取下一頁。
page = realpage & this->pagemask;
/* Check, if we cross a chip boundary */
if (!page) {
chipnr++;
this->select_chip(mtd, -1);
this->select_chip(mtd, chipnr);
}
/* Check, if the chip supports auto page increment
* or if we have hit a block boundary.
* 如果芯片支持頁自增操作,且未到block boundary(15)的話，不用再發送讀命令
*/
if (!NAND_CANAUTOINCR(this) || !(page & blockcheck))
sndcmd = 1;
}
/* Deselect and wake up anyone waiting on the device */
if (flags & NAND_GET_DEVICE)
nand_release_device(mtd);//放棄對設備都控制權，好讓其它進程獲取並佔有它
/*
* Return success, if no ECC failures, else -EBADMSG
* fs driver will take care of that, because
* retlen == desired len and result == -EBADMSG
*/
*retlen = read;
return ecc_failed ? -EBADMSG : 0;
}
好的，接着研究一下如何通過MTD原始設備進而通過FLASH硬件驅動向FLASH存儲器寫數據。
引用自<<Linux系統移植>>一文：
寫Nand Flash
當對nand flash的設備文件(nand flash在/dev下對應的文件)執行系統調用write(),或在某個文件系統中對該設備
進行讀操作時, 會調用struct mtd_info中write方法,他們缺省調用函數爲nand_write(),這兩個函數在
drivers/mtd/nand/nand_base.c中定義. nand_write()調用nand_write_ecc(),執行寫操作.在
nand_do_write_ecc()函數中,主要完成如下幾項工作：
1. 會調用在nand flash驅動中對struct nand_chip重載的select_chip方法,即
s3c2410_nand_select_chip()選擇要操作的MTD芯片.
2. 調用nand_write_page()寫一個頁.
3. 在nand_write_page()中,會調用在struct nand_chip中系統缺省的方法cmdfunc發送寫命令
到nand flash.
4. 在nand_write_page()中,會調用在nand flash驅動中對struct nand_chip重載的
write_buf(),即s3c2410_nand_write_buf()從Nand Flash的控制器的數據寄存器中寫入數據.
5. 在nand_write_page()中,會調用在nand flash驅動中對struct nand_chip重載waitfunc方法,
該方法調用系統缺省函數nand_wait(),該方法獲取操作狀態,並等待nand flash操作完成.等
待操作完成,是調用nand flash驅動中對struct nand_chip中重載的dev_ready方法,即
s3c2410_nand_devready()函數.
下面研究一下其中的細節：
/**
* nand_write - [MTD Interface] compability function for nand_write_ecc
* @mtd: MTD device structure
* @to: offset to write to
* @len: number of bytes to write
* @retlen: pointer to variable to store the number of written bytes
* @buf: the data to write
*
* This function simply calls nand_write_ecc with oob buffer and oobsel = NULL
*
*/
static int nand_write (struct mtd_info *mtd, loff_t to, size_t len, size_t * retlen, const u_char * buf)
{
return (nand_write_ecc (mtd, to, len, retlen, buf, NULL, NULL));
}
注：
以參數eccbuf、oobsel爲NULL，調用nand_write_ecc函數。
/**
* nand_write_ecc - [MTD Interface] NAND write with ECC
* @mtd: MTD device structure
* @to: offset to write to
* @len: number of bytes to write
* @retlen: pointer to variable to store the number of written bytes
* @buf: the data to write
* @eccbuf: filesystem supplied oob data buffer
* @oobsel: oob selection structure
*
* NAND write with ECC
*/
static int nand_write_ecc (struct mtd_info *mtd, loff_t to, size_t len,
size_t * retlen, const u_char * buf, u_char * eccbuf, struct nand_oobinfo *oobsel)
{
int startpage, page, ret = -EIO, oob = 0, written = 0, chipnr;
int autoplace = 0, numpages, totalpages;
struct nand_chip *this = mtd->priv;
u_char *oobbuf, *bufstart;
int ppblock = (1 << (this->phys_erase_shift - this->page_shift));//page/block
DEBUG (MTD_DEBUG_LEVEL3, "nand_write_ecc: to = 0x%08x, len = %i\n", (unsigned int) to, (int) len);
/* Initialize retlen, in case of early exit */
*retlen = 0;
/* Do not allow write past end of device */
/* 超越nand flash容量的寫操作是不允許的 */
if ((to + len) > mtd->size) {
DEBUG (MTD_DEBUG_LEVEL0, "nand_write_ecc: Attempt to write past end of page\n");
return -EINVAL;
}
/* reject writes, which are not page aligned */
/* 不按頁對齊的寫操作同樣是不允許的 */
if (NOTALIGNED (to) || NOTALIGNED(len)) {
printk (KERN_NOTICE "nand_write_ecc: Attempt to write not page aligned data\n");
return -EINVAL;
}
/* Grab the lock and see if the device is available */
/* 獲取設備的控制權 */
nand_get_device (this, mtd, FL_WRITING);
/* Calculate chipnr */
/*
* 存在多片flash的情況下，計算出所要寫的是哪片flash？
* (當然，像我的板，只用一片nand flash，所以這個操作是不必要的)
*/
chipnr = (int)(to >> this->chip_shift);
/* Select the NAND device */
/* 片選操作 */
this->select_chip(mtd, chipnr);
/* Check, if it is write protected */
/* 如果nand flash寫保護，當然不能再寫了 */
if (nand_check_wp(mtd))
goto out;
/* if oobsel is NULL, use chip defaults */
if (oobsel == NULL)
oobsel = &mtd->oobinfo;
/* Autoplace of oob data ? Use the default placement scheme */
if (oobsel->useecc == MTD_NANDECC_AUTOPLACE) {
oobsel = this->autooob;
autoplace = 1;
}
if (oobsel->useecc == MTD_NANDECC_AUTOPL_USR)
autoplace = 1;
/* Setup variables and oob buffer */
totalpages = len >> this->page_shift;//計算所要讀取的數據長度共有多少頁
page = (int) (to >> this->page_shift);//計算數據所要寫到的開始頁碼
/* Invalidate the page cache, if we write to the cached page */
/* 如果緩存保存的數據在我們要寫數據的範圍內，把緩存裏的數據設置爲不可用???? */
if (page <= this->pagebuf && this->pagebuf < (page + totalpages))
this->pagebuf = -1;
/* Set it relative to chip */
page &= this->pagemask;
startpage = page;
/* Calc number of pages we can write in one go */
numpages = min (ppblock - (startpage & (ppblock - 1)), totalpages);//計算出本block中允許被寫的頁數
oobbuf = nand_prepare_oobbuf (mtd, eccbuf, oobsel, autoplace, numpages);//先不深入研究~_~
bufstart = (u_char *)buf;//獲取所要寫數據的地址
/* Loop until all data is written */
/* 循環進行寫操作 */
while (written < len) {
this->data_poi = (u_char*) &buf[written];//先把所要寫的數據緩衝到data_poi下
/* Write one page. If this is the last page to write
* or the last page in this block, then use the
* real pageprogram command, else select cached programming
* if supported by the chip.
* 如果這是所寫數據的最後一個頁或許這是所寫block的最後一個頁，調用nand flash的
* pageprogram指令，真正把數據寫入nand flash中(nand flash的最小擦除單元爲block)
*/
ret = nand_write_page (mtd, this, page, &oobbuf[oob], oobsel, (--numpages > 0));
if (ret) {
DEBUG (MTD_DEBUG_LEVEL0, "nand_write_ecc: write_page failed %d\n", ret);
goto out;
}
/* Next oob page */
oob += mtd->oobsize;
/* Update written bytes count */
/* 更新寫入計數值 */
written += mtd->oobblock;
if (written == len)//寫入完畢，退出
goto cmp;
/* Increment page address */
page++;//下一頁
/* Have we hit a block boundary ? Then we have to verify and
* if verify is ok, we have to setup the oob buffer for
* the next pages.
* 暫時不是很明白，需要先搞明白nand_prepare_oobbuf函數的作用
*/
if (!(page & (ppblock - 1))){
int ofs;
this->data_poi = bufstart;//懷疑nand_verify_pages用到
ret = nand_verify_pages (mtd, this, startpage,
page - startpage,
oobbuf, oobsel, chipnr, (eccbuf != NULL));//一頁寫完，檢查數據
if (ret) {
DEBUG (MTD_DEBUG_LEVEL0, "nand_write_ecc: verify_pages failed %d\n", ret);
goto out;
}
*retlen = written;
ofs = autoplace ? mtd->oobavail : mtd->oobsize;
if (eccbuf)
eccbuf += (page - startpage) * ofs;
totalpages -= page - startpage;//更新需要寫的頁數
numpages = min (totalpages, ppblock);//更新可以寫的頁數
page &= this->pagemask;//更新頁碼
startpage = page;//更新開始頁碼
oobbuf = nand_prepare_oobbuf (mtd, eccbuf, oobsel,
autoplace, numpages);
/* Check, if we cross a chip boundary */
if (!page) {
chipnr++;
this->select_chip(mtd, -1);
this->select_chip(mtd, chipnr);
}
}
}
/* Verify the remaining pages */
cmp:
this->data_poi = bufstart;//懷疑nand_verify_pages用到
ret = nand_verify_pages (mtd, this, startpage, totalpages,
oobbuf, oobsel, chipnr, (eccbuf != NULL));
if (!ret)
*retlen = written;
else
DEBUG (MTD_DEBUG_LEVEL0, "nand_write_ecc: verify_pages failed %d\n", ret);
out:
/* Deselect and wake up anyone waiting on the device */
nand_release_device(mtd);//放棄對設備的控制權
return ret;
}
/**
* nand_write_page - [GENERIC] write one page
* @mtd: MTD device structure
* @this: NAND chip structure
* @page: startpage inside the chip, must be called with (page & this->pagemask)
* @oob_buf: out of band data buffer
* @oobsel: out of band selecttion structre
* @cached: 1 = enable cached programming if supported by chip
*
* Nand_page_program function is used for write and writev !
* This function will always program a full page of data
* If you call it with a non page aligned buffer, you're lost :)
*
* Cached programming is not supported yet.
*/
static int nand_write_page (struct mtd_info *mtd, struct nand_chip *this, int page,
u_char *oob_buf, struct nand_oobinfo *oobsel, int cached)
{
int i, status;
u_char ecc_code[32];
int eccmode = oobsel->useecc ? this->eccmode : NAND_ECC_NONE;
int *oob_config = oobsel->eccpos;
int datidx = 0, eccidx = 0, eccsteps = this->eccsteps;
int eccbytes = 0;
/* FIXME: Enable cached programming */
cached = 0;//在高版本的內核下找到這樣的解釋：
/*
* Cached progamming disabled for now, Not sure if its worth the
* trouble. The speed gain is not very impressive. (2.3->2.6Mib/s)
*/
/* Send command to begin auto page programming */
/* 發送頁編程指令 */
this->cmdfunc (mtd, NAND_CMD_SEQIN, 0x00, page);
/* Write out complete page of data, take care of eccmode */
switch (eccmode) {
/* No ecc, write all */
case NAND_ECC_NONE:
printk (KERN_WARNING "Writing data without ECC to NAND-FLASH is not recommended\n");
this->write_buf(mtd, this->data_poi, mtd->oobblock);
break;
/* Software ecc 3/256, write all */
case NAND_ECC_SOFT:
for (; eccsteps; eccsteps--) {
this->calculate_ecc(mtd, &this->data_poi[datidx], ecc_code);//計算出一頁的ecc數據
for (i = 0; i < 3; i++, eccidx++)
oob_buf[oob_config[eccidx]] = ecc_code[i];//存放到ecc_code數組中
datidx += this->eccsize;
}
this->write_buf(mtd, this->data_poi, mtd->oobblock);//調用FLASH硬件驅動層進行寫操作
break;
default:
eccbytes = this->eccbytes;
for (; eccsteps; eccsteps--) {
/* enable hardware ecc logic for write */
this->enable_hwecc(mtd, NAND_ECC_WRITE);
this->write_buf(mtd, &this->data_poi[datidx], this->eccsize);
this->calculate_ecc(mtd, &this->data_poi[datidx], ecc_code);
for (i = 0; i < eccbytes; i++, eccidx++)
oob_buf[oob_config[eccidx]] = ecc_code[i];
/* If the hardware ecc provides syndromes then
* the ecc code must be written immidiately after
* the data bytes (words) */
if (this->options & NAND_HWECC_SYNDROME)
this->write_buf(mtd, ecc_code, eccbytes);
datidx += this->eccsize;
}
break;
}
/* Write out OOB data */
if (this->options & NAND_HWECC_SYNDROME)
this->write_buf(mtd, &oob_buf[oobsel->eccbytes], mtd->oobsize - oobsel->eccbytes);
else
this->write_buf(mtd, oob_buf, mtd->oobsize);//寫oob data，主要把上面計算的ecc值寫進去
/* Send command to actually program the data */
this->cmdfunc (mtd, cached ? NAND_CMD_CACHEDPROG : NAND_CMD_PAGEPROG, -1, -1);
if (!cached) {
/* call wait ready function */
status = this->waitfunc (mtd, this, FL_WRITING);//等待寫入完成
/* See if operation failed and additional status checks are available */
if ((status & NAND_STATUS_FAIL) && (this->errstat)) {
status = this->errstat(mtd, this, FL_WRITING, status, page);
}
/* See if device thinks it succeeded */
if (status & NAND_STATUS_FAIL) {
DEBUG (MTD_DEBUG_LEVEL0, "%s: " "Failed write, page 0x%08x, ", __FUNCTION__, page);
return -EIO;
}
} else {
/* FIXME: Implement cached programming ! */
/* wait until cache is ready*/
// status = this->waitfunc (mtd, this, FL_CACHEDRPG);//cached的寫操作暫時沒用
}
return 0;
}