Subversion Repositories NaviCtrl

Rev

Rev 27 | Rev 92 | Go to most recent revision | Only display areas with differences | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 27 Rev 41
1
/*#######################################################################################*/
1
/*#######################################################################################*/
2
/* !!! THIS IS NOT FREE SOFTWARE !!!                                                     */
2
/* !!! THIS IS NOT FREE SOFTWARE !!!                                                     */
3
/*#######################################################################################*/
3
/*#######################################################################################*/
4
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
4
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
5
// + Copyright (c) 2008 Ingo Busker, Holger Buss
5
// + Copyright (c) 2008 Ingo Busker, Holger Buss
6
// + Nur für den privaten Gebrauch
6
// + Nur für den privaten Gebrauch
7
// + FOR NON COMMERCIAL USE ONLY
7
// + FOR NON COMMERCIAL USE ONLY
8
// + www.MikroKopter.com
8
// + www.MikroKopter.com
9
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
9
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10
// + Es gilt für das gesamte Projekt (Hardware, Software, Binärfiles, Sourcecode und Dokumentation), 
10
// + Es gilt für das gesamte Projekt (Hardware, Software, Binärfiles, Sourcecode und Dokumentation), 
11
// + dass eine Nutzung (auch auszugsweise) nur für den privaten (nicht-kommerziellen) Gebrauch zulässig ist. 
11
// + dass eine Nutzung (auch auszugsweise) nur für den privaten (nicht-kommerziellen) Gebrauch zulässig ist. 
12
// + Sollten direkte oder indirekte kommerzielle Absichten verfolgt werden, ist mit uns (info@mikrokopter.de) Kontakt 
12
// + Sollten direkte oder indirekte kommerzielle Absichten verfolgt werden, ist mit uns (info@mikrokopter.de) Kontakt 
13
// + bzgl. der Nutzungsbedingungen aufzunehmen. 
13
// + bzgl. der Nutzungsbedingungen aufzunehmen. 
14
// + Eine kommerzielle Nutzung ist z.B.Verkauf von MikroKoptern, Bestückung und Verkauf von Platinen oder Bausätzen,
14
// + Eine kommerzielle Nutzung ist z.B.Verkauf von MikroKoptern, Bestückung und Verkauf von Platinen oder Bausätzen,
15
// + Verkauf von Luftbildaufnahmen, usw.
15
// + Verkauf von Luftbildaufnahmen, usw.
16
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
16
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
17
// + Werden Teile des Quellcodes (mit oder ohne Modifikation) weiterverwendet oder veröffentlicht, 
17
// + Werden Teile des Quellcodes (mit oder ohne Modifikation) weiterverwendet oder veröffentlicht, 
18
// + unterliegen sie auch diesen Nutzungsbedingungen und diese Nutzungsbedingungen incl. Copyright müssen dann beiliegen
18
// + unterliegen sie auch diesen Nutzungsbedingungen und diese Nutzungsbedingungen incl. Copyright müssen dann beiliegen
19
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
19
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
20
// + Sollte die Software (auch auszugesweise) oder sonstige Informationen des MikroKopter-Projekts
20
// + Sollte die Software (auch auszugesweise) oder sonstige Informationen des MikroKopter-Projekts
21
// + auf anderen Webseiten oder sonstigen Medien veröffentlicht werden, muss unsere Webseite "http://www.mikrokopter.de"
21
// + auf anderen Webseiten oder sonstigen Medien veröffentlicht werden, muss unsere Webseite "http://www.mikrokopter.de"
22
// + eindeutig als Ursprung verlinkt werden
22
// + eindeutig als Ursprung verlinkt werden
23
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
23
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
24
// + Keine Gewähr auf Fehlerfreiheit, Vollständigkeit oder Funktion
24
// + Keine Gewähr auf Fehlerfreiheit, Vollständigkeit oder Funktion
25
// + Benutzung auf eigene Gefahr
25
// + Benutzung auf eigene Gefahr
26
// + Wir übernehmen keinerlei Haftung für direkte oder indirekte Personen- oder Sachschäden
26
// + Wir übernehmen keinerlei Haftung für direkte oder indirekte Personen- oder Sachschäden
27
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
27
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
28
// + Die PORTIERUNG der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur 
28
// + Die PORTIERUNG der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur 
29
// + mit unserer Zustimmung zulässig
29
// + mit unserer Zustimmung zulässig
30
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
30
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
31
// + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen
31
// + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen
32
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
32
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
33
// + Redistributions of source code (with or without modifications) must retain the above copyright notice, 
33
// + Redistributions of source code (with or without modifications) must retain the above copyright notice, 
34
// + this list of conditions and the following disclaimer.
34
// + this list of conditions and the following disclaimer.
35
// +   * Neither the name of the copyright holders nor the names of contributors may be used to endorse or promote products derived
35
// +   * Neither the name of the copyright holders nor the names of contributors may be used to endorse or promote products derived
36
// +     from this software without specific prior written permission.
36
// +     from this software without specific prior written permission.
37
// +   * The use of this project (hardware, software, binary files, sources and documentation) is only permitted 
37
// +   * The use of this project (hardware, software, binary files, sources and documentation) is only permitted 
38
// +     for non-commercial use (directly or indirectly)
38
// +     for non-commercial use (directly or indirectly)
39
// +     Commercial use (for excample: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted 
39
// +     Commercial use (for excample: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted 
40
// +     with our written permission
40
// +     with our written permission
41
// +   * If sources or documentations are redistributet on other webpages, out webpage (http://www.MikroKopter.de) must be 
41
// +   * If sources or documentations are redistributet on other webpages, out webpage (http://www.MikroKopter.de) must be 
42
// +     clearly linked as origin 
42
// +     clearly linked as origin 
43
// +   * PORTING this software (or part of it) to systems (other than hardware from www.mikrokopter.de) is NOT allowed
43
// +   * PORTING this software (or part of it) to systems (other than hardware from www.mikrokopter.de) is NOT allowed
44
//
44
//
45
// +  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
45
// +  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
46
// +  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
46
// +  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
47
// +  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
47
// +  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
48
// +  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
48
// +  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
49
// +  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
49
// +  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
50
// +  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
50
// +  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
51
// +  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
51
// +  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
52
// +  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
52
// +  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
53
// +  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
53
// +  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
54
// +  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
54
// +  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
55
// +  POSSIBILITY OF SUCH DAMAGE. 
55
// +  POSSIBILITY OF SUCH DAMAGE. 
56
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
56
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
57
#include <stdio.h>
57
#include <stdio.h>
58
#include <string.h>
58
#include <string.h>
59
#include "91x_lib.h"
59
#include "91x_lib.h"
60
#include "uart.h"
60
#include "uart1.h"
61
#include "sdc.h"
61
#include "sdc.h"
62
#include "ssc.h"
62
#include "ssc.h"
63
#include "timer.h"
63
#include "timer.h"
64
#include "main.h"
64
#include "main.h"
65
#include "crc16.h"
65
#include "crc16.h"
66
 
66
 
67
//________________________________________________________________________________________________________________________________________
67
//________________________________________________________________________________________________________________________________________
68
// Module name:                 sdc.c 
68
// Module name:                 sdc.c 
69
// Compiler used:               avr-gcc 3.4.5
69
// Compiler used:               avr-gcc 3.4.5
70
// Last Modifikation:   08.06.2008
70
// Last Modifikation:   08.06.2008
71
// Version:                             1.07
71
// Version:                             1.07
72
// Authors:                             Stephan Busker, Gregor Stobrawa         
72
// Authors:                             Stephan Busker, Gregor Stobrawa         
73
// Description:                 Source files for connecting to an sd-card using the SSC
73
// Description:                 Source files for connecting to an sd-card using the SSC
74
//
74
//
75
//........................................................................................................................................
75
//........................................................................................................................................
76
// Functions:                   SD_Result_t     SDC_init(void);
76
// Functions:                   SD_Result_t     SDC_init(void);
77
//                                              u8                      SDC_PutCommand (u8 *cmd);
77
//                                              u8                      SDC_PutCommand (u8 *cmd);
78
//                                              SD_Result_t     SDC_PutSector(u32 addr,u8 *Buffer);
78
//                                              SD_Result_t     SDC_PutSector(u32 addr,u8 *Buffer);
79
//                                              SD_Result_t     SDC_GetSector(u32 addr,u8 *Buffer);
79
//                                              SD_Result_t     SDC_GetSector(u32 addr,u8 *Buffer);
80
//
80
//
81
////........................................................................................................................................
81
////........................................................................................................................................
82
// ext. functions:              extern void SSC_Init(void);
82
// ext. functions:              extern void SSC_Init(void);
83
//                                              extern u8   SSC_GetChar (void);
83
//                                              extern u8   SSC_GetChar (void);
84
//                                              extern void SSC_PutChar (u8);
84
//                                              extern void SSC_PutChar (u8);
85
//                                              extern void SSC_Enable(void);
85
//                                              extern void SSC_Enable(void);
86
//                                              extern void SSC_Disable(void);
86
//                                              extern void SSC_Disable(void);
87
//                                              extern void     SSC_ClearRxFifo();
87
//                                              extern void     SSC_ClearRxFifo();
88
//........................................................................................................................................
88
//........................................................................................................................................
89
//
89
//
90
// URL:                                 www.Mikro-Control.de
90
// URL:                                 www.Mikro-Control.de
91
// mailto:                              stephan.busker@mikro-control.de
91
// mailto:                              stephan.busker@mikro-control.de
92
//________________________________________________________________________________________________________________________________________
92
//________________________________________________________________________________________________________________________________________
93
 
