mcc_ccs.c

CCS FAT file systemp access

      do
   {
      
         response = RecebeMMC ();
       
      if (response == 0xFE) break;
      
         delay_ms(1);
         
      } while (--errs);
      
      *0xFE9 = (int16) buffer;
   
      cnt3 = 2;
      cnt2 = 0;
   
   do
   {
         do
         {
            SSPBUF = 0xFF;
            while (!BF);
            
            *0xFEE = SSPBUF;
           
      } while (--cnt2);
      } while (--cnt3);
      
      
      response = RecebeMMC ();
      response = RecebeMMC ();
      
   SelecionaMMC (FALSE);
      
//      enable_interrupts(GLOBAL);
}


//-------------------------------------------------------------------------
// Escreve em um setor da mem?ria - FAT32
//-------------------------------------------------------------------------
void WriteSector (int32 sector, char *buffer)
{
   char errs;
      char response;
      char cnt2;
      char cnt3;
      #byte sectorL = sector
      #byte sectorH = sector+1
      #byte sectorHL = sector+2

//      if (input (CardInserted)) return;
   
//      disable_interrupts(GLOBAL);
//      restart_wdt();
   
      MMCAddressL    = 0;
      MMCAddressH    = sectorL;
      MMCAddressHL = sectorH;
      MMCAddressHH = sectorHL;
      gFAT32Vars.MMCAddress <<= 1;
   
      response = 0;

   SelecionaMMC (TRUE);
   
      EnviaMMC (0x58);
      
    EnviaMMC (MMCAddressHH);
    EnviaMMC (MMCAddressHL);
    EnviaMMC (MMCAddressH & 0xFE);
 
      EnviaMMC (0);
      EnviaMMC (0x01);
      MMC8Clock ();
      errs = 8;
      
      do
   {
       response = RecebeMMC ();
       
      } while (--errs && response==0xFF);
      
      if (response)
   {
      SelecionaMMC (FALSE);
       
         MMC8Clock();
//         enable_interrupts(GLOBAL);
         
        return;
      }
      
      MMC8Clock ();
      EnviaMMC (0xFE);
      *0xFE9 = (int16)buffer;
      
      cnt3 = 2;
      cnt2 = 0;
      
   do
   {
       do
       {
            SSPBUF = *0xFEE;
            while (!BF);
            response = SSPBUF;
            
         } while (--cnt2);
         
      } while (--cnt3);
   
      EnviaMMC (0x00);
      EnviaMMC (0x01);
      
      response = RecebeMMC ();
      response ^= 0xE5;
      
      if (response)
   {
       goto endwr3;
      }
      
      do
   {
       response = RecebeMMC ();
       
      } while (response == 0);
      
      response = 0;
      
endwr3:
   SelecionaMMC (FALSE);
    MMC8Clock();
    
//      enable_interrupts (GLOBAL);
}



//-------------------------------------------------------------------------
// mostra um determinado setor - FAT32
//-------------------------------------------------------------------------
void MostraSetor (int32 setor, char *dados, long tamanho)
{
   long i;
   long j;
   long k;

   printf ("\r\n\r\nLendo setor: %lx\r\n\r\n", setor);
   ReadSector (setor, dados);

   j = 0;
   for (i = 0; i < tamanho; i++)
   {
      printf ("%02X ", dados[i]);
      if (j >= 15)
      {
         printf ("          ");

         for (k = (i - 15); k < i; k++)
         {
            if (! isalnum (dados[k])) printf (".");
            else printf ("%c", dados[k]);
         }

         printf ("\r\n");
         j = 0;
      }

      else
      {
         j++;
      }

      delay_ms (1);

   }
}

//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
// Fun??es da FAT32
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------


char IsSelfDir (char *be)
{
   if (be[0] == '.' && be[1] == '.') return 0xFF;
   else return 0;
}


int16 GetCurrentDOSDate ()
{
   int16 retval;

   retval = myrec.tm_year - 1980;
   retval <<= 9;
   retval |= ((int16)myrec.tm_mon << 5);
   retval |= (int16)myrec.tm_mday;

   return retval;
}

int16 GetCurrentDOSTime ()
{
   int16 retval;

   retval = myrec.tm_hour;
   retval <<= 11;
   retval |= ((int16)myrec.tm_min << 5);
   retval |= (int16)myrec.tm_sec >> 1;
   
   return retval;
}

