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