93
 
94
 
94
 
95
 
95
 
96
#define CMD_GO_IDLE_STATE               0x00    /* CMD00: response R1 */
96
#define CMD_GO_IDLE_STATE               0x00    /* CMD00: response R1 */
97
#define CMD_SEND_OP_COND                0x01    /* CMD01: response R1 */
97
#define CMD_SEND_OP_COND                0x01    /* CMD01: response R1 */
98
#define CMD_SEND_IF_COND                0x08    /* CMD08: response R7 */
98
#define CMD_SEND_IF_COND                0x08    /* CMD08: response R7 */
99
#define CMD_SEND_CSD                    0x09    /* CMD09: response R1 */
99
#define CMD_SEND_CSD                    0x09    /* CMD09: response R1 */
100
#define CMD_SEND_CID                    0x0A    /* CMD10: response R1 */
100
#define CMD_SEND_CID                    0x0A    /* CMD10: response R1 */
101
#define CMD_SEND_STATUS                 0x0D    /* CMD13: response R2 */
101
#define CMD_SEND_STATUS                 0x0D    /* CMD13: response R2 */
102
#define CMD_SET_BLOCKLEN                0x10    /* CMD16: arg0[31:0]: block length, response R1*/
102
#define CMD_SET_BLOCKLEN                0x10    /* CMD16: arg0[31:0]: block length, response R1*/
103
#define CMD_READ_SINGLE_BLOCK   0x11    /* CMD17: arg0[31:0]: data address, response R1 */
103
#define CMD_READ_SINGLE_BLOCK   0x11    /* CMD17: arg0[31:0]: data address, response R1 */
104
#define CMD_WRITE_SINGLE_BLOCK  0x18    /* CMD24: arg0[31:0]: data address, response R1 */
104
#define CMD_WRITE_SINGLE_BLOCK  0x18    /* CMD24: arg0[31:0]: data address, response R1 */
105
#define CMD_APP_CMD                             0x37    /* CMD55: response R1 */
105
#define CMD_APP_CMD                             0x37    /* CMD55: response R1 */
106
#define CMD_READ_OCR                    0x3A    /* CMD58: response R3 */
106
#define CMD_READ_OCR                    0x3A    /* CMD58: response R3 */
107
#define CMD_CRC_ON_OFF                  0x3B    /* CMD59: arg0[31:1]: stuff bits, arg0[0:0]: crc option, response R1 */                                                                         
107
#define CMD_CRC_ON_OFF                  0x3B    /* CMD59: arg0[31:1]: stuff bits, arg0[0:0]: crc option, response R1 */                                                                         
108
#define ACMD_SEND_OP_COND               0x29    /* ACMD41: arg0[31]: stuff bits, arg0[30]: HCS, arg0[29:0] stuff bits*, response R1 */
108
#define ACMD_SEND_OP_COND               0x29    /* ACMD41: arg0[31]: stuff bits, arg0[30]: HCS, arg0[29:0] stuff bits*, response R1 */
109
 
109
 
110
#define R1_NO_ERR                               0x00
110
#define R1_NO_ERR                               0x00
111
#define R1_IDLE_STATE                   0x01
111
#define R1_IDLE_STATE                   0x01
112
#define R1_ERASE_RESET                  0x02
112
#define R1_ERASE_RESET                  0x02
113
#define R1_ILLEGAL_CMD                  0x04
113
#define R1_ILLEGAL_CMD                  0x04
114
#define R1_COM_CRC_ERR                  0x08
114
#define R1_COM_CRC_ERR                  0x08
115
#define R1_ERASE_SEQUENCE_ERR   0x10
115
#define R1_ERASE_SEQUENCE_ERR   0x10
116
#define R1_ADDRESS_ERR                  0x20
116
#define R1_ADDRESS_ERR                  0x20
117
#define R1_PARAMETER_ERR                0x40
117
#define R1_PARAMETER_ERR                0x40
118
#define R1_BAD_RESPONSE                 0x80
118
#define R1_BAD_RESPONSE                 0x80
119
 
119
 
120
#define R2_NO_ERR                               0x00
120
#define R2_NO_ERR                               0x00
121
#define R2_CARD_LOCKED                  0x01
121
#define R2_CARD_LOCKED                  0x01
122
#define R2_ERASE_WRITE_PROT_ERR 0x02
122
#define R2_ERASE_WRITE_PROT_ERR 0x02
123
#define R2_UNKOWN_ERR                   0x04
123
#define R2_UNKOWN_ERR                   0x04
124
#define R2_CARD_CTRL_ERR                0x08
124
#define R2_CARD_CTRL_ERR                0x08
125
#define R2_CARD_ECC_ERR             0x10
125
#define R2_CARD_ECC_ERR             0x10
126
#define R2_WRITE_PROT_ERR               0x20
126
#define R2_WRITE_PROT_ERR               0x20
127
#define R2_ERASE_PARAM_ERR              0x40
127
#define R2_ERASE_PARAM_ERR              0x40
128
#define R2_OUT_OF_RANGE_ERR             0x80
128
#define R2_OUT_OF_RANGE_ERR             0x80
129
 
129
 
130
#define DATA_START_TOKEN                0xFE
130
#define DATA_START_TOKEN                0xFE
131
#define DATA_RESPONSE_MASK              0x1F 
131
#define DATA_RESPONSE_MASK              0x1F 
132
#define DATA_RESPONSE_OK                0x05
132
#define DATA_RESPONSE_OK                0x05
133
#define DATA_RESPONSE_CRC_ERR   0x0B
133
#define DATA_RESPONSE_CRC_ERR   0x0B
134
#define DATA_RESPONSE_WRITE_ERR 0x1D
134
#define DATA_RESPONSE_WRITE_ERR 0x1D
135
 
135
 
136
typedef enum
136
typedef enum
137
{
137
{
138
        VER_UNKNOWN,
138
        VER_UNKNOWN,
139
        VER_1X,
139
        VER_1X,
140
        VER_20
140
        VER_20
141
} SDVersion_t;
141
} SDVersion_t;
142
 
142
 
143
typedef struct
143
typedef struct
144
{
144
{
145
  u8 Valid;
145
  u8 Valid;
146
  SDVersion_t Version;  // HW-Version 
146
  SDVersion_t Version;  // HW-Version 
147
  u32 Capacity;                 // Memory capacity  in bytes
147
  u32 Capacity;                 // Memory capacity  in bytes
148
  u8 CID[16];                   // CID register
148
  u8 CID[16];                   // CID register
149
  u8 CSD[16];                   // CSD register
149
  u8 CSD[16];                   // CSD register
150
} __attribute__((packed)) SDCardInfo_t;
150
} __attribute__((packed)) SDCardInfo_t;
151
 
151
 
152
volatile SDCardInfo_t SDCardInfo;
152
volatile SDCardInfo_t SDCardInfo;
153
 
153
 
154
 
154
 
155
//________________________________________________________________________________________________________________________________________
155
//________________________________________________________________________________________________________________________________________
156
// Function:    CRC7(u8* cmd, u32 len);
156
// Function:    CRC7(u8* cmd, u32 len);
157
// 
157
// 
158
// Description: This function calculated the CRC7 checksum used in the last byte of a spi command frame. 
158
// Description: This function calculated the CRC7 checksum used in the last byte of a spi command frame. 
159
//                              
159
//                              
160
//
160
//
161
// Returnvalue: the function returns the crc7 including bit 0 set to 1
161
// Returnvalue: the function returns the crc7 including bit 0 set to 1
162
//________________________________________________________________________________________________________________________________________
162
//________________________________________________________________________________________________________________________________________
163
 
