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
00040 #include "board.h"
00041 #include "Media.h"
00042 #include "MEDSdcard.h"
00043 #include "libsdmmc.h"
00044 #include <assert.h>
00045 #include <string.h>
00046
00047
00048
00049
00050
00051 #define NUM_SD_SLOTS 1
00052
00053 #define SD_BLOCK_SIZE 512
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066 static uint8_t MEDSdcard_Read(sMedia *media,
00067 uint32_t address,
00068 void *data,
00069 uint32_t length,
00070 MediaCallback callback,
00071 void *argument)
00072 {
00073 uint8_t error;
00074
00075
00076 if (media->state != MED_STATE_READY) {
00077
00078 TRACE_INFO("Media busy\n\r");
00079 return MED_STATUS_BUSY;
00080 }
00081
00082
00083 if ((length + address) > media->size) {
00084
00085 TRACE_WARNING("MEDSdcard_Read: Data too big: %d, %d\n\r",
00086 (int)length, (int)address);
00087 return MED_STATUS_ERROR;
00088 }
00089
00090
00091 media->state = MED_STATE_BUSY;
00092
00093 error = SD_Read((sSdCard *)media->interface, address, data, length, NULL, NULL);
00094
00095
00096 media->state = MED_STATE_READY;
00097
00098
00099 if (callback != 0)
00100
00101 callback(argument, error, 0, 0);
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,
00146 NULL);
00147
00148
00149 media->state = MED_STATE_READY;
00150
00151
00152 if (callback != 0)
00153
00154 callback(argument, error, 0, 0);
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
00181 if (media->state != MED_STATE_READY) {
00182
00183 return MED_STATUS_BUSY;
00184 }
00185
00186
00187 if ((length + address) > media->size) {
00188
00189
00190 return MED_STATUS_ERROR;
00191 }
00192
00193
00194 media->state = MED_STATE_BUSY;
00195 #if 1
00196 error = SD_Read((sSdCard *)media->interface,
00197 address, data, length,
00198 (fSdmmcCallback)callback, NULL);
00199 error = (error ? MED_STATUS_ERROR : MED_STATUS_SUCCESS);
00200 media->state = MED_STATE_READY;
00201
00202 if (callback) callback(argument, error, 0, 0);
00203
00204 return error;
00205 #else
00206 MEDTransfer *pXfr;
00207
00208 pXfr = &media->transfer;
00209 pXfr->data = data;
00210 pXfr->address = address;
00211 pXfr->length = length;
00212 pXfr->callback = callback;
00213 pXfr->argument = argument;
00214
00215 error = SD_Read((sSdCard *)media->interface,
00216 address,
00217 data,
00218 length,
00219 (fSdmmcCallback)SdMmcCallback,
00220 media);
00221 return (error ? MED_STATUS_ERROR : MED_STATUS_SUCCESS);
00222 #endif
00223 }
00224
00225
00226
00227
00228
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238 static uint8_t MEDSdusb_Write(sMedia *media,
00239 uint32_t address,
00240 void *data,
00241 uint32_t length,
00242 MediaCallback callback,
00243 void *argument)
00244 {
00245 uint8_t error;
00246
00247 if (media->state != MED_STATE_READY) {
00248 TRACE_INFO("MEDSdusb_Write: Busy\n\r");
00249 return MED_STATUS_BUSY;
00250 }
00251
00252
00253 if ((length + address) > media->size) {
00254 TRACE_WARNING("MEDSdcard_Write: Data too big\n\r");
00255 return MED_STATUS_ERROR;
00256 }
00257
00258
00259 media->state = MED_STATE_BUSY;
00260 #if 1
00261 error = SD_Write((sSdCard *)media->interface, address, data, length,
00262 (fSdmmcCallback)callback, NULL);
00263 error = (error ? MED_STATUS_ERROR : MED_STATUS_SUCCESS);
00264 media->state = MED_STATE_READY;
00265
00266 if (callback) callback(argument, error, 0, 0);
00267
00268 return error;
00269 #else
00270 MEDTransfer *pXfr;
00271
00272 pXfr = &media->transfer;
00273 pXfr->data = data;
00274 pXfr->address = address;
00275 pXfr->length = length;
00276 pXfr->callback = callback;
00277 pXfr->argument = argument;
00278
00279 error = SD_Write((sSdCard *)media->interface,
00280 address,
00281 data,
00282 length,
00283 (fSdmmcCallback)SdMmcCallback,
00284 media);
00285 return (error ? MED_STATUS_ERROR : MED_STATUS_SUCCESS);
00286 #endif
00287 }
00288
00289
00290
00291
00292
00293
00294 uint8_t MEDSdcard_Initialize(sMedia *media, sSdCard *pSdDrv)
00295 {
00296 TRACE_INFO("MEDSdcard init\n\r");
00297
00298 media->interface = pSdDrv;
00299 #if !defined(OP_BOOTSTRAP_MCI_on)
00300 media->write = MEDSdcard_Write;
00301 #else
00302 media->write = 0;
00303 #endif
00304 media->read = MEDSdcard_Read;
00305 media->lock = 0;
00306 media->unlock = 0;
00307 media->handler = 0;
00308 media->flush = 0;
00309
00310 media->blockSize = SD_BLOCK_SIZE;
00311 media->baseAddress = 0;
00312 media->size = pSdDrv->dwNbBlocks;
00313
00314 media->mappedRD = 0;
00315 media->mappedWR = 0;
00316 media->removable = 1;
00317
00318 media->state = MED_STATE_READY;
00319
00320 media->transfer.data = 0;
00321 media->transfer.address = 0;
00322 media->transfer.length = 0;
00323 media->transfer.callback = 0;
00324 media->transfer.argument = 0;
00325
00326 return 1;
00327 }
00328
00329
00330
00331
00332
00333
00334 uint8_t MEDSdusb_Initialize(sMedia *media, sSdCard *pSdDrv)
00335 {
00336 printf("MEDSdusb init\n\r");
00337
00338
00339 media->interface = pSdDrv;
00340 media->write = MEDSdusb_Write;
00341 media->read = MEDSdusb_Read;
00342 media->lock = 0;
00343 media->unlock = 0;
00344 media->handler = 0;
00345 media->flush = 0;
00346
00347 media->blockSize = SD_BLOCK_SIZE;
00348 media->baseAddress = 0;
00349 media->size = pSdDrv->dwNbBlocks;
00350
00351 media->mappedRD = 0;
00352 media->mappedWR = 0;
00353 media->protected = 0;
00354 media->removable = 1;
00355
00356 media->state = MED_STATE_READY;
00357
00358 media->transfer.data = 0;
00359 media->transfer.address = 0;
00360 media->transfer.length = 0;
00361 media->transfer.callback = 0;
00362 media->transfer.argument = 0;
00363
00364 return 1;
00365 }
00366
00367
00368
00369
00370
00371
00372 void MEDSdcard_EraseAll(sMedia *media)
00373 {
00374 uint8_t buffer[SD_BLOCK_SIZE];
00375 uint32_t block;
00376 uint32_t multiBlock = 1;
00377 uint8_t error;
00378
00379 printf("MEDSdcard Erase All ...\n\r");
00380
00381
00382 memset(buffer, 0, media->blockSize * multiBlock);
00383
00384 for (block = 0;
00385 block < (media->size - multiBlock);
00386 block += multiBlock) {
00387 error = SD_WriteBlocks((sSdCard *)media->interface, block, buffer, multiBlock);
00388
00389 if (error) {
00390 printf("\n\r-F- Failed to erase block (%u) #%u\n\r",
00391 (unsigned int)error, (unsigned int)block);
00392
00393
00394 while (1);
00395 }
00396 }
00397 }
00398
00399
00400
00401
00402
00403
00404 void MEDSdcard_EraseBlock(sMedia *media, uint32_t block)
00405 {
00406 uint8_t buffer[SD_BLOCK_SIZE];
00407 uint8_t error;
00408
00409
00410 memset(buffer, 0, media->blockSize);
00411 error = SD_WriteBlocks((sSdCard *)media->interface, block, buffer, 1);
00412
00413 if (error) {
00414 TRACE_ERROR("\n\r-F- Failed to write block (%u) #%u\n\r",
00415 (unsigned int)error, (unsigned int)block);
00416
00417
00418 while (1);
00419 }
00420 }
00421