diskio.c

   1 /*
   2         diskio.c -- glue interface to ElmChan FAT FS driver. Part of the
   3         BootMii project.
   4
   5 Copyright (C) 2008, 2009        Haxx Enterprises <bushing@gmail.com>
   6 Copyright (C) 2008, 2009        Sven Peter <svenpeter@gmail.com>
   7
   8 # This code is licensed to you under the terms of the GNU GPL, version 2;
   9 # see file COPYING or http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
  10 */
  11
  12 #include "bootmii_ppc.h"
  13 #include "ipc.h"
  14 #include "mini_ipc.h"
  15 #include "diskio.h"
  16 #include "string.h"
  17
  18 static u8 *buffer[512] __attribute__((aligned(32)));
  19
  20 DSTATUS disk_initialize (BYTE drv)
  21 {
  22         (void) drv;
  23
  24         int state = sd_get_state();
  25
  26         switch (state) {
  27         case SDMMC_NO_CARD:
  28                 return STA_NODISK;
  29
  30         case SDMMC_NEW_CARD:
  31                 if (sd_mount())
  32                         return STA_NOINIT;
  33                 else
  34                         return 0;
  35
  36         default:
  37                 return 0;
  38         }
  39 }
  40
  41 DSTATUS disk_status (BYTE drv)
  42 {
  43         (void) drv;
  44
  45         int state = sd_get_state();
  46
  47         switch (state) {
  48         case SDMMC_NO_CARD:
  49                 return STA_NODISK;
  50
  51         case SDMMC_NEW_CARD:
  52                 return STA_NOINIT;
  53
  54         default:
  55                 return 0;
  56         }
  57 }
  58
  59 DRESULT disk_read (BYTE drv, BYTE *buff, DWORD sector, u32 count)
  60 {
  61         u32 i;
  62         DRESULT res;
  63         (void) drv;
  64
  65         if (count > 1 && ((u32) buff % 64) == 0) {
  66                 if (sd_read(sector, count, buff) != 0)
  67                         return RES_ERROR;
  68                 return RES_OK;
  69         }
  70
  71         res = RES_OK;
  72         for (i = 0; i < count; i++) {
  73                 if (sd_read(sector + i, 1, buffer) != 0) {
  74                         res = RES_ERROR;
  75                         break;
  76                 }
  77
  78                 memcpy(buff + i * 512, buffer, 512);
  79         }
  80
  81         return res;
  82 }
  83
  84 #if _READONLY == 0
  85 DRESULT disk_write (BYTE drv, const BYTE *buff, DWORD sector, u32 count)
  86 {
  87         u32 i;
  88         DRESULT res;
  89         (void) drv;
  90
  91         res = RES_OK;
  92         if (count > 1 && ((u32) buff % 64) == 0) {
  93                 if (sd_write(sector, count, buff) != 0)
  94                         return RES_ERROR;
  95                 return RES_OK;
  96         }
  97
  98         for (i = 0; i < count; i++) {
  99                 memcpy(buffer, buff + i * 512, 512);
 100                 if (sd_write(sector + i, 1, buffer) != 0) {
 101                         res = RES_ERROR;
 102                         break;
 103                 }
 104         }
 105
 106         return res;
 107 }
 108 #endif /* _READONLY */
 109
 110 DRESULT disk_ioctl (BYTE drv, BYTE ctrl, void *buff)
 111 {
 112         (void) drv;
 113         u32 *buff_u32 = (u32 *) buff;
 114         DRESULT res = RES_OK;
 115
 116         switch (ctrl) {
 117         case CTRL_SYNC:
 118                 break;
 119         case GET_SECTOR_COUNT:
 120                 *buff_u32 = sd_getsize();
 121                 break;
 122         case GET_SECTOR_SIZE:
 123                 *buff_u32 = 512;
 124                 break;
 125         case GET_BLOCK_SIZE:
 126                 *buff_u32 = 512;
 127                 break;
 128         default:
 129                 res = RES_PARERR;
 130                 break;
 131         }
 132
 133         return res;
 134 }
 135
 136 DWORD get_fattime(void)
 137 {
 138         return 0; // TODO
 139 }