163
 
164
u8 CRC7(u8 * cmd, u32 len)
164
u8 CRC7(u8 * cmd, u32 len)
165
{
165
{
166
        u8 i, a;
166
        u8 i, a;
167
        u8 crc, Data;
167
        u8 crc, Data;
168
 
168
 
169
        crc = 0; // init CRC buffer
169
        crc = 0; // init CRC buffer
170
        for (a = 0; a < len ;a++) // for every byte in the msg
170
        for (a = 0; a < len ;a++) // for every byte in the msg
171
        {
171
        {
172
                Data = cmd[a];
172
                Data = cmd[a];
173
                for (i=0;i<8;i++) // for every bit in the byte
173
                for (i=0;i<8;i++) // for every bit in the byte
174
                {
174
                {
175
                        crc <<= 1; // shift crc
175
                        crc <<= 1; // shift crc
176
                        if ((Data & 0x80)^(crc & 0x80)) crc ^=0x09;       //xor
176
                        if ((Data & 0x80)^(crc & 0x80)) crc ^=0x09;       //xor
177
                        Data <<= 1;     // shift data  for next bit
177
                        Data <<= 1;     // shift data  for next bit
178
                }
178
                }
179
        }
179
        }
180
        crc = (crc<<1)|1; // set terminating bit to 1
180
        crc = (crc<<1)|1; // set terminating bit to 1
181
        return(crc);
181
        return(crc);
182
}
182
}
183
 
183
 
184
u8 SDC_WaitForBusy()
184
u8 SDC_WaitForBusy(u32 timeout)
185
{
185
{
186
        u8 rsp = 0;
186
        u8 rsp = 0;
187
        u16 timeout=0;
187
        u32 timestamp = 0;
188
 
188
 
189
        SSC_ClearRxFifo();
189
        SSC_ClearRxFifo();
190
        SSC_Enable();                           // enable chipselect.
190
        SSC_Enable();                           // enable chipselect.
-
 
191
        timestamp = SetDelay(timeout);
191
        do     
192
        do     
192
        {
193
        {
193
                rsp = SSC_GetChar();
194
                rsp = SSC_GetChar();
194
                if(timeout++>500) break;
195
                if(CheckDelay(timestamp)) break;
195
        }while(rsp != 0xFF);            // wait while card is busy (data out low)
196
        }while(rsp != 0xFF);            // wait while card is busy (data out low)
196
        return(rsp);
197
        return(rsp);
197
}
198
}
198
 
199
 
199
 
200
 
200
 
201
 
201
//________________________________________________________________________________________________________________________________________
202
//________________________________________________________________________________________________________________________________________
202
// Function:    SDC_SendCMDR1(u8 CmdNo, u32 arg);
203
// Function:    SDC_SendCMDR1(u8 CmdNo, u32 arg);
203
// 
204
// 
204
// Description: This function send a command frame to the SD-Card in spi-mode. 
205
// Description: This function send a command frame to the SD-Card in spi-mode. 
205
//                              
206
//                              
206
//
207
//
207
// Returnvalue: The function returns the first response byte like for R1 commands
208
// Returnvalue: The function returns the first response byte like for R1 commands
208
//________________________________________________________________________________________________________________________________________
209
//________________________________________________________________________________________________________________________________________
209
u8 SDC_SendCMDR1(u8 CmdNo, u32 arg)
210
u8 SDC_SendCMDR1(u8 CmdNo, u32 arg)
210
{
211
{
211
        u8 r1;
212
        u8 r1;
212
        u16 Timeout = 0;
213
        u16 timeout = 0;
213
        u16 a;
214
        u16 a;
214
        u8 cmd[6];
215
        u8 cmd[6];
215
 
216
 
216
        SSC_ClearRxFifo();      // clear the rx fifo
217
        SSC_ClearRxFifo();      // clear the rx fifo
217
        SSC_Enable();           // enable chipselect.
218
        SSC_Enable();           // enable chipselect.
218
        SDC_WaitForBusy();
219
        SDC_WaitForBusy(500);   // wait 500ms until card is busy
219
        SSC_ClearRxFifo();      // clear the rx fifo
220
        SSC_ClearRxFifo();      // clear the rx fifo
220
        SSC_GetChar();      // dummy to sync
221
        SSC_GetChar();      // dummy to sync
221
 
-
 
222
        /* Send cmd10 (SEND_CID) */;
222
 
223
        cmd[0] = 0x40|CmdNo; // set command index
223
        cmd[0] = 0x40|CmdNo; // set command index
224
        cmd[1] = (arg & 0xFF000000)>>24;
224
        cmd[1] = (arg & 0xFF000000)>>24;
225
        cmd[2] = (arg & 0x00FF0000)>>16;
225
        cmd[2] = (arg & 0x00FF0000)>>16;
226
        cmd[3] = (arg & 0x0000FF00)>>8;
226
        cmd[3] = (arg & 0x0000FF00)>>8;
227
        cmd[4] = (arg & 0x000000FF);
227
        cmd[4] = (arg & 0x000000FF);
228
        cmd[5] = CRC7(cmd, 5); // update checksum 
228
        cmd[5] = CRC7(cmd, 5); // update checksum 
229
        for (a = 0;a < 6; a++) // send the command sequence to the sdcard (6 bytes)
229
        for (a = 0;a < 6; a++) // send the command sequence to the sdcard (6 bytes)
230
        {      
230
        {      
231
                SSC_PutChar(cmd[a]);
231
                SSC_PutChar(cmd[a]);
232
        }
232
        }
233
        SSC_ClearRxFifo();      // clear the rx fifo to discard the bytes received during the transmission of the 6 command bytes
233
        SSC_ClearRxFifo();      // clear the rx fifo to discard the bytes received during the transmission of the 6 command bytes
-
 
234
 
234
        do                                     
235
        do                                     
235
        {
236
        {
236
                r1 = SSC_GetChar();       // get byte from sd-card
237
                r1 = SSC_GetChar();       // get byte from sd-card
237
                if (Timeout++ > 500) return(r1);
238
                if (timeout++ >500) break;
238
        }while(r1 == 0xFF); // wait for the response byte from sd-card.
239
        }while(r1 == 0xFF); // wait for the response byte from sd-card.
239
        return(r1);
240
        return(r1);
240
}
241
}
241
 
242
 
242
 
243
 
243
//________________________________________________________________________________________________________________________________________
244
//________________________________________________________________________________________________________________________________________
244
// Function:    SDC_SendACMDR1(u8 CmdNo, u32 arg);
245
// Function:    SDC_SendACMDR1(u8 CmdNo, u32 arg);
245
// 
246
//                                         
246
// Description: This function send a application command frame to the SD-Card in spi-mode. 
247
// Description: This function send a application command frame to the SD-Card in spi-mode. 
247
//                              
248
//                              
248
//
249
//
249
// Returnvalue: The function returns the first response byte like for R1 commands
250
// Returnvalue: The function returns the first response byte like for R1 commands
250
//________________________________________________________________________________________________________________________________________
251
//________________________________________________________________________________________________________________________________________
251
u8 SDC_SendACMDR1(u8 CmdNo, u32 arg)
252
u8 SDC_SendACMDR1(u8 CmdNo, u32 arg)
252
{
253
{
253
        u8 r1 = 0xFF;
254
        u8 r1 = 0xFF;
254
        r1 = SDC_SendCMDR1(CMD_APP_CMD, 0UL);
255
        r1 = SDC_SendCMDR1(CMD_APP_CMD, 0UL);
255
        if(r1 & R1_BAD_RESPONSE) return(r1);
256
        if(r1 & R1_BAD_RESPONSE) return(r1);
256
        r1 = SDC_SendCMDR1(CmdNo, arg);
257
        r1 = SDC_SendCMDR1(CmdNo, arg);
257
        return(r1);
258
        return(r1);
258
}
259
}
259
 
260
 
260
 
261
 
261
//________________________________________________________________________________________________________________________________________
262
//________________________________________________________________________________________________________________________________________
262
// Function:    SDC_GetData(u8 * cmd ,u8 *Buffer, u32 len);
263
// Function:    SDC_GetData(u8 * cmd ,u8 *Buffer, u32 len);
263
// 
264
// 
264
// Description: This function sneds cmd an reads a datablock of len from the sd-card
265
// Description: This function sneds cmd an reads a datablock of len from the sd-card
265
//                              
266
//                              
266
//
267
//
267
// Returnvalue: SD_Result_t
268
// Returnvalue: SD_Result_t
268
//________________________________________________________________________________________________________________________________________
269
//________________________________________________________________________________________________________________________________________
269
 
