URL https://opencores.org/ocsvn/sdcard_mass_storage_controller/sdcard_mass_storage_controller/trunk

Subversion Repositories sdcard_mass_storage_controller

[/] [sdcard_mass_storage_controller/] [trunk/] [sw/] [sdc_fifo/] [main.c] - Blame information for rev 87

Go to most recent revision | Details | Compare with Previous | View Log


 
/*$$HEADER*/
/******************************************************************************/
/*                                                                            */
/*                    H E A D E R   I N F O R M A T I O N                     */
/*                                                                            */
/******************************************************************************/
 
// Project Name                   : Development Board Debugger Example 
// File Name                      : main.c
// Prepared By                    : jb
// Project Start                  : 2009-01-01
 
 
/*$$COPYRIGHT NOTICE*/
/******************************************************************************/
/*                                                                            */
/*                      C O P Y R I G H T   N O T I C E                       */
/*                                                                            */
/******************************************************************************/
 
// Copyright (c) ORSoC 2009 All rights reserved.
 
// The information in this document is the property of ORSoC.
// Except as specifically authorized in writing by ORSoC, the receiver of
// this document shall keep the information contained herein confidential and
// shall protect the same in whole or in part thereof from disclosure and
// dissemination to third parties. Disclosure and disseminations to the receiver's
// employees shall only be made on a strict need to know basis.
 
 
/*$$DESCRIPTION*/
/******************************************************************************/
/*                                                                            */
/*                           D E S C R I P T I O N                            */
/*                                                                            */
/******************************************************************************/
 
// Perform some simple functions, used as an example when first using the 
// debug cable and proxy with GDB.
 
/*$$CHANGE HISTORY*/
/******************************************************************************/
/*                                                                            */
/*                         C H A N G E  H I S T O R Y                         */
/*                                                                            */
/******************************************************************************/
 
// Date         Version Description
//------------------------------------------------------------------------
// 090101       1.0     First version                           jb
 
/*$$INCLUDE FILES*/
/******************************************************************************/
/*                                                                            */
/*                      I N C L U D E   F I L E S                             */
/*                                                                            */
/******************************************************************************/
 
#define INCLUDED_FROM_C_FILE
 
#include "orsocdef.h"
#include "board.h"
#include "uart.h"
#include "main.h"
#define SD_REG(REG)  REG32(SD_CONTROLLER_BASE+REG) 
/*$$PRIVATE MACROS*/
/******************************************************************************/
/*                                                                            */
/*                      P R I V A T E   M A C R O S                           */
/*                                                                            */
/******************************************************************************/
 
/*$$GLOBAL VARIABLES*/
/******************************************************************************/
/*                                                                            */
/*                   G L O B A L   V A R I A B L E S                          */
/*                                                                            */
/******************************************************************************/
 
/*$$PRIVATE VARIABLES*/
/******************************************************************************/
/*                                                                            */
/*                  P R I V A T E   V A R I A B L E S                         */
/*                                                                            */
/******************************************************************************/
 
 
/*$$FUNCTIONS*/
/******************************************************************************/
/*                                                                            */
/*                          F U N C T I O N S                                 */
/*                                                                            */
/******************************************************************************/
 
 
/******************************************************************************/
/*                        W R I T E  T O EXTERNAL SDRAM 1                     */
/******************************************************************************/
 
// Write to External SDRAM  
void Write_External_SDRAM_1(void)
{
   uint32      i;
   uint32      read;
   uint32      range;
   uint32      adr_offset;
 
   range      = 0x7ff;        // Max range: 0x7fffff
   adr_offset = 0x00000000;  // External memory offset
 
   for (i=0x0; i < range; i=i+4) {
      REG32(adr_offset + i)   = (adr_offset + i);
   }
 
   for (i=0x0; i < range; i=i+4) {
     read = REG32(adr_offset + i);
     if (read != (adr_offset + i)) {
       while(TRUE){            //ERROR=HALT PROCESSOR 
       }
     }
   }
}
 
 
/*$$EXTERNAL EXEPTIONS*/
/******************************************************************************/
/*                  E X T E R N A L   E X E P T I O N S                       */
/******************************************************************************/
 
 
void external_exeption()
{
  REG uint8 i;
  REG uint32 PicSr,sr;
 
}
 
/*$$MAIN*/
/******************************************************************************/
/*                                                                            */
/*                       M A I N   P R O G R A M                              */
/*                                                                            */
/******************************************************************************/
 
 
 
 
 
 
//TO do
// Always check if error in repose (CRC, CICE) etc
// Always check for CICM (Command inhibit before senindg)
// Timeout when polling
// Divied into dividing Functions
// Clean up
 
 
#define BUSY 0x80
#define CRC_TOKEN 0x29
 
//SDC_REGISTERS
#define TX_CMD_FIFO 0x00
#define RX_CMD_FIFO 0x04
#define TX_DATA_FIFO 0x08
#define RX_DATA_FIFO 0x0C
#define STATUS 0x10
#define CONTROLL 0x14
#define TIMER_REG 0x18
 
//Program Defines
#define TRANSMISSION_FAILURE 1
#define TRANSMISSION_SUCCESSFUL 0
#define BYTE_1_MASK 0x000000FF
#define BYTE_2_MASK 0x0000FF00
#define BYTE_3_MASK 0x00FF0000
#define BYTE_4_MASK 0xFF000000
#define MMC_DATA_SIZE 512
 