void InicializaFAT32 ()
{
   int32 actsector;
   char i;
   
   gFirstEmptyCluster       = 0;
      gFAT32Vars.gStartSector = 0;
      
   // limpa o CREN (comunica??o cont?nua)
   printf ("\r\nInicializando FAT32...");
      
      ReadSector (gFAT32Vars.gStartSector, gFiles[MAXFILES-1].IOpuffer);
      
   if (gFiles[MAXFILES-1].IOpuffer[0] != 0xEB)
   {
      gStartSectorL    = gFiles[MAXFILES-1].IOpuffer[0x1C6];
         gStartSectorH    = gFiles[MAXFILES-1].IOpuffer[0x1C7];
         gStartSectorHL    = gFiles[MAXFILES-1].IOpuffer[0x1C8];
         
         ReadSector (gFAT32Vars.gStartSector, gFiles[MAXFILES-1].IOpuffer);
     }
      
      memcpy (&DiskInfo, gFiles[MAXFILES-1].IOpuffer, sizeof(DiskInfo));
      
     actsector = gFAT32Vars.gStartSector + DiskInfo.Reserved1;
     
      ReadSector (actsector, FATTable);
      gFAT32Vars.FATstartidx = 0;
      
      gFAT32Vars.gFirstDataSector = gFAT32Vars.gStartSector + DiskInfo.FATCopies * DiskInfo.hSectorsPerFat + DiskInfo.Reserved1 - 2;
   
      for (i = 0; i < MAXFILES; i++)
      gFiles[i].Free = TRUE;
      
   printf ("OK");
   
   return;
}


int32 GetNextCluster (int32 curcluster)
{
      int32 actsector;
      int32 clpage;
      char clpos;

      clpage = curcluster >> 7;
      clpos = curcluster & 0x7F;
      
      if (clpage != gFAT32Vars.FATstartidx)
     {
        // read in the requested page
      actsector = gFAT32Vars.gStartSector+DiskInfo.Reserved1 + clpage;
         ReadSector (actsector, FATTable);
         
         gFAT32Vars.FATstartidx = clpage;
   }
   
   return (FATTable[clpos]);
}

void SetClusterEntry (int32 curcluster, int32 value)
{
      int32 actsector;
      int32 clpage;
      char clpos;

      clpage = curcluster >> 7;
      clpos = curcluster & 0x7F;
      actsector = gFAT32Vars.gStartSector + DiskInfo.Reserved1 + clpage;
      
      if (clpage != gFAT32Vars.FATstartidx)
   {
       ReadSector (actsector, FATTable);
         gFAT32Vars.FATstartidx = clpage;
      }
   
      FATTable[clpos] = value;
      WriteSector (actsector, FATTable);
      actsector += DiskInfo.hSectorsPerFat;
      WriteSector (actsector,FATTable);
}

void ClearClusterEntry (int32 curcluster)
{
   int32 actsector;
      int32 clpage;
      char clpos;

      clpage = curcluster >> 7;
      clpos = curcluster & 0x7F;
      
      if (clpage != gFAT32Vars.FATstartidx)
   {
       actsector = gFAT32Vars.gStartSector + DiskInfo.Reserved1 + gFAT32Vars.FATstartidx;
         WriteSector (actsector, FATTable);
         
         actsector += DiskInfo.hSectorsPerFat;
         WriteSector (actsector,FATTable);
         
         actsector = gFAT32Vars.gStartSector + DiskInfo.Reserved1 + clpage;
         ReadSector (actsector,FATTable);
     
         gFAT32Vars.FATstartidx = clpage;
      }
      
   FATTable[clpos] = 0;
}


int32 FindFirstFreeCluster ()
{
   int32 i;
   int32 st;
   int32 actsector;
   int32 retval;
   char j;

      st = gFirstEmptyCluster;
      
      for (i = st; i < DiskInfo.hSectorsPerFat; i++)
   {
       if (i != gFAT32Vars.FATstartidx)
       {
           actsector = gFAT32Vars.gStartSector + DiskInfo.Reserved1 + i;
           ReadSector (actsector, FATTable);
            gFAT32Vars.FATstartidx = gFirstEmptyCluster = i;
         }
         
         for (j=0;j<128;j++)
         {
            if (FATTable[j] == 0)
           {
               retval = i;
               retval <<= 7;
               retval |= j;
               return retval;
            }
         }
      }
      
      return 0x0FFFFFFF;
}

void ConvertFilename (DIR *beDir, char *name)
{
   char i;
   char j;
   char c;

      j = 0;

      name[0] = 0;

      for (i = 0; i < 8; i++)
   {
       c = beDir->sName[i];
       
         if (c == ' ') break;
         
         name[j++] = c;
      }
     
      for (i = 0; i < 3; i++)
   {
         c = beDir->spam[i];
         
         if ((c == ' ') || (c == 0)) break;
         
         if (!i) name[j++] = '.';
         
       name[j++] = c;
      }
      
      name[j++] = 0;
}

void GetDOSName (DIR *pDir, char *fname)
{
   char i;
   char j;
   char leng;
   char c;
   char toext;

      toext = FALSE;
      j = 0;
      
      leng = strlen(fname);
      
      for (i = 0; i < 8; i++)
       pDir->sName[i] = ' ';
       
      for (i = 0; i < 3; i++)
         pDir->spam[i] = ' ';
         
      for (i = 0; i < leng; i++)
      {
       c = fname[i];
         c = toupper(c);
         
         if (c == '.')
       {
            toext = TRUE;
            continue;
         }
         
         if (toext) pDir->spam[j++] = c;
         else pDir->sName[i] = c;
      }
}


