Ignore:
Timestamp:
Jun 20, 2018, 7:59:22 PM (6 years ago)
Author:
coas-nagasima
Message:

SDカードの挿抜を検知するよう更新
他

File:
1 edited

Legend:

Unmodified
Added
Removed

  • asp3_tinet_ecnl_arm/trunk/ntshell/fatfs/ffarch.c

    r352 r359  
    5353#include "util/ntstdio.h"
    5454
    55 //extern ntstdio_t ntstdio;
     55extern ntstdio_t ntstdio;
     56
     57enum ffarch_state_t {
     58        FFS_IDLE,
     59        FFS_RETRY_WAIT,
     60};
     61
     62enum ffarch_state_t ffarch_state;
     63volatile int ffarch_timer;
     64int ffarch_retry_count;
     65uint8_t sdfs_new_status, sdfs_prev_status;
     66
     67static void ffarch_initialize();
     68
     69/*
     70 * FatFSタスク
     71 */
     72void ffarch_task(intptr_t exinf)
     73{
     74        ER ret, ret2;
     75        SYSTIM prev, now;
     76        int timer;
     77
     78        ffarch_initialize();
     79
     80        ret2 = get_tim(&now);
     81        if (ret2 != E_OK){
     82                ntstdio_printf(&ntstdio, "[ffarch] get_tim error: %s",
     83                        itron_strerror(ret2));
     84                return;
     85        }
     86
     87        for(;;){
     88                prev = now;
     89
     90                /* タイマー取得 */
     91                timer = ffarch_get_timer();
     92
     93                /* 待ち */
     94                ret = tslp_tsk(timer);
     95                if ((ret != E_OK) && (ret != E_TMOUT)) {
     96                        ntstdio_printf(&ntstdio, "[ffarch] tslp_tsk error: %s %d",
     97                                itron_strerror(ret), timer);
     98                        break;
     99                }
     100
     101                ret2 = get_tim(&now);
     102                if (ret2 != E_OK) {
     103                        ntstdio_printf(&ntstdio, "[ffarch] get_tim error: %s",
     104                                itron_strerror(ret2));
     105                        break;
     106                }
     107
     108                /* 時間経過 */
     109                int elapse = now - prev;
     110                ffarch_progress(elapse);
     111
     112                /* タイムアウト処理 */
     113                ffarch_timeout();
     114        }
     115}
    56116
    57117FATFS RomDisk;
    … …  
    71131bool_t SD_begin();
    72132
    73 int ffarch_init()
    74 {
    75         int result = -1;
    76 
     133void ffarch_init()
     134{
    77135        /* SD_CD */
    78136        gpio_init_in(&ins, P7_8);
    … …  
    81139        sdfs_init(&sdfs, P8_5, P8_6, P8_3, P8_4, "sd");
    82140
    83         result = SD_begin() ? 0 : -1;
    84         if (result == 0) {
    85                 printf("SD card (1:) OK!\n");
     141        ffarch_state = FFS_IDLE;
     142        ffarch_timer = 0;
     143        ffarch_retry_count = 3;
     144        sdfs_new_status = 0;
     145        sdfs_prev_status = STA_NODISK;
     146
     147        ffarch_timeout();
     148
     149        act_tsk(FFARCH_TASK);
     150
     151        if (romdisk_init()) {
     152                ntstdio_printf(&ntstdio, "ROM disk (0:) OK!\n");
    86153        }
    87154        else {
    88                 printf("SD card (1:) NG!\n");
    89         }
     155                ntstdio_printf(&ntstdio, "ROM disk (0:) NG!\n");
     156        }
     157
     158        serial_ctl_por(SIO_PORTID, IOCTL_FCSND | IOCTL_FCRCV);
     159}
     160
     161void ffarch_initialize()
     162{
    90163        sta_cyc(SDFS_CYC);
    91 
    92         if (romdisk_init())
    93                 result = 0;
    94 
    95         if (result == 0) {
    96                 printf("ROM disk (0:) OK!\n");
    97         }
    98         else {
    99                 printf("ROM disk (0:) NG!\n");
    100         }
    101 
    102         /* uploadディレクトリを作成しておく */
    103         f_mkdir("1:/upload");
    104 
    105         serial_ctl_por(SIO_PORTID, IOCTL_FCSND | IOCTL_FCRCV);
    106 
    107         return result;
    108164}
    109165
    … …  
    173229                return ramdisk_get_status();
    174230        case 1:
    175                 return sdfs_status(&sdfs);
     231                return sdfs._is_initialized;
    176232        }
    177233        return STA_NOINIT;
    … …  
    200256}
    201257
     258DRESULT sdfs_ioctl(BYTE ctrl, void *buff);
     259
    202260DRESULT disk_ioctl(BYTE pdrv, BYTE cmd, void *buff)
    203261{
    … …  
    206264                return RES_PARERR; /* ramdisk_ioctl(cmd, buff); */
    207265        case 1:
    208                 switch(cmd) {
    209                 case CTRL_SYNC:
    210                         return sdfs_sync(&sdfs);
    211                 case GET_SECTOR_COUNT:
    212                         return sdfs_sectors(&sdfs);
    213                 case GET_BLOCK_SIZE:
    214                         *((DWORD*)buff) = 1; // default when not known
    215                         return RES_OK;
    216                 }
     266                return sdfs_ioctl(cmd, buff);
    217267        }
    218268        return RES_PARERR;
    219269}
    220270
     271DRESULT sdfs_ioctl(BYTE ctrl, void *buff)
     272{
     273        DRESULT res;
     274        uint32_t *dp = (uint32_t *)buff, st, ed;
     275        uint8_t *ptr = (uint8_t *)buff;
     276
     277        if (sdfs._is_initialized & STA_NOINIT)
     278                return RES_NOTRDY;
     279
     280        res = RES_ERROR;
     281
     282        switch (ctrl) {
     283        case CTRL_SYNC:
     284                if (sdfs_sync(&sdfs) == 0) {
     285                        res = RES_OK;
     286                }
     287                break;
     288        case GET_SECTOR_SIZE:
     289                *(WORD*)buff = 512;
     290                res = RES_OK;
     291                break;
     292        case GET_SECTOR_COUNT:
     293                *(DWORD*)buff = sdfs._capacity / 512;
     294                res = RES_OK;
     295                break;
     296        case GET_BLOCK_SIZE:
     297                *(DWORD*)buff = sdfs._block_len;
     298                res = RES_OK;
     299                break;
     300        case CTRL_TRIM:
     301                res = sdfs_trim(&sdfs, dp[0], dp[1]);
     302                break;
     303        case MMC_GET_TYPE:
     304                *ptr = sdfs._card_type;
     305                res = RES_OK;
     306                break;
     307        case MMC_GET_CSD:
     308                memcpy(ptr, sdfs._csd, sizeof(sdfs._csd));
     309                res = RES_OK;
     310                break;
     311        case MMC_GET_CID:
     312                memcpy(ptr, sdfs._cid, sizeof(sdfs._cid));
     313                res = RES_OK;
     314                break;
     315        case MMC_GET_OCR:
     316                if (sdfs_get_ocr(&sdfs, buff) == 0) {
     317                        res = RES_OK;
     318                }
     319                break;
     320        case MMC_GET_SDSTAT:
     321                if (sdfs_get_sdstat(&sdfs, buff) == 0) {
     322                        res = RES_OK;
     323                }
     324                break;
     325        default:
     326                res = RES_PARERR;
     327        }
     328
     329        return res;
     330}
     331
    221332void sdfs_cychdr(intptr_t exinf)
    222333{
    223         BYTE s;
    224 
    225         s = sdfs._is_initialized;
    226         if (WP())               /* Write protected */
     334        BYTE s = 0;
     335             
     336        /* Write protected */
     337        if (WP())
    227338                s |= STA_PROTECT;
    228         else            /* Write enabled */
     339        else
    229340                s &= ~STA_PROTECT;
    230         if (gpio_read(&ins))    /* Card is in socket */
     341
     342        /* Card is in socket */
     343        if (gpio_read(&ins))
     344                s |= (STA_NODISK | STA_NOINIT);
     345        else
    231346                s &= ~STA_NODISK;
    232         else            /* Socket empty */
    233                 s |= (STA_NODISK | STA_NOINIT);
    234         sdfs._is_initialized = s;
     347
     348        sdfs_new_status = s;
     349
     350        if ((sdfs_prev_status != sdfs_new_status) && (ffarch_state == FFS_IDLE)) {
     351                ffarch_timer = 0;
     352                wup_tsk(FFARCH_TASK);
     353        }
     354}
     355
     356int ffarch_get_timer()
     357{
     358        return ffarch_timer;
     359}
     360
     361void ffarch_progress(int elapse)
     362{
     363        if (ffarch_timer != TMO_FEVR) {
     364                ffarch_timer -= elapse;
     365                if (ffarch_timer < 0) {
     366                        ffarch_timer = 0;
     367                }
     368        }
     369}
     370
     371void ffarch_timeout()
     372{
     373        if (ffarch_timer != 0)
     374                return;
     375
     376        switch (ffarch_state) {
     377        case FFS_RETRY_WAIT:
     378                if (ffarch_retry_count == 0) {
     379                        ntstdio_printf(&ntstdio, "SD card (1:) initialize tired...\n");
     380
     381                        ffarch_state = FFS_IDLE;
     382                        ffarch_timer = TMO_FEVR;
     383                        ffarch_retry_count = 3;
     384                        break;
     385                }
     386                ffarch_retry_count--;
     387                //goto case FFS_IDLE;
     388        case FFS_IDLE:
     389                /* SDカードが入れられた場合 */
     390                if ((sdfs._is_initialized & STA_NOINIT)
     391                        || (((sdfs_prev_status & STA_NODISK) != 0) && ((sdfs_new_status & STA_NODISK) == 0))) {
     392                        ntstdio_printf(&ntstdio, "SD card initializing ...\n");
     393
     394                        if (SD_begin()) {
     395                                ntstdio_printf(&ntstdio, "SD card (1:) OK!\n");
     396
     397                                /* uploadディレクトリを作成しておく */
     398                                f_mkdir("1:/upload");
     399
     400                                ffarch_state = FFS_IDLE;
     401                                ffarch_timer = TMO_FEVR;
     402                                ffarch_retry_count = 3;
     403                        }
     404                        else {
     405                                ntstdio_printf(&ntstdio, "SD card (1:) NG!\n");
     406                                ffarch_state = FFS_RETRY_WAIT;
     407                                ffarch_timer = 1000 * 1000;
     408                        }
     409                }
     410                /* SDカードが抜かれた場合 */
     411                else if (((sdfs_prev_status & STA_NODISK) == 0) && ((sdfs_new_status & STA_NODISK) != 0)) {
     412                        ntstdio_printf(&ntstdio, "SD card unmount\n");
     413
     414                        f_mount(&Sd.FatFs, "1:", 0);
     415                        ffarch_state = FFS_IDLE;
     416                        ffarch_timer = TMO_FEVR;
     417                        ffarch_retry_count = 3;
     418                }
     419                if (((sdfs_prev_status ^ sdfs_new_status) & STA_PROTECT) != 0) {
     420                        if ((sdfs_new_status & STA_PROTECT) != 0)
     421                                sdfs._is_initialized |= STA_PROTECT;
     422                        else
     423                                sdfs._is_initialized &= ~STA_PROTECT;
     424                }
     425                sdfs_prev_status = sdfs_new_status;
     426                break;
     427        }
    235428}
    236429
Note: See TracChangeset for help on using the changeset viewer.