BYTE MMCWRData[MMC_DATA_SIZE];
BYTE MMCRDData[MMC_DATA_SIZE];
 
unsigned char rca[2];
 
bool mmc_get_cmd_bigrsp (volatile unsigned char *rsp)
{
   unsigned char rtn_reg=0;
   unsigned char rtn_reg_timer=0;
  int arr_cnt=0;
 rtn_reg_timer= SD_REG(TIMER_REG);
  while (rtn_reg_timer != 0)
  {
     rtn_reg = SD_REG(STATUS);
                 if  (( rtn_reg & 0x2) != 0x2) //RX Fifo not Empty
                 {
                         rsp[arr_cnt]=SD_REG(RX_CMD_FIFO);
                         arr_cnt++;
 
                 }
                 if (arr_cnt==15)
                                return 1;
      rtn_reg_timer= SD_REG(TIMER_REG);
  }
  return 0;
}
 
/************************** SD mmc_get_cmd_rsp *********************************/
/*
* Read CMD_RX_FIFO, add to the rsp array,
* 1 on success, return 0 at timeout
*
*/
bool mmc_get_cmd_rsp (volatile unsigned char *rsp)
{
   volatile unsigned char rtn_reg=0;
   volatile unsigned char rtn_reg_timer=0;
  int arr_cnt=0;
 rtn_reg_timer= SD_REG(TIMER_REG);
  while (rtn_reg_timer != 0)
  {
     rtn_reg = SD_REG(STATUS);
                 if  (( rtn_reg & 0x2) != 0x2) //RX Fifo not Empty
                 {
                         rsp[arr_cnt]=SD_REG(RX_CMD_FIFO);
                         arr_cnt++;
 
                 }
                 if (arr_cnt==5)
                                return 1;
      rtn_reg_timer= SD_REG(TIMER_REG);
  }
  return 0;
}
 
 
 
 
 
 
int  mmc_init()
 
