wince/ynandif.c

   1 /*\r
   2  * YAFFS: Yet another FFS. A NAND-flash specific file system.\r
   3  * ynandif.c: NAND interface functions for the WinCE port of YAFFS.\r
   4  *\r
   5  * Copyright (C) 2002 Trimble Navigation Ltd.\r
   6  *\r
   7  * Created by Brad Beveridge <brad.beveridge@trimble.co.nz>\r
   8  *\r
   9  * This program is free software; you can redistribute it and/or modify\r
  10  * it under the terms of the GNU General Public License version 2 as\r
  11  * published by the Free Software Foundation.\r
  12  *\r
  13  * This program is distributed in the hope that it will be useful, \r
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of \r
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU \r
  16  * General Public License for more details. You should have received a \r
  17  * copy of the GNU General Public License along with this program; \r
  18  * if not, write to the Free Software Foundation, Inc., \r
  19  * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. \r
  20  *\r
  21  * $Id: ynandif.c,v 1.1 2002-11-08 07:30:00 charles Exp $\r
  22  */\r
  23 #include "ynandif.h"\r
  24 #include <windows.h>\r
  25 \r
  26 HANDLE devHandle = 0;\r
  27 \r
  28 /*\r
  29 *       Functions that need to be provided for YAFFS\r
  30 */\r
  31 int ynandif_WriteChunkToNAND(yaffs_Device *dev, int chunkInNAND,const __u8 *data, yaffs_Spare *spare)\r
  32 {\r
  33         if (devHandle)\r
  34         {\r
  35                 ynandif_data writeData;\r
  36                 int result;\r
  37 \r
  38                 writeData.chunk = chunkInNAND;\r
  39                 writeData.data = (__u8 *)data;\r
  40                 writeData.spare = (char *)spare;\r
  41                 \r
  42                 if (!DeviceIoControl(devHandle,\r
  43                                                      YNANDIF_WRITE,\r
  44                                                      &writeData,\r
  45                                                      sizeof(ynandif_data),\r
  46                                                      &result,\r
  47                                                      sizeof(result),\r
  48                                                      NULL,\r
  49                                                          NULL))\r
  50                         return YAFFS_FAIL;\r
  51 \r
  52                 return result;\r
  53         }\r
  54 \r
  55         return YAFFS_FAIL;\r
  56 }\r
  57 \r
  58 int ynandif_ReadChunkFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_Spare *spare)\r
  59 {\r
  60         if (devHandle)\r
  61         {\r
  62                 ynandif_data readData;\r
  63                 int result;\r
  64 \r
  65                 readData.chunk = chunkInNAND;\r
  66                 readData.data = data;\r
  67                 readData.spare = (char *)spare;\r
  68                 \r
  69                 if (!DeviceIoControl(devHandle,\r
  70                                                      YNANDIF_READ,\r
  71                                                      &readData,\r
  72                                                      sizeof(ynandif_data),\r
  73                                                      &result,\r
  74                                                      sizeof(result),\r
  75                                                      NULL,\r
  76                                                          NULL))\r
  77                         return YAFFS_FAIL;\r
  78 \r
  79                 return result;\r
  80         }\r
  81 \r
  82         return YAFFS_FAIL;\r
  83 }\r
  84 \r
  85 int ynandif_EraseBlockInNAND(yaffs_Device *dev, int blockNumber)\r
  86 {\r
  87         if (devHandle)\r
  88         {\r
  89                 int result;\r
  90                 \r
  91                 if (!DeviceIoControl(devHandle,\r
  92                                                      YNANDIF_ERASE,\r
  93                                                      &blockNumber,\r
  94                                                      sizeof(int),\r
  95                                                      &result,\r
  96                                                      sizeof(result),\r
  97                                                      NULL,\r
  98                                                          NULL))\r
  99                         return YAFFS_FAIL;\r
 100 \r
 101                 return result;\r
 102         }\r
 103 \r
 104 // if we return YAFFS_FAIL, then yaffs will retire this block & mark it bad, not exactly\r
 105 // what we want to do by default.\r
 106         return YAFFS_OK;\r
 107 }\r
 108 \r
 109 int ynandif_InitialiseNAND(yaffs_Device *dev)\r
 110 {\r
 111         RETAILMSG(1, (L"ynandif_InitialiseNAND\r\n"));\r
 112         devHandle = CreateFile(L"YND1:",\r
 113                                                    GENERIC_READ|GENERIC_WRITE,\r
 114                                                    0,\r
 115                                                    NULL,\r
 116                                                    OPEN_EXISTING,\r
 117                                                    0,\r
 118                                                    0);\r
 119 \r
 120         if (!devHandle)\r
 121                 return 0;\r
 122 \r
 123         RETAILMSG(1, (L"devhandle open\r\n"));\r
 124 \r
 125         RETAILMSG(1, (L"DeviceIo INIT\r\n"));\r
 126         if (!DeviceIoControl(devHandle,\r
 127                                                  YNANDIF_INIT,\r
 128                                                  NULL,\r
 129                                                  0,\r
 130                                                  NULL,\r
 131                                                  0,\r
 132                                                  NULL,\r
 133                                                  NULL))\r
 134                 return 0;\r
 135 \r
 136 \r
 137         if (dev)\r
 138         {\r
 139                 int nBlocks = ynandif_GetChipSize(0xFF) / (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK);\r
 140                 dev->startBlock = 1;  // Don't use block 0\r
 141                 dev->endBlock = nBlocks - 1;\r
 142         }\r
 143 \r
 144         return 1;\r
 145 }\r
 146 \r
 147 int ynandif_EraseAllBlocks(yaffs_Device *dev)\r
 148 {\r
 149         int numBlocks, counter;\r
 150         numBlocks = ynandif_GetChipSize(0xFF) / (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK);\r
 151         for (counter = 0; counter < numBlocks; counter++)\r
 152         {\r
 153                 ynandif_EraseBlockInNAND(dev, counter);\r
 154         }\r
 155         return YAFFS_OK;\r
 156 }\r
 157 \r
 158 int ynandif_GetChipSize(unsigned char chipNumber)\r
 159 {\r
 160         int ret = 0;\r
 161         RETAILMSG(1, (L"DeviceIo GETSIZE\r\n"));\r
 162         if (devHandle)\r
 163         {\r
 164                 RETAILMSG(1, (L"DeviceIo GETSIZE - getting ret\r\n"));\r
 165                 DeviceIoControl(devHandle,\r
 166                                         YNANDIF_GETSIZE,\r
 167                                         NULL,\r
 168                                         0,\r
 169                                         &ret,\r
 170                                         sizeof(ret),\r
 171                                         NULL,\r
 172                                         NULL);\r
 173         }\r
 174         RETAILMSG(1, (L"DeviceIo GETSIZE ret %X\r\n", ret));\r
 175 \r
 176 \r
 177 \r
 178         return ret;\r
 179 }\r