workbench/devs/AHI/Drivers/SB128/pci_aros.c

   1 #define __OOP_NOATTRBASES__
   2
   3 //#include <config.h>
   4
   5 #include <utility/hooks.h>
   6 #include <exec/interrupts.h>
   7 #include <asm/io.h>
   8 #include <oop/oop.h>
   9 #include <hidd/pci.h>
  10 #include <hidd/irq.h>
  11 #include <aros/asmcall.h>
  12
  13 #include <proto/oop.h>
  14
  15 #include "DriverData.h"
  16 #include "pci_wrapper.h"
  17
  18 #include <aros/debug.h>
  19 #define KPrintF kprintf
  20
  21 struct Library *OOPBase;
  22
  23
  24 static OOP_AttrBase __IHidd_PCIDev;
  25 static OOP_Object *pciobj, *irqobj;
  26
  27 static OOP_MethodID mid_RB;
  28 static OOP_MethodID mid_RW;
  29 static OOP_MethodID mid_RL;
  30
  31 static OOP_MethodID mid_WB;
  32 static OOP_MethodID mid_WW;
  33 static OOP_MethodID mid_WL;
  34
  35 static HIDDT_IRQ_Handler inthandler;
  36 static BOOL inthandler_added;
  37
  38 BOOL ahi_pci_init(struct DriverBase* AHIsubBase)
  39 {
  40     OOPBase = OpenLibrary(AROSOOP_NAME, 0);
  41     if (OOPBase)
  42     {
  43         __IHidd_PCIDev = OOP_ObtainAttrBase(IID_Hidd_PCIDevice);
  44         if (__IHidd_PCIDev)
  45         {
  46             pciobj = OOP_NewObject(NULL, CLID_Hidd_PCI, NULL);
  47             irqobj = OOP_NewObject(NULL, CLID_Hidd_IRQ, NULL);
  48
  49             if (pciobj && irqobj)
  50             {
  51                 mid_RB = OOP_GetMethodID(IID_Hidd_PCIDevice, moHidd_PCIDevice_ReadConfigByte);
  52                 mid_RW = OOP_GetMethodID(IID_Hidd_PCIDevice, moHidd_PCIDevice_ReadConfigWord);
  53                 mid_RL = OOP_GetMethodID(IID_Hidd_PCIDevice, moHidd_PCIDevice_ReadConfigLong);
  54
  55                 mid_WB = OOP_GetMethodID(IID_Hidd_PCIDevice, moHidd_PCIDevice_WriteConfigByte);
  56                 mid_WW = OOP_GetMethodID(IID_Hidd_PCIDevice, moHidd_PCIDevice_WriteConfigWord);
  57                 mid_WL = OOP_GetMethodID(IID_Hidd_PCIDevice, moHidd_PCIDevice_WriteConfigLong);
  58
  59                 return TRUE;
  60             }
  61         }
  62     }
  63
  64     return FALSE;
  65 }
  66
  67 void ahi_pci_exit(void)
  68 {
  69     if (irqobj)
  70         OOP_DisposeObject(irqobj);
  71     if (pciobj)
  72         OOP_DisposeObject(pciobj);
  73     if (__IHidd_PCIDev)
  74         OOP_ReleaseAttrBase(IID_Hidd_PCIDevice);
  75     if (OOPBase)
  76         CloseLibrary(OOPBase);
  77 }
  78
  79 struct enum_data
  80 {
  81     OOP_Object *prev_dev;
  82     OOP_Object *found_dev;
  83 };
  84
  85 static AROS_UFH3(void, Enumerator,
  86                  AROS_UFHA(struct Hook *,    hook,   A0),
  87                  AROS_UFHA(OOP_Object *,     device, A2),
  88                  AROS_UFHA(APTR,             msg,    A1))
  89 {
  90     AROS_USERFUNC_INIT
  91
  92     struct enum_data *ed = (struct enum_data *)hook->h_Data;
  93
  94     if ((ed->found_dev == 0) && (device != ed->prev_dev))
  95     {
  96         ed->found_dev = device;
  97     }
  98
  99     AROS_USERFUNC_EXIT
 100 }
 101
 102
 103 APTR ahi_pci_find_device(ULONG vendorid, ULONG deviceid, APTR dev)
 104 {
 105     struct enum_data ed;
 106
 107     struct Hook FindHook =
 108     {
 109       h_Entry:    (HOOKFUNC)Enumerator,
 110       h_Data:       &ed,
 111     };
 112
 113     struct TagItem Reqs[] =
 114     {
 115 #if 0
 116       { tHidd_PCI_Class         , 0x04      }, /* Multimedia */
 117       { tHidd_PCI_SubClass      , 0x01      }, /* Audio */
 118 #endif
 119       { tHidd_PCI_VendorID      , vendorid  },
 120       { tHidd_PCI_ProductID     , deviceid  },
 121       { TAG_DONE                , 0         },
 122     };
 123
 124     struct pHidd_PCI_EnumDevices enummsg =
 125     {
 126       mID:              OOP_GetMethodID(CLID_Hidd_PCI, moHidd_PCI_EnumDevices),
 127       callback: &FindHook,
 128       requirements:     (struct TagItem *)&Reqs,
 129     }, *msg = &enummsg;
 130
 131     ed.prev_dev = (OOP_Object *)dev;
 132     ed.found_dev = 0;
 133
 134     OOP_DoMethod(pciobj, (OOP_Msg)msg);
 135
 136     //KPrintF("ahi_pci_find_device: found_dev = %lx\n", ed.found_dev);
 137
 138     return (APTR)ed.found_dev;
 139 }
 140
 141 ULONG pci_inl(ULONG addr, struct SB128_DATA *card)
 142 {
 143     return (*((volatile ULONG *)(card->iobase + addr)));
 144 }
 145
 146 UWORD pci_inw(ULONG addr, struct SB128_DATA *card)
 147 {
 148     return (*((volatile UWORD *)(card->iobase + addr)));
 149 }
 150
 151 UBYTE pci_inb(ULONG addr, struct SB128_DATA *card)
 152 {
 153     return (*((volatile UBYTE *)(card->iobase + addr)));
 154 }
 155
 156 void pci_outl(ULONG value, ULONG addr, struct SB128_DATA *card)
 157 {
 158     *((volatile ULONG *)(card->iobase + addr)) = (value);
 159     pci_inl(addr, card);
 160 }
 161
 162 void pci_outw(UWORD value, ULONG addr, struct SB128_DATA *card)
 163 {
 164     *((volatile UWORD *)(card->iobase + addr)) = (value);
 165     pci_inw(addr, card);
 166 }
 167
 168 void pci_outb(UBYTE value, ULONG addr, struct SB128_DATA *card)
 169 {
 170     *((volatile UBYTE *)(card->iobase + addr)) = (value);
 171     pci_inb(addr, card);
 172 }
 173
 174 void outb_setbits(UBYTE value, ULONG addr, struct SB128_DATA *card)
 175 {
 176     UBYTE data = pci_inb(addr, card);
 177     data |= value;
 178
 179     pci_outb(data, addr, card);
 180 }
 181
 182
 183 void outb_clearbits(UBYTE value, ULONG addr, struct SB128_DATA *card)
 184 {
 185     UBYTE data = pci_inb(addr, card);
 186     data &= ~value;
 187
 188     pci_outb(data, addr, card);
 189 }
 190
 191
 192 void outw_setbits(UWORD value, ULONG addr, struct SB128_DATA *card)
 193 {
 194     UWORD data = pci_inw(addr, card);
 195     data |= value;
 196
 197     pci_outw(data, addr, card);
 198 }
 199
 200
 201 void outw_clearbits(UWORD value, ULONG addr, struct SB128_DATA *card)
 202 {
 203     UWORD data = pci_inw(addr, card);
 204     data &= ~value;
 205
 206     pci_outw(data, addr, card);
 207 }
 208
 209
 210 void outl_setbits(ULONG value, ULONG addr, struct SB128_DATA *card)
 211 {
 212     ULONG data = pci_inl(addr, card);
 213     data |= value;
 214
 215     pci_outl(data, addr, card);
 216 }
 217
 218
 219 void outl_clearbits(ULONG value, ULONG addr, struct SB128_DATA *card)
 220 {
 221     ULONG data = pci_inl(addr, card);
 222     data &= ~value;
 223
 224     pci_outl(data, addr, card);
 225 }
 226
 227
 228 ULONG inl_config(UBYTE reg, APTR dev)
 229 {
 230     struct pHidd_PCIDevice_ReadConfigLong  msg;
 231
 232     msg.mID = mid_RL;
 233     msg.reg = reg;
 234
 235     return OOP_DoMethod((OOP_Object *)dev, (OOP_Msg)&msg);
 236 }
 237
 238 UWORD inw_config(UBYTE reg, APTR dev)
 239 {
 240     struct pHidd_PCIDevice_ReadConfigWord  msg;
 241
 242     msg.mID = mid_RW;
 243     msg.reg = reg;
 244
 245     return OOP_DoMethod((OOP_Object *)dev, (OOP_Msg)&msg);
 246 }
 247
 248 UBYTE inb_config(UBYTE reg, APTR dev)
 249 {
 250     struct pHidd_PCIDevice_ReadConfigByte  msg;
 251
 252     msg.mID = mid_RB;
 253     msg.reg = reg;
 254
 255     return OOP_DoMethod(dev, (OOP_Msg)&msg);
 256 }
 257
 258 void outl_config(UBYTE reg, ULONG val, APTR dev)
 259 {
 260     struct pHidd_PCIDevice_WriteConfigLong msg;
 261
 262     msg.mID = mid_WL;
 263     msg.reg = reg;
 264     msg.val = val;
 265
 266     OOP_DoMethod((OOP_Object *)dev, (OOP_Msg)&msg);
 267 }
 268
 269 void outw_config(UBYTE reg, UWORD val, APTR dev)
 270 {
 271     struct pHidd_PCIDevice_WriteConfigWord msg;
 272
 273     msg.mID = mid_WW;
 274     msg.reg = reg;
 275     msg.val = val;
 276
 277     OOP_DoMethod((OOP_Object *)dev, (OOP_Msg)&msg);
 278 }
 279
 280 void outb_config(UBYTE reg, UBYTE val, APTR dev)
 281 {
 282     struct pHidd_PCIDevice_WriteConfigByte msg;
 283
 284     msg.mID = mid_WB;
 285     msg.reg = reg;
 286     msg.val = val;
 287
 288     OOP_DoMethod((OOP_Object *)dev, (OOP_Msg)&msg);
 289 }
 290
 291 ULONG ahi_pci_get_irq(APTR dev)
 292 {
 293     IPTR val;
 294
 295     OOP_GetAttr((OOP_Object *)dev, aHidd_PCIDevice_INTLine, &val);
 296
 297     return (ULONG)val;
 298 }
 299
 300 static void interrupt_code(HIDDT_IRQ_Handler *irq, HIDDT_IRQ_HwInfo *hw)
 301 {
 302     struct Interrupt *i = (struct Interrupt *)irq->h_Data;
 303
 304     AROS_UFC3(void, i->is_Code,
 305         AROS_UFCA(APTR, i->is_Data, A1),
 306         AROS_UFCA(APTR, i->is_Code, A5),
 307         AROS_UFCA(struct ExecBase *, SysBase, A6));
 308 }
 309
 310
 311 BOOL ahi_pci_add_intserver(struct Interrupt *i, APTR dev)
 312 {
 313     struct pHidd_IRQ_AddHandler __msg__, *msg = &__msg__;
 314     IPTR val;
 315
 316     OOP_GetAttr((OOP_Object *)dev, aHidd_PCIDevice_INTLine, &val);
 317
 318     inthandler.h_Node.ln_Pri = 1;
 319     inthandler.h_Node.ln_Name = "HD Audio IRQ";
 320     inthandler.h_Code = interrupt_code;
 321     inthandler.h_Data = i;
 322
 323     msg->mID = OOP_GetMethodID(CLID_Hidd_IRQ, moHidd_IRQ_AddHandler);
 324     msg->handlerinfo = &inthandler;
 325     msg->id = val;
 326
 327     OOP_DoMethod(irqobj, (OOP_Msg)msg);
 328
 329     inthandler_added = TRUE;
 330
 331     return TRUE;
 332 }
 333
 334 void ahi_pci_rem_intserver(struct Interrupt *i, APTR dev)
 335 {
 336     if (inthandler_added)
 337     {
 338         struct pHidd_IRQ_RemHandler __msg__ =
 339         {
 340             mID:                    OOP_GetMethodID(CLID_Hidd_IRQ, moHidd_IRQ_RemHandler),
 341             handlerinfo:            &inthandler,
 342         }, *msg = &__msg__;
 343
 344         OOP_DoMethod(irqobj, (OOP_Msg)msg);
 345
 346         inthandler_added = FALSE;
 347     }
 348
 349     KPrintF("ahi_pci_rem_intserver\n");
 350 }
 351
 352
 353 APTR ahi_pci_get_base_address(WORD which, APTR dev)
 354 {
 355     OOP_AttrID attr = 0;
 356     IPTR val = 0;
 357
 358     switch(which)
 359     {
 360         case 0:
 361           attr = aHidd_PCIDevice_Base0;
 362           break;
 363
 364         case 1:
 365           attr = aHidd_PCIDevice_Base1;
 366           break;
 367
 368         case 2:
 369           attr = aHidd_PCIDevice_Base2;
 370           break;
 371
 372         case 3:
 373           attr = aHidd_PCIDevice_Base3;
 374           break;
 375
 376         case 4:
 377           attr = aHidd_PCIDevice_Base4;
 378           break;
 379
 380         case 5:
 381           attr = aHidd_PCIDevice_Base5;
 382           break;
 383
 384         default:
 385           return 0;
 386     }
 387
 388     OOP_GetAttr((OOP_Object *)dev, attr, &val);
 389
 390     //KPrintF("ahi_pci_get_base_address. Result %lx\n", val);
 391
 392     return (APTR)val;
 393 }
 394
 395 ULONG ahi_pci_get_base_size(WORD which, APTR dev)
 396 {
 397     OOP_AttrID attr = 0;
 398     IPTR val = 0;
 399
 400     switch(which)
 401     {
 402         case 0:
 403           attr = aHidd_PCIDevice_Size0;
 404           break;
 405
 406         case 1:
 407           attr = aHidd_PCIDevice_Size1;
 408           break;
 409
 410         case 2:
 411           attr = aHidd_PCIDevice_Size2;
 412           break;
 413
 414         case 3:
 415           attr = aHidd_PCIDevice_Size3;
 416           break;
 417
 418         case 4:
 419           attr = aHidd_PCIDevice_Size4;
 420           break;
 421
 422         case 5:
 423           attr = aHidd_PCIDevice_Size5;
 424           break;
 425
 426         default:
 427           return 0;
 428     }
 429
 430     OOP_GetAttr((OOP_Object *)dev, attr, &val);
 431
 432     //KPrintF("ahi_pci_get_base_size. Result %lx\n", val);
 433
 434     return (ULONG)val;
 435
 436 }
 437
 438
 439
 440 ULONG ahi_pci_get_type(WORD which, APTR dev)
 441 {
 442   OOP_AttrID attr = 0;
 443   IPTR val = 0;
 444
 445   switch(which)
 446   {
 447     case 0:
 448       attr = aHidd_PCIDevice_Type0;
 449       break;
 450
 451     case 1:
 452       attr = aHidd_PCIDevice_Type1;
 453       break;
 454
 455     case 2:
 456       attr = aHidd_PCIDevice_Type2;
 457       break;
 458
 459     case 3:
 460       attr = aHidd_PCIDevice_Type3;
 461       break;
 462
 463     case 4:
 464       attr = aHidd_PCIDevice_Type4;
 465       break;
 466
 467     case 5:
 468       attr = aHidd_PCIDevice_Type5;
 469       break;
 470
 471     default:
 472       return 0;
 473   }
 474
 475   OOP_GetAttr((OOP_Object *)dev, attr, &val);
 476
 477   //KPrintF("ahi_pci_get_type. Result %lx\n", val);
 478
 479   return (ULONG) val;
 480 }