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

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