projects / openwrt / svn-archive / archive.git / blob
? search:


b0d5baf03fdd3c8c523f4080c7df590d6df7ee00
[openwrt/svn-archive/archive.git] / target / linux / at91-2.6 / image / romboot / patches / 003-SD-reflash.patch
1 diff -urN romboot.old/init.cpp romboot/init.cpp
2 --- romboot.old/init.cpp 2007-03-24 13:34:19.000000000 +0100
3 +++ romboot/init.cpp 2007-03-24 12:23:19.000000000 +0100
4 @@ -207,9 +207,10 @@
5 AT91F_US_EnableRx((AT91PS_USART)AT91C_BASE_DBGU);
6
7 /* Enable PIO to access the LEDs */
8 - AT91C_BASE_PIOB->PIO_PER = AT91C_PIO_PB2;
9 - AT91C_BASE_PIOB->PIO_OER = AT91C_PIO_PB2;
10 - AT91C_BASE_PIOB->PIO_CODR = AT91C_PIO_PB2;
11 + AT91C_BASE_PIOC->PIO_PER = AT91C_PIO_PC7 | AT91C_PIO_PC8 | AT91C_PIO_PC14 | AT91C_PIO_PC15;
12 + AT91C_BASE_PIOC->PIO_OER = AT91C_PIO_PC7 | AT91C_PIO_PC8 | AT91C_PIO_PC14 | AT91C_PIO_PC15;
13 + AT91C_BASE_PIOC->PIO_CODR = AT91C_PIO_PC7 | AT91C_PIO_PC15;
14 + AT91C_BASE_PIOC->PIO_SODR = AT91C_PIO_PC8 | AT91C_PIO_PC14;
15
16 // AT91F_DBGU_Printk("\n\rAT91F_LowLevelInit(): Debug channel initialized\n\r");
17 }
18 diff -urN romboot.old/main.cpp romboot/main.cpp
19 --- romboot.old/main.cpp 2007-03-24 13:34:19.000000000 +0100
20 +++ romboot/main.cpp 2007-03-24 12:28:55.000000000 +0100
21 @@ -13,6 +13,7 @@
22 //*----------------------------------------------------------------------------
23 #include <AT91RM9200.h>
24 #include <lib_AT91RM9200.h>
25 +#include <AT91C_MCI_Device.h>
26
27 #include "com.h"
28 #include "main.h"
29 @@ -39,16 +40,31 @@
30 extern void AT91F_DBGU_Printk(char *);
31 extern "C" void AT91F_ST_ASM_Handler(void);
32 extern "C" void Jump(unsigned int addr);
33 -extern int mci_main(void);
34 +extern int AT91F_MCI_Init(void);
35 +#define TRUE 1
36 +#define FALSE 0
37 +
38 +/* from trxhdr.h */
39 +
40 +#define TRX_MAGIC 0x30524448 /* "HDR0" */
41 +#define TRX_VERSION 1
42 +
43 +struct trx_header {
44 + unsigned int magic;
45 + unsigned int len;
46 + unsigned int crc32;
47 + unsigned int flag_version;
48 + unsigned int offsets[3];
49 +};
50
51 //const char *menu_separ = "*----------------------------------------*\n\r";
52
53 const char *menu_dataflash = {
54 - "1: DL DF [ad]\n\r"
55 - "2: RD DF [ad]\n\r"
56 - "3: CP SD\n\r"
57 - "4: U-BOOT\n\r"
58 - "5: RM BL in DF\n\r"
59 + "1: Download DF [addr]\n\r"
60 + "2: Read DF [addr]\n\r"
61 + "3: Copy SD-Card\n\r"
62 + "4: Start U-BOOT\n\r"
63 + "5: Clear bootloder\n\r"
64 };
65
66 //* Globales variables
67 @@ -155,14 +171,15 @@
68 //*-----------------------------------------------------------------------------
69 void AT91F_DisplayMenu(void)
70 {
71 - printf("\n\rFDL SD-Card LOADER %s %s %s\n\r", AT91C_VERSION, __DATE__, __TIME__);
72 -// printf(menu_separ);
73 - AT91F_DataflashPrintInfo();
74 -// printf(menu_separ);
75 printf(menu_dataflash);
76 -// printf(menu_separ);
77 }
78
79 +void AT91F_DisplayIntro(void)
80 +{
81 + printf("\n\rFDL LOADER %s %s %s\n\r", AT91C_VERSION, __DATE__, __TIME__);
82 + AT91F_DataflashPrintInfo();
83 +}
84 +
85 //*-----------------------------------------------------------------------------
86 //* Function Name : AsciiToHex()
87 //* Object : ascii to hexa conversion
88 @@ -311,23 +328,24 @@
89 AT91F_SetPLL();
90 }
91
92 -/*void LedCode(void)
93 +/*
94 +void LedCode(void)
95 {
96 int *pRegister;
97 pRegister = (int *)0xFFFFF800; // Enable port C peripheral reg
98 - *pRegister = 0x3c00;
99 + *pRegister = (AT91C_PIO_PC7 | AT91C_PIO_PC8 | AT91C_PIO_PC14 | AT91C_PIO_PC15);
100 pRegister = (int *)0xFFFFF810; // Output Enable reg
101 - *pRegister = 0x3c00;
102 + *pRegister = (AT91C_PIO_PC7 | AT91C_PIO_PC8 | AT91C_PIO_PC14 | AT91C_PIO_PC15);
103 pRegister = (int *)0xFFFFF830; // Set data
104 - *pRegister = 0x1400;
105 + *pRegister = AT91C_PIO_PC7 | AT91C_PIO_PC15;
106 pRegister = (int *)0xFFFFF834; // Clear bits
107 - *pRegister = 0x2800;
108 + *pRegister = AT91C_PIO_PC8 | AT91C_PIO_PC14;
109 }
110 */
111
112 +
113 void AT91F_StartUboot(unsigned int dummy, void *pvoid)
114 {
115 - //printf("Load U-BOOT from dataflash[%x] to SDRAM[%x]\n\r", AT91C_UBOOT_DATAFLASH_ADDR, AT91C_UBOOT_ADDR);
116 read_dataflash(AT91C_UBOOT_DATAFLASH_ADDR, AT91C_UBOOT_SIZE, (char *)(AT91C_UBOOT_ADDR));
117 //printf("Set PLLA to 180Mhz and Master clock to 60Mhz and start U-BOOT\n\r");
118 //* Reset registers
119 @@ -337,6 +355,67 @@
120 while(1);
121 }
122
123 +#define AT91C_MCI_TIMEOUT 1000000
124 +
125 +extern AT91S_MciDevice MCI_Device;
126 +
127 +extern void AT91F_MCIDeviceWaitReady(unsigned int);
128 +extern int AT91F_MCI_ReadBlockSwab(AT91PS_MciDevice, int, unsigned int *, int);
129 +
130 +
131 +int Program_From_MCI(void)
132 +{
133 + int i;
134 + unsigned int Max_Read_DataBlock_Length;
135 + int block = 0;
136 + int buffer = AT91C_DOWNLOAD_BASE_ADDRESS;
137 + int bufpos = AT91C_DOWNLOAD_BASE_ADDRESS;
138 + int NbPage = 0;
139 + struct trx_header *p;
140 + unsigned int data;
141 +
142 + p = (struct trx_header *)bufpos;
143 +
144 + Max_Read_DataBlock_Length = MCI_Device.pMCI_DeviceFeatures->Max_Read_DataBlock_Length;
145 +
146 + AT91F_MCIDeviceWaitReady(AT91C_MCI_TIMEOUT);
147 +
148 + AT91F_MCI_ReadBlockSwab(&MCI_Device, block*Max_Read_DataBlock_Length, (unsigned int *)bufpos, Max_Read_DataBlock_Length);
149 +
150 + if (p->magic != TRX_MAGIC)
151 + return FALSE;
152 +
153 + printf("Read SD-Card\n\r");
154 + AT91C_BASE_PIOC->PIO_CODR = AT91C_PIO_PC7 | AT91C_PIO_PC15 | AT91C_PIO_PC8 | AT91C_PIO_PC14;
155 + for (i=0; i<(p->len/512); i++) {
156 + AT91F_MCI_ReadBlockSwab(&MCI_Device, block*Max_Read_DataBlock_Length, (unsigned int *)bufpos, Max_Read_DataBlock_Length);
157 + block++;
158 + bufpos += Max_Read_DataBlock_Length;
159 + }
160 +
161 + NbPage = 0;
162 + i = dataflash_info[0].Device.pages_number;
163 + while(i >>= 1)
164 + NbPage++;
165 + i = ((p->offsets[1] - p->offsets[0])/ 512) + 1 + (NbPage << 13) + (dataflash_info[0].Device.pages_size << 17);
166 + *(int *)(buffer + p->offsets[0] + AT91C_OFFSET_VECT6) = i;
167 +
168 + printf("Write romboot\n\r");
169 + AT91C_BASE_PIOC->PIO_CODR = AT91C_PIO_PC7 | AT91C_PIO_PC15 | AT91C_PIO_PC14;
170 + AT91C_BASE_PIOC->PIO_SODR = AT91C_PIO_PC8;
171 + write_dataflash(0xc0000000, buffer + p->offsets[0], p->offsets[1] - p->offsets[0]);
172 + printf("Write u-boot\n\r");
173 + AT91C_BASE_PIOC->PIO_CODR = AT91C_PIO_PC7 | AT91C_PIO_PC15;
174 + AT91C_BASE_PIOC->PIO_SODR = AT91C_PIO_PC8 | AT91C_PIO_PC14;
175 + write_dataflash(0xc0008000, buffer + p->offsets[1], p->offsets[2] - p->offsets[1]);
176 + printf("Write knl/root\n\r");
177 + AT91C_BASE_PIOC->PIO_CODR = AT91C_PIO_PC8 | AT91C_PIO_PC15;
178 + AT91C_BASE_PIOC->PIO_SODR = AT91C_PIO_PC7 | AT91C_PIO_PC14;
179 + write_dataflash(0xc0042000, buffer + p->offsets[2], p->len - p->offsets[2]);
180 + AT91C_BASE_PIOC->PIO_CODR = AT91C_PIO_PC8 | AT91C_PIO_PC14;
181 + AT91C_BASE_PIOC->PIO_SODR = AT91C_PIO_PC7 | AT91C_PIO_PC15;
182 + return TRUE;
183 + }
184
185 //*----------------------------------------------------------------------------
186 //* Function Name : main
187 @@ -357,6 +436,7 @@
188 unsigned int crc1 = 0, crc2 = 0;
189 volatile int device;
190 int NbPage;
191 + int mci_present;
192
193 stdin = fopen(0, at91_dbgu_getc);
194 stdout = fopen(at91_dbgu_putc, 0);
195 @@ -387,6 +467,15 @@
196
197 // DataFlash on SPI Configuration
198 AT91F_DataflashInit ();
199 + AT91F_DisplayIntro();
200 + mci_present = AT91F_MCI_Init();
201 +
202 +#ifdef PRODTEST
203 + if (mci_present) {
204 + Program_From_MCI();
205 + AT91F_StartUboot(0, (void *)0);
206 + }
207 +#endif
208
209 // start tempo to start Uboot in a delay of 1 sec if no key pressed
210 svcUbootTempo.Start(&svcUbootTempo, 1000, 0, AT91F_StartUboot, (void *)0);
211 @@ -396,7 +485,7 @@
212
213 // stop tempo
214 svcUbootTempo.Stop(&svcUbootTempo);
215 -
216 +
217 while(1) {
218 while(command == 0) {
219 AddressToDownload = AT91C_DOWNLOAD_BASE_ADDRESS;
220 @@ -444,7 +533,8 @@
221 #endif
222
223 case '3':
224 - mci_main();
225 + if (mci_present)
226 + Program_From_MCI();
227 command=0;
228 break;
229
230 @@ -461,7 +551,6 @@
231 *i = 0;
232 }
233 write_dataflash(0xc0000000, 0x20000000, 0x4000);
234 - printf("BL CLR\r\n");
235 command = 0;
236 break;
237
238 diff -urN romboot.old/main.h romboot/main.h
239 --- romboot.old/main.h 2007-03-24 13:34:19.000000000 +0100
240 +++ romboot/main.h 2007-03-23 19:06:52.000000000 +0100
241 @@ -27,7 +27,7 @@
242
243 #define AT91C_OFFSET_VECT6 0x14 //* Offset for ARM vector 6
244
245 -#define AT91C_VERSION "VER 1.02"
246 +#define AT91C_VERSION "VER 1.03"
247 // Global variables and functions definition
248 extern unsigned int GetTickCount(void);
249 #endif
250 diff -urN romboot.old/Makefile romboot/Makefile
251 --- romboot.old/Makefile 2007-03-24 13:34:19.000000000 +0100
252 +++ romboot/Makefile 2007-03-24 10:45:38.000000000 +0100
253 @@ -1,12 +1,17 @@
254 LINKFLAGS= -T elf32-littlearm.lds -Ttext 0
255 COMPILEFLAGS= -Os
256 TARGET=romboot
257 +TARGET2=rbptest
258 +
259 OBJFILES=cstartup_ram.o asm_isr.o asm_mci_isr.o jump.o at45.o com.o dataflash.o \
260 - mci_device.o mci_main.o init.o main.o stdio.o _udivsi3.o _umodsi3.o div0.o
261 + mci_device.o init.o main.o stdio.o _udivsi3.o _umodsi3.o div0.o
262 +OBJFILES2=cstartup_ram.o asm_isr.o asm_mci_isr.o jump.o at45.o com.o dataflash.o \
263 + mci_device.o init.o ptmain.o stdio.o _udivsi3.o _umodsi3.o div0.o
264 +
265 LIBRARIES=
266 INCLUDES= -Iinclude
267
268 -all:$(TARGET)
269 +all:$(TARGET) $(TARGET2)
270
271 $(TARGET): $(OBJFILES)
272 $(LD) $(OBJFILES) -o $(TARGET).out $(LINKFLAGS) -n
273 @@ -14,6 +19,12 @@
274 $(OBJDUMP) -h -s $(TARGET).out > $(TARGET).lss
275 $(NM) -n $(TARGET).out | grep -v '\( [aUw] \)\|\(__crc_\)\|\( \$[adt]\)' > $(TARGET).map
276
277 +$(TARGET2): $(OBJFILES2)
278 + $(LD) $(OBJFILES2) -o $(TARGET2).out $(LINKFLAGS) -n
279 + $(OBJCOPY) $(TARGET2).out -O binary $(TARGET2).bin
280 + $(OBJDUMP) -h -s $(TARGET2).out > $(TARGET2).lss
281 + $(NM) -n $(TARGET2).out | grep -v '\( [aUw] \)\|\(__crc_\)\|\( \$[adt]\)' > $(TARGET2).map
282 +
283 asm_isr.o: asm_isr.S
284 $(CC) -c -Iinclude -o $@ $<
285
286 @@ -32,6 +43,12 @@
287 _umodsi3.o: _umodsi3.S
288 $(CC) -c $<
289
290 +main.o: main.cpp
291 + $(CC) -c $(COMPILEFLAGS) $(INCLUDES) -o main.o $<
292 +
293 +ptmain.o: main.cpp
294 + $(CC) -c $(COMPILEFLAGS) $(INCLUDES) -D PRODTEST -o ptmain.o $<
295 +
296 #%.o: %.S
297 # $(CC) -c $(INCLUDES) -o $@ $<
298
299 diff -urN romboot.old/mci_device.cpp romboot/mci_device.cpp
300 --- romboot.old/mci_device.cpp 2007-03-24 13:34:19.000000000 +0100
301 +++ romboot/mci_device.cpp 2007-03-24 11:23:38.000000000 +0100
302 @@ -16,14 +16,28 @@
303 #include <AT91C_MCI_Device.h>
304 #include "com.h"
305
306 -#define ENABLE_WRITE 1
307 +#define AT91C_MCI_TIMEOUT 1000000 /* For AT91F_MCIDeviceWaitReady */
308 +#define BUFFER_SIZE_MCI_DEVICE 512
309 +#define MASTER_CLOCK 60000000
310 +#define FALSE 0
311 +#define TRUE 1
312 +
313 +//* External Functions
314 +extern "C" void AT91F_ASM_MCI_Handler(void);
315 +extern "C" void AT91F_MCI_Device_Handler(AT91PS_MciDevice,unsigned int);
316 +//* Global Variables
317 +AT91S_MciDeviceFeatures MCI_Device_Features;
318 +AT91S_MciDeviceDesc MCI_Device_Desc;
319 +AT91S_MciDevice MCI_Device;
320 +
321 +#undef ENABLE_WRITE
322 #undef MMC
323
324 //*----------------------------------------------------------------------------
325 //* \fn AT91F_MCI_SendCommand
326 //* \brief Generic function to send a command to the MMC or SDCard
327 //*----------------------------------------------------------------------------
328 -AT91S_MCIDeviceStatus AT91F_MCI_SendCommand (
329 +int AT91F_MCI_SendCommand (
330 AT91PS_MciDevice pMCI_Device,
331 unsigned int Cmd,
332 unsigned int Arg)
333 @@ -63,7 +77,7 @@
334 //* \fn AT91F_MCI_SDCard_SendAppCommand
335 //* \brief Specific function to send a specific command to the SDCard
336 //*----------------------------------------------------------------------------
337 -AT91S_MCIDeviceStatus AT91F_MCI_SDCard_SendAppCommand (
338 +int AT91F_MCI_SDCard_SendAppCommand (
339 AT91PS_MciDevice pMCI_Device,
340 unsigned int Cmd_App,
341 unsigned int Arg )
342 @@ -98,7 +112,7 @@
343 //* \fn AT91F_MCI_GetStatus
344 //* \brief Addressed card sends its status register
345 //*----------------------------------------------------------------------------
346 -AT91S_MCIDeviceStatus AT91F_MCI_GetStatus(AT91PS_MciDevice pMCI_Device,unsigned int relative_card_address)
347 +int AT91F_MCI_GetStatus(AT91PS_MciDevice pMCI_Device,unsigned int relative_card_address)
348 {
349 if (AT91F_MCI_SendCommand(pMCI_Device,
350 AT91C_SEND_STATUS_CMD,
351 @@ -139,10 +153,25 @@
352 }
353
354 //*----------------------------------------------------------------------------
355 +//* \fn AT91F_MCI_Handler
356 +//* \brief MCI Handler
357 +//*----------------------------------------------------------------------------
358 +extern "C" void AT91F_MCI_Handler(void);
359 +
360 +void AT91F_MCI_Handler(void)
361 +{
362 + int status;
363 +
364 + status = ( AT91C_BASE_MCI->MCI_SR & AT91C_BASE_MCI->MCI_IMR );
365 +
366 + AT91F_MCI_Device_Handler(&MCI_Device,status);
367 +}
368 +
369 +//*----------------------------------------------------------------------------
370 //* \fn AT91F_MCI_ReadBlock
371 //* \brief Read an ENTIRE block or PARTIAL block
372 //*----------------------------------------------------------------------------
373 -AT91S_MCIDeviceStatus AT91F_MCI_ReadBlock(
374 +int AT91F_MCI_ReadBlock(
375 AT91PS_MciDevice pMCI_Device,
376 int src,
377 unsigned int *dataBuffer,
378 @@ -205,7 +234,7 @@
379 //* \fn AT91F_MCI_WriteBlock
380 //* \brief Write an ENTIRE block but not always PARTIAL block !!!
381 //*----------------------------------------------------------------------------
382 -AT91S_MCIDeviceStatus AT91F_MCI_WriteBlock(
383 +int AT91F_MCI_WriteBlock(
384 AT91PS_MciDevice pMCI_Device,
385 int dest,
386 unsigned int *dataBuffer,
387 @@ -268,7 +297,7 @@
388 //* \fn AT91F_MCI_MMC_SelectCard
389 //* \brief Toggles a card between the Stand_by and Transfer states or between Programming and Disconnect states
390 //*------------------------------------------------------------------------------------------------------------
391 -AT91S_MCIDeviceStatus AT91F_MCI_MMC_SelectCard(AT91PS_MciDevice pMCI_Device, unsigned int relative_card_address)
392 +int AT91F_MCI_MMC_SelectCard(AT91PS_MciDevice pMCI_Device, unsigned int relative_card_address)
393 {
394 int status;
395
396 @@ -302,7 +331,7 @@
397 //* \fn AT91F_MCI_GetCSD
398 //* \brief Asks to the specified card to send its CSD
399 //*----------------------------------------------------------------------------
400 -AT91S_MCIDeviceStatus AT91F_MCI_GetCSD (AT91PS_MciDevice pMCI_Device, unsigned int relative_card_address , unsigned int * response)
401 +int AT91F_MCI_GetCSD (AT91PS_MciDevice pMCI_Device, unsigned int relative_card_address , unsigned int * response)
402 {
403
404 if(AT91F_MCI_SendCommand(pMCI_Device,
405 @@ -322,7 +351,7 @@
406 //* \fn AT91F_MCI_SetBlocklength
407 //* \brief Select a block length for all following block commands (R/W)
408 //*----------------------------------------------------------------------------
409 -AT91S_MCIDeviceStatus AT91F_MCI_SetBlocklength(AT91PS_MciDevice pMCI_Device,unsigned int length)
410 +int AT91F_MCI_SetBlocklength(AT91PS_MciDevice pMCI_Device,unsigned int length)
411 {
412 return( AT91F_MCI_SendCommand(pMCI_Device, AT91C_SET_BLOCKLEN_CMD, length) );
413 }
414 @@ -332,7 +361,7 @@
415 //* \fn AT91F_MCI_MMC_GetAllOCR
416 //* \brief Asks to all cards to send their operations conditions
417 //*----------------------------------------------------------------------------
418 -AT91S_MCIDeviceStatus AT91F_MCI_MMC_GetAllOCR (AT91PS_MciDevice pMCI_Device)
419 +int AT91F_MCI_MMC_GetAllOCR (AT91PS_MciDevice pMCI_Device)
420 {
421 unsigned int response =0x0;
422
423 @@ -357,7 +386,7 @@
424 //* \fn AT91F_MCI_MMC_GetAllCID
425 //* \brief Asks to the MMC on the chosen slot to send its CID
426 //*----------------------------------------------------------------------------
427 -AT91S_MCIDeviceStatus AT91F_MCI_MMC_GetAllCID (AT91PS_MciDevice pMCI_Device, unsigned int *response)
428 +int AT91F_MCI_MMC_GetAllCID (AT91PS_MciDevice pMCI_Device, unsigned int *response)
429 {
430 int Nb_Cards_Found=-1;
431
432 @@ -391,7 +420,7 @@
433 //* \fn AT91F_MCI_MMC_Init
434 //* \brief Return the MMC initialisation status
435 //*----------------------------------------------------------------------------
436 -AT91S_MCIDeviceStatus AT91F_MCI_MMC_Init (AT91PS_MciDevice pMCI_Device)
437 +int AT91F_MCI_MMC_Init (AT91PS_MciDevice pMCI_Device)
438 {
439 unsigned int tab_response[4];
440 unsigned int mult,blocknr;
441 @@ -454,7 +483,7 @@
442 //* \fn AT91F_MCI_SDCard_GetOCR
443 //* \brief Asks to all cards to send their operations conditions
444 //*----------------------------------------------------------------------------
445 -AT91S_MCIDeviceStatus AT91F_MCI_SDCard_GetOCR (AT91PS_MciDevice pMCI_Device)
446 +int AT91F_MCI_SDCard_GetOCR (AT91PS_MciDevice pMCI_Device)
447 {
448 unsigned int response =0x0;
449
450 @@ -479,7 +508,7 @@
451 //* \fn AT91F_MCI_SDCard_GetCID
452 //* \brief Asks to the SDCard on the chosen slot to send its CID
453 //*----------------------------------------------------------------------------
454 -AT91S_MCIDeviceStatus AT91F_MCI_SDCard_GetCID (AT91PS_MciDevice pMCI_Device, unsigned int *response)
455 +int AT91F_MCI_SDCard_GetCID (AT91PS_MciDevice pMCI_Device, unsigned int *response)
456 {
457 if(AT91F_MCI_SendCommand(pMCI_Device,
458 AT91C_ALL_SEND_CID_CMD,
459 @@ -498,7 +527,7 @@
460 //* \fn AT91F_MCI_SDCard_SetBusWidth
461 //* \brief Set bus width for SDCard
462 //*----------------------------------------------------------------------------
463 -AT91S_MCIDeviceStatus AT91F_MCI_SDCard_SetBusWidth(AT91PS_MciDevice pMCI_Device)
464 +int AT91F_MCI_SDCard_SetBusWidth(AT91PS_MciDevice pMCI_Device)
465 {
466 volatile int ret_value;
467 char bus_width;
468 @@ -529,7 +558,7 @@
469 //* \fn AT91F_MCI_SDCard_Init
470 //* \brief Return the SDCard initialisation status
471 //*----------------------------------------------------------------------------
472 -AT91S_MCIDeviceStatus AT91F_MCI_SDCard_Init (AT91PS_MciDevice pMCI_Device)
473 +int AT91F_MCI_SDCard_Init (AT91PS_MciDevice pMCI_Device)
474 {
475 unsigned int tab_response[4];
476 unsigned int mult,blocknr;
477 @@ -567,7 +596,7 @@
478
479 pMCI_Device->pMCI_DeviceFeatures->Memory_Capacity = pMCI_Device->pMCI_DeviceFeatures->Max_Read_DataBlock_Length * blocknr;
480 //// End of Compute Memory Capacity
481 - printf("BLK 0x%x", pMCI_Device->pMCI_DeviceFeatures->Max_Read_DataBlock_Length);
482 + printf("SD-Card: %d Bytes\n\r", pMCI_Device->pMCI_DeviceFeatures->Memory_Capacity);
483
484 if( AT91F_MCI_SDCard_SetBusWidth(pMCI_Device) == AT91C_CMD_SEND_OK )
485 {
486 @@ -579,3 +608,141 @@
487 }
488 return AT91C_INIT_ERROR;
489 }
490 +
491 +//*----------------------------------------------------------------------------
492 +//* \fn AT91F_CfgDevice
493 +//* \brief This function is used to initialise MMC or SDCard Features
494 +//*----------------------------------------------------------------------------
495 +void AT91F_CfgDevice(void)
496 +{
497 + // Init Device Structure
498 +
499 + MCI_Device_Features.Relative_Card_Address = 0;
500 + MCI_Device_Features.Card_Inserted = AT91C_CARD_REMOVED;
501 + MCI_Device_Features.Max_Read_DataBlock_Length = 0;
502 + MCI_Device_Features.Max_Write_DataBlock_Length = 0;
503 + MCI_Device_Features.Read_Partial = 0;
504 + MCI_Device_Features.Write_Partial = 0;
505 + MCI_Device_Features.Erase_Block_Enable = 0;
506 + MCI_Device_Features.Sector_Size = 0;
507 + MCI_Device_Features.Memory_Capacity = 0;
508 +
509 + MCI_Device_Desc.state = AT91C_MCI_IDLE;
510 + MCI_Device_Desc.SDCard_bus_width = AT91C_MCI_SCDBUS;
511 +
512 + // Init AT91S_DataFlash Global Structure, by default AT45DB choosen !!!
513 + MCI_Device.pMCI_DeviceDesc = &MCI_Device_Desc;
514 + MCI_Device.pMCI_DeviceFeatures = &MCI_Device_Features;
515 +
516 +}
517 +
518 +//*----------------------------------------------------------------------------
519 +//* \fn AT91F_MCI_Init
520 +//* \brief Initialsise Card
521 +//*----------------------------------------------------------------------------
522 +int AT91F_MCI_Init(void)
523 +{
524 +
525 +///////////////////////////////////////////////////////////////////////////////////////////
526 +// MCI Init : common to MMC and SDCard
527 +///////////////////////////////////////////////////////////////////////////////////////////
528 +
529 + // Set up PIO SDC_TYPE to switch on MMC/SDCard and not DataFlash Card
530 + AT91F_PIO_CfgOutput(AT91C_BASE_PIOB,AT91C_PIO_PB7);
531 + AT91F_PIO_SetOutput(AT91C_BASE_PIOB,AT91C_PIO_PB7);
532 +
533 + // Init MCI for MMC and SDCard interface
534 + AT91F_MCI_CfgPIO();
535 + AT91F_MCI_CfgPMC();
536 + AT91F_PDC_Open(AT91C_BASE_PDC_MCI);
537 +
538 + // Disable all the interrupts
539 + AT91C_BASE_MCI->MCI_IDR = 0xFFFFFFFF;
540 +
541 + // Init MCI Device Structures
542 + AT91F_CfgDevice();
543 +
544 + // Configure MCI interrupt
545 + AT91F_AIC_ConfigureIt(AT91C_BASE_AIC,
546 + AT91C_ID_MCI,
547 + AT91C_AIC_PRIOR_HIGHEST,
548 + AT91C_AIC_SRCTYPE_INT_LEVEL_SENSITIVE,
549 + AT91F_ASM_MCI_Handler);
550 +
551 + // Enable MCI interrupt
552 + AT91F_AIC_EnableIt(AT91C_BASE_AIC,AT91C_ID_MCI);
553 +
554 + // Enable Receiver
555 + AT91F_US_EnableRx((AT91PS_USART) AT91C_BASE_DBGU);
556 +
557 + AT91F_MCI_Configure(AT91C_BASE_MCI,
558 + AT91C_MCI_DTOR_1MEGA_CYCLES,
559 + AT91C_MCI_MR_PDCMODE, // 15MHz for MCK = 60MHz (CLKDIV = 1)
560 + AT91C_MCI_SDCARD_4BITS_SLOTA);
561 +
562 + if(AT91F_MCI_SDCard_Init(&MCI_Device) != AT91C_INIT_OK)
563 + return FALSE;
564 + else
565 + return TRUE;
566 +
567 +}
568 +
569 +//*----------------------------------------------------------------------------
570 +//* \fn AT91F_MCIDeviceWaitReady
571 +//* \brief Wait for MCI Device ready
572 +//*----------------------------------------------------------------------------
573 +void AT91F_MCIDeviceWaitReady(unsigned int timeout)
574 +{
575 + volatile int status;
576 +
577 + do
578 + {
579 + status = AT91C_BASE_MCI->MCI_SR;
580 + timeout--;
581 + }
582 + while( !(status & AT91C_MCI_NOTBUSY) && (timeout>0) );
583 +}
584 +
585 +unsigned int swab32(unsigned int data)
586 +{
587 + unsigned int res = 0;
588 +
589 + res = (data & 0x000000ff) << 24 |
590 + (data & 0x0000ff00) << 8 |
591 + (data & 0x00ff0000) >> 8 |
592 + (data & 0xff000000) >> 24;
593 +
594 + return res;
595 +}
596 +
597 +//*--------------------------------------------------------------------
598 +//* \fn AT91F_MCI_ReadBlockSwab
599 +//* \brief Read Block and swap byte order
600 +//*--------------------------------------------------------------------
601 +int AT91F_MCI_ReadBlockSwab(
602 + AT91PS_MciDevice pMCI_Device,
603 + int src,
604 + unsigned int *databuffer,
605 + int sizeToRead)
606 +{
607 + int i;
608 + unsigned char *buf = (unsigned char *)databuffer;
609 +
610 + //* Read Block 1
611 + for(i=0;i<BUFFER_SIZE_MCI_DEVICE;i++)
612 + *buf++ = 0x00;
613 + AT91F_MCI_ReadBlock(&MCI_Device,src,databuffer,sizeToRead);
614 +
615 + //* Wait end of Read
616 + AT91F_MCIDeviceWaitReady(AT91C_MCI_TIMEOUT);
617 +
618 + {
619 + int index;
620 + unsigned int *uiBuffer = databuffer;
621 +
622 + for(index = 0; index < 512/4; index++)
623 + uiBuffer[index] = swab32(uiBuffer[index]);
624 + }
625 + return(1);
626 +}
627 +
628 diff -urN romboot.old/mci_main.cpp romboot/mci_main.cpp
629 --- romboot.old/mci_main.cpp 2007-03-24 13:34:19.000000000 +0100
630 +++ romboot/mci_main.cpp 1970-01-01 01:00:00.000000000 +0100
631 @@ -1,317 +0,0 @@
632 -//*----------------------------------------------------------------------------
633 -//* ATMEL Microcontroller Software Support - ROUSSET -
634 -//*----------------------------------------------------------------------------
635 -//* The software is delivered "AS IS" without warranty or condition of any
636 -//* kind, either express, implied or statutory. This includes without
637 -//* limitation any warranty or condition with respect to merchantability or
638 -//* fitness for any particular purpose, or against the infringements of
639 -//* intellectual property rights of others.
640 -//*----------------------------------------------------------------------------
641 -//* File Name : main.c
642 -//* Object : main application written in C
643 -//* Creation : FB 21/11/2002
644 -//*
645 -//*----------------------------------------------------------------------------
646 -#include "com.h"
647 -#include "dataflash.h"
648 -#include <AT91C_MCI_Device.h>
649 -
650 -#define AT91C_MCI_TIMEOUT 1000000 /* For AT91F_MCIDeviceWaitReady */
651 -#define BUFFER_SIZE_MCI_DEVICE 512
652 -#define MASTER_CLOCK 60000000
653 -#define FALSE -1
654 -#define TRUE 1
655 -
656 -//* External Functions
657 -extern "C" void AT91F_ASM_MCI_Handler(void);
658 -extern "C" void AT91F_MCI_Device_Handler(AT91PS_MciDevice,unsigned int);
659 -extern AT91S_MCIDeviceStatus AT91F_MCI_SDCard_Init (AT91PS_MciDevice);
660 -extern AT91S_MCIDeviceStatus AT91F_MCI_SetBlocklength(AT91PS_MciDevice,unsigned int);
661 -extern AT91S_MCIDeviceStatus AT91F_MCI_ReadBlock(AT91PS_MciDevice,int,unsigned int *,int);
662 -extern AT91S_MCIDeviceStatus AT91F_MCI_WriteBlock(AT91PS_MciDevice,int,unsigned int *,int);
663 -//* Global Variables
664 -AT91S_MciDeviceFeatures MCI_Device_Features;
665 -AT91S_MciDeviceDesc MCI_Device_Desc;
666 -AT91S_MciDevice MCI_Device;
667 -
668 -unsigned int dlBuffer = 0x20000000;
669 -#undef MCI_TEST
670 -#ifdef MCI_TEST
671 -char TestString[] = "\r\nHello Hamish\r\n";
672 -#endif
673 -
674 -//*----------------------------------------------------------------------------
675 -//* \fn AT91F_MCIDeviceWaitReady
676 -//* \brief Wait for MCI Device ready
677 -//*----------------------------------------------------------------------------
678 -void AT91F_MCIDeviceWaitReady(unsigned int timeout)
679 -{
680 - volatile int status;
681 -
682 - do
683 - {
684 - status = AT91C_BASE_MCI->MCI_SR;
685 - timeout--;
686 - }
687 - while( !(status & AT91C_MCI_NOTBUSY) && (timeout>0) );
688 -}
689 -
690 -unsigned int swab32(unsigned int data)
691 -{
692 - unsigned int res = 0;
693 -
694 - res = (data & 0x000000ff) << 24 |
695 - (data & 0x0000ff00) << 8 |
696 - (data & 0x00ff0000) >> 8 |
697 - (data & 0xff000000) >> 24;
698 -
699 - return res;
700 -}
701 -
702 -AT91S_MCIDeviceStatus readblock(
703 - AT91PS_MciDevice pMCI_Device,
704 - int src,
705 - unsigned int *databuffer,
706 - int sizeToRead)
707 -{
708 - int i;
709 - unsigned char *buf = (unsigned char *)databuffer;
710 -
711 - //* Read Block 1
712 - for(i=0;i<BUFFER_SIZE_MCI_DEVICE;i++)
713 - *buf++ = 0x00;
714 - AT91F_MCI_ReadBlock(&MCI_Device,src,databuffer,sizeToRead);
715 -
716 - //* Wait end of Read
717 - AT91F_MCIDeviceWaitReady(AT91C_MCI_TIMEOUT);
718 -
719 - {
720 - int index;
721 - unsigned int *uiBuffer = databuffer;
722 -
723 - for(index = 0; index < 512/4; index++)
724 - uiBuffer[index] = swab32(uiBuffer[index]);
725 - }
726 - return(1);
727 -}
728 -
729 -#if 0
730 -void printdata(unsigned int bufpos)
731 - {
732 - unsigned int *uip;
733 - int linebytes = 16;
734 - int nbytes = 64;
735 - int size = 4;
736 - int i;
737 -
738 - uip = (unsigned int *)bufpos;
739 -
740 - do {
741 -
742 - for(i=0; i<linebytes; i+=size) {
743 - printf(" %08x", *uip++);
744 - }
745 -
746 - printf("\n\r");
747 - nbytes -= linebytes;
748 - } while (nbytes > 0);
749 - }
750 -#endif
751 -//extern char message[40];
752 -
753 -int notnull(int bufpos, unsigned int len)
754 -{
755 - int i;
756 - unsigned char * bp = (unsigned char *)bufpos;
757 -
758 - for (i=0; i<len; i++)
759 - if (bp[i] != '\0')
760 - return(1);
761 -
762 - return(0);
763 -}
764 -//*----------------------------------------------------------------------------
765 -//* \fn AT91F_Test
766 -//* \brief Test Functions
767 -//*----------------------------------------------------------------------------
768 -int AT91F_Test(void)
769 -{
770 - int i;
771 - unsigned int Max_Read_DataBlock_Length;
772 - int block = 0;
773 - int bufpos = dlBuffer;
774 - int lastvalid = 0;
775 - int NbPage = 0;
776 -
777 -
778 - Max_Read_DataBlock_Length = MCI_Device.pMCI_DeviceFeatures->Max_Read_DataBlock_Length;
779 -
780 - //* ReadBlock & WriteBlock Test -> Entire Block
781 -
782 - //* Wait MCI Device Ready
783 - AT91F_MCIDeviceWaitReady(AT91C_MCI_TIMEOUT);
784 -
785 -#ifdef MCI_TEST
786 - //* Read Block 1
787 - for(i=0;i<BUFFER_SIZE_MCI_DEVICE;i++) Buffer[i] = 0x00;
788 - AT91F_MCI_ReadBlock(&MCI_Device,(1*Max_Read_DataBlock_Length),(unsigned int*) Buffer,Max_Read_DataBlock_Length);
789 -
790 - //* Wait end of Read
791 - AT91F_MCIDeviceWaitReady(AT91C_MCI_TIMEOUT);
792 -
793 - // Write Page 1
794 -// sprintf(Buffer,"\n\rThis sentence is written in your device... Congratulations\n\r");
795 - for(i=0; i<16; i++)
796 - Buffer[i] = TestString[i];
797 - AT91F_MCI_WriteBlock(&MCI_Device,(1*Max_Read_DataBlock_Length),(unsigned int*) Buffer,Max_Read_DataBlock_Length);
798 -
799 - //* Wait end of Write
800 - AT91F_MCIDeviceWaitReady(AT91C_MCI_TIMEOUT);
801 -#endif
802 -
803 - for(i=0; i<64; i++) {
804 - readblock(&MCI_Device, block*Max_Read_DataBlock_Length, (unsigned int *)bufpos, Max_Read_DataBlock_Length);
805 - if (notnull(bufpos, Max_Read_DataBlock_Length))
806 - lastvalid++;
807 - block++;
808 - bufpos += 512;
809 - }
810 -
811 - i = dataflash_info[0].Device.pages_number;
812 - while(i>>=1)
813 - NbPage++;
814 - i = lastvalid + (NbPage << 13) + (dataflash_info[0].Device.pages_size << 17);
815 - *(int *)(dlBuffer + 0x14) = i;
816 -
817 - for(i=0; i<4688; i++) {
818 - readblock(&MCI_Device, block*Max_Read_DataBlock_Length, (unsigned int *)bufpos, Max_Read_DataBlock_Length);
819 - block++;
820 - bufpos += 512;
821 - }
822 - write_dataflash(0xc0000000, dlBuffer, 512 * block);
823 - //* End Of Test
824 - printf("DONE %d\n\r", lastvalid);
825 -
826 -// printf(Buffer);
827 -
828 - return TRUE;
829 -}
830 -
831 -//*----------------------------------------------------------------------------
832 -//* \fn AT91F_CfgDevice
833 -//* \brief This function is used to initialise MMC or SDCard Features
834 -//*----------------------------------------------------------------------------
835 -void AT91F_CfgDevice(void)
836 -{
837 - // Init Device Structure
838 -
839 - MCI_Device_Features.Relative_Card_Address = 0;
840 - MCI_Device_Features.Card_Inserted = AT91C_CARD_REMOVED;
841 - MCI_Device_Features.Max_Read_DataBlock_Length = 0;
842 - MCI_Device_Features.Max_Write_DataBlock_Length = 0;
843 - MCI_Device_Features.Read_Partial = 0;
844 - MCI_Device_Features.Write_Partial = 0;
845 - MCI_Device_Features.Erase_Block_Enable = 0;
846 - MCI_Device_Features.Sector_Size = 0;
847 - MCI_Device_Features.Memory_Capacity = 0;
848 -
849 - MCI_Device_Desc.state = AT91C_MCI_IDLE;
850 - MCI_Device_Desc.SDCard_bus_width = AT91C_MCI_SCDBUS;
851 -
852 - // Init AT91S_DataFlash Global Structure, by default AT45DB choosen !!!
853 - MCI_Device.pMCI_DeviceDesc = &MCI_Device_Desc;
854 - MCI_Device.pMCI_DeviceFeatures = &MCI_Device_Features;
855 -
856 -}
857 -
858 -//*----------------------------------------------------------------------------
859 -//* \fn AT91F_Test_SDCard
860 -//* \brief Configure MCI for SDCard and complete SDCard init, then jump to Test Functions
861 -//*----------------------------------------------------------------------------
862 -int AT91F_Test_SDCard(void)
863 -{
864 - //////////////////////////////////////////////////////////
865 - //* For SDCard Init
866 - //////////////////////////////////////////////////////////
867 -
868 - AT91F_MCI_Configure(AT91C_BASE_MCI,
869 - AT91C_MCI_DTOR_1MEGA_CYCLES,
870 - AT91C_MCI_MR_PDCMODE, // 15MHz for MCK = 60MHz (CLKDIV = 1)
871 - AT91C_MCI_SDCARD_4BITS_SLOTA);
872 -
873 - if(AT91F_MCI_SDCard_Init(&MCI_Device) != AT91C_INIT_OK)
874 - return FALSE;
875 -
876 - printf("\n\rINI OK: TST\n\r");
877 -
878 - // Enter Main Tests
879 - return(AT91F_Test());
880 -}
881 -
882 -//*----------------------------------------------------------------------------
883 -//* \fn AT91F_MCI_Handler
884 -//* \brief MCI Handler
885 -//*----------------------------------------------------------------------------
886 -extern "C" void AT91F_MCI_Handler(void);
887 -
888 -void AT91F_MCI_Handler(void)
889 -{
890 - int status;
891 -
892 - status = ( AT91C_BASE_MCI->MCI_SR & AT91C_BASE_MCI->MCI_IMR );
893 -
894 - AT91F_MCI_Device_Handler(&MCI_Device,status);
895 -}
896 -
897 -//*----------------------------------------------------------------------------
898 -//* \fn main
899 -//* \brief main function
900 -//*----------------------------------------------------------------------------
901 -int mci_main(void)
902 -{
903 -// printf("MCI Test\n\r");
904 -
905 -///////////////////////////////////////////////////////////////////////////////////////////
906 -// MCI Init : common to MMC and SDCard
907 -///////////////////////////////////////////////////////////////////////////////////////////
908 -
909 -// printf("\n\rInit MCI Interface\n\r");
910 -
911 - // Set up PIO SDC_TYPE to switch on MMC/SDCard and not DataFlash Card
912 - AT91F_PIO_CfgOutput(AT91C_BASE_PIOB,AT91C_PIO_PB7);
913 - AT91F_PIO_SetOutput(AT91C_BASE_PIOB,AT91C_PIO_PB7);
914 -
915 - // Init MCI for MMC and SDCard interface
916 - AT91F_MCI_CfgPIO();
917 - AT91F_MCI_CfgPMC();
918 - AT91F_PDC_Open(AT91C_BASE_PDC_MCI);
919 -
920 - // Disable all the interrupts
921 - AT91C_BASE_MCI->MCI_IDR = 0xFFFFFFFF;
922 -
923 - // Init MCI Device Structures
924 - AT91F_CfgDevice();
925 -
926 - // Configure MCI interrupt
927 - AT91F_AIC_ConfigureIt(AT91C_BASE_AIC,
928 - AT91C_ID_MCI,
929 - AT91C_AIC_PRIOR_HIGHEST,
930 - AT91C_AIC_SRCTYPE_INT_LEVEL_SENSITIVE,
931 - AT91F_ASM_MCI_Handler);
932 -
933 - // Enable MCI interrupt
934 - AT91F_AIC_EnableIt(AT91C_BASE_AIC,AT91C_ID_MCI);
935 -
936 -///////////////////////////////////////////////////////////////////////////////////////////
937 -// Enter Test Menu
938 -///////////////////////////////////////////////////////////////////////////////////////////
939 -
940 - // Enable Receiver
941 - AT91F_US_EnableRx((AT91PS_USART) AT91C_BASE_DBGU);
942 -
943 - if(AT91F_Test_SDCard() == TRUE)
944 - printf("\n\rTST OK\n\r");
945 - else
946 - printf("\n\rTST Fail\n\r");
947 - return(1);
948 -}
OpenWrt SVN history