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 86

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"
 
/*$$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                              */
/*                                                                            */
/******************************************************************************/
 
 
 
 
 
 
 
 
//SDC_DEFINES
#define BUSY 0x80
#define CRC_TOKEN 0x29
#define SD_REG(REG)  REG32(SD_CONTROLLER_BASE+REG) 
//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;
}
 
 
 
bool cmd_trans_succesful (volatile unsigned char resp)
{
  if ( (resp & 0x1) != 1 )
          return 1;
  else
          return 0;
 
}
void write_0(int i)
{
    while( i !=0){
     SD_REG(TX_CMD_FIFO)=0;
         i--;
}
 
}
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 86

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	86	tac2
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
152
153	86	tac2	`//SDC_DEFINES`
154	85	tac2	`#define BUSY 0x80`
155			`#define CRC_TOKEN 0x29`
156	86	tac2	`#define SD_REG(REG) REG32(SD_CONTROLLER_BASE+REG)`
157	85	tac2	`//SDC_REGISTERS`
158			`#define TX_CMD_FIFO 0x00`
159			`#define RX_CMD_FIFO 0x04`
160			`#define TX_DATA_FIFO 0x08`
161			`#define RX_DATA_FIFO 0x0C`
162			`#define STATUS 0x10`
163			`#define CONTROLL 0x14`
164			`#define TIMER_REG 0x18`
165
166			`//Program Defines`
167			`#define TRANSMISSION_FAILURE 1`
168			`#define TRANSMISSION_SUCCESSFUL 0`
169			`#define BYTE_1_MASK 0x000000FF`
170			`#define BYTE_2_MASK 0x0000FF00`
171			`#define BYTE_3_MASK 0x00FF0000`
172			`#define BYTE_4_MASK 0xFF000000`
173			`#define MMC_DATA_SIZE 512`
174
175			`BYTE MMCWRData[MMC_DATA_SIZE];`
176			`BYTE MMCRDData[MMC_DATA_SIZE];`
177
178			`unsigned char rca[2];`
179
180			`bool mmc_get_cmd_bigrsp (volatile unsigned char *rsp)`
181			`{`
182			`unsigned char rtn_reg=0;`
183			`unsigned char rtn_reg_timer=0;`
184			`int arr_cnt=0;`
185			`rtn_reg_timer= SD_REG(TIMER_REG);`
186			`while (rtn_reg_timer != 0)`
187			`{`
188			`rtn_reg = SD_REG(STATUS);`
189			`if (( rtn_reg & 0x2) != 0x2) //RX Fifo not Empty`
190			`{`
191			`rsp[arr_cnt]=SD_REG(RX_CMD_FIFO);`
192			`arr_cnt++;`
193
194			`}`
195			`if (arr_cnt==15)`
196			`return 1;`
197			`rtn_reg_timer= SD_REG(TIMER_REG);`
198			`}`
199			`return 0;`
200			`}`
201
202			`/************************ SD mmc_get_cmd_rsp *******************************/`
203			`/*`
204			`* Read CMD_RX_FIFO, add to the rsp array,`
205			`* 1 on success, return 0 at timeout`
206			`*`
207			`*/`
208			`bool mmc_get_cmd_rsp (volatile unsigned char *rsp)`
209			`{`
210			`volatile unsigned char rtn_reg=0;`
211			`volatile unsigned char rtn_reg_timer=0;`
212			`int arr_cnt=0;`
213			`rtn_reg_timer= SD_REG(TIMER_REG);`
214			`while (rtn_reg_timer != 0)`
215			`{`
216			`rtn_reg = SD_REG(STATUS);`
217			`if (( rtn_reg & 0x2) != 0x2) //RX Fifo not Empty`
218			`{`
219			`rsp[arr_cnt]=SD_REG(RX_CMD_FIFO);`
220			`arr_cnt++;`
221
222			`}`
223			`if (arr_cnt==5)`
224			`return 1;`
225			`rtn_reg_timer= SD_REG(TIMER_REG);`
226			`}`
227			`return 0;`
228			`}`
229
230
231
232			`bool cmd_trans_succesful (volatile unsigned char resp)`
233			`{`
234			`if ( (resp & 0x1) != 1 )`
235			`return 1;`
236			`else`
237			`return 0;`
238
239			`}`
240			`void write_0(int i)`
241			`{`
242			`while( i !=0){`
243			`SD_REG(TX_CMD_FIFO)=0;`
244			`i--;`
245			`}`
246
247			`}`
248			`int mmc_init()`
249
250			`{`
251
252			`volatile unsigned char rtn_reg=0;`
253			`volatile unsigned int spv_2_0 =0;`
254			`volatile unsigned char response[15];`
255			`volatile unsigned char out_cmd[5];`
256			`response[0]=0;`
257			`//Reset the hardware`
258			`/* initialise the MMC card into SD-Bus mode, is performed in HW*/`
259			`SD_REG(CONTROLL)=1;`
260			`SD_REG(CONTROLL)=0;`
261
262			`//Reset SD Card. CMD 0, Arg 0.`
263			`//No response, wait for timeout`
264			`SD_REG(TX_CMD_FIFO)=0x40;`
265			`SD_REG(TX_CMD_FIFO)=0x00;`
266			`SD_REG(TX_CMD_FIFO)=0x00;`
267			`SD_REG(TX_CMD_FIFO)=0x00;`
268			`SD_REG(TX_CMD_FIFO)=0x00;`
269
270			`while ( SD_REG(TIMER_REG) != 0){}`
271
272			`//Check for SD 2.0 Card,`
273			`SD_REG(TX_CMD_FIFO)=0x48;`
274			`SD_REG(TX_CMD_FIFO)=0x00;`
275			`SD_REG(TX_CMD_FIFO)=0x00;`
276			`SD_REG(TX_CMD_FIFO)=0x01;`
277			`SD_REG(TX_CMD_FIFO)=0xAA;`
278
279			`//if response, card is v2.0 compatible, else reset card.`
280			`if (mmc_get_cmd_rsp(&response[0]) )`
281			`spv_2_0 = 1;`
282			`else`
283			`{`
284			`SD_REG(CONTROLL)=1;`
285			`SD_REG(CONTROLL)=0;`
286			`SD_REG(TX_CMD_FIFO)=0x40;`
287			`SD_REG(TX_CMD_FIFO)=0x00;`
288			`SD_REG(TX_CMD_FIFO)=0x00;`
289			`SD_REG(TX_CMD_FIFO)=0x00;`
290			`SD_REG(TX_CMD_FIFO)=0x00;`
291
292			`while ( SD_REG(TIMER_REG) != 0){}`
293			`}`
294
295			`if(spv_2_0==0)`
296			`{`
297			`//Send CMD55+ACMD41 until Busy bit is cleared (Response[0][8]==1)`
298			`while ( (rtn_reg & BUSY) != BUSY )`
299			`{ SD_REG(TX_CMD_FIFO)=0x77;`
300			`SD_REG(TX_CMD_FIFO)=0x00;`
301			`SD_REG(TX_CMD_FIFO)=0x00;`
302			`SD_REG(TX_CMD_FIFO)=0x00;`
303			`SD_REG(TX_CMD_FIFO)=0x00;`
304			`if ( mmc_get_cmd_rsp(&response[0]) && response[4]==0)`
305			`{`
306			`SD_REG(TX_CMD_FIFO)=0x69;`
307			`SD_REG(TX_CMD_FIFO)=0x00;`
308			`SD_REG(TX_CMD_FIFO)=0x00;`
309			`SD_REG(TX_CMD_FIFO)=0x00;`
310			`SD_REG(TX_CMD_FIFO)=0x00;`
311			`if (mmc_get_cmd_rsp(&response[0]))`
312			`rtn_reg = response[0];`
313			`else`
314			`return TRANSMISSION_FAILURE;`
315			`}`
316			`else`
317			`return TRANSMISSION_FAILURE;`
318			`}`
319
320			`}`
321			`//else Physical Specification Version 2.00`
322			`//Check response`
323			`//Initialization (ACMD41 HCS=1)`
324			`//Check for High Capacity or Standrd Capacity, Ver.2.00 Card`
325
326			`//CMD 2- get CSD, 136 bit response (Bit-40 this)`
327			`SD_REG(TX_CMD_FIFO)=0xC2;`
328			`SD_REG(TX_CMD_FIFO)=0x00;`
329			`SD_REG(TX_CMD_FIFO)=0x00;`
330			`SD_REG(TX_CMD_FIFO)=0x00;`
331			`SD_REG(TX_CMD_FIFO)=0x00;`
332
333			`if (!mmc_get_cmd_bigrsp(&response[0]))`
334			`return TRANSMISSION_FAILURE;`
335
336			`//CMD 3- get RCA nr`
337			`SD_REG(TX_CMD_FIFO)=0x43;`
338			`SD_REG(TX_CMD_FIFO)=0x00;`
339			`SD_REG(TX_CMD_FIFO)=0x00;`
340			`SD_REG(TX_CMD_FIFO)=0x00;`
341			`SD_REG(TX_CMD_FIFO)=0x00;`
342			`if (mmc_get_cmd_rsp(&response[0]))`
343			`{`
344			`rca[0] = response[0];`
345			`rca[1] = response[1];`
346			`}`
347			`else`
348			`return TRANSMISSION_FAILURE;`
349
350			`//Put card in transfer state, CMD 7`
351			`SD_REG(TX_CMD_FIFO)=0x47;`
352			`SD_REG(TX_CMD_FIFO)= rca[0] ;`
353			`SD_REG(TX_CMD_FIFO)= rca[1] ;`
354			`SD_REG(TX_CMD_FIFO)=0x0f;`
355			`SD_REG(TX_CMD_FIFO)=0x0f;`
356			`if (!mmc_get_cmd_rsp(&response[0]))`
357			`return TRANSMISSION_FAILURE;`
358
359			`//Set block size 512. CMD 16`
360			`SD_REG(TX_CMD_FIFO)=0x50;`
361			`SD_REG(TX_CMD_FIFO)=0;`
362			`SD_REG(TX_CMD_FIFO)=0;`
363			`SD_REG(TX_CMD_FIFO)=0x02;`
364			`SD_REG(TX_CMD_FIFO)=0;`
365			`if (!mmc_get_cmd_rsp(&response[0]))`
366			`return TRANSMISSION_FAILURE;`
367
368			`//Set bus width to 4. CMD 55 + ACMD 6`
369			`SD_REG(TX_CMD_FIFO)=0x77;`
370			`SD_REG(TX_CMD_FIFO)= rca[0] ;`
371			`SD_REG(TX_CMD_FIFO)= rca[1] ;`
372			`SD_REG(TX_CMD_FIFO)=0;`
373			`SD_REG(TX_CMD_FIFO)=0;`
374			`if (!mmc_get_cmd_rsp(&response[0]))`
375			`return TRANSMISSION_FAILURE;`
376			`// ACMD 6`
377			`SD_REG(TX_CMD_FIFO)=0x46;`
378			`SD_REG(TX_CMD_FIFO)=0;`
379			`SD_REG(TX_CMD_FIFO)=0;`
380			`SD_REG(TX_CMD_FIFO)=0;`
381			`SD_REG(TX_CMD_FIFO)=0x02;`
382			`if (!mmc_get_cmd_rsp(&response[0]))`
383			`return TRANSMISSION_FAILURE;`
384
385			`return TRANSMISSION_SUCCESSFUL;`
386			`}`
387
388
389			`int mmc_write_block(uint32 block_number)`
390			`{`
391			`uint32 var;`
392			`volatile unsigned char rtn_reg=0;`
393			`unsigned char response[4];`
394			`int i;`
395
396
397			`var= block_number << 9 ;`
398
399			`for (i=0; i < MMC_DATA_SIZE; i++)`
400			`SD_REG(TX_DATA_FIFO) = MMCWRData[i];`
401
402
403			`//Send CMD24, Single block write`
404			`SD_REG(TX_CMD_FIFO)=0x58;`
405			`SD_REG(TX_CMD_FIFO)=(BYTE)((var >> 24) & 0xFF);`
406			`SD_REG(TX_CMD_FIFO)=(BYTE)((var >> 16) & 0xFF);`
407			`SD_REG(TX_CMD_FIFO)=(BYTE)((var >> 8) & 0xFF);`
408			`SD_REG(TX_CMD_FIFO)=(BYTE)(var & 0xFF);`
409			`if (!mmc_get_cmd_rsp(&response[0]))`
410			`return TRANSMISSION_FAILURE;`
411
412			`//Wait for TX_DATA_FIFO to get empty`
413			`while ( (SD_REG(STATUS)& 0x04) == 0x04) {}`
414			`//Wait for RX_DATA_FIFO to not get empty, indicate transmision is complete and CRC token is avaible.`
415			`while ( (SD_REG(STATUS) & 0x08) == 0x08) {}`
416
417			`//Check for correct CRC repsonse token == 0x29...`
418			`//Busy cehck is performed in HW`
419			`rtn_reg =SD_REG(RX_DATA_FIFO);`
420			`if ((rtn_reg & CRC_TOKEN) == CRC_TOKEN)`
421			`return TRANSMISSION_SUCCESSFUL;`
422			`else`
423			`return TRANSMISSION_FAILURE;`
424			`}`
425
426			`int mmc_read_block(uint32 block_number)`
427			`{`
428			`volatile int i = 0;`
429			`volatile unsigned char response[4];`
430			`volatile unsigned char rsp;`
431			`uint32 var;`
432			`WORD Checksum;`
433
434			`var= block_number << 9;`
435
436			`SD_REG(TX_CMD_FIFO)=0x51;`
437			`SD_REG(TX_CMD_FIFO)=(BYTE)((var >> 24) & 0xFF);`
438			`SD_REG(TX_CMD_FIFO)=(BYTE)((var >> 16) & 0xFF);`
439			`SD_REG(TX_CMD_FIFO)=(BYTE)((var >> 8) & 0xFF);`
440			`SD_REG(TX_CMD_FIFO)=(BYTE)(var & 0xFF);`
441			`if (!mmc_get_cmd_rsp(&response[0]))`
442			`return TRANSMISSION_FAILURE;`
443
444			`rsp = SD_REG(STATUS) & 0x08;`
445			`while ( rsp == 0x08) {`
446			`rsp = SD_REG(STATUS) & 0x08;}`
447			`//Checksum is notread`
448
449			`i=0;`
450
451			`/* while (i<MMC_DATA_SIZE){`
452
453			`MMCRDData[i]=SD_REG(RX_DATA_FIFO);`
454			`i++;`
455			`}`
456			`*/`
457
458			`BYTE *p;`
459			`p=&MMCRDData[0];`
460
461			`register int RX_REG asm ("r0") ;`
462			`register int RSP asm ("r6") ;`
463			`register int LOOP_END asm ("r2") ;`
464			`register int DAT_RSP asm ("r3") ;`
465
466			`register int SAVE_RX_REG asm ("r18") ;`
467			`register int SAVE_RSP asm ("r19") ;`
468			`register int SAVE_LOOP_END asm ("r20") ;`
469			`register int SAVE_DAT_RSP asm ("r21") ;`
470
471			`// asm volatile ("l.mtspr %0,%1, %2" : "=r"(RSP) : "m"(p), "i"(0));`
472			`// 10007f8: 19 80 01 00 l.movhi r12,0x100`
473			`//10007fc: a9 8c 34 10 l.ori r12,r12,0x3410`
474
475			`asm volatile ("l.addi %0,%1, %2" : "=r"(SAVE_RSP ) : "r"(RSP), "i"(0));`
476			`asm volatile ("l.addi %0,%1, %2" : "=r"(SAVE_RX_REG ) : "r"(RX_REG), "i"(0));`
477			`asm volatile ("l.addi %0,%1, %2" : "=r"(SAVE_LOOP_END ) : "r"(LOOP_END), "i"(0));`
478			`asm volatile ("l.addi %0,%1, %2" : "=r"(SAVE_DAT_RSP ) : "r"(DAT_RSP), "i"(0));`
479
480
481			`RSP=&MMCRDData[0];`
482			`// asm volatile ("l.movhi %0,%1" : "=r"(RSP) : "i"(0x100) );`
483			`//asm volatile ("l.ori %0,%1, %2" : "=r"(RSP) : "r"(RSP) , "i"(0x4db0) );`
484
485
486			`asm volatile ("l.movhi %0,%1" : "=r"(RX_REG) : "i"(0xa000) );`
487			`asm volatile ("l.ori %0,%1, %2" : "=r"(RX_REG) : "r"(RX_REG) , "i"(0xc) );`
488
489
490			`asm volatile ("l.addi %0,%1,%2" : "=r"(LOOP_END) : "r"(RSP) , "i"(0x200) );`
491
492			`asm ("label:");`
493			`asm volatile ("l.lwz %0,%1 %2" : "=r"(DAT_RSP) : "i"(0), "r"(RX_REG) );`
494			`asm volatile ("l.sb %0 %1, %2" : : "i"(0), "r"(RSP) , "r"(DAT_RSP) );`
495			`asm volatile ("l.addi %0,%1,%2" : "=r"(RSP) : "r"(RSP), "i"(0x1) );`
496
497			`asm volatile ("l.sfne %0,%1" : "=r"(RSP) :"r"(LOOP_END) );`
498
499			`asm volatile ("l.bf label" );`
500
501			`asm volatile ("l.nop");`
502			`asm volatile ("l.addi %0,%1, %2" : "=r"(RSP) : "r"(SAVE_RSP ), "i"(0));`
503			`asm volatile ("l.addi %0,%1, %2" : "=r"(RX_REG) : "r"(SAVE_RX_REG ), "i"(0));`
504			`asm volatile ("l.addi %0,%1, %2" : "=r"(LOOP_END ) : "r"(SAVE_LOOP_END), "i"(0));`
505			`asm volatile ("l.addi %0,%1, %2" : "=r"(DAT_RSP ) : "r"(SAVE_DAT_RSP), "i"(0));`
506
507
508			`return TRANSMISSION_SUCCESSFUL;`
509			`}`
510			`void Start()`
511			`{`
512			`volatile unsigned char rtn_reg=0;`
513			`volatile unsigned char response[16];`
514			`volatile int a;`
515			`volatile int i;`
516
517			`for (i=0;i<512;i++)`
518			`MMCWRData[i]=0xff;`
519
520			`uart_init();`
521			`a=mmc_init();`
522			`if (a)`
523			`uart_print_str("1");`
524			`else`
525			`uart_print_str("0");`
526
527			`// mmc_write_block(0);`
528			`mmc_read_block(0);`
529			`for (i=0;i<512;i++)`
530			`uart_print_long( MMCRDData[i]);`
531
532			`mmc_read_block(1);`
533			`for (i=0;i<512;i++)`
534			`uart_print_long( MMCRDData[i]);`
535
536
537			`}`