rom/devs/ata/bus_class.c

   1 #include <aros/debug.h>
   2 #include <hidd/ata.h>
   3 #include <hidd/pci.h>
   4 #include <oop/oop.h>
   5 #include <utility/tagitem.h>
   6 #include <proto/exec.h>
   7 #include <proto/oop.h>
   8 #include <proto/utility.h>
   9
  10 #include "ata.h"
  11
  12 #define DIRQ(x)
  13
  14 static void Hidd_ATABus_HandleIRQ(UBYTE status, struct ata_Bus *bus)
  15 {
  16     struct ata_Unit *unit = bus->ab_SelectedUnit;
  17
  18     /*
  19      * don't waste your time on checking other devices.
  20      * pass irq ONLY if task is expecting one;
  21      */
  22     if (unit && bus->ab_HandleIRQ)
  23     {
  24         /* ok, we have a routine to handle any form of transmission etc. */
  25         DIRQ(bug("[ATA%02d] IRQ: Calling dedicated handler 0x%p... \n",
  26                  unit->au_UnitNum, bus->ab_HandleIRQ));
  27         bus->ab_HandleIRQ(unit, status);
  28
  29         return;
  30     }
  31
  32     DIRQ({
  33         /*
  34          * if we got *here* then device is most likely not expected to have an irq.
  35          */
  36         bug("[ATA%02d] Spurious IRQ\n", unit ? unit->au_UnitNum : -1);
  37
  38         if (0 == (ATAF_BUSY & status))
  39         {
  40             bug("[ATA  ] STATUS: %02lx\n"     , status);
  41             bug("[ATA  ] ALT STATUS: %02lx\n" , PIO_InAlt(bus, ata_AltStatus));
  42             bug("[ATA  ] ERROR: %02lx\n"      , PIO_In(bus, ata_Error));
  43             bug("[ATA  ] IRQ: REASON: %02lx\n", PIO_In(bus, atapi_Reason));
  44         }
  45     });
  46 }
  47
  48 static AROS_INTH1(ataBus_Reset, struct ata_Bus *, bus)
  49 {
  50     AROS_INTFUNC_INIT
  51
  52     struct ataBase *ATABase = bus->ab_Base;
  53     OOP_Object *obj = (void *)bus - ATABase->ataClass->InstOffset;
  54
  55     HIDD_ATABus_Shutdown(obj);
  56     return FALSE;
  57
  58     AROS_INTFUNC_EXIT
  59 }
  60
  61 /*****************************************************************************************
  62
  63     NAME
  64         --background--
  65
  66     LOCATION
  67         CLID_Hidd_ATABus
  68
  69     NOTES
  70         This class serves as a base class for implementing IDE (ATA) bus drivers.
  71         One particularity of this class is that IDE bus is very speed-critical.
  72         At the other hand, the driver implements very lowlevel operations which
  73         are called quite often. OOP_DoMethod() call is not fast enough, and in
  74         order to curcumvent this limitation, additionally to normal OOP API
  75         IDE bus drivers offer two additional non-standard interfaces. Internally
  76         they are implemented as library-alike function table plus driver-specific
  77         data. For the purpose of some performance optimizations the function
  78         table is private to ata.device and managed entirely by the base class.
  79         Driver classes have access only to data portion.
  80
  81         These interfaces are documented below.
  82
  83 *****************************************************************************************/
  84 /*****************************************************************************************
  85
  86     NAME
  87         --PIO interface--
  88
  89     LOCATION
  90         CLID_Hidd_ATABus
  91
  92     NOTES
  93         PIO interface is responsible for accessing I/O registers on the IDE
  94         bus, as well as performing PIO-mode 16- and 32-bit data transfers.
  95         This interface is mandatory and must be implemented by the driver,
  96         however some functions are optional. They can be either omitted
  97         entirely from the function table, or set to NULL pointers.
  98
  99         Control functions table for the interface consists of the following
 100         functions (listed in their order in the array):
 101
 102         VOID ata_out(void *obj, UBYTE val, UWORD offset)
 103         - Write byte into primary register bank with the given offset.
 104
 105         UBYTE ata_in(void *obj, UWORD offset)
 106         - Read byte from primary register bank with the given offset.
 107
 108         VOID ata_out_alt(void *obj, UBYTE val, UWORD offset)
 109         - Write byte into alternate register bank with the given offset.
 110           This function is optional.
 111
 112         UBYTE ata_in_alt(void *obj, UWORD offset)
 113         - Read byte from alternate register bank with the given offset.
 114           This function is optional.
 115
 116         Transfer functions table for the interface consists of the following
 117         functions (listed in their order in the array):
 118
 119         VOID ata_outsw(void *obj, APTR address, ULONG count)
 120         - Perform 16-bit PIO data write operation from the given memory
 121           region of the given size.
 122
 123         VOID ata_insw(void *obj, APTR address, ULONG count)
 124         - Perform 16-bit PIO data read operation into the given memory
 125           region of the given size.
 126
 127         VOID ata_outsl(void *obj, APTR address, ULONG count)
 128         - Perform 32-bit PIO data write operation from the given memory
 129           region of the given size. This function is optional.
 130
 131         UBYTE ata_insl(void *obj, APTR address, ULONG count)
 132         - Perform 32-bit PIO data read operation into the given memory
 133           region of the given size. This function is optional.
 134
 135 *****************************************************************************************/
 136 /*****************************************************************************************
 137
 138     NAME
 139         --DMA interface--
 140
 141     LOCATION
 142         CLID_Hidd_ATABus
 143
 144     NOTES
 145         DMA interface is optional, and is needed in order to support DMA data
 146         transfers.
 147
 148         Function table for the interface consists of the following functions:
 149
 150         BOOL dma_Setup(void *obj, APTR buffer, IPTR size, BOOL read)
 151         - Prepare the controller to DMA data transfer. The last argument is
 152           TRUE for read operation and FALSE for write. The function should
 153           return TRUE for success or FALSE for failure.
 154
 155         VOID dma_Start(void *obj)
 156         - Start DMA transfer.
 157
 158         VOID dma_End(void *obj, APTR buffer, IPTR size, BOOL read)
 159         - End DMA transfer and perform post-transfer cleanup of the given region.
 160
 161         ULONG dma_Result(void *obj)
 162         - Get resulting status of the operation. The function should return 0
 163           for succesful completion or error code to be passed up to ata.device
 164           caller in io_Result field of the IORequest.
 165
 166 *****************************************************************************************/
 167 /*****************************************************************************************
 168
 169     NAME
 170         aoHidd_ATABus_Use80Wire
 171
 172     SYNOPSIS
 173         [..G], BOOL
 174
 175     LOCATION
 176         CLID_Hidd_ATABus
 177
 178     FUNCTION
 179         Tells whether the bus currently uses 80-conductor cable.
 180
 181     NOTES
 182
 183     EXAMPLE
 184
 185     BUGS
 186
 187     SEE ALSO
 188
 189     INTERNALS
 190
 191 *****************************************************************************************/
 192 /*****************************************************************************************
 193
 194     NAME
 195         aoHidd_ATABus_Use32Bit
 196
 197     SYNOPSIS
 198         [.SG], BOOL
 199
 200     LOCATION
 201         CLID_Hidd_ATABus
 202
 203     FUNCTION
 204         When queried, tells whether the bus supports 32-bit PIO data transfers.
 205         When set, enables or disables 32-bit mode for PIO data transfers.
 206
 207     NOTES
 208
 209     EXAMPLE
 210
 211     BUGS
 212
 213     SEE ALSO
 214
 215     INTERNALS
 216
 217 *****************************************************************************************/
 218 /*****************************************************************************************
 219
 220     NAME
 221         aoHidd_ATABus_UseDMA
 222
 223     SYNOPSIS
 224         [..G], BOOL
 225
 226     LOCATION
 227         CLID_Hidd_ATABus
 228
 229     FUNCTION
 230         Tells whether the bus supports DMA transfers.
 231
 232     NOTES
 233
 234     EXAMPLE
 235
 236     BUGS
 237
 238     SEE ALSO
 239
 240     INTERNALS
 241         Default implementation in base class returns value depending on whether
 242         the subclass provided DMA interface function table during object creation.
 243
 244 *****************************************************************************************/
 245 /*****************************************************************************************
 246
 247     NAME
 248         aoHidd_ATABus_PIODataSize
 249
 250     SYNOPSIS
 251         [I..], BOOL
 252
 253     LOCATION
 254         CLID_Hidd_ATABus
 255
 256     FUNCTION
 257         Specifies size of PIO interface data structure.
 258
 259     NOTES
 260
 261     EXAMPLE
 262
 263     BUGS
 264
 265     SEE ALSO
 266
 267     INTERNALS
 268
 269 *****************************************************************************************/
 270 /*****************************************************************************************
 271
 272     NAME
 273         aoHidd_ATABus_DMADataSize
 274
 275     SYNOPSIS
 276         [I..], BOOL
 277
 278     LOCATION
 279         CLID_Hidd_ATABus
 280
 281     FUNCTION
 282         Specifies size of DMA interface data structure.
 283
 284     NOTES
 285
 286     EXAMPLE
 287
 288     BUGS
 289
 290     SEE ALSO
 291
 292     INTERNALS
 293
 294 *****************************************************************************************/
 295 /*****************************************************************************************
 296
 297     NAME
 298         aoHidd_ATABus_BusVectors
 299
 300     SYNOPSIS
 301         [I..], APTR *
 302
 303     LOCATION
 304         CLID_Hidd_ATABus
 305
 306     FUNCTION
 307         Specifies control functions table for building PIO interface object.
 308         The function table is an array of function pointers terminated
 309         by -1 value. The terminator must be present for purpose of
 310         binary compatibility with future extensions.
 311
 312     NOTES
 313         This function table is mandatory to be implemented by the driver.
 314
 315     EXAMPLE
 316
 317     BUGS
 318
 319     SEE ALSO
 320
 321     INTERNALS
 322
 323 *****************************************************************************************/
 324 /*****************************************************************************************
 325
 326     NAME
 327         aoHidd_ATABus_PIOVectors
 328
 329     SYNOPSIS
 330         [I..], APTR *
 331
 332     LOCATION
 333         CLID_Hidd_ATABus
 334
 335     FUNCTION
 336         Specifies transfers function table for building PIO interface object.
 337         The function table is an array of function pointers terminated
 338         by -1 value. The terminator must be present for purpose of
 339         binary compatibility with future extensions.
 340
 341     NOTES
 342         This function table is mandatory to be implemented by the driver.
 343
 344     EXAMPLE
 345
 346     BUGS
 347
 348     SEE ALSO
 349
 350     INTERNALS
 351
 352 *****************************************************************************************/
 353 /*****************************************************************************************
 354
 355     NAME
 356         aoHidd_ATABus_DMAVectors
 357
 358     SYNOPSIS
 359         [I..], APTR *
 360
 361     LOCATION
 362         CLID_Hidd_ATABus
 363
 364     FUNCTION
 365         Specifies function table for building DMA interface object. If not supplied,
 366         the bus is considered not DMA-capable.
 367
 368     NOTES
 369
 370     EXAMPLE
 371
 372     BUGS
 373
 374     SEE ALSO
 375         aoHidd_ATABus_PIOVectors
 376
 377     INTERNALS
 378
 379 *****************************************************************************************/
 380 /*****************************************************************************************
 381
 382     NAME
 383         aoHidd_ATABus_IRQHandler
 384
 385     SYNOPSIS
 386         [.S.], APTR
 387
 388     LOCATION
 389         CLID_Hidd_ATABus
 390
 391     FUNCTION
 392         Specifies IRQ handler function to be called when bus interrupt arrives.
 393         The function shoule be called using "C" calling convention and has the
 394         following prototype:
 395
 396             void ata_HandleIRQ(UBYTE status, APTR userdata);
 397
 398         Your driver should pass the following arguments to this function:
 399             status   - value read from ATA main status register.
 400             userdata - value of aoHidd_ATABus_IRQData attribute.
 401
 402     NOTES
 403         Reading drive status register is a part of interrupt acknowledge
 404         process, thus it has to be done by the driver.
 405
 406         It is driver's job to check whether the interrupt really belongs to
 407         the IDE bus. A generic way to do this is to test ATAF_BUSY bit of
 408         the status register for being zero. However, this may not work
 409         reliably with IRQ sharing, so advanced IDE controllers may offer
 410         different, better way to do this.
 411
 412     EXAMPLE
 413
 414     BUGS
 415
 416     SEE ALSO
 417         aoHidd_ATABus_IRQData
 418
 419     INTERNALS
 420
 421 *****************************************************************************************/
 422 /*****************************************************************************************
 423
 424     NAME
 425         aoHidd_ATABus_IRQData
 426
 427     SYNOPSIS
 428         [.S.], APTR
 429
 430     LOCATION
 431         CLID_Hidd_ATABus
 432
 433     FUNCTION
 434         Caller's private data to be supplied to IRQ handler function.
 435
 436     NOTES
 437
 438     EXAMPLE
 439
 440     BUGS
 441
 442     SEE ALSO
 443         aoHidd_ATABus_IRQData
 444
 445     INTERNALS
 446
 447 *****************************************************************************************/
 448
 449 OOP_Object *ATABus__Root__New(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
 450 {
 451     o = (OOP_Object *)OOP_DoSuperMethod(cl, o, &msg->mID);
 452     if (o)
 453     {
 454         struct ataBase *ATABase = cl->UserData;
 455         struct ata_Bus *data = OOP_INST_DATA(cl, o);
 456         struct TagItem *tstate = msg->attrList;
 457         struct TagItem *tag;
 458
 459         while ((tag = NextTagItem(&tstate)))
 460         {
 461             ULONG idx;
 462
 463             Hidd_ATABus_Switch(tag->ti_Tag, idx)
 464             {
 465             case aoHidd_ATABus_PIODataSize:
 466                 data->pioDataSize = tag->ti_Data;
 467                 break;
 468
 469             case aoHidd_ATABus_DMADataSize:
 470                 data->dmaDataSize = tag->ti_Data;
 471                 break;
 472
 473             case aoHidd_ATABus_BusVectors:
 474                 data->busVectors = (APTR *)tag->ti_Data;
 475                 break;
 476
 477             case aoHidd_ATABus_PIOVectors:
 478                 data->pioVectors = (struct ATA_PIOInterface *)tag->ti_Data;
 479                 break;
 480
 481             case aoHidd_ATABus_DMAVectors:
 482                 data->dmaVectors = (APTR *)tag->ti_Data;
 483                 break;
 484             }
 485         }
 486
 487         /* Cache device base pointer. Useful. */
 488         data->ab_Base = ATABase;
 489
 490         /* Install reset callback */
 491         data->ab_ResetInt.is_Node.ln_Name = ATABase->ata_Device.dd_Library.lib_Node.ln_Name;
 492         data->ab_ResetInt.is_Code         = (VOID_FUNC)ataBus_Reset;
 493         data->ab_ResetInt.is_Data         = data;
 494         AddResetCallback(&data->ab_ResetInt);
 495     }
 496     return o;
 497 }
 498
 499 void ATABus__Root__Dispose(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
 500 {
 501     struct ata_Bus *data = OOP_INST_DATA(cl, o);
 502
 503     RemResetCallback(&data->ab_ResetInt);
 504
 505     if (data->dmaInterface)
 506     {
 507         void *ptr = data->dmaInterface - sizeof(struct ATA_DMAInterface);
 508
 509         FreeMem(ptr, sizeof(struct ATA_DMAInterface) + data->dmaDataSize);
 510     }
 511     if (data->pioInterface)
 512     {
 513         void *ptr = data->pioInterface - sizeof(struct ATA_BusInterface);
 514
 515         FreeMem(ptr, sizeof(struct ATA_BusInterface) + data->pioDataSize);
 516     }
 517
 518     OOP_DoSuperMethod(cl, o, msg);
 519 }
 520
 521 void ATABus__Root__Get(OOP_Class *cl, OOP_Object *o, struct pRoot_Get *msg)
 522 {
 523     struct ataBase *ATABase = cl->UserData;
 524     struct ata_Bus *data = OOP_INST_DATA(cl, o);
 525     ULONG idx;
 526
 527     Hidd_ATABus_Switch (msg->attrID, idx)
 528     {
 529     case aoHidd_ATABus_Use80Wire:
 530         /* CHECKME: Is there any generic way to check this ? */
 531         *msg->storage = FALSE;
 532         return;
 533
 534     case aoHidd_ATABus_Use32Bit:
 535         *msg->storage = (data->pioVectors->ata_outsl &&
 536                          data->pioVectors->ata_insl) ? TRUE : FALSE;
 537         return;
 538
 539     case aoHidd_ATABus_UseDMA:
 540         *msg->storage = data->dmaVectors ? TRUE : FALSE;
 541         return;
 542     }
 543
 544     OOP_DoSuperMethod(cl, o, &msg->mID);
 545 }
 546
 547 /* Default ata_out_alt does nothing */
 548 static void default_out_alt(void *obj, UBYTE val, UWORD offset)
 549 {
 550
 551 }
 552
 553 /* Default ata_in_alt wraps AltStatus to status */
 554 static UBYTE default_in_alt(void *obj, UWORD offset)
 555 {
 556     struct ATA_BusInterface *vec = obj - sizeof(struct ATA_BusInterface);
 557
 558     return vec->ata_in(obj, ata_Status);
 559 }
 560
 561 static void CopyVectors(APTR *dest, APTR *src, unsigned int num)
 562 {
 563     unsigned int i;
 564
 565     for (i = 0; i < num; i++)
 566     {
 567         if (src[i] == (APTR *)-1)
 568             return;
 569         if (src[i])
 570             dest[i] = src[i];
 571     }
 572 }
 573
 574 /*****************************************************************************************
 575
 576     NAME
 577         moHidd_ATABus_GetPIOInterface
 578
 579     SYNOPSIS
 580         APTR OOP_DoMethod(OOP_Object *obj, struct pHidd_ATABus_GetPIOInterface *Msg);
 581
 582         APTR HIDD_ATABus_GetPIOInterface(void);
 583
 584     LOCATION
 585         CLID_Hidd_ATABus
 586
 587     FUNCTION
 588         Instantiates encapsulated PIO interface object and returns its
 589         pointer.
 590
 591     INPUTS
 592         None
 593
 594     RESULT
 595         A pointer to opaque PIO interface object or NULL in case of failure.
 596
 597     NOTES
 598         This method should be overloaded by driver subclasses in order to
 599         initialize data portion of the interface object.
 600
 601     EXAMPLE
 602
 603     BUGS
 604
 605     SEE ALSO
 606         moHidd_ATABus_GetDMAInterface
 607
 608     INTERNALS
 609         Interface objects contain not only driver-specific data, but also
 610         a private vector table. Because of this you cannot just AllocMem()
 611         the necessary structure in your driver. Always call OOP_DoSuperMethod()
 612         in order for the base class to instantiate the interface correctly.
 613
 614 *****************************************************************************************/
 615
 616 APTR ATABus__Hidd_ATABus__GetPIOInterface(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
 617 {
 618     struct ata_Bus *data = OOP_INST_DATA(cl, o);
 619     struct ATA_BusInterface *vec;
 620
 621     vec = AllocMem(sizeof(struct ATA_BusInterface) + data->pioDataSize,
 622                    MEMF_PUBLIC|MEMF_CLEAR);
 623     if (vec)
 624     {
 625         /* Some default vectors for simplicity */
 626         vec->ata_out_alt = default_out_alt;
 627         vec->ata_in_alt  = default_in_alt;
 628
 629         CopyVectors((APTR *)vec, data->busVectors,
 630                     sizeof(struct ATA_BusInterface) / sizeof(APTR));
 631
 632         data->pioInterface = &vec[1];
 633         return data->pioInterface;
 634     }
 635
 636     return NULL;
 637 }
 638
 639 /*****************************************************************************************
 640
 641     NAME
 642         moHidd_ATABus_GetDMAInterface
 643
 644     SYNOPSIS
 645         APTR OOP_DoMethod(OOP_Object *obj, struct pHidd_ATABus_GetDMAInterface *Msg);
 646
 647         APTR HIDD_ATABus_GetDMAInterface(void);
 648
 649     LOCATION
 650         CLID_Hidd_ATABus
 651
 652     FUNCTION
 653         Instantiates encapsulated DMA interface object and returns its
 654         pointer.
 655
 656     INPUTS
 657         None
 658
 659     RESULT
 660         A pointer to opaque DMA interface object or NULL upon failure or
 661         if DMA is not supported by this bus.
 662
 663     NOTES
 664         This method should be overloaded by driver subclasses in order to
 665         initialize data portion of the interface object.
 666
 667     EXAMPLE
 668
 669     BUGS
 670
 671     SEE ALSO
 672         moHidd_ATABus_GetPIOInterface
 673
 674     INTERNALS
 675         Interface objects contain not only driver-specific data, but also
 676         a private vector table. Because of this you cannot just AllocMem()
 677         the necessary structure in your driver. Always call OOP_DoSuperMethod()
 678         in order for the base class to instantiate the interface correctly.
 679
 680 *****************************************************************************************/
 681
 682 APTR ATABus__Hidd_ATABus__GetDMAInterface(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
 683 {
 684     struct ata_Bus *data = OOP_INST_DATA(cl, o);
 685     struct ATA_DMAInterface *vec;
 686
 687     if (!data->dmaVectors)
 688         return NULL;
 689
 690     vec = AllocMem(sizeof(struct ATA_DMAInterface) + data->dmaDataSize,
 691                    MEMF_PUBLIC|MEMF_CLEAR);
 692     if (vec)
 693     {
 694         CopyVectors((APTR *)vec, data->dmaVectors,
 695                     sizeof(struct ATA_DMAInterface) / sizeof(APTR));
 696
 697         data->dmaInterface = &vec[1];
 698         return data->dmaInterface;
 699     }
 700
 701     return NULL;
 702 }
 703
 704 /*****************************************************************************************
 705
 706     NAME
 707         moHidd_ATABus_SetXferMode
 708
 709     SYNOPSIS
 710         APTR OOP_DoMethod(OOP_Object *obj, struct pHidd_ATABus_SetXferMode *Msg);
 711
 712         APTR HIDD_ATABus_SetXferMode(UBYTE unit, ata_XferMode mode);
 713
 714     LOCATION
 715         CLID_Hidd_ATABus
 716
 717     FUNCTION
 718         Sets the desired transfer mode for the given drive on the bus controller.
 719
 720     INPUTS
 721         unit - drive number (0 for master and 1 for slave)
 722         mode - Mode number (see hidd/ata.h)
 723
 724     RESULT
 725         TRUE if succesful or FALSE if the desired mode is not supported
 726         by the hardware.
 727
 728     NOTES
 729         The default implementation is provided for drivers not supporting
 730         DMA and always returns FALSE if the caller attempts to set any of
 731         DMA modes.
 732
 733     EXAMPLE
 734
 735     BUGS
 736
 737     SEE ALSO
 738
 739     INTERNALS
 740
 741 *****************************************************************************************/
 742
 743 BOOL ATABus__Hidd_ATABus__SetXferMode(OOP_Class *cl, OOP_Object *o, struct pHidd_ATABus_SetXferMode *msg)
 744 {
 745     if ((msg->mode >= AB_XFER_MDMA0) && (msg->mode <= AB_XFER_UDMA6))
 746     {
 747         /* DMA is not supported, we cannot set DMA modes */
 748         return FALSE;
 749     }
 750
 751     return TRUE;
 752 }
 753
 754 /*****************************************************************************************
 755
 756     NAME
 757         moHidd_ATABus_Shutdown
 758
 759     SYNOPSIS
 760         APTR OOP_DoMethod(OOP_Object *obj, struct pHidd_ATABus_Shutdown *Msg);
 761
 762         APTR HIDD_ATABus_Shutdown(void);
 763
 764     LOCATION
 765         CLID_Hidd_ATABus
 766
 767     FUNCTION
 768         Instantly shutdown all activity on the bus.
 769
 770     INPUTS
 771         None
 772
 773     RESULT
 774         None
 775
 776     NOTES
 777         This method is called by ata.device during system reset handler execution.
 778
 779     EXAMPLE
 780
 781     BUGS
 782
 783     SEE ALSO
 784
 785     INTERNALS
 786         Default implementation disables interrupt using AltControl register.
 787
 788 *****************************************************************************************/
 789
 790 void ATABus__Hidd_ATABus__Shutdown(OOP_Class *cl, OOP_Object *o, OOP_Msg *msg)
 791 {
 792     struct ata_Bus *data = OOP_INST_DATA(cl, o);
 793
 794     if (data->pioInterface)
 795     {
 796         struct ATA_BusInterface *vec = data->pioInterface - sizeof(struct ATA_BusInterface);
 797
 798         vec->ata_out_alt(data->pioInterface, ATACTLF_INT_DISABLE, ata_AltControl);
 799     }
 800 }
 801
 802 /***************** Private nonvirtual methods follow *****************/
 803
 804 BOOL Hidd_ATABus_Start(OOP_Object *o, struct ataBase *ATABase)
 805 {
 806     struct ata_Bus *ab = OOP_INST_DATA(ATABase->busClass, o);
 807
 808     /* Attach IRQ handler */
 809     OOP_SetAttrsTags(o, aHidd_ATABus_IRQHandler, Hidd_ATABus_HandleIRQ,
 810                         aHidd_ATABus_IRQData   , ab,
 811                         TAG_DONE);
 812
 813     /*
 814      * Assign bus number.
 815      * TODO: This does not take into account possibility to
 816      * unload drivers. In this case existing units will disappear,
 817      * freeing up their numbers. These numbers should be reused.
 818      */
 819     ab->ab_BusNum = ATABase->ata__buscount++;
 820
 821     /* scan bus - try to locate all devices (disables irq) */
 822     ata_InitBus(ab);
 823
 824     /*
 825      * Start up bus task. It will perform scanning asynchronously, and
 826      * then, if succesful, insert units. This allows to keep things parallel.
 827      */
 828     D(bug("[ATA>>] Start: Bus %u: Unit 0 - %d, Unit 1 - %d\n", ab->ab_BusNum, ab->ab_Dev[0], ab->ab_Dev[1]));
 829     return NewCreateTask(TASKTAG_PC         , BusTaskCode,
 830                          TASKTAG_NAME       , "ATA[PI] Subsystem",
 831                          TASKTAG_STACKSIZE  , STACK_SIZE,
 832                          TASKTAG_PRI        , TASK_PRI,
 833                          TASKTAG_TASKMSGPORT, &ab->ab_MsgPort,
 834                          TASKTAG_ARG1       , ab,
 835                          TASKTAG_ARG2       , ATABase,
 836                          TAG_DONE) ? TRUE : FALSE;
 837 }
 838
 839 AROS_UFH3(BOOL, Hidd_ATABus_Open,
 840           AROS_UFHA(struct Hook *, h, A0),
 841           AROS_UFHA(OOP_Object *, obj, A2),
 842           AROS_UFHA(IPTR, reqUnit, A1))
 843 {
 844     AROS_USERFUNC_INIT
 845
 846     struct IORequest *req = h->h_Data;
 847     struct ataBase *ATABase = (struct ataBase *)req->io_Device;
 848     struct ata_Bus *b = (struct ata_Bus *)OOP_INST_DATA(ATABase->busClass, obj);
 849     ULONG bus = reqUnit >> 1;
 850     UBYTE dev = reqUnit & 1;
 851
 852     D(bug("[ATA%02ld] Checking bus %u dev %u\n", reqUnit, bus, dev));
 853
 854     if ((b->ab_BusNum == bus) && b->ab_Units[dev])
 855     {
 856         /* Got the unit */
 857         req->io_Unit  = &b->ab_Units[dev]->au_Unit;
 858         req->io_Error = 0;
 859
 860         b->ab_Units[dev]->au_Unit.unit_OpenCnt++;
 861         return TRUE;
 862     }
 863
 864     return FALSE;
 865
 866     AROS_USERFUNC_EXIT
 867 }
 868
 869 AROS_UFH3(BOOL, Hidd_ATABus_Tick,
 870           AROS_UFHA(struct Hook *, h, A0),
 871           AROS_UFHA(OOP_Object *, obj, A2),
 872           AROS_UFHA(struct ataBase *, ATABase, A1))
 873 {
 874     AROS_USERFUNC_INIT
 875
 876     struct ata_Bus *bus = (struct ata_Bus *)OOP_INST_DATA(ATABase->busClass, obj);
 877     LONG timeout = 0;
 878
 879     /*
 880      * This compare-decrement-fetch should be atomic, so we
 881      * use Forbid() here.
 882      * Not a good design, can anybody invent better one ?
 883      */
 884     Forbid();
 885     if (bus->ab_Timeout >= 0)
 886         timeout = --bus->ab_Timeout;
 887     Permit();
 888
 889     if (timeout < 0)
 890         Signal(bus->ab_Task, SIGBREAKF_CTRL_C);
 891
 892     return FALSE;
 893
 894     AROS_USERFUNC_EXIT
 895 }