arch/common/hidd.pci/pcideviceclass.c

   1 /*
   2     Copyright © 2004-2006, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: PCI device class
   6     Lang: English
   7 */
   8
   9 /*
  10  * 2008-03-30 T. Wiszkowski  Corrected typo and added InterruptStatus, CapabilitiesPresent attributes
  11  */
  12
  13 #include <exec/types.h>
  14 #include <hidd/pci.h>
  15 #include <oop/oop.h>
  16
  17 #include <utility/tagitem.h>
  18
  19 #include <proto/exec.h>
  20 #include <proto/utility.h>
  21 #include <proto/oop.h>
  22
  23 #include "pci.h"
  24 #include "pciutil.h"
  25
  26 #define DEBUG 1
  27 #include <aros/debug.h>
  28
  29 #ifdef HiddPCIDeviceAttrBase
  30 #undef HiddPCIDeviceAttrBase
  31 #endif // HiddPCIDeviceAttrBase
  32
  33 #define HiddPCIDeviceAttrBase   (PSD(cl)->hiddPCIDeviceAB)
  34
  35 static void setLong(OOP_Class *cl, OOP_Object *o, ULONG reg, ULONG value)
  36 {
  37     tDeviceData *dev = (tDeviceData *)OOP_INST_DATA(cl,o);
  38     OOP_Object *driver = dev->driver;
  39
  40     struct pHidd_PCIDriver_WriteConfigLong msg;
  41
  42     msg.mID = PSD(cl)->mid_WL;
  43     msg.bus = dev->bus;
  44     msg.dev = dev->dev;
  45     msg.sub = dev->sub;
  46     msg.reg = reg;
  47     msg.val = value;
  48
  49     OOP_DoMethod(driver, (OOP_Msg)&msg);
  50 }
  51
  52 static void setWord(OOP_Class *cl, OOP_Object *o, ULONG reg, UWORD value)
  53 {
  54     tDeviceData *dev = (tDeviceData *)OOP_INST_DATA(cl,o);
  55     OOP_Object *driver = dev->driver;
  56
  57     struct pHidd_PCIDriver_WriteConfigWord msg;
  58
  59     msg.mID = PSD(cl)->mid_WW;
  60     msg.bus = dev->bus;
  61     msg.dev = dev->dev;
  62     msg.sub = dev->sub;
  63     msg.reg = reg;
  64     msg.val = value;
  65
  66     OOP_DoMethod(driver, (OOP_Msg)&msg);
  67 }
  68
  69 static void setByte(OOP_Class *cl, OOP_Object *o, ULONG reg, UBYTE value)
  70 {
  71     tDeviceData *dev = (tDeviceData *)OOP_INST_DATA(cl,o);
  72     OOP_Object *driver = dev->driver;
  73
  74     struct pHidd_PCIDriver_WriteConfigByte msg;
  75
  76     msg.mID = PSD(cl)->mid_WB;
  77     msg.bus = dev->bus;
  78     msg.dev = dev->dev;
  79     msg.sub = dev->sub;
  80     msg.reg = reg;
  81     msg.val = value;
  82
  83     OOP_DoMethod(driver, (OOP_Msg)&msg);
  84 }
  85
  86 static ULONG getLong(OOP_Class *cl, OOP_Object *o, ULONG reg)
  87 {
  88     tDeviceData *dev = (tDeviceData *)OOP_INST_DATA(cl,o);
  89     OOP_Object *driver = dev->driver;
  90
  91     struct pHidd_PCIDriver_ReadConfigLong msg;
  92
  93     msg.mID = PSD(cl)->mid_RL;
  94     msg.bus = dev->bus;
  95     msg.dev = dev->dev;
  96     msg.sub = dev->sub;
  97     msg.reg = reg;
  98
  99     return OOP_DoMethod(driver, (OOP_Msg)&msg);
 100 }
 101
 102 static UWORD getWord(OOP_Class *cl, OOP_Object *o, ULONG reg)
 103 {
 104     tDeviceData *dev = (tDeviceData *)OOP_INST_DATA(cl,o);
 105     OOP_Object *driver = dev->driver;
 106
 107     struct pHidd_PCIDriver_ReadConfigWord msg;
 108
 109     msg.mID = PSD(cl)->mid_RW;
 110     msg.bus = dev->bus;
 111     msg.dev = dev->dev;
 112     msg.sub = dev->sub;
 113     msg.reg = reg;
 114
 115     return OOP_DoMethod(driver, (OOP_Msg)&msg);
 116 }
 117
 118 static UBYTE getByte(OOP_Class *cl, OOP_Object *o, ULONG reg)
 119 {
 120     tDeviceData *dev = (tDeviceData *)OOP_INST_DATA(cl,o);
 121     OOP_Object *driver = dev->driver;
 122
 123     struct pHidd_PCIDriver_ReadConfigByte msg;
 124
 125     msg.mID = PSD(cl)->mid_RB;
 126     msg.bus = dev->bus;
 127     msg.dev = dev->dev;
 128     msg.sub = dev->sub;
 129     msg.reg = reg;
 130
 131     return OOP_DoMethod(driver, (OOP_Msg)&msg);
 132 }
 133
 134 UBYTE PCIDev__Hidd_PCIDevice__ReadConfigByte(OOP_Class *cl, OOP_Object *o, struct pHidd_PCIDevice_ReadConfigByte *msg)
 135 {
 136     return getByte(cl, o, msg->reg);
 137 }
 138
 139 UWORD PCIDev__Hidd_PCIDevice__ReadConfigWord(OOP_Class *cl, OOP_Object *o, struct pHidd_PCIDevice_ReadConfigWord *msg)
 140 {
 141     return getWord(cl, o, msg->reg);
 142 }
 143
 144 UBYTE PCIDev__Hidd_PCIDevice__ReadConfigLong(OOP_Class *cl, OOP_Object *o, struct pHidd_PCIDevice_ReadConfigLong *msg)
 145 {
 146     return getLong(cl, o, msg->reg);
 147 }
 148
 149 VOID PCIDev__Hidd_PCIDevice__WriteConfigByte(OOP_Class *cl, OOP_Object *o, struct pHidd_PCIDevice_WriteConfigByte *msg)
 150 {
 151     setByte(cl, o, msg->reg, msg->val);
 152 }
 153
 154 VOID PCIDev__Hidd_PCIDevice__WriteConfigWord(OOP_Class *cl, OOP_Object *o, struct pHidd_PCIDevice_WriteConfigWord *msg)
 155 {
 156     setWord(cl, o, msg->reg, msg->val);
 157 }
 158
 159 VOID PCIDev__Hidd_PCIDevice__WriteConfigLong(OOP_Class *cl, OOP_Object *o, struct pHidd_PCIDevice_WriteConfigLong *msg)
 160 {
 161     setLong(cl, o, msg->reg, msg->val);
 162 }
 163
 164
 165 /*
 166     PCIDevice::New method is invoked by base pci class. It passes to the device
 167     class information about the driver this class should use and location of
 168     created device on the PCI bus handled by given driver.
 169 */
 170 OOP_Object *PCIDev__Root__New(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
 171 {
 172     int i;
 173
 174     o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg) msg);
 175     if (o)
 176     {
 177         struct TagItem *tags, *tag;
 178         tDeviceData *dev = (tDeviceData *)OOP_INST_DATA(cl, o);
 179         OOP_Object *driver = NULL;
 180
 181         tags=msg->attrList;
 182
 183         /*
 184             Get all information passed by pci class calling OOP_NewObject()
 185         */
 186         while((tag = NextTagItem((struct TagItem **)&tags)))
 187         {
 188             ULONG idx;
 189
 190             if (IS_PCIDEV_ATTR(tag->ti_Tag, idx))
 191             {
 192                 switch(idx)
 193                 {
 194                     case aoHidd_PCIDevice_Driver:
 195                         dev->driver = (OOP_Object*)tag->ti_Data;
 196                         driver = dev->driver;
 197                         break;
 198
 199                     case aoHidd_PCIDevice_Bus:
 200                         dev->bus = tag->ti_Data;
 201                         break;
 202
 203                     case aoHidd_PCIDevice_Dev:
 204                         dev->dev = tag->ti_Data;
 205                         break;
 206
 207                     case aoHidd_PCIDevice_Sub:
 208                         dev->sub = tag->ti_Data;
 209                         break;
 210                 }
 211             }
 212         }
 213
 214         /*
 215             If driver is passed (*HAS TO* be passed) acquire some unchangeable
 216             information regarding given device
 217         */
 218         if (driver)
 219         {
 220             UBYTE ht;
 221
 222             /*
 223                 Get the header type in order to determine whether it is a
 224                 device or bridge
 225             */
 226             ht = getByte(cl, o, PCICS_HEADERTYPE) & PCIHT_MASK;
 227             dev->isBridge = 0;
 228             if (ht == PCIHT_BRIDGE)
 229             {
 230                 dev->isBridge = 1;
 231                 dev->subbus = getByte(cl, o, PCIBR_SUBBUS);
 232             }
 233
 234             /* Get all constant ID's */
 235             dev->VendorID = getWord(cl, o, PCICS_VENDOR);
 236             dev->ProductID = getWord(cl, o, PCICS_PRODUCT);
 237
 238             dev->RevisionID = getByte(cl, o, PCICS_REVISION);
 239             dev->Interface = getByte(cl, o, PCICS_PROGIF);
 240             dev->SubClass = getByte(cl, o, PCICS_SUBCLASS);
 241             dev->Class = getByte(cl, o, PCICS_CLASS);
 242
 243             dev->SubsysVID = getWord(cl, o, PCICS_SUBVENDOR);
 244             dev->SubsystemID = getWord(cl, o, PCICS_SUBSYSTEM);
 245
 246             dev->IRQLine = getByte(cl, o, PCICS_INT_PIN);
 247
 248             if (dev->IRQLine)
 249             {
 250                 dev->INTLine = getByte(cl, o, PCICS_INT_LINE);
 251             }
 252             else dev->INTLine = 0;
 253
 254             dev->HeaderType = ht;
 255
 256             getPCIClassDesc(dev->Class, dev->SubClass, dev->Interface,
 257                 &dev->strClass, &dev->strSubClass, &dev->strInterface);
 258
 259             /* Satisfy BUG watchers ;) */
 260             D(bug("[PCIDevice] %02x.%02x.%x = %04.4lx:%04.4lx (%s %s %s)\n",
 261                 dev->bus, dev->dev, dev->sub,
 262                 dev->VendorID, dev->ProductID,
 263                 dev->strClass, dev->strSubClass, dev->strInterface));
 264
 265             /* Read two first base addresses */
 266             for (i = 0; i < 2; i++)
 267             {
 268                 dev->BaseReg[i].addr = getLong(cl, o, PCICS_BAR0 + (i << 2));
 269                 dev->BaseReg[i].size = sizePCIBaseReg(driver, PSD(cl), dev->bus,
 270                         dev->dev, dev->sub, i);
 271             }
 272
 273             /* Address and size of ROM */
 274             dev->RomBase = getLong(cl, o, PCICS_EXPROM_BASE);
 275             dev->RomSize = sizePCIBaseReg(driver, PSD(cl), dev->bus,
 276                         dev->dev, dev->sub, (PCICS_EXPROM_BASE - PCICS_BAR0) >> 2);
 277
 278             /*
 279                 Bridges specify only first two base addresses. If not bridge,
 280                 check the rest now
 281             */
 282             if (! dev->isBridge)
 283             {
 284                 for (i = 2; i < 6; i++)
 285                 {
 286                     dev->BaseReg[i].addr = getLong(cl, o, PCICS_BAR0 + (i << 2));
 287                     dev->BaseReg[i].size = sizePCIBaseReg(driver, PSD(cl), dev->bus,
 288                         dev->dev, dev->sub, i);
 289                 }
 290             }
 291         }
 292     }
 293
 294     return o;
 295 }
 296
 297 /*
 298     PCIDevice::Get method splitted into few parts in order to make switch'es shorter.
 299 */
 300
 301 static const void dispatch_generic(OOP_Class *cl, OOP_Object *o, struct pRoot_Get *msg)
 302 {
 303     ULONG idx;
 304     tDeviceData *dev = (tDeviceData *)OOP_INST_DATA(cl,o);
 305
 306     idx = msg->attrID - HiddPCIDeviceAttrBase;
 307
 308         switch(idx)
 309         {
 310             case aoHidd_PCIDevice_Driver:
 311                 *msg->storage = (IPTR)dev->driver;
 312                 break;
 313
 314             case aoHidd_PCIDevice_Bus:
 315                 *msg->storage = (IPTR)dev->bus;
 316                 break;
 317
 318             case aoHidd_PCIDevice_Dev:
 319                 *msg->storage = (IPTR)dev->dev;
 320                 break;
 321
 322             case aoHidd_PCIDevice_Sub:
 323                 *msg->storage = (IPTR)dev->sub;
 324                 break;
 325
 326             case aoHidd_PCIDevice_VendorID:
 327                 *msg->storage = (IPTR)dev->VendorID;
 328                 break;
 329
 330             case aoHidd_PCIDevice_ProductID:
 331                 *msg->storage = (IPTR)dev->ProductID;
 332                 break;
 333
 334             case aoHidd_PCIDevice_RevisionID:
 335                 *msg->storage = (IPTR)dev->RevisionID;
 336                 break;
 337
 338             case aoHidd_PCIDevice_Interface:
 339                 *msg->storage = (IPTR)dev->Interface;
 340                 break;
 341
 342             case aoHidd_PCIDevice_Class:
 343                 *msg->storage = (IPTR)dev->Class;
 344                 break;
 345
 346             case aoHidd_PCIDevice_SubClass:
 347                 *msg->storage = (IPTR)dev->SubClass;
 348                 break;
 349
 350             case aoHidd_PCIDevice_SubsystemVendorID:
 351                 *msg->storage = (IPTR)dev->SubsysVID;
 352                 break;
 353
 354             case aoHidd_PCIDevice_SubsystemID:
 355                 *msg->storage = (IPTR)dev->SubsystemID;
 356                 break;
 357
 358             case aoHidd_PCIDevice_INTLine:
 359                 *msg->storage = (IPTR)dev->INTLine;
 360                 break;
 361
 362             case aoHidd_PCIDevice_IRQLine:
 363                 *msg->storage = (IPTR)dev->IRQLine;
 364                 break;
 365
 366             case aoHidd_PCIDevice_RomBase:
 367                 *msg->storage = (IPTR)dev->RomBase;
 368                 break;
 369
 370             case aoHidd_PCIDevice_RomSize:
 371                 *msg->storage = (IPTR)dev->RomSize;
 372                 break;
 373         }
 374 }
 375
 376 static const void dispatch_base(OOP_Class *cl, OOP_Object *o, struct pRoot_Get *msg)
 377 {
 378     ULONG idx,id;
 379     tDeviceData *dev = (tDeviceData *)OOP_INST_DATA(cl,o);
 380
 381     idx = msg->attrID - HiddPCIDeviceAttrBase;
 382     id = 0;
 383
 384     switch(idx)
 385     {
 386         case aoHidd_PCIDevice_Base0:    id = 0;     break;
 387         case aoHidd_PCIDevice_Base1:    id = 1;     break;
 388         case aoHidd_PCIDevice_Base2:    id = 2;     break;
 389         case aoHidd_PCIDevice_Base3:    id = 3;     break;
 390         case aoHidd_PCIDevice_Base4:    id = 4;     break;
 391         case aoHidd_PCIDevice_Base5:    id = 5;     break;
 392     }
 393
 394     /* Do not allow reading of more than two base addresses in case of PCI-PCI bridges */
 395     if (dev->isBridge && id >= 2) { *msg->storage = 0; return; }
 396
 397     *msg->storage = (IPTR)dev->BaseReg[id].addr;
 398     if ((dev->BaseReg[id].addr & PCIBAR_MASK_TYPE)==PCIBAR_TYPE_IO)
 399     {
 400         *msg->storage &= PCIBAR_MASK_IO;
 401     }
 402     else
 403     {
 404         *msg->storage &= PCIBAR_MASK_MEM;
 405     }
 406 }
 407
 408 static const void dispatch_type(OOP_Class *cl, OOP_Object *o, struct pRoot_Get *msg)
 409 {
 410     ULONG idx,id;
 411     tDeviceData *dev = (tDeviceData *)OOP_INST_DATA(cl,o);
 412
 413     idx = msg->attrID - HiddPCIDeviceAttrBase;
 414     id = 0;
 415
 416     switch(idx)
 417     {
 418         case aoHidd_PCIDevice_Type0:    id = 0;     break;
 419         case aoHidd_PCIDevice_Type1:    id = 1;     break;
 420         case aoHidd_PCIDevice_Type2:    id = 2;     break;
 421         case aoHidd_PCIDevice_Type3:    id = 3;     break;
 422         case aoHidd_PCIDevice_Type4:    id = 4;     break;
 423         case aoHidd_PCIDevice_Type5:    id = 5;     break;
 424     }
 425
 426     /* Do not allow reading of more than two base addresses in case of PCI-PCI bridges */
 427     if (dev->isBridge && id >= 2) { *msg->storage = 0; return; }
 428
 429     *msg->storage = (IPTR)dev->BaseReg[id].addr;
 430     if ((dev->BaseReg[id].addr & PCIBAR_MASK_TYPE)==PCIBAR_TYPE_IO)
 431     {
 432         *msg->storage &= ~PCIBAR_MASK_IO;
 433     }
 434     else
 435     {
 436         *msg->storage &= ~PCIBAR_MASK_MEM;
 437     }
 438 }
 439
 440 static const void dispatch_size(OOP_Class *cl, OOP_Object *o, struct pRoot_Get *msg)
 441 {
 442     ULONG idx,id;
 443     tDeviceData *dev = (tDeviceData *)OOP_INST_DATA(cl,o);
 444
 445     idx = msg->attrID - HiddPCIDeviceAttrBase;
 446     id = 0;
 447
 448     switch(idx)
 449     {
 450         case aoHidd_PCIDevice_Size0:    id = 0;     break;
 451         case aoHidd_PCIDevice_Size1:    id = 1;     break;
 452         case aoHidd_PCIDevice_Size2:    id = 2;     break;
 453         case aoHidd_PCIDevice_Size3:    id = 3;     break;
 454         case aoHidd_PCIDevice_Size4:    id = 4;     break;
 455         case aoHidd_PCIDevice_Size5:    id = 5;     break;
 456     }
 457
 458     /* Do not allow reading of more than two base addresses in case of PCI-PCI bridges */
 459     if (dev->isBridge && id >= 2) { *msg->storage = 0; return;}
 460
 461     *msg->storage = (IPTR)dev->BaseReg[id].size;
 462 }
 463
 464 static const void dispatch_pci2pcibridge(OOP_Class *cl, OOP_Object *o, struct pRoot_Get *msg)
 465 {
 466     ULONG idx;
 467     tDeviceData *dev = (tDeviceData *)OOP_INST_DATA(cl,o);
 468
 469     UWORD control;
 470
 471     /* If device is not a PCI-PCI bridge, do nothing */
 472     if (!dev->isBridge) { *msg->storage = 0; return; }
 473
 474     control = getWord(cl, o, PCIBR_CONTROL);
 475
 476     idx = msg->attrID - HiddPCIDeviceAttrBase;
 477
 478     switch(idx)
 479     {
 480         case aoHidd_PCIDevice_isBridge:
 481             *msg->storage = dev->isBridge;
 482             break;
 483
 484         case aoHidd_PCIDevice_SubBus:
 485             *msg->storage = dev->subbus;
 486             break;
 487
 488         case aoHidd_PCIDevice_MemoryBase:
 489             *msg->storage = getWord(cl, o, PCIBR_MEMBASE) << 16;
 490             break;
 491
 492         case aoHidd_PCIDevice_MemoryLimit:
 493             *msg->storage = getWord(cl, o, PCIBR_MEMLIMIT) << 16;
 494             break;
 495
 496         case aoHidd_PCIDevice_PrefetchableBase:
 497             *msg->storage = getWord(cl, o, PCIBR_PREFETCHBASE) << 16;
 498             break;
 499
 500         case aoHidd_PCIDevice_PrefetchableLimit:
 501             *msg->storage = getWord(cl, o, PCIBR_PREFETCHLIMIT) << 16;
 502             break;
 503
 504         case aoHidd_PCIDevice_IOBase:
 505             *msg->storage = getByte(cl, o, PCIBR_IOBASE) << 8;
 506             break;
 507
 508         case aoHidd_PCIDevice_IOLimit:
 509             *msg->storage = getByte(cl, o, PCIBR_IOLIMIT) << 8;
 510             break;
 511
 512         case aoHidd_PCIDevice_ISAEnable:
 513             *msg->storage = (control & PCICTRLF_ISAENABLE) == PCICTRLF_ISAENABLE;
 514             break;
 515
 516         case aoHidd_PCIDevice_VGAEnable:
 517             *msg->storage = (control & PCICTRLF_VGAENABLE) == PCICTRLF_VGAENABLE;
 518             break;
 519     }
 520 }
 521
 522 const static void (*Dispatcher[num_Hidd_PCIDevice_Attrs])(OOP_Class *, OOP_Object *, struct pRoot_Get *) __attribute__((section(".rodata"))) =
 523 {
 524     [aoHidd_PCIDevice_Driver]       = dispatch_generic,
 525     [aoHidd_PCIDevice_Bus]          = dispatch_generic,
 526     [aoHidd_PCIDevice_Dev]          = dispatch_generic,
 527     [aoHidd_PCIDevice_Sub]          = dispatch_generic,
 528     [aoHidd_PCIDevice_VendorID]     = dispatch_generic,
 529     [aoHidd_PCIDevice_ProductID]    = dispatch_generic,
 530     [aoHidd_PCIDevice_RevisionID]   = dispatch_generic,
 531     [aoHidd_PCIDevice_Interface]    = dispatch_generic,
 532     [aoHidd_PCIDevice_Class]        = dispatch_generic,
 533     [aoHidd_PCIDevice_SubClass]     = dispatch_generic,
 534     [aoHidd_PCIDevice_SubsystemVendorID] = dispatch_generic,
 535     [aoHidd_PCIDevice_SubsystemID]  = dispatch_generic,
 536     [aoHidd_PCIDevice_INTLine]      = dispatch_generic,
 537     [aoHidd_PCIDevice_IRQLine]      = dispatch_generic,
 538     [aoHidd_PCIDevice_RomBase]      = dispatch_generic,
 539     [aoHidd_PCIDevice_RomSize]      = dispatch_generic,
 540     [aoHidd_PCIDevice_Base0]        = dispatch_base,
 541     [aoHidd_PCIDevice_Base1]        = dispatch_base,
 542     [aoHidd_PCIDevice_Base2]        = dispatch_base,
 543     [aoHidd_PCIDevice_Base3]        = dispatch_base,
 544     [aoHidd_PCIDevice_Base4]        = dispatch_base,
 545     [aoHidd_PCIDevice_Base5]        = dispatch_base,
 546     [aoHidd_PCIDevice_Size0]        = dispatch_size,
 547     [aoHidd_PCIDevice_Size1]        = dispatch_size,
 548     [aoHidd_PCIDevice_Size2]        = dispatch_size,
 549     [aoHidd_PCIDevice_Size3]        = dispatch_size,
 550     [aoHidd_PCIDevice_Size4]        = dispatch_size,
 551     [aoHidd_PCIDevice_Size5]        = dispatch_size,
 552     [aoHidd_PCIDevice_Type0]        = dispatch_type,
 553     [aoHidd_PCIDevice_Type1]        = dispatch_type,
 554     [aoHidd_PCIDevice_Type2]        = dispatch_type,
 555     [aoHidd_PCIDevice_Type3]        = dispatch_type,
 556     [aoHidd_PCIDevice_Type4]        = dispatch_type,
 557     [aoHidd_PCIDevice_Type5]        = dispatch_type,
 558
 559     /* Bridge attributes */
 560     [aoHidd_PCIDevice_isBridge]     = dispatch_pci2pcibridge,
 561     [aoHidd_PCIDevice_SubBus]       = dispatch_pci2pcibridge,
 562     [aoHidd_PCIDevice_MemoryBase]   = dispatch_pci2pcibridge,
 563     [aoHidd_PCIDevice_MemoryLimit]  = dispatch_pci2pcibridge,
 564     [aoHidd_PCIDevice_PrefetchableBase] = dispatch_pci2pcibridge,
 565     [aoHidd_PCIDevice_PrefetchableLimit] = dispatch_pci2pcibridge,
 566     [aoHidd_PCIDevice_IOBase]       = dispatch_pci2pcibridge,
 567     [aoHidd_PCIDevice_IOLimit]      = dispatch_pci2pcibridge,
 568     [aoHidd_PCIDevice_ISAEnable]    = dispatch_pci2pcibridge,
 569     [aoHidd_PCIDevice_VGAEnable]    = dispatch_pci2pcibridge,
 570
 571 };
 572
 573 void PCIDev__Root__Get(OOP_Class *cl, OOP_Object *o, struct pRoot_Get *msg)
 574 {
 575     ULONG idx;
 576     tDeviceData *dev = (tDeviceData *)OOP_INST_DATA(cl,o);
 577
 578     if (IS_PCIDEV_ATTR(msg->attrID, idx))
 579     {
 580         if (Dispatcher[idx] != NULL)
 581             Dispatcher[idx](cl, o, msg);
 582         else switch(idx)
 583         {
 584             case aoHidd_PCIDevice_isMEM:
 585                 *msg->storage = (
 586                     (getWord(cl, o, PCICS_COMMAND) &
 587                         PCICMF_MEMDECODE)
 588                     == PCICMF_MEMDECODE);
 589                 break;
 590
 591             case aoHidd_PCIDevice_isIO:
 592                 *msg->storage = (
 593                     (getWord(cl, o, PCICS_COMMAND) &
 594                         PCICMF_IODECODE)
 595                     == PCICMF_IODECODE);
 596                 break;
 597
 598             case aoHidd_PCIDevice_isMaster:
 599                 *msg->storage = (
 600                     (getWord(cl, o, PCICS_COMMAND) &
 601                         PCICMF_BUSMASTER)
 602                     == PCICMF_BUSMASTER);
 603                 break;
 604
 605             case aoHidd_PCIDevice_paletteSnoop:
 606                 *msg->storage = (
 607                     (getWord(cl, o, PCICS_COMMAND) &
 608                         PCICMF_VGASNOOP)
 609                     == PCICMF_VGASNOOP);
 610                 break;
 611
 612             case aoHidd_PCIDevice_is66MHz:
 613                 *msg->storage = (
 614                     (getWord(cl, o, PCICS_STATUS) &
 615                         PCISTF_66MHZ)
 616                     == PCISTF_66MHZ);
 617                 break;
 618
 619             case aoHidd_PCIDevice_ClassDesc:
 620                 *msg->storage = (IPTR)dev->strClass;
 621                 break;
 622
 623             case aoHidd_PCIDevice_SubClassDesc:
 624                 *msg->storage = (IPTR)dev->strSubClass;
 625                 break;
 626
 627             case aoHidd_PCIDevice_InterfaceDesc:
 628                 *msg->storage = (IPTR)dev->strInterface;
 629                 break;
 630
 631             case aoHidd_PCIDevice_IRQStatus:
 632                 *msg->storage = (
 633                     (getWord(cl, o, PCICS_STATUS) &
 634                         PCISTF_INTERRUPT_STATUS)
 635                     == PCISTF_INTERRUPT_STATUS);
 636                 break;
 637
 638             case aoHidd_PCIDevice_CapabilitiesPresent:
 639                 *msg->storage = (
 640                     (getWord(cl, o, PCICS_STATUS) &
 641                         PCISTF_CAPABILITIES)
 642                     == PCISTF_CAPABILITIES);
 643                 break;
 644
 645             default:
 646                 OOP_DoSuperMethod(cl, o, (OOP_Msg) msg);
 647                 break;
 648         }
 649     }
 650     else
 651     {
 652         OOP_DoSuperMethod(cl, o, (OOP_Msg) msg);
 653     }
 654 }
 655
 656 void PCIDev__Root__Set(OOP_Class *cl, OOP_Object *o, struct pRoot_Set *msg)
 657 {
 658     ULONG idx;
 659     tDeviceData *dev = (tDeviceData *)OOP_INST_DATA(cl,o);
 660     struct TagItem *tags, *tag;
 661
 662     tags = msg->attrList;
 663
 664     while ((tag = NextTagItem(&tags)))
 665     {
 666         if (IS_PCIDEV_ATTR(tag->ti_Tag, idx))
 667         {
 668             switch(idx)
 669             {
 670                 case aoHidd_PCIDevice_Base0:
 671                     setLong(cl, o, PCICS_BAR0, tag->ti_Data);
 672                     dev->BaseReg[0].addr = getLong(cl, o, PCICS_BAR0);
 673                     break;
 674
 675                 case aoHidd_PCIDevice_Base1:
 676                     setLong(cl, o, PCICS_BAR1, tag->ti_Data);
 677                     dev->BaseReg[1].addr = getLong(cl, o, PCICS_BAR1);
 678                     break;
 679
 680                 case aoHidd_PCIDevice_Base2:
 681                     if (!dev->isBridge)
 682                     {
 683                         setLong(cl, o, PCICS_BAR2, tag->ti_Data);
 684                         dev->BaseReg[2].addr = getLong(cl, o, PCICS_BAR2);
 685                     }
 686                     break;
 687
 688                 case aoHidd_PCIDevice_Base3:
 689                     if (!dev->isBridge)
 690                     {
 691                         setLong(cl, o, PCICS_BAR3, tag->ti_Data);
 692                         dev->BaseReg[3].addr = getLong(cl, o, PCICS_BAR3);
 693                     }
 694                     break;
 695
 696                 case aoHidd_PCIDevice_Base4:
 697                     if (!dev->isBridge)
 698                     {
 699                         setLong(cl, o, PCICS_BAR4, tag->ti_Data);
 700                         dev->BaseReg[4].addr = getLong(cl, o, PCICS_BAR4);
 701                     }
 702                     break;
 703
 704                 case aoHidd_PCIDevice_Base5:
 705                     if (!dev->isBridge)
 706                     {
 707                         setLong(cl, o, PCICS_BAR5, tag->ti_Data);
 708                         dev->BaseReg[5].addr = getLong(cl, o, PCICS_BAR5);
 709                     }
 710                     break;
 711
 712                 case aoHidd_PCIDevice_RomBase:
 713                     setLong(cl, o, PCICS_EXPROM_BASE, tag->ti_Data);
 714                     dev->RomBase = getLong(cl, o, PCICS_EXPROM_BASE);
 715                     break;
 716
 717                 case aoHidd_PCIDevice_MemoryBase:
 718                     if (dev->isBridge) setWord(cl, o, PCIBR_MEMBASE, tag->ti_Data >> 16); break;
 719
 720                 case aoHidd_PCIDevice_MemoryLimit:
 721                     if (dev->isBridge) setWord(cl, o, PCIBR_MEMLIMIT, tag->ti_Data >> 16); break;
 722
 723                 case aoHidd_PCIDevice_PrefetchableBase:
 724                     if (dev->isBridge) setWord(cl, o, PCIBR_PREFETCHBASE, tag->ti_Data >> 16); break;
 725
 726                 case aoHidd_PCIDevice_PrefetchableLimit:
 727                     if (dev->isBridge) setWord(cl, o, PCIBR_PREFETCHLIMIT, tag->ti_Data >> 16); break;
 728
 729                 case aoHidd_PCIDevice_IOBase:
 730                     if (dev->isBridge) setByte(cl, o, PCIBR_IOBASE, tag->ti_Data >> 8); break;
 731
 732                 case aoHidd_PCIDevice_IOLimit:
 733                     if (dev->isBridge) setByte(cl, o, PCIBR_IOLIMIT, tag->ti_Data >> 8); break;
 734
 735                 case aoHidd_PCIDevice_isIO:
 736                     {
 737                         UWORD command = getWord(cl, o, PCICS_COMMAND) & ~PCICMF_IODECODE;
 738                         if (tag->ti_Data)
 739                             command |= PCICMF_IODECODE;
 740                         setWord(cl, o, PCICS_COMMAND, command);
 741                     }
 742                     break;
 743
 744                 case aoHidd_PCIDevice_isMEM:
 745                     {
 746                         UWORD command = getWord(cl, o, PCICS_COMMAND) & ~PCICMF_MEMDECODE;
 747                         if (tag->ti_Data)
 748                             command |= PCICMF_MEMDECODE;
 749                         setWord(cl, o, PCICS_COMMAND, command);
 750                     }
 751                     break;
 752
 753                 case aoHidd_PCIDevice_isMaster:
 754                     {
 755                         UWORD command = getWord(cl, o, PCICS_COMMAND) & ~PCICMF_BUSMASTER;
 756                         if (tag->ti_Data)
 757                             command |= PCICMF_BUSMASTER;
 758                         setWord(cl, o, PCICS_COMMAND, command);
 759                     }
 760                     break;
 761
 762                 case aoHidd_PCIDevice_paletteSnoop:
 763                     {
 764                         UWORD command = getWord(cl, o, PCICS_COMMAND) & ~PCICMF_VGASNOOP;
 765                         if (tag->ti_Data)
 766                             command |= PCICMF_VGASNOOP;
 767                         setWord(cl, o, PCICS_COMMAND, command);
 768                     }
 769                     break;
 770
 771                 case aoHidd_PCIDevice_ISAEnable:
 772                     if (dev->isBridge)
 773                     {
 774                         UWORD control = getWord(cl, o, PCIBR_CONTROL) & ~PCICTRLF_ISAENABLE;
 775                         if (tag->ti_Data)
 776                             control |= PCICTRLF_ISAENABLE;
 777                         setWord(cl, o, PCIBR_CONTROL, control);
 778                     }
 779                     break;
 780
 781                 case aoHidd_PCIDevice_VGAEnable:
 782                     if (dev->isBridge)
 783                     {
 784                         UWORD control = getWord(cl, o, PCIBR_CONTROL) & ~PCICTRLF_VGAENABLE;
 785                         if (tag->ti_Data)
 786                             control |= PCICTRLF_VGAENABLE;
 787                         setWord(cl, o, PCIBR_CONTROL, control);
 788                     }
 789                     break;
 790
 791                 default:
 792                     bug("[PCIDevice] Trying to set nonsettable attribute %d!\n", idx);
 793                     break;
 794             }
 795         }
 796     }
 797 }