00001
00002
00003
00004
00005
00006
00007
00008
00009
00015
00016 #include "sceptre.h"
00017 #include "sdcard_driver.h"
00018 #include "ssp.h"
00019 #include "rdcf2.h"
00020
00021
00022 #define SDCARD_POWER_BIT (16)
00023 #define SDCARD_WRITE_PROTECT_BIT (24)
00024 #define SDCARD_DETECT_BIT (25)
00025 #define SDCARD_CS_BIT (20)
00026
00027
00028
00029
00030
00031 #define sdcard_status_idle (1<<0) // in IDLE state and initializing process.
00032 #define sdcard_status_erase_reset (1<<1) // erase sequence aborted.
00033 #define sdcard_status_illegal_cmd (1<<2) // illegal command was sent.
00034 #define sdcard_status_error_crc (1<<3) // bad CRC in last command.
00035 #define sdcard_status_erase_seq_err (1<<4) // error in sequence of erase commands.
00036 #define sdcard_status_addr_error (1<<5) // address did not match block length.
00037 #define sdcard_status_param_error (1<<6) // illegal argument used in command.
00038 #define sdcard_status_data_accepted 0x5 // write command is ok to go.
00039 #define sdcard_status_data_crc_error 0xb // crc error on data block.
00040 #define sdcard_status_data_write_error 0xd // write error on media (?).
00041
00042
00043 #define SDCARD_CMD0 0x40 // software reset
00044 #define SDCARD_CMD1 0x41 // brings card out of idle state
00045 #define SDCARD_CMD13 0x4d // read status word of card.
00046 #define SDCARD_CMD16 0x50 // sets the block length used by the memory card
00047 #define SDCARD_CMD17 0x51 // read single block
00048 #define SDCARD_CMD24 0x58 // writes a single block
00049
00050 #define SDCARD_MAX_CMD 8
00051 uint8_t sdcard_cmd[SDCARD_MAX_CMD];
00052
00053 uint8_t sdcard_cmd_reset[] = { 0x40, 0x00, 0x00, 0x00, 0x00, 0x95 };
00054 uint8_t sdcard_cmd_init[] = { 0x41, 0x00, 0x00, 0x00, 0x00, 0xff };
00055 uint8_t sdcard_cmd_set_block[] = { SDCARD_CMD16, 0, 0, 2, 0, 0xff };
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068 void sdcard_hardware_init(void)
00069 {
00070 IODIR1 |= (1<<SDCARD_POWER_BIT);
00071 IODIR1 &= ~(1<<SDCARD_WRITE_PROTECT_BIT);
00072 IODIR1 &= ~(1<<SDCARD_DETECT_BIT);
00073 }
00074
00075
00076 void sdcard_power(uint8_t power)
00077 {
00078 if (power==SDCARD_POWER_ON) IOCLR1 = (1<<SDCARD_POWER_BIT);
00079 else IOSET1 = (1<<SDCARD_POWER_BIT);
00080 }
00081
00082
00083 bool_t sdcard_detect(void)
00084 {
00085 return (IOPIN1&(1<<SDCARD_DETECT_BIT))==0? true : false;
00086 }
00087
00088
00089 bool_t sdcard_write_protected(void)
00090 {
00091 return (IOPIN1&(1<<SDCARD_WRITE_PROTECT_BIT))==0? false : true;
00092 }
00093
00094
00095 void sdcard_select(void)
00096 {
00097
00098 IOCLR0 = (1<<SDCARD_CS_BIT);
00099 }
00100
00101
00102 void sdcard_unselect(void)
00103 {
00104
00105 IOSET0 = (1<<SDCARD_CS_BIT);
00106 }
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118 bool_t sdcard_status(uint8_t response)
00119 {
00120 int count = 4000;
00121 uint8_t result = ~response;
00122 while (result!=response && --count>0) result = ssp_get_byte();
00123 return (count!=0);
00124 }
00125
00126
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136 bool_t sdcard_initialise(void)
00137 {
00138 unsigned int count;
00139 bool_t result;
00140
00141 sdcard_unselect();
00142 for (count=0; count<10; count++)
00143 {
00144 ssp_put_byte(0xFF);
00145 }
00146
00147 sdcard_select();
00148 ssp_send(sdcard_cmd_reset,6);
00149 if (sdcard_status(sdcard_status_idle)==false)
00150 {
00151 sdcard_unselect();
00152 ssp_get_byte();
00153 return false;
00154 }
00155
00156 count = 255;
00157 do
00158 {
00159 ssp_send(sdcard_cmd_init,6);
00160 count--;
00161 }
00162 while ((!sdcard_status(0x00)) && (count>0));
00163 sdcard_unselect();
00164 ssp_get_byte();
00165 if (count==0) return false;
00166
00167 sdcard_select();
00168 ssp_send(sdcard_cmd_set_block,6);
00169 result = sdcard_status(0x00);
00170 sdcard_unselect();
00171 ssp_get_byte();
00172
00173 return result;
00174 }
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185
00186
00187 bool_t sdcard_read_block(long sector, uint8_t *p_data)
00188 {
00189 sector <<= 1;
00190 sdcard_select();
00191 sdcard_cmd[0] = SDCARD_CMD17;
00192 sdcard_cmd[1] = (sector>>16) & 0xff;
00193 sdcard_cmd[2] = (sector>>8) & 0xff;
00194 sdcard_cmd[3] = sector & 0xff;
00195 sdcard_cmd[4] = 0;
00196 sdcard_cmd[5] = 0xff;
00197 ssp_send(sdcard_cmd,6);
00198 if (sdcard_status(0x00))
00199 {
00200
00201 if (sdcard_status(0xfe))
00202 {
00203 ssp_read(p_data,RDCF_SECTOR_SIZE);
00204
00205 ssp_get_byte();
00206 ssp_get_byte();
00207 }
00208 else
00209 {
00210 sdcard_unselect();
00211 ssp_get_byte();
00212 return true;
00213 }
00214 }
00215 else
00216 {
00217 sdcard_unselect();
00218 ssp_get_byte();
00219 return true;
00220 }
00221 sdcard_unselect();
00222 ssp_get_byte();
00223 return false;
00224 }
00225
00226
00227
00228
00229
00230
00231
00232
00233
00234 uint8_t sdcard_get_write_result (void)
00235 {
00236 int count = 60000l;
00237 uint8_t result = 0;
00238 while (result==0 && --count)
00239 {
00240 result = ssp_get_byte();
00241 }
00242 return result;
00243 }
00244
00245
00246
00247
00248
00249
00250
00251
00252
00253
00254
00255
00256
00257
00258 bool_t sdcard_write_block(long sector, const uint8_t *p_data)
00259 {
00260 int result = 0;
00261 sector <<= 1;
00262 sdcard_select();
00263 sdcard_cmd[0] = SDCARD_CMD24;
00264 sdcard_cmd[1] = (sector>>16) & 0xff;
00265 sdcard_cmd[2] = (sector>>8) & 0xff;
00266 sdcard_cmd[3] = sector & 0xff;
00267 sdcard_cmd[4] = 0;
00268 sdcard_cmd[5] = 0xff;
00269 ssp_send (sdcard_cmd, 6);
00270
00271 if (sdcard_status(0x00))
00272 {
00273
00274 ssp_put_byte(0xfe);
00275 ssp_send(p_data,RDCF_SECTOR_SIZE);
00276
00277 ssp_put_byte(0xff);
00278 ssp_put_byte(0xff);
00279
00280 result = ssp_get_byte();
00281 if ((result&0xf)!=sdcard_status_data_accepted)
00282 {
00283
00284 sdcard_unselect();
00285 ssp_get_byte();
00286 return true;
00287 }
00288 }
00289 else
00290 {
00291
00292 sdcard_unselect();
00293 ssp_get_byte();
00294 return true;
00295 }
00296
00297
00298
00299 result = sdcard_get_write_result();
00300
00301
00302 sdcard_unselect();
00303 ssp_get_byte();
00304 return false;
00305 }
00306