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
00093 error = SD_ReadBlocks((sSdCard*)media->interface, address,data,length);
00094
00095
00096 media->state = MED_STATE_READY;
00097
00098
00099 if (callback != 0) {
00100
00101 callback(argument, error, 0, 0);
00102 }
00103
00104 return error;
00105 }
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120 static uint8_t MEDSdcard_Write(sMedia *media,
00121 uint32_t address,
00122 void *data,
00123 uint32_t length,
00124 MediaCallback callback,
00125 void *argument)
00126 {
00127 uint8_t error;
00128
00129
00130 if (media->state != MED_STATE_READY) {
00131
00132 TRACE_WARNING("MEDSdcard_Write: Media is busy\n\r");
00133 return MED_STATUS_BUSY;
00134 }
00135
00136
00137 if ((length + address) > media->size) {
00138
00139 TRACE_WARNING("MEDSdcard_Write: Data too big\n\r");
00140 return MED_STATUS_ERROR;
00141 }
00142
00143
00144 media->state = MED_STATE_BUSY;
00145
00146 error = SD_WriteBlocks((sSdCard*)media->interface, address,data,length);
00147
00148
00149 media->state = MED_STATE_READY;
00150
00151
00152 if (callback != 0) {
00153
00154 callback(argument, error, 0, 0);
00155 }
00156
00157 return error;
00158 }
00159
00160
00161
00162
00163
00164
00165
00166
00167
00168
00169
00170
00171
00172 static uint8_t MEDSdusb_Read(sMedia *media,
00173 uint32_t address,
00174 void *data,
00175 uint32_t length,
00176 MediaCallback callback,
00177 void *argument)
00178 {
00179 uint8_t error;
00180
00181 if (media->state != MED_STATE_READY) {
00182
00183 return MED_STATUS_BUSY;
00184 }
00185
00186 if ((length + address) > media->size) {
00187
00188
00189 return MED_STATUS_ERROR;
00190 }
00191
00192 media->state = MED_STATE_BUSY;
00193 #if 1
00194 error = SD_Read((sSdCard*)media->interface,
00195 address,data,length,
00196 (fSdmmcCallback)callback,NULL);
00197 error = (error ? MED_STATUS_ERROR : MED_STATUS_SUCCESS);
00198 media->state = MED_STATE_READY;
00199 if (callback) callback(argument, error, 0, 0);
00200 return error;
00201 #else
00202 MEDTransfer * pXfr;
00203
00204 pXfr = &media->transfer;
00205 pXfr->data = data;
00206 pXfr->address = address;
00207 pXfr->length = length;
00208 pXfr->callback = callback;
00209 pXfr->argument = argument;
00210
00211 error = SD_Read((sSdCard*)media->interface,
00212 address,
00213 data,
00214 length,
00215 (fSdmmcCallback)SdMmcCallback,
00216 media);
00217 return (error ? MED_STATUS_ERROR : MED_STATUS_SUCCESS);
00218 #endif
00219 }
00220
00221
00222
00223
00224
00225
00226
00227
00228
00229
00230
00231
00232
00233
00234 static uint8_t MEDSdusb_Write(sMedia *media,
00235 uint32_t address,
00236 void *data,
00237 uint32_t length,
00238 MediaCallback callback,
00239 void *argument)
00240 {
00241 uint8_t error;
00242 if (media->state != MED_STATE_READY) {
00243 TRACE_INFO("MEDSdusb_Write: Busy\n\r");
00244 return MED_STATUS_BUSY;
00245 }
00246
00247 if ((length + address) > media->size) {
00248 TRACE_WARNING("MEDSdcard_Write: Data too big\n\r");
00249 return MED_STATUS_ERROR;
00250 }
00251
00252 media->state = MED_STATE_BUSY;
00253 #if 1
00254 error = SD_Write((sSdCard*)media->interface,address,data,length,
00255 (fSdmmcCallback)callback,NULL);
00256 error = (error ? MED_STATUS_ERROR : MED_STATUS_SUCCESS);
00257 media->state = MED_STATE_READY;
00258 if (callback) callback(argument, error, 0, 0);
00259 return error;
00260 #else
00261 MEDTransfer * pXfr;
00262
00263 pXfr = &media->transfer;
00264 pXfr->data = data;
00265 pXfr->address = address;
00266 pXfr->length = length;
00267 pXfr->callback = callback;
00268 pXfr->argument = argument;
00269
00270 error = SD_Write((sSdCard*)media->interface,
00271 address,
00272 data,
00273 length,
00274 (fSdmmcCallback)SdMmcCallback,
00275 media);
00276 return (error ? MED_STATUS_ERROR : MED_STATUS_SUCCESS);
00277 #endif
00278 }
00279
00280
00281
00282
00283
00284
00285 uint8_t MEDSdcard_Initialize(sMedia *media, sSdCard *pSdDrv)
00286 {
00287 TRACE_INFO("MEDSdcard init\n\r");
00288
00289 media->interface = pSdDrv;
00290 #if !defined(OP_BOOTSTRAP_MCI_on)
00291 media->write = MEDSdcard_Write;
00292 #else
00293 media->write = 0;
00294 #endif
00295 media->read = MEDSdcard_Read;
00296 media->lock = 0;
00297 media->unlock = 0;
00298 media->handler = 0;
00299 media->flush = 0;
00300
00301 media->blockSize = SD_BLOCK_SIZE;
00302 media->baseAddress = 0;
00303 media->size = pSdDrv->dwNbBlocks;
00304
00305 media->mappedRD = 0;
00306 media->mappedWR = 0;
00307 media->removable = 1;
00308
00309 media->state = MED_STATE_READY;
00310
00311 media->transfer.data = 0;
00312 media->transfer.address = 0;
00313 media->transfer.length = 0;
00314 media->transfer.callback = 0;
00315 media->transfer.argument = 0;
00316
00317 return 1;
00318 }
00319
00320
00321
00322
00323
00324
00325 uint8_t MEDSdusb_Initialize(sMedia *media, sSdCard *pSdDrv)
00326 {
00327 printf("MEDSdusb init\n\r");
00328
00329
00330 media->interface = pSdDrv;
00331 media->write = MEDSdusb_Write;
00332 media->read = MEDSdusb_Read;
00333 media->lock = 0;
00334 media->unlock = 0;
00335 media->handler = 0;
00336 media->flush = 0;
00337
00338 media->blockSize = SD_BLOCK_SIZE;
00339 media->baseAddress = 0;
00340 media->size = pSdDrv->dwNbBlocks;
00341
00342 media->mappedRD = 0;
00343 media->mappedWR = 0;
00344 media->protected = 0;
00345 media->removable = 1;
00346
00347 media->state = MED_STATE_READY;
00348
00349 media->transfer.data = 0;
00350 media->transfer.address = 0;
00351 media->transfer.length = 0;
00352 media->transfer.callback = 0;
00353 media->transfer.argument = 0;
00354
00355 return 1;
00356 }
00357
00358
00359
00360
00361
00362
00363 void MEDSdcard_EraseAll(sMedia *media)
00364 {
00365 uint8_t buffer[SD_BLOCK_SIZE];
00366 uint32_t block;
00367 uint32_t multiBlock = 1;
00368 uint8_t error;
00369
00370 printf("MEDSdcard Erase All ...\n\r");
00371
00372
00373 memset(buffer, 0, media->blockSize * multiBlock);
00374
00375 for (block=0;
00376 block < (media->size-multiBlock);
00377 block += multiBlock) {
00378 error = SD_WriteBlocks((sSdCard*)media->interface, block,buffer,multiBlock);
00379 if( error ) {
00380 printf("\n\r-F- Failed to erase block (%u) #%u\n\r",
00381 (unsigned int)error, (unsigned int)block);
00382
00383 while (1);
00384 }
00385 }
00386 }
00387
00388
00389
00390
00391
00392
00393 void MEDSdcard_EraseBlock(sMedia *media, uint32_t block)
00394 {
00395 uint8_t buffer[SD_BLOCK_SIZE];
00396 uint8_t error;
00397
00398
00399 memset(buffer, 0, media->blockSize);
00400 error = SD_WriteBlocks((sSdCard*)media->interface, block,buffer,1);
00401 if( error ) {
00402 TRACE_ERROR("\n\r-F- Failed to write block (%u) #%u\n\r",
00403 (unsigned int)error, (unsigned int)block);
00404
00405 while (1);
00406 }
00407 }
00408