TempleOSCDV5.00.ISO

Kernel/BlkDev/DskATA.HC

@@ -160,10 +160,10 @@ Bool ATAPIStartStop(CBlkDev *bd,F64 timeout,Bool start)
     return FALSE;
 }
 
-I64 ATAGetDevId(CBlkDev *bd,F64 timeout,U16 **_id_record)
+I64 ATAGetDevId(CBlkDev *bd,F64 timeout,Bool keep_id_record)
 {
-  U16 *id_record;
-  if (_id_record) *_id_record=NULL;
+  I64 res=BDT_NULL;
+  U16 *id_record=NULL;
   if (bd->type!=BDT_ATAPI && bd->base1)
     OutU8(bd->base1+ATAR1_CTRL,0x8);
   if (bd->flags & BDF_EXT_SIZE)
@@ -171,24 +171,30 @@ I64 ATAGetDevId(CBlkDev *bd,F64 timeout,U16 **_id_record)
   else
     OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
   ATACmd(bd,ATA_ID_DEV);
-  if (!ATAWaitNotBUSY(bd,timeout))
-    return BDT_NULL;
-  if (InU8(bd->base0+ATAR0_STAT)&ATAS_ERR)
-    return BDT_ATAPI;
-  id_record=ACAlloc(512);
-  if (!ATAGetRes(bd,timeout,id_record,512,512,FALSE)) {
-    Free(id_record);
-    return BDT_NULL;
+  if (ATAWaitNotBUSY(bd,timeout)) {
+    if (InU8(bd->base0+ATAR0_STAT)&ATAS_ERR)
+      res=BDT_ATAPI;
+    else {
+      id_record=ACAlloc(512);
+      if (ATAGetRes(bd,timeout,id_record,512,512,FALSE))
+	res=BDT_ATA;
+      else {
+	Free(id_record);
+	id_record=NULL;
+      }
+    }
   }
-  if (_id_record) *_id_record=id_record;
-  return BDT_ATA;
+  if (keep_id_record) {
+     Free(bd->dev_id_record);
+     bd->dev_id_record=id_record;
+  }
+  return res;
 }
 
 I64 ATAReadNativeMax(CBlkDev *bd,F64 timeout)
 {//Returns zero on err
   I64 res=0;
   Bool okay=TRUE;
-
   if (bd->type==BDT_ATAPI) {
     if (bd->flags & BDF_EXT_SIZE)
       OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
@@ -207,9 +213,7 @@ I64 ATAReadNativeMax(CBlkDev *bd,F64 timeout)
       if (0<timeout<tS)
 	return FALSE;
     }
-
-    Free(bd->dev_id_record);
-    if (ATAGetDevId(bd,timeout,&bd->dev_id_record)==BDT_NULL)
+    if (ATAGetDevId(bd,timeout,TRUE)==BDT_NULL)
       okay=FALSE;
     else
       BEqu(&bd->flags,BDf_EXT_SIZE,Bt(&bd->dev_id_record[86],10));
@@ -310,7 +314,6 @@ Bool ATAInit(CBlkDev *bd)
     bd->flags|=BDF_EXT_SIZE;
 
   if (ATAReadNativeMax(bd,tS+0.1)) {
-
     ATABlkSel(bd,bd->max_blk,0);
     if (bd->flags&BDF_EXT_SIZE)
       ATACmd(bd,ATA_SET_MAX_EXT);
@@ -379,7 +382,7 @@ I64 ATAProbe(I64 base0,I64 base1,I64 unit)
   bd.base1=base1;
   bd.unit=unit;
   bd.blk_size=DVD_BLK_SIZE;
-  return ATAGetDevId(&bd,tS+0.1,NULL);
+  return ATAGetDevId(&bd,tS+0.1,FALSE);
 }
 
 Bool ATAPIReadBlks2(CBlkDev *bd,F64 timeout,U8 *buf,

Kernel/BlkDev/DskATAId.HC

@@ -244,7 +244,7 @@ CBlkDev *ATAMount(U8 first_drv_let,I64 type,I64 base0,I64 base1,I64 unit)
     res->unit=unit;
     res->base0=base0;
     res->base1=base1;
-    if (BlkDevAdd(res,FALSE,FALSE))
+    if (BlkDevAdd(res,,FALSE,FALSE))
       return res;
   }
   return NULL;

Kernel/BlkDev/DskAddDev.HC

@@ -24,18 +24,20 @@ U0 BlkDevLockFwdingSet(CBlkDev *bd)
   }
 }
 
