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

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