{
 
         volatile unsigned char rtn_reg=0;
         volatile unsigned int spv_2_0 =0;
         volatile unsigned char response[15];
         volatile unsigned char out_cmd[5];
         response[0]=0;
         //Reset the hardware
         /* initialise the MMC card into SD-Bus mode, is performed in HW*/
         SD_REG(CONTROLL)=1;
         SD_REG(CONTROLL)=0;
 
     //Reset SD Card. CMD 0, Arg 0. 
         //No response, wait for timeout
         SD_REG(TX_CMD_FIFO)=0x40;
         SD_REG(TX_CMD_FIFO)=0x00;
         SD_REG(TX_CMD_FIFO)=0x00;
         SD_REG(TX_CMD_FIFO)=0x00;
         SD_REG(TX_CMD_FIFO)=0x00;
 
         while ( SD_REG(TIMER_REG) != 0){}
 
     //Check for SD 2.0 Card, 
         SD_REG(TX_CMD_FIFO)=0x48;
         SD_REG(TX_CMD_FIFO)=0x00;
          SD_REG(TX_CMD_FIFO)=0x00;
         SD_REG(TX_CMD_FIFO)=0x01;
         SD_REG(TX_CMD_FIFO)=0xAA;
 
     //if response, card is v2.0 compatible, else reset card.
     if (mmc_get_cmd_rsp(&response[0]) )
       spv_2_0 = 1;
         else
         {
           SD_REG(CONTROLL)=1;
           SD_REG(CONTROLL)=0;
       SD_REG(TX_CMD_FIFO)=0x40;
           SD_REG(TX_CMD_FIFO)=0x00;
           SD_REG(TX_CMD_FIFO)=0x00;
           SD_REG(TX_CMD_FIFO)=0x00;
           SD_REG(TX_CMD_FIFO)=0x00;
 
           while ( SD_REG(TIMER_REG) != 0){}
         }
 
         if(spv_2_0==0)
         {
                //Send CMD55+ACMD41 until Busy bit is cleared (Response[0][8]==1)
                while ( (rtn_reg & BUSY) != BUSY )
                {       SD_REG(TX_CMD_FIFO)=0x77;
                        SD_REG(TX_CMD_FIFO)=0x00;
                        SD_REG(TX_CMD_FIFO)=0x00;
                        SD_REG(TX_CMD_FIFO)=0x00;
                        SD_REG(TX_CMD_FIFO)=0x00;
                        if ( mmc_get_cmd_rsp(&response[0]) && response[4]==0)
                        {
                                SD_REG(TX_CMD_FIFO)=0x69;
                                SD_REG(TX_CMD_FIFO)=0x00;
                                SD_REG(TX_CMD_FIFO)=0x00;
                                SD_REG(TX_CMD_FIFO)=0x00;
                                SD_REG(TX_CMD_FIFO)=0x00;
                                if (mmc_get_cmd_rsp(&response[0]))
                                        rtn_reg = response[0];
                                else
                                        return TRANSMISSION_FAILURE;
          }
          else
                 return TRANSMISSION_FAILURE;
         }
 
         }
         //else Physical Specification Version 2.00
         //Check response
         //Initialization (ACMD41 HCS=1)
         //Check for High Capacity or Standrd Capacity,  Ver.2.00 Card
 
     //CMD 2- get CSD, 136 bit response (Bit-40 this)
         SD_REG(TX_CMD_FIFO)=0xC2;
         SD_REG(TX_CMD_FIFO)=0x00;
         SD_REG(TX_CMD_FIFO)=0x00;
         SD_REG(TX_CMD_FIFO)=0x00;
         SD_REG(TX_CMD_FIFO)=0x00;
 
     if (!mmc_get_cmd_bigrsp(&response[0]))
                return TRANSMISSION_FAILURE;
 
         //CMD 3- get RCA nr            
         SD_REG(TX_CMD_FIFO)=0x43;
         SD_REG(TX_CMD_FIFO)=0x00;
         SD_REG(TX_CMD_FIFO)=0x00;
         SD_REG(TX_CMD_FIFO)=0x00;
         SD_REG(TX_CMD_FIFO)=0x00;
     if (mmc_get_cmd_rsp(&response[0]))
         {
                 rca[0] = response[0];
                 rca[1] = response[1];
         }
         else
                return TRANSMISSION_FAILURE;
 
     //Put card in transfer state, CMD 7
         SD_REG(TX_CMD_FIFO)=0x47;
         SD_REG(TX_CMD_FIFO)= rca[0] ;
         SD_REG(TX_CMD_FIFO)= rca[1] ;
         SD_REG(TX_CMD_FIFO)=0x0f;
         SD_REG(TX_CMD_FIFO)=0x0f;
         if (!mmc_get_cmd_rsp(&response[0]))
           return TRANSMISSION_FAILURE;
 
         //Set block size 512. CMD 16
         SD_REG(TX_CMD_FIFO)=0x50;
          SD_REG(TX_CMD_FIFO)=0;
           SD_REG(TX_CMD_FIFO)=0;
         SD_REG(TX_CMD_FIFO)=0x02;
         SD_REG(TX_CMD_FIFO)=0;
         if (!mmc_get_cmd_rsp(&response[0]))
            return TRANSMISSION_FAILURE;
 
          //Set bus width to 4. CMD 55 + ACMD 6   
          SD_REG(TX_CMD_FIFO)=0x77;
          SD_REG(TX_CMD_FIFO)= rca[0] ;
          SD_REG(TX_CMD_FIFO)= rca[1] ;
           SD_REG(TX_CMD_FIFO)=0;
            SD_REG(TX_CMD_FIFO)=0;
          if (!mmc_get_cmd_rsp(&response[0]))
                return TRANSMISSION_FAILURE;
          // ACMD 6
          SD_REG(TX_CMD_FIFO)=0x46;
           SD_REG(TX_CMD_FIFO)=0;
            SD_REG(TX_CMD_FIFO)=0;
                 SD_REG(TX_CMD_FIFO)=0;
          SD_REG(TX_CMD_FIFO)=0x02;
          if (!mmc_get_cmd_rsp(&response[0]))
                        return TRANSMISSION_FAILURE;
 
   return TRANSMISSION_SUCCESSFUL;
}
 
 
int mmc_write_block(uint32 block_number)
{
   uint32 var;
   volatile unsigned char rtn_reg=0;
     unsigned char response[4];
   int i;
 
 
    var= block_number << 9 ;
 
   for (i=0; i < MMC_DATA_SIZE; i++)
           SD_REG(TX_DATA_FIFO) = MMCWRData[i];
 
 
   //Send CMD24, Single block write
    SD_REG(TX_CMD_FIFO)=0x58;
        SD_REG(TX_CMD_FIFO)=(BYTE)((var >> 24) & 0xFF);
        SD_REG(TX_CMD_FIFO)=(BYTE)((var >> 16) & 0xFF);
        SD_REG(TX_CMD_FIFO)=(BYTE)((var >> 8) & 0xFF);
        SD_REG(TX_CMD_FIFO)=(BYTE)(var & 0xFF);
        if (!mmc_get_cmd_rsp(&response[0]))
                        return TRANSMISSION_FAILURE;
 
    //Wait for TX_DATA_FIFO to get empty                
        while ( (SD_REG(STATUS)& 0x04) == 0x04) {}
    //Wait for RX_DATA_FIFO to not get empty, indicate transmision is complete and CRC token is avaible.        
        while ( (SD_REG(STATUS) & 0x08) == 0x08) {}
 
        //Check for correct CRC repsonse token == 0x29...
        //Busy cehck is performed in HW
        rtn_reg =SD_REG(RX_DATA_FIFO);
        if ((rtn_reg & CRC_TOKEN) == CRC_TOKEN)
         return TRANSMISSION_SUCCESSFUL;
        else
         return TRANSMISSION_FAILURE;
}
 
