arch/x86_64-linux/pcilinux/driverclass.c

   1 /*
   2     Copyright © 2004-2006, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: PCI direct driver for x86_64 linux.
   6     Lang: English
   7 */
   8 #include <exec/types.h>
   9 #include <hidd/hidd.h>
  10 #include <hidd/pci.h>
  11 #include <oop/oop.h>
  12
  13 #include <utility/tagitem.h>
  14
  15 #include <proto/exec.h>
  16 #include <proto/utility.h>
  17 #include <proto/oop.h>
  18
  19 #include <aros/symbolsets.h>
  20
  21 #include "pci.h"
  22
  23 #define DEBUG 1
  24 #include <aros/debug.h>
  25
  26 #ifdef HiddPCIDriverAttrBase
  27 #undef HiddPCIDriverAttrBase
  28 #endif // HiddPCIDriverAttrBase
  29
  30 #define HiddPCIDriverAttrBase   (PSD(cl)->hiddPCIDriverAB)
  31 #define HiddAttrBase            (PSD(cl)->hiddAB)
  32
  33 #define CFGADD(bus,dev,func,reg)    \
  34     ( 0x80000000 | ((bus)<<16) |    \
  35     ((dev)<<11) | ((func)<<8) | ((reg)&~3))
  36
  37 typedef union _pcicfg
  38 {
  39     ULONG   ul;
  40     UWORD   uw[2];
  41     UBYTE   ub[4];
  42 } pcicfg;
  43
  44 /*
  45     We overload the New method in order to introduce the Hidd Name and
  46     HardwareName attributes.
  47 */
  48 OOP_Object *PCILx__Root__New(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
  49 {
  50     struct pRoot_New mymsg;
  51
  52     struct TagItem mytags[] = {
  53         { aHidd_Name, (IPTR)"PCILinux" },
  54         { aHidd_HardwareName, (IPTR)"Linux direct access PCI driver" },
  55         { aHidd_PCIDriver_DirectBus, FALSE },
  56         { TAG_DONE, 0 }
  57     };
  58
  59     mymsg.mID = msg->mID;
  60     mymsg.attrList = (struct TagItem *)&mytags;
  61
  62     if (msg->attrList)
  63     {
  64         mytags[3].ti_Tag = TAG_MORE;
  65         mytags[3].ti_Data = (IPTR)msg->attrList;
  66     }
  67
  68     msg = &mymsg;
  69
  70     o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
  71
  72     return o;
  73 }
  74
  75 /*
  76     Some in/out magic to access PCI bus on PCs
  77 */
  78
  79 static inline ULONG inl(UWORD port)
  80 {
  81     ULONG val;
  82
  83     asm volatile ("inl %w1,%0":"=a"(val):"Nd"(port));
  84
  85     return val;
  86 }
  87
  88 static inline void outl(ULONG val, UWORD port)
  89 {
  90     asm volatile ("outl %0,%w1"::"a"(val),"Nd"(port));
  91 }
  92
  93 ULONG PCILx__Hidd_PCIDriver__ReadConfigLong(OOP_Class *cl, OOP_Object *o,
  94     struct pHidd_PCIDriver_ReadConfigLong *msg)
  95 {
  96     ULONG orig,temp;
  97
  98     Disable();
  99     orig=inl(PCI_AddressPort);
 100     outl(CFGADD(msg->bus, msg->dev, msg->sub, msg->reg),PCI_AddressPort);
 101     temp=inl(PCI_DataPort);
 102     outl(orig, PCI_AddressPort);
 103     Enable();
 104
 105     return temp;
 106 }
 107
 108 void PCILx__Hidd_PCIDriver__WriteConfigLong(OOP_Class *cl, OOP_Object *o,
 109     struct pHidd_PCIDriver_WriteConfigLong *msg)
 110 {
 111     ULONG orig;
 112
 113     Disable();
 114     orig=inl(PCI_AddressPort);
 115     outl(CFGADD(msg->bus, msg->dev, msg->sub, msg->reg),PCI_AddressPort);
 116     outl(msg->val,PCI_DataPort);
 117     outl(orig, PCI_AddressPort);
 118     Enable();
 119 }
 120
 121 IPTR PCILx__Hidd_PCIDriver__MapPCI(OOP_Class *cl, OOP_Object *o,
 122     struct pHidd_PCIDriver_MapPCI *msg)
 123 {
 124     ULONG offs = (IPTR)msg->PCIAddress >> 12;
 125     ULONG size = msg->Length;
 126     IPTR ret;
 127
 128     D(bug("[PCILinux] PCIDriver::MapPCI(%x, %x)\n", offs, size));
 129     asm volatile(
 130        "push %%rbp; mov %%rax,%%rbp; mov %1,%%rax; int $0x80; pop %%rbp"
 131         :"=a"(ret)
 132         :"i"(192), "b"(0), "c"(size), "d"(0x03), "S"(0x01), "D"(PSD(cl)->fd), "0"(offs)
 133     );
 134
 135     D(bug("[PCILinux] mmap syscall returned %x\n", ret));
 136
 137     return ret;
 138 }
 139
 140 VOID PCILx__Hidd_PCIDriver__UnmapPCI(OOP_Class *cl, OOP_Object *o,
 141     struct pHidd_PCIDriver_UnmapPCI *msg)
 142 {
 143     ULONG offs = (ULONG)msg->CPUAddress;
 144     ULONG size = msg->Length;
 145
 146     asm volatile(
 147         "int $0x80"
 148         :
 149         :"a"(91),"b"(offs),"c"(size));
 150 }
 151
 152 /* Class initialization and destruction */
 153
 154 #define psd (&LIBBASE->psd)
 155
 156 static int PCILx_ExpungeClass(LIBBASETYPEPTR LIBBASE)
 157 {
 158     D(bug("[PCILinux] deleting classes\n"));
 159
 160     OOP_ReleaseAttrBase(IID_Hidd_PCIDriver);
 161     OOP_ReleaseAttrBase(IID_Hidd);
 162
 163     return TRUE;
 164 }
 165
 166 static int PCILx_InitClass(LIBBASETYPEPTR LIBBASE)
 167 {
 168     OOP_Object *pci = NULL;
 169
 170     D(bug("LinuxPCI: Driver initialization\n"));
 171
 172     psd->hiddPCIDriverAB = OOP_ObtainAttrBase(IID_Hidd_PCIDriver);
 173     psd->hiddAB = OOP_ObtainAttrBase(IID_Hidd);
 174
 175     if (psd->hiddPCIDriverAB)
 176     {
 177         /*
 178          * The class may be added to the system. Add the driver
 179          * to PCI subsystem as well
 180          */
 181         struct pHidd_PCI_AddHardwareDriver msg;
 182
 183         /*
 184          * PCI is suppose to destroy the class on its Dispose
 185          */
 186         msg.driverClass = psd->driverClass;
 187         msg.mID = OOP_GetMethodID(IID_Hidd_PCI, moHidd_PCI_AddHardwareDriver);
 188
 189         // Add it for God's sake! ;)
 190         pci = OOP_NewObject(NULL, CLID_Hidd_PCI, NULL);
 191         OOP_DoMethod(pci, (OOP_Msg)&msg);
 192         OOP_DisposeObject(pci);
 193     }
 194     else
 195         return FALSE;
 196
 197     D(bug("LinuxPCI: Driver ClassPtr = %x\n", psd->driverClass));
 198
 199     return TRUE;
 200 }
 201
 202 ADD2INITLIB(PCILx_InitClass, 0)
 203 ADD2EXPUNGELIB(PCILx_ExpungeClass, 0)