00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039 #include "board.h"
00040 #include "Media.h"
00041 #include "MEDSdcard.h"
00042 #include "libsdmmc.h"
00043 #include <assert.h>
00044 #include <string.h>
00045
00046
00047
00048
00049
00050 #define NUM_SD_SLOTS 1
00051
00052 #define SD_BLOCK_SIZE 512
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065 static uint8_t MEDSdcard_Read(sMedia *media,
00066 uint32_t address,
00067 void *data,
00068 uint32_t length,
00069 MediaCallback callback,
00070 void *argument)
00071 {
00072 uint8_t error;
00073
00074
00075 if (media->state != MED_STATE_READY) {
00076
00077 TRACE_INFO("Media busy\n\r");
00078 return MED_STATUS_BUSY;
00079 }
00080
00081
00082 if ((length + address) > media->size) {
00083
00084 TRACE_WARNING("MEDSdcard_Read: Data too big: %d, %d\n\r",
00085 (int)length, (int)address);
00086 return MED_STATUS_ERROR;
00087 }
00088
00089
00090 media->state = MED_STATE_BUSY;
00091
00092 error = SD_Read((sSdCard*)media->interface, address, data,length,NULL,NULL);
00093
00094
00095 media->state = MED_STATE_READY;
00096
00097
00098 if (callback != 0) {
00099
00100 callback(argument, error, 0, 0);
00101 }
00102
00103 return error;
00104 }
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119 static uint8_t MEDSdcard_Write(sMedia *media,
00120 uint32_t address,
00121 void *data,
00122 uint32_t length,
00123 MediaCallback callback,
00124 void *argument)
00125 {
00126 uint8_t error;
00127
00128
00129 if (media->state != MED_STATE_READY) {
00130
00131 TRACE_WARNING("MEDSdcard_Write: Media is busy\n\r");
00132 return MED_STATUS_BUSY;
00133 }
00134
00135
00136 if ((length + address) > media->size) {
00137
00138 TRACE_WARNING("MEDSdcard_Write: Data too big\n\r");
00139 return MED_STATUS_ERROR;
00140 }
00141
00142
00143 media->state = MED_STATE_BUSY;
00144
00145 error = SD_Write((sSdCard*)media->interface, address,data,length,NULL,NULL);
00146
00147
00148 media->state = MED_STATE_READY;
00149
00150
00151 if (callback != 0) {
00152
00153 callback(argument, error, 0, 0);
00154 }
00155
00156 return error;
00157 }
00158
00159
00160
00161
00162
00163
00164
00165
00166
00167
00168
00169
00170
00171 static uint8_t MEDSdusb_Read(sMedia *media,
00172 uint32_t address,
00173 void *data,
00174 uint32_t length,
00175 MediaCallback callback,
00176 void *argument)
00177 {
00178 uint8_t error;
00179
00180 if (media->state != MED_STATE_READY) {
00181
00182 return MED_STATUS_BUSY;
00183 }
00184
00185 if ((length + address) > media->size) {
00186
00187
00188 return MED_STATUS_ERROR;
00189 }
00190
00191 media->state = MED_STATE_BUSY;
00192 #if 1
00193 error = SD_Read((sSdCard*)media->interface,
00194 address,data,length,
00195 (fSdmmcCallback)callback,NULL);
00196 error = (error ? MED_STATUS_ERROR : MED_STATUS_SUCCESS);
00197 media->state = MED_STATE_READY;
00198 if (callback) callback(argument, error, 0, 0);
00199 return error;
00200 #else
00201 MEDTransfer * pXfr;
00202
00203 pXfr = &media->transfer;
00204 pXfr->data = data;
00205 pXfr->address = address;
00206 pXfr->length = length;
00207 pXfr->callback = callback;
00208 pXfr->argument = argument;
00209
00210 error = SD_Read((sSdCard*)media->interface,
00211 address,
00212 data,
00213 length,
00214 (fSdmmcCallback)SdMmcCallback,
00215 media);
00216 return (error ? MED_STATUS_ERROR : MED_STATUS_SUCCESS);
00217 #endif
00218 }
00219
00220
00221
00222
00223
00224
00225
00226
00227
00228
00229
00230
00231
00232
00233 static uint8_t MEDSdusb_Write(sMedia *media,
00234 uint32_t address,
00235 void *data,
00236 uint32_t length,
00237 MediaCallback callback,
00238 void *argument)
00239 {
00240 uint8_t error;
00241 if (media->state != MED_STATE_READY) {
00242 TRACE_INFO("MEDSdusb_Write: Busy\n\r");
00243 return MED_STATUS_BUSY;
00244 }
00245
00246 if ((length + address) > media->size) {
00247 TRACE_WARNING("MEDSdcard_Write: Data too big\n\r");
00248 return MED_STATUS_ERROR;
00249 }
00250
00251 media->state = MED_STATE_BUSY;
00252 #if 1
00253 error = SD_Write((sSdCard*)media->interface,address,data,length,
00254 (fSdmmcCallback)callback,NULL);
00255 error = (error ? MED_STATUS_ERROR : MED_STATUS_SUCCESS);
00256 media->state = MED_STATE_READY;
00257 if (callback) callback(argument, error, 0, 0);
00258 return error;
00259 #else
00260 MEDTransfer * pXfr;
00261
00262 pXfr = &media->transfer;
00263 pXfr->data = data;
00264 pXfr->address = address;
00265 pXfr->length = length;
00266 pXfr->callback = callback;
00267 pXfr->argument = argument;
00268
00269 error = SD_Write((sSdCard*)media->interface,
00270 address,
00271 data,
00272 length,
00273 (fSdmmcCallback)SdMmcCallback,
00274 media);
00275 return (error ? MED_STATUS_ERROR : MED_STATUS_SUCCESS);
00276 #endif
00277 }
00278
00279
00280
00281
00282
00283
00284 uint8_t MEDSdcard_Initialize(sMedia *media, sSdCard *pSdDrv)
00285 {
00286 TRACE_INFO("MEDSdcard init\n\r");
00287
00288 media->interface = pSdDrv;
00289 #if !defined(OP_BOOTSTRAP_MCI_on)
00290 media->write = MEDSdcard_Write;
00291 #else
00292 media->write = 0;
00293 #endif
00294 media->read = MEDSdcard_Read;
00295 media->lock = 0;
00296 media->unlock = 0;
00297 media->handler = 0;
00298 media->flush = 0;
00299
00300 media->blockSize = SD_BLOCK_SIZE;
00301 media->baseAddress = 0;
00302 media->size = pSdDrv->dwNbBlocks;
00303
00304 media->mappedRD = 0;
00305 media->mappedWR = 0;
00306 media->removable = 1;
00307
00308 media->state = MED_STATE_READY;
00309
00310 media->transfer.data = 0;
00311 media->transfer.address = 0;
00312 media->transfer.length = 0;
00313 media->transfer.callback = 0;
00314 media->transfer.argument = 0;
00315
00316 return 1;
00317 }
00318
00319
00320
00321
00322
00323
00324 uint8_t MEDSdusb_Initialize(sMedia *media, sSdCard *pSdDrv)
00325 {
00326 printf("MEDSdusb init\n\r");
00327
00328
00329 media->interface = pSdDrv;
00330 media->write = MEDSdusb_Write;
00331 media->read = MEDSdusb_Read;
00332 media->lock = 0;
00333 media->unlock = 0;
00334 media->handler = 0;
00335 media->flush = 0;
00336
00337 media->blockSize = SD_BLOCK_SIZE;
00338 media->baseAddress = 0;
00339 media->size = pSdDrv->dwNbBlocks;
00340
00341 media->mappedRD = 0;
00342 media->mappedWR = 0;
00343 media->protected = 0;
00344 media->removable = 1;
00345
00346 media->state = MED_STATE_READY;
00347
00348 media->transfer.data = 0;
00349 media->transfer.address = 0;
00350 media->transfer.length = 0;
00351 media->transfer.callback = 0;
00352 media->transfer.argument = 0;
00353
00354 return 1;
00355 }
00356
00357
00358
00359
00360
00361
00362 void MEDSdcard_EraseAll(sMedia *media)
00363 {
00364 uint8_t buffer[SD_BLOCK_SIZE];
00365 uint32_t block;
00366 uint32_t multiBlock = 1;
00367 uint8_t error;
00368
00369 printf("MEDSdcard Erase All ...\n\r");
00370
00371
00372 memset(buffer, 0, media->blockSize * multiBlock);
00373
00374 for (block=0;
00375 block < (media->size-multiBlock);
00376 block += multiBlock) {
00377 error = SD_WriteBlocks((sSdCard*)media->interface, block,buffer,multiBlock);
00378 if( error ) {
00379 printf("\n\r-F- Failed to erase block (%u) #%u\n\r",
00380 (unsigned int)error, (unsigned int)block);
00381
00382 while (1);
00383 }
00384 }
00385 }
00386
00387
00388
00389
00390
00391
00392 void MEDSdcard_EraseBlock(sMedia *media, uint32_t block)
00393 {
00394 uint8_t buffer[SD_BLOCK_SIZE];
00395 uint8_t error;
00396
00397
00398 memset(buffer, 0, media->blockSize);
00399 error = SD_WriteBlocks((sSdCard*)media->interface, block,buffer,1);
00400 if( error ) {
00401 TRACE_ERROR("\n\r-F- Failed to write block (%u) #%u\n\r",
00402 (unsigned int)error, (unsigned int)block);
00403
00404 while (1);
00405 }
00406 }
00407