]> git.sur5r.net Git - u-boot/blob - board/at91rm9200dk/at45.c
ppc4xx: Update 44x_spd_ddr2 code (440SP/440SPe)
[u-boot] / board / at91rm9200dk / 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 <asm/hardware.h>
24
25 #ifdef CONFIG_HAS_DATAFLASH
26 #include <dataflash.h>
27
28 #define AT91C_SPI_CLK   10000000        /* Max Value = 10MHz to be compliant to
29 the Continuous Array Read function */
30
31 /* AC Characteristics */
32 /* DLYBS = tCSS = 250ns min and DLYBCT = tCSH = 250ns */
33 #define DATAFLASH_TCSS  (0xC << 16)
34 #define DATAFLASH_TCHS  (0x1 << 24)
35
36 #define AT91C_TIMEOUT_WRDY                      200000
37 #define AT91C_SPI_PCS0_SERIAL_DATAFLASH         0xE     /* Chip Select 0 : NPCS0 %1110 */
38 #define AT91C_SPI_PCS3_DATAFLASH_CARD           0x7     /* Chip Select 3 : NPCS3 %0111 */
39
40 void AT91F_SpiInit(void) {
41
42 /*-------------------------------------------------------------------*/
43 /*      SPI DataFlash Init                                                              */
44 /*-------------------------------------------------------------------*/
45         /* Configure PIOs */
46         AT91C_BASE_PIOA->PIO_ASR = AT91C_PA3_NPCS0 | AT91C_PA4_NPCS1 | AT91C_PA1_MOSI | AT91C_PA5_NPCS2 |
47                                    AT91C_PA6_NPCS3 | AT91C_PA0_MISO | AT91C_PA2_SPCK;
48         AT91C_BASE_PIOA->PIO_PDR = AT91C_PA3_NPCS0 | AT91C_PA4_NPCS1 | AT91C_PA1_MOSI | AT91C_PA5_NPCS2 |
49                                    AT91C_PA6_NPCS3 | AT91C_PA0_MISO | AT91C_PA2_SPCK;
50         /* Enable CLock */
51         AT91C_BASE_PMC->PMC_PCER = 1 << AT91C_ID_SPI;
52
53         /* Reset the SPI */
54         AT91C_BASE_SPI->SPI_CR = AT91C_SPI_SWRST;
55
56         /* Configure SPI in Master Mode with No CS selected !!! */
57         AT91C_BASE_SPI->SPI_MR = AT91C_SPI_MSTR | AT91C_SPI_MODFDIS | AT91C_SPI_PCS;
58
59         /* Configure CS0 and CS3 */
60         *(AT91C_SPI_CSR + 0) = AT91C_SPI_CPOL | (AT91C_SPI_DLYBS & DATAFLASH_TCSS) | (AT91C_SPI_DLYBCT &
61         DATAFLASH_TCHS) | ((AT91C_MASTER_CLOCK / (2*AT91C_SPI_CLK)) << 8);
62
63         *(AT91C_SPI_CSR + 3) = AT91C_SPI_CPOL | (AT91C_SPI_DLYBS & DATAFLASH_TCSS) | (AT91C_SPI_DLYBCT &
64         DATAFLASH_TCHS) | ((AT91C_MASTER_CLOCK / (2*AT91C_SPI_CLK)) << 8);
65
66 }
67
68 void AT91F_SpiEnable(int cs) {
69         switch(cs) {
70         case 0: /* Configure SPI CS0 for Serial DataFlash AT45DBxx */
71                 AT91C_BASE_SPI->SPI_MR &= 0xFFF0FFFF;
72                 AT91C_BASE_SPI->SPI_MR |= ((AT91C_SPI_PCS0_SERIAL_DATAFLASH<<16) & AT91C_SPI_PCS);
73                 break;
74         case 3: /* Configure SPI CS3 for Serial DataFlash Card */
75                 /* Set up PIO SDC_TYPE to switch on DataFlash Card and not MMC/SDCard */
76                 AT91C_BASE_PIOB->PIO_PER = AT91C_PIO_PB7;       /* Set in PIO mode */
77                 AT91C_BASE_PIOB->PIO_OER = AT91C_PIO_PB7;       /* Configure in output */
78                 /* Clear Output */
79                 AT91C_BASE_PIOB->PIO_CODR = AT91C_PIO_PB7;
80                 /* Configure PCS */
81                 AT91C_BASE_SPI->SPI_MR &= 0xFFF0FFFF;
82                 AT91C_BASE_SPI->SPI_MR |= ((AT91C_SPI_PCS3_DATAFLASH_CARD<<16) & AT91C_SPI_PCS);
83                 break;
84         }
85
86         /* SPI_Enable */
87         AT91C_BASE_SPI->SPI_CR = AT91C_SPI_SPIEN;
88 }
89
90 /*----------------------------------------------------------------------------*/
91 /* \fn    AT91F_SpiWrite                                                      */
92 /* \brief Set the PDC registers for a transfert                               */
93 /*----------------------------------------------------------------------------*/
94 unsigned int AT91F_SpiWrite ( AT91PS_DataflashDesc pDesc )
95 {
96         unsigned int timeout;
97
98         pDesc->state = BUSY;
99
100         AT91C_BASE_SPI->SPI_PTCR = AT91C_PDC_TXTDIS + AT91C_PDC_RXTDIS;
101
102         /* Initialize the Transmit and Receive Pointer */
103         AT91C_BASE_SPI->SPI_RPR = (unsigned int)pDesc->rx_cmd_pt ;
104         AT91C_BASE_SPI->SPI_TPR = (unsigned int)pDesc->tx_cmd_pt ;
105
106         /* Intialize the Transmit and Receive Counters */
107         AT91C_BASE_SPI->SPI_RCR = pDesc->rx_cmd_size;
108         AT91C_BASE_SPI->SPI_TCR = pDesc->tx_cmd_size;
109
110         if ( pDesc->tx_data_size != 0 ) {
111                 /* Initialize the Next Transmit and Next Receive Pointer */
112                 AT91C_BASE_SPI->SPI_RNPR = (unsigned int)pDesc->rx_data_pt ;
113                 AT91C_BASE_SPI->SPI_TNPR = (unsigned int)pDesc->tx_data_pt ;
114
115                 /* Intialize the Next Transmit and Next Receive Counters */
116                 AT91C_BASE_SPI->SPI_RNCR = pDesc->rx_data_size ;
117                 AT91C_BASE_SPI->SPI_TNCR = pDesc->tx_data_size ;
118         }
119
120         /* arm simple, non interrupt dependent timer */
121         reset_timer_masked();
122         timeout = 0;
123
124         AT91C_BASE_SPI->SPI_PTCR = AT91C_PDC_TXTEN + AT91C_PDC_RXTEN;
125         while(!(AT91C_BASE_SPI->SPI_SR & AT91C_SPI_RXBUFF) && ((timeout = get_timer_masked() ) < CFG_SPI_WRITE_TOUT));
126         AT91C_BASE_SPI->SPI_PTCR = AT91C_PDC_TXTDIS + AT91C_PDC_RXTDIS;
127         pDesc->state = IDLE;
128
129         if (timeout >= CFG_SPI_WRITE_TOUT){
130                 printf("Error Timeout\n\r");
131                 return DATAFLASH_ERROR;
132         }
133
134         return DATAFLASH_OK;
135 }
136
137
138 /*----------------------------------------------------------------------*/
139 /* \fn    AT91F_DataFlashSendCommand                                    */
140 /* \brief Generic function to send a command to the dataflash           */
141 /*----------------------------------------------------------------------*/
142 AT91S_DataFlashStatus AT91F_DataFlashSendCommand(
143         AT91PS_DataFlash pDataFlash,
144         unsigned char OpCode,
145         unsigned int CmdSize,
146         unsigned int DataflashAddress)
147 {
148     unsigned int adr;
149
150         if ( (pDataFlash->pDataFlashDesc->state) != IDLE)
151                 return DATAFLASH_BUSY;
152
153         /* process the address to obtain page address and byte address */
154         adr = ((DataflashAddress / (pDataFlash->pDevice->pages_size)) << pDataFlash->pDevice->page_offset) + (DataflashAddress % (pDataFlash->pDevice->pages_size));
155
156         /* fill the  command  buffer */
157         pDataFlash->pDataFlashDesc->command[0] = OpCode;
158         if (pDataFlash->pDevice->pages_number >= 16384) {
159                 pDataFlash->pDataFlashDesc->command[1] = (unsigned char)((adr & 0x0F000000) >> 24);
160                 pDataFlash->pDataFlashDesc->command[2] = (unsigned char)((adr & 0x00FF0000) >> 16);
161                 pDataFlash->pDataFlashDesc->command[3] = (unsigned char)((adr & 0x0000FF00) >> 8);
162                 pDataFlash->pDataFlashDesc->command[4] = (unsigned char)(adr & 0x000000FF);
163         } else {
164                 pDataFlash->pDataFlashDesc->command[1] = (unsigned char)((adr & 0x00FF0000) >> 16);
165                 pDataFlash->pDataFlashDesc->command[2] = (unsigned char)((adr & 0x0000FF00) >> 8);
166                 pDataFlash->pDataFlashDesc->command[3] = (unsigned char)(adr & 0x000000FF) ;
167                 pDataFlash->pDataFlashDesc->command[4] = 0;
168         }
169         pDataFlash->pDataFlashDesc->command[5] = 0;
170         pDataFlash->pDataFlashDesc->command[6] = 0;
171         pDataFlash->pDataFlashDesc->command[7] = 0;
172
173         /* Initialize the SpiData structure for the spi write fuction */
174         pDataFlash->pDataFlashDesc->tx_cmd_pt   =  pDataFlash->pDataFlashDesc->command ;
175         pDataFlash->pDataFlashDesc->tx_cmd_size =  CmdSize ;
176         pDataFlash->pDataFlashDesc->rx_cmd_pt   =  pDataFlash->pDataFlashDesc->command ;
177         pDataFlash->pDataFlashDesc->rx_cmd_size =  CmdSize ;
178
179         /* send the command and read the data */
180         return AT91F_SpiWrite (pDataFlash->pDataFlashDesc);
181 }
182
183
184 /*----------------------------------------------------------------------*/
185 /* \fn    AT91F_DataFlashGetStatus                                      */
186 /* \brief Read the status register of the dataflash                     */
187 /*----------------------------------------------------------------------*/
188 AT91S_DataFlashStatus AT91F_DataFlashGetStatus(AT91PS_DataflashDesc pDesc)
189 {
190         AT91S_DataFlashStatus status;
191
192         /* if a transfert is in progress ==> return 0 */
193         if( (pDesc->state) != IDLE)
194                 return DATAFLASH_BUSY;
195
196         /* first send the read status command (D7H) */
197         pDesc->command[0] = DB_STATUS;
198         pDesc->command[1] = 0;
199
200         pDesc->DataFlash_state  = GET_STATUS;
201         pDesc->tx_data_size     = 0 ;   /* Transmit the command and receive response */
202         pDesc->tx_cmd_pt                = pDesc->command ;
203         pDesc->rx_cmd_pt                = pDesc->command ;
204         pDesc->rx_cmd_size              = 2 ;
205         pDesc->tx_cmd_size              = 2 ;
206         status = AT91F_SpiWrite (pDesc);
207
208         pDesc->DataFlash_state = *( (unsigned char *) (pDesc->rx_cmd_pt) +1);
209
210         return status;
211 }
212
213
214 /*----------------------------------------------------------------------*/
215 /* \fn    AT91F_DataFlashWaitReady                                      */
216 /* \brief wait for dataflash ready (bit7 of the status register == 1)   */
217 /*----------------------------------------------------------------------*/
218 AT91S_DataFlashStatus AT91F_DataFlashWaitReady(AT91PS_DataflashDesc pDataFlashDesc, unsigned int timeout)
219 {
220         pDataFlashDesc->DataFlash_state = IDLE;
221
222         do {
223                 AT91F_DataFlashGetStatus(pDataFlashDesc);
224                 timeout--;
225         } while( ((pDataFlashDesc->DataFlash_state & 0x80) != 0x80) && (timeout > 0) );
226
227         if((pDataFlashDesc->DataFlash_state & 0x80) != 0x80)
228                 return DATAFLASH_ERROR;
229
230         return DATAFLASH_OK;
231 }
232
233
234 /*------------------------------------------------------------------------------*/
235 /* Function Name       : AT91F_DataFlashContinuousRead                          */
236 /* Object              : Continuous stream Read                                 */
237 /* Input Parameters    : DataFlash Service                                      */
238 /*                                              : <src> = dataflash address     */
239 /*                     : <*dataBuffer> = data buffer pointer                    */
240 /*                     : <sizeToRead> = data buffer size                        */
241 /* Return value         : State of the dataflash                                */
242 /*------------------------------------------------------------------------------*/
243 AT91S_DataFlashStatus AT91F_DataFlashContinuousRead (
244         AT91PS_DataFlash pDataFlash,
245         int src,
246         unsigned char *dataBuffer,
247         int sizeToRead )
248 {
249         AT91S_DataFlashStatus status;
250         /* Test the size to read in the device */
251         if ( (src + sizeToRead) > (pDataFlash->pDevice->pages_size * (pDataFlash->pDevice->pages_number)))
252                 return DATAFLASH_MEMORY_OVERFLOW;
253
254         pDataFlash->pDataFlashDesc->rx_data_pt = dataBuffer;
255         pDataFlash->pDataFlashDesc->rx_data_size = sizeToRead;
256         pDataFlash->pDataFlashDesc->tx_data_pt = dataBuffer;
257         pDataFlash->pDataFlashDesc->tx_data_size = sizeToRead;
258
259         status = AT91F_DataFlashSendCommand (pDataFlash, DB_CONTINUOUS_ARRAY_READ, 8, src);
260         /* Send the command to the dataflash */
261         return(status);
262 }
263
264
265 /*------------------------------------------------------------------------------*/
266 /* Function Name       : AT91F_DataFlashPagePgmBuf                              */
267 /* Object              : Main memory page program through buffer 1 or buffer 2  */
268 /* Input Parameters    : DataFlash Service                                      */
269 /*                                              : <*src> = Source buffer        */
270 /*                     : <dest> = dataflash destination address                 */
271 /*                     : <SizeToWrite> = data buffer size                       */
272 /* Return value         : State of the dataflash                                */
273 /*------------------------------------------------------------------------------*/
274 AT91S_DataFlashStatus AT91F_DataFlashPagePgmBuf(
275         AT91PS_DataFlash pDataFlash,
276         unsigned char *src,
277         unsigned int dest,
278         unsigned int SizeToWrite)
279 {
280         int cmdsize;
281         pDataFlash->pDataFlashDesc->tx_data_pt = src ;
282         pDataFlash->pDataFlashDesc->tx_data_size = SizeToWrite ;
283         pDataFlash->pDataFlashDesc->rx_data_pt = src;
284         pDataFlash->pDataFlashDesc->rx_data_size = SizeToWrite;
285
286         cmdsize = 4;
287         /* Send the command to the dataflash */
288         if (pDataFlash->pDevice->pages_number >= 16384)
289                 cmdsize = 5;
290         return(AT91F_DataFlashSendCommand (pDataFlash, DB_PAGE_PGM_BUF1, cmdsize, dest));
291 }
292
293
294 /*------------------------------------------------------------------------------*/
295 /* Function Name       : AT91F_MainMemoryToBufferTransfert                      */
296 /* Object              : Read a page in the SRAM Buffer 1 or 2                  */
297 /* Input Parameters    : DataFlash Service                                      */
298 /*                     : Page concerned                                         */
299 /*                     :                                                        */
300 /* Return value         : State of the dataflash                                */
301 /*------------------------------------------------------------------------------*/
302 AT91S_DataFlashStatus AT91F_MainMemoryToBufferTransfert(
303         AT91PS_DataFlash pDataFlash,
304         unsigned char BufferCommand,
305         unsigned int page)
306 {
307         int cmdsize;
308         /* Test if the buffer command is legal */
309         if ((BufferCommand != DB_PAGE_2_BUF1_TRF) && (BufferCommand != DB_PAGE_2_BUF2_TRF))
310                 return DATAFLASH_BAD_COMMAND;
311
312         /* no data to transmit or receive */
313         pDataFlash->pDataFlashDesc->tx_data_size = 0;
314         cmdsize = 4;
315         if (pDataFlash->pDevice->pages_number >= 16384)
316                 cmdsize = 5;
317         return(AT91F_DataFlashSendCommand (pDataFlash, BufferCommand, cmdsize, page*pDataFlash->pDevice->pages_size));
318 }
319
320
321 /*----------------------------------------------------------------------------- */
322 /* Function Name       : AT91F_DataFlashWriteBuffer                             */
323 /* Object              : Write data to the internal sram buffer 1 or 2          */
324 /* Input Parameters    : DataFlash Service                                      */
325 /*                      : <BufferCommand> = command to write buffer1 or buffer2 */
326 /*                     : <*dataBuffer> = data buffer to write                   */
327 /*                     : <bufferAddress> = address in the internal buffer       */
328 /*                     : <SizeToWrite> = data buffer size                       */
329 /* Return value         : State of the dataflash                                */
330 /*------------------------------------------------------------------------------*/
331 AT91S_DataFlashStatus AT91F_DataFlashWriteBuffer (
332         AT91PS_DataFlash pDataFlash,
333         unsigned char BufferCommand,
334         unsigned char *dataBuffer,
335         unsigned int bufferAddress,
336         int SizeToWrite )
337 {
338         int cmdsize;
339         /* Test if the buffer command is legal */
340         if ((BufferCommand != DB_BUF1_WRITE) && (BufferCommand != DB_BUF2_WRITE))
341                 return DATAFLASH_BAD_COMMAND;
342
343         /* buffer address must be lower than page size */
344         if (bufferAddress > pDataFlash->pDevice->pages_size)
345                 return DATAFLASH_BAD_ADDRESS;
346
347         if ( (pDataFlash->pDataFlashDesc->state)  != IDLE)
348                 return DATAFLASH_BUSY;
349
350         /* Send first Write Command */
351         pDataFlash->pDataFlashDesc->command[0] = BufferCommand;
352         pDataFlash->pDataFlashDesc->command[1] = 0;
353         if (pDataFlash->pDevice->pages_number >= 16384) {
354                 pDataFlash->pDataFlashDesc->command[2] = 0;
355                 pDataFlash->pDataFlashDesc->command[3] = (unsigned char)(((unsigned int)(bufferAddress &  pDataFlash->pDevice->byte_mask)) >> 8) ;
356                 pDataFlash->pDataFlashDesc->command[4] = (unsigned char)((unsigned int)bufferAddress  & 0x00FF) ;
357                 cmdsize = 5;
358         } else {
359                 pDataFlash->pDataFlashDesc->command[2] = (unsigned char)(((unsigned int)(bufferAddress &  pDataFlash->pDevice->byte_mask)) >> 8) ;
360                 pDataFlash->pDataFlashDesc->command[3] = (unsigned char)((unsigned int)bufferAddress  & 0x00FF) ;
361                 pDataFlash->pDataFlashDesc->command[4] = 0;
362                 cmdsize = 4;
363         }
364
365         pDataFlash->pDataFlashDesc->tx_cmd_pt    = pDataFlash->pDataFlashDesc->command ;
366         pDataFlash->pDataFlashDesc->tx_cmd_size = cmdsize ;
367         pDataFlash->pDataFlashDesc->rx_cmd_pt    = pDataFlash->pDataFlashDesc->command ;
368         pDataFlash->pDataFlashDesc->rx_cmd_size = cmdsize ;
369
370         pDataFlash->pDataFlashDesc->rx_data_pt  = dataBuffer ;
371         pDataFlash->pDataFlashDesc->tx_data_pt  = dataBuffer ;
372         pDataFlash->pDataFlashDesc->rx_data_size        = SizeToWrite ;
373         pDataFlash->pDataFlashDesc->tx_data_size        = SizeToWrite ;
374
375         return AT91F_SpiWrite(pDataFlash->pDataFlashDesc);
376 }
377
378 /*------------------------------------------------------------------------------*/
379 /* Function Name       : AT91F_PageErase                                        */
380 /* Object              : Erase a page                                           */
381 /* Input Parameters    : DataFlash Service                                      */
382 /*                     : Page concerned                                         */
383 /*                     :                                                        */
384 /* Return value         : State of the dataflash                                */
385 /*------------------------------------------------------------------------------*/
386 AT91S_DataFlashStatus AT91F_PageErase(
387         AT91PS_DataFlash pDataFlash,
388         unsigned int page)
389 {
390         int cmdsize;
391         /* Test if the buffer command is legal */
392         /* no data to transmit or receive */
393         pDataFlash->pDataFlashDesc->tx_data_size = 0;
394
395         cmdsize = 4;
396         if (pDataFlash->pDevice->pages_number >= 16384)
397                 cmdsize = 5;
398         return(AT91F_DataFlashSendCommand (pDataFlash, DB_PAGE_ERASE, cmdsize, page*pDataFlash->pDevice->pages_size));
399 }
400
401
402 /*------------------------------------------------------------------------------*/
403 /* Function Name       : AT91F_BlockErase                                       */
404 /* Object              : Erase a Block                                          */
405 /* Input Parameters    : DataFlash Service                                      */
406 /*                     : Page concerned                                         */
407 /*                     :                                                        */
408 /* Return value         : State of the dataflash                                */
409 /*------------------------------------------------------------------------------*/
410 AT91S_DataFlashStatus AT91F_BlockErase(
411         AT91PS_DataFlash pDataFlash,
412         unsigned int block)
413 {
414         int cmdsize;
415         /* Test if the buffer command is legal */
416         /* no data to transmit or receive */
417         pDataFlash->pDataFlashDesc->tx_data_size = 0;
418         cmdsize = 4;
419         if (pDataFlash->pDevice->pages_number >= 16384)
420                 cmdsize = 5;
421         return(AT91F_DataFlashSendCommand (pDataFlash, DB_BLOCK_ERASE,cmdsize, block*8*pDataFlash->pDevice->pages_size));
422 }
423
424 /*------------------------------------------------------------------------------*/
425 /* Function Name       : AT91F_WriteBufferToMain                                */
426 /* Object              : Write buffer to the main memory                        */
427 /* Input Parameters    : DataFlash Service                                      */
428 /*              : <BufferCommand> = command to send to buffer1 or buffer2       */
429 /*                     : <dest> = main memory address                           */
430 /* Return value         : State of the dataflash                                */
431 /*------------------------------------------------------------------------------*/
432 AT91S_DataFlashStatus AT91F_WriteBufferToMain (
433         AT91PS_DataFlash pDataFlash,
434         unsigned char BufferCommand,
435         unsigned int dest )
436 {
437         int cmdsize;
438         /* Test if the buffer command is correct */
439         if ((BufferCommand != DB_BUF1_PAGE_PGM) &&
440             (BufferCommand != DB_BUF1_PAGE_ERASE_PGM) &&
441             (BufferCommand != DB_BUF2_PAGE_PGM) &&
442             (BufferCommand != DB_BUF2_PAGE_ERASE_PGM) )
443                 return DATAFLASH_BAD_COMMAND;
444
445         /* no data to transmit or receive */
446         pDataFlash->pDataFlashDesc->tx_data_size = 0;
447
448         cmdsize = 4;
449         if (pDataFlash->pDevice->pages_number >= 16384)
450                 cmdsize = 5;
451         /* Send the command to the dataflash */
452         return(AT91F_DataFlashSendCommand (pDataFlash, BufferCommand, cmdsize, dest));
453 }
454
455
456 /*------------------------------------------------------------------------------*/
457 /* Function Name       : AT91F_PartialPageWrite                                 */
458 /* Object              : Erase partielly a page                                 */
459 /* Input Parameters    : <page> = page number                                   */
460 /*                      : <AdrInpage> = adr to begin the fading                 */
461 /*                     : <length> = Number of bytes to erase                    */
462 /*------------------------------------------------------------------------------*/
463 AT91S_DataFlashStatus AT91F_PartialPageWrite (
464         AT91PS_DataFlash pDataFlash,
465         unsigned char *src,
466         unsigned int dest,
467         unsigned int size)
468 {
469         unsigned int page;
470         unsigned int AdrInPage;
471
472         page = dest / (pDataFlash->pDevice->pages_size);
473         AdrInPage = dest % (pDataFlash->pDevice->pages_size);
474
475         /* Read the contents of the page in the Sram Buffer */
476         AT91F_MainMemoryToBufferTransfert(pDataFlash, DB_PAGE_2_BUF1_TRF, page);
477         AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, AT91C_TIMEOUT_WRDY);
478         /*Update the SRAM buffer */
479         AT91F_DataFlashWriteBuffer(pDataFlash, DB_BUF1_WRITE, src, AdrInPage, size);
480
481         AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, AT91C_TIMEOUT_WRDY);
482
483         /* Erase page if a 128 Mbits device */
484         if (pDataFlash->pDevice->pages_number >= 16384) {
485                 AT91F_PageErase(pDataFlash, page);
486                 /* Rewrite the modified Sram Buffer in the main memory */
487                 AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, AT91C_TIMEOUT_WRDY);
488         }
489
490         /* Rewrite the modified Sram Buffer in the main memory */
491         return(AT91F_WriteBufferToMain(pDataFlash, DB_BUF1_PAGE_ERASE_PGM, (page*pDataFlash->pDevice->pages_size)));
492 }
493
494
495 /*------------------------------------------------------------------------------*/
496 /* Function Name       : AT91F_DataFlashWrite                                   */
497 /* Object              :                                                        */
498 /* Input Parameters    : <*src> = Source buffer                                 */
499 /*                     : <dest> = dataflash adress                              */
500 /*                     : <size> = data buffer size                              */
501 /*------------------------------------------------------------------------------*/
502 AT91S_DataFlashStatus AT91F_DataFlashWrite(
503         AT91PS_DataFlash pDataFlash,
504         unsigned char *src,
505         int dest,
506         int size )
507 {
508         unsigned int length;
509         unsigned int page;
510         unsigned int status;
511
512         AT91F_SpiEnable(pDataFlash->pDevice->cs);
513
514         if ( (dest + size) > (pDataFlash->pDevice->pages_size * (pDataFlash->pDevice->pages_number)))
515                 return DATAFLASH_MEMORY_OVERFLOW;
516
517         /* If destination does not fit a page start address */
518         if ((dest % ((unsigned int)(pDataFlash->pDevice->pages_size)))  != 0 ) {
519                 length = pDataFlash->pDevice->pages_size - (dest % ((unsigned int)(pDataFlash->pDevice->pages_size)));
520
521                 if (size < length)
522                         length = size;
523
524                 if(!AT91F_PartialPageWrite(pDataFlash,src, dest, length))
525                         return DATAFLASH_ERROR;
526
527                 AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, AT91C_TIMEOUT_WRDY);
528
529                 /* Update size, source and destination pointers */
530                 size -= length;
531                 dest += length;
532                 src += length;
533         }
534
535         while (( size - pDataFlash->pDevice->pages_size ) >= 0 ) {
536                 /* program dataflash page */
537                 page = (unsigned int)dest / (pDataFlash->pDevice->pages_size);
538
539                 status = AT91F_DataFlashWriteBuffer(pDataFlash, DB_BUF1_WRITE, src, 0, pDataFlash->pDevice->pages_size);
540                 AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, AT91C_TIMEOUT_WRDY);
541
542                 status = AT91F_PageErase(pDataFlash, page);
543                 AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, AT91C_TIMEOUT_WRDY);
544                 if (!status)
545                         return DATAFLASH_ERROR;
546
547                 status = AT91F_WriteBufferToMain (pDataFlash, DB_BUF1_PAGE_PGM, dest);
548                 if(!status)
549                         return DATAFLASH_ERROR;
550
551                 AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, AT91C_TIMEOUT_WRDY);
552
553                 /* Update size, source and destination pointers */
554                 size -= pDataFlash->pDevice->pages_size ;
555                 dest += pDataFlash->pDevice->pages_size ;
556                 src  += pDataFlash->pDevice->pages_size ;
557         }
558
559         /* If still some bytes to read */
560         if ( size > 0 ) {
561                 /* program dataflash page */
562                 if(!AT91F_PartialPageWrite(pDataFlash, src, dest, size) )
563                         return DATAFLASH_ERROR;
564
565                 AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, AT91C_TIMEOUT_WRDY);
566         }
567         return DATAFLASH_OK;
568 }
569
570
571 /*------------------------------------------------------------------------------*/
572 /* Function Name       : AT91F_DataFlashRead                                    */
573 /* Object              : Read a block in dataflash                              */
574 /* Input Parameters    :                                                        */
575 /* Return value         :                                                       */
576 /*------------------------------------------------------------------------------*/
577 int AT91F_DataFlashRead(
578         AT91PS_DataFlash pDataFlash,
579         unsigned long addr,
580         unsigned long size,
581         char *buffer)
582 {
583         unsigned long SizeToRead;
584
585         AT91F_SpiEnable(pDataFlash->pDevice->cs);
586
587         if(AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, AT91C_TIMEOUT_WRDY) != DATAFLASH_OK)
588                 return -1;
589
590         while (size) {
591                 SizeToRead = (size < 0x8000)? size:0x8000;
592
593                 if (AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, AT91C_TIMEOUT_WRDY) != DATAFLASH_OK)
594                         return -1;
595
596                 if (AT91F_DataFlashContinuousRead (pDataFlash, addr, (uchar *)buffer, SizeToRead) != DATAFLASH_OK)
597                         return -1;
598
599                 size -= SizeToRead;
600                 addr += SizeToRead;
601                 buffer += SizeToRead;
602         }
603
604         return DATAFLASH_OK;
605 }
606
607
608 /*------------------------------------------------------------------------------*/
609 /* Function Name       : AT91F_DataflashProbe                                   */
610 /* Object              :                                                        */
611 /* Input Parameters    :                                                        */
612 /* Return value        : Dataflash status register                              */
613 /*------------------------------------------------------------------------------*/
614 int AT91F_DataflashProbe(int cs, AT91PS_DataflashDesc pDesc)
615 {
616         AT91F_SpiEnable(cs);
617         AT91F_DataFlashGetStatus(pDesc);
618         return((pDesc->command[1] == 0xFF)? 0: pDesc->command[1] & 0x3C);
619 }
620
621 #endif