270
 
270
SD_Result_t SDC_GetData(u8 CmdNo, u32 addr, u8 *Buffer, u32 len)
271
SD_Result_t SDC_GetData(u8 CmdNo, u32 addr, u8 *Buffer, u32 len)
271
{
272
{
272
        u8 rsp;        
273
        u8 rsp;        
273
        u16 timeout;
-
 
274
        u16 a, Crc16;
274
        u16 a, crc16;
275
        SD_Result_t result = SD_ERROR_UNKNOWN;
275
        SD_Result_t result = SD_ERROR_UNKNOWN;
276
 
276
 
277
        // send the command     
277
        // send the command     
278
        rsp = SDC_SendCMDR1(CmdNo, addr);
278
        rsp = SDC_SendCMDR1(CmdNo, addr);
279
        if (rsp != R1_NO_ERR)
279
        if (rsp != R1_NO_ERR)
280
        {
280
        {
281
                result = SD_ERROR_BAD_RESPONSE;
281
                result = SD_ERROR_BAD_RESPONSE;
282
                goto end;
282
                goto end;
283
        }
283
        }
284
        SSC_ClearRxFifo();
284
        SSC_ClearRxFifo();
285
        do
285
        do
286
        {
286
        {
287
                rsp = SSC_GetChar();
287
                rsp = SSC_GetChar();
288
                if((rsp & 0xF0) == 0x00) // data error token 
288
                if((rsp & 0xF0) == 0x00) // data error token 
289
                {
289
                {
290
                        result = SD_ERROR_READ_DATA;
290
                        result = SD_ERROR_READ_DATA;
291
                        goto end;
291
                        goto end;
292
                }
292
                }
293
//              if(timeout++>500) break;
-
 
294
        }while(rsp != DATA_START_TOKEN);
293
        }while(rsp != DATA_START_TOKEN);
295
        // data start token received
294
        // data start token received
296
        for (a = 0; a < len; a++)       // read the block from the SSC
295
        for (a = 0; a < len; a++)       // read the block from the SSC
297
        {
296
        {
298
                Buffer[a] = SSC_GetChar();
297
                Buffer[a] = SSC_GetChar();
299
        }
298
        }
300
        // Read two bytes CRC16-Data checksum
299
        // Read two bytes CRC16-Data checksum
301
        Crc16 = SSC_GetChar(); // highbyte fisrt        
300
        crc16 = SSC_GetChar(); // highbyte fisrt        
302
        Crc16 = (Crc16<<8)|SSC_GetChar(); // lowbyte last
301
        crc16 = (crc16<<8)|SSC_GetChar(); // lowbyte last
303
//      if(Crc16 != CRC16(Buffer, len)) result = SD_ERROR_CRC_DATA;
302
/*      if(crc16 != CRC16(Buffer, len)) result = SD_ERROR_CRC_DATA;
304
/*      else */result = SD_SUCCESS;
303
        else */result = SD_SUCCESS;
305
       
304
       
306
        end:
-
 
307
        //SSC_Disable();        // disable sdcard.
305
        end:
308
        if(result != SD_SUCCESS)
306
        if(result != SD_SUCCESS)
309
        {
307
        {
310
                sprintf(text,"Error %02X reading data from sd card (R1=%02X).\r\n", result, rsp);
308
                sprintf(text,"Error %02X reading data from sd card (R1=%02X).\r\n", result, rsp);
311
                SerialPutString(text);
309
                SerialPutString(text);
312
        }
310
        }
313
        return(result);
311
        return(result);
314
}
312
}
315
 
313
 
316
 
314
 
317
//________________________________________________________________________________________________________________________________________
315
//________________________________________________________________________________________________________________________________________
318
// Function:    SDC_PrintCID(u8 * pCID);
316
// Function:    SDC_PrintCID(u8 * pCID);
319
// 
317
// 
320
// Description: This function prints the CIS register in a human readable format. 
318
// Description: This function prints the CIS register in a human readable format. 
321
//                              
319
//                              
322
//
320
//
323
// Returnvalue: the function returns nothing
321
// Returnvalue: the function returns nothing
324
//________________________________________________________________________________________________________________________________________
322
//________________________________________________________________________________________________________________________________________
325
 
323
 
326
void SDC_PrintCID(u8 * pCID)
324
void SDC_PrintCID(u8 * pCID)
327
{
325
{
328
        u8 text[50];
326
        u8 text[50];
329
        u8 pn[6];
327
        u8 pn[6];
330
        u16 temp1, temp2;
328
        u16 temp1, temp2;
331
 
329
 
332
        sprintf(text, "\r\nManufacturer ID: %i\r\n", pCID[0]);
330
        sprintf(text, "\r\n Manufacturer ID: %i\r\n", pCID[0]);
333
        SerialPutString(text);
331
        SerialPutString(text);
334
        memcpy(pn, &pCID[1], 2);
332
        memcpy(pn, &pCID[1], 2);
335
        pn[2] = '\0'; // terminate string
333
        pn[2] = '\0'; // terminate string
336
        sprintf(text, "Application ID: %s\r\n",pn);
334
        sprintf(text, " Application ID: %s\r\n",pn);
337
        SerialPutString(text);
335
        SerialPutString(text);
338
        memcpy(pn, &pCID[3], 5);
336
        memcpy(pn, &pCID[3], 5);
339
        pn[5] = '\0'; // terminate string
337
        pn[5] = '\0'; // terminate string
340
        sprintf(text, "Product Name: %s\r\n",pn);
338
        sprintf(text, " Product Name: %s\r\n",pn);
341
        SerialPutString(text);
339
        SerialPutString(text);
342
        sprintf(text, "Product Rev.: %i.%i\r\n",pCID[8]>>4, pCID[8]&0xF);
340
        sprintf(text, " Product Rev.: %i.%i\r\n",pCID[8]>>4, pCID[8]&0xF);
343
        SerialPutString(text);
341
        SerialPutString(text);
344
        SerialPutString("Serial No.: ");
342
        SerialPutString(" Serial No.: ");
345
        for(temp1 = 0; temp1<4; temp1++)
343
        for(temp1 = 0; temp1<4; temp1++)
346
        {
344
        {
347
                sprintf(text,"%02X", pCID[9+temp1]);
345
                sprintf(text,"%02X", pCID[9+temp1]);
348
                SerialPutString(text);
346
                SerialPutString(text);
349
        }
347
        }
350
        SerialPutString("\r\n");
348
        SerialPutString("\r\n");
351
        temp1 = pCID[14] & 0x0F;    // month 
349
        temp1 = pCID[14] & 0x0F;    // month 
352
        temp2 = ((pCID[14]>>4)|(pCID[13]<<4)) + 2000; // year 
350
        temp2 = ((pCID[14]>>4)|(pCID[13]<<4)) + 2000; // year 
353
        sprintf(text, "Manufac. Date: %i/%i\r\n\r\n",temp1, temp2);
351
        sprintf(text, " Manufac. Date: %i/%i\r\n\r\n",temp1, temp2);
354
        SerialPutString(text);
352
        SerialPutString(text);
355
}
353
}
356
 
354
 
357
//________________________________________________________________________________________________________________________________________
355
//________________________________________________________________________________________________________________________________________
358
// Funtion:     SDC_GetCID(u8 * pCID);
356
// Funtion:     SDC_GetCID(u8 * pCID);
359
// 
357
// 
360
// Description: This function reads the CIS register form the sd card in spi mode. 
358
// Description: This function reads the CIS register form the sd card in spi mode. 
361
//                              
359
//                              
362
//
360
//
363
// Returnvalue: the function returns error state
361
// Returnvalue: the function returns error state
364
//________________________________________________________________________________________________________________________________________
362
//________________________________________________________________________________________________________________________________________
365
 
363
 
366
SD_Result_t SDC_GetCID(u8 * pCID)
364
SD_Result_t SDC_GetCID(u8 * pCID)
367
{
365
{
368
        return SDC_GetData(CMD_SEND_CID, 0UL, pCID, 16);
366
        return SDC_GetData(CMD_SEND_CID, 0UL, pCID, 16);
369
}
367
}
370
 
368
 
371
//________________________________________________________________________________________________________________________________________
369
//________________________________________________________________________________________________________________________________________
372
// Funtion:     SDC_GetCSD(u8 * pCSD);
370
// Funtion:     SDC_GetCSD(u8 * pCSD);
373
// 
371
// 
374
// Description: This function reads the CSD register form the sd card in spi mode. 
372
// Description: This function reads the CSD register form the sd card in spi mode. 
375
//                              
373
//                              
376
//
374
//
377
// Returnvalue: the function returns error state
375
// Returnvalue: the function returns error state
378
//________________________________________________________________________________________________________________________________________
376
//________________________________________________________________________________________________________________________________________
379
 
