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

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