rom/devs/trackdisk/trackdisk_device.c

   1 /*
   2     Copyright © 1995-2014, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Amiga-style device for trackdisk
   6     Lang: English
   7 */
   8
   9 #include <devices/trackdisk.h>
  10 #include <exec/resident.h>
  11 #include <exec/errors.h>
  12 #include <exec/memory.h>
  13 #include <exec/lists.h>
  14 #include <exec/alerts.h>
  15 #include <exec/tasks.h>
  16 #include <libraries/expansion.h>
  17 #include <libraries/expansionbase.h>
  18 #include <libraries/configvars.h>
  19 #include <dos/filehandler.h>
  20 #include <dos/dosextens.h>
  21 #include <dos/dostags.h>
  22 #include <clib/alib_protos.h>
  23 #include <aros/symbolsets.h>
  24 #include <aros/bootloader.h>
  25 #include <oop/oop.h>
  26
  27 #include <proto/oop.h>
  28 #include <proto/exec.h>
  29 #include <proto/expansion.h>
  30 #include <proto/utility.h>
  31 #include <proto/bootloader.h>
  32 #include <proto/dos.h>
  33 #include <asm/io.h>
  34
  35 #include <SDI/SDI_interrupt.h>
  36
  37 #include "trackdisk_device.h"
  38 #include "trackdisk_hw.h"
  39
  40 #include LC_LIBDEFS_FILE
  41
  42 #define DEBUG 0
  43 #include <aros/debug.h>
  44
  45 #undef kprintf
  46
  47 int td_getbyte(unsigned char *, struct TrackDiskBase *);
  48 int td_sendbyte(unsigned char, struct TrackDiskBase *);
  49 ULONG TD_InitTask(struct TrackDiskBase *);
  50 static void TD_DevTask();
  51 BOOL TD_PerformIO( struct IOExtTD *, struct TrackDiskBase *);
  52
  53 struct TDU *TD_InitUnit(ULONG num, struct TrackDiskBase *tdb)
  54 {
  55     struct TDU     *unit;
  56     struct ExpansionBase *ExpansionBase = NULL;
  57     struct DeviceNode *devnode;
  58     IPTR *pp;
  59     TEXT dosdevname[4] = "DF0", *handler = "FastFileSystem";
  60     UWORD len;
  61
  62     /* Try to get memory for structure */
  63     unit = AllocMem(sizeof(struct TDU), MEMF_PUBLIC | MEMF_CLEAR);
  64
  65     if (!tdb->td_nomount)
  66         ExpansionBase = (struct ExpansionBase *)OpenLibrary("expansion.library",40);
  67     if (unit)
  68     {
  69         unit->tdu_DiskIn = TDU_NODISK;  /* Assume there is no floppy in there */
  70         unit->pub.tdu_StepDelay = 4;    /* Standard values here */
  71         unit->pub.tdu_SettleDelay = 16;
  72         unit->pub.tdu_RetryCnt = 3;
  73         unit->pub.tdu_CalibrateDelay = 4;
  74         unit->tdu_UnitNum=num;
  75         unit->tdu_lastcyl = -1;
  76         unit->tdu_lasthd = -1;
  77         NEWLIST(&unit->tdu_Listeners);
  78
  79         /* Alloc memory for track buffering */
  80         unit->td_DMABuffer = AllocMem(DP_SECTORS * 512, MEMF_CLEAR | MEMF_24BITDMA);
  81
  82         if (!unit->td_DMABuffer)
  83         {
  84             Alert(AT_DeadEnd | AO_TrackDiskDev | AG_NoMemory);
  85         }
  86
  87         /* If buffer doesn't fit into DMA page realloc it */
  88         /* FIXME: we should ensure that the buffer is suitable the first time,
  89            either by using an aligned memory allocation function or by
  90            allocating twice as much as needed and manually aligning */
  91         if (( (((ULONG)(IPTR)unit->td_DMABuffer + DP_SECTORS*512) & 0xffff0000) -
  92                     ((ULONG)(IPTR)unit->td_DMABuffer&0xffff0000) ) != 0)
  93         {
  94             APTR buffer;
  95
  96             buffer = AllocMem(DP_SECTORS * 512, MEMF_CLEAR | MEMF_24BITDMA);
  97             if (!buffer)
  98             {
  99                 Alert(AT_DeadEnd | AO_TrackDiskDev | AG_NoMemory);
 100             }
 101
 102             FreeMem(unit->td_DMABuffer, DP_SECTORS*512);
 103             unit->td_DMABuffer = buffer;
 104         }
 105         /* Store the unit in TDBase */
 106         tdb->td_Units[num] = unit;
 107
 108         if (ExpansionBase)
 109         {
 110             D(bug("TD: Adding bootnode\n"));
 111             pp = (IPTR *)AllocMem(sizeof(struct DosEnvec)+sizeof(IPTR)*4,MEMF_PUBLIC|MEMF_CLEAR);
 112
 113             if (pp)
 114             {
 115                 dosdevname[2] += num;
 116                 pp[0] = (IPTR)dosdevname;
 117                 pp[1] = (IPTR)MOD_NAME_STRING;
 118                 pp[2] = num;
 119                 pp[DE_TABLESIZE + 4] = DE_BOOTBLOCKS;
 120                 pp[DE_SIZEBLOCK + 4] = 128;
 121                 pp[DE_NUMHEADS + 4] = 2;
 122                 pp[DE_SECSPERBLOCK + 4] = 1;
 123                 pp[DE_BLKSPERTRACK + 4] = 18;
 124                 pp[DE_RESERVEDBLKS + 4] = 2;
 125                 pp[DE_LOWCYL + 4] = 0;
 126                 pp[DE_HIGHCYL + 4] = 79;
 127                 pp[DE_NUMBUFFERS + 4] = 10;
 128                 pp[DE_BUFMEMTYPE + 4] = MEMF_PUBLIC | MEMF_24BITDMA;
 129                 pp[DE_MAXTRANSFER + 4] = 0x00200000;
 130                 pp[DE_MASK + 4] = 0x7FFFFFFE;
 131                 pp[DE_BOOTPRI + 4] = 5;
 132                 pp[DE_DOSTYPE + 4] = 0;
 133                 pp[DE_BOOTBLOCKS + 4] = 2;
 134                 devnode = MakeDosNode(pp);
 135
 136                 if (devnode)
 137                 {
 138                     len = strlen(handler);
 139                     devnode->dn_Handler = MKBADDR(AllocMem(
 140                         AROS_BSTR_MEMSIZE4LEN(len), MEMF_PUBLIC | MEMF_CLEAR)
 141                     );
 142
 143                     if (devnode->dn_Handler != BNULL)
 144                     {
 145                         CopyMem(handler, AROS_BSTR_ADDR(devnode->dn_Handler),
 146                             len);
 147                         AROS_BSTR_setstrlen(devnode->dn_Handler, len);
 148                         AddBootNode(pp[DE_BOOTPRI + 4], 0, devnode, NULL);
 149                     }
 150                 }
 151             }
 152         }
 153     }
 154     if (ExpansionBase)
 155     {
 156         CloseLibrary((struct Library *)ExpansionBase);
 157     }
 158     return (unit);
 159 }
 160
 161 static AROS_INTH1(td_floppytimer, struct TrackDiskBase *, TDBase)
 162 {
 163     AROS_INTFUNC_INIT
 164
 165     // Does anyone wait for io?
 166     if (TDBase->td_inttmo)
 167     {
 168         // Decrease timeout
 169         TDBase->td_inttmo--;
 170         // timeout?
 171         if (!TDBase->td_inttmo)
 172         {
 173             Signal(&TDBase->td_TaskData->td_Task,(1L << TDBase->td_TmoBit));
 174         }
 175     }
 176
 177     return FALSE;
 178
 179     AROS_INTFUNC_EXIT
 180 }
 181
 182 static AROS_INTH1(td_floppyint, struct TrackDiskBase *, TDBase)
 183 {
 184     AROS_INTFUNC_INIT
 185
 186     Signal(&TDBase->td_TaskData->td_Task,(1L << TDBase->td_IntBit));
 187
 188     return FALSE;
 189
 190     AROS_INTFUNC_EXIT
 191 }
 192
 193 static int GM_UNIQUENAME(Init)(LIBBASETYPEPTR TDBase)
 194 {
 195     struct BootLoaderBase *BootLoaderBase;
 196     ULONG i;
 197     UBYTE drives;
 198     struct Interrupt *irq;
 199
 200     D(bug("TD: Init\n"));
 201
 202     /* First thing, are we disabled from the bootloader? */
 203     if ((BootLoaderBase = OpenResource("bootloader.resource")))
 204     {
 205         struct List *list;
 206         struct Node *node;
 207
 208         list = (struct List *)GetBootInfo(BL_Args);
 209         if (list)
 210         {
 211             ForeachNode(list,node)
 212             {
 213                 if (0 == strncmp(node->ln_Name,"floppy=",5))
 214                 {
 215                     if (strstr(&node->ln_Name[7], "disabled"))
 216                     {
 217                         D(bug("[Floppy] Disabled with bootloader argument\n"));
 218                         return FALSE;
 219                     }
 220                     TDBase->td_nomount = (strstr(&node->ln_Name[7], "nomount") != NULL);
 221                 }
 222             }
 223         }
 224     }
 225
 226     /* First we check if there are any floppy drives configured in BIOS */
 227     /* We do this by reading CMOS byte 0x10 */
 228     /* It should really reside in battclock.resource */
 229     outb(0x10,0x70);
 230     drives = inb(0x71);
 231
 232     if (drives == 0)
 233     {
 234         /* No drives here. abort */
 235         D(bug("TD: No drives defined in BIOS\n"));
 236         return FALSE;
 237     }
 238
 239     for (i=0; i<TD_NUMUNITS; i++)
 240         TDBase->td_Units[i] = NULL;
 241
 242     irq = &TDBase->td_FloppyInt;
 243     irq->is_Node.ln_Type = NT_INTERRUPT;
 244     irq->is_Node.ln_Pri=127;            /* Set the highest pri */
 245     irq->is_Node.ln_Name = (STRPTR)MOD_NAME_STRING;
 246     irq->is_Code = (VOID_FUNC)td_floppyint;
 247     irq->is_Data = (APTR)TDBase;
 248
 249     AddIntServer(INTB_KERNEL + 6, irq);
 250
 251     irq = &TDBase->td_TimerInt;
 252     irq->is_Node.ln_Type = NT_INTERRUPT;
 253     irq->is_Node.ln_Pri=10;             /* Set the highest pri */
 254     irq->is_Node.ln_Name = (STRPTR)MOD_NAME_STRING;
 255     irq->is_Code = (VOID_FUNC)td_floppytimer;
 256     irq->is_Data = (APTR)TDBase;
 257
 258     AddIntServer(INTB_KERNEL + 0, irq);
 259
 260     /* Swap drivebits around */
 261     drives = ( (drives&0xf0)>>4 | (drives&0x0f)<<4 );
 262
 263     for (i=0;i<TD_NUMUNITS;i++)
 264     {
 265         /* We only want 3.5" 1.44MB drives */
 266         if (((drives >> (4*i))&0x0f) == 4)
 267         {
 268             kprintf("[Floppy] Unit %d is a 1.44MB drive\n",i);
 269             TD_InitUnit(i,TDBase);
 270         }
 271     }
 272
 273     /* Create the message processor task */
 274     TD_InitTask(TDBase);
 275
 276     return TRUE;
 277 }
 278
 279 static int GM_UNIQUENAME(Open)
 280 (
 281     LIBBASETYPEPTR TDBase,
 282     struct IOExtTD *iotd,
 283     ULONG unitnum,
 284     ULONG flags
 285 )
 286 {
 287     D(bug("TD: Open\n"));
 288     iotd->iotd_Req.io_Error = IOERR_OPENFAIL;
 289
 290     /* Is the requested unitNumber valid? */
 291     if (unitnum < TD_NUMUNITS)
 292     {
 293         struct TDU *unit;
 294
 295         iotd->iotd_Req.io_Device = (struct Device *)TDBase;
 296
 297         /* Get TDU structure */
 298         unit = TDBase->td_Units[unitnum];
 299         if (unit && (unit->tdu_Present)) {
 300             iotd->iotd_Req.io_Unit = (struct Unit *)unit;
 301             ((struct Unit *)unit)->unit_OpenCnt++;
 302             iotd->iotd_Req.io_Error = 0;
 303         }
 304     }
 305
 306     return iotd->iotd_Req.io_Error == 0;
 307
 308 }
 309
 310 static int GM_UNIQUENAME(Close)
 311 (
 312     LIBBASETYPEPTR TDBase,
 313     struct IOExtTD *iotd
 314 )
 315 {
 316     iotd->iotd_Req.io_Unit->unit_OpenCnt --;
 317
 318     return TRUE;
 319 }
 320
 321 ADD2INITLIB(GM_UNIQUENAME(Init), 0)
 322 ADD2OPENDEV(GM_UNIQUENAME(Open), 0)
 323 ADD2CLOSEDEV(GM_UNIQUENAME(Close), 0)
 324
 325 AROS_LH1(void, beginio,
 326  AROS_LHA(struct IOExtTD *, iotd, A1),
 327  struct TrackDiskBase *, TDBase, 5, TrackDisk)
 328 {
 329     AROS_LIBFUNC_INIT
 330     struct TDU *tdu;
 331
 332     if (iotd->iotd_Req.io_Flags & IOF_QUICK)
 333     {
 334         switch(iotd->iotd_Req.io_Command)
 335         {
 336             case TD_CHANGESTATE:
 337                 tdu = (struct TDU *)iotd->iotd_Req.io_Unit;
 338                 if ((!(tdu->pub.tdu_PubFlags & TDPF_NOCLICK)) || (tdu->tdu_DiskIn == TDU_DISK))
 339                     break;
 340             case CMD_READ:
 341             case CMD_UPDATE:
 342             case CMD_WRITE:
 343             case TD_FORMAT:
 344             case TD_MOTOR:
 345             case TD_SEEK:
 346             case ETD_READ:
 347             case ETD_UPDATE:
 348             case ETD_WRITE:
 349             case ETD_FORMAT:
 350             case ETD_MOTOR:
 351             case ETD_SEEK:
 352                 PutMsg(&TDBase->td_TaskData->td_Port, &iotd->iotd_Req.io_Message);
 353                 iotd->iotd_Req.io_Flags &= ~IOF_QUICK;
 354                 return;
 355         }
 356         TD_PerformIO(iotd,TDBase);
 357         return;
 358     }
 359     else
 360     {
 361         /* Forward to devicetask */
 362         PutMsg(&TDBase->td_TaskData->td_Port, &iotd->iotd_Req.io_Message);
 363         /* Not done quick */
 364         iotd->iotd_Req.io_Flags &= ~IOF_QUICK;
 365         return;
 366     }
 367     AROS_LIBFUNC_EXIT
 368 }
 369
 370 AROS_LH1(LONG, abortio,
 371  AROS_LHA(struct IOExtTD *, iotd, A1),
 372  struct TrackDiskBase *, TDBase, 6, TrackDisk)
 373 {
 374     AROS_LIBFUNC_INIT
 375     D(bug("TD: AbortIO\n"));
 376     return IOERR_NOCMD;
 377     AROS_LIBFUNC_EXIT
 378 }
 379
 380 void TestInsert(struct TrackDiskBase *tdb, struct TDU *tdu)
 381 {
 382     UBYTE dir;
 383     struct IOExtTD *iotd;
 384
 385     td_rseek(tdu->tdu_UnitNum,tdu->tdu_stepdir,1,tdb);
 386     tdu->tdu_stepdir = !tdu->tdu_stepdir;
 387     dir = (inb(FDC_DIR)>>7);
 388     if (dir == 0)
 389     {
 390         D(bug("[Floppy] Insertion detected\n"));
 391         td_recalibrate(tdu->tdu_UnitNum,1,0,tdb);
 392         tdu->tdu_DiskIn = TDU_DISK;
 393         tdu->pub.tdu_Counter++;
 394         tdu->tdu_ProtStatus = td_getprotstatus(tdu->tdu_UnitNum,tdb);
 395         Forbid();
 396         ForeachNode(&tdu->tdu_Listeners,iotd)
 397         {
 398             Cause((struct Interrupt *)((struct IOExtTD *)iotd->iotd_Req.io_Data));
 399         }
 400         Permit();
 401     }
 402 }
 403
 404 BOOL TD_PerformIO( struct IOExtTD *iotd, struct TrackDiskBase *tdb)
 405 {
 406     struct TDU *tdu;
 407     struct DriveGeometry *geo;
 408     UBYTE temp;
 409     BOOL reply;
 410
 411     reply = TRUE;
 412     tdu = (struct TDU *)iotd->iotd_Req.io_Unit;
 413     switch(iotd->iotd_Req.io_Command)
 414     {
 415         case ETD_CLEAR:
 416             if (iotd->iotd_Count > tdu->pub.tdu_Counter) {
 417                 iotd->iotd_Req.io_Error = TDERR_DiskChanged;
 418                 break;
 419             }
 420         case CMD_CLEAR:
 421             tdu->tdu_flags = 0;
 422             tdu->tdu_lastcyl = -1;
 423             tdu->tdu_lasthd = -1;
 424             iotd->iotd_Req.io_Error = 0;
 425             break;
 426         case ETD_READ:
 427             if (iotd->iotd_Count > tdu->pub.tdu_Counter) {
 428                 iotd->iotd_Req.io_Error = TDERR_DiskChanged;
 429                 break;
 430             }
 431         case CMD_READ:
 432             tdu->tdu_Busy = TRUE;
 433             iotd->iotd_Req.io_Error = td_read(iotd, tdb);
 434             tdu->tdu_Busy = FALSE;
 435             break;
 436         case ETD_UPDATE:
 437             if (iotd->iotd_Count > tdu->pub.tdu_Counter) {
 438                 iotd->iotd_Req.io_Error = TDERR_DiskChanged;
 439                 break;
 440             }
 441         case CMD_UPDATE:
 442             tdu->tdu_Busy = TRUE;
 443             iotd->iotd_Req.io_Error = td_update(tdu, tdb);
 444             tdu->tdu_Busy = FALSE;
 445             break;
 446         case ETD_WRITE:
 447             if (iotd->iotd_Count > tdu->pub.tdu_Counter) {
 448                 iotd->iotd_Req.io_Error = TDERR_DiskChanged;
 449                 break;
 450             }
 451         case CMD_WRITE:
 452             tdu->tdu_Busy = TRUE;
 453             iotd->iotd_Req.io_Error = td_write(iotd, tdb);
 454             tdu->tdu_Busy = FALSE;
 455             break;
 456         case TD_ADDCHANGEINT:
 457             Forbid();
 458             AddTail(&tdu->tdu_Listeners,(struct Node *)iotd);
 459             Permit();
 460             reply = FALSE;
 461             break;
 462         case TD_CHANGENUM:
 463             iotd->iotd_Req.io_Actual = tdu->pub.tdu_Counter;
 464             iotd->iotd_Req.io_Error=0;
 465             break;
 466         case TD_CHANGESTATE:
 467             if ((tdu->pub.tdu_PubFlags & TDPF_NOCLICK) && (tdu->tdu_DiskIn == TDU_NODISK)) {
 468                 TestInsert(tdb, tdu);
 469                 if (!tdu->tdu_MotorOn)
 470                     td_motoroff(tdu->tdu_UnitNum, tdb);
 471             }
 472             if (tdu->tdu_DiskIn == TDU_DISK)
 473             {
 474                 /* test if disk is still in there */
 475                 temp = td_getDiskChange();
 476                 iotd->iotd_Req.io_Actual = temp;
 477                 tdu->tdu_DiskIn = temp ^ 1;
 478             }
 479             else
 480             {
 481                 /* No disk in drive */
 482                 iotd->iotd_Req.io_Actual = 1;
 483             }
 484             iotd->iotd_Req.io_Error=0;
 485             break;
 486         case ETD_FORMAT:
 487             if (iotd->iotd_Count > tdu->pub.tdu_Counter) {
 488                 iotd->iotd_Req.io_Error = TDERR_DiskChanged;
 489                 break;
 490             }
 491         case TD_FORMAT:
 492             tdu->tdu_Busy = TRUE;
 493             iotd->iotd_Req.io_Error = td_format(iotd,tdb);
 494             tdu->tdu_Busy = FALSE;
 495             break;
 496         case ETD_MOTOR:
 497             if (iotd->iotd_Count > tdu->pub.tdu_Counter) {
 498                 iotd->iotd_Req.io_Error = TDERR_DiskChanged;
 499                 break;
 500             }
 501         case TD_MOTOR:
 502             iotd->iotd_Req.io_Error=0;
 503             switch (iotd->iotd_Req.io_Length)
 504             {
 505                 case 0:
 506                     tdu->tdu_MotorOn = 0;
 507                     td_motoroff(tdu->tdu_UnitNum,tdb);
 508                     break;
 509                 case 1:
 510                     tdu->tdu_MotorOn = 1;
 511                     td_motoron(tdu->tdu_UnitNum,tdb,TRUE);
 512                     break;
 513                 default:
 514                     iotd->iotd_Req.io_Error = TDERR_NotSpecified;
 515                     break;
 516             }
 517             break;
 518         case TD_PROTSTATUS:
 519             iotd->iotd_Req.io_Actual = tdu->tdu_ProtStatus;
 520             iotd->iotd_Req.io_Error=0;
 521             break;
 522         case TD_REMCHANGEINT:
 523             Forbid();
 524             Remove((struct Node *)iotd);
 525             Permit();
 526             break;
 527         case TD_GETGEOMETRY:
 528             geo = (struct DriveGeometry *)iotd->iotd_Req.io_Data;
 529             geo->dg_SectorSize = 512;
 530             geo->dg_TotalSectors = DP_STOTAL;
 531             geo->dg_Cylinders = DP_TRACKS;
 532             geo->dg_CylSectors = DP_SECTORS*2;
 533             geo->dg_Heads = 2;
 534             geo->dg_TrackSectors = DP_SECTORS;
 535             geo->dg_BufMemType = MEMF_PUBLIC;
 536             geo->dg_DeviceType = DG_DIRECT_ACCESS;
 537             geo->dg_Flags = DGF_REMOVABLE;
 538             iotd->iotd_Req.io_Error=0;
 539             break;
 540         case TD_GETDRIVETYPE:
 541             iotd->iotd_Req.io_Actual = DRIVE3_5;
 542             iotd->iotd_Req.io_Error=0;
 543             break;
 544         case TD_GETNUMTRACKS:
 545             iotd->iotd_Req.io_Actual = DP_TRACKS*2;
 546             iotd->iotd_Req.io_Error=0;
 547             break;
 548         case ETD_SEEK:
 549             if (iotd->iotd_Count > tdu->pub.tdu_Counter) {
 550                 iotd->iotd_Req.io_Error = TDERR_DiskChanged;
 551                 break;
 552             }
 553         case TD_SEEK:
 554             temp = (iotd->iotd_Req.io_Offset >> 10) / DP_SECTORS;
 555             tdu->tdu_MotorOn = 1;
 556             iotd->iotd_Req.io_Error = td_recalibrate(tdu->tdu_UnitNum, 0, temp, tdb);
 557             break;
 558         default:
 559             /* Not supported */
 560             D(bug("TD: Unknown command received\n"));
 561             iotd->iotd_Req.io_Error = IOERR_NOCMD;
 562             break;
 563     } /* switch(iotd->iotd_Req.io_Command) */
 564     return (reply);
 565 }
 566
 567 ULONG TD_InitTask(struct TrackDiskBase *tdb)
 568 {
 569     struct  TaskData *t;
 570     struct  MemList *ml;
 571     struct  Task *me;
 572
 573     /* Allocate Task Data structure */
 574     t = AllocMem(sizeof(struct TaskData), MEMF_PUBLIC|MEMF_CLEAR);
 575     /* Allocate Stack space */
 576     if ((t) && ((t->td_Stack = AllocMem(STACK_SIZE, MEMF_PUBLIC|MEMF_CLEAR)) == NULL))
 577     {
 578         FreeMem(t, sizeof(struct TaskData));
 579         t = NULL;
 580     }
 581     /* Allocate MemEntry for this task */
 582     ml = (struct MemList *)AllocMem(sizeof(struct MemList), MEMF_PUBLIC|MEMF_CLEAR);
 583
 584     /* Find the current task */
 585     me = FindTask(NULL);
 586
 587     if (t && ml)
 588     {
 589         D(bug("TD: Creating devicetask..."));
 590         /* Save stack info into task structure */
 591         t->td_Task.tc_SPLower = t->td_Stack;
 592         t->td_Task.tc_SPUpper = (BYTE *)t->td_Stack + STACK_SIZE;
 593         t->td_Task.tc_SPReg = (BYTE *)t->td_Task.tc_SPUpper - SP_OFFSET - sizeof(APTR);
 594
 595         /* Init MsgPort */
 596         NEWLIST(&t->td_Port.mp_MsgList);
 597         t->td_Port.mp_Node.ln_Type  = NT_MSGPORT;
 598         t->td_Port.mp_Flags         = PA_SIGNAL;
 599         t->td_Port.mp_SigBit        = SIGBREAKB_CTRL_F;
 600         t->td_Port.mp_SigTask       = &t->td_Task;
 601         t->td_Port.mp_Node.ln_Name = "trackdisk.device";
 602
 603         /* Init MemList */
 604         ml->ml_NumEntries = 1;
 605         ml->ml_ME[0].me_Addr = t;
 606         ml->ml_ME[0].me_Length = sizeof(struct TaskData);
 607         NEWLIST(&t->td_Task.tc_MemEntry);
 608         AddHead(&t->td_Task.tc_MemEntry, &ml->ml_Node);
 609
 610         /* Init Task structure */
 611         t->td_Task.tc_Node.ln_Name = "trackdisk.task";
 612         t->td_Task.tc_Node.ln_Type = NT_TASK;
 613         t->td_Task.tc_Node.ln_Pri  = 5;
 614         t->td_Task.tc_UserData = me;
 615
 616         tdb->td_TaskData = t;
 617
 618     struct TagItem task_Tags[] = {
 619         { TASKTAG_ARG1,             (IPTR)tdb },
 620         { TAG_DONE,                 0   },
 621     };
 622         /* Add task to system task list */
 623     NewAddTask(&t->td_Task, &TD_DevTask, NULL, task_Tags );
 624
 625         /* Wait until started */
 626         Wait(SIGBREAKF_CTRL_F);
 627
 628         D(bug(" OK\n"));
 629
 630         return 1;
 631     }
 632     else
 633     {
 634         if (t)
 635         {
 636             if (t->td_Stack) FreeMem(t->td_Stack, STACK_SIZE);
 637             FreeMem(t, sizeof(struct TaskData));
 638         }
 639         if (ml) FreeMem(ml, sizeof(struct MemList));
 640     }
 641
 642     return 0;
 643 }
 644
 645 static void TD_DevTask(struct TrackDiskBase *tdb)
 646 {
 647     struct TaskData             *td;
 648     struct IOExtTD              *iotd;
 649     struct TDU                  *tdu;
 650     ULONG                       tasig,tisig,sigs,i;
 651     UBYTE                       dir;
 652
 653     D(bug("[TDTask] TD_DevTask(tdb=%p)\n", tdb));
 654
 655     td = tdb->td_TaskData;
 656
 657     D(bug("[TDTask] TD_DevTask: struct TaskData @ %p\n", td));
 658
 659     tdb->td_IntBit = AllocSignal(-1);
 660     tdb->td_TmoBit = AllocSignal(-1);
 661     tdb->td_TimerMP = CreateMsgPort();
 662     tdb->td_TimerIO = (struct timerequest *) CreateIORequest(tdb->td_TimerMP, sizeof(struct timerequest));
 663     OpenDevice("timer.device", UNIT_VBLANK, (struct IORequest *)tdb->td_TimerIO, 0);
 664
 665     /* Initialize FDC */
 666     td_dinit(tdb);
 667
 668     /* Initial check for floppies */
 669     for (i=0;i<TD_NUMUNITS;i++)
 670     {
 671         if(tdb->td_Units[i])
 672         {
 673             td_rseek(i, 0, 1, tdb);
 674             tdb->td_Units[i]->tdu_Present = !td_recalibrate(tdb->td_Units[i]->tdu_UnitNum,1,0,tdb);
 675             tdb->td_Units[i]->pub.tdu_CurrTrk = 0;
 676             tdb->td_Units[i]->tdu_DiskIn = (td_getDiskChange() ^ 1);
 677             tdb->td_Units[i]->tdu_ProtStatus = td_getprotstatus(i,tdb);
 678             tdb->td_Units[i]->tdu_Busy = FALSE;
 679             tdb->td_Units[i]->tdu_stepdir = 0;
 680             if (((tdb->td_Units[i]->pub.tdu_PubFlags & TDPF_NOCLICK) && (tdb->td_Units[i]->tdu_DiskIn == TDU_NODISK))
 681                 || (!tdb->td_Units[i]->tdu_Present))
 682                 td_motoroff(i, tdb);
 683             D(bug("Drive %d presence: %ld\n", i, tdb->td_Units[i]->tdu_Present));
 684         }
 685     }
 686
 687     tasig = 1L << td->td_Port.mp_SigBit;
 688     tisig = 1L << tdb->td_TimerMP->mp_SigBit;
 689
 690     /* Reply to startup message */
 691     Signal(td->td_Task.tc_UserData,SIGBREAKF_CTRL_F);
 692
 693     tdb->td_TimerIO->tr_node.io_Command = TR_ADDREQUEST;
 694     tdb->td_TimerIO->tr_time.tv_secs = 2;
 695     tdb->td_TimerIO->tr_time.tv_micro = 500000;
 696     SendIO((struct IORequest *)tdb->td_TimerIO);
 697
 698     /* Endless task loop */
 699     for(;;)
 700     {
 701         sigs = 0L;
 702         sigs = Wait(tasig | tisig);  /* Wait for a message */
 703         /* If unit was not active process message */
 704         if (sigs & tasig)
 705         {
 706             /* We received a message. Deal with it */
 707             while((iotd = (struct IOExtTD *)GetMsg(&td->td_Port)) != NULL)
 708             {
 709                 /* Execute command */
 710                 if (TD_PerformIO( iotd, tdb))
 711                 {
 712                     /* Finish message */
 713                     ReplyMsg((struct Message *)iotd);
 714                 }
 715             }
 716         }
 717         if (sigs & tisig)
 718         {
 719             /* We were woken up by the timer. */
 720             WaitIO((struct IORequest *)tdb->td_TimerIO);
 721             for(i=0;i<TD_NUMUNITS;i++)
 722             {
 723                 /* If there is no floppy in drive, scan for changes */
 724                 if (tdb->td_Units[i])
 725                 {
 726                     tdu = tdb->td_Units[i];
 727                     switch (tdu->tdu_DiskIn)
 728                     {
 729                         case TDU_NODISK:
 730                             /*
 731                                Unfortunately "NoClick" technology which works on Amiga will not
 732                                work on PC because i82077 does not send step pulse when told to
 733                                seek to "-1" track and the drive can't recognize disk insertion.
 734                                Many thanks to Intel! :-(((
 735
 736                                Here we use another technique: in NoClick mode we just do nothing
 737                                if the disk is not in drive. We can perform this test only once
 738                                inside TD_CHANGESTATE command which is invoked by DISKCHANGE
 739                                CLI command. This means that we'll have to issue DISKCHANGE command
 740                                manually after we insert the disk, but this is probably better
 741                                than those clicks.
 742                             */
 743                             if (tdu->pub.tdu_PubFlags & TDPF_NOCLICK) {
 744                                 if (!tdu->tdu_MotorOn)
 745                                     td_motoroff(tdu->tdu_UnitNum, tdb);
 746                             } else
 747                                 TestInsert(tdb, tdu);
 748                             break;
 749                         case TDU_DISK:
 750                             /*
 751                                Fortunately this part is completely silent so we don't have to
 752                                do any extra mess here
 753                             */
 754                             if (!tdu->tdu_Busy)
 755                             {
 756                                 if (!tdu->tdu_MotorOn)
 757                                     td_motoron(tdu->tdu_UnitNum,tdb,FALSE);
 758                                 dir = (inb(FDC_DIR)>>7);
 759                                 if (!tdu->tdu_MotorOn)
 760                                     td_motoroff(tdu->tdu_UnitNum,tdb);
 761                                 if (dir == 1)
 762                                 {
 763                                     D(bug("[Floppy] Removal detected\n"));
 764                                     /* Go to cylinder 0 */
 765                                     td_recalibrate(tdu->tdu_UnitNum,1,0,tdb);
 766                                     tdu->tdu_DiskIn = TDU_NODISK;
 767                                     tdu->pub.tdu_Counter++;
 768                                     Forbid();
 769                                     ForeachNode(&tdu->tdu_Listeners,iotd)
 770                                     {
 771                                         Cause((struct Interrupt *)((struct IOExtTD *)iotd->iotd_Req.io_Data));
 772                                     }
 773                                     Permit();
 774                                     tdu->tdu_stepdir = 0;
 775                                 }
 776                             }
 777                             break;
 778                     }
 779                 }
 780             }
 781
 782             /* Reload the timer again */
 783             GetMsg(tdb->td_TimerMP);
 784             tdb->td_TimerIO->tr_node.io_Command = TR_ADDREQUEST;
 785             tdb->td_TimerIO->tr_time.tv_secs = 2;
 786             tdb->td_TimerIO->tr_time.tv_micro = 500000;
 787             SendIO((struct IORequest *)tdb->td_TimerIO);
 788         }
 789     }
 790 }
 791
 792