KernelLand/Modules/Storage/FDDv2/main.c

   1 /*
   2  * Acess2 82077AA FDC
   3  * - By John Hodge (thePowersGang)
   4  *
   5  * fdc.c
   6  * - Core file
   7  */
   8 #define DEBUG   0
   9 #include <acess.h>
  10 #include <modules.h>
  11 #include <fs_devfs.h>
  12 #include "common.h"
  13 #include <api_drv_disk.h>
  14
  15 // === CONSTANTS ===
  16 #define FDD_VERSION     VER2(1,10)
  17
  18 // === STRUCTURES ===
  19
  20 // === PROTOTYPES ===
  21  int    FDD_Install(char **Arguments);
  22  int    FDD_RegisterFS(void);
  23 // --- VFS
  24 char    *FDD_ReadDir(tVFS_Node *Node, int pos);
  25 tVFS_Node       *FDD_FindDir(tVFS_Node *dirNode, const char *Name);
  26  int    FDD_IOCtl(tVFS_Node *Node, int ID, void *Data);
  27 Uint64  FDD_ReadFS(tVFS_Node *node, Uint64 off, Uint64 len, void *buffer);
  28 // --- Helpers
  29  int    FDD_int_ReadWriteWithinTrack(int Disk, int Track, int bWrite, size_t Offset, size_t Length, void *Buffer);
  30
  31 // === GLOBALS ===
  32 MODULE_DEFINE(0, FDD_VERSION, Storage_FDDv2, FDD_Install, NULL, "x86_ISADMA", NULL);
  33 tDrive  gaFDD_Disks[MAX_DISKS];
  34 tVFS_Node       gaFDD_DiskNodes[MAX_DISKS];
  35 tVFS_NodeType   gFDD_RootNodeType = {
  36         .TypeName = "FDD Root Node",
  37         .ReadDir = FDD_ReadDir,
  38         .FindDir = FDD_FindDir,
  39         .IOCtl = FDD_IOCtl
  40         };
  41 tVFS_NodeType   gFDD_DevNodeType = {
  42         .TypeName = "FDD Device",
  43         .Read = FDD_ReadFS,
  44         .Write = NULL   // FDD_WriteFS?
  45         };
  46 tDevFS_Driver   gFDD_DriverInfo = {
  47         NULL, "fdd",
  48         {
  49         .Size = -1,
  50         .NumACLs = 1,
  51         .ACLs = &gVFS_ACL_EveryoneRX,
  52         .Flags = VFS_FFLAG_DIRECTORY,
  53         .Type = &gFDD_RootNodeType
  54         }
  55         };
  56
  57 // === CODE ===
  58 int FDD_Install(char **Arguments)
  59 {
  60         // Query CMOS memory
  61         {
  62                 Uint8   data;
  63                 outb(0x70, 0x10);
  64                 data = inb(0x71);
  65
  66                 // NOTE: CMOS only reports 2 disks
  67                 if( (data & 0xF0) == 0x40 )
  68                         gaFDD_Disks[0].bValid = gaFDD_Disks[0].bInserted = 1;
  69                 if( (data & 0x0F) == 0x04 )
  70                         gaFDD_Disks[1].bValid = gaFDD_Disks[1].bInserted = 1;
  71
  72                 if( gaFDD_Disks[0].bValid == 0 && gaFDD_Disks[1].bValid == 0 )
  73                         return MODULE_ERR_NOTNEEDED;
  74         }
  75
  76         // Initialise controller
  77         FDD_SetupIO();
  78
  79         FDD_RegisterFS();
  80
  81         return 0;
  82 }
  83
  84 /**
  85  * \brief Register the FDD driver with DevFS
  86  */
  87 int FDD_RegisterFS(void)
  88 {
  89         gFDD_DriverInfo.RootNode.CTime = gFDD_DriverInfo.RootNode.MTime
  90                 = gFDD_DriverInfo.RootNode.ATime = now();
  91
  92         for( int i = 0; i < MAX_DISKS; i ++ )
  93         {
  94                 if( !gaFDD_Disks[i].bValid )    continue ;
  95
  96                 // Initialise Child Nodes
  97                 gaFDD_DiskNodes[i].Inode = i;
  98                 gaFDD_DiskNodes[i].Flags = 0;
  99                 gaFDD_DiskNodes[i].NumACLs = 0;
 100                 gaFDD_DiskNodes[i].Type = &gFDD_DevNodeType;
 101                 gaFDD_DiskNodes[i].Size = 1440*1024;    // TODO: Non 1.44 disks
 102         }
 103
 104         DevFS_AddDevice( &gFDD_DriverInfo );
 105         return 0;
 106 }
 107
 108 /**
 109  * \brief Get the name of the \a Pos th item in the driver root
 110  * \param Node  Root node (unused)
 111  * \param Pos   Position
 112  * \return Heap string of node name
 113  */
 114 char *FDD_ReadDir(tVFS_Node *Node, int Pos)
 115 {
 116         char    ret_tpl[2];
 117         if(Pos < 0 || Pos > MAX_DISKS )
 118                 return NULL;
 119         if(gaFDD_Disks[Pos].bValid)
 120                 return VFS_SKIP;
 121
 122         ret_tpl[0] = '0' + Pos;
 123         ret_tpl[1] = '\0';
 124         return strdup(ret_tpl);
 125 }
 126
 127 /**
 128  * \brief Get a node by name
 129  * \param Node  Root node (unused)
 130  * \param Name  Drive name
 131  * \return Pointer to node structure
 132  */
 133 tVFS_Node *FDD_FindDir(tVFS_Node *Node, const char *Name)
 134 {
 135          int    pos;
 136         if( '0' > Name[0] || Name[0] > '9' )    return NULL;
 137         if( Name[1] != '\0' )   return NULL;
 138
 139         pos = Name[0] - '0';
 140
 141         return &gaFDD_DiskNodes[pos];
 142 }
 143
 144 static const char       *casIOCTLS[] = {DRV_IOCTLNAMES,DRV_DISK_IOCTLNAMES,NULL};
 145 /**
 146  * \brief Driver root IOCtl Handler
 147  * \param Node  Root node (unused)
 148  * \param ID    IOCtl ID
 149  * \param Data  IOCtl specific data pointer
 150  */
 151 int FDD_IOCtl(tVFS_Node *Node, int ID, void *Data)
 152 {
 153         switch(ID)
 154         {
 155         BASE_IOCTLS(DRV_TYPE_DISK, "FDDv2", FDD_VERSION, casIOCTLS);
 156
 157         case DISK_IOCTL_GETBLOCKSIZE:   return 512;
 158
 159         default:
 160                 return -1;
 161         }
 162 }
 163
 164 /**
 165  * \brief Read from a disk
 166  * \param Node  Disk node
 167  * \param Offset        Byte offset in disk
 168  * \param Length        Number of bytes to read
 169  * \param Buffer        Destination buffer
 170  * \return Number of bytes read
 171  */
 172 Uint64 FDD_ReadFS(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
 173 {
 174          int    disk = Node->Inode;
 175          int    track;
 176          int    rem_len;
 177         char    *dest = Buffer;
 178
 179         ENTER("pNode XOffset XLength pBuffer", Node, Offset, Length, Buffer);
 180
 181         if( Offset > Node->Size )       LEAVE_RET('i', 0);
 182         if( Length > Node->Size )       Length = Node->Size;
 183         if( Offset + Length > Node->Size )
 184                 Length = Node->Size - Offset;
 185         if( Length == 0 )       return 0;
 186
 187         rem_len = Length;
 188
 189         track = Offset / BYTES_PER_TRACK;
 190         Offset %= BYTES_PER_TRACK;
 191
 192         if( Offset )
 193         {
 194                  int    len;
 195                 if(rem_len > BYTES_PER_TRACK - Offset)
 196                         len = BYTES_PER_TRACK - Offset;
 197                 else
 198                         len = rem_len;
 199                 FDD_int_ReadWriteWithinTrack(disk, track, 0, Offset, len, dest);
 200                 dest += len;
 201                 rem_len -= len;
 202                 track ++;
 203         }
 204
 205         if( rem_len > 0)
 206         {
 207                 while( rem_len > BYTES_PER_TRACK )
 208                 {
 209                         FDD_int_ReadWriteWithinTrack(disk, track, 0, 0, BYTES_PER_TRACK, dest);
 210                         dest += BYTES_PER_TRACK;
 211                                 rem_len -= BYTES_PER_TRACK;
 212                         track ++;
 213                 }
 214
 215                 FDD_int_ReadWriteWithinTrack(disk, track, 0, 0, rem_len, dest);
 216         }
 217
 218         LEAVE('X', Length);
 219         return Length;
 220 }
 221
 222 /**
 223  * \brief Read from a track
 224  */
 225 int FDD_int_ReadWriteWithinTrack(int Disk, int Track, int bWrite, size_t Offset, size_t Length, void *Buffer)
 226 {
 227         if( Offset > BYTES_PER_TRACK || Length > BYTES_PER_TRACK )
 228                 return 1;
 229         if( Offset + Length > BYTES_PER_TRACK )
 230                 return 1;
 231
 232         if( Length == 0 )
 233                 return 0;
 234
 235         ENTER("iDisk iTrack bbWrite xOffset xLength pBuffer",
 236                 Disk, Track, bWrite, Offset, Length, Buffer);
 237
 238         Mutex_Acquire( &gaFDD_Disks[Disk].Mutex );
 239
 240         // If the cache doesn't exist, create it
 241         if( !gaFDD_Disks[Disk].TrackData[Track] )
 242         {
 243                 gaFDD_Disks[Disk].TrackData[Track] = malloc( BYTES_PER_TRACK );
 244                 // Don't bother reading if this is a whole track write
 245                 if( !(bWrite && Offset == 0 && Length == BYTES_PER_TRACK) )
 246                 {
 247                         LOG("Reading track");
 248                         FDD_int_ReadWriteTrack(Disk, Track, 0, gaFDD_Disks[Disk].TrackData[Track]);
 249                 }
 250         }
 251
 252         // Read/Write
 253         if( bWrite )
 254         {
 255                 // Write to cache then commit cache to disk
 256                 char    *dest = gaFDD_Disks[Disk].TrackData[Track];
 257                 LOG("Write to cache");
 258                 memcpy( dest + Offset, Buffer, Length );
 259                 FDD_int_ReadWriteTrack(Disk, Track, 1, gaFDD_Disks[Disk].TrackData[Track]);
 260         }
 261         else
 262         {
 263                 // Read from cache
 264                 char    *src = gaFDD_Disks[Disk].TrackData[Track];
 265                 LOG("Read from cache");
 266                 memcpy(Buffer, src + Offset, Length);
 267         }
 268
 269         Mutex_Release( &gaFDD_Disks[Disk].Mutex );
 270
 271         LEAVE('i', 0);
 272         return 0;
 273 }