00001
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
00041
00042
00043
00044
00045
00046
00047
00048 #include "conf_access.h"
00049
00050
00051 #if SD_MMC_SPI_MEM == ENABLE
00052
00053 #include "compiler.h"
00054 #include "board.h"
00055 #include "gpio.h"
00056 #include "spi.h"
00057 #include "conf_sd_mmc_spi.h"
00058 #include "sd_mmc_spi.h"
00059
00060
00061
00062
00063 #define NO_SUPPORT_USB_PING_PONG // defines if USB endpoints do not support ping pong mode
00064
00065
00066
00067
00068 static U32 gl_ptr_mem;
00069 static U8 sector_buf[MMC_SECTOR_SIZE];
00070
00071 Bool sd_mmc_spi_init_done = FALSE;
00072 U8 r1;
00073 U16 r2;
00074
00075 U8 csd[16];
00076 volatile U32 capacity;
00077 volatile U32 sd_mmc_spi_last_block_address;
00078 U16 erase_group_size;
00079 U8 card_type;
00080
00081
00082 U8 data_mem[513];
00083 #if (defined SD_MMC_READ_CID) && (SD_MMC_READ_CID == ENABLED)
00084 U8 cid[16];
00085 #endif
00086
00087
00088
00089
00096 Bool sd_mmc_spi_internal_init(void)
00097 {
00098 U16 retry;
00099
00100
00101 sd_mmc_spi_init_done = FALSE;
00102 card_type = MMC_CARD;
00103 retry = 0;
00104 do
00105 {
00106
00107 r1 = sd_mmc_spi_send_command(MMC_GO_IDLE_STATE, 0);
00108 spi_write(SD_MMC_SPI,0xFF);
00109
00110 retry++;
00111 if(retry > 100)
00112 return KO;
00113 }
00114 while(r1 != 0x01);
00115
00116
00117
00118 r1 = sd_mmc_spi_send_command(SD_APP_CMD55,0);
00119 spi_write(SD_MMC_SPI,0xFF);
00120
00121 r1 = sd_mmc_spi_send_command(SD_SEND_OP_COND_ACMD, 0);
00122 spi_write(SD_MMC_SPI,0xFF);
00123
00124 if ((r1&0xFE) == 0)
00125 {
00126 card_type = SD_CARD;
00127 }
00128 else
00129 {
00130 card_type = MMC_CARD;
00131
00132 retry = 0;
00133 do
00134 {
00135
00136 r1 = sd_mmc_spi_send_command(MMC_GO_IDLE_STATE, 0);
00137 spi_write(SD_MMC_SPI,0xFF);
00138
00139 retry++;
00140 if(retry > 100)
00141 return KO;
00142 }
00143 while(r1 != 0x01);
00144 }
00145
00146
00147
00148 retry = 0;
00149 do
00150 {
00151
00152 r1 = sd_mmc_spi_send_command(MMC_SEND_OP_COND, 0);
00153 spi_write(SD_MMC_SPI,0xFF);
00154
00155 retry++;
00156 if(retry == 50000)
00157 return KO;
00158 }
00159 while (r1);
00160
00161
00162 r1 = sd_mmc_spi_send_command(MMC_CRC_ON_OFF, 0);
00163 spi_write(SD_MMC_SPI,0xFF);
00164
00165
00166 r1 = sd_mmc_spi_send_command(MMC_SET_BLOCKLEN, 512);
00167 spi_write(SD_MMC_SPI,0xFF);
00168 if (r1 != 0x00)
00169 return KO;
00170
00171
00172 if (KO == sd_mmc_spi_get_csd(csd))
00173 return KO;
00174
00175
00176 sd_mmc_spi_get_capacity();
00177
00178
00179 #if (defined SD_MMC_READ_CID) && (SD_MMC_READ_CID == ENABLED)
00180 if (KO == sd_mmc_spi_get_cid(cid))
00181 return KO;
00182 #endif
00183
00184 sd_mmc_spi_init_done = TRUE;
00185
00186 return(OK);
00187 }
00188
00195 Bool sd_mmc_spi_init(spi_options_t spiOptions, unsigned int pba_hz)
00196 {
00197
00198 spi_setupChipReg(SD_MMC_SPI, &spiOptions, pba_hz);
00199
00200
00201 return sd_mmc_spi_internal_init();
00202 }
00203
00213 U8 sd_mmc_spi_send_command(U8 command, U32 arg)
00214 {
00215 spi_selectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
00216 r1 = sd_mmc_spi_command(command, arg);
00217 spi_unselectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
00218 return r1;
00219 }
00220
00230 U8 sd_mmc_spi_command(U8 command, U32 arg)
00231 {
00232 U8 retry;
00233
00234 spi_write(SD_MMC_SPI,0xFF);
00235 spi_write(SD_MMC_SPI,command | 0x40);
00236 spi_write(SD_MMC_SPI,arg>>24);
00237 spi_write(SD_MMC_SPI,arg>>16);
00238 spi_write(SD_MMC_SPI,arg>>8 );
00239 spi_write(SD_MMC_SPI,arg );
00240 spi_write(SD_MMC_SPI,0x95);
00241
00242
00243
00244
00245 retry = 0;
00246 r1 = 0xFF;
00247 while((r1 = sd_mmc_spi_send_and_read(0xFF)) == 0xFF)
00248 {
00249 retry++;
00250 if(retry > 10) break;
00251 }
00252 return r1;
00253 }
00254
00255
00256
00265 U8 sd_mmc_spi_send_and_read(U8 data_to_send)
00266 {
00267 unsigned short data_read;
00268 spi_write(SD_MMC_SPI,data_to_send);
00269 if( SPI_ERROR_TIMEOUT == spi_read(SD_MMC_SPI,&data_read) )
00270 return 0xFF;
00271 return (data_read);
00272 }
00273
00274
00275
00283 Bool sd_mmc_spi_get_csd(U8 *buffer)
00284 {
00285 U8 retry;
00286 unsigned short data_read;
00287
00288 if (KO == sd_mmc_spi_wait_not_busy())
00289 return KO;
00290
00291 spi_selectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
00292
00293 r1 = sd_mmc_spi_command(MMC_SEND_CSD, 0);
00294
00295 if(r1 != 0x00)
00296 {
00297 spi_unselectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
00298 sd_mmc_spi_init_done = FALSE;
00299 return KO;
00300 }
00301
00302 retry = 0;
00303 while((r1 = sd_mmc_spi_send_and_read(0xFF)) != MMC_STARTBLOCK_READ)
00304 {
00305 if (retry > 8)
00306 {
00307 spi_unselectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
00308 return KO;
00309 }
00310 retry++;
00311 }
00312 for (retry = 0; retry <16; retry++)
00313 {
00314 spi_write(SD_MMC_SPI,0xFF);
00315 spi_read(SD_MMC_SPI,&data_read);
00316 buffer[retry] = data_read;
00317 }
00318 spi_write(SD_MMC_SPI,0xFF);
00319 spi_write(SD_MMC_SPI,0xFF);
00320 spi_write(SD_MMC_SPI,0xFF);
00321 spi_unselectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
00322 return OK;
00323 }
00324
00325
00333 Bool sd_mmc_spi_get_cid(U8 *buffer)
00334 {
00335 U8 retry;
00336 unsigned short data_read;
00337
00338 if (KO == sd_mmc_spi_wait_not_busy())
00339 return KO;
00340
00341 spi_unselectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
00342
00343 r1 = sd_mmc_spi_command(MMC_SEND_CID, 0);
00344
00345 if(r1 != 0x00)
00346 {
00347 spi_unselectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
00348 sd_mmc_spi_init_done = FALSE;
00349 return KO;
00350 }
00351
00352 retry = 0;
00353 while((r2 = sd_mmc_spi_send_and_read(0xFF)) != MMC_STARTBLOCK_READ)
00354 {
00355 if (retry > 8)
00356 {
00357 spi_unselectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
00358 return KO;
00359 }
00360 retry++;
00361 }
00362
00363 for (retry = 0; retry <16; retry++)
00364 {
00365 spi_write(SD_MMC_SPI,0xFF);
00366 spi_read(SD_MMC_SPI,&data_read);
00367 buffer[retry] = data_read;
00368 }
00369 spi_write(SD_MMC_SPI,0xFF);
00370 spi_write(SD_MMC_SPI,0xFF);
00371 spi_write(SD_MMC_SPI,0xFF);
00372 spi_unselectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
00373 return OK;
00374 }
00375
00376
00377
00404 void sd_mmc_spi_get_capacity(void)
00405 {
00406 U16 c_size;
00407 U8 c_size_mult;
00408 U8 read_bl_len;
00409 U8 erase_grp_size;
00410 U8 erase_grp_mult;
00411
00412
00413 c_size = ((csd[6] & 0x03) << 10) + (csd[7] << 2) + ((csd[8] & 0xC0) >> 6);
00414 c_size_mult = ((csd[9] & 0x03) << 1) + ((csd[10] & 0x80) >> 7);
00415 read_bl_len = csd[5] & 0x0F;
00416 if (card_type == MMC_CARD)
00417 {
00418 erase_grp_size = ((csd[10] & 0x7C) >> 2);
00419 erase_grp_mult = ((csd[10] & 0x03) << 3) | ((csd[11] & 0xE0) >> 5);
00420 }
00421 else
00422 {
00423 erase_grp_size = ((csd[10] & 0x3F) << 1) + ((csd[11] & 0x80) >> 7);
00424 erase_grp_mult = 0;
00425 }
00426
00427
00428 sd_mmc_spi_last_block_address = ((U32)(c_size + 1) * (U32)((1 << (c_size_mult + 2)))) - 1;
00429 if (read_bl_len > 9)
00430 sd_mmc_spi_last_block_address <<= (read_bl_len - 9);
00431
00432
00433 capacity = (1 << read_bl_len) * (sd_mmc_spi_last_block_address + 1);
00434
00435
00436 erase_group_size = (erase_grp_size + 1) * (erase_grp_mult + 1);
00437 }
00438
00439
00440
00447 Bool sd_mmc_spi_get_status(void)
00448 {
00449 U8 retry, spireg;
00450
00451
00452 if (KO == sd_mmc_spi_wait_not_busy())
00453 return KO;
00454
00455 spi_selectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
00456
00457
00458 spi_write(SD_MMC_SPI,MMC_SEND_STATUS | 0x40);
00459 spi_write(SD_MMC_SPI,0);
00460 spi_write(SD_MMC_SPI,0);
00461 spi_write(SD_MMC_SPI,0);
00462 spi_write(SD_MMC_SPI,0);
00463 spi_write(SD_MMC_SPI,0x95);
00464
00465
00466
00467
00468 retry = 0;
00469 r2 = 0xFFFF;
00470 spireg = 0xFF;
00471 while((spireg = sd_mmc_spi_send_and_read(0xFF)) == 0xFF)
00472 {
00473 retry++;
00474 if(retry > 10)
00475 {
00476 spi_unselectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
00477 return KO;
00478 }
00479 }
00480 r2 = ((U16)(spireg) << 8) + sd_mmc_spi_send_and_read(0xFF);
00481
00482 spi_write(SD_MMC_SPI,0xFF);
00483 spi_unselectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
00484
00485 return OK;
00486 }
00487
00488
00494 Bool sd_mmc_spi_wait_not_busy(void)
00495 {
00496 U16 retry;
00497
00498
00499 spi_selectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
00500 retry = 0;
00501 while((r1 = sd_mmc_spi_send_and_read(0xFF)) != 0xFF)
00502 {
00503 retry++;
00504 if (retry == 50000)
00505 {
00506 spi_unselectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
00507 return KO;
00508 }
00509 }
00510 spi_unselectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
00511 return OK;
00512 }
00513
00514
00515
00524 Bool sd_mmc_spi_check_presence(void)
00525 {
00526 U16 retry;
00527
00528 retry = 0;
00529 if (sd_mmc_spi_init_done == FALSE)
00530 {
00531
00532
00533 while ((r1 = sd_mmc_spi_send_command(MMC_GO_IDLE_STATE, 0)) != 0x01)
00534 {
00535 spi_write(SD_MMC_SPI,0xFF);
00536 retry++;
00537 if (retry > 10)
00538 return KO;
00539 }
00540 return OK;
00541 }
00542 else
00543 {
00544 if ((r1 = sd_mmc_spi_send_command(MMC_CRC_ON_OFF,0)) == 0x00)
00545 return OK;
00546 sd_mmc_spi_init_done = FALSE;
00547 return KO;
00548 }
00549 }
00550
00551
00559 Bool sd_mmc_spi_mem_check(void)
00560 {
00561 if (sd_mmc_spi_check_presence() == OK)
00562 {
00563 if (sd_mmc_spi_init_done == FALSE)
00564 {
00565 sd_mmc_spi_internal_init();
00566 }
00567 if (sd_mmc_spi_init_done == TRUE)
00568 return OK;
00569 else
00570 return KO;
00571 }
00572 return KO;
00573 }
00574
00575
00576
00586 Bool is_sd_mmc_spi_write_pwd_locked(void)
00587 {
00588 if (card_type == MMC_CARD)
00589 {
00590 if (((csd[0] >> 2) & 0x0F) < 2)
00591 return KO;
00592 }
00593 if (KO == sd_mmc_spi_get_status())
00594 return KO;
00595 if ((r2&0x0001) != 0)
00596 return OK;
00597
00598 return KO;
00599 }
00600
00601
00628 Bool sd_mmc_spi_lock_operation(U8 operation, U8 pwd_lg, U8 * pwd)
00629 {
00630 Bool status = OK;
00631 U8 retry;
00632
00633
00634 if ((operation != OP_FORCED_ERASE) && (pwd_lg == 0))
00635 return KO;
00636
00637
00638 if (sd_mmc_spi_wait_not_busy() == KO)
00639 return KO;
00640
00641
00642 if (operation == OP_FORCED_ERASE)
00643 r1 = sd_mmc_spi_send_command(MMC_SET_BLOCKLEN, 1);
00644 else
00645 r1 = sd_mmc_spi_send_command(MMC_SET_BLOCKLEN, pwd_lg+2);
00646 spi_write(SD_MMC_SPI,0xFF);
00647 spi_write(SD_MMC_SPI,0xFF);
00648 spi_write(SD_MMC_SPI,0xFF);
00649 if (r1 != 0x00)
00650 return KO;
00651
00652
00653 spi_selectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
00654
00655
00656 r1 = sd_mmc_spi_command(MMC_LOCK_UNLOCK, 0);
00657
00658
00659 if(r1 != 0x00)
00660 {
00661 status = KO;
00662 }
00663
00664 spi_write(SD_MMC_SPI,0xFF);
00665
00666
00667 spi_write(SD_MMC_SPI,MMC_STARTBLOCK_WRITE);
00668
00669 spi_write(SD_MMC_SPI,operation);
00670 if (operation != OP_FORCED_ERASE)
00671 {
00672 spi_write(SD_MMC_SPI,pwd_lg);
00673 for(retry=0 ; retry<pwd_lg ; retry++)
00674 {
00675 spi_write(SD_MMC_SPI,*(pwd+retry));
00676 }
00677 }
00678 spi_write(SD_MMC_SPI,0xFF);
00679 spi_write(SD_MMC_SPI,0xFF);
00680
00681
00682 retry = 0;
00683 r1 = sd_mmc_spi_send_and_read(0xFF);
00684 if ((r1 & MMC_DR_MASK) != MMC_DR_ACCEPT)
00685 status = KO;
00686
00687 spi_write(SD_MMC_SPI,0xFF);
00688 spi_unselectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
00689
00690
00691 if (operation == OP_FORCED_ERASE)
00692 retry = 100;
00693 else
00694 retry = 10;
00695 while (sd_mmc_spi_wait_not_busy() == KO)
00696 {
00697 retry--;
00698 if (retry == 0)
00699 {
00700 status = KO;
00701 break;
00702 }
00703 }
00704
00705
00706 if (KO == sd_mmc_spi_get_status())
00707 status = KO;
00708 if ((r2&0x0002) != 0)
00709 status = KO;
00710
00711
00712 r1 = sd_mmc_spi_send_command(MMC_SET_BLOCKLEN, 512);
00713 if (r1 != 0x00)
00714 status = KO;
00715
00716 return status;
00717 }
00718
00719
00720
00728 Bool sd_mmc_spi_read_open (U32 pos)
00729 {
00730
00731 gl_ptr_mem = pos << 9;
00732
00733
00734 return sd_mmc_spi_wait_not_busy();
00735 }
00736
00737
00741 void sd_mmc_spi_read_close (void)
00742 {
00743
00744 }
00745
00746
00758 Bool sd_mmc_spi_write_open (U32 pos)
00759 {
00760
00761 gl_ptr_mem = pos << 9;
00762
00763
00764 return sd_mmc_spi_wait_not_busy();
00765 }
00766
00767
00772 void sd_mmc_spi_write_close (void)
00773 {
00774
00775 }
00776
00783 Bool sd_mmc_spi_read_multiple_sector(U16 nb_sector)
00784 {
00785 while (nb_sector--)
00786 {
00787
00788 sd_mmc_spi_read_sector_to_ram(sector_buf);
00789 sd_mmc_spi_read_multiple_sector_callback(sector_buf);
00790 }
00791
00792 return OK;
00793 }
00794
00801 Bool sd_mmc_spi_write_multiple_sector(U16 nb_sector)
00802 {
00803 while (nb_sector--)
00804 {
00805
00806 sd_mmc_spi_write_multiple_sector_callback(sector_buf);
00807 sd_mmc_spi_write_sector_from_ram(sector_buf);
00808 }
00809
00810 return OK;
00811 }
00812
00831 Bool sd_mmc_spi_erase_sector_group(U32 adr_start, U32 adr_end)
00832 {
00833 U8 cmd;
00834
00835
00836 if (KO == sd_mmc_spi_wait_not_busy())
00837 return KO;
00838
00839 spi_selectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
00840
00841
00842 if (card_type == MMC_CARD)
00843 { cmd = MMC_TAG_ERASE_GROUP_START; }
00844 else
00845 { cmd = SD_TAG_WR_ERASE_GROUP_START; }
00846 if ((r1 = sd_mmc_spi_command(cmd,(adr_start << 9))) != 0)
00847 {
00848 spi_unselectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
00849 return KO;
00850 }
00851 spi_write(SD_MMC_SPI,0xFF);
00852
00853
00854 if (card_type == MMC_CARD)
00855 { cmd = MMC_TAG_ERASE_GROUP_END; }
00856 else
00857 { cmd = SD_TAG_WR_ERASE_GROUP_END; }
00858 if ((r1 = sd_mmc_spi_command(cmd,(adr_end << 9))) != 0)
00859 {
00860 spi_unselectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
00861 return KO;
00862 }
00863 spi_write(SD_MMC_SPI,0xFF);
00864
00865
00866 if ((r1 = sd_mmc_spi_command(MMC_ERASE,0)) != 0)
00867 {
00868 spi_unselectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
00869 return KO;
00870 }
00871 spi_write(SD_MMC_SPI,0xFF);
00872
00873 spi_unselectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
00874
00875 return OK;
00876 }
00877
00878
00883 void sd_mmc_spi_read_close_PDCA (void)
00884 {
00885
00886
00887 spi_write(SD_MMC_SPI,0xFF);
00888 spi_write(SD_MMC_SPI,0xFF);
00889
00890
00891 spi_write(SD_MMC_SPI,0xFF);
00892 spi_write(SD_MMC_SPI,0xFF);
00893
00894 spi_unselectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
00895
00896
00897
00898
00899
00900 }
00901
00902
00903
00916 Bool sd_mmc_spi_read_open_PDCA (U32 pos)
00917 {
00918 U16 read_time_out;
00919
00920
00921 gl_ptr_mem = pos << 9;
00922
00923
00924 if (KO == sd_mmc_spi_wait_not_busy())
00925 return KO;
00926
00927
00928 spi_selectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
00929
00930 r1 = sd_mmc_spi_command(MMC_READ_SINGLE_BLOCK, gl_ptr_mem);
00931
00932
00933 if (r1 != 0x00)
00934 {
00935 spi_unselectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
00936
00937
00938 return KO;
00939 }
00940
00941
00942 read_time_out = 30000;
00943 while((r1 = sd_mmc_spi_send_and_read(0xFF)) == 0xFF)
00944 {
00945 read_time_out--;
00946 if (read_time_out == 0)
00947 {
00948 spi_unselectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
00949
00950
00951 return KO;
00952 }
00953 }
00954
00955
00956 if (r1 != MMC_STARTBLOCK_READ)
00957 {
00958 spi_write(SD_MMC_SPI,0xFF);
00959 spi_unselectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
00960
00961
00962 return KO;
00963 }
00964
00965
00966 return OK;
00967 }
00968
00969
00984 Bool sd_mmc_spi_read_sector_to_ram(void *ram)
00985 {
00986 U8 *_ram = ram;
00987 U16 i;
00988 U16 read_time_out;
00989 unsigned short data_read;
00990
00991 if (KO == sd_mmc_spi_wait_not_busy())
00992 return KO;
00993
00994 spi_selectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
00995
00996 r1 = sd_mmc_spi_command(MMC_READ_SINGLE_BLOCK, gl_ptr_mem);
00997
00998
00999 if (r1 != 0x00)
01000 {
01001 spi_unselectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
01002 return KO;
01003 }
01004
01005
01006 read_time_out = 30000;
01007 while((r1 = sd_mmc_spi_send_and_read(0xFF)) == 0xFF)
01008 {
01009 read_time_out--;
01010 if (read_time_out == 0)
01011 {
01012 spi_unselectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
01013 return KO;
01014 }
01015 }
01016
01017
01018 if (r1 != MMC_STARTBLOCK_READ)
01019 {
01020 spi_write(SD_MMC_SPI,0xFF);
01021 spi_unselectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
01022 return KO;
01023 }
01024
01025
01026 for(i=0;i<MMC_SECTOR_SIZE;i++)
01027 {
01028 spi_write(SD_MMC_SPI,0xFF);
01029 spi_read(SD_MMC_SPI,&data_read);
01030 *_ram++=data_read;
01031 }
01032 gl_ptr_mem += 512;
01033
01034
01035 spi_write(SD_MMC_SPI,0xFF);
01036 spi_write(SD_MMC_SPI,0xFF);
01037
01038
01039 spi_write(SD_MMC_SPI,0xFF);
01040 spi_write(SD_MMC_SPI,0xFF);
01041
01042
01043 spi_unselectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
01044
01045 return OK;
01046 }
01047
01048
01065 Bool sd_mmc_spi_write_sector_from_ram(const void *ram)
01066 {
01067 const U8 *_ram = ram;
01068 U16 i;
01069
01070
01071 if (KO == sd_mmc_spi_wait_not_busy())
01072 return KO;
01073
01074 spi_selectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
01075
01076 r1 = sd_mmc_spi_command(MMC_WRITE_BLOCK, gl_ptr_mem);
01077
01078 if(r1 != 0x00)
01079 {
01080 spi_unselectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
01081 return KO;
01082 }
01083
01084 spi_write(SD_MMC_SPI,0xFF);
01085
01086
01087 spi_write(SD_MMC_SPI,MMC_STARTBLOCK_WRITE);
01088
01089 for(i=0;i<MMC_SECTOR_SIZE;i++)
01090 {
01091 spi_write(SD_MMC_SPI,*_ram++);
01092 }
01093
01094 spi_write(SD_MMC_SPI,0xFF);
01095 spi_write(SD_MMC_SPI,0xFF);
01096
01097
01098 r1 = sd_mmc_spi_send_and_read(0xFF);
01099 if( (r1&MMC_DR_MASK) != MMC_DR_ACCEPT)
01100 {
01101 spi_write(SD_MMC_SPI,0xFF);
01102 spi_write(SD_MMC_SPI,0xFF);
01103 spi_unselectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
01104 return KO;
01105
01106 }
01107
01108 spi_write(SD_MMC_SPI,0xFF);
01109 spi_write(SD_MMC_SPI,0xFF);
01110
01111
01112 spi_unselectChip(SD_MMC_SPI, SD_MMC_SPI_NPCS);
01113 gl_ptr_mem += 512;
01114
01115
01116 i=0;
01117 while (KO == sd_mmc_spi_wait_not_busy())
01118 {
01119 i++;
01120 if (i == 10)
01121 return KO;
01122 }
01123
01124 return OK;
01125 }
01126
01127
01128 #endif // SD_MMC_SPI_MEM == ENABLE