int mmc_read_block(uint32 block_number)
{
    volatile int i = 0;
    volatile unsigned char response[4];
        volatile unsigned char rsp;
   uint32 var;
   WORD Checksum;
 
    var= block_number << 9;
 
    SD_REG(TX_CMD_FIFO)=0x51;
        SD_REG(TX_CMD_FIFO)=(BYTE)((var >> 24) & 0xFF);
        SD_REG(TX_CMD_FIFO)=(BYTE)((var >> 16) & 0xFF);
        SD_REG(TX_CMD_FIFO)=(BYTE)((var >> 8) & 0xFF);
        SD_REG(TX_CMD_FIFO)=(BYTE)(var & 0xFF);
   if (!mmc_get_cmd_rsp(&response[0]))
                        return TRANSMISSION_FAILURE;
 
rsp =  SD_REG(STATUS) & 0x08;
while ( rsp == 0x08) {
rsp =  SD_REG(STATUS) & 0x08;}
  //Checksum is notread
 
i=0;
 
 /* while (i<MMC_DATA_SIZE){
 
  MMCRDData[i]=SD_REG(RX_DATA_FIFO);
  i++;
  }
   */
 
         BYTE *p;
  p=&MMCRDData[0];
 
   register int  RX_REG asm ("r0") ;
    register int RSP asm ("r6") ;
    register int  LOOP_END asm ("r2") ;
        register int  DAT_RSP asm ("r3") ;
 
         register int  SAVE_RX_REG asm ("r18") ;
         register int  SAVE_RSP asm ("r19") ;
         register int  SAVE_LOOP_END asm ("r20") ;
         register int  SAVE_DAT_RSP asm ("r21") ;
 
    //  asm volatile ("l.mtspr %0,%1, %2" : "=r"(RSP) : "m"(p), "i"(0));
        // 10007f8:     19 80 01 00     l.movhi r12,0x100
  //10007fc:    a9 8c 34 10     l.ori r12,r12,0x3410
 
        asm volatile ("l.addi %0,%1, %2" : "=r"(SAVE_RSP ) : "r"(RSP), "i"(0));
        asm volatile ("l.addi %0,%1, %2" : "=r"(SAVE_RX_REG ) : "r"(RX_REG), "i"(0));
        asm volatile ("l.addi %0,%1, %2" : "=r"(SAVE_LOOP_END ) : "r"(LOOP_END), "i"(0));
        asm volatile ("l.addi %0,%1, %2" : "=r"(SAVE_DAT_RSP ) : "r"(DAT_RSP), "i"(0));
 
 
        RSP=&MMCRDData[0];
  // asm volatile ("l.movhi %0,%1" : "=r"(RSP) : "i"(0x100) );
   //asm volatile ("l.ori %0,%1, %2" : "=r"(RSP) :  "r"(RSP)  , "i"(0x4db0) );
 
 
    asm volatile ("l.movhi %0,%1" : "=r"(RX_REG) : "i"(0xa000) );
    asm volatile ("l.ori %0,%1, %2" : "=r"(RX_REG) :  "r"(RX_REG)  , "i"(0xc) );
 
 
   asm volatile ("l.addi %0,%1,%2" : "=r"(LOOP_END) : "r"(RSP) , "i"(0x200) );
 
   asm ("label:");
   asm volatile ("l.lwz %0,%1 %2" : "=r"(DAT_RSP) : "i"(0), "r"(RX_REG) );
   asm volatile ("l.sb  %0 %1, %2" :  : "i"(0), "r"(RSP) , "r"(DAT_RSP) );
   asm volatile ("l.addi %0,%1,%2" : "=r"(RSP) : "r"(RSP), "i"(0x1) );
 
        asm volatile ("l.sfne %0,%1" : "=r"(RSP) :"r"(LOOP_END) );
 
        asm volatile ("l.bf  label" );
 
        asm volatile ("l.nop");
        asm volatile ("l.addi %0,%1, %2" : "=r"(RSP) : "r"(SAVE_RSP ), "i"(0));
        asm volatile ("l.addi %0,%1, %2" : "=r"(RX_REG) : "r"(SAVE_RX_REG ), "i"(0));
        asm volatile ("l.addi %0,%1, %2" : "=r"(LOOP_END ) : "r"(SAVE_LOOP_END), "i"(0));
        asm volatile ("l.addi %0,%1, %2" : "=r"(DAT_RSP ) : "r"(SAVE_DAT_RSP), "i"(0));
 
 
  return TRANSMISSION_SUCCESSFUL;
}
void Start()
{
     volatile unsigned char rtn_reg=0;
    volatile unsigned char response[16];
     volatile int a;
         volatile int i;
 
         for (i=0;i<512;i++)
            MMCWRData[i]=0xff;
 
        uart_init();
        a=mmc_init();
        if (a)
                 uart_print_str("1");
         else
                 uart_print_str("0");
 
//       mmc_write_block(0); 
    mmc_read_block(0);
         for (i=0;i<512;i++)
        uart_print_long(  MMCRDData[i]);
 
                 mmc_read_block(1);
         for (i=0;i<512;i++)
          uart_print_long(  MMCRDData[i]);
 
 
}

Browse

Tools

Subversion Repositories sdcard_mass_storage_controller

[/] [sdcard_mass_storage_controller/] [trunk/] [sw/] [sdc_fifo/] [main.c] - Blame information for rev 87

