workbench/devs/AHI/Drivers/CMI8738/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 CMI8738_DATA *card)
 142 {
 143     return (*((ULONG *)(card->iobase + addr)));
 144 }
 145
 146 UWORD pci_inw(ULONG addr, struct CMI8738_DATA *card)
 147 {
 148     return (*((UWORD *)(card->iobase + addr)));
 149 }
 150
 151 UBYTE pci_inb(ULONG addr, struct CMI8738_DATA *card)
 152 {
 153     return (*((UBYTE *)(card->iobase + addr)));
 154 }
 155
 156 void pci_outl(ULONG value, ULONG addr, struct CMI8738_DATA *card)
 157 {
 158     *((ULONG *)(card->iobase + addr)) = (value);
 159 }
 160
 161 void pci_outw(UWORD value, ULONG addr, struct CMI8738_DATA *card)
 162 {
 163     *((UWORD *)(card->iobase + addr)) = (value);
 164 }
 165
 166 void pci_outb(UBYTE value, ULONG addr, struct CMI8738_DATA *card)
 167 {
 168     *((UBYTE *)(card->iobase + addr)) = (value);
 169 }
 170
 171 void outb_setbits(UBYTE value, ULONG addr, struct CMI8738_DATA *card)
 172 {
 173     UBYTE data = pci_inb(addr, card);
 174     data |= value;
 175
 176     pci_outb(data, addr, card);
 177 }
 178
 179
 180 void outb_clearbits(UBYTE value, ULONG addr, struct CMI8738_DATA *card)
 181 {
 182     UBYTE data = pci_inb(addr, card);
 183     data &= ~value;
 184
 185     pci_outb(data, addr, card);
 186 }
 187
 188
 189 void outw_setbits(UWORD value, ULONG addr, struct CMI8738_DATA *card)
 190 {
 191     UWORD data = pci_inw(addr, card);
 192     data |= value;
 193
 194     pci_outw(data, addr, card);
 195 }
 196
 197
 198 void outw_clearbits(UWORD value, ULONG addr, struct CMI8738_DATA *card)
 199 {
 200     UWORD data = pci_inw(addr, card);
 201     data &= ~value;
 202
 203     pci_outw(data, addr, card);
 204 }
 205
 206
 207 void outl_setbits(ULONG value, ULONG addr, struct CMI8738_DATA *card)
 208 {
 209     ULONG data = pci_inl(addr, card);
 210     data |= value;
 211
 212     pci_outl(data, addr, card);
 213 }
 214
 215
 216 void outl_clearbits(ULONG value, ULONG addr, struct CMI8738_DATA *card)
 217 {
 218     ULONG data = pci_inl(addr, card);
 219     data &= ~value;
 220
 221     pci_outl(data, addr, card);
 222 }
 223
 224
 225 ULONG inl_config(UBYTE reg, APTR dev)
 226 {
 227     struct pHidd_PCIDevice_ReadConfigLong  msg;
 228
 229     msg.mID = mid_RL;
 230     msg.reg = reg;
 231
 232     return OOP_DoMethod((OOP_Object *)dev, (OOP_Msg)&msg);
 233 }
 234
 235 UWORD inw_config(UBYTE reg, APTR dev)
 236 {
 237     struct pHidd_PCIDevice_ReadConfigWord  msg;
 238
 239     msg.mID = mid_RW;
 240     msg.reg = reg;
 241
 242     return OOP_DoMethod((OOP_Object *)dev, (OOP_Msg)&msg);
 243 }
 244
 245 UBYTE inb_config(UBYTE reg, APTR dev)
 246 {
 247     struct pHidd_PCIDevice_ReadConfigByte  msg;
 248
 249     msg.mID = mid_RB;
 250     msg.reg = reg;
 251
 252     return OOP_DoMethod(dev, (OOP_Msg)&msg);
 253 }
 254
 255 void outl_config(UBYTE reg, ULONG val, APTR dev)
 256 {
 257     struct pHidd_PCIDevice_WriteConfigLong msg;
 258
 259     msg.mID = mid_WL;
 260     msg.reg = reg;
 261     msg.val = val;
 262
 263     OOP_DoMethod((OOP_Object *)dev, (OOP_Msg)&msg);
 264 }
 265
 266 void outw_config(UBYTE reg, UWORD val, APTR dev)
 267 {
 268     struct pHidd_PCIDevice_WriteConfigWord msg;
 269
 270     msg.mID = mid_WW;
 271     msg.reg = reg;
 272     msg.val = val;
 273
 274     OOP_DoMethod((OOP_Object *)dev, (OOP_Msg)&msg);
 275 }
 276
 277 void outb_config(UBYTE reg, UBYTE val, APTR dev)
 278 {
 279     struct pHidd_PCIDevice_WriteConfigByte msg;
 280
 281     msg.mID = mid_WB;
 282     msg.reg = reg;
 283     msg.val = val;
 284
 285     OOP_DoMethod((OOP_Object *)dev, (OOP_Msg)&msg);
 286 }
 287
 288 ULONG ahi_pci_get_irq(APTR dev)
 289 {
 290     IPTR val;
 291
 292     OOP_GetAttr((OOP_Object *)dev, aHidd_PCIDevice_INTLine, &val);
 293
 294     return (ULONG)val;
 295 }
 296
 297 static void interrupt_code(HIDDT_IRQ_Handler *irq, HIDDT_IRQ_HwInfo *hw)
 298 {
 299     struct Interrupt *i = (struct Interrupt *)irq->h_Data;
 300
 301     AROS_UFC3(void, i->is_Code,
 302         AROS_UFCA(APTR, i->is_Data, A1),
 303         AROS_UFCA(APTR, i->is_Code, A5),
 304         AROS_UFCA(struct ExecBase *, SysBase, A6));
 305 }
 306
 307
 308 BOOL ahi_pci_add_intserver(struct Interrupt *i, APTR dev)
 309 {
 310     struct pHidd_IRQ_AddHandler __msg__, *msg = &__msg__;
 311     IPTR val;
 312
 313     OOP_GetAttr((OOP_Object *)dev, aHidd_PCIDevice_INTLine, &val);
 314
 315     inthandler.h_Node.ln_Pri = 1;
 316     inthandler.h_Node.ln_Name = "HD Audio IRQ";
 317     inthandler.h_Code = interrupt_code;
 318     inthandler.h_Data = i;
 319
 320     msg->mID = OOP_GetMethodID(CLID_Hidd_IRQ, moHidd_IRQ_AddHandler);
 321     msg->handlerinfo = &inthandler;
 322     msg->id = val;
 323
 324     OOP_DoMethod(irqobj, (OOP_Msg)msg);
 325
 326     inthandler_added = TRUE;
 327
 328     return TRUE;
 329 }
 330
 331 void ahi_pci_rem_intserver(struct Interrupt *i, APTR dev)
 332 {
 333     if (inthandler_added)
 334     {
 335         struct pHidd_IRQ_RemHandler __msg__ =
 336         {
 337             mID:                    OOP_GetMethodID(CLID_Hidd_IRQ, moHidd_IRQ_RemHandler),
 338             handlerinfo:            &inthandler,
 339         }, *msg = &__msg__;
 340
 341         OOP_DoMethod(irqobj, (OOP_Msg)msg);
 342
 343         inthandler_added = FALSE;
 344     }
 345
 346     KPrintF("ahi_pci_rem_intserver\n");
 347 }
 348
 349
 350 APTR ahi_pci_get_base_address(WORD which, APTR dev)
 351 {
 352     OOP_AttrID attr = 0;
 353     IPTR val = 0;
 354
 355     switch(which)
 356     {
 357         case 0:
 358           attr = aHidd_PCIDevice_Base0;
 359           break;
 360
 361         case 1:
 362           attr = aHidd_PCIDevice_Base1;
 363           break;
 364
 365         case 2:
 366           attr = aHidd_PCIDevice_Base2;
 367           break;
 368
 369         case 3:
 370           attr = aHidd_PCIDevice_Base3;
 371           break;
 372
 373         case 4:
 374           attr = aHidd_PCIDevice_Base4;
 375           break;
 376
 377         case 5:
 378           attr = aHidd_PCIDevice_Base5;
 379           break;
 380
 381         default:
 382           return 0;
 383     }
 384
 385     OOP_GetAttr((OOP_Object *)dev, attr, &val);
 386
 387     //KPrintF("ahi_pci_get_base_address. Result %lx\n", val);
 388
 389     return (APTR)val;
 390 }
 391
 392 ULONG ahi_pci_get_base_size(WORD which, APTR dev)
 393 {
 394     OOP_AttrID attr = 0;
 395     IPTR val = 0;
 396
 397     switch(which)
 398     {
 399         case 0:
 400           attr = aHidd_PCIDevice_Size0;
 401           break;
 402
 403         case 1:
 404           attr = aHidd_PCIDevice_Size1;
 405           break;
 406
 407         case 2:
 408           attr = aHidd_PCIDevice_Size2;
 409           break;
 410
 411         case 3:
 412           attr = aHidd_PCIDevice_Size3;
 413           break;
 414
 415         case 4:
 416           attr = aHidd_PCIDevice_Size4;
 417           break;
 418
 419         case 5:
 420           attr = aHidd_PCIDevice_Size5;
 421           break;
 422
 423         default:
 424           return 0;
 425     }
 426
 427     OOP_GetAttr((OOP_Object *)dev, attr, &val);
 428
 429     //KPrintF("ahi_pci_get_base_size. Result %lx\n", val);
 430
 431     return (ULONG)val;
 432
 433 }
 434
 435
 436
 437 ULONG ahi_pci_get_type(WORD which, APTR dev)
 438 {
 439   OOP_AttrID attr = 0;
 440   IPTR val = 0;
 441
 442   switch(which)
 443   {
 444     case 0:
 445       attr = aHidd_PCIDevice_Type0;
 446       break;
 447
 448     case 1:
 449       attr = aHidd_PCIDevice_Type1;
 450       break;
 451
 452     case 2:
 453       attr = aHidd_PCIDevice_Type2;
 454       break;
 455
 456     case 3:
 457       attr = aHidd_PCIDevice_Type3;
 458       break;
 459
 460     case 4:
 461       attr = aHidd_PCIDevice_Type4;
 462       break;
 463
 464     case 5:
 465       attr = aHidd_PCIDevice_Type5;
 466       break;
 467
 468     default:
 469       return 0;
 470   }
 471
 472   OOP_GetAttr((OOP_Object *)dev, attr, &val);
 473
 474   //KPrintF("ahi_pci_get_type. Result %lx\n", val);
 475
 476   return (ULONG) val;
 477 }