void ReadRootDirectory (char fil)
{
   int32 actsector;

      if (fil > (MAXFILES-1)) return;
      
     actsector = gFAT32Vars.gStartSector + (DiskInfo.FATCopies * DiskInfo.hSectorsPerFat) + DiskInfo.Reserved1;

      ReadSector (actsector, gFiles[fil].IOpuffer);
      
   gFAT32Vars.gDirEntrySector = actsector;
      gFiles[fil].dirSector = actsector;
      gFiles[fil].dirIdx = 0;
      memcpy (&(gFiles[fil].DirEntry), gFiles[fil].IOpuffer,32);
      gFiles[fil].CurrentCluster = DiskInfo.hRootStartCluster;
}


char FindDirEntry (char *fname, char f)
{
   DIR *pDir;
      int16 i;
      char filename[16];
      int32 nextcluster;
      int32 actsector;

      if (f > (MAXFILES-1)) return FALSE;
   
      gFAT32Vars.gFirstEmptyDirEntry = 0xFFFF;
      gFAT32Vars.gFirstDirEntryCluster = 0x0FFFFFFF;
      
   do
   {
       pDir = (DIR*)(gFiles[f].IOpuffer);
       
         for (i = 0; i < 16; i++)
       {
            if (((pDir->sName[0] == 0xE5) || (pDir->sName[0] == 0)) && (gFAT32Vars.gFirstEmptyDirEntry == 0xFFFF))
           {
              // store first free
                 gFAT32Vars.gFirstEmptyDirEntry = i;
               gFAT32Vars.gFirstDirEntryCluster = gFiles[f].CurrentCluster;
            }

               if (pDir->sName[0] == 0) return FALSE;
                 
         ConvertFilename (pDir,filename);
             if (!strcmp (filename, fname))
           {
               memcpy(&(gFiles[f].DirEntry), pDir, 32);
               gFiles[f].dirIdx = i;
               gFAT32Vars.gDirEntryIdx = i;
               return TRUE;
            }
            
            pDir++;
         }
         
         nextcluster = GetNextCluster (gFiles[f].CurrentCluster);
         
        
            if ((nextcluster != 0x0FFFFFFF) && (nextcluster != 0))
       {
            actsector = nextcluster + gFAT32Vars.gFirstDataSector;
            ReadSector (actsector, gFiles[f].IOpuffer);
            
            gFAT32Vars.gDirEntrySector = actsector;
            gFiles[f].dirSector = actsector;
            gFiles[f].CurrentCluster = nextcluster;
         }
       
         
      } while ((nextcluster != 0x0FFFFFFF) && (nextcluster != 0));
      
      return FALSE;
}

// file I/O routines
char *TryFile(char *fname, char *f)
{
   char i;
      char leng;
      char *filename;

      (*f) = 0xFF;
   
      for (i = 0; i < MAXFILES; i++)
   {
         if (gFiles[i].Free)
        {
           (*f) = i;
            break;
         }
      }
      
      if ((*f) == 0xFF) return 0;
      
      ReadRootDirectory (*f);
      
      filename = fname;
      leng = strlen (fname);
      
      for (i = 0; i < leng; i++)
   {
       if (fname[i] == '/')
       {
           fname[i] = 0;
            
            if (! cwd (filename,(*f)))
           {
                 gFiles[(*f)].Free = TRUE;
               return 0;
            }
         
            filename = fname + i + 1;
            
        }
      }
   
      return filename;
}

char fcreate (char f, char *fname)
{
   DIR *pDir;
      int32 actsector;
      char actcl;
      int16 i;

      if (f > (MAXFILES-1)) return FALSE;
      
      if (gFAT32Vars.gFirstDirEntryCluster == 0x0FFFFFFF)
   {
       // extend the directory file !!!
         gFAT32Vars.gFirstDirEntryCluster = FindFirstFreeCluster ();
         gFAT32Vars.gFirstEmptyDirEntry = 0;
         SetClusterEntry(gFiles[f].CurrentCluster, gFAT32Vars.gFirstDirEntryCluster);
      SetClusterEntry(gFAT32Vars.gFirstDirEntryCluster, 0x0FFFFFFF);
         actsector = gFAT32Vars.gFirstDirEntryCluster + gFAT32Vars.gFirstDataSector;
         
         for (i = 0; i < 512; i++)
         {
            gFiles[f].IOpuffer[i] = 0;
        }
       
         WriteSector(actsector, gFiles[f].IOpuffer);
      }
      
      actsector = gFAT32Vars.gFirstDirEntryCluster + gFAT32Vars.gFirstDataSector;