workbench/devs/ramdrive_device.c

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