]>
Commit | Line | Data |
---|---|---|
2abbe075 WD |
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 | ||
8b07a110 WD |
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 | ||
5779d8d9 | 36 | #define AT91C_TIMEOUT_WRDY 200000 |
2abbe075 WD |
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 | ||
8bde7f77 | 56 | /* Configure SPI in Master Mode with No CS selected !!! */ |
2abbe075 WD |
57 | AT91C_BASE_SPI->SPI_MR = AT91C_SPI_MSTR | AT91C_SPI_MODFDIS | AT91C_SPI_PCS; |
58 | ||
59 | /* Configure CS0 and CS3 */ | |
8b07a110 WD |
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); | |
2abbe075 | 62 | |
8b07a110 WD |
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); | |
2abbe075 WD |
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 | { | |
8bde7f77 | 96 | unsigned int timeout; |
2abbe075 WD |
97 | |
98 | pDesc->state = BUSY; | |
99 | ||
8bde7f77 | 100 | AT91C_BASE_SPI->SPI_PTCR = AT91C_PDC_TXTDIS + AT91C_PDC_RXTDIS; |
2abbe075 | 101 | |
8bde7f77 WD |
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 ; | |
2abbe075 | 105 | |
8bde7f77 WD |
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; | |
2abbe075 WD |
109 | |
110 | if ( pDesc->tx_data_size != 0 ) { | |
8bde7f77 WD |
111 | /* Initialize the Next Transmit and Next Receive Pointer */ |
112 | AT91C_BASE_SPI->SPI_RNPR = (unsigned int)pDesc->rx_data_pt ; | |
2abbe075 WD |
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 ; | |
8bde7f77 WD |
117 | AT91C_BASE_SPI->SPI_TNCR = pDesc->tx_data_size ; |
118 | } | |
2abbe075 | 119 | |
8bde7f77 | 120 | /* arm simple, non interrupt dependent timer */ |
2abbe075 WD |
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)); | |
8bde7f77 WD |
126 | AT91C_BASE_SPI->SPI_PTCR = AT91C_PDC_TXTDIS + AT91C_PDC_RXTDIS; |
127 | pDesc->state = IDLE; | |
2abbe075 WD |
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; | |
5779d8d9 WD |
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 | } | |
2abbe075 WD |
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; | |
8bde7f77 WD |
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); | |
2abbe075 WD |
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--; | |
5779d8d9 | 225 | } while( ((pDataFlashDesc->DataFlash_state & 0x80) != 0x80) && (timeout > 0) ); |
2abbe075 WD |
226 | |
227 | if((pDataFlashDesc->DataFlash_state & 0x80) != 0x80) | |
228 | return DATAFLASH_ERROR; | |
229 | ||
230 | return DATAFLASH_OK; | |
231 | } | |
232 | ||
233 | ||
2abbe075 WD |
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 ( | |
8bde7f77 | 244 | AT91PS_DataFlash pDataFlash, |
2abbe075 WD |
245 | int src, |
246 | unsigned char *dataBuffer, | |
247 | int sizeToRead ) | |
248 | { | |
5779d8d9 | 249 | AT91S_DataFlashStatus status; |
2abbe075 WD |
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 | ||
5779d8d9 | 259 | status = AT91F_DataFlashSendCommand (pDataFlash, DB_CONTINUOUS_ARRAY_READ, 8, src); |
2abbe075 | 260 | /* Send the command to the dataflash */ |
5779d8d9 | 261 | return(status); |
2abbe075 WD |
262 | } |
263 | ||
264 | ||
2abbe075 WD |
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 | { | |
5779d8d9 | 280 | int cmdsize; |
2abbe075 WD |
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 | ||
5779d8d9 | 286 | cmdsize = 4; |
2abbe075 | 287 | /* Send the command to the dataflash */ |
5779d8d9 WD |
288 | if (pDataFlash->pDevice->pages_number >= 16384) |
289 | cmdsize = 5; | |
290 | return(AT91F_DataFlashSendCommand (pDataFlash, DB_PAGE_PGM_BUF1, cmdsize, dest)); | |
2abbe075 WD |
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 | { | |
5779d8d9 | 307 | int cmdsize; |
2abbe075 WD |
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 */ | |
8bde7f77 | 313 | pDataFlash->pDataFlashDesc->tx_data_size = 0; |
5779d8d9 WD |
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)); | |
2abbe075 WD |
318 | } |
319 | ||
320 | ||
2abbe075 WD |
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 | { | |
5779d8d9 | 338 | int cmdsize; |
2abbe075 WD |
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 | ||
8bde7f77 WD |
350 | /* Send first Write Command */ |
351 | pDataFlash->pDataFlashDesc->command[0] = BufferCommand; | |
2abbe075 | 352 | pDataFlash->pDataFlashDesc->command[1] = 0; |
5779d8d9 WD |
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 | } | |
2abbe075 | 364 | |
8bde7f77 | 365 | pDataFlash->pDataFlashDesc->tx_cmd_pt = pDataFlash->pDataFlashDesc->command ; |
5779d8d9 | 366 | pDataFlash->pDataFlashDesc->tx_cmd_size = cmdsize ; |
8bde7f77 | 367 | pDataFlash->pDataFlashDesc->rx_cmd_pt = pDataFlash->pDataFlashDesc->command ; |
5779d8d9 | 368 | pDataFlash->pDataFlashDesc->rx_cmd_size = cmdsize ; |
2abbe075 | 369 | |
8bde7f77 WD |
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 ; | |
2abbe075 | 374 | |
8bde7f77 | 375 | return AT91F_SpiWrite(pDataFlash->pDataFlashDesc); |
2abbe075 WD |
376 | } |
377 | ||
5779d8d9 WD |
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 | } | |
2abbe075 WD |
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 | { | |
5779d8d9 | 437 | int cmdsize; |
2abbe075 WD |
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 | ||
5779d8d9 WD |
448 | cmdsize = 4; |
449 | if (pDataFlash->pDevice->pages_number >= 16384) | |
450 | cmdsize = 5; | |
2abbe075 | 451 | /* Send the command to the dataflash */ |
5779d8d9 | 452 | return(AT91F_DataFlashSendCommand (pDataFlash, BufferCommand, cmdsize, dest)); |
2abbe075 WD |
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); | |
5779d8d9 | 477 | AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, AT91C_TIMEOUT_WRDY); |
2abbe075 WD |
478 | /*Update the SRAM buffer */ |
479 | AT91F_DataFlashWriteBuffer(pDataFlash, DB_BUF1_WRITE, src, AdrInPage, size); | |
5779d8d9 WD |
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 | } | |
2abbe075 WD |
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 | ||
2abbe075 | 495 | /*------------------------------------------------------------------------------*/ |
5779d8d9 | 496 | /* Function Name : AT91F_DataFlashWrite */ |
2abbe075 WD |
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; | |
5779d8d9 WD |
509 | unsigned int page; |
510 | unsigned int status; | |
2abbe075 WD |
511 | |
512 | AT91F_SpiEnable(pDataFlash->pDevice->cs); | |
513 | ||
8bde7f77 | 514 | if ( (dest + size) > (pDataFlash->pDevice->pages_size * (pDataFlash->pDevice->pages_number))) |
2abbe075 WD |
515 | return DATAFLASH_MEMORY_OVERFLOW; |
516 | ||
8bde7f77 WD |
517 | /* If destination does not fit a page start address */ |
518 | if ((dest % ((unsigned int)(pDataFlash->pDevice->pages_size))) != 0 ) { | |
2abbe075 WD |
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 | ||
5779d8d9 | 527 | AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, AT91C_TIMEOUT_WRDY); |
2abbe075 WD |
528 | |
529 | /* Update size, source and destination pointers */ | |
8bde7f77 WD |
530 | size -= length; |
531 | dest += length; | |
532 | src += length; | |
533 | } | |
2abbe075 | 534 | |
8bde7f77 | 535 | while (( size - pDataFlash->pDevice->pages_size ) >= 0 ) { |
2abbe075 | 536 | /* program dataflash page */ |
5779d8d9 WD |
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) | |
2abbe075 WD |
549 | return DATAFLASH_ERROR; |
550 | ||
5779d8d9 | 551 | AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, AT91C_TIMEOUT_WRDY); |
2abbe075 WD |
552 | |
553 | /* Update size, source and destination pointers */ | |
8bde7f77 WD |
554 | size -= pDataFlash->pDevice->pages_size ; |
555 | dest += pDataFlash->pDevice->pages_size ; | |
556 | src += pDataFlash->pDevice->pages_size ; | |
557 | } | |
2abbe075 | 558 | |
8bde7f77 WD |
559 | /* If still some bytes to read */ |
560 | if ( size > 0 ) { | |
2abbe075 WD |
561 | /* program dataflash page */ |
562 | if(!AT91F_PartialPageWrite(pDataFlash, src, dest, size) ) | |
563 | return DATAFLASH_ERROR; | |
564 | ||
5779d8d9 | 565 | AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, AT91C_TIMEOUT_WRDY); |
2abbe075 | 566 | } |
8bde7f77 | 567 | return DATAFLASH_OK; |
2abbe075 WD |
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 | ||
5779d8d9 | 587 | if(AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, AT91C_TIMEOUT_WRDY) != DATAFLASH_OK) |
2abbe075 WD |
588 | return -1; |
589 | ||
590 | while (size) { | |
591 | SizeToRead = (size < 0x8000)? size:0x8000; | |
592 | ||
5779d8d9 | 593 | if (AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, AT91C_TIMEOUT_WRDY) != DATAFLASH_OK) |
2abbe075 WD |
594 | return -1; |
595 | ||
d52fb7e3 | 596 | if (AT91F_DataFlashContinuousRead (pDataFlash, addr, (uchar *)buffer, SizeToRead) != DATAFLASH_OK) |
2abbe075 WD |
597 | return -1; |
598 | ||
599 | size -= SizeToRead; | |
600 | addr += SizeToRead; | |
601 | buffer += SizeToRead; | |
602 | } | |
603 | ||
8bde7f77 | 604 | return DATAFLASH_OK; |
2abbe075 WD |
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); | |
8bde7f77 WD |
617 | AT91F_DataFlashGetStatus(pDesc); |
618 | return((pDesc->command[1] == 0xFF)? 0: pDesc->command[1] & 0x3C); | |
2abbe075 WD |
619 | } |
620 | ||
621 | #endif |