开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 其他嵌入式/单片机内容 > 查看源码
sd_mem.c
资源名称：sd(sd_4_data_mode).rar　[点击查看]
上传用户：hrbsz2007
上传日期：2008-05-11
资源大小：1222k
文件大小：57k
源码类别：

其他嵌入式/单片机内容

开发平台：

C/C++

sd_mem.c：源码内容
  1. /* Copyright 2002, ESS Technology, Inc. */
  2. /* SCCSID @(#)sd_mem.c 1.40 08/10/04 */
  4. #ifdef SD_MEMORY
  5. #include "common.h"
  6. #include "ioport.h"
  7. #include "mvd.h"
  8. #include "buffer.h"
  9. #include "custmem.h"
  10. #include "memmap.h"
  11. #include "smfont.h"
  12. #include "util.h"
  13. #include "constvar.h"
  14. #include "sd_mem.h"
  15. #include "sysinfo.h"
  16. #include "mem_dev.h"
  17. #include "debug.h"
  20. /*------------------------------------------------------------------------
  21.  * Debugging macros
  22.  *------------------------------------------------------------------------*/
  23. #define CPRINTF(a) 
  24. #define PRINTF(a) 
  25. #define JPRINTF(a) 
  27. #define SD_ENABLE_WRITE
  29. #if 0
  30. int bpt;
  31. #define BREAKPOINT(x) {bpt=x;while(bpt) VCX_service();}
  32. #else
  33. #define BREAKPOINT(x)
  34. #endif
  36. /*------------------------------------------------------------------------
  37.  * macros
  38.  *------------------------------------------------------------------------*/
  39. #define USEC(x) (cpuclk*x/10)
  40. #define get_bigend32(pcbuf, off) ((uchar)pcbuf[off]|((uchar)pcbuf[off+1] << 8)| 
  41. ( (uchar)pcbuf[off+2] << 16)|((uchar)pcbuf[off+3] <<24))
  44. /*------------------------------------------------------------------------
  45.  * Public variables
  46.  *------------------------------------------------------------------------*/
  47. SD_CINFO SD_card_info;
  48. SD_XMIT_STATUS SD_xmit_info;
  51. /*------------------------------------------------------------------------
  52.  * Private variables
  53.  *------------------------------------------------------------------------*/
  54. static SD_CARD_STATUS *SD_card_status_ptr; /* R1 reply */
  55. static SD_STATUS *SD_status_ptr;
  56. static SD_OCR *SD_ocr_reg_ptr;
  57. static SD_CID *SD_cid_reg_ptr;
  58. static SD_CSD *SD_csd_reg_ptr;
  59. static ushort SD_rca_reg; /* rel card address..ID for multi cards */
  60. static SD_SCR *SD_scr_reg_ptr;
  61. static uint SD_rdata32;
  62. static int sd_is_mmc;
  63. static int sd_io_status = 0;
  65. static SD_CMD_Q SD_acmdq; /* SD command queue or appcmd */
  66. static unsigned short sd_crc16_look_up_table[256];
  67. static uchar  sd_crc7_look_up_table[256];
  69. static int sdTotalBlockNo, sdPagePerBlock, sdEraseSecSize;
  71. /* NOTE: move LUT's to rom later */
  72. /* LUT for commands with responses: R1, R1b, R2, R3, R6 */
  73. uchar SD_cmd2resp[64] = {
  74.     /* CMD0 - CMD7 */
  75.     SD_NR, SD_R3, SD_R2, SD_R6, SD_NR, SD_NR, SD_NR, SD_R1b,
  76.     /* CMD8 - CMD15 */
  77.     SD_NR, SD_R2, SD_R2, SD_R1_RD, SD_R1b,SD_R1, SD_NR, SD_NR,
  78.     /* CMD16 - CMD23 */
  79.     SD_R1, SD_R1_RD, SD_R1_RD, SD_NR, SD_NR, SD_NR, SD_NR, SD_R1,
  80.     /* CMD24 - CMD31 */
  81.     SD_R1_WR, SD_R1_WR, SD_NR, SD_R1, SD_R1b,SD_R1b,SD_R1, SD_NR,
  82.     /* CMD32 - CMD39 */
  83.     SD_R1, SD_R1, SD_NR, SD_NR, SD_NR, SD_NR, SD_R1b,SD_NR,
  84.     /* CMD40 - CMD47 */
  85.     SD_NR, SD_NR, SD_R1, SD_NR, SD_NR, SD_NR, SD_NR, SD_NR,
  86.     /* CMD48 - CMD55 */
  87.     SD_NR, SD_NR, SD_NR, SD_NR, SD_NR, SD_NR, SD_NR, SD_R1,
  88.     /* CMD56 - CMD63 */
  89.     SD_R1, SD_NR, SD_NR, SD_NR, SD_NR, SD_NR, SD_NR, SD_NR
  90. };
  92. /* LUT for app. commands with responses: R1, R1b, R2, R3, R6 */
  93. uchar SD_acmd2resp[52] = {
  94.     /* ACMD0 - ACMD7 */
  95.     SD_NR, SD_NR, SD_NR, SD_NR, SD_NR, SD_NR, SD_R1, SD_NR,
  96.     /* ACMD8 - ACMD15 */
  97.     SD_NR, SD_NR, SD_NR, SD_NR, SD_NR, SD_R1_RD, SD_NR, SD_NR,
  98.     /* ACMD16 - ACMD23 */
  99.     SD_NR, SD_NR, SD_NR, SD_NR, SD_NR, SD_NR, SD_R1, SD_R1,
  100.     /* ACMD24 - ACMD31 */
  101.     SD_NR, SD_NR, SD_NR, SD_NR, SD_NR, SD_NR, SD_NR, SD_NR,
  102.     /* ACMD32 - ACMD8 */
  103.     SD_NR, SD_NR, SD_NR, SD_NR, SD_NR, SD_NR, SD_NR, SD_NR,
  104.     /* ACMD40 - ACMD47 */
  105.     SD_NR, SD_R3, SD_R1, SD_NR, SD_NR, SD_NR, SD_NR, SD_NR,
  106.     /* ACMD48 - ACMD51 */
  107.     SD_NR, SD_NR, SD_NR, SD_R1_RD
  108. };
  110. /* LUT for SD command classes */
  111. uchar SD_cmd2class[64] = {
  112.     /* CMD0 - CMD7 */
  113.     SD_CL0,SD_CL0,SD_CL0,SD_CL0,SD_CL0,SD_CL0,SD_CL0,SD_CL0,
  114.     /* CMD8 - CMD15 */
  115.     SD_CL0,SD_CL0,SD_CL0,SD_CL1,SD_CL0,SD_CL0,SD_CL0,SD_CL0,
  116.     /* CMD16 - CMD23 */
  117.     SD_CL2,SD_CL2,SD_CL2,SD_CL2,SD_CL2,SD_CL2,SD_CL2,SD_CL2,
  118.     /* CMD24 - CMD31 */
  119.     SD_CL4,SD_CL4,SD_CL4,SD_CL4,SD_CL6,SD_CL6,SD_CL6,SD_CL6,
  120.     /* CMD32 - CMD39 */
  121.     SD_CL5,SD_CL5,SD_CL5,SD_CL5,SD_CL5,SD_CL5,SD_CL5,SD_CL5,
  122.     /* CMD40 - CMD47 */
  123.     SD_CL5,SD_CL5,SD_CL7,SD_CL7,SD_CL7,SD_CL7,SD_CL7,SD_CL7,
  124.     /* CMD48 - CMD55 */
  125.     SD_CL7,SD_CL7,SD_CL7,SD_CL7,SD_CL7,SD_CL7,SD_CL7,SD_CL8,
  126.     /* CMD56 - CMD63 */
  127.     SD_CL8,SD_CL8,SD_CL8,SD_CL8,SD_CL8,SD_CL8,SD_CL8,SD_CL8,
  128. };
  130. /* LUT for CSD's TAAC time value */
  131. uchar SD_taac_valx10[16] = {
  132.     00, 10, 12, 13, 15, 20, 25, 30,
  133.     35, 40, 45, 50, 55, 60, 70, 80
  134. };
  136. #ifdef BANK2SPEEDUP
  137. static unsigned old_wait_state;
  138. #endif
  140. /*------------------------------------------------------------------------
  141.  * Private functions
  142.  *------------------------------------------------------------------------*/
  143. static int SD_set_cmd(int, uint);
  144. static void SD_update_card_info(void);
  145. static ushort SD_calc_crc16(uchar *, ushort);
  146. static void SD_calc_crc16_table(ushort *);
  147. static uchar SD_calc_crc7(uchar *, ushort);
  148. static void SD_calc_crc7_table(uchar *);
  149. static int  SD_write_blk(int, int, int, int *, int);
  151. /*------------------------------------------------------------------------
  152.  * Begin SD function listing
  153.  *------------------------------------------------------------------------*/
  155. /* 
  156.   Function: Get partition boot record (PBR) address from master
  157.     boot record area.
  159.   input:
  161.   output: PBR start address as physical lba (physical sector number).
  163.   side-effects:
  164. */
  165. unsigned int SD_boot_setup(void)
  166. {
  167.    uchar *buff;
  168.    uint PBR_start_psn;
  170.    
  171.    SD_enable_io(1); /* enable SD eaux pins */
  173.    buff = (uchar *)dram_cached(SD_DATA_START);
  174.    SD_read_sector_lba((short *)buff, 0, 1, 1); /* 512B per block */
  175.    if (((buff[0x0] == 0xEB) && (buff[0x2] == 0x90))
  176.          || (buff[0x0] == 0xE9)) {
  177.         PBR_start_psn = 0;
  178.    }else
  179.        PBR_start_psn = get_bigend32(buff, 454);
  181.    return(PBR_start_psn);
  182. }
  183. /*********************************************************************
  184.     return:
  185.           1: MMC
  186.           0: SD or else
  187. **********************************************************************/
  188. int SD_is_mmc(void){
  189.     if(SD_card_info.type == SD_MMC)
  190. return 1;
  191.     else
  192. return 0;    
  193. }
  194. /* 
  195.   Function: Reads from specified lba to designated buffer.
  197.   input:
  198. buff: pointer for SD data destination.
  199. lba: physical logical block address.
  200. nblk: number of blocks to read.
  202.   output: number of bytes read.
  204.   side-effects:
  205. */
  206. int SD_read_sector_lba(short *buff, int lba, int nblk, int immed)
  207. {
  208.     int i, start_lba = lba;
  209.     short *pDest = buff;
  211.     set_bank2_wait ();
  213.     if (nblk == 1) {
  214. SD_read_blk(lba<<9, 9, (unsigned int *)buff, immed);
  215.     } else {
  216. PRINTF(("SD_multi_block read: %d-->%x : nblk %d n",
  217.  lba, buff, nblk));
  218. if(SD_card_info.type == SD_MMC){
  219.     for(i= 0; i<nblk; i++){
  220. SD_read_blk(start_lba<<9, 9, (unsigned int *)pDest, immed);
  221. pDest += 0x100;
  222. start_lba++;
  223.     }
  224. }else
  225.     SD_read_nblk(lba<<9, nblk, (unsigned int *)buff, immed);
  226.     }
  228.     restore_bank2_wait ();
  230.     return (nblk*512);
  231. }
  233. static int SD_find_free_block(int start_blk)
  234. {
  235.     int blk_no = start_blk, i, lba, cluster, pcluster;
  236.     while(blk_no++<sdTotalBlockNo){
  237. pcluster = 0;
  238. for(i=0; i<sdPagePerBlock; i++){
  239.     lba = blk_no*sdPagePerBlock +i;
  240.     cluster = HD_lba_to_cluster(lba);
  241.     if(cluster == -1) continue;
  242.     if(cluster == pcluster)
  243. continue;
  244.     
  245.     pcluster = cluster;
  246.     if(!HD_cluster_is_free(cluster))
  247. break;
  248. }
  249. if(i<sdPagePerBlock)
  250.     continue;
  251. else{
  252.     JPRINTF(("found a free block: %dn", blk_no));
  253.     return blk_no;
  254. }
  255.     }
  256.     return -1;
  257. }
  259. static int SD_erase_block(int start_lba, int nblk)
  260. {
  261.     int status, end_lba;
  262.     end_lba = start_lba+nblk-1;
  263.     status = SD_send_cmd(SD_CMD_ERASE_WR_BLK_START, start_lba<<9,1);
  264.     if(status != 1)
  265. return -1;
  266.     status = SD_send_cmd(SD_CMD_ERASE_WR_BLK_END, end_lba<<9,1);
  267.     if(status != 1)
  268. return -1;
  269.     status = SD_send_cmd(SD_CMD_ERASE, 0, 1);
  270.     if(status != 1)
  271. return -1;
  272.     else if(SD_xmit_info.result == 0)
  273. return 0;
  274.     else{
  275. JPRINTF(("card status %xn", *(int*)SD_card_status_ptr));
  276. return -1;
  277.     }
  278. }
  279. int SD_write_sector_lba(short *buff, int lba, int nblk, int immed)
  280. {
  281.     int start_lba= lba,i, status;
  282.     short *pSrc= buff;
  283.     int free_blk;
  285. #ifndef SD_ENABLE_WRITE
  286.     return -1;
  287. #endif
  288.    
  289.     if(SD_card_info.type == SD_MMC){
  290. for(i=0; i<nblk; i++){
  291.     status = SD_write_blk(start_lba<<9, 9, 1, (int *)pSrc, 1);
  292.     if(status){
  293. JPRINTF(("MMC writing error ...n"));
  294. assert(0);
  295. return 0;
  296.     } 
  297.     pSrc += 0x100;
  298.     start_lba++;
  299. }
  300.     }else{
  301. status = SD_write_blk(start_lba<<9, 9, nblk, (int *)pSrc, immed);
  302. if(status) 
  303.     return 0;
  304. if(nblk>1 && immed)
  305.     status = SD_send_cmd(SD_CMD_STOP_TRANSMIT, 0, 1); 
  306.     }
  308.     JPRINTF(("SD_write_sector_lba: data_cnt%d nblk %d, status %xn",
  309.      SD_xmit_info.data_cnt, nblk, status));
  310.     return (512*nblk);
  311. }
  314. /* 
  315.   Function: The faster CRC16 calculation procedure 
  316. uses 256 x 16-bit Look Up Table (8bit at a time)..
  317. more efficient than generating CRC 1bit at a time.
  318. (adapted from memstick.c version)
  320.   input: 
  321. data: pointer to data to be protected by CRC.
  322. count: total bytes of data.
  324.   output: CRC16
  326.   side-effects:
  327. */
  328. static ushort SD_calc_crc16(uchar *data, ushort count)
  329. {
  330.     ushort fcs = 0x0; /* initial FCS value */
  331.     ushort i, t, tl, th;
  332.     for (i=0; i<count; i++)
  333.     {
  334.         t = fcs;
  335.         fcs = sd_crc16_look_up_table[(t>>8) ^ *data++];
  336.         fcs = fcs ^ (t<<8);
  337.     }
  338.     return(fcs);
  339. }
  340. /* in case of 4-bit mode */
  341. static ushort SD_calc_crc16_4_bit(int *data, ushort count, ushort *crc)
  342. {
  343.     ushort fcs0 = 0x0, fcs1=0, fcs2=0, fcs3=0; /* initial FCS value */
  344.     ushort i, j ;
  345.     int tmp, *pInt;
  346.     uint filter;
  347.     ushort d0,d1,d2,d3;
  348.     ushort tt0,tt1,tt2,tt3;
  350.     pInt = data;
  351.     for (i=0; i<count; i++)
  352.     {
  353.         PRINTF(("data is %xn", *pInt));
  354.         tmp = *pInt++;
  355.         d3  = ((tmp & 0x80000000) >> 24); /* 0 */
  356.         d3 |= ((tmp & 0x08000000) >> 21); /* 1 */
  357.         d3 |= ((tmp & 0x00800000) >> 18); /* 2 */
  358.         d3 |= ((tmp & 0x00080000) >> 15); /* 3 */
  359.         d3 |= ((tmp & 0x00008000) >> 12); /* 4 */
  360.         d3 |= ((tmp & 0x00000800) >>  9); /* 5 */
  361.         d3 |= ((tmp & 0x00000080) >>  6); /* 6 */
  362.         d3 |= ((tmp & 0x00000008) >>  3);       /* 7 */
  363.         d2  = ((tmp & 0x40000000) >> 23); /* 0 */
  364.         d2 |= ((tmp & 0x04000000) >> 20); /* 1 */
  365.         d2 |= ((tmp & 0x00400000) >> 17); /* 2 */
  366.         d2 |= ((tmp & 0x00040000) >> 14); /* 3 */
  367.         d2 |= ((tmp & 0x00004000) >> 11); /* 4 */
  368.         d2 |= ((tmp & 0x00000400) >>  8); /* 5 */
  369.         d2 |= ((tmp & 0x00000040) >>  5); /* 6 */
  370.         d2 |= ((tmp & 0x00000004) >>  2); /* 7 */
  371.         d1  = ((tmp & 0x20000000) >> 22); /* 0 */
  372.         d1 |= ((tmp & 0x02000000) >> 19); /* 1 */
  373.         d1 |= ((tmp & 0x00200000) >> 16); /* 2 */
  374.         d1 |= ((tmp & 0x00020000) >> 13); /* 3 */
  375.         d1 |= ((tmp & 0x00002000) >> 10); /* 4 */
  376.         d1 |= ((tmp & 0x00000200) >>  7); /* 5 */
  377.         d1 |= ((tmp & 0x00000020) >>  4); /* 6 */
  378.         d1 |= ((tmp & 0x00000002) >>  1); /* 7 */
  379.         d0  = ((tmp & 0x10000000) >> 21); /* 0 */
  380.         d0 |= ((tmp & 0x01000000) >> 18); /* 1 */
  381.         d0 |= ((tmp & 0x00100000) >> 15); /* 2 */
  382.         d0 |= ((tmp & 0x00010000) >> 12); /* 3 */
  383.         d0 |= ((tmp & 0x00001000) >>  9); /* 4 */
  384.         d0 |= ((tmp & 0x00000100) >>  6); /* 5 */
  385.         d0 |= ((tmp & 0x00000010) >>  3); /* 6 */
  386.         d0 |= ((tmp & 0x00000001) );      /* 7 */
  388. //        PRINTF(("wanted : %x tmp %x, filter %xn",
  389. //                 data_wanted, tmp, filter));
  390.         tt0 = fcs0;
  391.         tt1 = fcs1;
  392.         tt2 = fcs2;
  393.         tt3 = fcs3;
  394.         fcs0 = sd_crc16_look_up_table[(tt0>>8) ^ d0];
  395.         fcs1 = sd_crc16_look_up_table[(tt1>>8) ^ d1];
  396.         fcs2 = sd_crc16_look_up_table[(tt2>>8) ^ d2];
  397.         fcs3 = sd_crc16_look_up_table[(tt3>>8) ^ d3];
  398.         fcs0 = fcs0 ^ (tt0<<8);
  399.         fcs1 = fcs1 ^ (tt1<<8);
  400.         fcs2 = fcs2 ^ (tt2<<8);
  401.         fcs3 = fcs3 ^ (tt3<<8);
  403.     }
  404.     crc[0] = fcs0;
  405.     crc[1] = fcs1;
  406.     crc[2] = fcs2;
  407.     crc[3] = fcs3;
  408.     return(0);
  409. }
  410. static uchar SD_calc_crc7(uchar *data, ushort count)
  411. {
  412.     uchar fcs = 0x0; /* initial FCS value */
  413.     ushort i;
  414.     uchar  g = 0x9;
  415.     uchar t;
  417.     for (i=0; i<count; i++)
  418.     {
  419.         t = sd_crc7_look_up_table[fcs];
  420. t <<= 1;
  421. if(t&0x80) 
  422.     fcs = (t&0x7f)^g;
  423. else
  424.     fcs = t;
  425.         t = sd_crc7_look_up_table[*data++];
  426. fcs ^= t;
  427.     }
  428.     return(fcs);
  429. }
  430. /*********************************************************** 
  431.   Function: Generate look up table for CRC16 calculation. 
  432.             G(x): x16+x12+x5+1
  433. ***********************************************************/
  435. static void SD_calc_crc16_table(ushort *table)
  436. {
  437. int d, i, k;
  438. ushort g = 0x1021; /* x16+ x12 +x5+1 */
  440. for (i=0; i<256; i++)
  441. {
  442. d = i<<8;
  443. for (k=0; k<8; k++)
  444. {
  445. d <<= 1;
  446. if(d&0x10000)
  447. d ^= g;
  448. }
  449. table[i] = d&0xffff;
  450. }
  451. }
  452. /*********************************************************** 
  453.   Function: Generate look up table for CRC7 calculation. 
  454.             G(x): x7+x3+1
  455. ***********************************************************/
  456. static void SD_calc_crc7_table(uchar *table)
  457. {
  458.     int i, k, d;
  459.     uchar g = 0x9; /* x7+ x3 +1 */
  460.     
  461.     PRINTF(("SD_fcs_table_calc_crc7 ...n"));
  462.     for (i=0; i<256; i++){
  463.         d = i;
  464.         for (k=0; k<7; k++){
  465.     if(d&0x80)
  466. d ^= g;
  467.     d <<= 1;
  468.         }
  469.         if(d&0x80)
  470.     d ^= g;
  471.         table[i] = d&0x7f;
  472.     }    
  473. }
  476. /* 
  477.   Function: Update SD_card_info from SD_csd_register..
  478.     calculate some card information.
  479.     (ref. pp.63-71..SD Physical Layer)
  481.   input: (none..but assumes CSD register is updated)
  483.   side-effects:       
  484. SD_card_info members are updated:
  485. 1. card's read access time (n_ac_max)  
  486. 2. card's write access time (n_wr_max)
  487. 3. card's memory capacity.
  488. */
  489. static void SD_update_card_info(void)
  490. {
  491.     int cnt, mmc_ac, sd_ac;
  492.     uint data;
  493.     int nwrmax;
  494.     
  496.     /* calculate access times */
  497.     /* data = taac = ((value*CPUCLK)/4) * 10^cnt */
  498.     data = cpuclk*SD_taac_valx10[SD_csd_reg_ptr->taac_value];
  499.     data >>= 2; /* WS = 4 */
  500.     cnt = SD_csd_reg_ptr->taac_unit - 5; /* n power of 10 */
  501.     if (cnt < 0) {
  502. do {
  503.     data /= 10;
  504.     cnt++;
  505. } while (cnt);
  506.     } else {
  507. while (cnt) {
  508.     data *= 10;
  509.     cnt--;
  510. };
  511.     }
  512.     /* read access time */
  513.     SD_card_info.n_ac_max = SD_NAC_MIN + data +
  514. (100 * SD_csd_reg_ptr->nsac); 
  515.     mmc_ac = 10*(data+100*SD_csd_reg_ptr->nsac);
  516.     if(sd_is_mmc)
  517. SD_card_info.n_ac_max  = mmc_ac;
  518.     JPRINTF(("n_ac_max: sd: %d, mmc %d n",
  519.      SD_card_info.n_ac_max, mmc_ac));
  521.     /* write access time */
  522.     nwrmax = (SD_card_info.n_ac_max)<<(SD_csd_reg_ptr->r2w_factor);
  523.     /*prevent short var n_wr_max overflow*/
  524.     if (nwrmax > 0xffff) nwrmax = 0xffff;
  525.     SD_card_info.n_wr_max = nwrmax;
  527.     /* calculate card capacity = BLOCKNR * BLOCK_LEN */
  528.     data = ((SD_csd_reg_ptr->c_size_11_2<<2) |
  529. SD_csd_reg_ptr->c_size_1_0) + 1;
  530.     cnt = 1 << (SD_csd_reg_ptr->c_size_mult + 2);
  531.     data = data * cnt; /* BLOCKNR */
  532.     sdTotalBlockNo = data;
  533.     cnt = 1 << (SD_csd_reg_ptr->rd_blk_len); /* BLOCK_LEN */
  534.     sdPagePerBlock = cnt/512;
  535.     sdEraseSecSize = SD_csd_reg_ptr->sector_size+1;
  536.     SD_card_info.capacity = data * cnt; /* in Bytes */
  537. }
  540. /* 
  541.   Function: Initialize SD related buffers, structure members and
  542.     and IO pins.
  544.   input:
  546.   output:       
  548.   side-effects:
  549. */
  550. void SD_init(void)
  551. {
  552.     unsigned sclk_high, sclk_low;
  556. dawei(("SD_init()n"));
  557.     SD_GET_SCLK_VAL(sclk_high, sclk_low);
  559.     /* initialization */
  560.     SD_card_status_ptr = (SD_CARD_STATUS *)dram_cached(SD_CSTATUS_START);
  561.     SD_status_ptr = (SD_STATUS *)dram_cached(SD_STATUS_START);
  562.     SD_ocr_reg_ptr = (SD_OCR *)dram_cached(SD_OCR_START);
  563.     SD_cid_reg_ptr = (SD_CID *)dram_cached(SD_CID_START);
  564.     SD_csd_reg_ptr = (SD_CSD *)dram_cached(SD_CSD_START);
  565.     SD_scr_reg_ptr = (SD_SCR *)dram_cached(SD_SCR_START);
  567.     /* generate the crc table */ 
  568.     SD_calc_crc16_table(sd_crc16_look_up_table); 
  569.     SD_calc_crc7_table(sd_crc7_look_up_table); 
  571.     SD_rca_reg = 0; /* initially '0' */
  572.     SD_card_info.type = SD_UNKNOWN;
  573.     sd_is_mmc = 0;
  574.     SD_card_info.capacity = 0; /* used to check if CSD received */
  575.     SD_xmit_info.com_state = SD_IDLE;
  576. #if SD_CHECK_RECV_CRC
  577.     SD_xmit_info.crc7_err_cnt = 0;
  578.     SD_xmit_info.crc16_err_cnt = 0;
  579. #endif
  581.     SD_acmdq.cmd = SD_CMD_EMPTY;
  582.     SET_SD_CMD; /* initially high */
  583.     SD_DETECT_INPUT; 
  584. }
  587. /* 
  588.   Function: Enable/disable SD eaux ports shared with ATAPI. This is
  589.     used to prevent ATAPI initialization problems.
  591.   input:
  592. enable: 1 - enable SD IO ports.
  593. 0 - disable SD IO ports.
  595.   output:       
  597.   side-effects:
  598. (refer to sd_mem.h for specific eaux ports affected)
  599. */
  600. void SD_enable_io(int enable)
  601. {
  602. #if defined(SD_MEMORY)
  603.     /* shared with ATAPI..
  604.      * there is known conflict with ATAPI-D7 (Busy pin) that cause
  605.      * ATAPI initialization problem..tread lightly here.
  606.      */
  607.     if (enable){
  608. sd_io_status = 1;
  609. ENABLE_SD_GENERAL;
  610. ENABLE_SD_IO;
  611.     } else if(sd_io_status){
  612. DISABLE_SD_GENERAL;
  613. DISABLE_SD_IO;
  614. sd_io_status = 0;
  615.     }
  616. #endif    
  617. }
  620. /* 
  621.   Function: SD-memory/MMC card detection. Gets relative card  
  622.     address(RCA) from card if detected.
  624.   input: (none)
  626.   output:       
  627. -2: failed to get CSD register
  628. -1: not voltage compatible
  629.  0: no valid SD-mem or MMC card found
  630.  5: if successful
  631. */
  632. int SD_identify_device(void)
  633. {
  634.     int status, status1, cnt=0;    
  637.     SD_enable_io(1);
  638.     
  639.     SD_init();
  641.     SD_card_info.inserted = 1;
  643.     /* Force SD card to idle-state to start initialization */
  644.     SD_clk_restricted_cmd(SD_CMD_GO_IDLE_STATE, 0);
  646.     /* send ACMD41 w/acceptable OCR.. 
  647.      * and wait until SD card is ready.
  648.      */
  649.     SD_ocr_reg_ptr->card_ready = 0;
  650.     do {
  651. status = SD_clk_restricted_cmd(SD_CMD_APP_CMD, 0);
  652. status1 = SD_clk_restricted_cmd(SD_ACMD_SD_SEND_OP_COND, 
  653. SD_ACCEPTABLE_OCR);
  654. if ((status == -1) && (status1 == -1)) { 
  655.     SD_clk_restricted_cmd(SD_CMD_GO_IDLE_STATE, 0);
  656.     cnt++;
  657.     if (cnt > SD_MAX_RETRIES) {
  658. /* timed out..no response */
  659. status = -3;
  660. break;
  661.     }
  662. }
  663.     } while (!SD_ocr_reg_ptr->card_ready);
  665.     sd_is_mmc = 0;
  666.     /*
  667.      * if no response: 1) SD card not voltage compatible
  668.      *        2) could be Multimedia card..verify
  669.      *   by sending CMD1 (MMC's ACMD41)
  670.      */
  671.     if (status == -3){
  672. /* check if MMC? */
  673. SD_clk_restricted_cmd(SD_CMD_GO_IDLE_STATE, 0);
  675. cnt=0;
  676. SD_ocr_reg_ptr->card_ready = 0;
  677. do {
  678.     status = SD_clk_restricted_cmd(SD_CMD_MMC_SEND_OP_COND, 
  679.    SD_ACCEPTABLE_OCR);
  680.     if (status == -1) {
  681. /* no response */
  682. cnt++;
  683. if (cnt > SD_MAX_RETRIES){
  684.     /* card not voltage compatible */
  685.     return (-1);
  686. }
  687.     }
  688. } while (!SD_ocr_reg_ptr->card_ready);
  690. SD_card_info.type = SD_MMC; /* MultiMedia Card */
  691. sd_is_mmc = 1;
  692.     } else {
  693. SD_card_info.type = SD_MEM; /* SD Memory Card */
  694.     }
  696.     if(SD_card_info.type == SD_MMC){
  697. SD_rca_reg = 0x1;
  698.     }
  699.     else{
  700. SD_rca_reg = 0xffff; 
  701.     }
  703.     /* send CMD2 to get CID number */
  704.     status = SD_clk_restricted_cmd(SD_CMD_ALL_SEND_CID, 0);
  707.     /* send CMD3 to get RCA */
  708.     if(SD_card_info.type == SD_MMC){
  709. status = SD_clk_restricted_cmd(SD_CMD_SEND_REL_ADDR, 
  710.        SD_rca_reg<<16);
  711.     }
  712.     else{
  713. status = SD_clk_restricted_cmd(SD_CMD_SEND_REL_ADDR, 0);
  714.     }
  716.     if (status == 1) {
  717. /* send CMD9 to get Card Specific Data (CSD) */
  718. status = SD_send_cmd(SD_CMD_SEND_CSD, SD_rca_reg<<16, 1);
  719. if (status == 1) {
  720.     SD_update_card_info();
  722.     /* send card to tranfer state */
  723.     SD_send_cmd(SD_CMD_SELECT_CARD, SD_rca_reg<<16, 1);    
  724.     if (SD_card_info.type > SD_MMC) {
  725. /* send ACMD51 to get SD configuration register */
  726. SD_scr_reg_ptr->sd_bus_widths = 0x1; /* default 1bit */
  727. SD_send_acmd(SD_ACMD_SEND_SCR, 0, 1);
  729. /* set to 4bit data bus if possible */
  730. SD_set_bus_width(2);
  732. /* send ACMD13 to get SD Status register */
  733. SD_send_acmd(SD_ACMD_SD_STATUS, 0, 1);
  734.     }
  735.     /* we have valid SD/MMC card */
  736.     status = 5;
  737. } else {
  738.     status = -2; /* failed to get CSD */
  739. }   
  740.     } else {
  741. SD_card_info.type = SD_UNKNOWN;
  742. status = 0;
  743.     }    
  745.     SD_enable_io(0);
  746.     
  747.     return (status);
  748. }
  751. /* 
  752.   Function: SD-memory/MMC card reset.
  754.   input:
  756.   output:       
  758.   side-effects:
  759. */
  760. void SD_reset(void)
  761. {
  762.     unsigned sclk_high, sclk_low;
  764.     SD_GET_SCLK_VAL(sclk_high, sclk_low);
  766.     SD_send_cmd(SD_CMD_GO_IDLE_STATE, 0, 1);
  768.     SD_xmit_info.data_width = 0; /* initially only D0 used */
  769.     SD_card_info.type = SD_UNKNOWN;
  770.     sd_is_mmc = 0;
  771.     SD_card_info.inserted = 0;
  772.     SD_card_info.capacity = 0; /* used to check if CSD received */
  773.     SD_xmit_info.com_state = SD_IDLE;
  774. #if SD_CHECK_RECV_CRC
  775.     SD_xmit_info.crc7_err_cnt = 0;
  776.     SD_xmit_info.crc16_err_cnt = 0;
  777. #endif
  779.     SD_acmdq.cmd = SD_CMD_EMPTY;
  780.     SET_SD_CMD; /* initially high */
  781. }
  784. /* 
  785.   Function:  Set data bus width, 4bit or 1bit.
  787.   input: 
  788. 0 - 1bit data bus (narrow bus)
  789. 2 - 4bit data bus (wide bus)
  791.   output:       
  792. 1: success
  793. otherwise: failed
  794. */
  795. int SD_set_bus_width(int width)
  796. {
  797.     uint status = 0;
  798.     
  799.     dawei(("SD_set_bus_width( %d )n", width));
  800.     if ((SD_scr_reg_ptr->sd_bus_widths & 0x4)) {
  801. /* 4bit supported by card */
  802. if ((width>>1) != SD_xmit_info.data_width) {
  803.     status = SD_send_acmd(SD_ACMD_SET_BUS_WIDTH, width, 1);
  804.     if (status==1) SD_xmit_info.data_width = (width>>1);
  805. }
  806.     }
  808.     return (status);
  809. }
  811. /* 
  812.   Function: Read single block from SD. The max block size is card
  813.     specific, in the range of 512 to 2048 bytes. The minimum
  814.     block size is 1 byte if card support "partial block read".
  815.     SD memory card always support PBR.
  816.     (NOTE: currently our code is hardwired to 512B block)
  818.   input:
  819. addr: location of SD data (lba).
  820. blk_sz: block size to read. (2^val bytes)
  821. data_ptr: SD data destination.
  822. immed: 1 - complete data read in function.
  823.        0 - initiate data read..let SD_service() finish
  824.            in background.
  825.   output:       
  826. -4: unsupported block size.
  827. -3: timed out (reached retry limit)
  828. -2: communication busy
  829. -1: invalid or unsupported command or no card.
  830.  0: read initiated.."passed" to SD_service(). 
  831.        1: successful
  833.   side-effects:
  834. */
  835. int SD_read_blk(int addr, int blk_sz, uint *data_ptr, int immed)
  836. {
  837.     int status;
  840.     if (blk_sz != SD_xmit_info.cur_blk_size) {
  841. /* check if card allows block size */
  842. if ((blk_sz == SD_csd_reg_ptr->rd_blk_len) ||
  843.     (SD_csd_reg_ptr->rd_blk_len_partial && 
  844.      blk_sz < SD_csd_reg_ptr->rd_blk_len)) {
  845.     SD_send_cmd(SD_CMD_SET_BLOCKLEN, (1<<blk_sz), immed);
  846. } else {
  847.     return (-4); /* invalid block size */
  848. }
  849.     }
  850.     SD_xmit_info.cur_blk_size = blk_sz;
  851.     SD_xmit_info.rd_dest_ptr = data_ptr;
  852.     
  853.     status=SD_send_cmd(SD_CMD_READ_SINGLE_BLOCK, addr, immed);
  855.     return (status);
  856. }
  858. static int SD_write_blk(int addr,int blk_sz,int nblk,int*data_ptr, int immed)
  859. {
  860.     int status = 1;
  861.     int erase_blk_en, sec_size, wr_bl_len, wr_blk_len_partial;
  863.     if (blk_sz != SD_xmit_info.cur_blk_size) {
  864. /* check if card allows block size */
  865. if ((blk_sz == SD_csd_reg_ptr->wr_blk_len) ||
  866.     (SD_csd_reg_ptr->wr_blk_partial && 
  867.      blk_sz < SD_csd_reg_ptr->wr_blk_len)) {
  868.     status = SD_send_cmd(SD_CMD_SET_BLOCKLEN, (1<<blk_sz), immed);
  869. } else {
  870.     return (-4); /* invalid block size */
  871. }
  872.     }
  873.     if(status != 1){
  874. JPRINTF(("SD Set Block_len error. status %dn", status));
  875. return -1;
  876.     }
  877.     SD_xmit_info.cur_blk_size = blk_sz;
  878.     SD_xmit_info.wr_src_ptr = data_ptr;
  879.     SD_xmit_info.data_len = nblk*(1<<blk_sz);
  880.     if(nblk>1)
  881. status=SD_send_cmd(SD_CMD_WRITE_MULTI_BLOCK, addr, immed);
  882.     else
  883. status=SD_send_cmd(SD_CMD_WRITE_BLOCK, addr, immed);
  884.     if(status != 1){
  885. JPRINTF(("SD Set Write Cmd error.n"));
  886. return -1;
  887.     }
  888.     else if(SD_xmit_info.result != 0){
  889. JPRINTF(("SD Writing   error.n"));
  890. return -1;
  891.     }
  892.     return 0;
  893. }
  894. /* 
  895.   Function: Read multiple blocks from SD. The max block size is card
  896.     specific, in the range of 512 to 2048 bytes. 
  897.     (NOTE: currently our code is hardwired to 512B block)
  899.   input:
  900. addr: location of SD data (lba).
  901. nblk: number of blocks to read. 
  902. data_ptr: SD data destination.
  903. immed: 1 - complete data read in function.
  904.        0 - initiate data read..let SD_service() finish
  905.            in background.
  906.   output:       
  907. -3: timed out (reached retry limit)
  908. -2: communication busy
  909. -1: invalid or unsupported command or no card.
  910.  0: read initiated.."passed" to SD_service(). 
  911.        1: successful
  913.   side-effects:
  914. */
  915. int SD_read_nblk(int addr, int nblk, uint *data_ptr, int immed)
  916. {
  917.     int status, limit;
  919.     /* make sure block size is 512B..FAT hardwired */
  920.     if (SD_xmit_info.cur_blk_size != 9) {
  921. SD_send_cmd(SD_CMD_SET_BLOCKLEN, 512, immed);
  922.     }
  923.     SD_xmit_info.cur_blk_size = 9; /* 512..(2^9) */
  924.     SD_xmit_info.rd_dest_ptr = data_ptr;
  926.     limit = nblk*512;
  928. #if 0
  929.     status = SD_send_cmd(MMC_CMD_READ_UNTIL_STOP, addr, 0);
  930. #endif
  931.     status = SD_send_cmd(SD_CMD_READ_MULTI_BLOCK, addr, 0);
  932.     SD_xmit_info.data_len = nblk*512;
  933.     SD_xmit_info.data_cnt = 0;
  934.     /* NOTE: for "non-immediate" case, make sure similar process
  935.      * below is present in background task to complete the read.
  936.      */
  937.     if ((status >= 0) && immed) {
  938. PRINTF(("com_state %dn",SD_xmit_info.com_state));
  939. while (SD_xmit_info.com_state) {
  940.     SD_service();
  941.     if (SD_xmit_info.data_cnt >= limit
  942. && !sd_is_mmc) break;
  943. }
  944. status = SD_send_cmd(SD_CMD_STOP_TRANSMIT, 0, immed);
  945. PRINTF(("xmit bytes %d, required bytes %d, statusn", 
  946.  SD_xmit_info.data_cnt, SD_xmit_info.data_len, status));
  947.     }else{
  948. JPRINTF(("SD_read_nblk... error n"));
  950.     }
  952.     return (status);
  953. }
  955. /* 
  956.   Function: used in SD_service() for post-processing of commands...
  957.     1) command retry for errors (up to SD_MAX_RETRIES).
  958.     2) send app-command if CMD55 was previously sent.
  959.     3) send pending command in queue if any.
  961.   input: no arguments..but app-commands and pending commands are
  962.  stored in "SD_acmdq" structure for processing.
  963.   
  964.   output:
  966.   side-effects:
  967. */
  968. int SD_get_next_cmd(void)
  969. {
  970.     int send=0;
  972.     
  973.     if (SD_xmit_info.response_expected &&
  974. !SD_xmit_info.response_recv) {
  975. if (SD_xmit_info.retry_cnt < SD_MAX_RETRIES) {
  976.     /* failed/aborted commands..retry */
  977.     SD_xmit_info.wait_nclk = SD_NCR_MAX;
  978.     send = 1;     
  979. } else {
  980.     /* reach retry limit */
  981.     SD_xmit_info.retry_cnt = 0xff; 
  982. }
  983.     } else {
  984. /* command specific post-processing */
  985. switch (SD_xmit_info.cmd) {
  986. case SD_CMD_APP_CMD:
  987.     /* send app-command */
  988.     SD_set_cmd(SD_acmdq.cmd, SD_acmdq.arg);
  989.     SD_acmdq.cmd = SD_CMD_EMPTY; /* clear cmd-Q */
  990.     send = 1;
  991.     break;
  992.     
  993. default:
  994.     if (SD_acmdq.cmd != SD_CMD_EMPTY) {
  995. /* cmd pending */
  996. send = SD_set_cmd(SD_acmdq.cmd, SD_acmdq.arg);
  997. SD_acmdq.cmd = SD_CMD_EMPTY; /* clear cmd-Q */
  998.     }
  999.     break;
  1000. }
  1001.     }
  1002.     
  1003.     return (send);
  1004. }
  1007. /* 
  1008.   Function: send command to SD card.  
  1010.   input:
  1011. command: command index (0-63).
  1012. arg: command argument.
  1013. immed: 1-complete command immediately 
  1014. 0-initiate command..let SD_service() finish
  1016.   output:       
  1017. -3: timed out (reached retry limit)
  1018. -2: communication busy
  1019. -1: invalid or unsupported command or no card.
  1020.  0: pending..command "passed" to SD_service(). 
  1021.        1: successful
  1022. */
  1023. int SD_send_cmd(int command, uint arg, int immed)
  1024. {
  1025.     int status=0;
  1028.     if (!SD_card_info.inserted || command > 63) 
  1029. return (-1); /* sanity check */    
  1030.     
  1031.     /* send command w/ CRC7*/
  1032.     if ( (SD_xmit_info.com_state == SD_IDLE) || 
  1033.  (command == SD_CMD_STOP_TRANSMIT) ) {
  1035. if (!SD_set_cmd(command, arg)) return (-1);
  1037. SD_xmit_info.com_state = HOST2SD_START;
  1039. if (immed) {
  1040.     while (SD_xmit_info.com_state) SD_service();
  1042.     status = (SD_xmit_info.retry_cnt == 0xff) ? -3 : 1;
  1043. }
  1044.     } else {
  1045. /* put in cmd-Q..if not app-command */
  1046. if (!(command & ACMD_MARKER) && 
  1047.     (command != SD_CMD_APP_CMD)) {
  1048.     SD_acmdq.cmd = command;
  1049.     SD_acmdq.arg = arg;
  1050. } else {
  1051.     status = -2; /* Bus is busy..lost app-command */
  1052. }
  1053.     }
  1055.     return (status);
  1056. }
  1059. /* 
  1060.   Function: send application specific command to SD card.
  1061.     App-commands needs to send pre-command(0x55).
  1063.   input:
  1064. command: app-command index.
  1065. arg: app-command argument.
  1066. immed: 1-complete command immediately 
  1067. 0-initiate command..let SD_service() finish
  1069.   output:       
  1070. -2: communication busy
  1071. -1: invalid command.
  1072.  0: pending..command "passed" to SD_service(). 
  1073.        1: successful
  1074. */
  1075. int SD_send_acmd(int acmd, uint arg, int immed)
  1076. {
  1077.     int status;
  1078.     
  1079.     /* set app-command */
  1080.     SD_acmdq.cmd = acmd;
  1081.     SD_acmdq.arg = arg;
  1082.     status = SD_send_cmd(SD_CMD_APP_CMD, SD_rca_reg<<16, immed);
  1083.     
  1084.     return (status);
  1085. }
  1087. /* 
  1088.   Function: Initializes xmit data structure for new command. 
  1089.     Checks card(CSD reg) for command class support.
  1091.   input:
  1092. command: command index.
  1093. arg: command argument.
  1095.   output:       
  1096.  0: command not supported by card.
  1097.        1: successful
  1098. */
  1099. static int SD_set_cmd(int command, uint arg) 
  1100. {
  1101.     uint is_acmd, cmd, tmp;
  1102.     uchar *sd_resp_ptr;
  1103.     
  1105.     cmd = command & 0x3f;
  1106.     is_acmd = command & ACMD_MARKER;
  1108.     if (SD_card_info.capacity) {
  1109. /* card has been initialized..check class support */
  1110. tmp = (is_acmd) ? SD_CL8 : SD_cmd2class[cmd]; /* class */
  1111. if (!(SD_csd_reg_ptr->ccc & (1<<tmp))) {
  1112.     return(0); /* card does not support command class */
  1113. }
  1114.     }
  1115.     sd_resp_ptr = (is_acmd) ? SD_acmd2resp : SD_cmd2resp;
  1118.     SD_xmit_info.cmd = command;
  1119.     SD_xmit_info.arg = arg;
  1120.     SD_xmit_info.response_expected = (sd_resp_ptr[cmd] & 0xf);
  1121.     SD_xmit_info.response_recv = 0;
  1122.     SD_xmit_info.use_data = (sd_resp_ptr[cmd]>>4);
  1123.     SD_xmit_info.wait_nclk = SD_NCR_MAX;
  1124.     SD_xmit_info.cmd_sent = 0; 
  1125.     SD_xmit_info.retry_cnt = 0;    
  1127.     if (SD_xmit_info.use_data == 2) { /* data read */
  1128. /* data destination */
  1129. if (SD_xmit_info.cmd == SD_ACMD_SD_STATUS) {
  1130.     SD_xmit_info.cur_blk_size = 6; /* 64Bytes */
  1131.     SD_xmit_info.rd_dest_ptr = (uint *)SD_status_ptr;
  1132. } else if (SD_xmit_info.cmd == SD_ACMD_SEND_SCR) {
  1133.     SD_xmit_info.cur_blk_size = 3; /* 8Bytes */
  1134.     SD_xmit_info.rd_dest_ptr = (uint *)SD_scr_reg_ptr;
  1135. }
  1136.     } else if (!SD_xmit_info.use_data
  1137.        || SD_xmit_info.response_expected) { 
  1138. /* response data destination */
  1139. if (SD_xmit_info.response_expected == SD_R2) {
  1140.     SD_xmit_info.rd_dest_ptr = 
  1141. (SD_xmit_info.cmd == SD_CMD_SEND_CSD) ?
  1142. (uint *)SD_csd_reg_ptr : (uint *)SD_cid_reg_ptr;
  1143. } else {
  1144.     if (SD_xmit_info.response_expected == SD_R3){
  1145. SD_xmit_info.rd_dest_ptr = (uint *)SD_ocr_reg_ptr;
  1146.     } else if (SD_xmit_info.response_expected == SD_R6){
  1147. /* R6 is special..*/
  1148. SD_xmit_info.rd_dest_ptr = &SD_rdata32;
  1149.     } else { /* R1 or R1b */
  1150. SD_xmit_info.rd_dest_ptr = (uint *)SD_card_status_ptr;
  1151.     }
  1152. }
  1153.     }
  1155.     return(1);
  1156. }
  1158. static int SD_slow_clk_data_out(uchar out_data)
  1159. {  
  1160.     int i;
  1161.     unsigned sclk_high, sclk_low;
  1163.     SD_GET_SCLK_VAL(sclk_high, sclk_low);
  1165.     for(i=0; i<8; i++){
  1166. if (out_data & 0x80) {
  1167.     SET_SD_CMD;
  1168. } else {
  1169.     CLEAR_SD_CMD;
  1170. }
  1171. out_data <<= 1;
  1172. CLEAR_SD_CLK;
  1173. risc_sleep_a_bit(USEC(2));
  1174. SET_SD_CLK;
  1175. risc_sleep_a_bit(USEC(2));
  1176.     }
  1177. }
  1178. /***********************************************
  1179.  up to 1 DWORD
  1180. ************************************************/
  1181. static int SD_slow_clk_data_in(int bit_cnt)
  1182. {
  1183.     int data_in = 0, i;
  1184.     unsigned sclk_high, sclk_low;
  1186.     SD_GET_SCLK_VAL(sclk_high, sclk_low);
  1188.     for (i=0; i<bit_cnt; i++) {
  1189. CLEAR_SD_CLK;
  1190. risc_sleep_a_bit(USEC(2));
  1191. SET_SD_CLK;
  1192. risc_sleep_a_bit(USEC(1));
  1193. data_in <<= 1;
  1194. data_in |= (SD_CMD_HIGH != 0);
  1195. risc_sleep_a_bit(USEC(1));
  1196.     }
  1197.     return data_in;
  1198. }
  1199. static void SD_slow_clk_pulse_l2h(void)
  1200. {
  1201.     unsigned sclk_high, sclk_low;
  1203.     SD_GET_SCLK_VAL(sclk_high, sclk_low);
  1205.     CLEAR_SD_CLK;
  1206.     risc_sleep_a_bit(USEC(2));
  1207.     SET_SD_CLK;
  1208.     risc_sleep_a_bit(USEC(2));
  1209. }
  1210. /* 
  1211.   Function: For init commands during SD card initialization,
  1212.     under clock restriction (100KHz < clk < 400KHz).
  1213.     (Also for MMC's CMD1)
  1215.   input:
  1216. command: command index (CMD1,CMD2,CMD3,CMD55,ACMD41).
  1217. arg: command argument.
  1219.   output:       
  1220. -1: timed out (reached retry limit).
  1221.  0: crc error.
  1222.        1: successful
  1224.   side-effects:
  1225. updates SD_card_status for CMD55 if success.
  1226. updates SD_ocr_reg for ACMD41/CMD1 if success. 
  1227. updates SD_cid_reg for CMD2 if success. 
  1228. updates SD_rca_reg for CMD3 if success. 
  1229. */
  1230. int SD_clk_restricted_cmd(int command, uint arg)
  1231. {
  1232.     int i, j,cnt, sd_timeout, rcv_cnt, crc_check;
  1233.     ushort sd_crc;
  1234.     uint sd_mask, tmp, data_in, *sd_rdata_ptr;
  1235.     char cmd_buf[8], rcv_buf[8], *pChar, *rdata_pchar;
  1236.     unsigned sclk_high, sclk_low;
  1238.     PRINTF(("SD_clk_restricted_cmd ...command %x, arg %xn", command, arg));
  1240.     SD_GET_SCLK_VAL(sclk_high, sclk_low);
  1241.     
  1242.     pChar = cmd_buf;
  1243.     data_in = 0x40|(command & 0x3f);
  1244.     *pChar++ = data_in;
  1246.     *pChar++ = (arg>>24) & 0xff;
  1247.     *pChar++ = (arg>>16)& 0xff;
  1248.     *pChar++ = (arg>>8) &0xff;
  1249.     *pChar++ = arg & 0xff;
  1250.     sd_crc = SD_calc_crc7(cmd_buf, 5);
  1252.     for (i=0; i<5; i++)
  1253. SD_slow_clk_data_out(cmd_buf[i]);
  1255.     tmp = (sd_crc<<1) | 1;
  1256.     /* crc7 + end bit */
  1257.     SD_slow_clk_data_out(tmp);
  1259.     SD_CMD_INPUT; /* get ready for response */
  1260.     if(SD_card_info.type == SD_MMC
  1261.        && command == SD_CMD_SEND_REL_ADDR)
  1262. sd_timeout = SD_NCR_MAX;
  1263.     else
  1264. sd_timeout = SD_NID_MAX;
  1266.     
  1267.     for (i = 0; (i < sd_timeout); i++) {
  1268. SD_slow_clk_pulse_l2h();
  1270. if (SD_CMD_LOW) { /* response start bit */
  1271.     /* xmit bit */
  1272.     SD_slow_clk_pulse_l2h();
  1273.     /* get SD response */
  1274.     sd_crc = 0;
  1275.     break;
  1276. }
  1277.     }
  1279.     if (i >= sd_timeout){
  1280. /* timed out..*/
  1281. JPRINTF(("clk_res: timed outn"));
  1282. return (-1);
  1283.     } else {
  1284. cnt = 0;
  1285. crc_check = 0;
  1286. if (command == SD_CMD_ALL_SEND_CID
  1287.     ||command == SD_CMD_SEND_CID ) {
  1288.     cnt = 3; /* extra data for R2 response */
  1289.     sd_rdata_ptr = (uint *)SD_cid_reg_ptr;
  1290. } else if ((command == SD_ACMD_SD_SEND_OP_COND) ||
  1291.    (command == SD_CMD_MMC_SEND_OP_COND)) {
  1292.     sd_rdata_ptr = (uint *)SD_ocr_reg_ptr;
  1293.     /* R3 */
  1294. } else if (command == SD_CMD_SEND_REL_ADDR
  1295.    && SD_card_info.type == SD_MEM) {
  1296.     sd_rdata_ptr = &SD_rdata32;
  1297.     /* R6 */
  1298.     crc_check = 1;
  1299. } else { /* R1 (SD_CMD_APP_CMD)*/
  1300.     sd_rdata_ptr = (uint *)SD_card_status_ptr;
  1301.     crc_check = 1;
  1302. }
  1303.     }
  1305.     
  1306.     /* clock in cmd and arg (38bits)..save only arg (last 32bits) */
  1307.     pChar = rcv_buf;
  1309.     data_in = SD_slow_clk_data_in(6);
  1310.     *pChar++ = data_in;
  1311.     rcv_cnt = 1;
  1313.     rdata_pchar = (char*)sd_rdata_ptr;
  1314.     for(j=0; j<4; j++){
  1315. data_in = SD_slow_clk_data_in(8);
  1316. *pChar++ = data_in;
  1317. rcv_cnt++;
  1318. *rdata_pchar++ = data_in;
  1319.     }
  1320.     
  1321.     cnt <<= 2;
  1322.     while (cnt){
  1323. *rdata_pchar++ = SD_slow_clk_data_in(8) ;
  1324. cnt--;
  1325. if (!cnt) goto sd_exit;
  1326.     }
  1328.     /* crc7 + end bit */
  1329.     data_in = SD_slow_clk_data_in(8) ;
  1330.     
  1331. #if CHECK_RECV_CRC 
  1332.     if (!crc_check) {
  1333. sd_crc = 0x7f; /* no CRC for R3 response */
  1334.     }else
  1335. sd_crc = SD_calc_crc7(rcv_buf, rcv_cnt);
  1336.     data_in >>= 1; /* remove end bit */
  1337.     PRINTF(("Received crc: %x, Computed crc: %xn", data_in, sd_crc));
  1338.     if (data_in != sd_crc) {
  1339. /* crc error */
  1340. CPRINTF(("CRC error in SD_clk_restricted_cmd()n"));
  1341. CPRINTF(("cmd: %d, arg: %n", command, arg));
  1342. CPRINTF(("xmit crc: 0x%x, gen crc: 0x%xn", data_in, sd_crc));
  1343. BREAKPOINT(0);
  1344. return (0);
  1345.     }
  1346. #endif
  1348.     if (command == SD_CMD_SEND_REL_ADDR
  1349. && SD_card_info.type == SD_MEM) {
  1350. sd_rdata_ptr = (uint *)SD_card_status_ptr;
  1351. *sd_rdata_ptr &= (~0x1fff); /* bit 0-12 */
  1352. *sd_rdata_ptr |= (SD_rdata32 & 0x1fff);
  1353. SD_card_status_ptr->error = 
  1354.     (SD_rdata32>>13) & 1;
  1355. SD_card_status_ptr->illegal_cmd = 
  1356.     (SD_rdata32>>14) & 1;
  1357. SD_card_status_ptr->com_crc_error = 
  1358.     (SD_rdata32>>15) & 1;
  1360. SD_rca_reg = SD_rdata32>>16; /* new RCA */
  1361.     }
  1363. sd_exit:
  1364.     /* extra 8 Clocks for SD card post-processing */
  1365.     for (i = 0; i < 8; i++) {
  1366. SD_slow_clk_pulse_l2h();
  1367.     }
  1369.     return (1); 
  1370. }
  1373. static void SD_cmd_output(uchar out_cmd)
  1374. {
  1375.     int i;
  1376.     unsigned sclk_high, sclk_low;
  1378.     SD_GET_SCLK_VAL(sclk_high, sclk_low);
  1380.     for (i=0; i<8; i++) {
  1381. if (out_cmd &0x80) {
  1382.     SET_SD_CMD;
  1383. } else {
  1384.     CLEAR_SD_CMD;
  1385. }
  1386. PULSE_SD_CLK_HL;
  1387. out_cmd <<= 1;
  1388.     }
  1389. }
  1390. static void SD_1_bit_data_out(uchar out_data)
  1391. {
  1392.     int i;
  1393.     unsigned sclk_high, sclk_low;
  1395.     SD_GET_SCLK_VAL(sclk_high, sclk_low);
  1397.     for (i=0; i<8; i++) {
  1398. CLEAR_SD_CLK;
  1399. if (out_data & 0x80) {
  1400.     SET_SD_DAT0;
  1401. } else {
  1402.     CLEAR_SD_DAT0;
  1403. }
  1404. SET_SD_CLK;
  1405. out_data <<= 1;
  1406.     }
  1407. }
  1409. static void SD_4_bit_data_out(char *pOutData, int cnt)
  1410. {
  1411.     int i;
  1412.     char out_data;
  1413.     unsigned sclk_high, sclk_low;
  1415.     SD_GET_SCLK_VAL(sclk_high, sclk_low);
  1417.     for(i= 0; i<cnt; i++){
  1418. out_data = *pOutData++;
  1419. CLEAR_SD_CLK;
  1420. SET_SD_DAT3_0( ((out_data>>4) & 0xf));
  1421. SET_SD_CLK;
  1422. CLEAR_SD_CLK;
  1423. SET_SD_DAT3_0( (out_data&0xf));
  1424. SET_SD_CLK;
  1425.     }
  1426. }
  1428. /*****************************************************************
  1429.   up to 1 DWORD
  1430. ******************************************************************/
  1431. static int SD_1_bit_data_in(int bit_cnt)
  1432. {
  1433.     int i, data_in;
  1434.     unsigned sclk_high, sclk_low;
  1436.     SD_GET_SCLK_VAL(sclk_high, sclk_low);
  1438.     data_in = 0;    
  1439.     for (i=0; i<bit_cnt; i++){
  1440. data_in <<= 1;
  1441. CLEAR_SD_CLK;
  1442. if(sd_is_mmc){
  1443.     asm("nop"); asm("nop");asm("nop");
  1444.     data_in |= SD_DAT0;
  1445.     SET_SD_CLK;
  1446. }else{
  1447.     SET_SD_CLK;
  1448.     data_in |= SD_DAT0;
  1449. }
  1450.     }     
  1451.     return data_in;
  1452. }
  1453. /* 
  1454.   Function: The main SD transmission state machine..processes
  1455.     all SD/MMC related commands. 
  1456.     (ref. SD bus protocol, pp.10-83, 
  1457.      SD-mem Physical layer specifications)
  1459.   input: no arguments, but relies on "SD_xmit_info" structure for
  1460.          state transitions and transmission info.
  1462.   output:       
  1464.   side-effects: 
  1465. "SD_xmit_info" members are updated according to 
  1466. transmission progress.
  1467. */
  1468. void SD_service(void) 
  1469. {    
  1470.     static uint sd_mask, sd_cmd_info, *sd_rdata_ptr, sd_cnt;
  1471.     static ushort sd_crc[4];
  1472.     int i,j, sd_cmd_high, sd_dat0_high, arg;
  1473.     uint tmp, data_in;
  1474.     int wr_feedback_crc;
  1475.     char cmd_buf[8], *pChar;
  1476.     unsigned sclk_high, sclk_low;
  1478.     SD_GET_SCLK_VAL(sclk_high, sclk_low);
  1480.     switch (SD_xmit_info.com_state) {
  1481.     case HOST2SD_START:
  1482. SET_SD_CMD;
  1483. CLEAR_SD_CLK;     /* prepare */
  1485. sd_cmd_info = (SD_xmit_info.cmd&0x3f)|0x40;
  1486. sd_cnt = 0;
  1487. pChar = cmd_buf;
  1488. *pChar++ = sd_cmd_info;
  1489. arg = SD_xmit_info.arg;
  1490. *pChar++ =(arg>>24)&0xff;
  1491. *pChar++ =(arg>>16)&0xff;
  1492. *pChar++ =(arg>>8)&0xff;
  1493. *pChar = arg & 0xff;
  1494. sd_crc[0] = SD_calc_crc7(cmd_buf, 5);
  1496. SD_xmit_info.com_state = HOST2SD_CMD;
  1497. SD_xmit_info.result = -1; /* need to set to be 0 when succeed, 
  1498.                                      currently only used in case of Erase */
  1499. /*break; save time..let it drop*/
  1500.     case HOST2SD_CMD:
  1501. sd_cnt++; /* for timeout/mode check */
  1502. /* command index/argument..8bits at a time */
  1503. for(i=0; i<5; i++)
  1504.     SD_cmd_output(cmd_buf[i]);
  1505.  
  1506. SD_xmit_info.com_state = HOST2SD_CRC7;
  1507. break;
  1508.     
  1509.     case HOST2SD_CRC7:
  1510. /* send crc7 */
  1511. tmp = (sd_crc[0]<<1) | 1; /* crc7 + end bit */
  1512. SD_cmd_output(tmp);
  1514. CLEAR_SD_CLK;
  1515. if (SD_xmit_info.response_expected) {     
  1516.     SD_CMD_INPUT; /* tristate cmd */
  1518.     if (SD_xmit_info.use_data == 2) { 
  1519. /* data read */
  1520. if (SD_xmit_info.data_width) {
  1521.     /* all four data lines used */
  1522.     SD_DAT3_0_INPUT;
  1523. } else {
  1524.     SD_DAT0_INPUT;
  1525. }
  1526. sd_cmd_info = 0; /* bytes received */
  1527. SD_xmit_info.wait_nclk = SD_card_info.n_ac_max;
  1528.     } 
  1529.     else if(SD_xmit_info.response_expected == SD_R1b){
  1530. SD_DAT0_INPUT; /* busy check */
  1531.     }
  1533.     sd_rdata_ptr = SD_xmit_info.rd_dest_ptr;
  1534.     SD_xmit_info.com_state = HOST2SD_WAIT;
  1535. } else {
  1536.     SD_xmit_info.com_state = HOST2SD_8CYCLES;
  1537. }
  1538. break;
  1540.     case HOST2SD_WAIT:
  1541. /* check 8 cycles at a time */
  1542.      
  1543. for (i = 0; SD_xmit_info.wait_nclk; i++) {
  1544.     SD_LOCK15;
  1545.     SET_SD_CLK;
  1546.     if(sd_is_mmc){
  1547. CLEAR_SD_CLK;
  1548. sd_cmd_high = SD_CMD_HIGH? 1:0;
  1549. sd_dat0_high = SD_DAT0_HIGH? 1:0;
  1550.     }else{
  1551. sd_cmd_high = SD_CMD_HIGH? 1:0;
  1552. sd_dat0_high = SD_DAT0_HIGH? 1:0;
  1553. CLEAR_SD_CLK;
  1554.     }
  1556.     if (SD_xmit_info.use_data != 2
  1557. && !SD_xmit_info.response_recv
  1558. && !sd_cmd_high){ /* response start bit */
  1560. SD_LOCK15;
  1561. SET_SD_CLK;
  1562. if(sd_is_mmc){
  1563.     CLEAR_SD_CLK;
  1564.     sd_cmd_high = SD_CMD_HIGH? 1:0;
  1565. }else{
  1566.     sd_cmd_high = SD_CMD_HIGH? 1:0;
  1567.     CLEAR_SD_CLK;
  1568. }
  1570. /* get SD response */
  1571. sd_crc[0] = 0;
  1572. sd_mask = 6; /* bit count */
  1573. sd_cmd_info = 0; /* clear received bits */  
  1574. sd_cnt = 0; /* for timeout/mode check */
  1575. SD_xmit_info.com_state = SD2HOST_NODATA;
  1576. break;
  1577.     } else if ((SD_xmit_info.use_data==2) 
  1578.        && !sd_dat0_high) { /* data start bit? */
  1580. sd_crc[0] = 0; /* clear crc */
  1581. /* current block size (bytes) */
  1582.         if(SD_xmit_info.cmd == MMC_CMD_READ_UNTIL_STOP)
  1583.     sd_mask = SD_xmit_info.data_len;
  1584. else
  1585.     sd_mask = 1 << (SD_xmit_info.cur_blk_size);
  1586. if(SD_xmit_info.data_width){
  1587.     SD_xmit_info.com_state = SD2HOST_DATA4;
  1588. }
  1589. else{
  1590.     SD_xmit_info.com_state = SD2HOST_DATA1;
  1591. }
  1592. break;
  1593.     }
  1594.     /* btan: After received response, we actually don't need wait n_wr_max clk. *
  1595.      * 4 clk is ok for my SD. I did not test other SD. If you meet problem in   *
  1596.      * SD writing function, please increase it or let me know. */
  1597.     else if (SD_xmit_info.use_data != 2 && SD_xmit_info.response_recv 
  1598.      && sd_cmd_high && SD_xmit_info.wait_nclk > 4) {
  1599. SD_xmit_info.wait_nclk = 4;
  1600.     }
  1601.     SD_xmit_info.wait_nclk--;
  1602. }
  1604. if (!SD_xmit_info.wait_nclk) {
  1605. #ifdef  SD_ENABLE_WRITE
  1606.     if (SD_xmit_info.use_data == 1
  1607. && SD_xmit_info.response_recv) {
  1608. /* prepare to write.. */
  1610. /* current block size (bytes) */
  1611. sd_cmd_info = 1 << (SD_xmit_info.cur_blk_size);
  1612. if (SD_xmit_info.data_width) {
  1613.     /* write wide bus */
  1614.     CLEAR_SD_DAT3_0;
  1615.     SD_xmit_info.com_state = HOST2SD_DATA4;
  1616. } else {
  1617.     CLEAR_SD_DAT0;
  1618.     SD_xmit_info.com_state = HOST2SD_DATA1;
  1619. }     
  1620. break;
  1621.     } else 
  1622. #endif /* SD_ENABLE_WRITE */
  1623.     {
  1624. /* timed out..send again?? */
  1625.                 JPRINTF(("SD res:time out. xmit_len %d, xmit_cnt %d cmd %dn",
  1626.  SD_xmit_info.data_len, SD_xmit_info.data_cnt,
  1627.  SD_xmit_info.cmd));
  1628. SD_xmit_info.retry_cnt++;
  1629. SD_xmit_info.com_state = HOST2SD_8CYCLES;
  1630.     }
  1631. }
  1632. break;
  1634. #ifdef SD_ENABLE_WRITE
  1635.     case HOST2SD_DATA1:
  1636. /* write data, one byte at a time */
  1637. sd_cmd_info = 1 << (SD_xmit_info.cur_blk_size);
  1638. pChar = (char*)SD_xmit_info.wr_src_ptr + SD_xmit_info.data_cnt;
  1639. /* crc16 calculation for narrow bus */
  1640. sd_crc[0] = SD_calc_crc16((uchar *)pChar,sd_cmd_info);
  1641.         JPRINTF(("Xmit src %x, len %dn", pChar, sd_cmd_info));
  1642. /* send start bit */
  1643.     CLEAR_SD_DAT0;
  1644.     CLEAR_SD_CLK;
  1645.     SET_SD_CLK;
  1646. for(i=0; i<sd_cmd_info; i++)
  1647.     SD_1_bit_data_out(*pChar++);
  1648.    
  1649. SD_xmit_info.data_cnt += sd_cmd_info; /* monitor total bytes */
  1651. /* set wait timeout cycles..in case multi-block */
  1652. SD_xmit_info.wait_nclk = SD_card_info.n_wr_max; 
  1653. /* finished data..send CRC */
  1654. SD_xmit_info.com_state = HOST2SD_CRC16_DATA;
  1655. break;
  1657.     case HOST2SD_DATA4:
  1658. /* wide bus write, 32bits at a time */
  1659. sd_cmd_info = 1 << (SD_xmit_info.cur_blk_size);
  1660. pChar = (char*)SD_xmit_info.wr_src_ptr + SD_xmit_info.data_cnt;
  1661.         PRINTF(("wr_src_ptr %x, data_cnt %x pChar %xn",
  1662.  SD_xmit_info.wr_src_ptr, SD_xmit_info.data_cnt, pChar));
  1663. /* crc16 calculation for 4-bit bus */
  1664. SD_calc_crc16_4_bit((int*)pChar, sd_cmd_info>>2, sd_crc);
  1665. /* send start bit */
  1666.     CLEAR_SD_DAT3_0;
  1667.     CLEAR_SD_CLK;
  1668.     SET_SD_CLK;
  1670. SD_4_bit_data_out(pChar, sd_cmd_info);
  1672. SD_xmit_info.data_cnt += sd_cmd_info; /* monitor total bytes */
  1673. /* set wait timeout cycles..in case multi-block */
  1674. SD_xmit_info.wait_nclk = SD_card_info.n_wr_max; 
  1675. /* finished data "block"..get CRC */
  1676. SD_xmit_info.com_state = HOST2SD_CRC16_DATA;
  1678. break;
  1680.     case HOST2SD_CRC16_DATA:
  1681. /* send crc16 */
  1682. if (SD_xmit_info.data_width){
  1683.     /* wide bus */
  1684.     uint filter = 0x8000;
  1685.     for (i=0; i<16; i++){
  1686. CLEAR_SD_CLK;
  1687. tmp = 0;
  1688.                 for(j=0; j<4; j++){
  1689.     tmp |= ( (sd_crc[j]&filter?1:0)<<j);
  1690. }
  1691. SET_SD_DAT3_0(tmp);
  1692. SET_SD_CLK;
  1693.      filter >>= 1;
  1694.     }
  1695.     /* send end bit */
  1696.     CLEAR_SD_CLK;
  1697.     SET_SD_DAT3_0(0xf); /* set dat[3:0] high */
  1698.     SET_SD_CLK;
  1700.     SD_DAT0_INPUT;    
  1701. } else {
  1702.     /* narrow bus */
  1703.     SD_1_bit_data_out(sd_crc[0]>>8);
  1704.     SD_1_bit_data_out(sd_crc[0]&0xff);
  1705.     /* send end bit */
  1706.     CLEAR_SD_CLK;
  1707.     SET_SD_DAT0;
  1708.     SET_SD_CLK;
  1710.     SD_DAT0_INPUT;    
  1711. }
  1712. PRINTF(("wait to get crc back n"));
  1713. /* 2 clks..then there should be CRC check start bit */
  1714. PULSE_SD_CLK;     
  1715. PULSE_SD_CLK;
  1717. /* crc status: 010: Ok
  1718.                        101: Transimission error
  1719.                        111: Error */
  1720. wr_feedback_crc = SD_1_bit_data_in(5);
  1722. sd_cnt = 0;
  1723.         if(wr_feedback_crc != 0x5){
  1724.     JPRINTF(("crc after xmit CRC16: %xn",wr_feedback_crc));
  1725.     SD_xmit_info.com_state = HOST2SD_8CYCLES;
  1726. }
  1727. else{
  1728.     SD_xmit_info.wait_nclk = 100*SD_card_info.n_wr_max; 
  1729.     SD_xmit_info.com_state = HOST2SD_CHECK_BUSY;
  1730. }
  1731. break;
  1732. #endif /* SD_ENABLE_WRITE */
  1733.     case HOST2SD_CHECK_BUSY:
  1735. #if 0
  1736. /* Reading performance will be impacted */
  1737. RISC_sleep_nsec(3000000);
  1738. #endif
  1739. sd_cnt++; /* for timeout/mode check */
  1740. for (i=0; i<8; i++) {
  1741.     PULSE_SD_CLKZ;
  1742.     if (SD_DAT0_HIGH) { /* Busy bit */
  1743. /* SD not Busy..continue */
  1744. /* set next_state..
  1745.  *  - for single-block write, prepare to go idle 
  1746.  *  - for multi-block write, write another block
  1747.  */
  1748. PRINTF((" Not busy ... xmit_cnt %dn", 
  1749.  SD_xmit_info.data_cnt));
  1751. if(SD_xmit_info.cmd == SD_CMD_WRITE_MULTI_BLOCK
  1752.    && SD_xmit_info.data_cnt < SD_xmit_info.data_len){
  1753.     SD_xmit_info.wait_nclk = SD_card_info.n_wr_max; 
  1754.     SD_xmit_info.com_state = HOST2SD_WAIT;
  1755. }
  1756. else{
  1757.     SD_xmit_info.com_state = HOST2SD_8CYCLES;
  1758.     SD_xmit_info.result = 0;
  1759. }
  1760. /* single block write  or erase*/
  1761. break;
  1762.     }
  1763. }
  1765. /*consider a timeout mechanism for this state */
  1767. if (sd_cnt > SD_xmit_info.wait_nclk){
  1768.     JPRINTF(("Check Bus Busy: Time outn"));
  1769.     SD_xmit_info.com_state = HOST2SD_8CYCLES; 
  1770. }
  1771. break;
  1772.     case SD2HOST_NODATA:
  1773. sd_cnt++; /* for timeout/mode check */
  1774. /* response: command index/arg..8bits at a time */
  1775. data_in = 0;
  1776.        
  1777. for (i=0; (i<8) && sd_mask; i++) {
  1778.     SD_LOCK15;     
  1779.             SET_SD_CLK;
  1780.     if(sd_is_mmc){
  1781. CLEAR_SD_CLK;
  1782. sd_cmd_high = SD_CMD_HIGH? 1:0;
  1783.     }else{
  1784. sd_cmd_high = SD_CMD_HIGH? 1:0;
  1785. CLEAR_SD_CLK;
  1786.     }
  1788.     data_in <<= 1;
  1789.     data_in |= sd_cmd_high;
  1790.     sd_mask--; /* bit count remain */
  1791. }
  1793. if (i==8) { /* one arg byte in..cmd index only has 6 bits */
  1794.     SD_rdata32 <<= 8;
  1795.     SD_rdata32 |= data_in;
  1797.     sd_cmd_info += 8; /* received bits */     
  1798.     if (sd_cmd_info == 32) { /* received 32 bits */
  1799. *sd_rdata_ptr++ = SD_rdata32;
  1800. /* for 32 bit data we won't get anymore */
  1801. sd_cmd_info = 0; /* reset */
  1802.     }
  1803. }
  1805. if (!sd_mask) {
  1806.     if (sd_cnt == 1) {
  1807. /* finished cmd..get arg */
  1808. if (SD_xmit_info.response_expected == SD_R2) {
  1809.     sd_mask = 120; /* CID/CSD bit count */
  1810.     sd_crc[0] = 0; /* CRC7 on arg data only */
  1811. } else {
  1812.     sd_mask = 32; /* bit count */
  1813. }
  1814. sd_cmd_info = 0; /* clear received bits */
  1816. /* no state change..SD_xmit_info.com_state */
  1817.     } else if ((sd_cnt == 16) &&
  1818.        (SD_xmit_info.response_expected == SD_R2)) {
  1819. /* finished CID/CSD register..next CRC7 */
  1820. sd_crc[1] = sd_crc[0]; /* save current crc */
  1821. sd_mask = 8; /* internal CRC7 + end bit */
  1823. /* no state change..SD_xmit_info.com_state */
  1824.     } else {
  1825. /* finished arg.. */
  1826. if (SD_xmit_info.response_expected == SD_R2) {
  1827.     /* internal crc */
  1828. #if SD_CHECK_RECV_CRC
  1829.     data_in = 
  1830. (SD_xmit_info.cmd == SD_CMD_SEND_CSD) ?
  1831. (uint)SD_csd_reg_ptr->crc : 
  1832. (uint)SD_cid_reg_ptr->crc;
  1833.     
  1834.     data_in &= 0x7f; /* 7bit crc */
  1835.     sd_crc[1] &= 0x7f; /* 7bit crc */
  1836.     if (data_in != sd_crc[1]) {
  1837. /* crc error */
  1838. SD_xmit_info.crc7_err_cnt++;
  1839. CPRINTF(("R2 CRC7 error in SD_service()n"));
  1840. CPRINTF(("xmit crc: 0x%x, gen crc: 0x%xn",
  1841.  data_in, sd_crc[1]));
  1842. BREAKPOINT(0);
  1843.     }
  1844. #endif /* SD_CHECK_RECV_CRC */
  1845.     SD_xmit_info.response_recv = 1;
  1846.     SD_xmit_info.com_state = HOST2SD_8CYCLES;
  1847. } else {
  1848.     /* R6 response data */
  1849.     if (SD_xmit_info.response_expected == SD_R6) {
  1850. sd_rdata_ptr = (uint *)SD_card_status_ptr;
  1851. *sd_rdata_ptr &= (~0x1fff);
  1852. *sd_rdata_ptr |= (SD_rdata32 & 0x1fff);
  1853. SD_card_status_ptr->error = 
  1854.     (SD_rdata32>>12) & 1;
  1855. SD_card_status_ptr->illegal_cmd = 
  1856.     (SD_rdata32>>13) & 1;
  1857. SD_card_status_ptr->com_crc_error = 
  1858.     (SD_rdata32>>14) & 1;
  1860. SD_rca_reg = SD_rdata32>>16;
  1861.     }
  1863.     if (SD_xmit_info.response_expected == SD_R3) {
  1864. /* R3 response has no CRC7 */
  1865. sd_crc[0] = 0x7f;
  1866.     }
  1867.     /* finished arg..get CRC */
  1868.     SD_xmit_info.com_state = SD2HOST_CRC7_NODATA;
  1869. }
  1870.     }
  1871. }
  1872. break;
  1874.     case SD2HOST_DATA1:
  1875. /* just get data, 32*sd_maskbits at a time..ignore response */
  1876.          
  1877.  PRINTF(("SD2HOST_DATA1: xmit_len %d, xmit_data %d sd_mask %dn",
  1878.   SD_xmit_info.data_len, SD_xmit_info.data_cnt, sd_mask));
  1879.  
  1880.  sd_cmd_info = sd_mask;
  1881.  j = (sd_mask+3)/4;
  1882.  if(sd_is_mmc){
  1883.      do{
  1884.  data_in = 0;    
  1885.  for (i=0; (i<32); i++){
  1886.      data_in <<= 1;
  1887.      SD_LOCK15;
  1888.      SET_SD_CLK;
  1889.      CLEAR_SD_CLK;
  1890.      asm("nop"); asm("nop");asm("nop");
  1891.      data_in |= SD_DAT0;
  1892.  }     
  1893.  *sd_rdata_ptr++ = data_in;
  1894.      }while(--j>0);
  1895.  
  1896.  }else{
  1897.      do{
  1898.  data_in = 0;    
  1899.  for (i=0; (i<32); i++){
  1900.      data_in <<= 1;
  1901.      SD_LOCK15;
  1902.      SET_SD_CLK;
  1903.      data_in |= SD_DAT0;
  1904.      CLEAR_SD_CLK;
  1905.  }     
  1906.  *sd_rdata_ptr++ = data_in;
  1907.      }while(--j>0);
  1908.  }
  1909.  PRINTF(("SD_xmit_cmd %dn", SD_xmit_info.cmd));
  1910.  if(SD_xmit_info.cmd == SD_CMD_READ_MULTI_BLOCK){
  1911.      SD_xmit_info.data_cnt += sd_cmd_info;
  1912.      PRINTF(("SD_xmit_cmd %dn", SD_xmit_info.cmd));
  1913.  }
  1914.  else{
  1915.      SD_xmit_info.data_cnt = sd_cmd_info;
  1916.  }
  1917.  
  1918.  /* set wait timeout cycles..in case multi-block */
  1919.  SD_xmit_info.wait_nclk = SD_card_info.n_ac_max;
  1920.  
  1921.  /* finished arg..get CRC */
  1922.  if(SD_xmit_info.cmd == MMC_CMD_READ_UNTIL_STOP){
  1923.      SD_xmit_info.com_state = SD_IDLE;
  1924.  }else{
  1925.      SD_xmit_info.com_state = SD2HOST_CRC16_DATA;
  1926.      PRINTF(("go to get CRC16n"));
  1927.  }
  1928.  break;
  1930.     case SD2HOST_DATA4:
  1931. /* just get data, 32bits at a time..ignore response */
  1932. sd_cmd_info += sd_mask;
  1933. sd_mask >>= 2;
  1934. do{
  1935.     data_in = 0;
  1936.     for (i=0; (i<8); i++){
  1937. SD_LOCK15;
  1938. SET_SD_CLK;
  1939. data_in <<= 4;
  1940. data_in |= SD_DAT3_0;
  1941. CLEAR_SD_CLK;
  1942.     }
  1943.     *sd_rdata_ptr++ = data_in;
  1944.     sd_mask--; /* bytes remain */
  1945. }while(sd_mask>0);
  1946. SD_xmit_info.data_cnt = sd_cmd_info; /* monitor total bytes */
  1948. /* set wait timeout cycles..in case multi-block */
  1949. SD_xmit_info.wait_nclk = SD_card_info.n_ac_max; 
  1950. /* finished data block..get CRC */
  1951. SD_xmit_info.com_state = SD2HOST_CRC16_DATA;
  1952. break;
  1954.     case SD2HOST_CRC7_NODATA:
  1955. /* get crc7 */
  1956. data_in = 0;
  1957. /* clock in crc7 + end bit */
  1958.  
  1959. for (i=0; (i < 8); i++) {
  1960.     SD_LOCK15;
  1961.     SET_SD_CLK;
  1962.     if(sd_is_mmc){
  1963. CLEAR_SD_CLK;
  1964. sd_cmd_high = SD_CMD_HIGH ?1:0;
  1965.     }else{
  1966. sd_cmd_high = SD_CMD_HIGH ?1:0;
  1967. CLEAR_SD_CLK;
  1968.     }
  1969. #if SD_CHECK_RECV_CRC
  1970.     data_in <<= 1;
  1971.     data_in |= sd_cmd_high;
  1972. #endif
  1973. }
  1974. SD_xmit_info.response_recv = 1;
  1975. if(SD_xmit_info.response_expected == SD_R1b){
  1977.     if(SD_xmit_info.cmd == SD_CMD_ERASE
  1978.    && (SD_card_status_ptr->erase_seq_error
  1979.        || SD_card_status_ptr->erase_param)
  1980.        ){
  1981. JPRINTF(("Erase error...n"));
  1982. SD_xmit_info.com_state = HOST2SD_8CYCLES;
  1983.     }else{
  1984. SD_xmit_info.wait_nclk = 100*SD_card_info.n_wr_max; 
  1985. SD_xmit_info.com_state = HOST2SD_CHECK_BUSY;
  1986. JPRINTF(("R1b: to check busy state: card_status %x, cmd %d n",
  1987.  *(int*)SD_card_status_ptr, SD_xmit_info.cmd));
  1988.     }
  1989. }else{
  1990. #ifdef SD_ENABLE_WRITE
  1991.     if (SD_xmit_info.cmd == SD_CMD_WRITE_BLOCK
  1992. ||SD_xmit_info.cmd == SD_CMD_WRITE_MULTI_BLOCK ) { 
  1993. /* data write */
  1994. if (SD_xmit_info.data_width) {
  1995.     SET_SD_DAT3_0(0xf); /* set dat[3:0] high */
  1996. } else {
  1997.     SET_SD_DAT0;
  1998. }
  1999. SD_xmit_info.wait_nclk = SD_card_info.n_wr_max;
  2000. SD_xmit_info.com_state = HOST2SD_WAIT;
  2001. SD_xmit_info.data_cnt = 0;
  2002. JPRINTF(("Wait to write data, status %xn",
  2003.  *(int*)SD_card_status_ptr));
  2004.     }else
  2005. #endif /* SD_ENABLE_WRITE */
  2006. SD_xmit_info.com_state = HOST2SD_8CYCLES;
  2008. }
  2009. break;
  2011.     case SD2HOST_CRC16_DATA:
  2012. /* get crc16 */
  2013. data_in = 0;
  2014. /* clock in crc16 + end bit */
  2015.         PRINTF(("SD2HOST_CRC16_DATA:n"));
  2016. for (i=0; (i < 17); i++) {
  2017.     data_in <<= 1;
  2018.     SD_LOCK15;
  2019.     SET_SD_CLK;
  2020.     if(sd_is_mmc){
  2021. CLEAR_SD_CLK;
  2022. data_in |= SD_DAT0;
  2023.     }else{
  2024. data_in |= SD_DAT0;
  2025. CLEAR_SD_CLK;
  2026.     }
  2027. }
  2028. if(data_in &1 == 0)
  2029. JPRINTF(("End bit not found.n"));
  2030. /* 
  2031.  *  - for single-block read, prepare to go idle 
  2032.  *  - for multi-block read, get another block
  2033.  */
  2034. if (SD_xmit_info.cmd == SD_CMD_READ_MULTI_BLOCK) {
  2035.     PRINTF(("end of sector, xmit_cnt %d  xmit_len %dn", 
  2036.      SD_xmit_info.data_cnt,SD_xmit_info.data_len));
  2037.     if(sd_is_mmc 
  2038.        && SD_xmit_info.data_cnt>= SD_xmit_info.data_len){
  2039.    SD_xmit_info.com_state = HOST2SD_8CYCLES;
  2040.    SD_xmit_info.response_recv = 1;
  2041.    PRINTF(("command->HOST2SD_8CYCLES n"));
  2042.        }
  2043.     else{
  2044. SD_xmit_info.com_state = HOST2SD_WAIT;
  2045.     }
  2046. } else {
  2047.     SD_xmit_info.response_recv = 1; /* prevent resend */
  2048.     SD_xmit_info.com_state = HOST2SD_8CYCLES;
  2049. }
  2050. break;
  2052.     case HOST2SD_8CYCLES:
  2053. /* extra 8 Clocks for SD card's post-processing */
  2054. for (i = 0; i < 8; i++){
  2055.     SD_LOCK15;
  2056.     SET_SD_CLK;
  2057.     CLEAR_SD_CLK;
  2058. }
  2059. /* check for next command..or resend */
  2060. if (SD_get_next_cmd()){
  2061.     JPRINTF(("next cmd not emptyn"));
  2062.     SD_xmit_info.com_state = HOST2SD_START;
  2063. } else {
  2064.     SD_xmit_info.cmd_sent = 1; /* cmd completed */
  2065.     SD_xmit_info.com_state = SD_IDLE;
  2066. }
  2067. break;
  2069.     case SD_IDLE:
  2070.     default:
  2071. break;
  2072.     }
  2073.     VCX_service();
  2074. }
  2076. int SD_get_status(void)
  2077. {
  2078.     int status = 0;
  2079.     
  2080.     status = SD_send_cmd(SD_CMD_SEND_STATUS,  SD_rca_reg<<16, 1);
  2081.     if(status != 1)
  2082. return -1;
  2083.     else
  2084. return (*(int*)SD_card_status_ptr);
  2085. }
  2087. #ifdef MD_ASYNC_RW
  2090. void SD_clear_state()
  2091. {
  2092.     SD_xmit_info.com_state = SD_IDLE;
  2093.     SD_xmit_info.cmd = SD_CMD_EMPTY;
  2094.     SD_acmdq.cmd = SD_CMD_EMPTY; /* clear cmd-Q */
  2095.     return;
  2096. }
  2098. /* return: 0: not finish; 1: finish; 2:read single finish; *
  2099.  * 3:write single finish; 4: read multi finish; 5: write multi finish*/
  2100. int SD_cmd_service()
  2101. {
  2102.     int ret = 0, status = 1;
  2103.     if (!SD_card_info.inserted) {
  2104. SD_clear_state();
  2105. return 1;
  2106.     }
  2107.     if (SD_xmit_info.com_state != SD_IDLE) SD_service();
  2108.     if (SD_xmit_info.com_state == SD_IDLE) {
  2109. if (SD_xmit_info.cmd == SD_CMD_READ_SINGLE_BLOCK) {
  2110.     ret = 2;
  2111. }
  2112. else if (SD_xmit_info.cmd == SD_CMD_WRITE_BLOCK) {
  2113.     ret = 3;
  2114. }
  2115. else if (SD_xmit_info.cmd == SD_CMD_READ_MULTI_BLOCK) {
  2116.     ret = 4;
  2117. }
  2118. else if (SD_xmit_info.cmd == SD_CMD_WRITE_MULTI_BLOCK) {
  2119.     ret = 5;
  2120. }
  2122. if (SD_xmit_info.cmd == SD_CMD_WRITE_MULTI_BLOCK || 
  2123.     SD_xmit_info.cmd == SD_CMD_READ_MULTI_BLOCK) {
  2124.     SD_xmit_info.cmd = SD_CMD_EMPTY;
  2125.     status = SD_send_cmd(SD_CMD_STOP_TRANSMIT, 0, 0);
  2126. }
  2127. else {
  2128.     SD_xmit_info.cmd = SD_CMD_EMPTY;
  2129.     if (!SD_get_next_cmd() && !ret) ret = 1;
  2130. }
  2131.     }
  2132.     else if (SD_xmit_info.cmd == SD_CMD_READ_MULTI_BLOCK &&
  2133.      SD_xmit_info.data_cnt >= SD_xmit_info.data_len && !sd_is_mmc) {
  2134. status = SD_send_cmd(SD_CMD_STOP_TRANSMIT, 0, 0);
  2135. ret = 4;
  2136.     }
  2137.     return ret;
  2138. }
  2139. #endif /*MD_ASYNC_RW*/
  2142. #if NOT_USED 
  2143. /* 
  2144.   Function: 
  2146.   input:
  2148.   output:       
  2150.   side-effects:
  2151. */
  2152. int SD_get_status(void)
  2153. {
  2154.     uint status = 0;
  2155.     
  2156.     if (SD_card_info.type > SD_MMC) {
  2157. SD_send_acmd(SD_ACMD_SD_STATUS, 0, 1);
  2158.     }
  2160.     return (status);
  2161. }
  2163. /* 
  2164.   Function: SD lock card (password protect)
  2166.   input:
  2168.   output:       
  2170.   side-effects:
  2171. */
  2172. int SD_lock_card(int action, char *passwd)
  2173. {
  2174.     int status;
  2175.     
  2176.     /*  lock/unlock card */
  2177.     return (status);
  2178. }
  2180. /* 
  2181.   Function: SD set password 
  2183.   input:
  2185.   output:       
  2187.   side-effects:
  2188. */
  2189. int SD_set_password(char *passwd)
  2190. {
  2191.     int status;
  2192.     
  2193.     /* set password */
  2194.     return (status);
  2195. }
  2197. /* 
  2198.   Function: SD reset password 
  2200.   input:
  2202.   output:       
  2204.   side-effects:
  2205. */
  2206. int SD_reset_password(char *passwd)
  2207. {
  2208.     int status;
  2209.     
  2210.     /* reset password  w/ and w/o password */
  2211.     return (status);
  2212. }
  2214. /* 
  2215.   Function: 
  2217.   input:
  2219.   output:       
  2221.   side-effects:
  2222. */
  2223. int SD_write_data(uint data)
  2224. {
  2225.     int status;
  2227.     /* send data w/ CRC16 */
  2228.     return (status);
  2229. }
  2230. #endif
  2232. #endif /* SD_MEMORY */