workbench/devs/ramdrive_device.c

   1 /*
   2     Copyright © 1995-2017, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 /****************************************************************************************/
   7
   8 #define NUM_HEADS   2
   9 #define NUM_CYL     80
  10 #define NUM_SECS    11
  11 #define BLOCKSIZE   512
  12
  13 #define DISKSIZE    (NUM_HEADS * NUM_CYL * NUM_SECS * BLOCKSIZE)
  14 #define NUM_TRACKS  (NUM_CYL * NUM_HEADS)
  15
  16 /****************************************************************************************/
  17
  18 #include <devices/trackdisk.h>
  19 #include <devices/newstyle.h>
  20 #include <exec/resident.h>
  21 #include <exec/errors.h>
  22 #include <exec/memory.h>
  23 #include <exec/initializers.h>
  24 #include <proto/exec.h>
  25 #include <dos/dosextens.h>
  26 #include <dos/dostags.h>
  27 #include <proto/dos.h>
  28 #include <aros/macros.h>
  29 #include <aros/libcall.h>
  30 #include <aros/symbolsets.h>
  31 #include <string.h>
  32
  33 #if defined(__GNUC__) || defined(__INTEL_COMPILER)
  34 #include "ramdrive_device_gcc.h"
  35 #endif
  36
  37 #define DEBUG 0
  38 #include <aros/debug.h>
  39
  40 #include LC_LIBDEFS_FILE
  41
  42 /****************************************************************************************/
  43
  44 #define NEWSTYLE_DEVICE 1
  45
  46 #if NEWSTYLE_DEVICE
  47
  48 static const UWORD SupportedCommands[] =
  49 {
  50     CMD_FLUSH,
  51     CMD_READ,
  52     CMD_WRITE,
  53     CMD_UPDATE,
  54     CMD_CLEAR,
  55     TD_CHANGENUM,
  56     TD_CHANGESTATE,
  57     TD_PROTSTATUS,
  58     TD_REMOVE,
  59     TD_ADDCHANGEINT,
  60     TD_REMCHANGEINT,
  61     TD_GETDRIVETYPE,
  62     TD_GETNUMTRACKS,
  63     TD_FORMAT,
  64     TD_RAWREAD,
  65     TD_RAWWRITE,
  66     TD_SEEK,
  67     TD_MOTOR,
  68     ETD_READ,
  69     ETD_WRITE,
  70     ETD_UPDATE,
  71     ETD_CLEAR,
  72     ETD_MOTOR,
  73     ETD_SEEK,
  74     ETD_FORMAT,
  75     ETD_RAWREAD,
  76     ETD_RAWWRITE,
  77     NSCMD_DEVICEQUERY,
  78     0
  79 };
  80
  81 #endif
  82
  83 /****************************************************************************************/
  84
  85 static void FormatOFS(UBYTE *mem, ULONG number, struct unit *unit);
  86
  87 /****************************************************************************************/
  88
  89 static int GM_UNIQUENAME(Init)(LIBBASETYPEPTR ramdrivebase)
  90 {
  91     D(bug("ramdrive_device: in libinit func\n"));
  92
  93     InitSemaphore(&ramdrivebase->sigsem);
  94     NEWLIST((struct List *)&ramdrivebase->units);
  95     memset( &ramdrivebase->port, 0, sizeof( ramdrivebase->port ) );
  96     ramdrivebase->port.mp_Node.ln_Type = NT_MSGPORT;
  97     ramdrivebase->port.mp_Flags = PA_SIGNAL;
  98     ramdrivebase->port.mp_SigBit = SIGB_SINGLE;
  99     NEWLIST((struct List *)&ramdrivebase->port.mp_MsgList);
 100
 101     D(bug("ramdrive_device: in libinit func. Returning %x (success) :-)\n", ramdrivebase));
 102     return TRUE;
 103 }
 104
 105 /****************************************************************************************/
 106
 107 AROS_UFP3(LONG, unitentry,
 108     AROS_UFPA(STRPTR, argstr, A0),
 109     AROS_UFPA(ULONG, arglen, D0),
 110     AROS_UFPA(struct ExecBase *, SysBase, A6));
 111
 112 /****************************************************************************************/
 113
 114 static int GM_UNIQUENAME(Open)
 115 (
 116     LIBBASETYPEPTR ramdrivebase,
 117     struct IOExtTD *iotd,
 118     ULONG unitnum,
 119     ULONG flags
 120 )
 121 {
 122     static const struct TagItem tags[] =
 123     {
 124         { NP_Name       , (IPTR)"Ram Drive Unit Process"},
 125         { NP_Input      , 0                             },
 126         { NP_Output     , 0                             },
 127         { NP_Error      , 0                             },
 128         { NP_CurrentDir , 0                             },
 129         { NP_Priority   , 0                             },
 130         { NP_HomeDir    , 0                             },
 131         { NP_CopyVars   , 0                             },
 132         { NP_Entry      , (IPTR)unitentry               },
 133         { TAG_END       , 0                             }
 134     };
 135     struct unit *unit;
 136
 137     D(bug("ramdrive_device: in libopen func.\n"));
 138
 139     if (iotd->iotd_Req.io_Message.mn_Length < sizeof(struct IOExtTD))
 140     {
 141         D(bug("ramdrive.device/open: IORequest structure passed to OpenDevice is too small!\n"));
 142         iotd->iotd_Req.io_Error = IOERR_OPENFAIL;
 143         return FALSE;
 144     }
 145
 146     D(bug("ramdrive_device: in libopen func. Looking if unit is already open\n"));
 147
 148     ObtainSemaphore(&ramdrivebase->sigsem);
 149
 150     for(unit = (struct unit *)ramdrivebase->units.mlh_Head;
 151         unit->msg.mn_Node.ln_Succ != NULL;
 152         unit = (struct unit *)unit->msg.mn_Node.ln_Succ)
 153         if(unit->unitnum == unitnum)
 154         {
 155             unit->usecount++;
 156             ReleaseSemaphore(&ramdrivebase->sigsem);
 157
 158             iotd->iotd_Req.io_Unit                    = (struct Unit *)unit;
 159             iotd->iotd_Req.io_Error                   = 0;
 160             iotd->iotd_Req.io_Message.mn_Node.ln_Type = NT_REPLYMSG;
 161
 162             D(bug("ramdrive_device: in libopen func. Yep. Unit is already open\n"));
 163
 164             return TRUE;
 165         }
 166
 167     D(bug("ramdrive_device: in libopen func. No, it is not. So creating new unit ...\n"));
 168
 169     unit = (struct unit *)AllocMem(sizeof(struct unit), MEMF_PUBLIC);
 170     if(unit != NULL)
 171     {
 172         D(bug("ramdrive_device: in libopen func. Allocation of unit memory okay. Setting up unit and calling CreateNewProc ...\n"));
 173
 174         unit->usecount                  = 1;
 175         unit->ramdrivebase              = ramdrivebase;
 176         unit->unitnum                   = unitnum;
 177         unit->msg.mn_ReplyPort          = &ramdrivebase->port;
 178         unit->msg.mn_Length             = sizeof(struct unit);
 179         unit->port.mp_Node.ln_Type      = NT_MSGPORT;
 180         unit->port.mp_Flags             = PA_IGNORE;
 181         unit->port.mp_SigTask           = CreateNewProc((struct TagItem *)tags);
 182
 183         D(bug("ramdrive_device: in libopen func. CreateNewProc called. Proc = %x\n", unit->port.mp_SigTask));
 184
 185         if(unit->port.mp_SigTask != NULL)
 186         {
 187             NEWLIST((struct List *)&unit->port.mp_MsgList);
 188
 189             /* setup replyport to point to active task */
 190             ramdrivebase->port.mp_SigTask = FindTask(NULL);
 191             SetSignal(0, SIGF_SINGLE);
 192
 193             D(bug("ramdrive_device: in libopen func. Sending startup msg\n"));
 194             PutMsg(&((struct Process *)unit->port.mp_SigTask)->pr_MsgPort, &unit->msg);
 195
 196             D(bug("ramdrive_device: in libopen func. Waiting for replymsg\n"));
 197             WaitPort(&ramdrivebase->port);
 198             (void)GetMsg(&ramdrivebase->port);
 199             D(bug("ramdrive_device: in libopen func. Received replymsg\n"));
 200
 201             if(unit->mem)
 202             {
 203                 AddTail((struct List *)&ramdrivebase->units, &unit->msg.mn_Node);
 204                 iotd->iotd_Req.io_Unit = (struct Unit *)unit;
 205                 /* Set returncode */
 206                 iotd->iotd_Req.io_Error = 0;
 207                 ReleaseSemaphore(&ramdrivebase->sigsem);
 208                 return TRUE;
 209             }else
 210                 iotd->iotd_Req.io_Error = TDERR_NotSpecified;
 211         }else
 212             iotd->iotd_Req.io_Error = TDERR_NoMem;
 213         FreeMem(unit, sizeof(struct unit));
 214     }else
 215         iotd->iotd_Req.io_Error = TDERR_NoMem;
 216
 217     ReleaseSemaphore(&ramdrivebase->sigsem);
 218
 219     return FALSE;
 220 }
 221
 222 /****************************************************************************************/
 223
 224 static int GM_UNIQUENAME(Close)
 225 (
 226     LIBBASETYPEPTR ramdrivebase,
 227     struct IOExtTD *iotd
 228 )
 229 {
 230     struct unit *unit;
 231
 232     ObtainSemaphore(&ramdrivebase->sigsem);
 233     unit = (struct unit *)iotd->iotd_Req.io_Unit;
 234     if(!--unit->usecount)
 235     {
 236         Remove(&unit->msg.mn_Node);
 237         ramdrivebase->port.mp_SigTask = FindTask(NULL);
 238         SetSignal(0, SIGF_SINGLE);
 239         PutMsg(&unit->port, &unit->msg);
 240         WaitPort(&ramdrivebase->port);
 241         (void)GetMsg(&ramdrivebase->port);
 242         FreeMem(unit, sizeof(struct unit));
 243     }
 244     ReleaseSemaphore(&ramdrivebase->sigsem);
 245
 246     return TRUE;
 247 }
 248
 249 /****************************************************************************************/
 250
 251 ADD2INITLIB(GM_UNIQUENAME(Init), 0)
 252 ADD2OPENDEV(GM_UNIQUENAME(Open), 0)
 253 ADD2CLOSEDEV(GM_UNIQUENAME(Close), 0)
 254
 255 /****************************************************************************************/
 256
 257 AROS_LH1(void, beginio,
 258     AROS_LHA(struct IOExtTD *, iotd, A1),
 259     struct ramdrivebase *, ramdrivebase, 5, Ramdrive)
 260 {
 261     AROS_LIBFUNC_INIT
 262
 263     switch(iotd->iotd_Req.io_Command)
 264     {
 265 #if NEWSTYLE_DEVICE
 266         case NSCMD_DEVICEQUERY:
 267             if(iotd->iotd_Req.io_Length < ((LONG)OFFSET(NSDeviceQueryResult, SupportedCommands)) + sizeof(UWORD *))
 268             {
 269                 iotd->iotd_Req.io_Error = IOERR_BADLENGTH;
 270             }
 271             else
 272             {
 273                 struct NSDeviceQueryResult *d;
 274
 275                 d = (struct NSDeviceQueryResult *)iotd->iotd_Req.io_Data;
 276
 277                 d->DevQueryFormat           = 0;
 278                 d->SizeAvailable            = sizeof(struct NSDeviceQueryResult);
 279                 d->DeviceType       = NSDEVTYPE_TRACKDISK;
 280                 d->DeviceSubType            = 0;
 281                 d->SupportedCommands    = (UWORD *)SupportedCommands;
 282
 283                 iotd->iotd_Req.io_Actual = sizeof(struct NSDeviceQueryResult);
 284                 iotd->iotd_Req.io_Error  = 0;
 285
 286             }
 287             break;
 288 #endif
 289
 290         case TD_CHANGENUM:
 291             /* result: io_Actual = disk change counter */
 292
 293         case TD_CHANGESTATE:
 294             /* result: io_Actual = disk presence indicator (0 = disk is in drive) */
 295
 296         case TD_PROTSTATUS:
 297             /* result: io_Actual = disk protection status (0 = not protected) */
 298
 299             iotd->iotd_Req.io_Actual = 0;
 300             iotd->iotd_Req.io_Error = 0;
 301             break;
 302
 303         case ETD_UPDATE:
 304         case CMD_UPDATE:
 305         case ETD_CLEAR:
 306         case CMD_CLEAR:
 307         case TD_REMOVE:
 308         case TD_ADDCHANGEINT:
 309         case TD_REMCHANGEINT:
 310             /* Ignore but don't fail */
 311             iotd->iotd_Req.io_Error = 0;
 312             break;
 313
 314         case TD_GETDRIVETYPE:
 315             iotd->iotd_Req.io_Actual = DRIVE3_5;
 316             iotd->iotd_Req.io_Error = 0;
 317             break;
 318
 319         case TD_GETNUMTRACKS:
 320             iotd->iotd_Req.io_Actual = NUM_TRACKS;
 321             iotd->iotd_Req.io_Error = 0;
 322             break;
 323
 324         case CMD_FLUSH:
 325             {
 326                 struct IOExtTD *flushed_iotd;
 327                 struct unit    *u =(struct unit *)iotd->iotd_Req.io_Unit;
 328                 Forbid();
 329                 while((flushed_iotd = (struct IOExtTD *)GetMsg(&u->port)))
 330                 {
 331                     flushed_iotd->iotd_Req.io_Error = IOERR_ABORTED;
 332                     ReplyMsg(&flushed_iotd->iotd_Req.io_Message);
 333                 }
 334                 Permit();
 335             }
 336             break;
 337
 338         case ETD_READ:
 339         case CMD_READ:
 340         case ETD_WRITE:
 341         case CMD_WRITE:
 342         case ETD_FORMAT:
 343         case TD_FORMAT:
 344         case ETD_RAWREAD:
 345         case TD_RAWREAD:
 346         case ETD_RAWWRITE:
 347         case TD_RAWWRITE:
 348         case ETD_SEEK:
 349         case TD_SEEK:
 350         case ETD_MOTOR:
 351         case TD_MOTOR:
 352             /* Not done quick */
 353             iotd->iotd_Req.io_Flags &= ~IOF_QUICK;
 354
 355             /* Forward to unit thread */
 356             PutMsg(&((struct unit *)iotd->iotd_Req.io_Unit)->port,
 357                    &iotd->iotd_Req.io_Message);
 358             return;
 359
 360         default:
 361             /* Not supported */
 362             iotd->iotd_Req.io_Error = IOERR_NOCMD;
 363             break;
 364
 365     } /* switch(iotd->iotd_Req.io_Command) */
 366
 367     /* WaitIO will look into this */
 368     iotd->iotd_Req.io_Message.mn_Node.ln_Type = NT_MESSAGE;
 369
 370     /* Finish message */
 371     if(!(iotd->iotd_Req.io_Flags&IOF_QUICK))
 372         ReplyMsg(&iotd->iotd_Req.io_Message);
 373
 374     AROS_LIBFUNC_EXIT
 375 }
 376
 377 /****************************************************************************************/
 378
 379 AROS_LH1(LONG, abortio,
 380  AROS_LHA(struct IOExtTD *, iotd, A1),
 381            struct ramdrivebase *, ramdrivebase, 6, Ramdrive)
 382 {
 383     AROS_LIBFUNC_INIT
 384
 385     return IOERR_NOCMD;
 386
 387     AROS_LIBFUNC_EXIT
 388 }
 389
 390 /****************************************************************************************/
 391
 392 AROS_LH0(STRPTR, killrad0,
 393            struct ramdrivebase *, ramdrivebase, 7, Ramdrive)
 394 {
 395     AROS_LIBFUNC_INIT
 396
 397     /* FIXME: KillRAD0 not implemented yet */
 398
 399     return 0;
 400
 401     AROS_LIBFUNC_EXIT
 402 }
 403
 404 /****************************************************************************************/
 405
 406 AROS_LH1(STRPTR, killrad,
 407  AROS_LHA(ULONG, unit, D0),
 408            struct ramdrivebase *, ramdrivebase, 8, Ramdrive)
 409 {
 410     AROS_LIBFUNC_INIT
 411
 412     /* FIXME: KillRAD not implemented yet */
 413
 414     return 0;
 415
 416     AROS_LIBFUNC_EXIT
 417 }
 418
 419 /****************************************************************************************/
 420
 421 #define ramdrivebase unit->ramdrivebase
 422
 423 /****************************************************************************************/
 424
 425 static LONG read(struct unit *unit, struct IOExtTD *iotd)
 426 {
 427     STRPTR      buf;
 428     ULONG       offset, size;
 429
 430     D(bug("ramdrive_device/read: offset = %d  size = %d\n", iotd->iotd_Req.io_Offset, iotd->iotd_Req.io_Length));
 431
 432     if(iotd->iotd_SecLabel)
 433     {
 434         D(bug("ramdrive_device/read: iotd->iotd_SecLabel is != NULL -> returning IOERR_NOCMD\n"));
 435         return IOERR_NOCMD;
 436     }
 437
 438     buf    = iotd->iotd_Req.io_Data;
 439     offset = iotd->iotd_Req.io_Offset;
 440     size   = iotd->iotd_Req.io_Length;
 441
 442     unit->headpos = offset;
 443
 444     if (offset + size > DISKSIZE)
 445     {
 446         D(bug("ramdrive_device/read: Seek to offset %d failed. Returning TDERR_SeekError\n", offset));
 447         return TDERR_SeekError;
 448     }
 449
 450     CopyMem(&unit->mem[offset], buf, size);
 451
 452     iotd->iotd_Req.io_Actual = size;
 453
 454 #if DEBUG
 455     buf = iotd->iotd_Req.io_Data;
 456     D(bug("ramdrive_device/read: returning 0. First 4 buffer bytes = [%c%c%c%c]\n", buf[0], buf[1], buf[2], buf[3]));
 457 #endif
 458
 459     return 0;
 460 }
 461
 462 /****************************************************************************************/
 463
 464 static LONG write(struct unit *unit, struct IOExtTD *iotd)
 465 {
 466     STRPTR      buf;
 467     ULONG       offset, size;
 468
 469     if(iotd->iotd_SecLabel)
 470         return IOERR_NOCMD;
 471
 472     buf    = iotd->iotd_Req.io_Data;
 473     offset = iotd->iotd_Req.io_Offset;
 474     size   = iotd->iotd_Req.io_Length;
 475
 476     unit->headpos = offset;
 477
 478     if (offset + size > DISKSIZE)
 479     {
 480         D(bug("ramdrive_device/write: Seek to offset %d failed. Returning TDERR_SeekError\n", offset));
 481         return TDERR_SeekError;
 482     }
 483
 484     iotd->iotd_Req.io_Actual = size;
 485
 486     CopyMem(buf, &unit->mem[offset], size);
 487
 488     return 0;
 489 }
 490
 491 /****************************************************************************************/
 492
 493 AROS_UFH3(LONG, unitentry,
 494  AROS_UFHA(STRPTR, argstr, A0),
 495  AROS_UFHA(ULONG, arglen, D0),
 496  AROS_UFHA(struct ExecBase *, SysBase, A6))
 497 {
 498     AROS_USERFUNC_INIT
 499
 500     struct Process      *me;
 501     LONG                err = 0L;
 502     struct IOExtTD      *iotd;
 503     struct unit         *unit;
 504
 505     D(bug("ramdrive_device/unitentry: just started\n"));
 506
 507     me = (struct Process *)FindTask(NULL);
 508
 509     WaitPort(&me->pr_MsgPort);
 510     unit = (struct unit *)GetMsg(&me->pr_MsgPort);
 511     unit->port.mp_SigBit = AllocSignal(-1);
 512     unit->port.mp_Flags = PA_SIGNAL;
 513
 514     D(bug("ramdrive_device/unitentry: Trying to allocate memory disk\n"));
 515
 516     unit->mem = AllocVec(DISKSIZE, MEMF_PUBLIC | MEMF_CLEAR);
 517     if(!unit->mem)
 518     {
 519         D(bug("ramdrive_device/unitentry: Memory allocation failed :-( Replying startup msg.\n"));
 520
 521         Forbid();
 522         ReplyMsg(&unit->msg);
 523         return 0;
 524     }
 525
 526     D(bug("ramdrive_device/unitentry: Memory allocation okay :-) Replying startup msg.\n"));
 527
 528     FormatOFS(unit->mem, unit->unitnum, unit);
 529
 530     ReplyMsg(&unit->msg);
 531
 532     D(bug("ramdrive_device/unitentry: Now entering main loop\n"));
 533
 534     for(;;)
 535     {
 536         while((iotd = (struct IOExtTD *)GetMsg(&unit->port)) != NULL)
 537         {
 538             if(&iotd->iotd_Req.io_Message == &unit->msg)
 539             {
 540                 D(bug("ramdrive_device/unitentry: Recevied EXIT message.\n"));
 541
 542                 FreeVec(unit->mem);
 543                 Forbid();
 544                 ReplyMsg(&unit->msg);
 545                 return 0;
 546             }
 547
 548             switch(iotd->iotd_Req.io_Command)
 549             {
 550                 case ETD_RAWREAD:
 551                 case TD_RAWREAD:
 552                     /*
 553                     ** same as CMD_READ, but offset does not have to be multiple of
 554                     ** BLOCKSIZE
 555                     **
 556                     ** fall through
 557                     */
 558
 559                 case ETD_READ:
 560                 case CMD_READ:
 561                     D(bug("ramdrive_device/unitentry: received CMD_READ.\n"));
 562                     err = read(unit, iotd);
 563                     break;
 564
 565                 case ETD_RAWWRITE:
 566                 case TD_RAWWRITE:
 567                     /*
 568                     ** same as CMD_WRITE, but offset does not have to be multiple of
 569                     ** BLOCKSIZE
 570                     **
 571                     ** fall through
 572                     */
 573
 574                 case ETD_WRITE:
 575                 case CMD_WRITE:
 576                 case ETD_FORMAT:
 577                 case TD_FORMAT:
 578                     D(bug("ramdrive_device/unitentry: received %s\n", (iotd->iotd_Req.io_Command == CMD_WRITE) ? "CMD_WRITE" : "TD_FORMAT"));
 579                     err = write(unit, iotd);
 580                     break;
 581
 582                 case ETD_MOTOR:
 583                 case TD_MOTOR:
 584                     /*
 585                     ** DOS wants the previous state in io_Actual.
 586                     ** We return "!io_Actual"
 587                     */
 588
 589                     iotd->iotd_Req.io_Actual = (iotd->iotd_Req.io_Actual == 1) ? 0 : 1;
 590                     err = 0;
 591                     break;
 592
 593                 case ETD_SEEK:
 594                 case TD_SEEK:
 595                     unit->headpos = iotd->iotd_Req.io_Actual;
 596                     err = 0;
 597                     break;
 598
 599             } /* switch(iotd->iotd_Req.io_Command) */
 600
 601             iotd->iotd_Req.io_Error = err;
 602             ReplyMsg(&iotd->iotd_Req.io_Message);
 603
 604         } /* while((iotd = (struct IOExtTD *)GetMsg(&unit->port)) != NULL) */
 605
 606         WaitPort(&unit->port);
 607
 608     } /* for(;;) */
 609
 610     AROS_USERFUNC_EXIT
 611 }
 612
 613 /****************************************************************************************/
 614
 615 /* The following routines are based on TurboDevice by Thomas Dreibholz */
 616
 617 /****************************************************************************************/
 618
 619 static ULONG CalcRootBlock(void)
 620 {
 621     return NUM_CYL * NUM_HEADS * NUM_SECS / 2;
 622 }
 623
 624 /****************************************************************************************/
 625
 626 static ULONG CalcBitMap(void)
 627 {
 628     return CalcRootBlock() + 1;
 629 }
 630
 631 /****************************************************************************************/
 632
 633 VOID RootBlockCheckSum(UBYTE *buf)
 634 {
 635     LONG checksum, *long_ptr;
 636     LONG  i;
 637
 638     long_ptr = (ULONG *)buf;
 639     checksum = 0;
 640
 641     for(i = 0; i < TD_SECTOR / 4; i++)
 642     {
 643         checksum += AROS_BE2LONG(long_ptr[i]);
 644     }
 645     long_ptr[5] = AROS_LONG2BE(-checksum);
 646 }
 647
 648 /****************************************************************************************/
 649
 650 VOID CalcBitMapCheckSum(UBYTE *buf)
 651 {
 652     LONG checksum, i;
 653     LONG *long_ptr = (LONG *)buf;
 654
 655     for(i = 1, checksum = 0; i < TD_SECTOR / 4; i++)
 656     {
 657         checksum += AROS_BE2LONG(long_ptr[i]);
 658     }
 659     long_ptr[0] = AROS_LONG2BE(-checksum);
 660 }
 661
 662 /****************************************************************************************/
 663
 664 VOID InstallRootBlock(UBYTE *buf, STRPTR diskname, ULONG bitmap,
 665                       struct unit *unit)
 666 {
 667     struct DateStamp ds;
 668     ULONG            *long_ptr;
 669     LONG             i;
 670
 671     long_ptr      = (ULONG *)buf;
 672     long_ptr[0]   = AROS_LONG2BE(2);
 673     long_ptr[3]   = AROS_LONG2BE(72);
 674     long_ptr[78]  = AROS_LONG2BE(-1);
 675     long_ptr[79]  = AROS_LONG2BE(bitmap);
 676     long_ptr[127] = AROS_LONG2BE(1);
 677
 678     DateStamp(&ds);
 679
 680     long_ptr[121] = AROS_LONG2BE(ds.ds_Days);
 681     long_ptr[122] = AROS_LONG2BE(ds.ds_Minute);
 682     long_ptr[123] = AROS_LONG2BE(ds.ds_Tick);
 683
 684     long_ptr[105] = AROS_LONG2BE(ds.ds_Days);
 685     long_ptr[106] = AROS_LONG2BE(ds.ds_Minute);
 686     long_ptr[107] = AROS_LONG2BE(ds.ds_Tick);
 687
 688     buf[432] = (UBYTE)strlen(diskname);
 689
 690     for(i = 0; i < strlen(diskname); i++)
 691     {
 692         buf[433+i] = diskname[i];
 693     }
 694
 695     RootBlockCheckSum(buf);
 696 }
 697
 698 /****************************************************************************************/
 699
 700 static ULONG CalcBlocks(void)
 701 {
 702     return NUM_CYL * NUM_HEADS * NUM_SECS - 1;
 703 }
 704
 705 /****************************************************************************************/
 706
 707 static void AllocBitMapBlock(LONG block, UBYTE *buf)
 708 {
 709     ULONG *long_ptr = (ULONG *)buf;
 710     LONG  longword, bit;
 711     LONG  old_long, new_long;
 712
 713     longword = (block - 2) / 32;
 714     bit = block - 2 - longword * 32;
 715     old_long = AROS_BE2LONG(long_ptr[longword + 1]);
 716     new_long = old_long & (0xFFFFFFFF - (1L << bit));
 717
 718     long_ptr[longword + 1] = AROS_LONG2BE(new_long);
 719 }
 720
 721 /****************************************************************************************/
 722
 723 static void FreeBitMapBlock(LONG block, UBYTE *buf)
 724 {
 725     ULONG *long_ptr = (ULONG *)buf;
 726     LONG  longword, bit;
 727     LONG  old_long, new_long;
 728
 729     longword = (block - 2) / 32;
 730     bit = block - 2 - longword * 32;
 731     old_long = AROS_BE2LONG(long_ptr[longword + 1]);
 732     new_long = old_long | (1L << bit);
 733
 734     long_ptr[longword + 1] = AROS_LONG2BE(new_long);
 735 }
 736
 737 /****************************************************************************************/
 738
 739 static void FormatOFS(UBYTE *mem, ULONG number, struct unit *unit)
 740 {
 741     ULONG a,b,c,d;
 742     UBYTE *cmem;
 743     UBYTE Name[6];
 744
 745     mem[0]='D';
 746     mem[1]='O';
 747     mem[2]='S';
 748     mem[3]=0x00;
 749
 750     a = CalcRootBlock();
 751     b = CalcBitMap();
 752
 753     cmem = mem + (a * TD_SECTOR);
 754     strcpy(Name, "RAM_#");
 755     Name[4] = '0' + number;
 756
 757     InstallRootBlock(cmem, Name, b, unit);
 758     cmem = mem + (b * TD_SECTOR);
 759     d = CalcBlocks();
 760     for(c = 2; c <= d; c++)
 761     {
 762         FreeBitMapBlock(c, cmem);
 763     }
 764
 765     AllocBitMapBlock(a, cmem);
 766     AllocBitMapBlock(b, cmem);
 767
 768     CalcBitMapCheckSum(cmem);
 769 }
 770
 771 /****************************************************************************************/
 772
 773 const char end = 0;
 774
 775 /****************************************************************************************/