Ok, let's try to start working on a flash adapater solution together:
My main objective is to have a flash adapter that is capable to dump/read BGA-316 chips.
Optional targets:
* Write+Erase support
* VSC support (I actually found some vendor specific commands and want a reader where I am able to play around with them)
* High speed
* Cheap price
I started to collect a market-overview of potentially interesting Flash adapters, both commercially available and DIY solutions:
https://docs.google.com/spreadsheets/d/ ... sp=sharing(Should I provide a Non-Google-Docs version for anyone?)
Does anyone know any flash readers that I haven't covered yet? Any feedback or improvements are highly appreciated!
BGA-316 has defined approximately 80 balls (the standard defines up to 32 chip enable lines, the chips I have seem use ), so I took a look at the interface between the flash reader and the chip adapters and counted the number of pins. It seems that all the commercial data-recovery flash readers do not have enough pins for ONFI BGA-316.
I guess that we might be able to spare a few pins by sharing the data lines between the quad 8-bit data lines, which would slow the reading down, but would allow flash readers to be used with less pins. I am not sure, whether that works out electrically (whether the chips are able to drive the load of shared data lines), or whether we would get other signal integrity problems. If sharing the lines would be possible, what is the minimum number of pins we actually need to fully support BGA-316? (I have a friend who might be able to answer that question)
I took a look at the interface connector between the flash reader and the chip adapters, to see whether they are easily purchasable, whether it is possible to develop your own adapters, whether the wiring is high-speed capable.
Is any of the vendors able to use GPIO Extenders on the Flash Adapters? Using 2 I/Os for a GPIO extender that extends to the 32 CE lines might be a good idea to spare I/O lines between the flash reader and the adapters.
Another thing that surprised me is that I couldn't find any USB3 flash reader yet. But perhaps it would need a lot of effort for parallelisation for all the other things to make use of USB3 speed, and it would likely interfere with the linear dump-file concept the industry currently has.
Since I couldn't find any data-recovery capable flash reader with BGA-316 support, I also searched for universal programmers (the UP-828P looks really interesting!), and I researched how it would be possible to DIY. I also searched for single-board computers that have enough GPIOs to be usable, anything that can be turned into a NAND flash reader.
Since BGA316 is difficult from the hardware side and kind of a niche market, I thought it might be a good idea that we start with an easier ONFI compliant target instead first, so I chose TSOP-48 for it. I have a BGA-316 <-> TSOP-48 adapter (with 4CE), so whatever is to be learnt for TSOP-48 should be applicable to BGA-316 later.
I bought a 360-Clip for TSOP48 and used it with a logic-analyzer. One important warning: The 360-CLIP comes in 3 different versions: The 32-Pin version, the 48-Pin version and the 56-Pin version. I accidently bought the 32-Pin version, which provides only 2 CE lines, the 48-Pin version is my preferred version. If you have to deal with TSOP56 you want the 56-Pin version.
I think we should develop an ONFI decoder for SigRok, does anyone want to help there? I developed a few SigRok plugins in the past.
My research showed that many of the readers do not provide the programming voltage (VPP) on the pins, so those are not usable for Write/Erase. But they still might be usable for special VSC (vendor specific commands)
Does anyone know the maximum signal speed of the individual signal lines of ONFI? Can anyone recommend a certain logic analyzer for the job? Can anyone provide logic-analyzer dumps from a complete ONFI communication?
On the software-side, I have found several different interesting options:
I found a ANSI-C flash reader for one of the commercial tools
I found various ANSI-C flash readers that should be easily adaptable to various boards and systems.
The Linux kernel contains a lot of flash interface code and various tables for supporting various chips.
I found a ONFI compliant flash reader implemented in VHDL on OpenCores. I tried to get it converted to Verilog in an automated way, but I failed with that, I guess I would have to convert it manually to Verilog.
I took the Raspberry-Pi 360-Clip Flash-Reader code from GitHub that was posted in the forum and started enhancing it with testing functionality, I'll send it upstream to GitHub soon.
So from the software-side I am somewhat confident that we will be able to find a good solution.
Most of the commercial tools seem to just dump all pages in a linear way into a single dump file that can then be processed by most commercial tools. I think the single dump file itself is OK, but I personally would prefer that the flash reader also spits out all the flash parameters and things like the flash-ID and adds it somewhere to the file, which might be useful information for the analyzing tools later on.
I had a lot of ideas in the past about interposers that would allow not just logic analyzing but even man-in-the-middle tampering with ONFI flash, some of them I have documented in the TheMissingManual already. And I even found interposers for BGA-316 on the market, but they are only usable for logic-analyzing.