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

   1 /*
   2     Copyright © 2004-2013, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define __OOP_NOATTRBASES__
   7
   8
   9 #include <utility/hooks.h>
  10 #include <exec/interrupts.h>
  11 #include <aros/macros.h>
  12 #include <aros/io.h>
  13 #include <oop/oop.h>
  14 #include <hidd/pci.h>
  15 #include <aros/asmcall.h>
  16
  17 #include <proto/oop.h>
  18
  19 #include "DriverData.h"
  20 #include "pci_wrapper.h"
  21
  22 #include <aros/debug.h>
  23 #define KPrintF DebugPrintF
  24
  25 struct Library *OOPBase;
  26
  27 static OOP_AttrBase __IHidd_PCIDev;
  28 static OOP_Object *pciobj;
  29
  30 static OOP_MethodID mid_RB;
  31 static OOP_MethodID mid_RW;
  32 static OOP_MethodID mid_RL;
  33
  34 static OOP_MethodID mid_WB;
  35 static OOP_MethodID mid_WW;
  36 static OOP_MethodID mid_WL;
  37
  38 static BOOL inthandler_added;
  39
  40 BOOL ahi_pci_init(struct DriverBase* AHIsubBase)
  41 {
  42     OOPBase = OpenLibrary(AROSOOP_NAME, 0);
  43     if (OOPBase)
  44     {
  45         __IHidd_PCIDev = OOP_ObtainAttrBase(IID_Hidd_PCIDevice);
  46         if (__IHidd_PCIDev)
  47         {
  48             pciobj = OOP_NewObject(NULL, CLID_Hidd_PCI, NULL);
  49
  50             if (pciobj)
  51             {
  52                 mid_RB = OOP_GetMethodID(IID_Hidd_PCIDevice, moHidd_PCIDevice_ReadConfigByte);
  53                 mid_RW = OOP_GetMethodID(IID_Hidd_PCIDevice, moHidd_PCIDevice_ReadConfigWord);
  54                 mid_RL = OOP_GetMethodID(IID_Hidd_PCIDevice, moHidd_PCIDevice_ReadConfigLong);
  55
  56                 mid_WB = OOP_GetMethodID(IID_Hidd_PCIDevice, moHidd_PCIDevice_WriteConfigByte);
  57                 mid_WW = OOP_GetMethodID(IID_Hidd_PCIDevice, moHidd_PCIDevice_WriteConfigWord);
  58                 mid_WL = OOP_GetMethodID(IID_Hidd_PCIDevice, moHidd_PCIDevice_WriteConfigLong);
  59
  60                 return TRUE;
  61             }
  62         }
  63     }
  64
  65     return FALSE;
  66 }
  67
  68 void ahi_pci_exit(void)
  69 {
  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 CardData *card)
 141 {
 142     return LONGIN(card->iobase + addr);
 143 }
 144
 145 UWORD pci_inw(ULONG addr, struct CardData *card)
 146 {
 147     return WORDIN(card->iobase + addr);
 148 }
 149
 150 UBYTE pci_inb(ULONG addr, struct CardData *card)
 151 {
 152     return BYTEIN(card->iobase + addr);
 153 }
 154
 155 void pci_outl(ULONG value, ULONG addr, struct CardData *card)
 156 {
 157     LONGOUT(card->iobase + addr, value);
 158 }
 159
 160 void pci_outw(UWORD value, ULONG addr, struct CardData *card)
 161 {
 162     WORDOUT(card->iobase + addr, value);
 163 }
 164
 165 void pci_outb(UBYTE value, ULONG addr, struct CardData *card)
 166 {
 167     BYTEOUT(card->iobase + addr, value);
 168 }
 169
 170 void outb_setbits(UBYTE value, ULONG addr, struct CardData *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 CardData *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 CardData *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 CardData *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 CardData *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 CardData *card)
 216 {
 217     ULONG data = pci_inl(addr, card);
 218     data &= ~value;
 219
 220     pci_outl(data, addr, card);
 221 }
 222
 223
 224 ULONG pci_inl_mt(ULONG addr, struct CardData *card)
 225 {
 226     return LONGIN(card->mtbase + addr);
 227 }
 228
 229 UWORD pci_inw_mt(ULONG addr, struct CardData *card)
 230 {
 231     return WORDIN(card->mtbase + addr);
 232 }
 233
 234 UBYTE pci_inb_mt(ULONG addr, struct CardData *card)
 235 {
 236     return BYTEIN(card->mtbase + addr);
 237 }
 238
 239 void pci_outl_mt(ULONG value, ULONG addr, struct CardData *card)
 240 {
 241     LONGOUT(card->mtbase + addr, value);
 242 }
 243
 244 void pci_outw_mt(UWORD value, ULONG addr, struct CardData *card)
 245 {
 246     WORDOUT(card->mtbase + addr, value);
 247 }
 248
 249 void pci_outb_mt(UBYTE value, ULONG addr, struct CardData *card)
 250 {
 251     BYTEOUT(card->mtbase + addr, value);
 252 }
 253
 254 ULONG inl_config(UBYTE reg, APTR dev)
 255 {
 256     struct pHidd_PCIDevice_ReadConfigLong  msg;
 257
 258     msg.mID = mid_RL;
 259     msg.reg = reg;
 260
 261     return OOP_DoMethod((OOP_Object *)dev, (OOP_Msg)&msg);
 262 }
 263
 264 UWORD inw_config(UBYTE reg, APTR dev)
 265 {
 266     struct pHidd_PCIDevice_ReadConfigWord  msg;
 267
 268     msg.mID = mid_RW;
 269     msg.reg = reg;
 270
 271     return OOP_DoMethod((OOP_Object *)dev, (OOP_Msg)&msg);
 272 }
 273
 274 UBYTE inb_config(UBYTE reg, APTR dev)
 275 {
 276     struct pHidd_PCIDevice_ReadConfigByte  msg;
 277
 278     msg.mID = mid_RB;
 279     msg.reg = reg;
 280
 281     return OOP_DoMethod(dev, (OOP_Msg)&msg);
 282 }
 283
 284 void outl_config(UBYTE reg, ULONG val, APTR dev)
 285 {
 286     struct pHidd_PCIDevice_WriteConfigLong msg;
 287
 288     msg.mID = mid_WL;
 289     msg.reg = reg;
 290     msg.val = val;
 291
 292     OOP_DoMethod((OOP_Object *)dev, (OOP_Msg)&msg);
 293 }
 294
 295 void outw_config(UBYTE reg, UWORD val, APTR dev)
 296 {
 297     struct pHidd_PCIDevice_WriteConfigWord msg;
 298
 299     msg.mID = mid_WW;
 300     msg.reg = reg;
 301     msg.val = val;
 302
 303     OOP_DoMethod((OOP_Object *)dev, (OOP_Msg)&msg);
 304 }
 305
 306 void outb_config(UBYTE reg, UBYTE val, APTR dev)
 307 {
 308     struct pHidd_PCIDevice_WriteConfigByte msg;
 309
 310     msg.mID = mid_WB;
 311     msg.reg = reg;
 312     msg.val = val;
 313
 314     OOP_DoMethod((OOP_Object *)dev, (OOP_Msg)&msg);
 315 }
 316
 317 ULONG ahi_pci_get_irq(APTR dev)
 318 {
 319     IPTR val;
 320
 321     OOP_GetAttr((OOP_Object *)dev, aHidd_PCIDevice_INTLine, &val);
 322
 323     return (ULONG)val;
 324 }
 325
 326 BOOL ahi_pci_add_intserver(struct Interrupt *i, APTR dev)
 327 {
 328     IPTR val;
 329
 330     OOP_GetAttr((OOP_Object *)dev, aHidd_PCIDevice_INTLine, &val);
 331
 332     AddIntServer(INTB_KERNEL + val, i);
 333
 334     inthandler_added = TRUE;
 335
 336     return TRUE;
 337 }
 338
 339 void ahi_pci_rem_intserver(struct Interrupt *i, APTR dev)
 340 {
 341     if (inthandler_added)
 342     {
 343         IPTR val;
 344
 345         OOP_GetAttr((OOP_Object *)dev, aHidd_PCIDevice_INTLine, &val);
 346
 347         RemIntServer(INTB_KERNEL + val, i);
 348
 349         inthandler_added = FALSE;
 350     }
 351
 352     KPrintF("ahi_pci_rem_intserver\n");
 353 }
 354
 355 APTR ahi_pci_logic_to_physic_addr(APTR addr, APTR dev)
 356 {
 357   struct pHidd_PCIDriver_CPUtoPCI __msg__, *msg = &__msg__;
 358   IPTR                              driverobj, retval;
 359
 360   OOP_GetAttr((OOP_Object *)dev, aHidd_PCIDevice_Driver, &driverobj);
 361
 362   msg->mID = OOP_GetMethodID(IID_Hidd_PCIDriver, moHidd_PCIDriver_CPUtoPCI);
 363   msg->address = addr;
 364
 365   KPrintF("ahi_pci_logic_to_physic_addr(%lx)\n", msg->address);
 366
 367   retval = OOP_DoMethod((OOP_Object *)driverobj, (OOP_Msg)msg);
 368
 369   KPrintF("ahi_pci_logic_to_physic_addr(%lx) = %lx\n", msg->address, retval);
 370
 371   return (APTR)retval;
 372 }
 373
 374 APTR ahi_pci_get_base_address(WORD which, APTR dev)
 375 {
 376     OOP_AttrID attr = 0;
 377     IPTR val = 0;
 378
 379     switch(which)
 380     {
 381         case 0:
 382           attr = aHidd_PCIDevice_Base0;
 383           break;
 384
 385         case 1:
 386           attr = aHidd_PCIDevice_Base1;
 387           break;
 388
 389         case 2:
 390           attr = aHidd_PCIDevice_Base2;
 391           break;
 392
 393         case 3:
 394           attr = aHidd_PCIDevice_Base3;
 395           break;
 396
 397         case 4:
 398           attr = aHidd_PCIDevice_Base4;
 399           break;
 400
 401         case 5:
 402           attr = aHidd_PCIDevice_Base5;
 403           break;
 404
 405         default:
 406           return 0;
 407     }
 408
 409     OOP_GetAttr((OOP_Object *)dev, attr, &val);
 410
 411     //KPrintF("ahi_pci_get_base_address. Result %lx\n", val);
 412
 413     return (APTR)val;
 414 }
 415
 416 ULONG ahi_pci_get_base_size(WORD which, APTR dev)
 417 {
 418     OOP_AttrID attr = 0;
 419     IPTR val = 0;
 420
 421     switch(which)
 422     {
 423         case 0:
 424           attr = aHidd_PCIDevice_Size0;
 425           break;
 426
 427         case 1:
 428           attr = aHidd_PCIDevice_Size1;
 429           break;
 430
 431         case 2:
 432           attr = aHidd_PCIDevice_Size2;
 433           break;
 434
 435         case 3:
 436           attr = aHidd_PCIDevice_Size3;
 437           break;
 438
 439         case 4:
 440           attr = aHidd_PCIDevice_Size4;
 441           break;
 442
 443         case 5:
 444           attr = aHidd_PCIDevice_Size5;
 445           break;
 446
 447         default:
 448           return 0;
 449     }
 450
 451     OOP_GetAttr((OOP_Object *)dev, attr, &val);
 452
 453     //KPrintF("ahi_pci_get_base_size. Result %lx\n", val);
 454
 455     return (ULONG)val;
 456
 457 }
 458
 459
 460
 461 ULONG ahi_pci_get_type(WORD which, APTR dev)
 462 {
 463   OOP_AttrID attr = 0;
 464   IPTR val = 0;
 465
 466   switch(which)
 467   {
 468     case 0:
 469       attr = aHidd_PCIDevice_Type0;
 470       break;
 471
 472     case 1:
 473       attr = aHidd_PCIDevice_Type1;
 474       break;
 475
 476     case 2:
 477       attr = aHidd_PCIDevice_Type2;
 478       break;
 479
 480     case 3:
 481       attr = aHidd_PCIDevice_Type3;
 482       break;
 483
 484     case 4:
 485       attr = aHidd_PCIDevice_Type4;
 486       break;
 487
 488     case 5:
 489       attr = aHidd_PCIDevice_Type5;
 490       break;
 491
 492     default:
 493       return 0;
 494   }
 495
 496   OOP_GetAttr((OOP_Object *)dev, attr, &val);
 497
 498   //KPrintF("ahi_pci_get_type. Result %lx\n", val);
 499
 500   return (ULONG) val;
 501 }