Line No.	Rev	Author	Line
1	85	tac2
2			`/$$HEADER/`
3			`/******************************************************************************/`
4			`/* */`
5			`/* H E A D E R I N F O R M A T I O N */`
6			`/* */`
7			`/******************************************************************************/`
8
9			`// Project Name : Development Board Debugger Example`
10			`// File Name : main.c`
11			`// Prepared By : jb`
12			`// Project Start : 2009-01-01`
13
14
15			`/$$COPYRIGHT NOTICE/`
16			`/******************************************************************************/`
17			`/* */`
18			`/* C O P Y R I G H T N O T I C E */`
19			`/* */`
20			`/******************************************************************************/`
21
22			`// Copyright (c) ORSoC 2009 All rights reserved.`
23
24			`// The information in this document is the property of ORSoC.`
25			`// Except as specifically authorized in writing by ORSoC, the receiver of`
26			`// this document shall keep the information contained herein confidential and`
27			`// shall protect the same in whole or in part thereof from disclosure and`
28			`// dissemination to third parties. Disclosure and disseminations to the receiver's`
29			`// employees shall only be made on a strict need to know basis.`
30
31
32			`/$$DESCRIPTION/`
33			`/******************************************************************************/`
34			`/* */`
35			`/* D E S C R I P T I O N */`
36			`/* */`
37			`/******************************************************************************/`
38
39			`// Perform some simple functions, used as an example when first using the`
40			`// debug cable and proxy with GDB.`
41
42			`/$$CHANGE HISTORY/`
43			`/******************************************************************************/`
44			`/* */`
45			`/* C H A N G E H I S T O R Y */`
46			`/* */`
47			`/******************************************************************************/`
48
49			`// Date Version Description`
50			`//------------------------------------------------------------------------`
51			`// 090101 1.0 First version jb`
52
53			`/$$INCLUDE FILES/`
54			`/******************************************************************************/`
55			`/* */`
56			`/* I N C L U D E F I L E S */`
57			`/* */`
58			`/******************************************************************************/`
59
60			`#define INCLUDED_FROM_C_FILE`
61
62			`#include "orsocdef.h"`
63			`#include "board.h"`
64			`#include "uart.h"`
65			`#include "main.h"`
66	87	tac2	`#define SD_REG(REG) REG32(SD_CONTROLLER_BASE+REG)`
67	85	tac2	`/$$PRIVATE MACROS/`
68			`/******************************************************************************/`
69			`/* */`
70			`/* P R I V A T E M A C R O S */`
71			`/* */`
72			`/******************************************************************************/`
73
74			`/$$GLOBAL VARIABLES/`
75			`/******************************************************************************/`
76			`/* */`
77			`/* G L O B A L V A R I A B L E S */`
78			`/* */`
79			`/******************************************************************************/`
80
81			`/$$PRIVATE VARIABLES/`
82			`/******************************************************************************/`
83			`/* */`
84			`/* P R I V A T E V A R I A B L E S */`
85			`/* */`
86			`/******************************************************************************/`
87
88
89			`/$$FUNCTIONS/`
90			`/******************************************************************************/`
91			`/* */`
92			`/* F U N C T I O N S */`
93			`/* */`
94			`/******************************************************************************/`
95
96
97			`/******************************************************************************/`
98			`/* W R I T E T O EXTERNAL SDRAM 1 */`
99			`/******************************************************************************/`
100
101			`// Write to External SDRAM`
102			`void Write_External_SDRAM_1(void)`
103			`{`
104			`uint32 i;`
105			`uint32 read;`
106			`uint32 range;`
107			`uint32 adr_offset;`
108
109			`range = 0x7ff; // Max range: 0x7fffff`
110			`adr_offset = 0x00000000; // External memory offset`
111
112			`for (i=0x0; i < range; i=i+4) {`
113			`REG32(adr_offset + i) = (adr_offset + i);`
114			`}`
115
116			`for (i=0x0; i < range; i=i+4) {`
117			`read = REG32(adr_offset + i);`
118			`if (read != (adr_offset + i)) {`
119			`while(TRUE){ //ERROR=HALT PROCESSOR`
120			`}`
121			`}`
122			`}`
123			`}`
124
125
126			`/$$EXTERNAL EXEPTIONS/`
127			`/******************************************************************************/`
128			`/* E X T E R N A L E X E P T I O N S */`
129			`/******************************************************************************/`
130
131
132			`void external_exeption()`
133			`{`
134			`REG uint8 i;`
135			`REG uint32 PicSr,sr;`
136
137			`}`
138
139			`/$$MAIN/`
140			`/******************************************************************************/`
141			`/* */`
142			`/* M A I N P R O G R A M */`
143			`/* */`
144			`/******************************************************************************/`
145
146
147
148
149
150
151	87	tac2	`//TO do`
152			`// Always check if error in repose (CRC, CICE) etc`
153			`// Always check for CICM (Command inhibit before senindg)`
154			`// Timeout when polling`
155			`// Divied into dividing Functions`
156			`// Clean up`
157	85	tac2
158
159			`#define BUSY 0x80`
160			`#define CRC_TOKEN 0x29`
161	87	tac2
162	85	tac2	`//SDC_REGISTERS`
163			`#define TX_CMD_FIFO 0x00`
164			`#define RX_CMD_FIFO 0x04`
165			`#define TX_DATA_FIFO 0x08`
166			`#define RX_DATA_FIFO 0x0C`
167			`#define STATUS 0x10`
168			`#define CONTROLL 0x14`
169			`#define TIMER_REG 0x18`
170
171			`//Program Defines`
172			`#define TRANSMISSION_FAILURE 1`
173			`#define TRANSMISSION_SUCCESSFUL 0`
174			`#define BYTE_1_MASK 0x000000FF`
175			`#define BYTE_2_MASK 0x0000FF00`
176			`#define BYTE_3_MASK 0x00FF0000`
177			`#define BYTE_4_MASK 0xFF000000`
178			`#define MMC_DATA_SIZE 512`
179
180			`BYTE MMCWRData[MMC_DATA_SIZE];`
181			`BYTE MMCRDData[MMC_DATA_SIZE];`
182
183			`unsigned char rca[2];`
184
185			`bool mmc_get_cmd_bigrsp (volatile unsigned char *rsp)`
186			`{`
187			`unsigned char rtn_reg=0;`
188			`unsigned char rtn_reg_timer=0;`
189			`int arr_cnt=0;`
190			`rtn_reg_timer= SD_REG(TIMER_REG);`
191			`while (rtn_reg_timer != 0)`
192			`{`
193			`rtn_reg = SD_REG(STATUS);`
194			`if (( rtn_reg & 0x2) != 0x2) //RX Fifo not Empty`
195			`{`
196			`rsp[arr_cnt]=SD_REG(RX_CMD_FIFO);`
197			`arr_cnt++;`
198
199			`}`
200			`if (arr_cnt==15)`
201			`return 1;`
202			`rtn_reg_timer= SD_REG(TIMER_REG);`
203			`}`
204			`return 0;`
205			`}`
206
207			`/************************ SD mmc_get_cmd_rsp *******************************/`
208			`/*`
209			`* Read CMD_RX_FIFO, add to the rsp array,`
210			`* 1 on success, return 0 at timeout`
211			`*`
212			`*/`
213			`bool mmc_get_cmd_rsp (volatile unsigned char *rsp)`
214			`{`
215			`volatile unsigned char rtn_reg=0;`
216			`volatile unsigned char rtn_reg_timer=0;`
217			`int arr_cnt=0;`
218			`rtn_reg_timer= SD_REG(TIMER_REG);`
219			`while (rtn_reg_timer != 0)`
220			`{`
221			`rtn_reg = SD_REG(STATUS);`
222			`if (( rtn_reg & 0x2) != 0x2) //RX Fifo not Empty`
223			`{`
224			`rsp[arr_cnt]=SD_REG(RX_CMD_FIFO);`
225			`arr_cnt++;`
226
227			`}`
228			`if (arr_cnt==5)`
229			`return 1;`
230			`rtn_reg_timer= SD_REG(TIMER_REG);`
231			`}`
232			`return 0;`
233			`}`
234
235
236
237
238
239	87	tac2
240	85	tac2	`int mmc_init()`
241
242			`{`
243
244			`volatile unsigned char rtn_reg=0;`
245			`volatile unsigned int spv_2_0 =0;`
246			`volatile unsigned char response[15];`
247			`volatile unsigned char out_cmd[5];`
248			`response[0]=0;`
249			`//Reset the hardware`
250			`/* initialise the MMC card into SD-Bus mode, is performed in HW*/`
251			`SD_REG(CONTROLL)=1;`
252			`SD_REG(CONTROLL)=0;`
253
254			`//Reset SD Card. CMD 0, Arg 0.`
255			`//No response, wait for timeout`
256			`SD_REG(TX_CMD_FIFO)=0x40;`
257			`SD_REG(TX_CMD_FIFO)=0x00;`
258			`SD_REG(TX_CMD_FIFO)=0x00;`
259			`SD_REG(TX_CMD_FIFO)=0x00;`
260			`SD_REG(TX_CMD_FIFO)=0x00;`
261
262			`while ( SD_REG(TIMER_REG) != 0){}`
263
264			`//Check for SD 2.0 Card,`
265			`SD_REG(TX_CMD_FIFO)=0x48;`
266			`SD_REG(TX_CMD_FIFO)=0x00;`
267			`SD_REG(TX_CMD_FIFO)=0x00;`
268			`SD_REG(TX_CMD_FIFO)=0x01;`
269			`SD_REG(TX_CMD_FIFO)=0xAA;`
270
271			`//if response, card is v2.0 compatible, else reset card.`
272			`if (mmc_get_cmd_rsp(&response[0]) )`
273			`spv_2_0 = 1;`
274			`else`
275			`{`
276			`SD_REG(CONTROLL)=1;`
277			`SD_REG(CONTROLL)=0;`
278			`SD_REG(TX_CMD_FIFO)=0x40;`
279			`SD_REG(TX_CMD_FIFO)=0x00;`
280			`SD_REG(TX_CMD_FIFO)=0x00;`
281			`SD_REG(TX_CMD_FIFO)=0x00;`
282			`SD_REG(TX_CMD_FIFO)=0x00;`
283
284			`while ( SD_REG(TIMER_REG) != 0){}`
285			`}`
286
287			`if(spv_2_0==0)`
288			`{`
289			`//Send CMD55+ACMD41 until Busy bit is cleared (Response[0][8]==1)`
290			`while ( (rtn_reg & BUSY) != BUSY )`
291			`{ SD_REG(TX_CMD_FIFO)=0x77;`
292			`SD_REG(TX_CMD_FIFO)=0x00;`
293			`SD_REG(TX_CMD_FIFO)=0x00;`
294			`SD_REG(TX_CMD_FIFO)=0x00;`
295			`SD_REG(TX_CMD_FIFO)=0x00;`
296			`if ( mmc_get_cmd_rsp(&response[0]) && response[4]==0)`
297			`{`
298			`SD_REG(TX_CMD_FIFO)=0x69;`
299			`SD_REG(TX_CMD_FIFO)=0x00;`
300			`SD_REG(TX_CMD_FIFO)=0x00;`
301			`SD_REG(TX_CMD_FIFO)=0x00;`
302			`SD_REG(TX_CMD_FIFO)=0x00;`
303			`if (mmc_get_cmd_rsp(&response[0]))`
304			`rtn_reg = response[0];`
305			`else`
306			`return TRANSMISSION_FAILURE;`
307			`}`
308			`else`
309			`return TRANSMISSION_FAILURE;`
310			`}`
311
312			`}`
313			`//else Physical Specification Version 2.00`
314			`//Check response`
315			`//Initialization (ACMD41 HCS=1)`
316			`//Check for High Capacity or Standrd Capacity, Ver.2.00 Card`
317
318			`//CMD 2- get CSD, 136 bit response (Bit-40 this)`
319			`SD_REG(TX_CMD_FIFO)=0xC2;`
320			`SD_REG(TX_CMD_FIFO)=0x00;`
321			`SD_REG(TX_CMD_FIFO)=0x00;`
322			`SD_REG(TX_CMD_FIFO)=0x00;`
323			`SD_REG(TX_CMD_FIFO)=0x00;`
324
325			`if (!mmc_get_cmd_bigrsp(&response[0]))`
326			`return TRANSMISSION_FAILURE;`
327
328			`//CMD 3- get RCA nr`
329			`SD_REG(TX_CMD_FIFO)=0x43;`
330			`SD_REG(TX_CMD_FIFO)=0x00;`
331			`SD_REG(TX_CMD_FIFO)=0x00;`
332			`SD_REG(TX_CMD_FIFO)=0x00;`
333			`SD_REG(TX_CMD_FIFO)=0x00;`
334			`if (mmc_get_cmd_rsp(&response[0]))`
335			`{`
336			`rca[0] = response[0];`
337			`rca[1] = response[1];`
338			`}`
339			`else`
340			`return TRANSMISSION_FAILURE;`
341
342			`//Put card in transfer state, CMD 7`
343			`SD_REG(TX_CMD_FIFO)=0x47;`
344			`SD_REG(TX_CMD_FIFO)= rca[0] ;`
345			`SD_REG(TX_CMD_FIFO)= rca[1] ;`
346			`SD_REG(TX_CMD_FIFO)=0x0f;`
347			`SD_REG(TX_CMD_FIFO)=0x0f;`
348			`if (!mmc_get_cmd_rsp(&response[0]))`
349			`return TRANSMISSION_FAILURE;`
350
351			`//Set block size 512. CMD 16`
352			`SD_REG(TX_CMD_FIFO)=0x50;`
353			`SD_REG(TX_CMD_FIFO)=0;`
354			`SD_REG(TX_CMD_FIFO)=0;`
355			`SD_REG(TX_CMD_FIFO)=0x02;`
356			`SD_REG(TX_CMD_FIFO)=0;`
357			`if (!mmc_get_cmd_rsp(&response[0]))`
358			`return TRANSMISSION_FAILURE;`
359
360			`//Set bus width to 4. CMD 55 + ACMD 6`
361			`SD_REG(TX_CMD_FIFO)=0x77;`
362			`SD_REG(TX_CMD_FIFO)= rca[0] ;`
363			`SD_REG(TX_CMD_FIFO)= rca[1] ;`
364			`SD_REG(TX_CMD_FIFO)=0;`
365			`SD_REG(TX_CMD_FIFO)=0;`
366			`if (!mmc_get_cmd_rsp(&response[0]))`
367			`return TRANSMISSION_FAILURE;`
368			`// ACMD 6`
369			`SD_REG(TX_CMD_FIFO)=0x46;`
370			`SD_REG(TX_CMD_FIFO)=0;`
371			`SD_REG(TX_CMD_FIFO)=0;`
372			`SD_REG(TX_CMD_FIFO)=0;`
373			`SD_REG(TX_CMD_FIFO)=0x02;`
374			`if (!mmc_get_cmd_rsp(&response[0]))`
375			`return TRANSMISSION_FAILURE;`
376
377			`return TRANSMISSION_SUCCESSFUL;`
378			`}`
379
380
381			`int mmc_write_block(uint32 block_number)`
382			`{`
383			`uint32 var;`
384			`volatile unsigned char rtn_reg=0;`
385			`unsigned char response[4];`
386			`int i;`
387
388
389			`var= block_number << 9 ;`
390
391			`for (i=0; i < MMC_DATA_SIZE; i++)`
392			`SD_REG(TX_DATA_FIFO) = MMCWRData[i];`
393
394
395			`//Send CMD24, Single block write`
396			`SD_REG(TX_CMD_FIFO)=0x58;`
397			`SD_REG(TX_CMD_FIFO)=(BYTE)((var >> 24) & 0xFF);`
398			`SD_REG(TX_CMD_FIFO)=(BYTE)((var >> 16) & 0xFF);`
399			`SD_REG(TX_CMD_FIFO)=(BYTE)((var >> 8) & 0xFF);`
400			`SD_REG(TX_CMD_FIFO)=(BYTE)(var & 0xFF);`
401			`if (!mmc_get_cmd_rsp(&response[0]))`
402			`return TRANSMISSION_FAILURE;`
403
404			`//Wait for TX_DATA_FIFO to get empty`
405			`while ( (SD_REG(STATUS)& 0x04) == 0x04) {}`
406			`//Wait for RX_DATA_FIFO to not get empty, indicate transmision is complete and CRC token is avaible.`
407			`while ( (SD_REG(STATUS) & 0x08) == 0x08) {}`
408
409			`//Check for correct CRC repsonse token == 0x29...`
410			`//Busy cehck is performed in HW`
411			`rtn_reg =SD_REG(RX_DATA_FIFO);`
412			`if ((rtn_reg & CRC_TOKEN) == CRC_TOKEN)`
413			`return TRANSMISSION_SUCCESSFUL;`
414			`else`
415			`return TRANSMISSION_FAILURE;`
416			`}`
417
418			`int mmc_read_block(uint32 block_number)`
419			`{`
420			`volatile int i = 0;`
421			`volatile unsigned char response[4];`
422			`volatile unsigned char rsp;`
423			`uint32 var;`
424			`WORD Checksum;`
425
426			`var= block_number << 9;`
427
428			`SD_REG(TX_CMD_FIFO)=0x51;`
429			`SD_REG(TX_CMD_FIFO)=(BYTE)((var >> 24) & 0xFF);`
430			`SD_REG(TX_CMD_FIFO)=(BYTE)((var >> 16) & 0xFF);`
431			`SD_REG(TX_CMD_FIFO)=(BYTE)((var >> 8) & 0xFF);`
432			`SD_REG(TX_CMD_FIFO)=(BYTE)(var & 0xFF);`
433			`if (!mmc_get_cmd_rsp(&response[0]))`
434			`return TRANSMISSION_FAILURE;`
435
436			`rsp = SD_REG(STATUS) & 0x08;`
437			`while ( rsp == 0x08) {`
438			`rsp = SD_REG(STATUS) & 0x08;}`
439			`//Checksum is notread`
440
441			`i=0;`
442
443			`/* while (i<MMC_DATA_SIZE){`
444
445			`MMCRDData[i]=SD_REG(RX_DATA_FIFO);`
446			`i++;`
447			`}`
448			`*/`
449
450			`BYTE *p;`
451			`p=&MMCRDData[0];`
452
453			`register int RX_REG asm ("r0") ;`
454			`register int RSP asm ("r6") ;`
455			`register int LOOP_END asm ("r2") ;`
456			`register int DAT_RSP asm ("r3") ;`
457
458			`register int SAVE_RX_REG asm ("r18") ;`
459			`register int SAVE_RSP asm ("r19") ;`
460			`register int SAVE_LOOP_END asm ("r20") ;`
461			`register int SAVE_DAT_RSP asm ("r21") ;`
462
463			`// asm volatile ("l.mtspr %0,%1, %2" : "=r"(RSP) : "m"(p), "i"(0));`
464			`// 10007f8: 19 80 01 00 l.movhi r12,0x100`
465			`//10007fc: a9 8c 34 10 l.ori r12,r12,0x3410`
466
467			`asm volatile ("l.addi %0,%1, %2" : "=r"(SAVE_RSP ) : "r"(RSP), "i"(0));`
468			`asm volatile ("l.addi %0,%1, %2" : "=r"(SAVE_RX_REG ) : "r"(RX_REG), "i"(0));`
469			`asm volatile ("l.addi %0,%1, %2" : "=r"(SAVE_LOOP_END ) : "r"(LOOP_END), "i"(0));`
470			`asm volatile ("l.addi %0,%1, %2" : "=r"(SAVE_DAT_RSP ) : "r"(DAT_RSP), "i"(0));`
471
472
473			`RSP=&MMCRDData[0];`
474			`// asm volatile ("l.movhi %0,%1" : "=r"(RSP) : "i"(0x100) );`
475			`//asm volatile ("l.ori %0,%1, %2" : "=r"(RSP) : "r"(RSP) , "i"(0x4db0) );`
476
477
478			`asm volatile ("l.movhi %0,%1" : "=r"(RX_REG) : "i"(0xa000) );`
479			`asm volatile ("l.ori %0,%1, %2" : "=r"(RX_REG) : "r"(RX_REG) , "i"(0xc) );`
480
481
482			`asm volatile ("l.addi %0,%1,%2" : "=r"(LOOP_END) : "r"(RSP) , "i"(0x200) );`
483
484			`asm ("label:");`
485			`asm volatile ("l.lwz %0,%1 %2" : "=r"(DAT_RSP) : "i"(0), "r"(RX_REG) );`
486			`asm volatile ("l.sb %0 %1, %2" : : "i"(0), "r"(RSP) , "r"(DAT_RSP) );`
487			`asm volatile ("l.addi %0,%1,%2" : "=r"(RSP) : "r"(RSP), "i"(0x1) );`
488
489			`asm volatile ("l.sfne %0,%1" : "=r"(RSP) :"r"(LOOP_END) );`
490
491			`asm volatile ("l.bf label" );`
492
493			`asm volatile ("l.nop");`
494			`asm volatile ("l.addi %0,%1, %2" : "=r"(RSP) : "r"(SAVE_RSP ), "i"(0));`
495			`asm volatile ("l.addi %0,%1, %2" : "=r"(RX_REG) : "r"(SAVE_RX_REG ), "i"(0));`
496			`asm volatile ("l.addi %0,%1, %2" : "=r"(LOOP_END ) : "r"(SAVE_LOOP_END), "i"(0));`
497			`asm volatile ("l.addi %0,%1, %2" : "=r"(DAT_RSP ) : "r"(SAVE_DAT_RSP), "i"(0));`
498
499
500			`return TRANSMISSION_SUCCESSFUL;`
501			`}`
502			`void Start()`
503			`{`
504			`volatile unsigned char rtn_reg=0;`
505			`volatile unsigned char response[16];`
506			`volatile int a;`
507			`volatile int i;`
508
509			`for (i=0;i<512;i++)`
510			`MMCWRData[i]=0xff;`
511
512			`uart_init();`
513			`a=mmc_init();`
514			`if (a)`
515			`uart_print_str("1");`
516			`else`
517			`uart_print_str("0");`
518
519			`// mmc_write_block(0);`
520			`mmc_read_block(0);`
521			`for (i=0;i<512;i++)`
522			`uart_print_long( MMCRDData[i]);`
523
524			`mmc_read_block(1);`
525			`for (i=0;i<512;i++)`
526			`uart_print_long( MMCRDData[i]);`
527
528
529			`}`