377
 
380
SD_Result_t SDC_GetCSD(u8 * pCSD)
378
SD_Result_t SDC_GetCSD(u8 * pCSD)
381
{
379
{
382
        return SDC_GetData(CMD_SEND_CSD, 0UL, pCSD, 16);
380
        return SDC_GetData(CMD_SEND_CSD, 0UL, pCSD, 16);
383
}
381
}
384
 
382
 
385
 
383
 
386
//________________________________________________________________________________________________________________________________________
384
//________________________________________________________________________________________________________________________________________
387
// Funtion:     SDC_Init(void);
385
// Funtion:     SDC_Init(void);
388
// 
386
// 
389
// Description: This function initialises the SDCard to spi-mode. 
387
// Description: This function initialises the SDCard to spi-mode. 
390
//                              
388
//                              
391
//
389
//
392
// Returnvalue: the function returns 0 if the initialisation was successfull otherwise the function returns an errorcode.
390
// Returnvalue: the function returns 0 if the initialisation was successfull otherwise the function returns an errorcode.
393
//________________________________________________________________________________________________________________________________________
391
//________________________________________________________________________________________________________________________________________
394
 
392
 
395
SD_Result_t SDC_Init(void)
393
SD_Result_t SDC_Init(void)
396
{
394
{
397
        u32 Timeout = 0;
395
        u32 timeout = 0;
398
        u8 text[50];
396
        u8 text[50];
399
        u8 rsp[6]; // SD-SPI response buffer
397
        u8 rsp[6]; // SD-SPI response buffer
400
        SD_Result_t result = SD_ERROR_UNKNOWN;
398
        SD_Result_t result = SD_ERROR_UNKNOWN;
401
               
399
               
402
        if(SD_SWITCH) // init only if the SD-Switch is indicating a card in the slot
400
        if(SD_SWITCH) // init only if the SD-Switch is indicating a card in the slot
403
        {
401
        {
404
                SerialPutString("\r\n  SSC init...");  
402
                SerialPutString("\r\n SSC init...");
405
                SSC_Init();
403
                SSC_Init();
406
                SerialPutString("ok");
404
                SerialPutString("ok");
407
       
405
 
408
                SerialPutString("\r\n  SDC init...");  
406
                SerialPutString("\r\n SDC init...");
409
                SDCardInfo.Valid = 0;
407
                SDCardInfo.Valid = 0;
410
                /* The host shall supply power to the card so that the voltage is reached to Vdd_min within 250ms and
408
                /* The host shall supply power to the card so that the voltage is reached to Vdd_min within 250ms and
411
                start to supply at least 74 SD clocks to the SD card with keeping cmd line to high. In case of SPI
409
                start to supply at least 74 SD clocks to the SD card with keeping cmd line to high. In case of SPI
412
                mode, CS shall be held to high during 74 clock cycles. */
410
                mode, CS shall be held to high during 74 clock cycles. */
413
                SSC_Disable(); // set SD_CS high
411
                SSC_Disable(); // set SD_CS high
414
                SSC_ClearRxFifo();      // clear the rx fifo
412
                SSC_ClearRxFifo();      // clear the rx fifo
415
       
413
       
416
                for (Timeout = 0; Timeout < 15; Timeout++)      // 15*8 = 120 cycles
414
                for (timeout = 0; timeout < 15; timeout++)      // 15*8 = 120 cycles
417
                {
415
                {
418
                        SSC_PutChar(0xFF);
416
                        SSC_PutChar(0xFF);
419
                }
417
                }
420
       
418
       
421
                // switch to idle state
419
                // switch to idle state
422
                while(SDC_SendCMDR1(CMD_GO_IDLE_STATE, 0UL) != R1_IDLE_STATE)                                          
420
                while(SDC_SendCMDR1(CMD_GO_IDLE_STATE, 0UL) != R1_IDLE_STATE)                                          
423
                {
421
                {
424
                        if (Timeout++ > 20)
422
                        if (timeout++ > 20)
425
                        {
423
                        {
426
                                SerialPutString("reset timeout");
424
                                SerialPutString("reset timeout");
427
                                result = SD_ERROR_RESET;
425
                                result = SD_ERROR_RESET;
428
                                goto end;                                                                              
426
                                goto end;                                                                              
429
                        }
427
                        }
430
                }
428
                }
431
            // enable crc feature
429
            // enable crc feature
432
/*              if(SDC_SendCMDR1(CMD_CRC_ON_OFF, 1UL) != R1_IDLE_STATE)
430
/*              if(SDC_SendCMDR1(CMD_CRC_ON_OFF, 1UL) != R1_IDLE_STATE)
433
                {
431
                {
434
                                sprintf(text,"Bad cmd59 R1=%02X.\r\n", rsp[0]);
432
                                sprintf(text,"Bad cmd59 R1=%02X.", rsp[0]);
435
                                SerialPutString(text);
433
                                SerialPutString(text);
436
                                result = SD_ERROR_BAD_RESPONSE;
434
                                result = SD_ERROR_BAD_RESPONSE;
437
                                goto end;
435
                                goto end;
438
                }*/
436
                }*/
439
                // check for card hw version                                            
437
                // check for card hw version                                            
440
                // 2.7-3.6V Range = 0x01, check pattern 0xAA
438
                // 2.7-3.6V Range = 0x01, check pattern 0xAA
441
                rsp[0] = SDC_SendCMDR1(CMD_SEND_IF_COND, 0x000001AA);
439
                rsp[0] = SDC_SendCMDR1(CMD_SEND_IF_COND, 0x000001AA);
442
                // answer to cmd58 is an R7 response (R1+ 4Byte IFCond)
440
                // answer to cmd58 is an R7 response (R1+ 4Byte IFCond)
443
                if(rsp[0] & R1_BAD_RESPONSE)
441
                if(rsp[0] & R1_BAD_RESPONSE)
444
                {
442
                {
445
                        sprintf(text,"Bad cmd8 R1=%02X.\r\n", rsp[0]);
443
                        sprintf(text,"Bad cmd8 R1=%02X.", rsp[0]);
446
                        SerialPutString(text);
444
                        SerialPutString(text);
447
                        result = SD_ERROR_BAD_RESPONSE;
445
                        result = SD_ERROR_BAD_RESPONSE;
448
                        goto end;
446
                        goto end;
449
                }
447
                }
450
                if(rsp[0] & R1_ILLEGAL_CMD)
448
                if(rsp[0] & R1_ILLEGAL_CMD)
451
                {
449
                {
452
                        //Ver1.X SD Memory Card or not a SD Memory Card
450
                        //Ver1.X SD Memory Card or not a SD Memory Card
453
                        SDCardInfo.Version = VER_1X;                   
451
                        SDCardInfo.Version = VER_1X;                   
454
                }
452
                }
455
                else
453
                else
456
                {
454
                {
457
                   // Ver2.00 or later SD Memory Card
455
                   // Ver2.00 or later SD Memory Card
458
                   // reading the remaining bytes of the R7 response
456
                   // reading the remaining bytes of the R7 response
459
                   SDCardInfo.Version = VER_20;
457
                   SDCardInfo.Version = VER_20;
460
                   for(Timeout = 1; Timeout < 5; Timeout++)
458
                   for(timeout = 1; timeout < 5; timeout++)
461
                   {
459
                   {
462
                                rsp[Timeout] = SSC_GetChar();
460
                                rsp[timeout] = SSC_GetChar();
463
                   }
461
                   }
464
                   //check pattern
462
                   //check pattern
465
                   if(rsp[4]!= 0xAA)
463
                   if(rsp[4]!= 0xAA)
466
                   {
464
                   {
467
                                SerialPutString("Bad cmd8 R7 check pattern.\r\n");
465
                                SerialPutString("Bad cmd8 R7 check pattern.\r\n");
468
                                result = SD_ERROR_BAD_RESPONSE;
466
                                result = SD_ERROR_BAD_RESPONSE;
469
                                goto end;
467
                                goto end;
470
                   }
468
                   }
471
                   if ( (rsp[3] & 0x0F)!= 0x01 ) // voltage range is not 2.7-3.6V
469
                   if ( (rsp[3] & 0x0F)!= 0x01 ) // voltage range is not 2.7-3.6V
472
                   {
470
                   {
473
                               
471
                               
474
                                SerialPutString("Card is incompatible to 3.3V.\r\n");
472
                                SerialPutString("Card is incompatible to 3.3V.\r\n");
475
                                result = SD_ERROR_BAD_VOLTAGE_RANGE;
473
                                result = SD_ERROR_BAD_VOLTAGE_RANGE;
476
                                goto end;              
474
                                goto end;              
477
                   }
475
                   }
478
                }
476
                }
479
       
477
       
480
                rsp[0] = SDC_SendCMDR1(CMD_READ_OCR, 0UL);
478
                rsp[0] = SDC_SendCMDR1(CMD_READ_OCR, 0UL);
481
                // answer to cmd58 is an R3 response (R1 + 4Byte OCR)
479
                // answer to cmd58 is an R3 response (R1 + 4Byte OCR)
482
                if(rsp[0] & R1_BAD_RESPONSE)
480
                if(rsp[0] & R1_BAD_RESPONSE)
483
                {
481
                {
484
                        sprintf(text,"Bad cmd58 R1 %02x.\r\n", rsp[0]);
482
                        sprintf(text,"Bad cmd58 R1 %02x.", rsp[0]);
485
                        SerialPutString(text);
483
                        SerialPutString(text);
486
                        result = SD_ERROR_BAD_RESPONSE;
484
                        result = SD_ERROR_BAD_RESPONSE;
487
                        goto end;
485
                        goto end;
488
                }
486
                }
489
                if(rsp[0] & R1_ILLEGAL_CMD)
487
                if(rsp[0] & R1_ILLEGAL_CMD)
490
                {
488
                {
491
                        SerialPutString("Not an SD-CARD.\r\n");
489
                        SerialPutString("Not an SD-CARD.");
492
                        result = SD_ERROR_NO_SDCARD;
490
                        result = SD_ERROR_NO_SDCARD;
493
                        goto end;
491
                        goto end;
494
                }
492
                }
495
                // read 4 bytes of OCR register
493
                // read 4 bytes of OCR register
496
                for(Timeout = 1; Timeout < 5; Timeout++)
494
                for(timeout = 1; timeout < 5; timeout++)
497
                {
495
                {
498
                        rsp[Timeout] = SSC_GetChar();
496
                        rsp[timeout] = SSC_GetChar();
499
                }
497
                }
500
                //      NavicCtrl uses 3.3 V,  therefore check for bit 20 & 21 
498
                //      NavicCtrl uses 3.3 V,  therefore check for bit 20 & 21 
501
                if((rsp[2] & 0x30) != 0x30)
499
                if((rsp[2] & 0x30) != 0x30)
502
                {
500
                {
503
                        // supply voltage is not supported by sd-card
501
                        // supply voltage is not supported by sd-card
504
                        SerialPutString("Card is incompatible to 3.3V.\r\n");
502
                        SerialPutString("Card is incompatible to 3.3V.");
505
                        result = SD_ERROR_BAD_VOLTAGE_RANGE;
503
                        result = SD_ERROR_BAD_VOLTAGE_RANGE;
506
                        goto end;
504
                        goto end;
507
                }
505
                }
508
               
506
               
509
                // Initialize the sd-card sending continously ACMD_SEND_OP_COND (only supported by SD cards)
507
                // Initialize the sd-card sending continously ACMD_SEND_OP_COND (only supported by SD cards)
510
                Timeout =  SetDelay(2000); // set timeout to 2000 ms (large cards tend to longer) 
508
                timeout =  SetDelay(2000); // set timeout to 2000 ms (large cards tend to longer) 
511
                do
509
                do
512
                {
510
                {
513
                        rsp[0] = SDC_SendACMDR1(ACMD_SEND_OP_COND, 0UL);
511
                        rsp[0] = SDC_SendACMDR1(ACMD_SEND_OP_COND, 0UL);
514
                        if(rsp[0] & R1_BAD_RESPONSE)
512
                        if(rsp[0] & R1_BAD_RESPONSE)
515
                        {
513
                        {
516
                                sprintf(text,"Bad Acmd41 R1=%02X.\r\n", rsp[0]);
514
                                sprintf(text,"Bad Acmd41 R1=%02X.", rsp[0]);
517
                                SerialPutString(text);
515
                                SerialPutString(text);
518
                                result = SD_ERROR_BAD_RESPONSE;
516
                                result = SD_ERROR_BAD_RESPONSE;
519
                                goto end;
517
                                goto end;
520
                        }
518
                        }
521
                        if(CheckDelay(Timeout))
519
                        if(CheckDelay(timeout))
522
                        {
520
                        {
523
                            SerialPutString("Init timeout.\r\n");
521
                            SerialPutString("Init timeout.");
524
                                result = SD_ERROR_INITIALIZE;
522
                                result = SD_ERROR_INITIALIZE;
525
                                goto end;
523
                                goto end;
526
                        }
524
                        }
527
                } while(rsp[0] & R1_IDLE_STATE); // loop until idle state
525
                } while(rsp[0] & R1_IDLE_STATE); // loop until idle state
528
               
526
               
529
                if(rsp[0] != R1_NO_ERR)
527
                if(rsp[0] != R1_NO_ERR)
530
                {
528
                {
531
                        SerialPutString("Init error.\r\n");
529
                        SerialPutString("Init error.");
532
                        result = SD_ERROR_INITIALIZE;
530
                        result = SD_ERROR_INITIALIZE;
533
                        goto end;      
531
                        goto end;      
534
                }
532
                }
535
                /* set block size to 512 bytes */
533
                /* set block size to 512 bytes */
536
        if(SDC_SendCMDR1(CMD_SET_BLOCKLEN, 512UL) != R1_NO_ERR)
534
        if(SDC_SendCMDR1(CMD_SET_BLOCKLEN, 512UL) != R1_NO_ERR)
537
        {
535
        {
538
                SerialPutString("Error setting block length to 512.\r\n");
536
                SerialPutString("Error setting block length to 512.");
539
                        result = SD_ERROR_SET_BLOCKLEN;
537
                        result = SD_ERROR_SET_BLOCKLEN;
540
                        goto end;
538
                        goto end;
541
        }
539
        }
542
 
-
 
543
 
540
               
544
                //SSC_Disable(); // set SD_CS high                                               
541
                //SSC_Disable(); // set SD_CS high                                                                       
545
                // here is the right place to inrease the SPI boud rate to maximum              
542
                // here is the right place to inrease the SPI boud rate to maximum              
546
                //SSC_Enable(); // set SD_CS high
543
                //SSC_Enable(); // set SD_CS high
547
 
544
 
548
                // read CID register
545
                // read CID register
549
                result = SDC_GetCID((u8 *)&SDCardInfo.CID);
546
                result = SDC_GetCID((u8 *)&SDCardInfo.CID);
550
                if(result != SD_SUCCESS)
547
                if(result != SD_SUCCESS)
551
                {
548
                {
552
                        SerialPutString("Error reading CID.\r\n");
549
                        SerialPutString("Error reading CID.\r\n");
553
                        goto end;
550
                        goto end;
554
                }
551
                }
555
       
552
       
556
                // read CSD register
553
                // read CSD register
557
                result = SDC_GetCSD((u8 *)&SDCardInfo.CSD);
554
                result = SDC_GetCSD((u8 *)&SDCardInfo.CSD);
558
                if(result != SD_SUCCESS)
555
                if(result != SD_SUCCESS)
559
                {
556
                {
560
                        SerialPutString("Error reading CSD.\r\n");
557
                        SerialPutString("Error reading CSD.");
561
                        goto end;
558
                        goto end;
562
                }
559
                }
563
       
560
       
564
                SerialPutString("ok\r\n");
561
                SerialPutString("ok\r\n");
565
       
562
       
566
                u8 c_size_mult, read_bl_len;
563
                u8 c_size_mult, read_bl_len;
567
                u32 c_size;
564
                u32 c_size;
568
       
565
       
569
                switch(SDCardInfo.CSD[0]>>6) // check CSD Version
566
                switch(SDCardInfo.CSD[0]>>6) // check CSD Version
570
                {
567
                {
571
                case 0x00: // if CSD is V1.0 structure (2GB limit)
568
                case 0x00: // if CSD is V1.0 structure (2GB limit)
572
       
569
       
573
                        /*
570
                        /*
574
                        memory capacity = BLOCKNR * BLOCK_LEN
571
                        memory capacity = BLOCKNR * BLOCK_LEN
575
                        BLOCKNR = (C_SIZE+1) * MULT
572
                        BLOCKNR = (C_SIZE+1) * MULT
576
                        MULT = 2^(C_SIZE_MULT+2)
573
                        MULT = 2^(C_SIZE_MULT+2)
577
                        BLOCK_LEN = 2^READ_BL_LEN
574
                        BLOCK_LEN = 2^READ_BL_LEN
578
               
575
               
579
                        C_SIZE      is 12 bits [73:62] in CSD register
576
                        C_SIZE      is 12 bits [73:62] in CSD register
580
                        C_SIZE_MULT is  3 bits [49:47] in CSD register
577
                        C_SIZE_MULT is  3 bits [49:47] in CSD register
581
                        READ_BL_LEN is  4 bits [83:80] in CSD register
578
                        READ_BL_LEN is  4 bits [83:80] in CSD register
582
                        */
579
                        */
583
       
580
       
584
                        read_bl_len = (SDCardInfo.CSD[5] & 0x0F);               //CSD[05] -> [87:80]
581
                        read_bl_len = (SDCardInfo.CSD[5] & 0x0F);               //CSD[05] -> [87:80]
585
                        c_size = ((u32)(SDCardInfo.CSD[6] & 0x03))<<10; //CSD[06] -> [79:72]
582
                        c_size = ((u32)(SDCardInfo.CSD[6] & 0x03))<<10; //CSD[06] -> [79:72]
586
                        c_size |= ((u32)SDCardInfo.CSD[7])<<2;                  //CSD[07] -> [71:64]
583
                        c_size |= ((u32)SDCardInfo.CSD[7])<<2;                  //CSD[07] -> [71:64]
587
                        c_size |= (u32)(SDCardInfo.CSD[8]>>6);                  //CSD[08] -> [63:56]
584
                        c_size |= (u32)(SDCardInfo.CSD[8]>>6);                  //CSD[08] -> [63:56]
588
                        c_size_mult = (SDCardInfo.CSD[9] & 0x03)<<1;    //CSD[09] -> [55:48]
585
                        c_size_mult = (SDCardInfo.CSD[9] & 0x03)<<1;    //CSD[09] -> [55:48]
589
                        c_size_mult |=(SDCardInfo.CSD[10] & 0x80)>>7;   //CSD[10] -> [47:40]
586
                        c_size_mult |=(SDCardInfo.CSD[10] & 0x80)>>7;   //CSD[10] -> [47:40]
590
                        SDCardInfo.Capacity = (u32)(c_size+1)*(1L<<(c_size_mult+2))*(1L<<read_bl_len);
587
                        SDCardInfo.Capacity = (u32)(c_size+1)*(1L<<(c_size_mult+2))*(1L<<read_bl_len);
591
                        break;
588
                        break;
592
       
589
       
593
                case 0x01: // if CSD is V2.0 structure (HC SD-Card > 2GB) 
590
                case 0x01: // if CSD is V2.0 structure (HC SD-Card > 2GB) 
594
       
591
       
595
                        /*
592
                        /*
596
                        memory capacity = (C_SIZE+1) * 512K byte
593
                        memory capacity = (C_SIZE+1) * 512K byte
597
                        C_SIZE is 22 bits [69:48] in CSR register
594
                        C_SIZE is 22 bits [69:48] in CSR register
598
                        */
595
                        */
599
       
596
       
600
                        c_size = ((u32)(SDCardInfo.CSD[7] & 0x3F))<<16; //CSD[07] -> [71:64]
597
                        c_size = ((u32)(SDCardInfo.CSD[7] & 0x3F))<<16; //CSD[07] -> [71:64]
601
                        c_size |= ((u32)SDCardInfo.CSD[8])<<8;                  //CSD[08] -> [63:56]
598
                        c_size |= ((u32)SDCardInfo.CSD[8])<<8;                  //CSD[08] -> [63:56]
602
                        c_size |= (u32)SDCardInfo.CSD[9];                               //CSD[09] -> [55:48];
599
                        c_size |= (u32)SDCardInfo.CSD[9];                               //CSD[09] -> [55:48];
603
                        SDCardInfo.Capacity = (c_size + 1)* 512L * 1024L;
600
                        SDCardInfo.Capacity = (c_size + 1)* 512L * 1024L;
604
                        break; 
601
                        break;
-
 
602
       
605
                 default: //unknown CSD Version
603
                default: //unknown CSD Version
606
                        SDCardInfo.Capacity = 0;
604
                        SDCardInfo.Capacity = 0;
607
                        break; 
605
                        break; 
608
                }
606
                }
609
       
607
       
610
                switch(SDCardInfo.Version)
608
                switch(SDCardInfo.Version)
611
                {
609
                {
612
                        case VER_1X:
610
                        case VER_1X:
613
                                SerialPutString("  SD-CARD V1.x");
611
                                SerialPutString("  SD-CARD V1.x");
614
                                break;
612
                                break;
615
                        case VER_20:
613
                        case VER_20:
616
                                SerialPutString("  SD-CARD V2.0 or later");
614
                                SerialPutString("  SD-CARD V2.0 or later");
617
                        default:
615
                        default:
618
                                break;
616
                                break;
619
                }
617
                }
620
                u16 mb_size = (u16)(SDCardInfo.Capacity/(1024L*1024L));
618
                u16 mb_size = (u16)(SDCardInfo.Capacity/(1024L*1024L));
621
                sprintf(text, "\r\n  Capacity = %i MB", mb_size);
619
                sprintf(text, "\r\n  Capacity = %i MB", mb_size);
622
                SerialPutString(text);
620
                SerialPutString(text);
623
       
621
       
624
//              SDC_PrintCID((u8 *)&SDCardInfo.CID);
622
                SDC_PrintCID((u8 *)&SDCardInfo.CID);
625
                SDCardInfo.Valid = 1;
-
 
626
                       
623
                SDCardInfo.Valid = 1;
627
                // jump point for error condition before
624
                // jump point for error condition before
628
                end:
625
                end:
629
                SSC_Disable();
626
                SSC_Disable();
630
        }
627
        }
631
        else
628
        else
632
        {
629
        {
633
                //SerialPutString("\r\nNo Card in Slot.");
-
 
634
                SSC_Deinit();
630
                SSC_Deinit();
635
                SDCardInfo.Valid = 0;
631
                SDCardInfo.Valid = 0;
636
                result = SD_ERROR_NOCARD;
632
                result = SD_ERROR_NOCARD;
-
 
633
                SerialPutString("No Card in Slot.");
637
        }
634
        }
638
//      if(result != SD_SUCCESS)                SerialPutString("nok ");
-
 
639
 
-
 
640
        return(result);
635
        return(result);
641
}
636
}
642
 
