rom/devs/scsi/scsi_busclass.c

   1 /*
   2     Copyright © 2019, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <aros/debug.h>
   7
   8 #include <proto/exec.h>
   9
  10 /* We want all other bases obtained from our base */
  11 #define __NOLIBBASE__
  12
  13 #include <proto/oop.h>
  14 #include <proto/utility.h>
  15
  16 #include <hidd/storage.h>
  17 #include <hidd/bus.h>
  18 #include <hidd/scsi.h>
  19 #include <oop/oop.h>
  20 #include <utility/tagitem.h>
  21
  22 #include "scsi.h"
  23 #include "scsi_Bus.h"
  24
  25 #define DIRQ(x)
  26 #define DATTR(x)
  27
  28 static void Hidd_SCSIBus_HandleIRQ(UBYTE status, struct scsi_Bus *bus)
  29 {
  30     struct scsi_Unit *unit = bus->sb_SelectedUnit;
  31
  32     /*
  33      * don't waste your time on checking other devices.
  34      * pass irq ONLY if task is expecting one;
  35      */
  36     if (unit && bus->sb_HandleIRQ)
  37     {
  38         /* ok, we have a routine to handle any form of transmission etc. */
  39         DIRQ(bug("[SCSI%02d] IRQ: Calling dedicated handler 0x%p... \n",
  40                  unit->su_UnitNum, bus->sb_HandleIRQ));
  41         bus->sb_HandleIRQ(unit, status);
  42
  43         return;
  44     }
  45
  46     DIRQ({
  47         /*
  48          * if we got *here* then device is most likely not expected to have an irq.
  49          */
  50         bug("[SCSI%02d] Spurious IRQ\n", unit ? unit->su_UnitNum : -1);
  51
  52         if (0 == (ATAF_BUSY & status))
  53         {
  54             bug("[SCSI  ] STATUS: %02lx\n"     , status);
  55             bug("[SCSI  ] ALT STATUS: %02lx\n" , PIO_InAlt(bus, scsi_AltStatus));
  56             bug("[SCSI  ] ERROR: %02lx\n"      , PIO_In(bus, scsi_Error));
  57             bug("[SCSI  ] IRQ: REASON: %02lx\n", PIO_In(bus, atapi_Reason));
  58         }
  59     });
  60 }
  61
  62 static AROS_INTH1(ataBus_Reset, struct scsi_Bus *, bus)
  63 {
  64     AROS_INTFUNC_INIT
  65
  66     struct scsiBase *SCSIBase = bus->sb_Base;
  67     OOP_Object *obj = (void *)bus - SCSIBase->busClass->InstOffset;
  68
  69     D(bug("[SCSI:Bus] %s()\n", __func__));
  70
  71     HIDD_SCSIBus_Shutdown(obj);
  72
  73     return FALSE;
  74
  75     AROS_INTFUNC_EXIT
  76 }
  77
  78 /*****************************************************************************************
  79
  80     NAME
  81         --background--
  82
  83     LOCATION
  84         CLID_Hidd_SCSIBus
  85
  86     NOTES
  87         This class serves as a base class for implementing IDE (ATA) bus drivers.
  88         One particularity of this class is that IDE bus is very speed-critical.
  89         At the other hand, the driver implements very lowlevel operations which
  90         are called quite often. OOP_DoMethod() call is not fast enough, and in
  91         order to circumvent this limitation, additionally to normal OOP API
  92         IDE bus drivers offer two additional non-standard interfaces. Internally
  93         they are implemented as library-alike function table plus driver-specific
  94         data. For the purpose of some performance optimizations the function
  95         table is private to ata.device and managed entirely by the base class.
  96         Driver classes have access only to data portion.
  97
  98         These interfaces are documented below.
  99
 100 *****************************************************************************************/
 101 /*****************************************************************************************
 102
 103     NAME
 104         --PIO interface--
 105
 106     LOCATION
 107         CLID_Hidd_SCSIBus
 108
 109     NOTES
 110         PIO interface is responsible for accessing I/O registers on the IDE
 111         bus, as well as performing PIO-mode 16- and 32-bit data transfers.
 112         This interface is mandatory and must be implemented by the driver,
 113         however some functions are optional. They can be either omitted
 114         entirely from the function table, or set to NULL pointers.
 115
 116         Control functions table for the interface consists of the following
 117         functions (listed in their order in the array):
 118
 119         VOID scsi_out(void *obj, UBYTE val, UWORD offset)
 120         - Write byte into primary register bank with the given offset.
 121
 122         UBYTE scsi_in(void *obj, UWORD offset)
 123         - Read byte from primary register bank with the given offset.
 124
 125         VOID scsi_out_alt(void *obj, UBYTE val, UWORD offset)
 126         - Write byte into alternate register bank with the given offset.
 127           This function is optional.
 128
 129         UBYTE scsi_in_alt(void *obj, UWORD offset)
 130         - Read byte from alternate register bank with the given offset.
 131           This function is optional.
 132
 133         Transfer functions table for the interface consists of the following
 134         functions (listed in their order in the array):
 135
 136         VOID scsi_outsw(void *obj, APTR address, ULONG count)
 137         - Perform 16-bit PIO data write operation from the given memory
 138           region of the given size.
 139
 140         VOID scsi_insw(void *obj, APTR address, ULONG count)
 141         - Perform 16-bit PIO data read operation into the given memory
 142           region of the given size.
 143
 144         VOID scsi_outsl(void *obj, APTR address, ULONG count)
 145         - Perform 32-bit PIO data write operation from the given memory
 146           region of the given size. This function is optional.
 147
 148         UBYTE scsi_insl(void *obj, APTR address, ULONG count)
 149         - Perform 32-bit PIO data read operation into the given memory
 150           region of the given size. This function is optional.
 151
 152 *****************************************************************************************/
 153 /*****************************************************************************************
 154
 155     NAME
 156         --DMA interface--
 157
 158     LOCATION
 159         CLID_Hidd_SCSIBus
 160
 161     NOTES
 162         DMA interface is optional, and is needed in order to support DMA data
 163         transfers.
 164
 165         Function table for the interface consists of the following functions:
 166
 167         BOOL dma_Setup(void *obj, APTR buffer, IPTR size, BOOL read)
 168         - Prepare the controller to DMA data transfer. The last argument is
 169           TRUE for read operation and FALSE for write. The function should
 170           return TRUE for success or FALSE for failure.
 171
 172         VOID dma_Start(void *obj)
 173         - Start DMA transfer.
 174
 175         VOID dma_End(void *obj, APTR buffer, IPTR size, BOOL read)
 176         - End DMA transfer and perform post-transfer cleanup of the given region.
 177
 178         ULONG dma_Result(void *obj)
 179         - Get resulting status of the operation. The function should return 0
 180           for successful completion or error code to be passed up to ata.device
 181           caller in io_Result field of the IORequest.
 182
 183 *****************************************************************************************/
 184 /*****************************************************************************************
 185
 186     NAME
 187         aoHidd_SCSIBus_Use80Wire
 188
 189     SYNOPSIS
 190         [..G], BOOL
 191
 192     LOCATION
 193         CLID_Hidd_SCSIBus
 194
 195     FUNCTION
 196         Tells whether the bus currently uses 80-conductor cable.
 197
 198     NOTES
 199         This attribute actually makes difference only for DMA modes. If
 200         your bus driver returns FALSE, ata.device will not use modes
 201         higher than UDMA2 on the bus.
 202
 203     EXAMPLE
 204
 205     BUGS
 206
 207     SEE ALSO
 208
 209     INTERNALS
 210
 211 *****************************************************************************************/
 212 /*****************************************************************************************
 213
 214     NAME
 215         aoHidd_SCSIBus_Use32Bit
 216
 217     SYNOPSIS
 218         [.SG], BOOL
 219
 220     LOCATION
 221         CLID_Hidd_SCSIBus
 222
 223     FUNCTION
 224         When queried, tells whether the bus supports 32-bit PIO data transfers.
 225         When set, enables or disables 32-bit mode for PIO data transfers.
 226
 227     NOTES
 228
 229     EXAMPLE
 230
 231     BUGS
 232
 233     SEE ALSO
 234
 235     INTERNALS
 236
 237 *****************************************************************************************/
 238 /*****************************************************************************************
 239
 240     NAME
 241         aoHidd_SCSIBus_UseDMA
 242
 243     SYNOPSIS
 244         [..G], BOOL
 245
 246     LOCATION
 247         CLID_Hidd_SCSIBus
 248
 249     FUNCTION
 250         Tells whether the bus supports DMA transfers.
 251
 252     NOTES
 253
 254     EXAMPLE
 255
 256     BUGS
 257
 258     SEE ALSO
 259
 260     INTERNALS
 261         Default implementation in base class returns value depending on whether
 262         the subclass provided DMA interface function table during object creation.
 263
 264 *****************************************************************************************/
 265 /*****************************************************************************************
 266
 267     NAME
 268         aoHidd_SCSIBus_PIODataSize
 269
 270     SYNOPSIS
 271         [I..], BOOL
 272
 273     LOCATION
 274         CLID_Hidd_SCSIBus
 275
 276     FUNCTION
 277         Specifies size of PIO interface data structure.
 278
 279     NOTES
 280
 281     EXAMPLE
 282
 283     BUGS
 284
 285     SEE ALSO
 286
 287     INTERNALS
 288
 289 *****************************************************************************************/
 290 /*****************************************************************************************
 291
 292     NAME
 293         aoHidd_SCSIBus_DMADataSize
 294
 295     SYNOPSIS
 296         [I..], BOOL
 297
 298     LOCATION
 299         CLID_Hidd_SCSIBus
 300
 301     FUNCTION
 302         Specifies size of DMA interface data structure.
 303
 304     NOTES
 305
 306     EXAMPLE
 307
 308     BUGS
 309
 310     SEE ALSO
 311
 312     INTERNALS
 313
 314 *****************************************************************************************/
 315 /*****************************************************************************************
 316
 317     NAME
 318         aoHidd_SCSIBus_BusVectors
 319
 320     SYNOPSIS
 321         [I..], APTR *
 322
 323     LOCATION
 324         CLID_Hidd_SCSIBus
 325
 326     FUNCTION
 327         Specifies control functions table for building PIO interface object.
 328         The function table is an array of function pointers terminated
 329         by -1 value. The terminator must be present for purpose of
 330         binary compatibility with future extensions.
 331
 332     NOTES
 333         This function table is mandatory to be implemented by the driver.
 334
 335     EXAMPLE
 336
 337     BUGS
 338
 339     SEE ALSO
 340
 341     INTERNALS
 342
 343 *****************************************************************************************/
 344 /*****************************************************************************************
 345
 346     NAME
 347         aoHidd_SCSIBus_PIOVectors
 348
 349     SYNOPSIS
 350         [I..], APTR *
 351
 352     LOCATION
 353         CLID_Hidd_SCSIBus
 354
 355     FUNCTION
 356         Specifies transfers function table for building PIO interface object.
 357         The function table is an array of function pointers terminated
 358         by -1 value. The terminator must be present for purpose of
 359         binary compatibility with future extensions.
 360
 361     NOTES
 362         This function table is mandatory to be implemented by the driver.
 363
 364     EXAMPLE
 365
 366     BUGS
 367
 368     SEE ALSO
 369
 370     INTERNALS
 371
 372 *****************************************************************************************/
 373 /*****************************************************************************************
 374
 375     NAME
 376         aoHidd_SCSIBus_DMAVectors
 377
 378     SYNOPSIS
 379         [I..], APTR *
 380
 381     LOCATION
 382         CLID_Hidd_SCSIBus
 383
 384     FUNCTION
 385         Specifies function table for building DMA interface object. If not supplied,
 386         the bus is considered not DMA-capable.
 387
 388     NOTES
 389
 390     EXAMPLE
 391
 392     BUGS
 393
 394     SEE ALSO
 395         aoHidd_SCSIBus_PIOVectors
 396
 397     INTERNALS
 398
 399 *****************************************************************************************/
 400 /*****************************************************************************************
 401
 402     NAME
 403         aoHidd_SCSIBus_UseIOAlt
 404
 405     SYNOPSIS
 406         [..G], BOOL
 407
 408     LOCATION
 409         CLID_Hidd_SCSIBus
 410
 411     FUNCTION
 412         Tells whether the bus supports alternate registers bank
 413         (scsi_AltControl and scsi_AltStatus).
 414
 415     NOTES
 416
 417     EXAMPLE
 418
 419     BUGS
 420
 421     SEE ALSO
 422
 423     INTERNALS
 424         Default implementation in base class returns value depending on whether
 425         the subclass provided respective I/O functions in bus interface vector
 426         table during object creation.
 427
 428 *****************************************************************************************/
 429 /*****************************************************************************************
 430
 431     NAME
 432         aoHidd_SCSIBus_Master
 433
 434     SYNOPSIS
 435         [..G], OOP_Object *
 436
 437     LOCATION
 438         CLID_Hidd_SCSIBus
 439
 440     FUNCTION
 441         Returns a pointer to OOP object of private unit class, representing
 442         a master drive on the bus, or NULL if there's no master device.
 443
 444     NOTES
 445
 446     EXAMPLE
 447
 448     BUGS
 449
 450     SEE ALSO
 451         aoHidd_SCSIBus_Slave
 452
 453     INTERNALS
 454
 455 *****************************************************************************************/
 456 /*****************************************************************************************
 457
 458     NAME
 459         aoHidd_SCSIBus_Slave
 460
 461     SYNOPSIS
 462         [..G], OOP_Object *
 463
 464     LOCATION
 465         CLID_Hidd_SCSIBus
 466
 467     FUNCTION
 468         Returns a pointer to OOP object of private unit class, representing
 469         a slave drive on the bus, or NULL if there's no master device.
 470
 471     NOTES
 472
 473     EXAMPLE
 474
 475     BUGS
 476
 477     SEE ALSO
 478         aoHidd_SCSIBus_Master
 479
 480     INTERNALS
 481
 482 *****************************************************************************************/
 483 /*****************************************************************************************
 484
 485     NAME
 486         aoHidd_SCSIBus_CanSetXferMode
 487
 488     SYNOPSIS
 489         [..G], BOOL
 490
 491     LOCATION
 492         CLID_Hidd_SCSIBus
 493
 494     FUNCTION
 495         Tells whether the bus driver implements moHidd_SCSIBus_SetXferMode method.
 496
 497     NOTES
 498
 499     EXAMPLE
 500
 501     BUGS
 502         Current version of ata.device does not use this attribute, and it is
 503         considered reserved.
 504
 505     SEE ALSO
 506         moHidd_SCSIBus_SetXferMode
 507
 508     INTERNALS
 509
 510 *****************************************************************************************/
 511
 512 OOP_Object *SCSIBus__Root__New(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
 513 {
 514     struct scsiBase *SCSIBase = cl->UserData;
 515     D(bug("[SCSI:Bus] %s()\n", __func__));
 516
 517     o = (OOP_Object *)OOP_DoSuperMethod(cl, o, &msg->mID);
 518     if (o)
 519     {
 520         struct scsi_Bus *data = OOP_INST_DATA(cl, o);
 521         struct TagItem *tstate = msg->attrList;
 522         struct TagItem *tag;
 523
 524         D(
 525           bug("[SCSI:Bus] %s: instance @ 0x%p\n", __func__, o);
 526           bug("[SCSI:Bus] %s: scsi_Bus @ 0x%p\n", __func__, data);
 527          )
 528
 529         /* Defaults */
 530         data->keepEmpty = TRUE;
 531
 532         while ((tag = NextTagItem(&tstate)))
 533         {
 534             ULONG idx;
 535
 536             Hidd_SCSIBus_Switch(tag->ti_Tag, idx)
 537             {
 538             case aoHidd_SCSIBus_PIODataSize:
 539                 data->pioDataSize = tag->ti_Data;
 540                 D(bug("[SCSI:Bus] %s: PIODataSize = %d\n", __func__, data->pioDataSize);)
 541                 break;
 542
 543             case aoHidd_SCSIBus_DMADataSize:
 544                 data->dmaDataSize = tag->ti_Data;
 545                 DATTR(bug("[SCSI:Bus] %s: DMADataSize = %d\n", __func__, data->dmaDataSize);)
 546                 break;
 547
 548             case aoHidd_SCSIBus_BusVectors:
 549                 data->busVectors = (struct SCSI_BusInterface *)tag->ti_Data;
 550                 DATTR(bug("[SCSI:Bus] %s: BusVectors @ 0x%p\n", __func__, data->busVectors);)
 551                 break;
 552
 553             case aoHidd_SCSIBus_PIOVectors:
 554                 data->pioVectors = (struct SCSI_PIOInterface *)tag->ti_Data;
 555                 DATTR(bug("[SCSI:Bus] %s: PIOVectors @ 0x%p\n", __func__, data->pioVectors);)
 556                 break;
 557
 558             case aoHidd_SCSIBus_DMAVectors:
 559                 data->dmaVectors = (APTR *)tag->ti_Data;
 560                 DATTR(bug("[SCSI:Bus] %s: DMAVectors @ 0x%p\n", __func__, data->dmaVectors);)
 561                 break;
 562             }
 563             Hidd_Bus_Switch(tag->ti_Tag, idx)
 564             {
 565             case aoHidd_Bus_KeepEmpty:
 566                 data->keepEmpty = tag->ti_Data;
 567                 break;
 568             }
 569         }
 570
 571         /* Cache device base pointer. Useful. */
 572         data->sb_Base = SCSIBase;
 573
 574         /* Install reset callback */
 575         data->sb_ResetInt.is_Node.ln_Name = SCSIBase->scsi_Device.dd_Library.lib_Node.ln_Name;
 576         data->sb_ResetInt.is_Code         = (VOID_FUNC)ataBus_Reset;
 577         data->sb_ResetInt.is_Data         = data;
 578         AddResetCallback(&data->sb_ResetInt);
 579     }
 580     return o;
 581 }
 582
 583 void SCSIBus__Root__Dispose(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
 584 {
 585     struct scsi_Bus *data = OOP_INST_DATA(cl, o);
 586
 587     RemResetCallback(&data->sb_ResetInt);
 588
 589     if (data->dmaInterface)
 590     {
 591         void *ptr = data->dmaInterface - sizeof(struct SCSI_DMAInterface);
 592
 593         FreeMem(ptr, sizeof(struct SCSI_DMAInterface) + data->dmaDataSize);
 594     }
 595     if (data->pioInterface)
 596     {
 597         void *ptr = data->pioInterface - sizeof(struct SCSI_BusInterface);
 598
 599         FreeMem(ptr, sizeof(struct SCSI_BusInterface) + data->pioDataSize);
 600     }
 601
 602     OOP_DoSuperMethod(cl, o, msg);
 603 }
 604
 605 /*
 606  * Here we take into account that the table can be either
 607  * terminated early, or have NULL entries.
 608  */
 609 #define HAVE_VECTOR(x) (x && (x != (APTR)-1))
 610
 611 void SCSIBus__Root__Get(OOP_Class *cl, OOP_Object *o, struct pRoot_Get *msg)
 612 {
 613     struct scsiBase *SCSIBase = cl->UserData;
 614     struct scsi_Bus *data = OOP_INST_DATA(cl, o);
 615     ULONG idx;
 616
 617     Hidd_Bus_Switch (msg->attrID, idx)
 618     {
 619     case aoHidd_Bus_MaxUnits:
 620         *msg->storage = MAX_BUSUNITS;
 621         return;
 622     }
 623
 624     Hidd_SCSIBus_Switch (msg->attrID, idx)
 625     {
 626     case aoHidd_SCSIBus_Use80Wire:
 627         *msg->storage = FALSE;
 628         return;
 629
 630     case aoHidd_SCSIBus_Use32Bit:
 631         *msg->storage = (HAVE_VECTOR(data->pioVectors->scsi_outsl) &&
 632                          HAVE_VECTOR(data->pioVectors->scsi_insl)) ?
 633                          TRUE : FALSE;
 634         return;
 635
 636     case aoHidd_SCSIBus_UseDMA:
 637         *msg->storage = data->dmaVectors ? TRUE : FALSE;
 638         return;
 639
 640     case aoHidd_SCSIBus_UseIOAlt:
 641         *msg->storage = (HAVE_VECTOR(data->busVectors->scsi_out_alt) &&
 642                          HAVE_VECTOR(data->busVectors->scsi_in_alt)) ?
 643                          TRUE : FALSE;
 644         return;
 645
 646     case aoHidd_SCSIBus_CanSetXferMode:
 647         *msg->storage = FALSE;
 648         return;
 649     }
 650
 651     OOP_DoSuperMethod(cl, o, &msg->mID);
 652 }
 653
 654 void SCSIBus__Hidd_StorageBus__EnumUnits(OOP_Class *cl, OOP_Object *o, struct pHidd_StorageBus_EnumUnits *msg)
 655 {
 656     struct scsi_Bus *data = OOP_INST_DATA(cl, o);
 657     BOOL stop = FALSE;
 658
 659     D(bug ("[SCSI:Bus] Hidd_StorageBus__EnumUnits()\n");)
 660
 661     if (data->sb_Units[0])
 662         stop = CALLHOOKPKT(msg->callback, data->sb_Units[0], msg->hookMsg);
 663     if ((!stop) && (data->sb_Units[1]))
 664          stop = CALLHOOKPKT(msg->callback, data->sb_Units[1], msg->hookMsg);
 665 }
 666
 667 /* Default scsi_out_alt does nothing */
 668 static void default_out_alt(void *obj, UBYTE val, UWORD offset)
 669 {
 670
 671 }
 672
 673 /* Default scsi_in_alt wraps AltStatus to status */
 674 static UBYTE default_in_alt(void *obj, UWORD offset)
 675 {
 676     struct SCSI_BusInterface *vec = obj - sizeof(struct SCSI_BusInterface);
 677
 678     return vec->scsi_in(obj, scsi_Status);
 679 }
 680
 681 static void CopyVectors(APTR *dest, APTR *src, unsigned int num)
 682 {
 683     unsigned int i;
 684
 685     for (i = 0; i < num; i++)
 686     {
 687         if (src[i] == (APTR *)-1)
 688             return;
 689         if (src[i])
 690             dest[i] = src[i];
 691     }
 692 }
 693
 694 /*****************************************************************************************
 695
 696     NAME
 697         moHidd_SCSIBus_GetPIOInterface
 698
 699     SYNOPSIS
 700         APTR OOP_DoMethod(OOP_Object *obj, struct pHidd_SCSIBus_GetPIOInterface *Msg);
 701
 702         APTR HIDD_SCSIBus_GetPIOInterface(void);
 703
 704     LOCATION
 705         CLID_Hidd_SCSIBus
 706
 707     FUNCTION
 708         Instantiates encapsulated PIO interface object and returns its
 709         pointer.
 710
 711     INPUTS
 712         None
 713
 714     RESULT
 715         A pointer to opaque PIO interface object or NULL in case of failure.
 716
 717     NOTES
 718         This method should be overloaded by driver subclasses in order to
 719         initialize data portion of the interface object.
 720
 721     EXAMPLE
 722
 723     BUGS
 724
 725     SEE ALSO
 726         moHidd_SCSIBus_GetDMAInterface
 727
 728     INTERNALS
 729         Interface objects contain not only driver-specific data, but also
 730         a private vector table. Because of this you cannot just AllocMem()
 731         the necessary structure in your driver. Always call OOP_DoSuperMethod()
 732         in order for the base class to instantiate the interface correctly.
 733
 734 *****************************************************************************************/
 735
 736 APTR SCSIBus__Hidd_SCSIBus__GetPIOInterface(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
 737 {
 738     struct scsi_Bus *data = OOP_INST_DATA(cl, o);
 739     struct SCSI_BusInterface *vec;
 740
 741     D(
 742       bug("[SCSI:Bus] %s()\n", __func__);
 743       bug("[SCSI:Bus] %s: scsi_Bus @ 0x%p\n", __func__, data);
 744      )
 745
 746     vec = AllocMem(sizeof(struct SCSI_BusInterface) + data->pioDataSize,
 747                    MEMF_PUBLIC|MEMF_CLEAR);
 748     if (vec)
 749     {
 750         D(bug("[SCSI:Bus] %s: SCSI_BusInterface @ 0x%p (%d bytes + %d)\n", __func__, vec, sizeof(struct SCSI_BusInterface), data->pioDataSize);)
 751
 752         /* Some default vectors for simplicity */
 753         vec->scsi_out_alt = default_out_alt;
 754         vec->scsi_in_alt  = default_in_alt;
 755
 756         CopyVectors((APTR *)vec, (APTR *)data->busVectors,
 757                     sizeof(struct SCSI_BusInterface) / sizeof(APTR));
 758
 759         data->pioInterface = &vec[1];
 760         return data->pioInterface;
 761     }
 762
 763     return NULL;
 764 }
 765
 766 /*****************************************************************************************
 767
 768     NAME
 769         moHidd_SCSIBus_GetDMAInterface
 770
 771     SYNOPSIS
 772         APTR OOP_DoMethod(OOP_Object *obj, struct pHidd_SCSIBus_GetDMAInterface *Msg);
 773
 774         APTR HIDD_SCSIBus_GetDMAInterface(void);
 775
 776     LOCATION
 777         CLID_Hidd_SCSIBus
 778
 779     FUNCTION
 780         Instantiates encapsulated DMA interface object and returns its
 781         pointer.
 782
 783     INPUTS
 784         None
 785
 786     RESULT
 787         A pointer to opaque DMA interface object or NULL upon failure or
 788         if DMA is not supported by this bus.
 789
 790     NOTES
 791         This method should be overloaded by driver subclasses in order to
 792         initialize data portion of the interface object.
 793
 794     EXAMPLE
 795
 796     BUGS
 797
 798     SEE ALSO
 799         moHidd_SCSIBus_GetPIOInterface
 800
 801     INTERNALS
 802         Interface objects contain not only driver-specific data, but also
 803         a private vector table. Because of this you cannot just AllocMem()
 804         the necessary structure in your driver. Always call OOP_DoSuperMethod()
 805         in order for the base class to instantiate the interface correctly.
 806
 807 *****************************************************************************************/
 808
 809 APTR SCSIBus__Hidd_SCSIBus__GetDMAInterface(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
 810 {
 811     struct scsi_Bus *data = OOP_INST_DATA(cl, o);
 812     struct SCSI_DMAInterface *vec;
 813
 814     D(bug("[SCSI:Bus] %s()\n", __func__));
 815
 816     if (!data->dmaVectors)
 817         return NULL;
 818
 819     vec = AllocMem(sizeof(struct SCSI_DMAInterface) + data->dmaDataSize,
 820                    MEMF_PUBLIC|MEMF_CLEAR);
 821     if (vec)
 822     {
 823         CopyVectors((APTR *)vec, data->dmaVectors,
 824                     sizeof(struct SCSI_DMAInterface) / sizeof(APTR));
 825
 826         data->dmaInterface = &vec[1];
 827         return data->dmaInterface;
 828     }
 829
 830     return NULL;
 831 }
 832
 833 /*****************************************************************************************
 834
 835     NAME
 836         moHidd_SCSIBus_SetXferMode
 837
 838     SYNOPSIS
 839         APTR OOP_DoMethod(OOP_Object *obj, struct pHidd_SCSIBus_SetXferMode *Msg);
 840
 841         APTR HIDD_SCSIBus_SetXferMode(UBYTE unit, scsi_XferMode mode);
 842
 843     LOCATION
 844         CLID_Hidd_SCSIBus
 845
 846     FUNCTION
 847         Sets the desired transfer mode for the given drive on the bus controller.
 848
 849     INPUTS
 850         unit - drive number (0 for master and 1 for slave)
 851         mode - Mode number (see hidd/ata.h)
 852
 853     RESULT
 854         TRUE if successful or FALSE if the desired mode is not supported
 855         by the hardware.
 856
 857     NOTES
 858         The default implementation is provided for drivers not supporting
 859         DMA and always returns FALSE if the caller attempts to set any of
 860         DMA modes.
 861
 862     EXAMPLE
 863
 864     BUGS
 865         Current version of ata.device does not use this method, and it is
 866         considered reserved.
 867
 868     SEE ALSO
 869         aoHidd_SCSIBus_CanSetXferMode
 870
 871     INTERNALS
 872
 873 *****************************************************************************************/
 874
 875 BOOL SCSIBus__Hidd_SCSIBus__SetXferMode(OOP_Class *cl, OOP_Object *o, struct pHidd_SCSIBus_SetXferMode *msg)
 876 {
 877     D(bug("[SCSI:Bus] %s()\n", __func__));
 878
 879     if ((msg->mode >= AB_XFER_MDMA0) && (msg->mode <= AB_XFER_UDMA6))
 880     {
 881         /* DMA is not supported, we cannot set DMA modes */
 882         return FALSE;
 883     }
 884
 885     return TRUE;
 886 }
 887
 888 /*****************************************************************************************
 889
 890     NAME
 891         moHidd_SCSIBus_Shutdown
 892
 893     SYNOPSIS
 894         APTR OOP_DoMethod(OOP_Object *obj, struct pHidd_SCSIBus_Shutdown *Msg);
 895
 896         APTR HIDD_SCSIBus_Shutdown(void);
 897
 898     LOCATION
 899         CLID_Hidd_SCSIBus
 900
 901     FUNCTION
 902         Instantly shutdown all activity on the bus.
 903
 904     INPUTS
 905         None
 906
 907     RESULT
 908         None
 909
 910     NOTES
 911         This method is called by ata.device during system reset handler execution.
 912
 913     EXAMPLE
 914
 915     BUGS
 916
 917     SEE ALSO
 918
 919     INTERNALS
 920         Default implementation disables interrupt using AltControl register.
 921
 922 *****************************************************************************************/
 923
 924 void SCSIBus__Hidd_SCSIBus__Shutdown(OOP_Class *cl, OOP_Object *o, OOP_Msg *msg)
 925 {
 926     struct scsi_Bus *data = OOP_INST_DATA(cl, o);
 927
 928     D(bug("[SCSI:Bus] %s()\n", __func__));
 929
 930     if (data->pioInterface)
 931     {
 932         struct SCSI_BusInterface *vec = data->pioInterface - sizeof(struct SCSI_BusInterface);
 933
 934         vec->scsi_out_alt(data->pioInterface, SCSICTLF_INT_DISABLE, scsi_AltControl);
 935     }
 936 }
 937
 938 /***************** Private nonvirtual methods follow *****************/
 939
 940 BOOL Hidd_SCSIBus_Start(OOP_Object *o, struct scsiBase *SCSIBase)
 941 {
 942     struct scsi_Bus *sb = OOP_INST_DATA(SCSIBase->busClass, o);
 943
 944     D(bug("[SCSI:Bus] %s()\n", __func__));
 945
 946     /* Attach IRQ handler */
 947     OOP_SetAttrsTags(o, aHidd_Bus_IRQHandler, Hidd_SCSIBus_HandleIRQ,
 948                         aHidd_Bus_IRQData   , sb,
 949                         TAG_DONE);
 950
 951     /* scan bus - try to locate all devices (disables irq) */
 952     scsi_InitBus(sb);
 953
 954     if ((sb->sb_Dev[0] == DEV_NONE) && (sb->sb_Dev[1] == DEV_NONE) &&
 955         (!sb->keepEmpty))
 956     {
 957         /*
 958          * If there are no devices, and KeepEmpty is not set
 959          * the bus will be thrown away.
 960          */
 961         return FALSE;
 962     }
 963
 964     /*
 965      * Assign bus number.
 966      * TODO:
 967      * 1. This does not take into account possibility to
 968      * unload drivers. In this case existing units will disappear,
 969      * freeing up their numbers. These numbers should be reused.
 970      * 2. We REALLY need modify-and-fetch atomics.
 971      */
 972     Forbid();
 973     sb->sb_BusNum = SCSIBase->scsi__buscount++;
 974     Permit();
 975
 976     if ((sb->sb_Dev[0] < DEV_ATA) && (sb->sb_Dev[1] < DEV_ATA))
 977     {
 978         /* Do not start up task if there are no usable devices. */
 979         return TRUE;
 980     }
 981
 982     /*
 983      * This small trick is based on the fact that shared semaphores
 984      * have no specific owner. You can obtain and release them from
 985      * within any task. It will block only on attempt to re-lock it
 986      * in exclusive mode.
 987      * So instead of complex handshake we obtain the semaphore before
 988      * starting bus task. It will release the semaphore when done.
 989      */
 990     ObtainSemaphoreShared(&SCSIBase->DetectionSem);
 991
 992     /*
 993      * Start up bus task. It will perform scanning asynchronously, and
 994      * then, if successful, insert units. This allows to keep things parallel.
 995      */
 996     D(bug("[SCSI>>] Start: Bus %u: Unit 0 - %d, Unit 1 - %d\n", sb->sb_BusNum, sb->sb_Dev[0], sb->sb_Dev[1]));
 997     return NewCreateTask(TASKTAG_PC         , BusTaskCode,
 998                          TASKTAG_NAME       , "ATA[PI] Subsystem",
 999                          TASKTAG_STACKSIZE  , STACK_SIZE,
1000                          TASKTAG_PRI        , TASK_PRI,
1001                          TASKTAG_TASKMSGPORT, &sb->sb_MsgPort,
1002                          TASKTAG_ARG1       , sb,
1003                          TASKTAG_ARG2       , SCSIBase,
1004                          TAG_DONE) ? TRUE : FALSE;
1005 }
1006
1007 AROS_UFH3(BOOL, Hidd_SCSIBus_Open,
1008           AROS_UFHA(struct Hook *, h, A0),
1009           AROS_UFHA(OOP_Object *, obj, A2),
1010           AROS_UFHA(IPTR, reqUnit, A1))
1011 {
1012     AROS_USERFUNC_INIT
1013
1014     struct IORequest *req = h->h_Data;
1015     struct scsiBase *SCSIBase = (struct scsiBase *)req->io_Device;
1016     struct scsi_Bus *sb = (struct scsi_Bus *)OOP_INST_DATA(SCSIBase->busClass, obj);
1017     ULONG bus = reqUnit >> 1;
1018     UBYTE dev = reqUnit & 1;
1019
1020     D(bug("[SCSI:Bus] %s()\n", __func__));
1021     D(bug("[SCSI%02ld] Checking bus %u dev %u\n", reqUnit, bus, dev));
1022
1023     if ((sb->sb_BusNum == bus) && sb->sb_Units[dev])
1024     {
1025         struct scsi_Unit *unit = (struct scsi_Unit *)OOP_INST_DATA(SCSIBase->unitClass, sb->sb_Units[dev]);
1026
1027         /* Got the unit */
1028         req->io_Unit  = &unit->su_Unit;
1029         req->io_Error = 0;
1030
1031         unit->su_Unit.unit_OpenCnt++;
1032         return TRUE;
1033     }
1034
1035     return FALSE;
1036
1037     AROS_USERFUNC_EXIT
1038 }