projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
export the IMAGEBUILDER variable so that makefiles can test for the image builder run
[openwrt.git] / target / linux / at91-2.6 / image / romboot / patches / 002-Add-SD-Card.patch
1 diff -urN romboot.old/asm_mci_isr.S romboot/asm_mci_isr.S
2 --- romboot.old/asm_mci_isr.S 1970-01-01 01:00:00.000000000 +0100
3 +++ romboot/asm_mci_isr.S 2007-03-22 18:52:05.000000000 +0100
4 @@ -0,0 +1,75 @@
5 +#include <AT91RM9200_inc.h>
6 +
7 +#define ARM_MODE_USER 0x10
8 +#define ARM_MODE_FIQ 0x11
9 +#define ARM_MODE_IRQ 0x12
10 +#define ARM_MODE_SVC 0x13
11 +#define ARM_MODE_ABORT 0x17
12 +#define ARM_MODE_UNDEF 0x1B
13 +#define ARM_MODE_SYS 0x1F
14 +
15 +#define I_BIT 0x80
16 +#define F_BIT 0x40
17 +#define T_BIT 0x20
18 +
19 +
20 +/* -----------------------------------------------------------------------------
21 + AT91F_ASM_MCI_Handler
22 + ---------------------
23 + Handler called by the AIC
24 +
25 + Save context
26 + Call C handler
27 + Restore context
28 + ----------------------------------------------------------------------------- */
29 +
30 +.global AT91F_ASM_MCI_Handler
31 +
32 +AT91F_ASM_MCI_Handler:
33 +/* Adjust and save LR_irq in IRQ stack */
34 + sub r14, r14, #4
35 + stmfd sp!, {r14}
36 +
37 +/* Write in the IVR to support Protect Mode
38 + No effect in Normal Mode
39 + De-assert the NIRQ and clear the source in Protect Mode */
40 + ldr r14, =AT91C_BASE_AIC
41 + str r14, [r14, #AIC_IVR]
42 +
43 +/* Save SPSR and r0 in IRQ stack */
44 + mrs r14, SPSR
45 + stmfd sp!, {r0, r14}
46 +
47 +/* Enable Interrupt and Switch in SYS Mode */
48 + mrs r0, CPSR
49 + bic r0, r0, #I_BIT
50 + orr r0, r0, #ARM_MODE_SYS
51 + msr CPSR_c, r0
52 +
53 +/* Save scratch/used registers and LR in User Stack */
54 + stmfd sp!, { r1-r3, r12, r14}
55 +
56 + ldr r1, =AT91F_MCI_Handler
57 + mov r14, pc
58 + bx r1
59 +
60 +/* Restore scratch/used registers and LR from User Stack */
61 + ldmia sp!, { r1-r3, r12, r14}
62 +
63 +/* Disable Interrupt and switch back in IRQ mode */
64 + mrs r0, CPSR
65 + bic r0, r0, #ARM_MODE_SYS
66 + orr r0, r0, #I_BIT | ARM_MODE_IRQ
67 + msr CPSR_c, r0
68 +
69 +/* Mark the End of Interrupt on the AIC */
70 + ldr r0, =AT91C_BASE_AIC
71 + str r0, [r0, #AIC_EOICR]
72 +
73 +/* Restore SPSR_irq and r0 from IRQ stack */
74 + ldmia sp!, {r0, r14}
75 + msr SPSR_cxsf, r14
76 +
77 +/* Restore adjusted LR_irq from IRQ stack directly in the PC */
78 + ldmia sp!, {pc}^
79 +
80 diff -urN romboot.old/compile romboot/compile
81 --- romboot.old/compile 2004-08-04 18:24:24.000000000 +0200
82 +++ romboot/compile 1970-01-01 01:00:00.000000000 +0100
83 @@ -1,35 +0,0 @@
84 -#!/bin/sh
85 -
86 -OUTPUT=romboot
87 -
88 -CROSS=/space/arm/buildroot/build_arm_nofpu/staging_dir/bin/arm-linux-
89 -#CROSS=/opt/cross/bin/arm-linux-
90 -#GCC="$CROSS"gcc
91 -GCC="$CROSS"gcc-msoft-float
92 -LD="$CROSS"ld
93 -OBJCOPY="$CROSS"objcopy
94 -SIZE="$CROSS"size
95 -OBJDUMP="$CROSS"objdump
96 -
97 -LDFLAGS="-T elf32-littlearm.lds -Ttext 0"
98 -
99 -$GCC asm_isr.S -c -Iinclude
100 -$GCC cstartup_ram.S -c -Iinclude
101 -$GCC jump.S -c -Iinclude
102 -$GCC at45.cpp -c -Iinclude -Os
103 -$GCC com.cpp -c -Iinclude -Os
104 -$GCC dataflash.cpp -c -Iinclude -Os
105 -$GCC init.cpp -c -Iinclude -Os
106 -$GCC main.cpp -c -Iinclude -Os
107 -$GCC -c stdio.cpp -Os
108 -$GCC -c _udivsi3.S
109 -$GCC -c _umodsi3.S
110 -$GCC -c div0.c -Os
111 -
112 -$LD cstartup_ram.o asm_isr.o jump.o at45.o com.o dataflash.o init.o main.o stdio.o _udivsi3.o _umodsi3.o div0.o -o $OUTPUT.out $LDFLAGS -n
113 -
114 -$OBJCOPY $OUTPUT.out -O binary $OUTPUT.bin
115 -
116 -$OBJDUMP -h -s $OUTPUT.out > $OUTPUT.lss
117 -
118 -$SIZE $OUTPUT.out
119 diff -urN romboot.old/include/AT91C_MCI_Device.h romboot/include/AT91C_MCI_Device.h
120 --- romboot.old/include/AT91C_MCI_Device.h 1970-01-01 01:00:00.000000000 +0100
121 +++ romboot/include/AT91C_MCI_Device.h 2007-03-22 18:53:51.000000000 +0100
122 @@ -0,0 +1,379 @@
123 +//*---------------------------------------------------------------------------
124 +//* ATMEL Microcontroller Software Support - ROUSSET -
125 +//*---------------------------------------------------------------------------
126 +//* The software is delivered "AS IS" without warranty or condition of any
127 +//* kind, either express, implied or statutory. This includes without
128 +//* limitation any warranty or condition with respect to merchantability or
129 +//* fitness for any particular purpose, or against the infringements of
130 +//* intellectual property rights of others.
131 +//*---------------------------------------------------------------------------
132 +//* File Name : AT91C_MCI_Device.h
133 +//* Object : Data Flash Atmel Description File
134 +//* Translator :
135 +//*
136 +//* 1.0 26/11/02 FB : Creation
137 +//*---------------------------------------------------------------------------
138 +
139 +#ifndef AT91C_MCI_Device_h
140 +#define AT91C_MCI_Device_h
141 +
142 +#include "AT91RM9200.h"
143 +#include "lib_AT91RM9200.h"
144 +
145 +typedef unsigned int AT91S_MCIDeviceStatus;
146 +
147 +/////////////////////////////////////////////////////////////////////////////////////////////////////
148 +
149 +#define AT91C_CARD_REMOVED 0
150 +#define AT91C_MMC_CARD_INSERTED 1
151 +#define AT91C_SD_CARD_INSERTED 2
152 +
153 +#define AT91C_NO_ARGUMENT 0x0
154 +
155 +#define AT91C_FIRST_RCA 0xCAFE
156 +#define AT91C_MAX_MCI_CARDS 10
157 +
158 +#define AT91C_BUS_WIDTH_1BIT 0x00
159 +#define AT91C_BUS_WIDTH_4BITS 0x02
160 +
161 +/* Driver State */
162 +#define AT91C_MCI_IDLE 0x0
163 +#define AT91C_MCI_TIMEOUT_ERROR 0x1
164 +#define AT91C_MCI_RX_SINGLE_BLOCK 0x2
165 +#define AT91C_MCI_RX_MULTIPLE_BLOCK 0x3
166 +#define AT91C_MCI_RX_STREAM 0x4
167 +#define AT91C_MCI_TX_SINGLE_BLOCK 0x5
168 +#define AT91C_MCI_TX_MULTIPLE_BLOCK 0x6
169 +#define AT91C_MCI_TX_STREAM 0x7
170 +
171 +/* TimeOut */
172 +#define AT91C_TIMEOUT_CMDRDY 30
173 +
174 +/////////////////////////////////////////////////////////////////////////////////////////////////////
175 +// MMC & SDCard Structures
176 +/////////////////////////////////////////////////////////////////////////////////////////////////////
177 +
178 +/*-----------------------------------------------*/
179 +/* SDCard Device Descriptor Structure Definition */
180 +/*-----------------------------------------------*/
181 +typedef struct _AT91S_MciDeviceDesc
182 +{
183 + volatile unsigned char state;
184 + unsigned char SDCard_bus_width;
185 +
186 +} AT91S_MciDeviceDesc, *AT91PS_MciDeviceDesc;
187 +
188 +/*---------------------------------------------*/
189 +/* MMC & SDCard Structure Device Features */
190 +/*---------------------------------------------*/
191 +typedef struct _AT91S_MciDeviceFeatures
192 +{
193 + unsigned char Card_Inserted; // (0=AT91C_CARD_REMOVED) (1=AT91C_MMC_CARD_INSERTED) (2=AT91C_SD_CARD_INSERTED)
194 + unsigned int Relative_Card_Address; // RCA
195 + unsigned int Max_Read_DataBlock_Length; // 2^(READ_BL_LEN) in CSD
196 + unsigned int Max_Write_DataBlock_Length; // 2^(WRITE_BL_LEN) in CSD
197 + unsigned char Read_Partial; // READ_BL_PARTIAL
198 + unsigned char Write_Partial; // WRITE_BL_PARTIAL
199 + unsigned char Erase_Block_Enable; // ERASE_BLK_EN
200 + unsigned char Read_Block_Misalignment; // READ_BLK_MISALIGN
201 + unsigned char Write_Block_Misalignment; // WRITE_BLK_MISALIGN
202 + unsigned char Sector_Size; // SECTOR_SIZE
203 + unsigned int Memory_Capacity; // Size in bits of the device
204 +
205 +} AT91S_MciDeviceFeatures, *AT91PS_MciDeviceFeatures ;
206 +
207 +/*---------------------------------------------*/
208 +/* MCI Device Structure Definition */
209 +/*---------------------------------------------*/
210 +typedef struct _AT91S_MciDevice
211 +{
212 + AT91PS_MciDeviceDesc pMCI_DeviceDesc; // MCI device descriptor
213 + AT91PS_MciDeviceFeatures pMCI_DeviceFeatures;// Pointer on a MCI device features array
214 +}AT91S_MciDevice, *AT91PS_MciDevice;
215 +
216 +/////////////////////////////////////////////////////////////////////////////////////////////////////
217 +// MCI_CMD Register Value
218 +/////////////////////////////////////////////////////////////////////////////////////////////////////
219 +#define AT91C_POWER_ON_INIT (0 | AT91C_MCI_TRCMD_NO | AT91C_MCI_SPCMD_INIT | AT91C_MCI_OPDCMD)
220 +
221 +/////////////////////////////////////////////////////////////////
222 +// Class 0 & 1 commands: Basic commands and Read Stream commands
223 +/////////////////////////////////////////////////////////////////
224 +
225 +#define AT91C_GO_IDLE_STATE_CMD (0 | AT91C_MCI_TRCMD_NO | AT91C_MCI_SPCMD_NONE )
226 +#define AT91C_MMC_GO_IDLE_STATE_CMD (0 | AT91C_MCI_TRCMD_NO | AT91C_MCI_SPCMD_NONE | AT91C_MCI_OPDCMD)
227 +#define AT91C_MMC_SEND_OP_COND_CMD (1 | AT91C_MCI_TRCMD_NO | AT91C_MCI_SPCMD_NONE | AT91C_MCI_RSPTYP_48 | AT91C_MCI_OPDCMD)
228 +#define AT91C_ALL_SEND_CID_CMD (2 | AT91C_MCI_TRCMD_NO | AT91C_MCI_SPCMD_NONE | AT91C_MCI_RSPTYP_136 )
229 +#define AT91C_MMC_ALL_SEND_CID_CMD (2 | AT91C_MCI_TRCMD_NO | AT91C_MCI_SPCMD_NONE | AT91C_MCI_RSPTYP_136 | AT91C_MCI_OPDCMD)
230 +#define AT91C_SET_RELATIVE_ADDR_CMD (3 | AT91C_MCI_TRCMD_NO | AT91C_MCI_SPCMD_NONE | AT91C_MCI_RSPTYP_48 | AT91C_MCI_MAXLAT )
231 +#define AT91C_MMC_SET_RELATIVE_ADDR_CMD (3 | AT91C_MCI_TRCMD_NO | AT91C_MCI_SPCMD_NONE | AT91C_MCI_RSPTYP_48 | AT91C_MCI_MAXLAT | AT91C_MCI_OPDCMD)
232 +
233 +#define AT91C_SET_DSR_CMD (4 | AT91C_MCI_TRCMD_NO | AT91C_MCI_SPCMD_NONE | AT91C_MCI_RSPTYP_NO | AT91C_MCI_MAXLAT ) // no tested
234 +
235 +#define AT91C_SEL_DESEL_CARD_CMD (7 | AT91C_MCI_TRCMD_NO | AT91C_MCI_SPCMD_NONE | AT91C_MCI_RSPTYP_48 | AT91C_MCI_MAXLAT )
236 +#define AT91C_SEND_CSD_CMD (9 | AT91C_MCI_TRCMD_NO | AT91C_MCI_SPCMD_NONE | AT91C_MCI_RSPTYP_136 | AT91C_MCI_MAXLAT )
237 +#define AT91C_SEND_CID_CMD (10 | AT91C_MCI_TRCMD_NO | AT91C_MCI_SPCMD_NONE | AT91C_MCI_RSPTYP_136 | AT91C_MCI_MAXLAT )
238 +#define AT91C_MMC_READ_DAT_UNTIL_STOP_CMD (11 | AT91C_MCI_TRTYP_STREAM| AT91C_MCI_SPCMD_NONE | AT91C_MCI_RSPTYP_48 | AT91C_MCI_TRDIR | AT91C_MCI_TRCMD_START | AT91C_MCI_MAXLAT )
239 +
240 +#define AT91C_STOP_TRANSMISSION_CMD (12 | AT91C_MCI_TRCMD_STOP | AT91C_MCI_SPCMD_NONE | AT91C_MCI_RSPTYP_48 | AT91C_MCI_MAXLAT )
241 +#define AT91C_STOP_TRANSMISSION_SYNC_CMD (12 | AT91C_MCI_TRCMD_STOP | AT91C_MCI_SPCMD_SYNC | AT91C_MCI_RSPTYP_48 | AT91C_MCI_MAXLAT )
242 +#define AT91C_SEND_STATUS_CMD (13 | AT91C_MCI_TRCMD_NO | AT91C_MCI_SPCMD_NONE | AT91C_MCI_RSPTYP_48 | AT91C_MCI_MAXLAT )
243 +#define AT91C_GO_INACTIVE_STATE_CMD (15 | AT91C_MCI_RSPTYP_NO )
244 +
245 +//*------------------------------------------------
246 +//* Class 2 commands: Block oriented Read commands
247 +//*------------------------------------------------
248 +
249 +#define AT91C_SET_BLOCKLEN_CMD (16 | AT91C_MCI_TRCMD_NO | AT91C_MCI_SPCMD_NONE | AT91C_MCI_RSPTYP_48 | AT91C_MCI_MAXLAT )
250 +#define AT91C_READ_SINGLE_BLOCK_CMD (17 | AT91C_MCI_SPCMD_NONE | AT91C_MCI_RSPTYP_48 | AT91C_MCI_TRCMD_START | AT91C_MCI_TRTYP_BLOCK | AT91C_MCI_TRDIR | AT91C_MCI_MAXLAT)
251 +#define AT91C_READ_MULTIPLE_BLOCK_CMD (18 | AT91C_MCI_SPCMD_NONE | AT91C_MCI_RSPTYP_48 | AT91C_MCI_TRCMD_START | AT91C_MCI_TRTYP_MULTIPLE | AT91C_MCI_TRDIR | AT91C_MCI_MAXLAT)
252 +
253 +//*--------------------------------------------
254 +//* Class 3 commands: Sequential write commands
255 +//*--------------------------------------------
256 +
257 +#define AT91C_MMC_WRITE_DAT_UNTIL_STOP_CMD (20 | AT91C_MCI_TRTYP_STREAM| AT91C_MCI_SPCMD_NONE | AT91C_MCI_RSPTYP_48 & ~(AT91C_MCI_TRDIR) | AT91C_MCI_TRCMD_START | AT91C_MCI_MAXLAT ) // MMC
258 +
259 +//*------------------------------------------------
260 +//* Class 4 commands: Block oriented write commands
261 +//*------------------------------------------------
262 +
263 +#define AT91C_WRITE_BLOCK_CMD (24 | AT91C_MCI_SPCMD_NONE | AT91C_MCI_RSPTYP_48 | AT91C_MCI_TRCMD_START | (AT91C_MCI_TRTYP_BLOCK & ~(AT91C_MCI_TRDIR)) | AT91C_MCI_MAXLAT)
264 +#define AT91C_WRITE_MULTIPLE_BLOCK_CMD (25 | AT91C_MCI_SPCMD_NONE | AT91C_MCI_RSPTYP_48 | AT91C_MCI_TRCMD_START | (AT91C_MCI_TRTYP_MULTIPLE & ~(AT91C_MCI_TRDIR)) | AT91C_MCI_MAXLAT)
265 +#define AT91C_PROGRAM_CSD_CMD (27 | AT91C_MCI_RSPTYP_48 )
266 +
267 +
268 +//*----------------------------------------
269 +//* Class 6 commands: Group Write protect
270 +//*----------------------------------------
271 +
272 +#define AT91C_SET_WRITE_PROT_CMD (28 | AT91C_MCI_RSPTYP_48 )
273 +#define AT91C_CLR_WRITE_PROT_CMD (29 | AT91C_MCI_RSPTYP_48 )
274 +#define AT91C_SEND_WRITE_PROT_CMD (30 | AT91C_MCI_RSPTYP_48 )
275 +
276 +
277 +//*----------------------------------------
278 +//* Class 5 commands: Erase commands
279 +//*----------------------------------------
280 +
281 +#define AT91C_TAG_SECTOR_START_CMD (32 | AT91C_MCI_SPCMD_NONE | AT91C_MCI_RSPTYP_48 | AT91C_MCI_TRCMD_NO | AT91C_MCI_MAXLAT)
282 +#define AT91C_TAG_SECTOR_END_CMD (33 | AT91C_MCI_SPCMD_NONE | AT91C_MCI_RSPTYP_48 | AT91C_MCI_TRCMD_NO | AT91C_MCI_MAXLAT)
283 +#define AT91C_MMC_UNTAG_SECTOR_CMD (34 | AT91C_MCI_RSPTYP_48 )
284 +#define AT91C_MMC_TAG_ERASE_GROUP_START_CMD (35 | AT91C_MCI_RSPTYP_48 )
285 +#define AT91C_MMC_TAG_ERASE_GROUP_END_CMD (36 | AT91C_MCI_RSPTYP_48 )
286 +#define AT91C_MMC_UNTAG_ERASE_GROUP_CMD (37 | AT91C_MCI_RSPTYP_48 )
287 +#define AT91C_ERASE_CMD (38 | AT91C_MCI_SPCMD_NONE | AT91C_MCI_RSPTYP_48 | AT91C_MCI_TRCMD_NO | AT91C_MCI_MAXLAT )
288 +
289 +//*----------------------------------------
290 +//* Class 7 commands: Lock commands
291 +//*----------------------------------------
292 +
293 +#define AT91C_LOCK_UNLOCK (42 | AT91C_MCI_SPCMD_NONE | AT91C_MCI_RSPTYP_48 | AT91C_MCI_TRCMD_NO | AT91C_MCI_MAXLAT) // no tested
294 +
295 +//*-----------------------------------------------
296 +// Class 8 commands: Application specific commands
297 +//*-----------------------------------------------
298 +
299 +#define AT91C_APP_CMD (55 | AT91C_MCI_SPCMD_NONE | AT91C_MCI_RSPTYP_48 | AT91C_MCI_TRCMD_NO | AT91C_MCI_MAXLAT)
300 +#define AT91C_GEN_CMD (56 | AT91C_MCI_SPCMD_NONE | AT91C_MCI_RSPTYP_48 | AT91C_MCI_TRCMD_NO | AT91C_MCI_MAXLAT) // no tested
301 +
302 +#define AT91C_SDCARD_SET_BUS_WIDTH_CMD (6 | AT91C_MCI_SPCMD_NONE | AT91C_MCI_RSPTYP_48 | AT91C_MCI_TRCMD_NO | AT91C_MCI_MAXLAT)
303 +#define AT91C_SDCARD_STATUS_CMD (13 | AT91C_MCI_SPCMD_NONE | AT91C_MCI_RSPTYP_48 | AT91C_MCI_TRCMD_NO | AT91C_MCI_MAXLAT)
304 +#define AT91C_SDCARD_SEND_NUM_WR_BLOCKS_CMD (22 | AT91C_MCI_SPCMD_NONE | AT91C_MCI_RSPTYP_48 | AT91C_MCI_TRCMD_NO | AT91C_MCI_MAXLAT)
305 +#define AT91C_SDCARD_SET_WR_BLK_ERASE_COUNT_CMD (23 | AT91C_MCI_SPCMD_NONE | AT91C_MCI_RSPTYP_48 | AT91C_MCI_TRCMD_NO | AT91C_MCI_MAXLAT)
306 +#define AT91C_SDCARD_APP_OP_COND_CMD (41 | AT91C_MCI_SPCMD_NONE | AT91C_MCI_RSPTYP_48 | AT91C_MCI_TRCMD_NO )
307 +#define AT91C_SDCARD_SET_CLR_CARD_DETECT_CMD (42 | AT91C_MCI_SPCMD_NONE | AT91C_MCI_RSPTYP_48 | AT91C_MCI_TRCMD_NO | AT91C_MCI_MAXLAT)
308 +#define AT91C_SDCARD_SEND_SCR_CMD (51 | AT91C_MCI_SPCMD_NONE | AT91C_MCI_RSPTYP_48 | AT91C_MCI_TRCMD_NO | AT91C_MCI_MAXLAT)
309 +
310 +#define AT91C_SDCARD_APP_ALL_CMD (AT91C_SDCARD_SET_BUS_WIDTH_CMD +\
311 + AT91C_SDCARD_STATUS_CMD +\
312 + AT91C_SDCARD_SEND_NUM_WR_BLOCKS_CMD +\
313 + AT91C_SDCARD_SET_WR_BLK_ERASE_COUNT_CMD +\
314 + AT91C_SDCARD_APP_OP_COND_CMD +\
315 + AT91C_SDCARD_SET_CLR_CARD_DETECT_CMD +\
316 + AT91C_SDCARD_SEND_SCR_CMD)
317 +
318 +//*----------------------------------------
319 +//* Class 9 commands: IO Mode commands
320 +//*----------------------------------------
321 +
322 +#define AT91C_MMC_FAST_IO_CMD (39 | AT91C_MCI_SPCMD_NONE | AT91C_MCI_RSPTYP_48 | AT91C_MCI_MAXLAT)
323 +#define AT91C_MMC_GO_IRQ_STATE_CMD (40 | AT91C_MCI_SPCMD_NONE | AT91C_MCI_RSPTYP_48 | AT91C_MCI_TRCMD_NO | AT91C_MCI_MAXLAT)
324 +
325 +/////////////////////////////////////////////////////////////////////////////////////////////////////
326 +// Functions returnals
327 +/////////////////////////////////////////////////////////////////////////////////////////////////////
328 +#define AT91C_CMD_SEND_OK 0 // Command ok
329 +#define AT91C_CMD_SEND_ERROR -1 // Command failed
330 +#define AT91C_INIT_OK 2 // Init Successfull
331 +#define AT91C_INIT_ERROR 3 // Init Failed
332 +#define AT91C_READ_OK 4 // Read Successfull
333 +#define AT91C_READ_ERROR 5 // Read Failed
334 +#define AT91C_WRITE_OK 6 // Write Successfull
335 +#define AT91C_WRITE_ERROR 7 // Write Failed
336 +#define AT91C_ERASE_OK 8 // Erase Successfull
337 +#define AT91C_ERASE_ERROR 9 // Erase Failed
338 +#define AT91C_CARD_SELECTED_OK 10 // Card Selection Successfull
339 +#define AT91C_CARD_SELECTED_ERROR 11 // Card Selection Failed
340 +
341 +/////////////////////////////////////////////////////////////////////////////////////////////////////
342 +// MCI_SR Errors
343 +/////////////////////////////////////////////////////////////////////////////////////////////////////
344 +#define AT91C_MCI_SR_ERROR (AT91C_MCI_UNRE |\
345 + AT91C_MCI_OVRE |\
346 + AT91C_MCI_DTOE |\
347 + AT91C_MCI_DCRCE |\
348 + AT91C_MCI_RTOE |\
349 + AT91C_MCI_RENDE |\
350 + AT91C_MCI_RCRCE |\
351 + AT91C_MCI_RDIRE |\
352 + AT91C_MCI_RINDE)
353 +
354 +////////////////////////////////////////////////////////////////////////////////////////////////////
355 +// OCR Register
356 +////////////////////////////////////////////////////////////////////////////////////////////////////
357 +#define AT91C_VDD_16_17 (1 << 4)
358 +#define AT91C_VDD_17_18 (1 << 5)
359 +#define AT91C_VDD_18_19 (1 << 6)
360 +#define AT91C_VDD_19_20 (1 << 7)
361 +#define AT91C_VDD_20_21 (1 << 8)
362 +#define AT91C_VDD_21_22 (1 << 9)
363 +#define AT91C_VDD_22_23 (1 << 10)
364 +#define AT91C_VDD_23_24 (1 << 11)
365 +#define AT91C_VDD_24_25 (1 << 12)
366 +#define AT91C_VDD_25_26 (1 << 13)
367 +#define AT91C_VDD_26_27 (1 << 14)
368 +#define AT91C_VDD_27_28 (1 << 15)
369 +#define AT91C_VDD_28_29 (1 << 16)
370 +#define AT91C_VDD_29_30 (1 << 17)
371 +#define AT91C_VDD_30_31 (1 << 18)
372 +#define AT91C_VDD_31_32 (1 << 19)
373 +#define AT91C_VDD_32_33 (1 << 20)
374 +#define AT91C_VDD_33_34 (1 << 21)
375 +#define AT91C_VDD_34_35 (1 << 22)
376 +#define AT91C_VDD_35_36 (1 << 23)
377 +#define AT91C_CARD_POWER_UP_BUSY (1 << 31)
378 +
379 +#define AT91C_MMC_HOST_VOLTAGE_RANGE (AT91C_VDD_27_28 +\
380 + AT91C_VDD_28_29 +\
381 + AT91C_VDD_29_30 +\
382 + AT91C_VDD_30_31 +\
383 + AT91C_VDD_31_32 +\
384 + AT91C_VDD_32_33)
385 +
386 +////////////////////////////////////////////////////////////////////////////////////////////////////
387 +// CURRENT_STATE & READY_FOR_DATA in SDCard Status Register definition (response type R1)
388 +////////////////////////////////////////////////////////////////////////////////////////////////////
389 +#define AT91C_SR_READY_FOR_DATA (1 << 8) // corresponds to buffer empty signalling on the bus
390 +#define AT91C_SR_IDLE (0 << 9)
391 +#define AT91C_SR_READY (1 << 9)
392 +#define AT91C_SR_IDENT (2 << 9)
393 +#define AT91C_SR_STBY (3 << 9)
394 +#define AT91C_SR_TRAN (4 << 9)
395 +#define AT91C_SR_DATA (5 << 9)
396 +#define AT91C_SR_RCV (6 << 9)
397 +#define AT91C_SR_PRG (7 << 9)
398 +#define AT91C_SR_DIS (8 << 9)
399 +
400 +#define AT91C_SR_CARD_SELECTED (AT91C_SR_READY_FOR_DATA + AT91C_SR_TRAN)
401 +
402 +/////////////////////////////////////////////////////////////////////////////////////////////////////
403 +// MMC CSD register header File
404 +// AT91C_CSD_xxx_S for shift value
405 +// AT91C_CSD_xxx_M for mask value
406 +/////////////////////////////////////////////////////////////////////////////////////////////////////
407 +
408 +// First Response INT <=> CSD[3] : bits 0 to 31
409 +#define AT91C_CSD_BIT0_S 0 // [0:0]
410 +#define AT91C_CSD_BIT0_M 0x01
411 +#define AT91C_CSD_CRC_S 1 // [7:1]
412 +#define AT91C_CSD_CRC_M 0x7F
413 +#define AT91C_CSD_MMC_ECC_S 8 // [9:8] reserved for MMC compatibility
414 +#define AT91C_CSD_MMC_ECC_M 0x03
415 +#define AT91C_CSD_FILE_FMT_S 10 // [11:10]
416 +#define AT91C_CSD_FILE_FMT_M 0x03
417 +#define AT91C_CSD_TMP_WP_S 12 // [12:12]
418 +#define AT91C_CSD_TMP_WP_M 0x01
419 +#define AT91C_CSD_PERM_WP_S 13 // [13:13]
420 +#define AT91C_CSD_PERM_WP_M 0x01
421 +#define AT91C_CSD_COPY_S 14 // [14:14]
422 +#define AT91C_CSD_COPY_M 0x01
423 +#define AT91C_CSD_FILE_FMT_GRP_S 15 // [15:15]
424 +#define AT91C_CSD_FILE_FMT_GRP_M 0x01
425 +// reserved 16 // [20:16]
426 +// reserved 0x1F
427 +#define AT91C_CSD_WBLOCK_P_S 21 // [21:21]
428 +#define AT91C_CSD_WBLOCK_P_M 0x01
429 +#define AT91C_CSD_WBLEN_S 22 // [25:22]
430 +#define AT91C_CSD_WBLEN_M 0x0F
431 +#define AT91C_CSD_R2W_F_S 26 // [28:26]
432 +#define AT91C_CSD_R2W_F_M 0x07
433 +#define AT91C_CSD_MMC_DEF_ECC_S 29 // [30:29] reserved for MMC compatibility
434 +#define AT91C_CSD_MMC_DEF_ECC_M 0x03
435 +#define AT91C_CSD_WP_GRP_EN_S 31 // [31:31]
436 +#define AT91C_CSD_WP_GRP_EN_M 0x01
437 +
438 +// Seconde Response INT <=> CSD[2] : bits 32 to 63
439 +#define AT91C_CSD_v21_WP_GRP_SIZE_S 0 // [38:32]
440 +#define AT91C_CSD_v21_WP_GRP_SIZE_M 0x7F
441 +#define AT91C_CSD_v21_SECT_SIZE_S 7 // [45:39]
442 +#define AT91C_CSD_v21_SECT_SIZE_M 0x7F
443 +#define AT91C_CSD_v21_ER_BLEN_EN_S 14 // [46:46]
444 +#define AT91C_CSD_v21_ER_BLEN_EN_M 0x01
445 +
446 +#define AT91C_CSD_v22_WP_GRP_SIZE_S 0 // [36:32]
447 +#define AT91C_CSD_v22_WP_GRP_SIZE_M 0x1F
448 +#define AT91C_CSD_v22_ER_GRP_SIZE_S 5 // [41:37]
449 +#define AT91C_CSD_v22_ER_GRP_SIZE_M 0x1F
450 +#define AT91C_CSD_v22_SECT_SIZE_S 10 // [46:42]
451 +#define AT91C_CSD_v22_SECT_SIZE_M 0x1F
452 +
453 +#define AT91C_CSD_C_SIZE_M_S 15 // [49:47]
454 +#define AT91C_CSD_C_SIZE_M_M 0x07
455 +#define AT91C_CSD_VDD_WMAX_S 18 // [52:50]
456 +#define AT91C_CSD_VDD_WMAX_M 0x07
457 +#define AT91C_CSD_VDD_WMIN_S 21 // [55:53]
458 +#define AT91C_CSD_VDD_WMIN_M 0x07
459 +#define AT91C_CSD_RCUR_MAX_S 24 // [58:56]
460 +#define AT91C_CSD_RCUR_MAX_M 0x07
461 +#define AT91C_CSD_RCUR_MIN_S 27 // [61:59]
462 +#define AT91C_CSD_RCUR_MIN_M 0x07
463 +#define AT91C_CSD_CSIZE_L_S 30 // [63:62] <=> 2 LSB of CSIZE
464 +#define AT91C_CSD_CSIZE_L_M 0x03
465 +
466 +// Third Response INT <=> CSD[1] : bits 64 to 95
467 +#define AT91C_CSD_CSIZE_H_S 0 // [73:64] <=> 10 MSB of CSIZE
468 +#define AT91C_CSD_CSIZE_H_M 0x03FF
469 +// reserved 10 // [75:74]
470 +// reserved 0x03
471 +#define AT91C_CSD_DSR_I_S 12 // [76:76]
472 +#define AT91C_CSD_DSR_I_M 0x01
473 +#define AT91C_CSD_RD_B_MIS_S 13 // [77:77]
474 +#define AT91C_CSD_RD_B_MIS_M 0x01
475 +#define AT91C_CSD_WR_B_MIS_S 14 // [78:78]
476 +#define AT91C_CSD_WR_B_MIS_M 0x01
477 +#define AT91C_CSD_RD_B_PAR_S 15 // [79:79]
478 +#define AT91C_CSD_RD_B_PAR_M 0x01
479 +#define AT91C_CSD_RD_B_LEN_S 16 // [83:80]
480 +#define AT91C_CSD_RD_B_LEN_M 0x0F
481 +#define AT91C_CSD_CCC_S 20 // [95:84]
482 +#define AT91C_CSD_CCC_M 0x0FFF
483 +
484 +// Fourth Response INT <=> CSD[0] : bits 96 to 127
485 +#define AT91C_CSD_TRANS_SPEED_S 0 // [103:96]
486 +#define AT91C_CSD_TRANS_SPEED_M 0xFF
487 +#define AT91C_CSD_NSAC_S 8 // [111:104]
488 +#define AT91C_CSD_NSAC_M 0xFF
489 +#define AT91C_CSD_TAAC_S 16 // [119:112]
490 +#define AT91C_CSD_TAAC_M 0xFF
491 +// reserved 24 // [121:120]
492 +// reserved 0x03
493 +#define AT91C_CSD_MMC_SPEC_VERS_S 26 // [125:122] reserved for MMC compatibility
494 +#define AT91C_CSD_MMC_SPEC_VERS_M 0x0F
495 +#define AT91C_CSD_STRUCT_S 30 // [127:126]
496 +#define AT91C_CSD_STRUCT_M 0x03
497 +
498 +/////////////////////////////////////////////////////////////////////////////////////////////////////
499 +
500 +#endif
501 +
502 diff -urN romboot.old/init.cpp romboot/init.cpp
503 --- romboot.old/init.cpp 2004-07-06 13:01:55.000000000 +0200
504 +++ romboot/init.cpp 2007-03-21 12:43:39.000000000 +0100
505 @@ -35,7 +35,7 @@
506 //*----------------------------------------------------------------------------
507 void AT91F_SpuriousHandler()
508 {
509 - AT91F_DBGU_Printk("-F- Spurious Interrupt detected\n\r");
510 + AT91F_DBGU_Printk("ISI");
511 while (1);
512 }
513
514 @@ -46,7 +46,7 @@
515 //*----------------------------------------------------------------------------
516 void AT91F_DataAbort()
517 {
518 - AT91F_DBGU_Printk("-F- Data Abort detected\n\r");
519 + AT91F_DBGU_Printk("IDA");
520 while (1);
521 }
522
523 @@ -56,7 +56,7 @@
524 //*----------------------------------------------------------------------------
525 void AT91F_FetchAbort()
526 {
527 - AT91F_DBGU_Printk("-F- Prefetch Abort detected\n\r");
528 + AT91F_DBGU_Printk("IPA");
529 while (1);
530 }
531
532 @@ -66,7 +66,7 @@
533 //*----------------------------------------------------------------------------
534 void AT91F_Undef()
535 {
536 - AT91F_DBGU_Printk("-F- Undef detected\n\r");
537 + AT91F_DBGU_Printk("IUD");
538 while (1);
539 }
540
541 @@ -76,7 +76,7 @@
542 //*----------------------------------------------------------------------------
543 void AT91F_UndefHandler()
544 {
545 - AT91F_DBGU_Printk("-F- Undef detected\n\r");
546 + AT91F_DBGU_Printk("IUD");
547 while (1);
548 }
549
550 diff -urN romboot.old/main.cpp romboot/main.cpp
551 --- romboot.old/main.cpp 2007-03-19 12:44:03.000000000 +0100
552 +++ romboot/main.cpp 2007-03-21 19:23:41.000000000 +0100
553 @@ -33,18 +33,22 @@
554 #define DELAY_MAIN_FREQ 1000
555 #define DISP_LINE_LEN 16
556
557 +#define COMPACT 1
558 +
559 //* prototypes
560 extern void AT91F_DBGU_Printk(char *);
561 extern "C" void AT91F_ST_ASM_Handler(void);
562 extern "C" void Jump(unsigned int addr);
563 +extern int mci_main(void);
564
565 -const char *menu_separ = "*----------------------------------------*\n\r";
566 +//const char *menu_separ = "*----------------------------------------*\n\r";
567
568 const char *menu_dataflash = {
569 - "1: Download Dataflash [addr]\n\r"
570 - "2: Read Dataflash [addr]\n\r"
571 - "3: Start U-BOOT\n\r"
572 - "4: Clear bootloader section in Dataflash\n\r"
573 + "1: DL DF [ad]\n\r"
574 + "2: RD DF [ad]\n\r"
575 + "3: CP SD\n\r"
576 + "4: U-BOOT\n\r"
577 + "5: RM BL in DF\n\r"
578 };
579
580 //* Globales variables
581 @@ -151,12 +155,12 @@
582 //*-----------------------------------------------------------------------------
583 void AT91F_DisplayMenu(void)
584 {
585 - printf("\n\rFDL LOADER %s %s %s\n\r", AT91C_VERSION, __DATE__, __TIME__);
586 - printf(menu_separ);
587 + printf("\n\rFDL SD-Card LOADER %s %s %s\n\r", AT91C_VERSION, __DATE__, __TIME__);
588 +// printf(menu_separ);
589 AT91F_DataflashPrintInfo();
590 - printf(menu_separ);
591 +// printf(menu_separ);
592 printf(menu_dataflash);
593 - printf(menu_separ);
594 +// printf(menu_separ);
595 }
596
597 //*-----------------------------------------------------------------------------
598 @@ -194,6 +198,7 @@
599 }
600
601
602 +#ifndef COMPACT
603 //*-----------------------------------------------------------------------------
604 //* Function Name : AT91F_MemoryDisplay()
605 //* Object : Display the content of the dataflash
606 @@ -244,7 +249,7 @@
607 } while (nbytes > 0);
608 return 0;
609 }
610 -
611 +#endif
612
613 //*--------------------------------------------------------------------------------------
614 //* Function Name : AT91F_SetPLL
615 @@ -306,7 +311,7 @@
616 AT91F_SetPLL();
617 }
618
619 -void LedCode(void)
620 +/*void LedCode(void)
621 {
622 int *pRegister;
623 pRegister = (int *)0xFFFFF800; // Enable port C peripheral reg
624 @@ -318,15 +323,16 @@
625 pRegister = (int *)0xFFFFF834; // Clear bits
626 *pRegister = 0x2800;
627 }
628 +*/
629
630 void AT91F_StartUboot(unsigned int dummy, void *pvoid)
631 {
632 - printf("Load U-BOOT from dataflash[%x] to SDRAM[%x]\n\r", AT91C_UBOOT_DATAFLASH_ADDR, AT91C_UBOOT_ADDR);
633 + //printf("Load U-BOOT from dataflash[%x] to SDRAM[%x]\n\r", AT91C_UBOOT_DATAFLASH_ADDR, AT91C_UBOOT_ADDR);
634 read_dataflash(AT91C_UBOOT_DATAFLASH_ADDR, AT91C_UBOOT_SIZE, (char *)(AT91C_UBOOT_ADDR));
635 - printf("Set PLLA to 180Mhz and Master clock to 60Mhz and start U-BOOT\n\r");
636 + //printf("Set PLLA to 180Mhz and Master clock to 60Mhz and start U-BOOT\n\r");
637 //* Reset registers
638 AT91F_ResetRegisters();
639 - LedCode();
640 +// LedCode();
641 Jump(AT91C_UBOOT_ADDR);
642 while(1);
643 }
644 @@ -385,120 +391,124 @@
645 // start tempo to start Uboot in a delay of 1 sec if no key pressed
646 svcUbootTempo.Start(&svcUbootTempo, 1000, 0, AT91F_StartUboot, (void *)0);
647
648 - printf("press any key to enter bootloader\n\r");
649 + printf("press key\n\r");
650 getc();
651
652 // stop tempo
653 svcUbootTempo.Stop(&svcUbootTempo);
654
655 - while(1)
656 - {
657 - while(command == 0)
658 - {
659 - AddressToDownload = AT91C_DOWNLOAD_BASE_ADDRESS;
660 - SizeToDownload = AT91C_DOWNLOAD_MAX_SIZE;
661 - DeviceAddress = 0;
662 + while(1) {
663 + while(command == 0) {
664 + AddressToDownload = AT91C_DOWNLOAD_BASE_ADDRESS;
665 + SizeToDownload = AT91C_DOWNLOAD_MAX_SIZE;
666 + DeviceAddress = 0;
667
668 - AT91F_DisplayMenu();
669 - message[0] = 0;
670 - message[2] = 0;
671 - AT91F_ReadLine("Enter: ", message);
672 + AT91F_DisplayMenu();
673 + message[0] = 0;
674 + message[2] = 0;
675 + AT91F_ReadLine("Enter: ", message);
676
677 - command = message[0];
678 - if(command == '1' || command == '2')
679 - if(AsciiToHex(&message[2], &DeviceAddress) == 0)
680 - command = 0;
681 -
682 - switch(command)
683 - {
684 - case '1':
685 - printf("Download Dataflash [0x%x]\n\r", DeviceAddress);
686 -
687 - switch(DeviceAddress & 0xFF000000)
688 - {
689 - case CFG_DATAFLASH_LOGIC_ADDR_CS0:
690 - device = 0;
691 - break;
692 + command = message[0];
693 + if(command == '1' || command == '2')
694 + if(AsciiToHex(&message[2], &DeviceAddress) == 0)
695 + command = 0;
696 +
697 + switch(command) {
698 + case '1':
699 + printf("DL DF [0x%x]\n\r", DeviceAddress);
700 +
701 + switch(DeviceAddress & 0xFF000000) {
702 + case CFG_DATAFLASH_LOGIC_ADDR_CS0:
703 + device = 0;
704 + break;
705
706 - case CFG_DATAFLASH_LOGIC_ADDR_CS3:
707 - device = 1;
708 - break;
709 + case CFG_DATAFLASH_LOGIC_ADDR_CS3:
710 + device = 1;
711 + break;
712
713 - default:
714 - command = 0;
715 - break;
716 - }
717 - break;
718 -
719 - case '2':
720 - do
721 - {
722 - AT91F_MemoryDisplay(DeviceAddress, 4, 64);
723 - AT91F_ReadLine ((char *)0, message);
724 - DeviceAddress += 0x100;
725 + default:
726 + command = 0;
727 + break;
728 + }
729 + break;
730 +
731 +#ifndef COMPACT
732 + case '2':
733 + do {
734 + AT91F_MemoryDisplay(DeviceAddress, 4, 64);
735 + AT91F_ReadLine ((char *)0, message);
736 + DeviceAddress += 0x100;
737 + } while(message[0] == '\0');
738 + command = 0;
739 + break;
740 +#endif
741 +
742 + case '3':
743 + mci_main();
744 + command=0;
745 + break;
746 +
747 + case '4':
748 + AT91F_StartUboot(0, (void *)0);
749 + command = 0;
750 + break;
751 +
752 + case '5':
753 + {
754 + int *i;
755 +
756 + for(i = (int *)0x20000000; i < (int *)0x20004000; i++)
757 + *i = 0;
758 + }
759 + write_dataflash(0xc0000000, 0x20000000, 0x4000);
760 + printf("BL CLR\r\n");
761 + command = 0;
762 + break;
763 +
764 + default:
765 + command = 0;
766 + break;
767 + } // switch(command)
768 + } // while(command == 0)
769 +
770 + xmodemPipe.Read(&xmodemPipe, (char *)AddressToDownload, SizeToDownload, XmodemProtocol, 0);
771 + while(XmodemComplete !=1);
772 + SizeToDownload = (unsigned int)(svcXmodem.pData) - (unsigned int)AddressToDownload;
773 +
774 + // Modification of vector 6
775 + NbPage = 0;
776 + i = dataflash_info[device].Device.pages_number;
777 + while(i >>= 1)
778 + NbPage++;
779 + i = (SizeToDownload / 512) + 1 + (NbPage << 13) + (dataflash_info[device].Device.pages_size << 17);
780 + *(int *)(AddressToDownload + AT91C_OFFSET_VECT6) = i;
781 +
782 +// printf("\n\rModification of Arm Vector 6 :%x\n\r", i);
783 +
784 + printf("\n\rWR %d in DF [0x%x]\n\r",SizeToDownload, DeviceAddress);
785 + crc1 = 0;
786 + pAT91->CRC32((const unsigned char *)AddressToDownload, SizeToDownload , &crc1);
787 +
788 + // write the dataflash
789 + write_dataflash (DeviceAddress, AddressToDownload, SizeToDownload);
790 + // clear the buffer before read
791 + for(i=0; i < SizeToDownload; i++)
792 + *(unsigned char *)(AddressToDownload + i) = 0;
793 +
794 + //* Read dataflash page in TestBuffer
795 + read_dataflash (DeviceAddress, SizeToDownload, (char *)(AddressToDownload));
796 +
797 + printf("Vfy DF: ");
798 + crc2 = 0;
799 +
800 + pAT91->CRC32((const unsigned char *)AddressToDownload, SizeToDownload , &crc2);
801 + if (crc1 != crc2)
802 + printf("Fail\r\n");
803 + else
804 + printf("OK\r\n");
805 +
806 + command = 0;
807 + XmodemComplete = 0;
808 + AT91F_WaitKeyPressed();
809 }
810 - while(message[0] == '\0');
811 - command = 0;
812 - break;
813 -
814 - case '3':
815 - AT91F_StartUboot(0, (void *)0);
816 - command = 0;
817 - break;
818 - case '4':
819 - {
820 - int *i;
821 - for(i = (int *)0x20000000; i < (int *)0x20004000; i++)
822 - *i = 0;
823 - }
824 - write_dataflash(0xc0000000, 0x20000000, 0x4000);
825 - printf("Bootsection cleared\r\n");
826 - command = 0;
827 - break;
828 - default:
829 - command = 0;
830 - break;
831 - }
832 }
833 -
834 - xmodemPipe.Read(&xmodemPipe, (char *)AddressToDownload, SizeToDownload, XmodemProtocol, 0);
835 - while(XmodemComplete !=1);
836 - SizeToDownload = (unsigned int)(svcXmodem.pData) - (unsigned int)AddressToDownload;
837 -
838 - // Modification of vector 6
839 - NbPage = 0;
840 - i = dataflash_info[device].Device.pages_number;
841 - while(i >>= 1)
842 - NbPage++;
843 - i = (SizeToDownload / 512) + 1 + (NbPage << 13) + (dataflash_info[device].Device.pages_size << 17);
844 - *(int *)(AddressToDownload + AT91C_OFFSET_VECT6) = i;
845 -
846 - printf("\n\rModification of Arm Vector 6 :%x\n\r", i);
847 -
848 - printf("\n\rWrite %d bytes in DataFlash [0x%x]\n\r",SizeToDownload, DeviceAddress);
849 - crc1 = 0;
850 - pAT91->CRC32((const unsigned char *)AddressToDownload, SizeToDownload , &crc1);
851 -
852 - // write the dataflash
853 - write_dataflash (DeviceAddress, AddressToDownload, SizeToDownload);
854 - // clear the buffer before read
855 - for(i=0; i < SizeToDownload; i++)
856 - *(unsigned char *)(AddressToDownload + i) = 0;
857 -
858 - //* Read dataflash page in TestBuffer
859 - read_dataflash (DeviceAddress, SizeToDownload, (char *)(AddressToDownload));
860 -
861 - printf("Verify Dataflash: ");
862 - crc2 = 0;
863 -
864 - pAT91->CRC32((const unsigned char *)AddressToDownload, SizeToDownload , &crc2);
865 - if (crc1 != crc2)
866 - printf("Failed\r\n");
867 - else
868 - printf("OK\r\n");
869 -
870 - command = 0;
871 - XmodemComplete = 0;
872 - AT91F_WaitKeyPressed();
873 - }
874 -}
875 diff -urN romboot.old/main.h romboot/main.h
876 --- romboot.old/main.h 2004-07-03 17:41:14.000000000 +0200
877 +++ romboot/main.h 2007-03-21 21:48:52.000000000 +0100
878 @@ -27,7 +27,7 @@
879
880 #define AT91C_OFFSET_VECT6 0x14 //* Offset for ARM vector 6
881
882 -#define AT91C_VERSION "VER 1.01"
883 +#define AT91C_VERSION "VER 1.02"
884 // Global variables and functions definition
885 extern unsigned int GetTickCount(void);
886 #endif
887 diff -urN romboot.old/Makefile romboot/Makefile
888 --- romboot.old/Makefile 2007-03-19 12:44:03.000000000 +0100
889 +++ romboot/Makefile 2007-03-21 12:29:11.000000000 +0100
890 @@ -1,8 +1,8 @@
891 LINKFLAGS= -T elf32-littlearm.lds -Ttext 0
892 COMPILEFLAGS= -Os
893 TARGET=romboot
894 -OBJFILES=cstartup_ram.o asm_isr.o jump.o at45.o com.o dataflash.o \
895 - init.o main.o stdio.o _udivsi3.o _umodsi3.o div0.o
896 +OBJFILES=cstartup_ram.o asm_isr.o asm_mci_isr.o jump.o at45.o com.o dataflash.o \
897 + mci_device.o mci_main.o init.o main.o stdio.o _udivsi3.o _umodsi3.o div0.o
898 LIBRARIES=
899 INCLUDES= -Iinclude
900
901 @@ -11,10 +11,15 @@
902 $(TARGET): $(OBJFILES)
903 $(LD) $(OBJFILES) -o $(TARGET).out $(LINKFLAGS) -n
904 $(OBJCOPY) $(TARGET).out -O binary $(TARGET).bin
905 + $(OBJDUMP) -h -s $(TARGET).out > $(TARGET).lss
906 + $(NM) -n $(TARGET).out | grep -v '\( [aUw] \)\|\(__crc_\)\|\( \$[adt]\)' > $(TARGET).map
907
908 asm_isr.o: asm_isr.S
909 $(CC) -c -Iinclude -o $@ $<
910
911 +asm_mci_isr.o: asm_mci_isr.S
912 + $(CC) -c -Iinclude -o $@ $<
913 +
914 cstartup_ram.o: cstartup_ram.S
915 $(CC) -c -Iinclude -o $@ $<
916
917 diff -urN romboot.old/mci_device.cpp romboot/mci_device.cpp
918 --- romboot.old/mci_device.cpp 1970-01-01 01:00:00.000000000 +0100
919 +++ romboot/mci_device.cpp 2007-03-22 18:52:48.000000000 +0100
920 @@ -0,0 +1,581 @@
921 +//*----------------------------------------------------------------------------
922 +//* ATMEL Microcontroller Software Support - ROUSSET -
923 +//*----------------------------------------------------------------------------
924 +//* The software is delivered "AS IS" without warranty or condition of any
925 +//* kind, either express, implied or statutory. This includes without
926 +//* limitation any warranty or condition with respect to merchantability or
927 +//* fitness for any particular purpose, or against the infringements of
928 +//* intellectual property rights of others.
929 +//*----------------------------------------------------------------------------
930 +//* File Name : mci_device.c
931 +//* Object : TEST DataFlash Functions
932 +//* Creation : FB 26/11/2002
933 +//*
934 +//*----------------------------------------------------------------------------
935 +
936 +#include <AT91C_MCI_Device.h>
937 +#include "com.h"
938 +
939 +#define ENABLE_WRITE 1
940 +#undef MMC
941 +
942 +//*----------------------------------------------------------------------------
943 +//* \fn AT91F_MCI_SendCommand
944 +//* \brief Generic function to send a command to the MMC or SDCard
945 +//*----------------------------------------------------------------------------
946 +AT91S_MCIDeviceStatus AT91F_MCI_SendCommand (
947 + AT91PS_MciDevice pMCI_Device,
948 + unsigned int Cmd,
949 + unsigned int Arg)
950 +{
951 + unsigned int error,status;
952 + //unsigned int tick=0;
953 +
954 + // Send the command
955 + AT91C_BASE_MCI->MCI_ARGR = Arg;
956 + AT91C_BASE_MCI->MCI_CMDR = Cmd;
957 +
958 + // wait for CMDRDY Status flag to read the response
959 + do
960 + {
961 + status = AT91C_BASE_MCI->MCI_SR;
962 + //tick++;
963 + }
964 + while( !(status & AT91C_MCI_CMDRDY) );//&& (tick<100) );
965 +
966 + // Test error ==> if crc error and response R3 ==> don't check error
967 + error = (AT91C_BASE_MCI->MCI_SR) & AT91C_MCI_SR_ERROR;
968 + if(error != 0 )
969 + {
970 + // if the command is SEND_OP_COND the CRC error flag is always present (cf : R3 response)
971 + if ( (Cmd != AT91C_SDCARD_APP_OP_COND_CMD) && (Cmd != AT91C_MMC_SEND_OP_COND_CMD) )
972 + return ((AT91C_BASE_MCI->MCI_SR) & AT91C_MCI_SR_ERROR);
973 + else
974 + {
975 + if (error != AT91C_MCI_RCRCE)
976 + return ((AT91C_BASE_MCI->MCI_SR) & AT91C_MCI_SR_ERROR);
977 + }
978 + }
979 + return AT91C_CMD_SEND_OK;
980 +}
981 +
982 +//*----------------------------------------------------------------------------
983 +//* \fn AT91F_MCI_SDCard_SendAppCommand
984 +//* \brief Specific function to send a specific command to the SDCard
985 +//*----------------------------------------------------------------------------
986 +AT91S_MCIDeviceStatus AT91F_MCI_SDCard_SendAppCommand (
987 + AT91PS_MciDevice pMCI_Device,
988 + unsigned int Cmd_App,
989 + unsigned int Arg )
990 +{
991 + unsigned int status;
992 + //unsigned int tick=0;
993 +
994 + // Send the CMD55 for application specific command
995 + AT91C_BASE_MCI->MCI_ARGR = (pMCI_Device->pMCI_DeviceFeatures->Relative_Card_Address << 16 );
996 + AT91C_BASE_MCI->MCI_CMDR = AT91C_APP_CMD;
997 +
998 + // wait for CMDRDY Status flag to read the response
999 + do
1000 + {
1001 + status = AT91C_BASE_MCI->MCI_SR;
1002 + //tick++;
1003 + }
1004 + while( !(status & AT91C_MCI_CMDRDY) );//&& (tick<100) );
1005 +
1006 + // if an error occurs
1007 + if (((AT91C_BASE_MCI->MCI_SR) & AT91C_MCI_SR_ERROR) != 0 )
1008 + return ((AT91C_BASE_MCI->MCI_SR) & AT91C_MCI_SR_ERROR);
1009 +
1010 + // check if it is a specific command and then send the command
1011 + if ( (Cmd_App && AT91C_SDCARD_APP_ALL_CMD) == 0)
1012 + return AT91C_CMD_SEND_ERROR;
1013 +
1014 + return( AT91F_MCI_SendCommand(pMCI_Device,Cmd_App,Arg) );
1015 +}
1016 +
1017 +//*----------------------------------------------------------------------------
1018 +//* \fn AT91F_MCI_GetStatus
1019 +//* \brief Addressed card sends its status register
1020 +//*----------------------------------------------------------------------------
1021 +AT91S_MCIDeviceStatus AT91F_MCI_GetStatus(AT91PS_MciDevice pMCI_Device,unsigned int relative_card_address)
1022 +{
1023 + if (AT91F_MCI_SendCommand(pMCI_Device,
1024 + AT91C_SEND_STATUS_CMD,
1025 + relative_card_address <<16) == AT91C_CMD_SEND_OK)
1026 + return (AT91C_BASE_MCI->MCI_RSPR[0]);
1027 +
1028 + return AT91C_CMD_SEND_ERROR;
1029 +}
1030 +
1031 +//*----------------------------------------------------------------------------
1032 +//* \fn AT91F_MCI_Device_Handler
1033 +//* \brief MCI C interrupt handler
1034 +//*----------------------------------------------------------------------------
1035 +extern "C" void AT91F_MCI_Device_Handler(AT91PS_MciDevice, unsigned int);
1036 +
1037 +void AT91F_MCI_Device_Handler(
1038 + AT91PS_MciDevice pMCI_Device,
1039 + unsigned int status)
1040 +{
1041 + // If End of Tx Buffer Empty interrupt occurred
1042 + if ( status & AT91C_MCI_TXBUFE )
1043 + {
1044 + AT91C_BASE_MCI->MCI_IDR = AT91C_MCI_TXBUFE;
1045 + AT91C_BASE_PDC_MCI->PDC_PTCR = AT91C_PDC_TXTDIS;
1046 +
1047 + pMCI_Device->pMCI_DeviceDesc->state = AT91C_MCI_IDLE;
1048 + } // End of if AT91C_MCI_TXBUFF
1049 +
1050 + // If End of Rx Buffer Full interrupt occurred
1051 + if ( status & AT91C_MCI_RXBUFF )
1052 + {
1053 + AT91C_BASE_MCI->MCI_IDR = AT91C_MCI_RXBUFF;
1054 + AT91C_BASE_PDC_MCI->PDC_PTCR = AT91C_PDC_RXTDIS;
1055 +
1056 + pMCI_Device->pMCI_DeviceDesc->state = AT91C_MCI_IDLE;
1057 + } // End of if AT91C_MCI_RXBUFF
1058 +
1059 +}
1060 +
1061 +//*----------------------------------------------------------------------------
1062 +//* \fn AT91F_MCI_ReadBlock
1063 +//* \brief Read an ENTIRE block or PARTIAL block
1064 +//*----------------------------------------------------------------------------
1065 +AT91S_MCIDeviceStatus AT91F_MCI_ReadBlock(
1066 + AT91PS_MciDevice pMCI_Device,
1067 + int src,
1068 + unsigned int *dataBuffer,
1069 + int sizeToRead )
1070 +{
1071 + ////////////////////////////////////////////////////////////////////////////////////////////
1072 + if(pMCI_Device->pMCI_DeviceDesc->state != AT91C_MCI_IDLE)
1073 + return AT91C_READ_ERROR;
1074 +
1075 + if( (AT91F_MCI_GetStatus(pMCI_Device,pMCI_Device->pMCI_DeviceFeatures->Relative_Card_Address) & AT91C_SR_READY_FOR_DATA) != AT91C_SR_READY_FOR_DATA)
1076 + return AT91C_READ_ERROR;
1077 +
1078 + if ( (src + sizeToRead) > pMCI_Device->pMCI_DeviceFeatures->Memory_Capacity )
1079 + return AT91C_READ_ERROR;
1080 +
1081 + // If source does not fit a begin of a block
1082 + if ( (src % pMCI_Device->pMCI_DeviceFeatures->Max_Read_DataBlock_Length) != 0 )
1083 + return AT91C_READ_ERROR;
1084 +
1085 + // Test if the MMC supports Partial Read Block
1086 + // ALWAYS SUPPORTED IN SD Memory Card
1087 + if( (sizeToRead < pMCI_Device->pMCI_DeviceFeatures->Max_Read_DataBlock_Length)
1088 + && (pMCI_Device->pMCI_DeviceFeatures->Read_Partial == 0x00) )
1089 + return AT91C_READ_ERROR;
1090 +
1091 + if( sizeToRead > pMCI_Device->pMCI_DeviceFeatures->Max_Read_DataBlock_Length)
1092 + return AT91C_READ_ERROR;
1093 + ////////////////////////////////////////////////////////////////////////////////////////////
1094 +
1095 + // Init Mode Register
1096 + AT91C_BASE_MCI->MCI_MR |= ((pMCI_Device->pMCI_DeviceFeatures->Max_Read_DataBlock_Length << 16) | AT91C_MCI_PDCMODE);
1097 +
1098 + if (sizeToRead %4)
1099 + sizeToRead = (sizeToRead /4)+1;
1100 + else
1101 + sizeToRead = sizeToRead/4;
1102 +
1103 + AT91C_BASE_PDC_MCI->PDC_PTCR = (AT91C_PDC_TXTDIS | AT91C_PDC_RXTDIS);
1104 + AT91C_BASE_PDC_MCI->PDC_RPR = (unsigned int)dataBuffer;
1105 + AT91C_BASE_PDC_MCI->PDC_RCR = sizeToRead;
1106 +
1107 + // Send the Read single block command
1108 + if ( AT91F_MCI_SendCommand(pMCI_Device, AT91C_READ_SINGLE_BLOCK_CMD, src) != AT91C_CMD_SEND_OK )
1109 + return AT91C_READ_ERROR;
1110 +
1111 + pMCI_Device->pMCI_DeviceDesc->state = AT91C_MCI_RX_SINGLE_BLOCK;
1112 +
1113 + // Enable AT91C_MCI_RXBUFF Interrupt
1114 + AT91C_BASE_MCI->MCI_IER = AT91C_MCI_RXBUFF;
1115 +
1116 + // (PDC) Receiver Transfer Enable
1117 + AT91C_BASE_PDC_MCI->PDC_PTCR = AT91C_PDC_RXTEN;
1118 +
1119 + return AT91C_READ_OK;
1120 +}
1121 +
1122 +
1123 +#ifdef ENABLE_WRITE
1124 +//*----------------------------------------------------------------------------
1125 +//* \fn AT91F_MCI_WriteBlock
1126 +//* \brief Write an ENTIRE block but not always PARTIAL block !!!
1127 +//*----------------------------------------------------------------------------
1128 +AT91S_MCIDeviceStatus AT91F_MCI_WriteBlock(
1129 + AT91PS_MciDevice pMCI_Device,
1130 + int dest,
1131 + unsigned int *dataBuffer,
1132 + int sizeToWrite )
1133 +{
1134 + ////////////////////////////////////////////////////////////////////////////////////////////
1135 + if( pMCI_Device->pMCI_DeviceDesc->state != AT91C_MCI_IDLE)
1136 + return AT91C_WRITE_ERROR;
1137 +
1138 + if( (AT91F_MCI_GetStatus(pMCI_Device,pMCI_Device->pMCI_DeviceFeatures->Relative_Card_Address) & AT91C_SR_READY_FOR_DATA) != AT91C_SR_READY_FOR_DATA)
1139 + return AT91C_WRITE_ERROR;
1140 +
1141 + if ( (dest + sizeToWrite) > pMCI_Device->pMCI_DeviceFeatures->Memory_Capacity )
1142 + return AT91C_WRITE_ERROR;
1143 +
1144 + // If source does not fit a begin of a block
1145 + if ( (dest % pMCI_Device->pMCI_DeviceFeatures->Max_Read_DataBlock_Length) != 0 )
1146 + return AT91C_WRITE_ERROR;
1147 +
1148 + // Test if the MMC supports Partial Write Block
1149 + if( (sizeToWrite < pMCI_Device->pMCI_DeviceFeatures->Max_Write_DataBlock_Length)
1150 + && (pMCI_Device->pMCI_DeviceFeatures->Write_Partial == 0x00) )
1151 + return AT91C_WRITE_ERROR;
1152 +
1153 + if( sizeToWrite > pMCI_Device->pMCI_DeviceFeatures->Max_Write_DataBlock_Length )
1154 + return AT91C_WRITE_ERROR;
1155 + ////////////////////////////////////////////////////////////////////////////////////////////
1156 +
1157 + // Init Mode Register
1158 + AT91C_BASE_MCI->MCI_MR |= ((pMCI_Device->pMCI_DeviceFeatures->Max_Write_DataBlock_Length << 16) | AT91C_MCI_PDCMODE);
1159 +
1160 + if (sizeToWrite %4)
1161 + sizeToWrite = (sizeToWrite /4)+1;
1162 + else
1163 + sizeToWrite = sizeToWrite/4;
1164 +
1165 + // Init PDC for write sequence
1166 + AT91C_BASE_PDC_MCI->PDC_PTCR = (AT91C_PDC_TXTDIS | AT91C_PDC_RXTDIS);
1167 + AT91C_BASE_PDC_MCI->PDC_TPR = (unsigned int) dataBuffer;
1168 + AT91C_BASE_PDC_MCI->PDC_TCR = sizeToWrite;
1169 +
1170 + // Send the write single block command
1171 + if ( AT91F_MCI_SendCommand(pMCI_Device, AT91C_WRITE_BLOCK_CMD, dest) != AT91C_CMD_SEND_OK)
1172 + return AT91C_WRITE_ERROR;
1173 +
1174 + pMCI_Device->pMCI_DeviceDesc->state = AT91C_MCI_TX_SINGLE_BLOCK;
1175 +
1176 + // Enable AT91C_MCI_TXBUFE Interrupt
1177 + AT91C_BASE_MCI->MCI_IER = AT91C_MCI_TXBUFE;
1178 +
1179 + // Enables TX for PDC transfert requests
1180 + AT91C_BASE_PDC_MCI->PDC_PTCR = AT91C_PDC_TXTEN;
1181 +
1182 + return AT91C_WRITE_OK;
1183 +}
1184 +#endif
1185 +
1186 +#ifdef MMC
1187 +//*------------------------------------------------------------------------------------------------------------
1188 +//* \fn AT91F_MCI_MMC_SelectCard
1189 +//* \brief Toggles a card between the Stand_by and Transfer states or between Programming and Disconnect states
1190 +//*------------------------------------------------------------------------------------------------------------
1191 +AT91S_MCIDeviceStatus AT91F_MCI_MMC_SelectCard(AT91PS_MciDevice pMCI_Device, unsigned int relative_card_address)
1192 +{
1193 + int status;
1194 +
1195 + //* Check if the MMC card chosen is already the selected one
1196 + status = AT91F_MCI_GetStatus(pMCI_Device,relative_card_address);
1197 +
1198 + if (status < 0)
1199 + return AT91C_CARD_SELECTED_ERROR;
1200 +
1201 + if ((status & AT91C_SR_CARD_SELECTED) == AT91C_SR_CARD_SELECTED)
1202 + return AT91C_CARD_SELECTED_OK;
1203 +
1204 + //* Search for the MMC Card to be selected, status = the Corresponding Device Number
1205 + status = 0;
1206 + while( (pMCI_Device->pMCI_DeviceFeatures[status].Relative_Card_Address != relative_card_address)
1207 + && (status < AT91C_MAX_MCI_CARDS) )
1208 + status++;
1209 +
1210 + if (status > AT91C_MAX_MCI_CARDS)
1211 + return AT91C_CARD_SELECTED_ERROR;
1212 +
1213 + if (AT91F_MCI_SendCommand( pMCI_Device,
1214 + AT91C_SEL_DESEL_CARD_CMD,
1215 + pMCI_Device->pMCI_DeviceFeatures[status].Relative_Card_Address << 16) == AT91C_CMD_SEND_OK)
1216 + return AT91C_CARD_SELECTED_OK;
1217 + return AT91C_CARD_SELECTED_ERROR;
1218 +}
1219 +#endif
1220 +
1221 +//*----------------------------------------------------------------------------
1222 +//* \fn AT91F_MCI_GetCSD
1223 +//* \brief Asks to the specified card to send its CSD
1224 +//*----------------------------------------------------------------------------
1225 +AT91S_MCIDeviceStatus AT91F_MCI_GetCSD (AT91PS_MciDevice pMCI_Device, unsigned int relative_card_address , unsigned int * response)
1226 +{
1227 +
1228 + if(AT91F_MCI_SendCommand(pMCI_Device,
1229 + AT91C_SEND_CSD_CMD,
1230 + (relative_card_address << 16)) != AT91C_CMD_SEND_OK)
1231 + return AT91C_CMD_SEND_ERROR;
1232 +
1233 + response[0] = AT91C_BASE_MCI->MCI_RSPR[0];
1234 + response[1] = AT91C_BASE_MCI->MCI_RSPR[1];
1235 + response[2] = AT91C_BASE_MCI->MCI_RSPR[2];
1236 + response[3] = AT91C_BASE_MCI->MCI_RSPR[3];
1237 +
1238 + return AT91C_CMD_SEND_OK;
1239 +}
1240 +
1241 +//*----------------------------------------------------------------------------
1242 +//* \fn AT91F_MCI_SetBlocklength
1243 +//* \brief Select a block length for all following block commands (R/W)
1244 +//*----------------------------------------------------------------------------
1245 +AT91S_MCIDeviceStatus AT91F_MCI_SetBlocklength(AT91PS_MciDevice pMCI_Device,unsigned int length)
1246 +{
1247 + return( AT91F_MCI_SendCommand(pMCI_Device, AT91C_SET_BLOCKLEN_CMD, length) );
1248 +}
1249 +
1250 +#ifdef MMC
1251 +//*----------------------------------------------------------------------------
1252 +//* \fn AT91F_MCI_MMC_GetAllOCR
1253 +//* \brief Asks to all cards to send their operations conditions
1254 +//*----------------------------------------------------------------------------
1255 +AT91S_MCIDeviceStatus AT91F_MCI_MMC_GetAllOCR (AT91PS_MciDevice pMCI_Device)
1256 +{
1257 + unsigned int response =0x0;
1258 +
1259 + while(1)
1260 + {
1261 + response = AT91F_MCI_SendCommand(pMCI_Device,
1262 + AT91C_MMC_SEND_OP_COND_CMD,
1263 + AT91C_MMC_HOST_VOLTAGE_RANGE);
1264 + if (response != AT91C_CMD_SEND_OK)
1265 + return AT91C_INIT_ERROR;
1266 +
1267 + response = AT91C_BASE_MCI->MCI_RSPR[0];
1268 +
1269 + if ( (response & AT91C_CARD_POWER_UP_BUSY) == AT91C_CARD_POWER_UP_BUSY)
1270 + return(response);
1271 + }
1272 +}
1273 +#endif
1274 +
1275 +#ifdef MMC
1276 +//*----------------------------------------------------------------------------
1277 +//* \fn AT91F_MCI_MMC_GetAllCID
1278 +//* \brief Asks to the MMC on the chosen slot to send its CID
1279 +//*----------------------------------------------------------------------------
1280 +AT91S_MCIDeviceStatus AT91F_MCI_MMC_GetAllCID (AT91PS_MciDevice pMCI_Device, unsigned int *response)
1281 +{
1282 + int Nb_Cards_Found=-1;
1283 +
1284 + while(1)
1285 + {
1286 + if(AT91F_MCI_SendCommand(pMCI_Device,
1287 + AT91C_MMC_ALL_SEND_CID_CMD,
1288 + AT91C_NO_ARGUMENT) != AT91C_CMD_SEND_OK)
1289 + return Nb_Cards_Found;
1290 + else
1291 + {
1292 + Nb_Cards_Found = 0;
1293 + //* Assignation of the relative address to the MMC CARD
1294 + pMCI_Device->pMCI_DeviceFeatures[Nb_Cards_Found].Relative_Card_Address = Nb_Cards_Found + AT91C_FIRST_RCA;
1295 + //* Set the insert flag
1296 + pMCI_Device->pMCI_DeviceFeatures[Nb_Cards_Found].Card_Inserted = AT91C_MMC_CARD_INSERTED;
1297 +
1298 + if (AT91F_MCI_SendCommand(pMCI_Device,
1299 + AT91C_MMC_SET_RELATIVE_ADDR_CMD,
1300 + (Nb_Cards_Found + AT91C_FIRST_RCA) << 16) != AT91C_CMD_SEND_OK)
1301 + return AT91C_CMD_SEND_ERROR;
1302 +
1303 + //* If no error during assignation address ==> Increment Nb_cards_Found
1304 + Nb_Cards_Found++ ;
1305 + }
1306 + }
1307 +}
1308 +#endif
1309 +#ifdef MMC
1310 +//*----------------------------------------------------------------------------
1311 +//* \fn AT91F_MCI_MMC_Init
1312 +//* \brief Return the MMC initialisation status
1313 +//*----------------------------------------------------------------------------
1314 +AT91S_MCIDeviceStatus AT91F_MCI_MMC_Init (AT91PS_MciDevice pMCI_Device)
1315 +{
1316 + unsigned int tab_response[4];
1317 + unsigned int mult,blocknr;
1318 + unsigned int i,Nb_Cards_Found=0;
1319 +
1320 + //* Resets all MMC Cards in Idle state
1321 + AT91F_MCI_SendCommand(pMCI_Device, AT91C_MMC_GO_IDLE_STATE_CMD, AT91C_NO_ARGUMENT);
1322 +
1323 + if(AT91F_MCI_MMC_GetAllOCR(pMCI_Device) == AT91C_INIT_ERROR)
1324 + return AT91C_INIT_ERROR;
1325 +
1326 + Nb_Cards_Found = AT91F_MCI_MMC_GetAllCID(pMCI_Device,tab_response);
1327 + if (Nb_Cards_Found != AT91C_CMD_SEND_ERROR)
1328 + {
1329 + //* Set the Mode Register
1330 + AT91C_BASE_MCI->MCI_MR = AT91C_MCI_MR_PDCMODE;
1331 +
1332 + for(i = 0; i < Nb_Cards_Found; i++)
1333 + {
1334 + if (AT91F_MCI_GetCSD(pMCI_Device,
1335 + pMCI_Device->pMCI_DeviceFeatures[i].Relative_Card_Address,
1336 + tab_response) != AT91C_CMD_SEND_OK)
1337 + pMCI_Device->pMCI_DeviceFeatures[i].Relative_Card_Address = 0;
1338 + else
1339 + {
1340 + pMCI_Device->pMCI_DeviceFeatures[i].Max_Read_DataBlock_Length = 1 << ((tab_response[1] >> AT91C_CSD_RD_B_LEN_S) & AT91C_CSD_RD_B_LEN_M );
1341 + pMCI_Device->pMCI_DeviceFeatures[i].Max_Write_DataBlock_Length = 1 << ((tab_response[3] >> AT91C_CSD_WBLEN_S) & AT91C_CSD_WBLEN_M );
1342 + pMCI_Device->pMCI_DeviceFeatures[i].Sector_Size = 1 + ((tab_response[2] >> AT91C_CSD_v22_SECT_SIZE_S) & AT91C_CSD_v22_SECT_SIZE_M );
1343 + pMCI_Device->pMCI_DeviceFeatures[i].Read_Partial = (tab_response[1] >> AT91C_CSD_RD_B_PAR_S) & AT91C_CSD_RD_B_PAR_M;
1344 + pMCI_Device->pMCI_DeviceFeatures[i].Write_Partial = (tab_response[3] >> AT91C_CSD_WBLOCK_P_S) & AT91C_CSD_WBLOCK_P_M;
1345 +
1346 + // None in MMC specification version 2.2
1347 + pMCI_Device->pMCI_DeviceFeatures[i].Erase_Block_Enable = 0;
1348 +
1349 + pMCI_Device->pMCI_DeviceFeatures[i].Read_Block_Misalignment = (tab_response[1] >> AT91C_CSD_RD_B_MIS_S) & AT91C_CSD_RD_B_MIS_M;
1350 + pMCI_Device->pMCI_DeviceFeatures[i].Write_Block_Misalignment = (tab_response[1] >> AT91C_CSD_WR_B_MIS_S) & AT91C_CSD_WR_B_MIS_M;
1351 +
1352 + //// Compute Memory Capacity
1353 + // compute MULT
1354 + mult = 1 << ( ((tab_response[2] >> AT91C_CSD_C_SIZE_M_S) & AT91C_CSD_C_SIZE_M_M) + 2 );
1355 + // compute MSB of C_SIZE
1356 + blocknr = ((tab_response[1] >> AT91C_CSD_CSIZE_H_S) & AT91C_CSD_CSIZE_H_M) << 2;
1357 + // compute MULT * (LSB of C-SIZE + MSB already computed + 1) = BLOCKNR
1358 + blocknr = mult * ( ( blocknr + ( (tab_response[2] >> AT91C_CSD_CSIZE_L_S) & AT91C_CSD_CSIZE_L_M) ) + 1 );
1359 +
1360 + pMCI_Device->pMCI_DeviceFeatures[i].Memory_Capacity = pMCI_Device->pMCI_DeviceFeatures[i].Max_Read_DataBlock_Length * blocknr;
1361 + //// End of Compute Memory Capacity
1362 +
1363 + } // end of else
1364 + } // end of for
1365 +
1366 + return AT91C_INIT_OK;
1367 + } // end of if
1368 +
1369 + return AT91C_INIT_ERROR;
1370 +}
1371 +#endif
1372 +
1373 +//*----------------------------------------------------------------------------
1374 +//* \fn AT91F_MCI_SDCard_GetOCR
1375 +//* \brief Asks to all cards to send their operations conditions
1376 +//*----------------------------------------------------------------------------
1377 +AT91S_MCIDeviceStatus AT91F_MCI_SDCard_GetOCR (AT91PS_MciDevice pMCI_Device)
1378 +{
1379 + unsigned int response =0x0;
1380 +
1381 + // The RCA to be used for CMD55 in Idle state shall be the card's default RCA=0x0000.
1382 + pMCI_Device->pMCI_DeviceFeatures->Relative_Card_Address = 0x0;
1383 +
1384 + while( (response & AT91C_CARD_POWER_UP_BUSY) != AT91C_CARD_POWER_UP_BUSY )
1385 + {
1386 + response = AT91F_MCI_SDCard_SendAppCommand(pMCI_Device,
1387 + AT91C_SDCARD_APP_OP_COND_CMD,
1388 + AT91C_MMC_HOST_VOLTAGE_RANGE);
1389 + if (response != AT91C_CMD_SEND_OK)
1390 + return AT91C_INIT_ERROR;
1391 +
1392 + response = AT91C_BASE_MCI->MCI_RSPR[0];
1393 + }
1394 +
1395 + return(AT91C_BASE_MCI->MCI_RSPR[0]);
1396 +}
1397 +
1398 +//*----------------------------------------------------------------------------
1399 +//* \fn AT91F_MCI_SDCard_GetCID
1400 +//* \brief Asks to the SDCard on the chosen slot to send its CID
1401 +//*----------------------------------------------------------------------------
1402 +AT91S_MCIDeviceStatus AT91F_MCI_SDCard_GetCID (AT91PS_MciDevice pMCI_Device, unsigned int *response)
1403 +{
1404 + if(AT91F_MCI_SendCommand(pMCI_Device,
1405 + AT91C_ALL_SEND_CID_CMD,
1406 + AT91C_NO_ARGUMENT) != AT91C_CMD_SEND_OK)
1407 + return AT91C_CMD_SEND_ERROR;
1408 +
1409 + response[0] = AT91C_BASE_MCI->MCI_RSPR[0];
1410 + response[1] = AT91C_BASE_MCI->MCI_RSPR[1];
1411 + response[2] = AT91C_BASE_MCI->MCI_RSPR[2];
1412 + response[3] = AT91C_BASE_MCI->MCI_RSPR[3];
1413 +
1414 + return AT91C_CMD_SEND_OK;
1415 +}
1416 +
1417 +//*----------------------------------------------------------------------------
1418 +//* \fn AT91F_MCI_SDCard_SetBusWidth
1419 +//* \brief Set bus width for SDCard
1420 +//*----------------------------------------------------------------------------
1421 +AT91S_MCIDeviceStatus AT91F_MCI_SDCard_SetBusWidth(AT91PS_MciDevice pMCI_Device)
1422 +{
1423 + volatile int ret_value;
1424 + char bus_width;
1425 +
1426 + do
1427 + {
1428 + ret_value =AT91F_MCI_GetStatus(pMCI_Device,pMCI_Device->pMCI_DeviceFeatures->Relative_Card_Address);
1429 + }
1430 + while((ret_value > 0) && ((ret_value & AT91C_SR_READY_FOR_DATA) == 0));
1431 +
1432 + // Select Card
1433 + AT91F_MCI_SendCommand(pMCI_Device,
1434 + AT91C_SEL_DESEL_CARD_CMD,
1435 + (pMCI_Device->pMCI_DeviceFeatures->Relative_Card_Address)<<16);
1436 +
1437 + // Set bus width for Sdcard
1438 + if(pMCI_Device->pMCI_DeviceDesc->SDCard_bus_width == AT91C_MCI_SCDBUS)
1439 + bus_width = AT91C_BUS_WIDTH_4BITS;
1440 + else bus_width = AT91C_BUS_WIDTH_1BIT;
1441 +
1442 + if (AT91F_MCI_SDCard_SendAppCommand(pMCI_Device,AT91C_SDCARD_SET_BUS_WIDTH_CMD,bus_width) != AT91C_CMD_SEND_OK)
1443 + return AT91C_CMD_SEND_ERROR;
1444 +
1445 + return AT91C_CMD_SEND_OK;
1446 +}
1447 +
1448 +//*----------------------------------------------------------------------------
1449 +//* \fn AT91F_MCI_SDCard_Init
1450 +//* \brief Return the SDCard initialisation status
1451 +//*----------------------------------------------------------------------------
1452 +AT91S_MCIDeviceStatus AT91F_MCI_SDCard_Init (AT91PS_MciDevice pMCI_Device)
1453 +{
1454 + unsigned int tab_response[4];
1455 + unsigned int mult,blocknr;
1456 +
1457 + AT91F_MCI_SendCommand(pMCI_Device, AT91C_GO_IDLE_STATE_CMD, AT91C_NO_ARGUMENT);
1458 +
1459 + if(AT91F_MCI_SDCard_GetOCR(pMCI_Device) == AT91C_INIT_ERROR)
1460 + return AT91C_INIT_ERROR;
1461 +
1462 + if (AT91F_MCI_SDCard_GetCID(pMCI_Device,tab_response) == AT91C_CMD_SEND_OK)
1463 + {
1464 + pMCI_Device->pMCI_DeviceFeatures->Card_Inserted = AT91C_SD_CARD_INSERTED;
1465 +
1466 + if (AT91F_MCI_SendCommand(pMCI_Device, AT91C_SET_RELATIVE_ADDR_CMD, 0) == AT91C_CMD_SEND_OK)
1467 + {
1468 + pMCI_Device->pMCI_DeviceFeatures->Relative_Card_Address = (AT91C_BASE_MCI->MCI_RSPR[0] >> 16);
1469 + if (AT91F_MCI_GetCSD(pMCI_Device,pMCI_Device->pMCI_DeviceFeatures->Relative_Card_Address,tab_response) == AT91C_CMD_SEND_OK)
1470 + {
1471 + pMCI_Device->pMCI_DeviceFeatures->Max_Read_DataBlock_Length = 1 << ((tab_response[1] >> AT91C_CSD_RD_B_LEN_S) & AT91C_CSD_RD_B_LEN_M );
1472 + pMCI_Device->pMCI_DeviceFeatures->Max_Write_DataBlock_Length = 1 << ((tab_response[3] >> AT91C_CSD_WBLEN_S) & AT91C_CSD_WBLEN_M );
1473 + pMCI_Device->pMCI_DeviceFeatures->Sector_Size = 1 + ((tab_response[2] >> AT91C_CSD_v21_SECT_SIZE_S) & AT91C_CSD_v21_SECT_SIZE_M );
1474 + pMCI_Device->pMCI_DeviceFeatures->Read_Partial = (tab_response[1] >> AT91C_CSD_RD_B_PAR_S) & AT91C_CSD_RD_B_PAR_M;
1475 + pMCI_Device->pMCI_DeviceFeatures->Write_Partial = (tab_response[3] >> AT91C_CSD_WBLOCK_P_S) & AT91C_CSD_WBLOCK_P_M;
1476 + pMCI_Device->pMCI_DeviceFeatures->Erase_Block_Enable = (tab_response[3] >> AT91C_CSD_v21_ER_BLEN_EN_S) & AT91C_CSD_v21_ER_BLEN_EN_M;
1477 + pMCI_Device->pMCI_DeviceFeatures->Read_Block_Misalignment = (tab_response[1] >> AT91C_CSD_RD_B_MIS_S) & AT91C_CSD_RD_B_MIS_M;
1478 + pMCI_Device->pMCI_DeviceFeatures->Write_Block_Misalignment = (tab_response[1] >> AT91C_CSD_WR_B_MIS_S) & AT91C_CSD_WR_B_MIS_M;
1479 +
1480 + //// Compute Memory Capacity
1481 + // compute MULT
1482 + mult = 1 << ( ((tab_response[2] >> AT91C_CSD_C_SIZE_M_S) & AT91C_CSD_C_SIZE_M_M) + 2 );
1483 + // compute MSB of C_SIZE
1484 + blocknr = ((tab_response[1] >> AT91C_CSD_CSIZE_H_S) & AT91C_CSD_CSIZE_H_M) << 2;
1485 + // compute MULT * (LSB of C-SIZE + MSB already computed + 1) = BLOCKNR
1486 + blocknr = mult * ( ( blocknr + ( (tab_response[2] >> AT91C_CSD_CSIZE_L_S) & AT91C_CSD_CSIZE_L_M) ) + 1 );
1487 +
1488 + pMCI_Device->pMCI_DeviceFeatures->Memory_Capacity = pMCI_Device->pMCI_DeviceFeatures->Max_Read_DataBlock_Length * blocknr;
1489 + //// End of Compute Memory Capacity
1490 + printf("BLK 0x%x", pMCI_Device->pMCI_DeviceFeatures->Max_Read_DataBlock_Length);
1491 +
1492 + if( AT91F_MCI_SDCard_SetBusWidth(pMCI_Device) == AT91C_CMD_SEND_OK )
1493 + {
1494 + if (AT91F_MCI_SetBlocklength(pMCI_Device,pMCI_Device->pMCI_DeviceFeatures->Max_Read_DataBlock_Length) == AT91C_CMD_SEND_OK)
1495 + return AT91C_INIT_OK;
1496 + }
1497 + }
1498 + }
1499 + }
1500 + return AT91C_INIT_ERROR;
1501 +}
1502 diff -urN romboot.old/mci_main.cpp romboot/mci_main.cpp
1503 --- romboot.old/mci_main.cpp 1970-01-01 01:00:00.000000000 +0100
1504 +++ romboot/mci_main.cpp 2007-03-22 18:52:58.000000000 +0100
1505 @@ -0,0 +1,317 @@
1506 +//*----------------------------------------------------------------------------
1507 +//* ATMEL Microcontroller Software Support - ROUSSET -
1508 +//*----------------------------------------------------------------------------
1509 +//* The software is delivered "AS IS" without warranty or condition of any
1510 +//* kind, either express, implied or statutory. This includes without
1511 +//* limitation any warranty or condition with respect to merchantability or
1512 +//* fitness for any particular purpose, or against the infringements of
1513 +//* intellectual property rights of others.
1514 +//*----------------------------------------------------------------------------
1515 +//* File Name : main.c
1516 +//* Object : main application written in C
1517 +//* Creation : FB 21/11/2002
1518 +//*
1519 +//*----------------------------------------------------------------------------
1520 +#include "com.h"
1521 +#include "dataflash.h"
1522 +#include <AT91C_MCI_Device.h>
1523 +
1524 +#define AT91C_MCI_TIMEOUT 1000000 /* For AT91F_MCIDeviceWaitReady */
1525 +#define BUFFER_SIZE_MCI_DEVICE 512
1526 +#define MASTER_CLOCK 60000000
1527 +#define FALSE -1
1528 +#define TRUE 1
1529 +
1530 +//* External Functions
1531 +extern "C" void AT91F_ASM_MCI_Handler(void);
1532 +extern "C" void AT91F_MCI_Device_Handler(AT91PS_MciDevice,unsigned int);
1533 +extern AT91S_MCIDeviceStatus AT91F_MCI_SDCard_Init (AT91PS_MciDevice);
1534 +extern AT91S_MCIDeviceStatus AT91F_MCI_SetBlocklength(AT91PS_MciDevice,unsigned int);
1535 +extern AT91S_MCIDeviceStatus AT91F_MCI_ReadBlock(AT91PS_MciDevice,int,unsigned int *,int);
1536 +extern AT91S_MCIDeviceStatus AT91F_MCI_WriteBlock(AT91PS_MciDevice,int,unsigned int *,int);
1537 +//* Global Variables
1538 +AT91S_MciDeviceFeatures MCI_Device_Features;
1539 +AT91S_MciDeviceDesc MCI_Device_Desc;
1540 +AT91S_MciDevice MCI_Device;
1541 +
1542 +unsigned int dlBuffer = 0x20000000;
1543 +#undef MCI_TEST
1544 +#ifdef MCI_TEST
1545 +char TestString[] = "\r\nHello Hamish\r\n";
1546 +#endif
1547 +
1548 +//*----------------------------------------------------------------------------
1549 +//* \fn AT91F_MCIDeviceWaitReady
1550 +//* \brief Wait for MCI Device ready
1551 +//*----------------------------------------------------------------------------
1552 +void AT91F_MCIDeviceWaitReady(unsigned int timeout)
1553 +{
1554 + volatile int status;
1555 +
1556 + do
1557 + {
1558 + status = AT91C_BASE_MCI->MCI_SR;
1559 + timeout--;
1560 + }
1561 + while( !(status & AT91C_MCI_NOTBUSY) && (timeout>0) );
1562 +}
1563 +
1564 +unsigned int swab32(unsigned int data)
1565 +{
1566 + unsigned int res = 0;
1567 +
1568 + res = (data & 0x000000ff) << 24 |
1569 + (data & 0x0000ff00) << 8 |
1570 + (data & 0x00ff0000) >> 8 |
1571 + (data & 0xff000000) >> 24;
1572 +
1573 + return res;
1574 +}
1575 +
1576 +AT91S_MCIDeviceStatus readblock(
1577 + AT91PS_MciDevice pMCI_Device,
1578 + int src,
1579 + unsigned int *databuffer,
1580 + int sizeToRead)
1581 +{
1582 + int i;
1583 + unsigned char *buf = (unsigned char *)databuffer;
1584 +
1585 + //* Read Block 1
1586 + for(i=0;i<BUFFER_SIZE_MCI_DEVICE;i++)
1587 + *buf++ = 0x00;
1588 + AT91F_MCI_ReadBlock(&MCI_Device,src,databuffer,sizeToRead);
1589 +
1590 + //* Wait end of Read
1591 + AT91F_MCIDeviceWaitReady(AT91C_MCI_TIMEOUT);
1592 +
1593 + {
1594 + int index;
1595 + unsigned int *uiBuffer = databuffer;
1596 +
1597 + for(index = 0; index < 512/4; index++)
1598 + uiBuffer[index] = swab32(uiBuffer[index]);
1599 + }
1600 + return(1);
1601 +}
1602 +
1603 +#if 0
1604 +void printdata(unsigned int bufpos)
1605 + {
1606 + unsigned int *uip;
1607 + int linebytes = 16;
1608 + int nbytes = 64;
1609 + int size = 4;
1610 + int i;
1611 +
1612 + uip = (unsigned int *)bufpos;
1613 +
1614 + do {
1615 +
1616 + for(i=0; i<linebytes; i+=size) {
1617 + printf(" %08x", *uip++);
1618 + }
1619 +
1620 + printf("\n\r");
1621 + nbytes -= linebytes;
1622 + } while (nbytes > 0);
1623 + }
1624 +#endif
1625 +//extern char message[40];
1626 +
1627 +int notnull(int bufpos, unsigned int len)
1628 +{
1629 + int i;
1630 + unsigned char * bp = (unsigned char *)bufpos;
1631 +
1632 + for (i=0; i<len; i++)
1633 + if (bp[i] != '\0')
1634 + return(1);
1635 +
1636 + return(0);
1637 +}
1638 +//*----------------------------------------------------------------------------
1639 +//* \fn AT91F_Test
1640 +//* \brief Test Functions
1641 +//*----------------------------------------------------------------------------
1642 +int AT91F_Test(void)
1643 +{
1644 + int i;
1645 + unsigned int Max_Read_DataBlock_Length;
1646 + int block = 0;
1647 + int bufpos = dlBuffer;
1648 + int lastvalid = 0;
1649 + int NbPage = 0;
1650 +
1651 +
1652 + Max_Read_DataBlock_Length = MCI_Device.pMCI_DeviceFeatures->Max_Read_DataBlock_Length;
1653 +
1654 + //* ReadBlock & WriteBlock Test -> Entire Block
1655 +
1656 + //* Wait MCI Device Ready
1657 + AT91F_MCIDeviceWaitReady(AT91C_MCI_TIMEOUT);
1658 +
1659 +#ifdef MCI_TEST
1660 + //* Read Block 1
1661 + for(i=0;i<BUFFER_SIZE_MCI_DEVICE;i++) Buffer[i] = 0x00;
1662 + AT91F_MCI_ReadBlock(&MCI_Device,(1*Max_Read_DataBlock_Length),(unsigned int*) Buffer,Max_Read_DataBlock_Length);
1663 +
1664 + //* Wait end of Read
1665 + AT91F_MCIDeviceWaitReady(AT91C_MCI_TIMEOUT);
1666 +
1667 + // Write Page 1
1668 +// sprintf(Buffer,"\n\rThis sentence is written in your device... Congratulations\n\r");
1669 + for(i=0; i<16; i++)
1670 + Buffer[i] = TestString[i];
1671 + AT91F_MCI_WriteBlock(&MCI_Device,(1*Max_Read_DataBlock_Length),(unsigned int*) Buffer,Max_Read_DataBlock_Length);
1672 +
1673 + //* Wait end of Write
1674 + AT91F_MCIDeviceWaitReady(AT91C_MCI_TIMEOUT);
1675 +#endif
1676 +
1677 + for(i=0; i<64; i++) {
1678 + readblock(&MCI_Device, block*Max_Read_DataBlock_Length, (unsigned int *)bufpos, Max_Read_DataBlock_Length);
1679 + if (notnull(bufpos, Max_Read_DataBlock_Length))
1680 + lastvalid++;
1681 + block++;
1682 + bufpos += 512;
1683 + }
1684 +
1685 + i = dataflash_info[0].Device.pages_number;
1686 + while(i>>=1)
1687 + NbPage++;
1688 + i = lastvalid + (NbPage << 13) + (dataflash_info[0].Device.pages_size << 17);
1689 + *(int *)(dlBuffer + 0x14) = i;
1690 +
1691 + for(i=0; i<4688; i++) {
1692 + readblock(&MCI_Device, block*Max_Read_DataBlock_Length, (unsigned int *)bufpos, Max_Read_DataBlock_Length);
1693 + block++;
1694 + bufpos += 512;
1695 + }
1696 + write_dataflash(0xc0000000, dlBuffer, 512 * block);
1697 + //* End Of Test
1698 + printf("DONE %d\n\r", lastvalid);
1699 +
1700 +// printf(Buffer);
1701 +
1702 + return TRUE;
1703 +}
1704 +
1705 +//*----------------------------------------------------------------------------
1706 +//* \fn AT91F_CfgDevice
1707 +//* \brief This function is used to initialise MMC or SDCard Features
1708 +//*----------------------------------------------------------------------------
1709 +void AT91F_CfgDevice(void)
1710 +{
1711 + // Init Device Structure
1712 +
1713 + MCI_Device_Features.Relative_Card_Address = 0;
1714 + MCI_Device_Features.Card_Inserted = AT91C_CARD_REMOVED;
1715 + MCI_Device_Features.Max_Read_DataBlock_Length = 0;
1716 + MCI_Device_Features.Max_Write_DataBlock_Length = 0;
1717 + MCI_Device_Features.Read_Partial = 0;
1718 + MCI_Device_Features.Write_Partial = 0;
1719 + MCI_Device_Features.Erase_Block_Enable = 0;
1720 + MCI_Device_Features.Sector_Size = 0;
1721 + MCI_Device_Features.Memory_Capacity = 0;
1722 +
1723 + MCI_Device_Desc.state = AT91C_MCI_IDLE;
1724 + MCI_Device_Desc.SDCard_bus_width = AT91C_MCI_SCDBUS;
1725 +
1726 + // Init AT91S_DataFlash Global Structure, by default AT45DB choosen !!!
1727 + MCI_Device.pMCI_DeviceDesc = &MCI_Device_Desc;
1728 + MCI_Device.pMCI_DeviceFeatures = &MCI_Device_Features;
1729 +
1730 +}
1731 +
1732 +//*----------------------------------------------------------------------------
1733 +//* \fn AT91F_Test_SDCard
1734 +//* \brief Configure MCI for SDCard and complete SDCard init, then jump to Test Functions
1735 +//*----------------------------------------------------------------------------
1736 +int AT91F_Test_SDCard(void)
1737 +{
1738 + //////////////////////////////////////////////////////////
1739 + //* For SDCard Init
1740 + //////////////////////////////////////////////////////////
1741 +
1742 + AT91F_MCI_Configure(AT91C_BASE_MCI,
1743 + AT91C_MCI_DTOR_1MEGA_CYCLES,
1744 + AT91C_MCI_MR_PDCMODE, // 15MHz for MCK = 60MHz (CLKDIV = 1)
1745 + AT91C_MCI_SDCARD_4BITS_SLOTA);
1746 +
1747 + if(AT91F_MCI_SDCard_Init(&MCI_Device) != AT91C_INIT_OK)
1748 + return FALSE;
1749 +
1750 + printf("\n\rINI OK: TST\n\r");
1751 +
1752 + // Enter Main Tests
1753 + return(AT91F_Test());
1754 +}
1755 +
1756 +//*----------------------------------------------------------------------------
1757 +//* \fn AT91F_MCI_Handler
1758 +//* \brief MCI Handler
1759 +//*----------------------------------------------------------------------------
1760 +extern "C" void AT91F_MCI_Handler(void);
1761 +
1762 +void AT91F_MCI_Handler(void)
1763 +{
1764 + int status;
1765 +
1766 + status = ( AT91C_BASE_MCI->MCI_SR & AT91C_BASE_MCI->MCI_IMR );
1767 +
1768 + AT91F_MCI_Device_Handler(&MCI_Device,status);
1769 +}
1770 +
1771 +//*----------------------------------------------------------------------------
1772 +//* \fn main
1773 +//* \brief main function
1774 +//*----------------------------------------------------------------------------
1775 +int mci_main(void)
1776 +{
1777 +// printf("MCI Test\n\r");
1778 +
1779 +///////////////////////////////////////////////////////////////////////////////////////////
1780 +// MCI Init : common to MMC and SDCard
1781 +///////////////////////////////////////////////////////////////////////////////////////////
1782 +
1783 +// printf("\n\rInit MCI Interface\n\r");
1784 +
1785 + // Set up PIO SDC_TYPE to switch on MMC/SDCard and not DataFlash Card
1786 + AT91F_PIO_CfgOutput(AT91C_BASE_PIOB,AT91C_PIO_PB7);
1787 + AT91F_PIO_SetOutput(AT91C_BASE_PIOB,AT91C_PIO_PB7);
1788 +
1789 + // Init MCI for MMC and SDCard interface
1790 + AT91F_MCI_CfgPIO();
1791 + AT91F_MCI_CfgPMC();
1792 + AT91F_PDC_Open(AT91C_BASE_PDC_MCI);
1793 +
1794 + // Disable all the interrupts
1795 + AT91C_BASE_MCI->MCI_IDR = 0xFFFFFFFF;
1796 +
1797 + // Init MCI Device Structures
1798 + AT91F_CfgDevice();
1799 +
1800 + // Configure MCI interrupt
1801 + AT91F_AIC_ConfigureIt(AT91C_BASE_AIC,
1802 + AT91C_ID_MCI,
1803 + AT91C_AIC_PRIOR_HIGHEST,
1804 + AT91C_AIC_SRCTYPE_INT_LEVEL_SENSITIVE,
1805 + AT91F_ASM_MCI_Handler);
1806 +
1807 + // Enable MCI interrupt
1808 + AT91F_AIC_EnableIt(AT91C_BASE_AIC,AT91C_ID_MCI);
1809 +
1810 +///////////////////////////////////////////////////////////////////////////////////////////
1811 +// Enter Test Menu
1812 +///////////////////////////////////////////////////////////////////////////////////////////
1813 +
1814 + // Enable Receiver
1815 + AT91F_US_EnableRx((AT91PS_USART) AT91C_BASE_DBGU);
1816 +
1817 + if(AT91F_Test_SDCard() == TRUE)
1818 + printf("\n\rTST OK\n\r");
1819 + else
1820 + printf("\n\rTST Fail\n\r");
1821 + return(1);
1822 +}
Personal OpenWRT clone
This page took 0.136597 seconds and 5 git commands to generate.