637
 
643
 
638
 
644
//________________________________________________________________________________________________________________________________________
639
//________________________________________________________________________________________________________________________________________
645
// Funtion:     SDC_Deinit(void);
640
// Funtion:     SDC_Deinit(void);
646
// 
641
// 
647
// Description: This function deinitialises the SDCard interface. 
642
// Description: This function deinitialises the SDCard interface. 
648
//                              
643
//                              
649
//
644
//
650
// Returnvalue: the function returns 0 if the initialisation was successfull otherwise the function returns an errorcode.
645
// Returnvalue: the function returns 0 if the initialisation was successfull otherwise the function returns an errorcode.
651
//________________________________________________________________________________________________________________________________________
646
//________________________________________________________________________________________________________________________________________
652
 
647
 
653
SD_Result_t SDC_Deinit(void)
648
SD_Result_t SDC_Deinit(void)
654
{
649
{
655
        SerialPutString("SDC deinit...");
650
        SerialPutString("\r\n SDC deinit...");
656
        SSC_Deinit();
651
        SSC_Deinit();
657
 
652
 
658
        SDCardInfo.Valid = 0;
653
        SDCardInfo.Valid = 0;
659
        SDCardInfo.Capacity = 0;
654
        SDCardInfo.Capacity = 0;
660
        SDCardInfo.Version = VER_UNKNOWN;
655
        SDCardInfo.Version = VER_UNKNOWN;
661
 
656
 
662
        SerialPutString("ok\r\n");
657
        SerialPutString("ok");
663
        return(SD_SUCCESS);
658
        return(SD_SUCCESS);
664
}
659
}
665
 
