]> git.ipfire.org Git - people/ms/u-boot.git/blob - drivers/mtd/at45.c
projects / people / ms / u-boot.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'next' of git://git.denx.de/u-boot-net
[people/ms/u-boot.git] / drivers / mtd / at45.c
1 /* Driver for ATMEL DataFlash support
2 * Author : Hamid Ikdoumi (Atmel)
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License as
6 * published by the Free Software Foundation; either version 2 of
7 * the License, or (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
17 * MA 02111-1307 USA
18 *
19 */
20
21 #include <config.h>
22 #include <common.h>
23 #include <dataflash.h>
24
25 /*
26 * spi.c API
27 */
28 extern unsigned int AT91F_SpiWrite(AT91PS_DataflashDesc pDesc);
29 extern void AT91F_SpiEnable(int cs);
30
31 #define AT91C_TIMEOUT_WRDY 200000
32
33 /*----------------------------------------------------------------------*/
34 /* \fn AT91F_DataFlashSendCommand */
35 /* \brief Generic function to send a command to the dataflash */
36 /*----------------------------------------------------------------------*/
37 AT91S_DataFlashStatus AT91F_DataFlashSendCommand(AT91PS_DataFlash pDataFlash,
38 unsigned char OpCode,
39 unsigned int CmdSize,
40 unsigned int DataflashAddress)
41 {
42 unsigned int adr;
43
44 if ((pDataFlash->pDataFlashDesc->state) != IDLE)
45 return DATAFLASH_BUSY;
46
47 /* process the address to obtain page address and byte address */
48 adr = ((DataflashAddress / (pDataFlash->pDevice->pages_size)) <<
49 pDataFlash->pDevice->page_offset) +
50 (DataflashAddress % (pDataFlash->pDevice->pages_size));
51
52 /* fill the command buffer */
53 pDataFlash->pDataFlashDesc->command[0] = OpCode;
54 if (pDataFlash->pDevice->pages_number >= 16384) {
55 pDataFlash->pDataFlashDesc->command[1] =
56 (unsigned char)((adr & 0x0F000000) >> 24);
57 pDataFlash->pDataFlashDesc->command[2] =
58 (unsigned char)((adr & 0x00FF0000) >> 16);
59 pDataFlash->pDataFlashDesc->command[3] =
60 (unsigned char)((adr & 0x0000FF00) >> 8);
61 pDataFlash->pDataFlashDesc->command[4] =
62 (unsigned char)(adr & 0x000000FF);
63 } else {
64 pDataFlash->pDataFlashDesc->command[1] =
65 (unsigned char)((adr & 0x00FF0000) >> 16);
66 pDataFlash->pDataFlashDesc->command[2] =
67 (unsigned char)((adr & 0x0000FF00) >> 8);
68 pDataFlash->pDataFlashDesc->command[3] =
69 (unsigned char)(adr & 0x000000FF);
70 pDataFlash->pDataFlashDesc->command[4] = 0;
71 }
72 pDataFlash->pDataFlashDesc->command[5] = 0;
73 pDataFlash->pDataFlashDesc->command[6] = 0;
74 pDataFlash->pDataFlashDesc->command[7] = 0;
75
76 /* Initialize the SpiData structure for the spi write fuction */
77 pDataFlash->pDataFlashDesc->tx_cmd_pt =
78 pDataFlash->pDataFlashDesc->command;
79 pDataFlash->pDataFlashDesc->tx_cmd_size = CmdSize;
80 pDataFlash->pDataFlashDesc->rx_cmd_pt =
81 pDataFlash->pDataFlashDesc->command;
82 pDataFlash->pDataFlashDesc->rx_cmd_size = CmdSize;
83
84 /* send the command and read the data */
85 return AT91F_SpiWrite(pDataFlash->pDataFlashDesc);
86 }
87
88 /*----------------------------------------------------------------------*/
89 /* \fn AT91F_DataFlashGetStatus */
90 /* \brief Read the status register of the dataflash */
91 /*----------------------------------------------------------------------*/
92 AT91S_DataFlashStatus AT91F_DataFlashGetStatus(AT91PS_DataflashDesc pDesc)
93 {
94 AT91S_DataFlashStatus status;
95
96 /* if a transfert is in progress ==> return 0 */
97 if ((pDesc->state) != IDLE)
98 return DATAFLASH_BUSY;
99
100 /* first send the read status command (D7H) */
101 pDesc->command[0] = DB_STATUS;
102 pDesc->command[1] = 0;
103
104 pDesc->DataFlash_state = GET_STATUS;
105 pDesc->tx_data_size = 0; /* Transmit the command */
106 /* and receive response */
107 pDesc->tx_cmd_pt = pDesc->command;
108 pDesc->rx_cmd_pt = pDesc->command;
109 pDesc->rx_cmd_size = 2;
110 pDesc->tx_cmd_size = 2;
111 status = AT91F_SpiWrite(pDesc);
112
113 pDesc->DataFlash_state = *((unsigned char *)(pDesc->rx_cmd_pt) + 1);
114
115 return status;
116 }
117
118 /*----------------------------------------------------------------------*/
119 /* \fn AT91F_DataFlashWaitReady */
120 /* \brief wait for dataflash ready (bit7 of the status register == 1) */
121 /*----------------------------------------------------------------------*/
122 AT91S_DataFlashStatus AT91F_DataFlashWaitReady(AT91PS_DataflashDesc
123 pDataFlashDesc,
124 unsigned int timeout)
125 {
126 pDataFlashDesc->DataFlash_state = IDLE;
127
128 do {
129 AT91F_DataFlashGetStatus(pDataFlashDesc);
130 timeout--;
131 } while (((pDataFlashDesc->DataFlash_state & 0x80) != 0x80) &&
132 (timeout > 0));
133
134 if ((pDataFlashDesc->DataFlash_state & 0x80) != 0x80)
135 return DATAFLASH_ERROR;
136
137 return DATAFLASH_OK;
138 }
139
140 /*--------------------------------------------------------------------------*/
141 /* Function Name : AT91F_DataFlashContinuousRead */
142 /* Object : Continuous stream Read */
143 /* Input Parameters : DataFlash Service */
144 /* : <src> = dataflash address */
145 /* : <*dataBuffer> = data buffer pointer */
146 /* : <sizeToRead> = data buffer size */
147 /* Return value : State of the dataflash */
148 /*--------------------------------------------------------------------------*/
149 AT91S_DataFlashStatus AT91F_DataFlashContinuousRead(
150 AT91PS_DataFlash pDataFlash,
151 int src,
152 unsigned char *dataBuffer,
153 int sizeToRead)
154 {
155 AT91S_DataFlashStatus status;
156 /* Test the size to read in the device */
157 if ((src + sizeToRead) >
158 (pDataFlash->pDevice->pages_size *
159 (pDataFlash->pDevice->pages_number)))
160 return DATAFLASH_MEMORY_OVERFLOW;
161
162 pDataFlash->pDataFlashDesc->rx_data_pt = dataBuffer;
163 pDataFlash->pDataFlashDesc->rx_data_size = sizeToRead;
164 pDataFlash->pDataFlashDesc->tx_data_pt = dataBuffer;
165 pDataFlash->pDataFlashDesc->tx_data_size = sizeToRead;
166
167 status = AT91F_DataFlashSendCommand(
168 pDataFlash, DB_CONTINUOUS_ARRAY_READ, 8, src);
169 /* Send the command to the dataflash */
170 return (status);
171 }
172
173 /*---------------------------------------------------------------------------*/
174 /* Function Name : AT91F_DataFlashPagePgmBuf */
175 /* Object : Main memory page program thru buffer 1 or buffer 2 */
176 /* Input Parameters : DataFlash Service */
177 /* : <*src> = Source buffer */
178 /* : <dest> = dataflash destination address */
179 /* : <SizeToWrite> = data buffer size */
180 /* Return value : State of the dataflash */
181 /*---------------------------------------------------------------------------*/
182 AT91S_DataFlashStatus AT91F_DataFlashPagePgmBuf(AT91PS_DataFlash pDataFlash,
183 unsigned char *src,
184 unsigned int dest,
185 unsigned int SizeToWrite)
186 {
187 int cmdsize;
188 pDataFlash->pDataFlashDesc->tx_data_pt = src;
189 pDataFlash->pDataFlashDesc->tx_data_size = SizeToWrite;
190 pDataFlash->pDataFlashDesc->rx_data_pt = src;
191 pDataFlash->pDataFlashDesc->rx_data_size = SizeToWrite;
192
193 cmdsize = 4;
194 /* Send the command to the dataflash */
195 if (pDataFlash->pDevice->pages_number >= 16384)
196 cmdsize = 5;
197 return (AT91F_DataFlashSendCommand(
198 pDataFlash, DB_PAGE_PGM_BUF1, cmdsize, dest));
199 }
200
201 /*---------------------------------------------------------------------------*/
202 /* Function Name : AT91F_MainMemoryToBufferTransfert */
203 /* Object : Read a page in the SRAM Buffer 1 or 2 */
204 /* Input Parameters : DataFlash Service */
205 /* : Page concerned */
206 /* : */
207 /* Return value : State of the dataflash */
208 /*---------------------------------------------------------------------------*/
209 AT91S_DataFlashStatus AT91F_MainMemoryToBufferTransfert(
210 AT91PS_DataFlash
211 pDataFlash,
212 unsigned char
213 BufferCommand,
214 unsigned int page)
215 {
216 int cmdsize;
217 /* Test if the buffer command is legal */
218 if ((BufferCommand != DB_PAGE_2_BUF1_TRF) &&
219 (BufferCommand != DB_PAGE_2_BUF2_TRF)) {
220 return DATAFLASH_BAD_COMMAND;
221 }
222
223 /* no data to transmit or receive */
224 pDataFlash->pDataFlashDesc->tx_data_size = 0;
225 cmdsize = 4;
226 if (pDataFlash->pDevice->pages_number >= 16384)
227 cmdsize = 5;
228 return (AT91F_DataFlashSendCommand(
229 pDataFlash, BufferCommand, cmdsize,
230 page * pDataFlash->pDevice->pages_size));
231 }
232
233 /*-------------------------------------------------------------------------- */
234 /* Function Name : AT91F_DataFlashWriteBuffer */
235 /* Object : Write data to the internal sram buffer 1 or 2 */
236 /* Input Parameters : DataFlash Service */
237 /* : <BufferCommand> = command to write buffer1 or 2 */
238 /* : <*dataBuffer> = data buffer to write */
239 /* : <bufferAddress> = address in the internal buffer */
240 /* : <SizeToWrite> = data buffer size */
241 /* Return value : State of the dataflash */
242 /*---------------------------------------------------------------------------*/
243 AT91S_DataFlashStatus AT91F_DataFlashWriteBuffer(
244 AT91PS_DataFlash pDataFlash,
245 unsigned char BufferCommand,
246 unsigned char *dataBuffer,
247 unsigned int bufferAddress,
248 int SizeToWrite)
249 {
250 int cmdsize;
251 /* Test if the buffer command is legal */
252 if ((BufferCommand != DB_BUF1_WRITE) &&
253 (BufferCommand != DB_BUF2_WRITE)) {
254 return DATAFLASH_BAD_COMMAND;
255 }
256
257 /* buffer address must be lower than page size */
258 if (bufferAddress > pDataFlash->pDevice->pages_size)
259 return DATAFLASH_BAD_ADDRESS;
260
261 if ((pDataFlash->pDataFlashDesc->state) != IDLE)
262 return DATAFLASH_BUSY;
263
264 /* Send first Write Command */
265 pDataFlash->pDataFlashDesc->command[0] = BufferCommand;
266 pDataFlash->pDataFlashDesc->command[1] = 0;
267 if (pDataFlash->pDevice->pages_number >= 16384) {
268 pDataFlash->pDataFlashDesc->command[2] = 0;
269 pDataFlash->pDataFlashDesc->command[3] =
270 (unsigned char)(((unsigned int)(bufferAddress &
271 pDataFlash->pDevice->
272 byte_mask)) >> 8);
273 pDataFlash->pDataFlashDesc->command[4] =
274 (unsigned char)((unsigned int)bufferAddress & 0x00FF);
275 cmdsize = 5;
276 } else {
277 pDataFlash->pDataFlashDesc->command[2] =
278 (unsigned char)(((unsigned int)(bufferAddress &
279 pDataFlash->pDevice->
280 byte_mask)) >> 8);
281 pDataFlash->pDataFlashDesc->command[3] =
282 (unsigned char)((unsigned int)bufferAddress & 0x00FF);
283 pDataFlash->pDataFlashDesc->command[4] = 0;
284 cmdsize = 4;
285 }
286
287 pDataFlash->pDataFlashDesc->tx_cmd_pt =
288 pDataFlash->pDataFlashDesc->command;
289 pDataFlash->pDataFlashDesc->tx_cmd_size = cmdsize;
290 pDataFlash->pDataFlashDesc->rx_cmd_pt =
291 pDataFlash->pDataFlashDesc->command;
292 pDataFlash->pDataFlashDesc->rx_cmd_size = cmdsize;
293
294 pDataFlash->pDataFlashDesc->rx_data_pt = dataBuffer;
295 pDataFlash->pDataFlashDesc->tx_data_pt = dataBuffer;
296 pDataFlash->pDataFlashDesc->rx_data_size = SizeToWrite;
297 pDataFlash->pDataFlashDesc->tx_data_size = SizeToWrite;
298
299 return AT91F_SpiWrite(pDataFlash->pDataFlashDesc);
300 }
301
302 /*---------------------------------------------------------------------------*/
303 /* Function Name : AT91F_PageErase */
304 /* Object : Erase a page */
305 /* Input Parameters : DataFlash Service */
306 /* : Page concerned */
307 /* : */
308 /* Return value : State of the dataflash */
309 /*---------------------------------------------------------------------------*/
310 AT91S_DataFlashStatus AT91F_PageErase(
311 AT91PS_DataFlash pDataFlash,
312 unsigned int page)
313 {
314 int cmdsize;
315 /* Test if the buffer command is legal */
316 /* no data to transmit or receive */
317 pDataFlash->pDataFlashDesc->tx_data_size = 0;
318
319 cmdsize = 4;
320 if (pDataFlash->pDevice->pages_number >= 16384)
321 cmdsize = 5;
322 return (AT91F_DataFlashSendCommand(pDataFlash,
323 DB_PAGE_ERASE, cmdsize,
324 page * pDataFlash->pDevice->pages_size));
325 }
326
327 /*---------------------------------------------------------------------------*/
328 /* Function Name : AT91F_BlockErase */
329 /* Object : Erase a Block */
330 /* Input Parameters : DataFlash Service */
331 /* : Page concerned */
332 /* : */
333 /* Return value : State of the dataflash */
334 /*---------------------------------------------------------------------------*/
335 AT91S_DataFlashStatus AT91F_BlockErase(
336 AT91PS_DataFlash pDataFlash,
337 unsigned int block)
338 {
339 int cmdsize;
340 /* Test if the buffer command is legal */
341 /* no data to transmit or receive */
342 pDataFlash->pDataFlashDesc->tx_data_size = 0;
343 cmdsize = 4;
344 if (pDataFlash->pDevice->pages_number >= 16384)
345 cmdsize = 5;
346 return (AT91F_DataFlashSendCommand(pDataFlash, DB_BLOCK_ERASE, cmdsize,
347 block * 8 *
348 pDataFlash->pDevice->pages_size));
349 }
350
351 /*---------------------------------------------------------------------------*/
352 /* Function Name : AT91F_WriteBufferToMain */
353 /* Object : Write buffer to the main memory */
354 /* Input Parameters : DataFlash Service */
355 /* : <BufferCommand> = command to send to buffer1 or buffer2 */
356 /* : <dest> = main memory address */
357 /* Return value : State of the dataflash */
358 /*---------------------------------------------------------------------------*/
359 AT91S_DataFlashStatus AT91F_WriteBufferToMain(AT91PS_DataFlash pDataFlash,
360 unsigned char BufferCommand,
361 unsigned int dest)
362 {
363 int cmdsize;
364 /* Test if the buffer command is correct */
365 if ((BufferCommand != DB_BUF1_PAGE_PGM) &&
366 (BufferCommand != DB_BUF1_PAGE_ERASE_PGM) &&
367 (BufferCommand != DB_BUF2_PAGE_PGM) &&
368 (BufferCommand != DB_BUF2_PAGE_ERASE_PGM))
369 return DATAFLASH_BAD_COMMAND;
370
371 /* no data to transmit or receive */
372 pDataFlash->pDataFlashDesc->tx_data_size = 0;
373
374 cmdsize = 4;
375 if (pDataFlash->pDevice->pages_number >= 16384)
376 cmdsize = 5;
377 /* Send the command to the dataflash */
378 return (AT91F_DataFlashSendCommand(pDataFlash, BufferCommand,
379 cmdsize, dest));
380 }
381
382 /*---------------------------------------------------------------------------*/
383 /* Function Name : AT91F_PartialPageWrite */
384 /* Object : Erase partielly a page */
385 /* Input Parameters : <page> = page number */
386 /* : <AdrInpage> = adr to begin the fading */
387 /* : <length> = Number of bytes to erase */
388 /*---------------------------------------------------------------------------*/
389 AT91S_DataFlashStatus AT91F_PartialPageWrite(AT91PS_DataFlash pDataFlash,
390 unsigned char *src,
391 unsigned int dest,
392 unsigned int size)
393 {
394 unsigned int page;
395 unsigned int AdrInPage;
396
397 page = dest / (pDataFlash->pDevice->pages_size);
398 AdrInPage = dest % (pDataFlash->pDevice->pages_size);
399
400 /* Read the contents of the page in the Sram Buffer */
401 AT91F_MainMemoryToBufferTransfert(pDataFlash, DB_PAGE_2_BUF1_TRF, page);
402 AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
403 AT91C_TIMEOUT_WRDY);
404 /*Update the SRAM buffer */
405 AT91F_DataFlashWriteBuffer(pDataFlash, DB_BUF1_WRITE, src,
406 AdrInPage, size);
407
408 AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
409 AT91C_TIMEOUT_WRDY);
410
411 /* Erase page if a 128 Mbits device */
412 if (pDataFlash->pDevice->pages_number >= 16384) {
413 AT91F_PageErase(pDataFlash, page);
414 /* Rewrite the modified Sram Buffer in the main memory */
415 AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
416 AT91C_TIMEOUT_WRDY);
417 }
418
419 /* Rewrite the modified Sram Buffer in the main memory */
420 return (AT91F_WriteBufferToMain(pDataFlash, DB_BUF1_PAGE_ERASE_PGM,
421 (page *
422 pDataFlash->pDevice->pages_size)));
423 }
424
425 /*---------------------------------------------------------------------------*/
426 /* Function Name : AT91F_DataFlashWrite */
427 /* Object : */
428 /* Input Parameters : <*src> = Source buffer */
429 /* : <dest> = dataflash adress */
430 /* : <size> = data buffer size */
431 /*---------------------------------------------------------------------------*/
432 AT91S_DataFlashStatus AT91F_DataFlashWrite(AT91PS_DataFlash pDataFlash,
433 unsigned char *src,
434 int dest, int size)
435 {
436 unsigned int length;
437 unsigned int page;
438 unsigned int status;
439
440 AT91F_SpiEnable(pDataFlash->pDevice->cs);
441
442 if ((dest + size) > (pDataFlash->pDevice->pages_size *
443 (pDataFlash->pDevice->pages_number)))
444 return DATAFLASH_MEMORY_OVERFLOW;
445
446 /* If destination does not fit a page start address */
447 if ((dest % ((unsigned int)(pDataFlash->pDevice->pages_size))) != 0) {
448 length =
449 pDataFlash->pDevice->pages_size -
450 (dest % ((unsigned int)(pDataFlash->pDevice->pages_size)));
451
452 if (size < length)
453 length = size;
454
455 if (!AT91F_PartialPageWrite(pDataFlash, src, dest, length))
456 return DATAFLASH_ERROR;
457
458 AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
459 AT91C_TIMEOUT_WRDY);
460
461 /* Update size, source and destination pointers */
462 size -= length;
463 dest += length;
464 src += length;
465 }
466
467 while ((size - pDataFlash->pDevice->pages_size) >= 0) {
468 /* program dataflash page */
469 page = (unsigned int)dest / (pDataFlash->pDevice->pages_size);
470
471 status = AT91F_DataFlashWriteBuffer(pDataFlash,
472 DB_BUF1_WRITE, src, 0,
473 pDataFlash->pDevice->
474 pages_size);
475 AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
476 AT91C_TIMEOUT_WRDY);
477
478 status = AT91F_PageErase(pDataFlash, page);
479 AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
480 AT91C_TIMEOUT_WRDY);
481 if (!status)
482 return DATAFLASH_ERROR;
483
484 status = AT91F_WriteBufferToMain(pDataFlash,
485 DB_BUF1_PAGE_PGM, dest);
486 if (!status)
487 return DATAFLASH_ERROR;
488
489 AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
490 AT91C_TIMEOUT_WRDY);
491
492 /* Update size, source and destination pointers */
493 size -= pDataFlash->pDevice->pages_size;
494 dest += pDataFlash->pDevice->pages_size;
495 src += pDataFlash->pDevice->pages_size;
496 }
497
498 /* If still some bytes to read */
499 if (size > 0) {
500 /* program dataflash page */
501 if (!AT91F_PartialPageWrite(pDataFlash, src, dest, size))
502 return DATAFLASH_ERROR;
503
504 AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
505 AT91C_TIMEOUT_WRDY);
506 }
507 return DATAFLASH_OK;
508 }
509
510 /*---------------------------------------------------------------------------*/
511 /* Function Name : AT91F_DataFlashRead */
512 /* Object : Read a block in dataflash */
513 /* Input Parameters : */
514 /* Return value : */
515 /*---------------------------------------------------------------------------*/
516 int AT91F_DataFlashRead(AT91PS_DataFlash pDataFlash,
517 unsigned long addr, unsigned long size, char *buffer)
518 {
519 unsigned long SizeToRead;
520
521 AT91F_SpiEnable(pDataFlash->pDevice->cs);
522
523 if (AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
524 AT91C_TIMEOUT_WRDY) != DATAFLASH_OK)
525 return -1;
526
527 while (size) {
528 SizeToRead = (size < 0x8000) ? size : 0x8000;
529
530 if (AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
531 AT91C_TIMEOUT_WRDY) !=
532 DATAFLASH_OK)
533 return -1;
534
535 if (AT91F_DataFlashContinuousRead(pDataFlash, addr,
536 (uchar *) buffer,
537 SizeToRead) != DATAFLASH_OK)
538 return -1;
539
540 size -= SizeToRead;
541 addr += SizeToRead;
542 buffer += SizeToRead;
543 }
544
545 return DATAFLASH_OK;
546 }
547
548 /*---------------------------------------------------------------------------*/
549 /* Function Name : AT91F_DataflashProbe */
550 /* Object : */
551 /* Input Parameters : */
552 /* Return value : Dataflash status register */
553 /*---------------------------------------------------------------------------*/
554 int AT91F_DataflashProbe(int cs, AT91PS_DataflashDesc pDesc)
555 {
556 AT91F_SpiEnable(cs);
557 AT91F_DataFlashGetStatus(pDesc);
558 return ((pDesc->command[1] == 0xFF) ? 0 : pDesc->command[1] & 0x3C);
559 }
"Das U-Boot" Source Tree