bertos/emul/diskio_emul.c

   1 /**
   2  * \file
   3  * <!--
   4  * This file is part of BeRTOS.
   5  *
   6  * Bertos is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  *
  20  * As a special exception, you may use this file as part of a free software
  21  * library without restriction.  Specifically, if other files instantiate
  22  * templates or use macros or inline functions from this file, or you compile
  23  * this file and link it with other files to produce an executable, this
  24  * file does not by itself cause the resulting executable to be covered by
  25  * the GNU General Public License.  This exception does not however
  26  * invalidate any other reasons why the executable file might be covered by
  27  * the GNU General Public License.
  28  *
  29  * Copyright 2009 Develer S.r.l. (http://www.develer.com/)
  30  *
  31  * -->
  32  *
  33  * \brief Low level disk access for FatFs emulated.
  34  *
  35  * \version $Id$
  36  * \author Luca Ottaviano <lottaviano@develer.com>
  37  */
  38
  39 /*-----------------------------------------------------------------------*/
  40 /* Low level disk I/O module skeleton for FatFs     (C)ChaN, 2007        */
  41 /*-----------------------------------------------------------------------*/
  42
  43 #include <fs/fatfs/src/diskio.h>
  44 #include <stdio.h>
  45 #include <errno.h>
  46 #include <time.h>
  47
  48 #define SECTOR_SIZE 512
  49
  50 static volatile DSTATUS Stat = STA_NOINIT;
  51
  52 /**
  53  * This is an example implementation, used to simulate the the calls to normal filesystem calls
  54  * It only works for drive 0.
  55  */
  56
  57
  58 /*-----------------------------------------------------------------------*/
  59 /* Inidialize a Drive                                                    */
  60
  61 static FILE *fake_disk = 0;
  62
  63 DSTATUS disk_initialize (
  64         BYTE drv                                /* Physical drive nmuber (0..) */
  65 )
  66 {
  67         if (drv)
  68                 return STA_NOINIT; /* Support only drive 0 */
  69         // XXX: pay attention here: some functions call disk_initialize *after* it has
  70         //  been initialized for the first time.
  71         //  Here we just return the status (that should always be ~STA_NOINIT after the first
  72         //  call)
  73         if (fake_disk)
  74                 return Stat;
  75
  76         const char *path = "emuldisk.dsk";
  77         fake_disk = fopen(path, "w+");
  78         int err = errno;
  79         if (!fake_disk)
  80         {
  81                 switch (err)
  82                 {
  83                 case EINVAL:
  84                         fprintf(stderr, "invalid mode\n");
  85                 default:
  86                         return STA_NOINIT;
  87                 }
  88         }
  89         Stat &= ~STA_NOINIT;
  90         return Stat;
  91 }
  92
  93
  94
  95 /*-----------------------------------------------------------------------*/
  96 /* Return Disk Status                                                    */
  97
  98 DSTATUS disk_status (
  99         BYTE drv                /* Physical drive nmuber (0..) */
 100 )
 101 {
 102         if (drv)
 103                 return STA_NOINIT; /* Support only drive 0 */
 104         return Stat;
 105 }
 106
 107
 108
 109 /*-----------------------------------------------------------------------*/
 110 /* Read Sector(s)                                                        */
 111
 112 DRESULT disk_read (
 113         BYTE drv,               /* Physical drive nmuber (0..) */
 114         BYTE *buff,             /* Data buffer to store read data */
 115         DWORD sector,   /* Sector address (LBA) */
 116         BYTE count              /* Number of sectors to read (1..255) */
 117 )
 118 {
 119         if (drv || !count) return RES_PARERR;
 120         if (Stat & STA_NOINIT) return RES_NOTRDY;
 121
 122         fseek(fake_disk, sector * SECTOR_SIZE, SEEK_SET);
 123         size_t read_items = fread(buff, SECTOR_SIZE, count, fake_disk);
 124         if (read_items == count)
 125                 return RES_OK;
 126         else
 127         {
 128                 if (feof(fake_disk))
 129                         fprintf(stderr, "end-of-file\n");
 130                 if (ferror(fake_disk))
 131                         fprintf(stderr, "error\n");
 132                 return RES_ERROR;
 133         }
 134 }
 135
 136
 137 /*-----------------------------------------------------------------------*/
 138 /* Write Sector(s)                                                       */
 139
 140 #if _READONLY == 0
 141 DRESULT disk_write (
 142         BYTE drv,                       /* Physical drive nmuber (0..) */
 143         const BYTE *buff,       /* Data to be written */
 144         DWORD sector,           /* Sector address (LBA) */
 145         BYTE count                      /* Number of sectors to write (1..255) */
 146 )
 147 {
 148         if (drv || !count) return RES_PARERR;
 149         if (Stat & STA_NOINIT) return RES_NOTRDY;
 150         if (Stat & STA_PROTECT) return RES_WRPRT;
 151
 152         fseek(fake_disk, sector * SECTOR_SIZE, SEEK_SET);
 153         size_t write_items = fwrite(buff, SECTOR_SIZE, count, fake_disk);
 154         if (write_items == count)
 155                 return RES_OK;
 156         else
 157         {
 158                 if (feof(fake_disk))
 159                         fprintf(stderr, "end-of-file\n");
 160                 if (ferror(fake_disk))
 161                         fprintf(stderr, "error\n");
 162                 return RES_ERROR;
 163         }
 164 }
 165 #endif /* _READONLY */
 166
 167
 168
 169 /*-----------------------------------------------------------------------*/
 170 /* Miscellaneous Functions                                               */
 171
 172 DRESULT disk_ioctl (
 173         BYTE drv,               /* Physical drive nmuber (0..) */
 174         BYTE ctrl,              /* Control code */
 175         void *buff              /* Buffer to send/receive control data */
 176 )
 177 {
 178         if (drv) return RES_PARERR;
 179         if (Stat & STA_NOINIT) return RES_NOTRDY;
 180
 181         switch (ctrl)
 182         {
 183         case GET_SECTOR_SIZE:
 184                 *(WORD*)buff = SECTOR_SIZE;
 185                 break;
 186         case GET_SECTOR_COUNT:
 187                 *(DWORD*)buff = 65536;
 188                 break;
 189         case GET_BLOCK_SIZE:
 190                 *(DWORD*)buff = 1;
 191                 break;
 192         case CTRL_SYNC:
 193                 fflush(fake_disk);
 194                 break;
 195         default:
 196                 return RES_PARERR;
 197         }
 198         return RES_OK;
 199 }
 200
 201 DWORD get_fattime(void)
 202 {
 203         time_t tmp = time(0);
 204         struct tm *t = localtime(&tmp);
 205         DWORD tim = 0;
 206         // seconds
 207         tim |= (t->tm_sec / 2);
 208         // min
 209         tim |= (t->tm_min << 5);
 210         // hour
 211         tim |= (t->tm_hour << 11);
 212         // month day (1..31)
 213         tim |= (t->tm_mday << 16);
 214         // month (1..12)
 215         tim |= ((t->tm_mon + 1) << 21);
 216         // year (0..127)
 217         tim |= ((t->tm_year - 80) << 25);
 218         return tim;
 219 }
 220