660
 
666
 
661
 
667
//________________________________________________________________________________________________________________________________________
662
//________________________________________________________________________________________________________________________________________
668
// Funtion:     SDC_PutSector(void);
663
// Funtion:     SDC_PutSector(void);
669
// 
664
// 
670
// Description: This function writes one sector of data to the SSC 
665
// Description: This function writes one sector of data to the SSC 
671
//                              
666
//                              
672
//
667
//
673
// Returnvalue: SD_Result_t
668
// Returnvalue: SD_Result_t
674
//________________________________________________________________________________________________________________________________________
669
//________________________________________________________________________________________________________________________________________
675
 
670
 
676
SD_Result_t SDC_PutSector(u32 addr, const u8 *Buffer)
671
SD_Result_t SDC_PutSector(u32 addr, const u8 *Buffer)
677
{
672
{
678
        u8 rsp;
673
        u8 rsp;
-
 
674
        u16 a, crc16;
679
        u16 timeout = 0;
675
        u16 timeout = 0;
680
        u16 a, Crc16;
-
 
681
        //u32 Timeout = 0;
-
 
682
        SD_Result_t result = SD_ERROR_UNKNOWN;
676
        SD_Result_t result = SD_ERROR_UNKNOWN;
683
 
677
 
684
        addr = addr << 9; // convert sectoradress to byteadress
678
        addr = addr << 9; // convert sectoradress to byteadress
685
        rsp = SDC_SendCMDR1(CMD_WRITE_SINGLE_BLOCK, addr);
679
        rsp = SDC_SendCMDR1(CMD_WRITE_SINGLE_BLOCK, addr);
686
        if (rsp != R1_NO_ERR)
680
        if (rsp != R1_NO_ERR)
687
        {
681
        {
688
                result = SD_ERROR_BAD_RESPONSE;
682
                result = SD_ERROR_BAD_RESPONSE;
689
                goto end;
683
                goto end;
690
        }
684
        }
691
        SSC_ClearRxFifo();             
685
        SSC_ClearRxFifo();             
692
        for (a=0;a<20;a++)                                      // at least one byte
686
        for (a=0;a<20;a++)                                      // at least one byte
693
        {
687
        {
694
                SSC_GetChar();
688
                SSC_GetChar();
695
        }
689
        }
696
        Crc16 = CRC16(Buffer, 512);         // calc checksum for data block
690
        crc16 = CRC16(Buffer, 512);         // calc checksum for data block
697
        SSC_PutChar(DATA_START_TOKEN);          // send data start of header to the SSC 
691
        SSC_PutChar(DATA_START_TOKEN);          // send data start of header to the SSC 
698
       
692
       
699
        for (a=0;a<512;a++)                                     // transmit one sector (normaly 512bytes) of data to the sdcard.
693
        for (a=0;a<512;a++)                                     // transmit one sector (normaly 512bytes) of data to the sdcard.
700
        {
694
        {
701
                SSC_PutChar(Buffer[a]);
695
                SSC_PutChar(Buffer[a]);
702
        }
696
        }
703
        // write two bytes of crc16 to the sdcard
697
        // write two bytes of crc16 to the sdcard
704
        SSC_PutChar((u8)(Crc16>>8));            // write high byte first
698
        SSC_PutChar((u8)(crc16>>8));            // write high byte first
705
        SSC_PutChar((u8)(0x00FF&Crc16));        // lowbyte last
699
        SSC_PutChar((u8)(0x00FF&crc16));        // lowbyte last
706
        SSC_ClearRxFifo();
700
        SSC_ClearRxFifo();
707
        do                                                                      // wait for data response token
701
        do                                                                      // wait for data response token
708
        {
702
        {
709
                rsp = SSC_GetChar();
703
                rsp = SSC_GetChar();
710
                if(timeout++>500) break;
704
                if(timeout++ > 500)
-
 
705
                {
-
 
706
                        result = SD_ERROR_TIMEOUT;
-
 
707
                        goto end;
-
 
708
                }
711
        }while((rsp & 0x11) != 0x01 );
709
        }while((rsp & 0x11) != 0x01 );
712
        // analyse data response token
710
        // analyse data response token
713
        switch(rsp & DATA_RESPONSE_MASK)
711
        switch(rsp & DATA_RESPONSE_MASK)
714
        {
712
        {
715
                case DATA_RESPONSE_OK:
713
                case DATA_RESPONSE_OK:
716
                        result = SD_SUCCESS;
714
                        result = SD_SUCCESS;
717
                        break;
715
                        break;
718
                case DATA_RESPONSE_CRC_ERR:
716
                case DATA_RESPONSE_CRC_ERR:
719
                        result = SD_ERROR_CRC_DATA;
717
                        result = SD_ERROR_CRC_DATA;
720
                        goto end;
718
                        goto end;
721
                        break;
719
                        break;
722
                case DATA_RESPONSE_WRITE_ERR:
720
                case DATA_RESPONSE_WRITE_ERR:
723
                        result = SD_ERROR_WRITE_DATA;
721
                        result = SD_ERROR_WRITE_DATA;
724
                        goto end;
722
                        goto end;
725
                        break;
723
                        break;
726
                default:
724
                default:
727
                        result = SD_ERROR_UNKNOWN;
725
                        result = SD_ERROR_UNKNOWN;
728
                        goto end;
726
                        goto end;
729
                        break;
727
                        break;
730
 
728
 
731
        }
729
        }
732
        // wait until the sdcard is busy.
730
        // wait 2 seconds until the sdcard is busy.
733
        rsp = SDC_WaitForBusy();
731
        rsp = SDC_WaitForBusy(2000);
734
        if(rsp != 0xFF)
732
        if(rsp != 0xFF)
735
        {
733
        {
736
                result =  SD_ERROR_TIMEOUT;
734
                result =  SD_ERROR_TIMEOUT;
737
                goto end;
735
                goto end;
738
        }
736
        }
-
 
737
 
739
        // check card status
738
        // check card status
740
        rsp = SDC_SendCMDR1(CMD_SEND_STATUS, 0);
739
        rsp = SDC_SendCMDR1(CMD_SEND_STATUS, 0);
-
 
740
        // first byte of R2 response is like R1 response
741
        if(rsp != R1_NO_ERR)
741
        if(rsp != R1_NO_ERR)
742
        {
742
        {
743
                result =  SD_ERROR_BAD_RESPONSE;
743
                result =  SD_ERROR_BAD_RESPONSE;
744
                SSC_GetChar();
744
                SSC_GetChar(); // read out 2nd byte
745
                goto end;
745
                goto end;
746
        }
746
        }
747
        // 2nd byte of r2 response
747
        // 2nd byte of r2 response
748
        rsp = SSC_GetChar();
748
        rsp = SSC_GetChar();
749
        if(rsp != R2_NO_ERR)
749
        if(rsp != R2_NO_ERR)
750
        {
750
        {
751
                result =  SD_ERROR_WRITE_DATA;
751
                result =  SD_ERROR_WRITE_DATA;
752
                SSC_GetChar();
752
                SSC_GetChar();
753
                goto end;
753
                goto end;
754
        }
754
        }
755
        end:
755
        end:
756
        //SSC_Disable();                                                // disable sdcard.
-
 
757
        if(result != SD_SUCCESS)
756
        if(result != SD_SUCCESS)
758
        {
757
        {
759
                sprintf(text,"Error %02X writing data to sd card (R=%02X).\r\n", result, rsp);
758
                sprintf(text,"Error %02X writing data to sd card (R=%02X).\r\n", result, rsp);
760
                SerialPutString(text);
759
                SerialPutString(text);
761
        }
760
        }
762
        return(result);
761
        return(result);
763
}
762
}
764
 
