WebSVN - NaviCtrl - Diff - Rev 27 and 41

 // +  POSSIBILITY OF SUCH DAMAGE.
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 #include <stdio.h>
 #include <string.h>
 #include "91x_lib.h"
-#include "uart.h"
+#include "uart1.h"
 #include "sdc.h"
 #include "ssc.h"
 #include "timer.h"
 #include "main.h"
 #include "crc16.h"
+        }
         crc = (crc<<1)|1; // set terminating bit to 1
         return(crc);
+}
-u8 SDC_WaitForBusy()
+u8 SDC_WaitForBusy(u32 timeout)
+{
         u8 rsp = 0;
-        u16 timeout=0;
+        u32 timestamp = 0;
+        SSC_ClearRxFifo();
-        SSC_ClearRxFifo();
+        SSC_Enable();                           // enable chipselect.
-        SSC_Enable();                           // enable chipselect.
+        timestamp = SetDelay(timeout);
         do
         {
                 rsp = SSC_GetChar();
-                if(timeout++>500) break;
+                if(CheckDelay(timestamp)) break;
         }while(rsp != 0xFF);            // wait while card is busy (data out low)
 // Returnvalue: The function returns the first response byte like for R1 commands
 //________________________________________________________________________________________________________________________________________
 u8 SDC_SendCMDR1(u8 CmdNo, u32 arg)
+{
         u8 r1;
-        u16 Timeout = 0;
+        u16 timeout = 0;
         u16 a;
         u8 cmd[6];
         SSC_ClearRxFifo();      // clear the rx fifo
         SSC_Enable();           // enable chipselect.
-        SDC_WaitForBusy();
+        SDC_WaitForBusy(500);   // wait 500ms until card is busy
         SSC_ClearRxFifo();      // clear the rx fifo
-        SSC_GetChar();      // dummy to sync
         SSC_GetChar();      // dummy to sync
         /* Send cmd10 (SEND_CID) */;
         cmd[0] = 0x40|CmdNo; // set command index
         cmd[1] = (arg & 0xFF000000)>>24;
         cmd[2] = (arg & 0x00FF0000)>>16;
         for (a = 0;a < 6; a++) // send the command sequence to the sdcard (6 bytes)
+        {
                 SSC_PutChar(cmd[a]);
+        }
         SSC_ClearRxFifo();      // clear the rx fifo to discard the bytes received during the transmission of the 6 command bytes
         do
+        {
                 r1 = SSC_GetChar();       // get byte from sd-card
-                if (Timeout++ > 500) return(r1);
+                if (timeout++ >500) break;
         }while(r1 == 0xFF); // wait for the response byte from sd-card.
         return(r1);
+}
 //________________________________________________________________________________________________________________________________________
 // Function:    SDC_SendACMDR1(u8 CmdNo, u32 arg);
 //
 // Description: This function send a application command frame to the SD-Card in spi-mode.
 //
 //
 //________________________________________________________________________________________________________________________________________
 SD_Result_t SDC_GetData(u8 CmdNo, u32 addr, u8 *Buffer, u32 len)
+{
-        u8 rsp;
-        u16 timeout;
+        u8 rsp;
-        u16 a, Crc16;
+        u16 a, crc16;
         SD_Result_t result = SD_ERROR_UNKNOWN;
         // send the command
                 if((rsp & 0xF0) == 0x00) // data error token
+                {
                         result = SD_ERROR_READ_DATA;
                         goto end;
+                }
-//              if(timeout++>500) break;
         }while(rsp != DATA_START_TOKEN);
         // data start token received
         for (a = 0; a < len; a++)       // read the block from the SSC
+        {
                 Buffer[a] = SSC_GetChar();
+        }
         // Read two bytes CRC16-Data checksum
-        Crc16 = SSC_GetChar(); // highbyte fisrt
+        crc16 = SSC_GetChar(); // highbyte fisrt
-        Crc16 = (Crc16<<8)|SSC_GetChar(); // lowbyte last
+        crc16 = (crc16<<8)|SSC_GetChar(); // lowbyte last
-//      if(Crc16 != CRC16(Buffer, len)) result = SD_ERROR_CRC_DATA;
+/*      if(crc16 != CRC16(Buffer, len)) result = SD_ERROR_CRC_DATA;
-/*      else */result = SD_SUCCESS;
+        else */result = SD_SUCCESS;
-        end:
-        //SSC_Disable();        // disable sdcard.
+        end:
         if(result != SD_SUCCESS)
+        {
                 sprintf(text,"Error %02X reading data from sd card (R1=%02X).\r\n", result, rsp);
                 SerialPutString(text);
+{
         u8 text[50];
         u8 pn[6];
         u16 temp1, temp2;
-        sprintf(text, "\r\nManufacturer ID: %i\r\n", pCID[0]);
+        sprintf(text, "\r\n Manufacturer ID: %i\r\n", pCID[0]);
         SerialPutString(text);
         memcpy(pn, &pCID[1], 2);
         pn[2] = '\0'; // terminate string
-        sprintf(text, "Application ID: %s\r\n",pn);
+        sprintf(text, " Application ID: %s\r\n",pn);
         SerialPutString(text);
         memcpy(pn, &pCID[3], 5);
         pn[5] = '\0'; // terminate string
-        sprintf(text, "Product Name: %s\r\n",pn);
+        sprintf(text, " Product Name: %s\r\n",pn);
         SerialPutString(text);
-        sprintf(text, "Product Rev.: %i.%i\r\n",pCID[8]>>4, pCID[8]&0xF);
+        sprintf(text, " Product Rev.: %i.%i\r\n",pCID[8]>>4, pCID[8]&0xF);
         SerialPutString(text);
-        SerialPutString("Serial No.: ");
+        SerialPutString(" Serial No.: ");
         for(temp1 = 0; temp1<4; temp1++)
+        {
                 sprintf(text,"%02X", pCID[9+temp1]);
                 SerialPutString(text);
+        }
         SerialPutString("\r\n");
         temp1 = pCID[14] & 0x0F;    // month
         temp2 = ((pCID[14]>>4)|(pCID[13]<<4)) + 2000; // year
-        sprintf(text, "Manufac. Date: %i/%i\r\n\r\n",temp1, temp2);
+        sprintf(text, " Manufac. Date: %i/%i\r\n\r\n",temp1, temp2);
         SerialPutString(text);
+}
 // Returnvalue: the function returns 0 if the initialisation was successfull otherwise the function returns an errorcode.
 //________________________________________________________________________________________________________________________________________
 SD_Result_t SDC_Init(void)
 {
-        u32 Timeout = 0;
+        u32 timeout = 0;
         u8 text[50];
         u8 rsp[6]; // SD-SPI response buffer
         SD_Result_t result = SD_ERROR_UNKNOWN;
         if(SD_SWITCH) // init only if the SD-Switch is indicating a card in the slot
+        {
-                SerialPutString("\r\n  SSC init...");
+                SerialPutString("\r\n SSC init...");
                 SSC_Init();
                 SerialPutString("ok");
-                SerialPutString("\r\n  SDC init...");
+                SerialPutString("\r\n SDC init...");
                 SDCardInfo.Valid = 0;
                 /* The host shall supply power to the card so that the voltage is reached to Vdd_min within 250ms and
                 start to supply at least 74 SD clocks to the SD card with keeping cmd line to high. In case of SPI
                 mode, CS shall be held to high during 74 clock cycles. */
                 SSC_Disable(); // set SD_CS high
                 SSC_ClearRxFifo();      // clear the rx fifo
-                for (Timeout = 0; Timeout < 15; Timeout++)      // 15*8 = 120 cycles
+                for (timeout = 0; timeout < 15; timeout++)      // 15*8 = 120 cycles
+                {
                         SSC_PutChar(0xFF);
+                }
                 // switch to idle state
                 while(SDC_SendCMDR1(CMD_GO_IDLE_STATE, 0UL) != R1_IDLE_STATE)
+                {
-                        if (Timeout++ > 20)
+                        if (timeout++ > 20)
+                        {
                                 SerialPutString("reset timeout");
                                 result = SD_ERROR_RESET;
                                 goto end;
+                        }
                 }
             // enable crc feature
 /*              if(SDC_SendCMDR1(CMD_CRC_ON_OFF, 1UL) != R1_IDLE_STATE)
+                {
-                                sprintf(text,"Bad cmd59 R1=%02X.\r\n", rsp[0]);
+                                sprintf(text,"Bad cmd59 R1=%02X.", rsp[0]);
                                 SerialPutString(text);
                                 result = SD_ERROR_BAD_RESPONSE;
                                 goto end;
                 }*/
                 // check for card hw version
                 // 2.7-3.6V Range = 0x01, check pattern 0xAA
                 rsp[0] = SDC_SendCMDR1(CMD_SEND_IF_COND, 0x000001AA);
                 // answer to cmd58 is an R7 response (R1+ 4Byte IFCond)
                 if(rsp[0] & R1_BAD_RESPONSE)
+                {
-                        sprintf(text,"Bad cmd8 R1=%02X.\r\n", rsp[0]);
+                        sprintf(text,"Bad cmd8 R1=%02X.", rsp[0]);
                         SerialPutString(text);
                 else
+                {
                    // Ver2.00 or later SD Memory Card
                    // reading the remaining bytes of the R7 response
                    SDCardInfo.Version = VER_20;
-                   for(Timeout = 1; Timeout < 5; Timeout++)
+                   for(timeout = 1; timeout < 5; timeout++)
+                   {
-                                rsp[Timeout] = SSC_GetChar();
+                                rsp[timeout] = SSC_GetChar();
+                   }
                    //check pattern
                    if(rsp[4]!= 0xAA)
+                   {
                                 SerialPutString("Bad cmd8 R7 check pattern.\r\n");
                 rsp[0] = SDC_SendCMDR1(CMD_READ_OCR, 0UL);
                 // answer to cmd58 is an R3 response (R1 + 4Byte OCR)
                 if(rsp[0] & R1_BAD_RESPONSE)
                 {
-                        sprintf(text,"Bad cmd58 R1 %02x.\r\n", rsp[0]);
+                        sprintf(text,"Bad cmd58 R1 %02x.", rsp[0]);
                         SerialPutString(text);
                         result = SD_ERROR_BAD_RESPONSE;
                         goto end;
+                }
                 if(rsp[0] & R1_ILLEGAL_CMD)
                 {
-                        SerialPutString("Not an SD-CARD.\r\n");
+                        SerialPutString("Not an SD-CARD.");
                         result = SD_ERROR_NO_SDCARD;
                         goto end;
+                }
                 // read 4 bytes of OCR register
-                for(Timeout = 1; Timeout < 5; Timeout++)
+                for(timeout = 1; timeout < 5; timeout++)
                 {
-                        rsp[Timeout] = SSC_GetChar();
+                        rsp[timeout] = SSC_GetChar();
+                }
                 //      NavicCtrl uses 3.3 V,  therefore check for bit 20 & 21
                 if((rsp[2] & 0x30) != 0x30)
+                {
                         // supply voltage is not supported by sd-card
-                        SerialPutString("Card is incompatible to 3.3V.\r\n");
+                        SerialPutString("Card is incompatible to 3.3V.");
                         result = SD_ERROR_BAD_VOLTAGE_RANGE;
                         goto end;
+                }
                 // Initialize the sd-card sending continously ACMD_SEND_OP_COND (only supported by SD cards)
-                Timeout =  SetDelay(2000); // set timeout to 2000 ms (large cards tend to longer)
+                timeout =  SetDelay(2000); // set timeout to 2000 ms (large cards tend to longer)
                 do
+                {
                         rsp[0] = SDC_SendACMDR1(ACMD_SEND_OP_COND, 0UL);
                         if(rsp[0] & R1_BAD_RESPONSE)
+                        {
-                                sprintf(text,"Bad Acmd41 R1=%02X.\r\n", rsp[0]);
+                                sprintf(text,"Bad Acmd41 R1=%02X.", rsp[0]);
                                 SerialPutString(text);
                                 result = SD_ERROR_BAD_RESPONSE;
                                 goto end;
+                        }
-                        if(CheckDelay(Timeout))
+                        if(CheckDelay(timeout))
+                        {
-                            SerialPutString("Init timeout.\r\n");
+                            SerialPutString("Init timeout.");
                                 result = SD_ERROR_INITIALIZE;
                                 goto end;
+                        }
                 } while(rsp[0] & R1_IDLE_STATE); // loop until idle state
                 if(rsp[0] != R1_NO_ERR)
+                {
-                        SerialPutString("Init error.\r\n");
+                        SerialPutString("Init error.");
                         result = SD_ERROR_INITIALIZE;
                         goto end;
+                }
                 /* set block size to 512 bytes */
         if(SDC_SendCMDR1(CMD_SET_BLOCKLEN, 512UL) != R1_NO_ERR)
+        {
-                SerialPutString("Error setting block length to 512.\r\n");
+                SerialPutString("Error setting block length to 512.");
-                        result = SD_ERROR_SET_BLOCKLEN;
-                        goto end;
+                        result = SD_ERROR_SET_BLOCKLEN;
-        }
+                        goto end;
+        }
                 //SSC_Disable(); // set SD_CS high
                 // here is the right place to inrease the SPI boud rate to maximum
                 // read CSD register
                 result = SDC_GetCSD((u8 *)&SDCardInfo.CSD);
                 if(result != SD_SUCCESS)
                 {
-                        SerialPutString("Error reading CSD.\r\n");
+                        SerialPutString("Error reading CSD.");
                         goto end;
+                }
                         c_size = ((u32)(SDCardInfo.CSD[7] & 0x3F))<<16; //CSD[07] -> [71:64]
                         c_size |= ((u32)SDCardInfo.CSD[8])<<8;                  //CSD[08] -> [63:56]
                         c_size |= (u32)SDCardInfo.CSD[9];                               //CSD[09] -> [55:48];
                         SDCardInfo.Capacity = (c_size + 1)* 512L * 1024L;
+                        break;
-                        break;
-                 default: //unknown CSD Version
+                default: //unknown CSD Version
                         SDCardInfo.Capacity = 0;
                         break;
+                }
+                }
                 u16 mb_size = (u16)(SDCardInfo.Capacity/(1024L*1024L));
                 sprintf(text, "\r\n  Capacity = %i MB", mb_size);
                 SerialPutString(text);
-//              SDC_PrintCID((u8 *)&SDCardInfo.CID);
+                SDC_PrintCID((u8 *)&SDCardInfo.CID);
-                SDCardInfo.Valid = 1;
                 SDCardInfo.Valid = 1;
                 // jump point for error condition before
                 end:
                 SSC_Disable();
+        }
         else
-        {
                 //SerialPutString("\r\nNo Card in Slot.");
                 SSC_Deinit();
                 SDCardInfo.Valid = 0;
+                result = SD_ERROR_NOCARD;
-                result = SD_ERROR_NOCARD;
+                SerialPutString("No Card in Slot.");
-        }
-//      if(result != SD_SUCCESS)                SerialPutString("nok ");
+        }
         return(result);
+}
 // Returnvalue: the function returns 0 if the initialisation was successfull otherwise the function returns an errorcode.
 //________________________________________________________________________________________________________________________________________
 SD_Result_t SDC_Deinit(void)
 {
-        SerialPutString("SDC deinit...");
+        SerialPutString("\r\n SDC deinit...");
         SSC_Deinit();
         SDCardInfo.Valid = 0;
         SDCardInfo.Capacity = 0;
         SDCardInfo.Version = VER_UNKNOWN;
-        SerialPutString("ok\r\n");
+        SerialPutString("ok");
 //________________________________________________________________________________________________________________________________________
 SD_Result_t SDC_PutSector(u32 addr, const u8 *Buffer)
+{
+        u8 rsp;
-        u8 rsp;
+        u16 a, crc16;
-        u16 timeout = 0;
-        u16 a, Crc16;
-        //u32 Timeout = 0;
+        u16 timeout = 0;
         SD_Result_t result = SD_ERROR_UNKNOWN;
         addr = addr << 9; // convert sectoradress to byteadress
         SSC_ClearRxFifo();
         for (a=0;a<20;a++)                                      // at least one byte
+        {
                 SSC_GetChar();
+        }
-        Crc16 = CRC16(Buffer, 512);         // calc checksum for data block
+        crc16 = CRC16(Buffer, 512);         // calc checksum for data block
         SSC_PutChar(DATA_START_TOKEN);          // send data start of header to the SSC
         for (a=0;a<512;a++)                                     // transmit one sector (normaly 512bytes) of data to the sdcard.
+        {
                 SSC_PutChar(Buffer[a]);
+        }
         // write two bytes of crc16 to the sdcard
-        SSC_PutChar((u8)(Crc16>>8));            // write high byte first
+        SSC_PutChar((u8)(crc16>>8));            // write high byte first
-        SSC_PutChar((u8)(0x00FF&Crc16));        // lowbyte last
+        SSC_PutChar((u8)(0x00FF&crc16));        // lowbyte last
         SSC_ClearRxFifo();
         do                                                                      // wait for data response token
+        {
                 rsp = SSC_GetChar();
+                if(timeout++ > 500)
+                {
+                        result = SD_ERROR_TIMEOUT;
+                        goto end;
                 if(timeout++>500) break;
         }while((rsp & 0x11) != 0x01 );
         // analyse data response token
         switch(rsp & DATA_RESPONSE_MASK)
+        {
                         result = SD_ERROR_UNKNOWN;
                         goto end;
                         break;
         }
-        // wait until the sdcard is busy.
+        // wait 2 seconds until the sdcard is busy.
-        rsp = SDC_WaitForBusy();
+        rsp = SDC_WaitForBusy(2000);
         if(rsp != 0xFF)
         {
                 result =  SD_ERROR_TIMEOUT;
                 goto end;
+        }
         // check card status
+        rsp = SDC_SendCMDR1(CMD_SEND_STATUS, 0);
-        rsp = SDC_SendCMDR1(CMD_SEND_STATUS, 0);
+        // first byte of R2 response is like R1 response
         if(rsp != R1_NO_ERR)
+        {
                 result =  SD_ERROR_BAD_RESPONSE;
-                SSC_GetChar();
+                SSC_GetChar(); // read out 2nd byte
                 goto end;
+        }
         // 2nd byte of r2 response
         rsp = SSC_GetChar();
                 result =  SD_ERROR_WRITE_DATA;
                 SSC_GetChar();
                 goto end;
+        }
         end:
-        //SSC_Disable();                                                // disable sdcard.
         if(result != SD_SUCCESS)
+        {
                 sprintf(text,"Error %02X writing data to sd card (R=%02X).\r\n", result, rsp);
                 SerialPutString(text);
+        }
         return(result);
 }
 //________________________________________________________________________________________________________________________________________

Subversion Repositories NaviCtrl

(root)/tags/V0.14a/sdc.c @ 313 - Rev 27 → 41