00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #include <avr/io.h>
00024 #include <avr/interrupt.h>
00025 #include <stdio.h>
00026 #include <stdlib.h>
00027 #include <string.h>
00028 #include <ctype.h>
00029 #include "global.h"
00030 #include "Xspi.h"
00031 #include "task.h"
00032 #include "MessageQueue.h"
00033 #include "curses.h"
00034 #include "io.h"
00035 #include "cio.h"
00036 #include "utils.h"
00037
00038 #include "Xmmc.h"
00039 #include "ff.h"
00040
00041
00042 #include "mmcconf.h"
00043
00044
00045 void MMCTask(void *arg) __attribute__ ( ( noreturn ) );
00046
00047 MESSAGE_QUEUE *SDcardMSG;
00048 TCB Tmmc;
00049 static WINDOW *mmcW;
00050
00051
00052
00053 void mmcInit(void)
00054 {
00055
00056
00057 XSPI_CLR_CE();
00058 CreateTask(&Tmmc,MMCTask,512,20,"T1tsk",NULL);
00059 Insert(&ActiveTasks,&Tmmc);
00060 SDcardMSG = MqInit(32,"SDCardMsg");
00061 }
00062
00063 int mmcResponse(unsigned char response)
00064 {
00065 unsigned short count = 0xfff;
00066 unsigned char result;
00067 int loop = 1;
00068 while((count > 0) && loop)
00069 {
00070 result = XspiTransferByte(0xff);
00071 if(result == response)
00072 loop = 0;
00073 --count;
00074 }
00075 if(count == 0)
00076 return 1;
00077 else
00078 return 0;
00079 }
00080
00081
00082 u08 mmcReset(void)
00083 {
00084 u16 retry;
00085 u08 r1=0;
00086 int i;
00087 char loop;
00088 char *buff;
00089
00090 buff = malloc(128);
00091
00092
00093
00094 wprintw(mmcW,"Dummy\n");
00095 for(i=0;i<10;++i)
00096 buff[i] = 0xff;
00097 XspiTransfer(buff,i);
00098
00099 XSPI_SET_CE();
00100 wprintw(mmcW,"CE ON\n");
00101 XspiTransferByte(0xff);
00102 i = 0;
00103 buff[i++] = MMC_GO_IDLE_STATE | 0x40;
00104 buff[i++] = 0;
00105 buff[i++] = 0;
00106 buff[i++] = 0;
00107 buff[i++] = 0;
00108 buff[i++] = 0x95;
00109 XspiTransfer(buff,i);
00110
00111 wprintw(mmcW,"Check Resp\n");
00112 if(mmcResponse(0x01) == 1)
00113 {
00114
00115 XSPI_CLR_CE();
00116 wprintw(mmcW,"IDLE ERROR\n");
00117 return 1;
00118 }
00119 loop = 1;
00120 retry = 256;
00121 do
00122 {
00123 i = 0;
00124 buff[i++] = 0xff;
00125 buff[i++] = MMC_APP_CMD | 0x40;
00126 buff[i++] = 0;
00127 buff[i++] = 0;
00128 buff[i++] = 0;
00129 buff[i++] = 0;
00130 buff[i++] = 0x95;
00131 XspiTransfer(buff,i);
00132
00133 if(mmcResponse(0x01) == 1)
00134 {
00135
00136 XSPI_CLR_CE();
00137 wprintw(mmcW,"APP_CMD\n");
00138 return 1;
00139 }
00140
00141 i = 0;
00142 buff[i++] = 0xff;
00143 buff[i++] = MMC_SEND_OP_COND_A | 0x40;
00144 buff[i++] = 0;
00145 buff[i++] = 0;
00146 buff[i++] = 0;
00147 buff[i++] = 0;
00148 buff[i++] = 0x95;
00149 XspiTransfer(buff,i);
00150
00151
00152 if(mmcResponse(0x00) == 0)
00153 {
00154
00155 loop = 0;
00156 }
00157 else
00158 TimeDelay(5);
00159 --retry;
00160 }while(loop && retry);
00161 if(retry == 0) return 1;
00162
00163 i = 0;
00164 buff[i++] = 0xff;
00165 buff[i++] = MMC_SET_BLOCKLEN | 0x40;
00166 buff[i++] = 0;
00167 buff[i++] = 0;
00168 buff[i++] = 2;
00169 buff[i++] = 0;
00170 buff[i++] = 0x95;
00171 XspiTransfer(buff,i);
00172
00173 if(mmcResponse(0x00) == 1)
00174 {
00175
00176 XSPI_CLR_CE();
00177 wprintw(mmcW,"BL ERROR\n");
00178 return 1;
00179 }
00180 XSPI_CLR_CE();
00181 free(buff);
00182 return r1;
00183 }
00184
00185
00186
00187 unsigned short mmcSendStatus(void)
00188 {
00189 union {
00190 unsigned short rV;
00191 unsigned char cV[2];
00192 } R;
00193 char *b = malloc(64);
00194
00195
00196 XSPI_SET_CE();
00197 R.cV[0] = mmcCommand(MMC_SEND_STATUS, 0,b);
00198 R.cV[1] = XspiTransferByte(0xff);
00199
00200 XSPI_CLR_CE();
00201 free(b);
00202 return R.rV;
00203 }
00204
00205 u08 mmcSendCommand(u08 cmd, u32 arg)
00206 {
00207 u08 r1;
00208 char *b = malloc(64);
00209
00210 XSPI_SET_CE();
00211
00212 r1 = mmcCommand(cmd, arg,b);
00213
00214 XSPI_CLR_CE();
00215 free(b);
00216 return r1;
00217 }
00218
00219 u08 mmcRead(u32 sector, u08* buffer)
00220 {
00221 u08 r1;
00222 u16 i;
00223
00224 wprintw(mmcW,"R Sector %ld->%04x\n",sector,(int)buffer);
00225 char *b = malloc(128);
00226
00227 for(i=0;i<10;++i)
00228 b[i] = 0xff;
00229 XspiTransfer(b,i);
00230
00231
00232 XSPI_SET_CE();
00233
00234 r1 = mmcCommand(MMC_READ_SINGLE_BLOCK, sector<<9,b);
00235 #ifdef MMC_DEBUG
00236 rprintf("MMC Read Block R1=0x%x\r\n", r1);
00237 #endif
00238
00239 if(r1) wprintw(mmcW,"R1 = %02x\n",r1 & 0x0ff);
00240 if(r1 != 0x00)
00241 return r1;
00242
00243 while(XspiTransferByte(0xFF) != MMC_STARTBLOCK_READ);
00244
00245 for(i=0; i< 512;++i) buffer[i] = 0xff;
00246 XspiTransfer((char *)buffer,512);
00247
00248
00249
00250
00251
00252
00253
00254 XspiTransferByte(0xFF);
00255 XspiTransferByte(0xFF);
00256
00257 XSPI_CLR_CE();
00258 free(b);
00259
00260 return 0;
00261 }
00262
00263 u08 mmcWrite(u32 sector, u08* buffer)
00264 {
00265 u08 r1;
00266 char *b = malloc(64);
00267
00268 wprintw(mmcW,"W Sector %ld <- %04x\n",sector,buffer);
00269
00270 XSPI_SET_CE();
00271
00272 r1 = mmcCommand(MMC_WRITE_BLOCK, sector<<9,b);
00273 #ifdef MMC_DEBUG
00274 rprintf("MMC Write Block R1=0x%x\r\n", r1);
00275 #endif
00276
00277 if(r1 != 0x00)
00278 return r1;
00279
00280 XspiTransferByte(0xFF);
00281
00282 XspiTransferByte(MMC_STARTBLOCK_WRITE);
00283
00284
00285 XspiTransfer((char *)buffer,512);
00286
00287 XspiTransferByte(0xFF);
00288 XspiTransferByte(0xFF);
00289
00290 r1 = XspiTransferByte(0xFF);
00291 if( (r1&MMC_DR_MASK) != MMC_DR_ACCEPT)
00292 return r1;
00293 #ifdef MMC_DEBUG
00294 rprintf("Data Response Token=0x%x\r\n", r1);
00295 #endif
00296
00297 while(!XspiTransferByte(0xFF));
00298
00299 XSPI_CLR_CE();
00300
00301 free(b);
00302 return 0;
00303 }
00304
00305 u08 mmcCommand(u08 cmd, u32 arg, char *b)
00306 {
00307 u08 r1;
00308 u08 retry=0;
00309
00310 int i;
00311 i = 0;
00312
00313 b[i++] = 0xff;
00314 b[i++] = cmd | 0x40;
00315 b[i++] = arg>>24;
00316 b[i++] = arg>>16;
00317 b[i++] = arg>>8;
00318 b[i++] = arg;
00319 b[i++] = 0x95;
00320 XspiTransfer(b,i);
00321
00322
00323
00324
00325
00326 while((r1 = XspiTransferByte(0xFF)) == 0xFF)
00327 if(retry++ > 8) break;
00328
00329 return r1;
00330 }
00331
00332 void SecDump(int fd, char *b)
00333 {
00334 char *s = malloc(256);
00335 int i,j,l;
00336 unsigned adr=0;
00337
00338 for(j=0;j<512;j+=16)
00339 {
00340 l = 0;
00341 l += UnsignedToHex(adr,&s[l],' ');
00342 for(i=0;i<16;++i)
00343 {
00344 l += CharToHex(b[i+j],&s[l],(i==7)?' ':'-');
00345 }
00346 for(i=0;i<16;++i)
00347 {
00348 if(isprint(b[i+j]))
00349 s[l++] = b[i+j];
00350 else
00351 s[l++] = '.';
00352 }
00353 s[l++] = '\r';
00354 s[l++] = '\n';
00355 _write(fd,s,l);
00356 adr += 16;
00357 }
00358 free(s);
00359 }
00360
00361 void MMCTask(void* arg)
00362 {
00363 WINDOW *win;
00364 unsigned char v;
00365 MSG *msg;
00366 char *b;
00367 int i;
00368 unsigned short uS;
00369 unsigned int uI;
00370 unsigned long *pL;
00371 unsigned short *pU;
00372 int fd;
00373 unsigned char *sbuff;
00374
00375 extern void wHexDump(WINDOW *w,char *b,int n);
00376 extern void HexDump(int ,char *,int);
00377 FIL *FileObj;
00378 FATFS *FSYS;
00379
00380
00381 win = newwin(16,30,16,30,NULL,FG(YELLOW) | BG(BLUE),WIN_BOXED);
00382 scrollok(win,1);
00383 mmcW = win;
00384 WinSetTitle(win, "SD CARD");
00385 b = malloc(64);
00386 sbuff = malloc(512);
00387 v = 1;
00388
00389 fd = _open("COM1",CIO_WRITE_ONLY | CIO_READ_ONLY);
00390
00391
00392
00393 while(1)
00394 {
00395 msg = MqGet(SDcardMSG);
00396 switch(msg->MsgCmd)
00397 {
00398 case MMC_CMD_RESET:
00399 wprintw(win,"MMC Init\n");
00400 v = mmcReset();
00401 wprintw(win,"MMC Init Result = %x\n",v);
00402 break;
00403 case MMC_CMD_RDSECTOR:
00404 pL = (unsigned long *)msg->Payload;
00405 for(i=0;i<512;++i) sbuff[i] = 0xcd;
00406 v = mmcRead(*pL,sbuff);
00407 wprintw(win,"Read Sector %ld %02x\n",*pL,v & 0x0ff);
00408 i = sprintf(b,"-----SECTOR %lu------- %02x\r\n",*pL,v);
00409 _write(fd,b,i);
00410 SecDump(fd,(char *)sbuff);
00411 break;
00412 case MMC_CMD_WDSECTOR:
00413 pL = (unsigned long *)msg->Payload;
00414 pU = (unsigned short *)&msg->Payload[sizeof(unsigned long)];
00415 wprintw(win,"Write Sector %lu %u\n",*pL,*pU);
00416 HexDump(fd,msg->Payload,64);
00417 memset(sbuff,0,512);
00418 memcpy(sbuff,&msg->Payload[sizeof(unsigned long)+sizeof(unsigned short)],*pU);
00419 mmcWrite(*pL, sbuff);
00420 break;
00421 case MMC_CMD_STATUS:
00422 uS = mmcSendStatus();
00423 wprintw(win,"Status = %04x\n",uS);
00424 break;
00425 case MMC_CMD_WRITE_FILE:
00426 FileObj = (FIL *)malloc(sizeof(FIL));
00427 FSYS = (FATFS *)malloc(sizeof(FATFS));
00428 if(f_mount(1,FSYS) != 0) wprintw(win,"Mount Error\n");
00429 if(f_open(FileObj,"1:test1.txt",FA_WRITE | FA_CREATE_NEW) == 0)
00430 {
00431 sprintf((char *)sbuff,"This is a TEST\r\n");
00432 for(i=0;i<50;++i)
00433 {
00434 f_write(FileObj,sbuff,strlen((char *)sbuff),&uI);
00435 }
00436 f_sync(FileObj);
00437 f_close(FileObj);
00438 wprintw(win,"DONE\n");
00439 }
00440 else
00441 {
00442 wprintw(win,"Error\n");
00443 }
00444 break;
00445 }
00446 DeleteMSG(msg);
00447 }
00448 }
00449
00450 void MsgMMCReset(void)
00451 {
00452 MSG *msg;
00453
00454 msg = NewMSG(0);
00455 msg->MsgCmd = MMC_CMD_RESET;
00456 MqPut(SDcardMSG,msg);
00457 }
00458
00459 void MsgMMCReadSector(unsigned long sector)
00460 {
00461 MSG *msg;
00462 unsigned long *pL;
00463
00464 msg = NewMSG(sizeof(unsigned long));
00465 msg->MsgCmd = MMC_CMD_RDSECTOR;
00466 pL = (unsigned long *)msg->Payload;
00467 *pL = sector;
00468 MqPut(SDcardMSG,msg);
00469 }
00470
00471 void MsgMMCWriteSector(unsigned long sector,char *b,int n)
00472 {
00473 MSG *msg;
00474 unsigned long *pL;
00475 unsigned short *pU;
00476
00477 msg = NewMSG(n+sizeof(unsigned long)+sizeof(unsigned short));
00478 msg->MsgCmd = MMC_CMD_WDSECTOR;
00479 memcpy(&msg->Payload[sizeof(unsigned long)+sizeof(unsigned short)],b,n );
00480 pL = (unsigned long *)msg->Payload;
00481 pU = (unsigned short *)&msg->Payload[sizeof(unsigned long)];
00482 *pL = sector;
00483 *pU = n;
00484 MqPut(SDcardMSG,msg);
00485 }
00486
00487 void MsgMMCSendStatus(void)
00488 {
00489 MSG *msg;
00490
00491 msg = NewMSG(0);
00492 msg->MsgCmd = MMC_CMD_STATUS;
00493 MqPut(SDcardMSG,msg);
00494 }
00495
00496 void MsgMMCWriteTestFile(void)
00497 {
00498 MSG *msg;
00499
00500 msg = NewMSG(0);
00501 msg->MsgCmd = MMC_CMD_WRITE_FILE;
00502 MqPut(SDcardMSG,msg);
00503 }
00504
00505