763
 
765
 
764
 
766
//________________________________________________________________________________________________________________________________________
765
//________________________________________________________________________________________________________________________________________
767
// Funtion:     SDC_GetSector(u32 addr,u8 *Buffer);
766
// Funtion:     SDC_GetSector(u32 addr,u8 *Buffer);
768
// 
767
// 
769
// Description: This function reads one sector of data from the SSC
768
// Description: This function reads one sector of data from the SSC
770
//                              
769
//                              
771
//
770
//
772
// Returnvalue: SD_Result_t
771
// Returnvalue: SD_Result_t
773
//________________________________________________________________________________________________________________________________________
772
//________________________________________________________________________________________________________________________________________
774
 
773
 
775
SD_Result_t SDC_GetSector(u32 addr,u8 *Buffer)
774
SD_Result_t SDC_GetSector(u32 addr,u8 *Buffer)
776
{
775
{
777
        addr = addr << 9; // convert sectoradress to byteadress
776
        addr = addr << 9; // convert sectoradress to byteadress
778
        return SDC_GetData(CMD_READ_SINGLE_BLOCK, addr, Buffer, 512);
777
        return SDC_GetData(CMD_READ_SINGLE_BLOCK, addr, Buffer, 512);
779
}
778
}
780
 
779
 
781
 
780
 
782
 
781
 
783
 
782