-I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
-{
-  I64 i,j,ext_base,offset,res=0;
+I64 BlkDevAdd(CBlkDev *bd,I64 prt_num=MIN_I64,
+	Bool whole_drv,Bool make_free)
+{//It will mount just one partition of prt_num>=0.
+//When repartitioing whole drive, whole_drv=TRUE.
+  I64 i,j,ext_base,offset,res=0,num=0;
   CDrv *dv;
   CRedSeaBoot br;
   CMasterBoot mbr;
 
   bd->bd_signature=BD_SIGNATURE_VAL;
   if (make_free)
-    dv=DrvMakeFreeSlot(bd->first_drv_let+res);
+    dv=DrvMakeFreeSlot(bd->first_drv_let);
   else
-    dv=DrvMakeFreeSlot(DrvNextFreeLet(bd->first_drv_let+res));
+    dv=DrvMakeFreeSlot(DrvNextFreeLet(bd->first_drv_let));
   dv->bd=bd;
   dv->drv_offset=bd->drv_offset;
   dv->size=bd->max_blk+1-bd->drv_offset;
@@ -44,6 +46,7 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
     case BDT_ISO_FILE_READ:
     case BDT_ISO_FILE_WRITE:
       dv->dv_signature=DRV_SIGNATURE_VAL;
+      dv->prt_num=num;
       dv->fs_type=FSt_REDSEA;
 //This is to force creation of a RAM
       //drive during boot, so it is probably
@@ -63,8 +66,9 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
 	dv->dv_signature=0; //Revoke validation
       else {
 	dv->dv_signature=0; //Revoke validation
-	if (one_drv) {
+	if (whole_drv) {
 	  dv->dv_signature=DRV_SIGNATURE_VAL;
+	  dv->prt_num=num;
 	  res++;
 	  dv->fs_type=FSt_REDSEA;
 	  dv->size=bd->max_blk+1-bd->drv_offset;
@@ -75,12 +79,12 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
 	}
 	offset=0;
 	ext_base=INVALID_CLUSTER;
-	while (TRUE) {
+	while (prt_num<0 || num<=prt_num) {
 	  ATAReadBlks(bd,&mbr,offset,1);
 	  if (mbr.signature!=0xAA55)
 	    break;
 	  j=-1;
-	  for (i=0;i<4;i++) {
+	  for (i=0;i<4 && (prt_num<0 || num<=prt_num);i++) {
 	    if (mbr.p[i].type) {
 	      if (make_free)
 		dv=DrvMakeFreeSlot(bd->first_drv_let+res);
@@ -92,9 +96,10 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
 	      switch (mbr.p[i].type) {
 		case MBR_PT_REDSEA:
 		  dv->dv_signature=DRV_SIGNATURE_VAL;
+		  dv->prt_num=num;
 		  res++;
 		  dv->fs_type=FSt_REDSEA;
-		  RedSeaDrvInit(dv);
+		  RedSeaInit(dv);
 		  break;
 		case MBR_PT_FAT32a:
 		case MBR_PT_FAT32b:
@@ -104,17 +109,19 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
 		case MBR_PT_FAT32f:
 		  ATAReadBlks(bd,&br,dv->drv_offset,1);
 		  dv->dv_signature=DRV_SIGNATURE_VAL;
+		  dv->prt_num=num;
 		  res++;
 		  if (br.signature==MBR_PT_REDSEA) {
 		    dv->fs_type=FSt_REDSEA;
-		    RedSeaDrvInit(dv);
+		    RedSeaInit(dv);
 		  } else {
 		    dv->fs_type=FSt_FAT32;
-		    FAT32DrvInit(dv);
+		    FAT32Init(dv);
 		  }
 		  break;
 		case MBR_PT_NTFS:
 		  dv->dv_signature=DRV_SIGNATURE_VAL;
+		  dv->prt_num=num;
 		  res++;
 		  dv->fs_type=FSt_NTFS;
 		  break;
@@ -124,9 +131,11 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
 		  break;
 		default:
 		  dv->dv_signature=DRV_SIGNATURE_VAL;
+		  dv->prt_num=num;
 		  res++;
 		  dv->fs_type=FSt_UNKNOWN;
 	      }
+	      num++;
 	    }
 	  }
 	  if (Let2BlkDevType(bd->first_drv_let+res)!=bd->type)
@@ -145,6 +154,7 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
       break;
     case BDT_ATAPI:
       dv->dv_signature=DRV_SIGNATURE_VAL;
+      dv->prt_num=num;
       res++;
       dv->fs_type=FSt_ISO9660; //Start with this
       dv->size=0;

Kernel/BlkDev/DskBlkDev.HC

@@ -44,8 +44,8 @@ Bool BlkDevInit(CBlkDev *bd)
 	}
 	dv->fs_type=FSt_REDSEA;
 	dv->size=bd->max_blk+1-bd->drv_offset;
-	if (RedSeaDrvValidate(bd->first_drv_let))
-	  RedSeaDrvInit(dv);
+	if (RedSeaValidate(bd->first_drv_let))
+	  RedSeaInit(dv);
 	else
 	  RedSeaFmt(bd->first_drv_let);
 	res=TRUE;
@@ -54,21 +54,25 @@ Bool BlkDevInit(CBlkDev *bd)
 	if (FileFind(bd->file_dsk_name,&de,FUF_JUST_FILES)) {
 	  bd->max_blk=de.size>>BLK_SIZE_BITS-1;
 	  try bd->file_dsk=FOpen(bd->file_dsk_name,"rc",bd->max_blk+1);
-	  catch
+	  catch {
+	    if (Fs->except_ch=='File')
+	      PrintErr("Not Contiguous.  Move file to filename.ISO.C.\n");
 	    Fs->catch_except=TRUE;
+	  }
 	  if (bd->file_dsk) {
 	    dv->fs_type=FSt_REDSEA;
 	    dv->size=bd->max_blk+1-bd->drv_offset;
-	    if (RedSeaDrvValidate(bd->first_drv_let)) {
-	      RedSeaDrvInit(dv);
+	    if (RedSeaValidate(bd->first_drv_let)) {
+	      RedSeaInit(dv);
 	      res=TRUE;
-	    }
+	    } else
+	      PrintErr("Not RedSea\n");
 	  }
 	}
 	break;
       case BDT_ISO_FILE_WRITE:
 	if (!bd->file_dsk_name) {
-	  StrPrint(buf,"%C:/Drv%C.DRV.C",
+	  StrPrint(buf,"%C:/Drv%C.ISO.C",
 		blkdev.boot_drv_let,bd->first_drv_let);
 	  bd->file_dsk_name=AStrNew(buf);
 	}
@@ -78,6 +82,7 @@ Bool BlkDevInit(CBlkDev *bd)
 	dv->fs_type=FSt_REDSEA;
 	dv->size=bd->max_blk+1-bd->drv_offset;
 	RedSeaFmt(bd->first_drv_let);
+	CallExtStr("RedSeaISO9660",bd->file_dsk_name,bd->first_drv_let);
 	res=TRUE;
 	break;
       case BDT_ATA:

Kernel/BlkDev/DskCDDVD.HC

@@ -2,7 +2,7 @@
 //ISO2 is ISO13490
 //ISO3 is ISO13346
 
-Bool ISODrvInit(CDrv *dv,I64 blk)
+Bool ISOInit(CDrv *dv,I64 blk)
 {
   CBlkDev *bd=dv->bd;
   I64 spc=bd->blk_size>>BLK_SIZE_BITS,i=blk/spc,drv_offset=0;
@@ -13,9 +13,9 @@ Bool ISODrvInit(CDrv *dv,I64 blk)
 
   try {
     unlock=DrvLock(dv);
-    dv->fs_type=FSt_ISO9660; //default
+    dv->fs_type=FSt_ISO9660;
     dv->spc=spc;
-    dv->drv_offset=bd->drv_offset=dv->data_area=dv->root_cluster=dv->size=0;
+    dv->data_area=dv->root_cluster=dv->drv_offset=bd->drv_offset=dv->size=0;
     while (TRUE) {
       dv->size=MaxI64(dv->size,(i+1)*spc);
       RBlks(dv,iso,i*spc,spc);
@@ -30,17 +30,17 @@ Bool ISODrvInit(CDrv *dv,I64 blk)
 	      break;
 	    case ISO1T_SUPPLEMENTARY_DESC:
 	      de=&iso->root_dir_record;
-	      dv->root_cluster=de->loc.little;
 	      dv->size=iso->vol_space_size.little*bd->blk_size>>BLK_SIZE_BITS;
 	      if (!StrCmp(iso->publisher_id,"TempleOS RedSea")) {
 		dv->fs_type=FSt_REDSEA;
 		bd->drv_offset=dv->drv_offset=19<<2+drv_offset;
 		bd->max_blk=dv->size-1;
 		dv->size-=bd->drv_offset;
-		RedSeaDrvInit(dv);
-	      }
+		RedSeaInit(dv);
+	      } else
+		dv->root_cluster=de->loc.little;
 	      res=TRUE;
-	      goto ipi_done;
+	      goto di_done;
 	    case ISO1T_TERMINATOR:
 	      throw('Drv');
 	  }
@@ -51,7 +51,7 @@ Bool ISODrvInit(CDrv *dv,I64 blk)
       }
       i++;
     }
-ipi_done:
+di_done:
     Free(iso);
     if (unlock)
       DrvUnlock(dv);

Kernel/BlkDev/DskCache.HC

@@ -3,7 +3,7 @@ U0 DskCacheInit(I64 size_in_U8s)
   CCacheBlk *tmpc;
   I64 i,cnt;
 
-  while (LBts(&sys_semas[SYS_SEMA_DSK_CACHE],0))
+  while (LBts(&sys_semas[SEMA_DSK_CACHE],0))
     Yield;
   Free(blkdev.cache_ctrl);
   Free(blkdev.cache_base);
@@ -34,7 +34,7 @@ U0 DskCacheInit(I64 size_in_U8s)
       tmpc->next_hash=tmpc->last_hash=tmpc;
     }
   }
-  LBtr(&sys_semas[SYS_SEMA_DSK_CACHE],0);
+  LBtr(&sys_semas[SEMA_DSK_CACHE],0);
 }
 
 I64 DskCacheHash(I64 blk)
@@ -77,7 +77,7 @@ U0 DskCacheAdd(CDrv *dv,U8 *buf, I64 blk, I64 cnt)
 {
   CCacheBlk *tmpc;
   if (blkdev.cache_base) {
-    while (LBts(&sys_semas[SYS_SEMA_DSK_CACHE],0))
+    while (LBts(&sys_semas[SEMA_DSK_CACHE],0))
       Yield;
     while (cnt-->0) {
       if (!(tmpc=DskCacheFind(dv,blk)))
@@ -90,7 +90,7 @@ U0 DskCacheAdd(CDrv *dv,U8 *buf, I64 blk, I64 cnt)
       blk++;
       buf+=BLK_SIZE;
     }
-    LBtr(&sys_semas[SYS_SEMA_DSK_CACHE],0);
+    LBtr(&sys_semas[SEMA_DSK_CACHE],0);
   }
 }
 
@@ -98,7 +98,7 @@ U0 DskCacheInvalidate2(CDrv *dv)
 {
   CCacheBlk *tmpc,*tmpc1;
   if (blkdev.cache_base) {
-    while (LBts(&sys_semas[SYS_SEMA_DSK_CACHE],0))
+    while (LBts(&sys_semas[SEMA_DSK_CACHE],0))
       Yield;
     tmpc=blkdev.cache_ctrl->last_lru;
     while (tmpc!=blkdev.cache_ctrl) {
@@ -112,7 +112,7 @@ U0 DskCacheInvalidate2(CDrv *dv)
       }
       tmpc=tmpc1;
     }
-    LBtr(&sys_semas[SYS_SEMA_DSK_CACHE],0);
+    LBtr(&sys_semas[SEMA_DSK_CACHE],0);
   }
 }
 
@@ -120,7 +120,7 @@ U0 RCache(CDrv *dv,U8 **_buf, I64 *_blk, I64 *_cnt)
 {
   CCacheBlk *tmpc;
   if (blkdev.cache_base) {
-    while (LBts(&sys_semas[SYS_SEMA_DSK_CACHE],0))
+    while (LBts(&sys_semas[SEMA_DSK_CACHE],0))
       Yield;
 //fetch leading blks from cache
     while (*_cnt>0) {
@@ -140,6 +140,6 @@ U0 RCache(CDrv *dv,U8 **_buf, I64 *_blk, I64 *_cnt)
       } else
 	break;
     }
-    LBtr(&sys_semas[SYS_SEMA_DSK_CACHE],0);
+    LBtr(&sys_semas[SEMA_DSK_CACHE],0);
   }
 }

Kernel/BlkDev/DskDrv.HC

@@ -38,7 +38,7 @@ U0 DrvsRelease()
 CDrv *DrvMakeFreeSlot(U8 drv_let)
 {//Make a slot free for a new drv, like during $LK,"Mount",A="MN:Mount"$().
 //!!! drv_let is not a $LK,"remapped",A="MN:DrvMap"$ drv.
-  I64 i=ToUpper(drv_let)-'A';
+  I64 i=Let2Let(drv_let)-'A';
   CDrv *res;
   if (!(0<=i<NUM_DRVS))
     throw('Drv');
@@ -51,7 +51,7 @@ CDrv *DrvMakeFreeSlot(U8 drv_let)
 U8 DrvNextFreeLet(U8 first_drv_let='C')
 {//Locate free slot for new drv, like during $LK,"Mount",A="MN:Mount"$().
 //!!! first_drv_let is not a $LK,"remapped",A="MN:DrvMap"$ drv.
-  I64 i=ToUpper(first_drv_let)-'A',type=Let2BlkDevType(first_drv_let);
+  I64 i=Let2Let(first_drv_let)-'A',type=Let2BlkDevType(first_drv_let);
   if (!(0<=i<NUM_DRVS))
     throw('Drv');
   do
@@ -158,9 +158,20 @@ U8 Drv2Let(CDrv *dv=NULL)
   return dv->drv_let;
 }
 
+U8 Let2Let(U8 drv_let=0)
+{//Drv letter to Drv letter.
+  if (!drv_let)
+    drv_let=Drv2Let(Fs->cur_dv);
+  else if (drv_let==':')
+    drv_let=blkdev.boot_drv_let;
+  else if (drv_let=='~')
+    drv_let=*blkdev.home_dir;
+  return ToUpper(drv_let);
+}
+
 I64 Let2BlkDevType(U8 drv_let)
 {//Drv letter to BlkDev Type. drv_let=0 not allowed. See $LK,"BDT_NULL",A="MN:BDT_NULL"$.
-  drv_let=ToUpper(drv_let);
+  drv_let=Let2Let(drv_let);
   if ('A'<=drv_let<='B')
     return BDT_RAM;
   if ('C'<=drv_let<='L')
@@ -180,11 +191,7 @@ CDrv *Let2Drv(U8 drv_let=0,Bool except=TRUE)
   if (!drv_let)
     dv=Fs->cur_dv;
   else {
-    if (drv_let==':')
-      drv_let=blkdev.boot_drv_let;
-    else if (drv_let=='~')
-      drv_let=*blkdev.home_dir;
-    drv_let=ToUpper(drv_let);
+    drv_let=Let2Let(drv_let);
     if (!('A'<=drv_let<='Z')) {
       if (except)
 	throw('Drv');
@@ -219,7 +226,7 @@ U0 DskCacheInvalidate(CDrv *dv)
     if (bd->flags & BDF_READ_CACHE)
       DskCacheInvalidate2(dv);
     if (bd->type==BDT_ATAPI && !(bd->flags & BDF_READ_ONLY_OVERRIDE))
-      ISODrvInit(dv,(32767/bd->blk_size+1)*bd->blk_size>>BLK_SIZE_BITS);
+      ISOInit(dv,(32767/bd->blk_size+1)*bd->blk_size>>BLK_SIZE_BITS);
     if (unlock)
       DrvUnlock(dv);
   } catch
@@ -233,15 +240,18 @@ U0 ChgDsk(U8 drv_let=0)
   CBlkDev *bd=dv->bd;
   if (!(bd->flags&BDF_INITIALIZED))
     BlkDevInit(bd);
-  else if (bd->flags&BDF_REMOVABLE)
+  else if (bd->flags&BDF_REMOVABLE) {
+    if (bd->type==BDT_ATAPI)
+      ATAInit(bd); //TODO: This is a kludge for QEMU?
     DskCacheInvalidate(dv);
+  }
   Drv(drv_let);
   RedSeaFreeFreeLst(dv);
 }
 
 Bool DrvMap(U8 drv_let,CDrv *dv)
 {//Make drive letter map to another.
-  drv_let=ToUpper(drv_let);
+  drv_let=Let2Let(drv_let);
   if ('A'<=drv_let<='Z') {
     blkdev.let_to_drv[drv_let-'A']=dv;
     dv->drv_let=drv_let;
@@ -311,13 +321,7 @@ U8 drv_text_attr[3]={BLACK,BLUE,RED};
 
 U8 DrvTextAttrGet(U8 drv_let=0)
 {//Get color of drive.
-  if (!drv_let)
-    drv_let=Drv2Let(Fs->cur_dv);
-  else if (drv_let==':')
-    drv_let=blkdev.boot_drv_let;
-  else if (drv_let=='~')
-    drv_let=*blkdev.home_dir;
-  drv_let=ToUpper(drv_let);
+  drv_let=Let2Let(drv_let);
   if ('A'<=drv_let<='Z')
     return blkdev_text_attr[Let2BlkDevType(drv_let)]<<4|
 	  drv_text_attr[drv_let%sizeof(drv_text_attr)];

Kernel/BlkDev/DskFmt.HC

@@ -2,7 +2,9 @@ Bool DrvTypeSet(U8 drv_let,I64 type=FSt_REDSEA)
 {//Very dangerous
   I64 i,j,ext_base,drv_num,offset,cur_type;
   CMasterBoot mbr;
-  CBlkDev *bd=Let2BlkDev(drv_let);
+  CBlkDev *bd;
+  drv_let=Let2Let(drv_let);
+  bd=Let2BlkDev(drv_let);
   drv_num=bd->first_drv_let-'A';
   switch (bd->type) {
     case BDT_ATA:
@@ -17,7 +19,7 @@ Bool DrvTypeSet(U8 drv_let,I64 type=FSt_REDSEA)
 	    if (cur_type==5 || cur_type==15)
 	      j=i;
 	    else {
-	      if (drv_num+'A'==ToUpper(drv_let)) {
+	      if (drv_num+'A'==drv_let) {
 		switch (type) {
 		  case FSt_REDSEA:
 		    mbr.p[i].type=MBR_PT_REDSEA;

Kernel/BlkDev/DskStrA.HC

@@ -257,7 +257,7 @@ Bool FileNameChk(U8 *filename)
   }
   if (StrLen(filename)>=CDIR_FILENAME_LEN) return FALSE;
   while (*ptr)
-    if (!Bt(chars_bmp_filename,*ptr++))
+    if (!Bt(char_bmp_filename,*ptr++))
       return FALSE;
   return TRUE;
 }

Kernel/BlkDev/FileSysFAT.HC

@@ -19,7 +19,7 @@ CDate Dos2CDate(U16 t,U16 d)
   return Struct2Date(&ds);
 }
 
-U0 FAT32DrvInit(CDrv *dv)
+U0 FAT32Init(CDrv *dv)
 {
   CFAT32Boot br32;
   Bool unlock;
@@ -45,18 +45,6 @@ U0 FAT32DrvInit(CDrv *dv)
       DrvUnlock(dv);
 }
 
-Bool FAT32DrvValidate(U8 drv_let)
-{
-  CDrv *dv;
-  CFAT32Boot br;
-  if ((dv=Let2Drv(drv_let,FALSE)) && dv->fs_type==FSt_FAT32 &&
-	RBlks(dv,&br,dv->drv_offset,1) && br.signature==0xAA55 &&
-	br.sects==dv->size)
-    return TRUE;
-  else
-    return FALSE;
-}
-
 U0 FAT32Fmt(U8 drv_let,Bool quick=TRUE)
 {
   CFAT32Boot *br=CAlloc(BLK_SIZE);
@@ -115,11 +103,11 @@ U0 FAT32Fmt(U8 drv_let,Bool quick=TRUE)
 
     WBlks(dv,fis,dv->drv_offset+br->file_system_info_sect,1);
     WBlks(dv,br,dv->drv_offset,1);
-    FAT32DrvInit(dv);
+    FAT32Init(dv);
     ClustersAlloc(dv,0,1,FALSE); //Alloc #1
     br->root_cluster=ClustersAlloc(dv,0,1,FALSE);
     WBlks(dv,br,dv->drv_offset,1);
-    FAT32DrvInit(dv);
+    FAT32Init(dv);
     DrvUnlock(dv);
   } catch
     DrvUnlock(dv);

Kernel/BlkDev/FileSysISO.HC

@@ -42,7 +42,7 @@ Bool ISO1FromName(U8 *dst,U8 *src)
       src++;
       if (*src==';')
 	break;
-      if (Bt(chars_bmp_filename,*src)) {
+      if (Bt(char_bmp_filename,*src)) {
 	if (j>=CDIR_FILENAME_LEN-1)
 	  return FALSE;
 	dst[j++]=*src++;

Kernel/BlkDev/FileSysRedSea.HC

@@ -55,7 +55,7 @@ U0 RedSeaFreeLstBuild(CDrv *dv)
       DrvUnlock(dv);
 }
 
-U0 RedSeaDrvInit(CDrv *dv)
+U0 RedSeaInit(CDrv *dv)
 {
   CRedSeaBoot br;
   Bool unlock;
@@ -79,7 +79,7 @@ U0 RedSeaDrvInit(CDrv *dv)
       DrvUnlock(dv);
 }
 
-Bool RedSeaDrvValidate(U8 drv_let)
+Bool RedSeaValidate(U8 drv_let)
 {
   CDrv *dv;
   CRedSeaBoot br;
@@ -119,7 +119,7 @@ U0 RedSeaFmt(U8 drv_let,Bool quick=TRUE)
     WZeroBlks(dv,dv->drv_offset,i);
 
     WBlks(dv,br,dv->drv_offset,1);
-    RedSeaDrvInit(dv);
+    RedSeaInit(dv);
     ClustersAlloc(dv,0,1,FALSE);	//Alloc #1
 
     root_dir_blks=MaxI64(1,dv->bd->init_root_dir_blks);
@@ -144,7 +144,7 @@ U0 RedSeaFmt(U8 drv_let,Bool quick=TRUE)
     d_native->datetime=Now;
 
     WBlks(dv,root_dir,br->root_cluster,root_dir_blks);
-    RedSeaDrvInit(dv);
+    RedSeaInit(dv);
     DrvUnlock(dv);
   } catch
     DrvUnlock(dv);