intel OPAE FPGA Linux Device Driver Architecture

OPAE Intel FPGA Linux Device Driver Architecture

Az OPAE Intel FPGA illesztőprogram interfészeket biztosít a felhasználói alkalmazások számára az FPGA-gyorsítók konfigurálásához, felsorolásához, megnyitásához és eléréséhez az Intel FPGA megoldásokkal felszerelt platformokon, és lehetővé teszi a rendszerszintű felügyeleti funkciókat, például az FPGA újrakonfigurálását, az energiagazdálkodást és a virtualizációt.

Hardver architektúra

Az operációs rendszer szempontjából view, az FPGA hardver normál PCIe eszközként jelenik meg. Az FPGA eszközmemória egy előre meghatározott adatstruktúra (Device Feature List) segítségével van megszervezve. Az FPGA-eszköz által támogatott funkciók ezeken az adatstruktúrákon keresztül jelennek meg, amint az alábbi ábrán látható:

FPGA PCIe eszköz

Az illesztőprogram támogatja a PCIe SR-IOV-t virtuális függvények (VF-ek) létrehozásához, amelyek segítségével egyedi gyorsítókat lehet hozzárendelni a virtuális gépekhez.

Intel Corporation. Minden jog fenntartva. Az Intel, az Intel logó és más Intel védjegyek az Intel Corporation vagy leányvállalatai védjegyei. Az Intel szavatolja, hogy FPGA és félvezető termékei az aktuális specifikációknak megfelelő teljesítményt nyújtanak az Intel szabványos garanciájával összhangban, de fenntartja a jogot, hogy bármely terméket és szolgáltatást előzetes értesítés nélkül módosítson. Az Intel nem vállal felelősséget az itt leírt információk, termékek vagy szolgáltatások alkalmazásából vagy használatából eredően, kivéve, ha az Intel kifejezetten írásban beleegyezik. Az Intel ügyfeleinek azt tanácsoljuk, hogy szerezzék be az eszközspecifikációk legfrissebb verzióját, mielőtt bármilyen közzétett információra hagyatkoznának, és mielőtt megrendelnék termékeket vagy szolgáltatásokat.

Más nevek és márkák mások tulajdonát képezhetik.

Virtualizált FPGA PCIe eszköz

FPGA Management Engine (FME)
Az FPGA Management Engine energia- és hőkezelést, hibajelentést, újrakonfigurálást, teljesítményjelentést és egyéb infrastrukturális funkciókat hajt végre. Minden FPGA-nak van egy FME-je, amely mindig a fizikai funkción (PF) keresztül érhető el. A felhasználói térbeli alkalmazások kizárólagos hozzáférést kaphatnak az FME-hez az open() használatával, és a close() segítségével kiváltságos felhasználóként (root) engedhetik el.

Kikötő
A port jelenti az interfészt a statikus FPGA-szövet (az „FPGA-interfészkezelő (FIM)”) és egy gyorsító funkciót (AF) tartalmazó, részben újrakonfigurálható régió között. A port vezérli a szoftver és a gyorsító közötti kommunikációt, és olyan funkciókat tesz elérhetővé, mint a visszaállítás és a hibakeresés. Egy PCIe-eszköznek több portja is lehet, és mindegyik port elérhető egy VF-en keresztül, ha hozzárendeli az FME-eszköz FPGA_FME_PORT_ASSIGN ioctl-jével.

Gyorsító funkció (AF) egység

• A gyorsító funkció (AF) egység egy porthoz van csatlakoztatva, és egy 256K MMIO-régiót tesz elérhetővé a gyorsító-specifikus vezérlőregiszterekhez.
• A felhasználói terület alkalmazások kizárólagos hozzáférést kaphatnak egy porthoz csatolt AFU-hoz a port eszköz open() paranccsal, és a close() segítségével felszabadíthatják.
• A felhasználói térbeli alkalmazások az mmap() gyorsító MMIO régiókat is képesek felvenni.

Részleges újrakonfigurálás
Amint fentebb említettük, a gyorsítók újrakonfigurálhatók egy gyorsító funkció (AF) részleges újrakonfigurálásával. file. A gyorsító funkciót (AF) az FPGA pontos FIM-hez és célzott statikus régiójához (Port) kell előállítani; ellenkező esetben az újrakonfigurálási művelet meghiúsul, és a rendszer instabilitását okozhatja. Ez a kompatibilitás úgy ellenőrizhető, hogy az AF-fejlécben szereplő interfész-azonosítót összehasonlítja az FME által a sysfs-en keresztül megjelenített interfész-azonosítóval. Ezt az ellenőrzést általában a felhasználói terület végzi el az IOCTL újrakonfigurálása előtt.

Jegyzet:
Jelenleg az FPGA-t elérő minden szoftvert, beleértve a virtualizált gazdagépen futókat is, be kell zárni a részleges újrakonfigurálás megkísérlése előtt. A lépések a következők lennének:

1. Rakd ki a sofőrt a vendégből
2. Húzza ki a VF-et a vendégből
3. Az SR-IOV letiltása
4. Hajtsa végre a részleges újrakonfigurálást
5. SR-IOV engedélyezése
6. Csatlakoztassa a VF-et a vendéghez
7. Töltsd be a sofőrt a vendégbe

FPGA virtualizáció
Ahhoz, hogy a virtuális gépen futó alkalmazásokból hozzá lehessen férni a gyorsítóhoz, a megfelelő AFU portot hozzá kell rendelni egy virtuális géphez a következő lépések végrehajtásával:

1. Alapértelmezés szerint a PF birtokolja az összes AFU portot. Minden olyan portot, amelyet át kell rendelni egy VF-hez, először el kell engedni a PF-től az FME-eszköz FPGA_FME_PORT_RELEASE ioctl-jén keresztül.
2. Miután N portot felszabadított a PF-ből, az alábbi paranccsal engedélyezhető a SRIOV és a VF. Minden VF-nek csak egy AFU-portja van. echo N > PCI_DEVICE_PATH/sriov_numvfs
3. A virtuális gépeken át a virtuális gépekre.
4. A VF alatti AFU elérhető a VM-ben lévő alkalmazásokból (ugyanazt az illesztőprogramot használja a VF-en belül).

Jegyzet:
FME nem rendelhető VF-hez, így a PR és egyéb menedzsment funkciók csak a PF-en keresztül érhetők el.

Sofőr szervezet

PCIe modul eszközillesztő

Sofőr szervezet

Az FPGA-eszközök normál PCIe-eszközökként jelennek meg; így az FPGA PCIe PF vagy VF észlelése után mindig az FPGA PCIe eszközillesztő (intel-FPGA-PCI.ko) töltődik be először. Ez az illesztőprogram infrastrukturális szerepet játszik az illesztőprogram-architektúrában. Azt:

• Létrehoz egy FPGA-tárolóeszközt a jellemző eszközök szülőjeként.
• Végigjárja a PCIe eszköz BAR-memóriájában megvalósított Device Feature List listát, hogy felfedezze a funkcióeszközöket és azok alfunkcióit, és platformeszközöket hozzon létre számukra a tárolóeszköz alatt.
• Támogatja az SR-IOV-t.
• Bemutatja a szolgáltatáseszköz-infrastruktúrát, amely absztrahálja az alszolgáltatások műveleteit, és a közös funkciókat teszi közzé a szolgáltatás eszközillesztői számára.

A PCIe modul eszközillesztő funkciói

• Tartalmazza a PCIe-felderítést, az eszközök felsorolását és a funkciók felfedezését.
• Sysfs könyvtárakat hoz létre a szülőeszközhöz, az FPGA Management Engine-hez (FME) és a porthoz.
• Létrehozza a platform illesztőprogram-példányait, aminek hatására a Linux kernel betölti a megfelelő platformmodul-illesztőprogramjaikat.

FME Platform Module Device Driver

• Teljesítmény- és hőkezelés, hibajelentés, teljesítményjelentés és egyéb infrastrukturális funkciók. Ezeket a funkciókat az FME illesztőprogram által elérhető sysf interfészeken keresztül érheti el.
• Részleges újrakonfigurálás. Az FME meghajtó regisztrál egy FPGA Managert a PR alfunkció inicializálása során; amint kap egy FPGA_FME_PORT_PR ioctl-t Öntől, meghívja az FPGA Manager közös interfész funkcióját, hogy befejezze a bitfolyam részleges újrakonfigurálását az adott portra.
• Portkezelés a virtualizációhoz. Az FME illesztőprogram két ioctl-t vezet be, az FPGA_FME_PORT_RELEASE, amely felszabadítja az adott portot a PF-ből; és az FPGA_FME_PORT_ASSIGN, amely a portot visszarendeli a PF-hez. Miután a portot felszabadították a PF-ből, a PCIe illesztőprogram által biztosított SR-IOV interfészeken keresztül hozzárendelhető a VF-hez. További információkért lásd az „FPGA virtualizáció” részt.

Az FME platform modul eszközillesztő funkciói

• Létrehozza az FME karakter eszköz csomópontját.
• Létrehozza az FME sysf-eket files és megvalósítja az FME sysfs-t file kiegészítők.
• Megvalósítja az FME privát funkció al-illesztőprogramjait.
• FME privát funkció al-illesztőprogramjai:
  • FME fejléc
  • Hőkezelés
  • Energiagazdálkodás
  • Globális hiba
  • Részleges újrakonfigurálás
  • Globális teljesítmény

Port Platform Module Device Driver
Az FME illesztőprogramhoz hasonlóan az FPGA port (és AFU) illesztőprogramot (intel-fpga-afu.ko) a Port platform eszköz létrehozása után vizsgálja meg. Ennek a modulnak az a fő funkciója, hogy interfészt biztosítson a felhasználói területeken futó alkalmazások számára az egyes gyorsítók eléréséhez, beleértve a port alapvető visszaállítási vezérlését, az AFU MMIO régió exportálását, a DMA pufferleképezési szolgáltatást, az UMsg(1) értesítést és a távoli hibakeresési funkciókat ( lásd fent).

Az UMsg-t csak az Acceleration Stack támogatja az Intel Xeon® processzorhoz integrált FPGA-val.

Port Platform Module eszközillesztő funkciói

• Létrehozza a Port karakter eszköz csomópontot.
• Létrehozza a Port sysfs fájlt files és megvalósítja a Port sysfs file kiegészítők.
• Megvalósítja a Port privát funkció al-illesztőprogramjait.
• Port privát szolgáltatási segédprogramjai:
  • Port fejléc
  • AFU
  • Port hiba
  • UMsg(2)
  • Signal Tap

Alkalmazás FPGA-eszközök felsorolása
Ez a rész bemutatja, hogyan sorolják fel az alkalmazások az FPGA-eszközt a /sys/class/fpga alatti sysfs hierarchiából. Az exampAz alábbiakban két Intel FPGA-eszköz van telepítve a gazdagépen. Minden FPGA eszköz egy FME-vel és két porttal (AFU) rendelkezik. Minden FPGA-eszközhöz létrejön egy eszközkönyvtár a /sys/class/fpga alatt:

/sys/class/fpga/intel-fpga-dev.0
/sys/class/fpga/intel-fpga-dev.1

Minden csomópont egy FME-vel és két porttal (AFU) rendelkezik gyermekeszközként:
/sys/class/fpga/intel-fpga-dev.0/intel-fpga-fme.0
/sys/class/fpga/intel-fpga-dev.0/intel-fpga-port.0
/sys/class/fpga/intel-fpga-dev.0/intel-fpga-port.1
/sys/class/fpga/intel-fpga-dev.1/intel-fpga-fme.1
/sys/class/fpga/intel-fpga-dev.1/intel-fpga-port.2
/sys/class/fpga/intel-fpga-dev.1/intel-fpga-port.3

Az FME/Port sysfs interfészek elnevezése általában a következő:
/sys/class/fpga/intel-fpga-dev.i/intel-fpga-fme.j/
/sys/class/fpga/intel-fpga-dev.i/intel-fpga-port.k/

I sorszámozással az összes konténer eszközt, j sorszámmal az FME-ket és k sorszámmal minden portot.

Az ioctl()-hez és mmap()-hoz használt eszközcsomópontokra a következő módon lehet hivatkozni:
/dev/intel-fpga-fme.j
/dev/intel-fpga-port.k

PCIe illesztőprogramok felsorolása
Ez a rész áttekintést adview az intel-fpga-pci.ko által végrehajtott eszközfelsorolás kódfolyamának. A főbb adatstruktúrák és funkciók kiemelve vannak. Ezt a részt a legjobb követni, amikor viewa kísérő forráskód (pcie.c) megadása.

Felsorolási adatstruktúrák

enum fpga_id_type {
PARENT_ID,
FME_ID,
PORT_ID,
FPGA_ID_MAX
};
statikus struktúra idr fpga_ids[FPGA_ID_MAX];
struct fpga_chardev_info {
const char *név;
dev_t devt;
};
struct fpga_chardev_info fpga_chrdevs[] = {
{ .name = FPGA_FEATURE_DEV_FME },
{ .name = FPGA_FEATURE_DEV_PORT },
};
static struct class *fpga_class;
static struct pci_device_id cci_pcie_id_tbl[] = {
{PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCIe_DEVICE_ID_RCiEP0_MCP),},
{PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCIe_DEVICE_ID_VF_MCP),},
{PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCIe_DEVICE_ID_RCiEP0_SKX_P),},
{PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCIe_DEVICE_ID_VF_SKX_P),},
{PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCIe_DEVICE_ID_RCiEP0_DCP),},
{PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCIe_DEVICE_ID_VF_DCP),},
{0,}
};
static struct pci_driver cci_pci_driver = {
.name = DRV_NAME,
.id_table = cci_pcie_id_tbl,
.probe = cci_pci_probe,
.remove = cci_pci_remove,
.sriov_configure = cci_pci_sriov_configure
};
struct cci_drvdata {
int eszköz_azonosítója;
struct eszköz *fme_dev;
struct mutex zár;
struct list_head port_dev_list;
int kiadott_port_szám;
struct list_head régiók;
};
struct build_feature_devs_info {
struct pci_dev *pdev;
void __iomem *ioaddr;
void __iomem *ioend;
int aktuális_sáv;
void __iomem *pfme_hdr;
struct eszköz *parent_dev;
struct platform_device *feature_dev;
};

Felsorolási folyamat

• ccidrv_init()
  • Az fpga_ids inicializálása az idr_init() segítségével.
  • Inicializálja az fpga_chrdevs[i].devt fájlt az alloc_chrdev_region() segítségével.
  • Az fpga_class inicializálása a class_create() segítségével.
  • pci_register_driver(&cci_pci_driver);
• cci_pci_probe()
  • Engedélyezze a PCI-eszközt, kérjen hozzáférést a régióihoz, állítsa be a PCI-mester módot, és konfigurálja a DMA-t.
• cci_pci_create_feature_devs() build_info_alloc_and_init()
  • Rendeljen ki egy build_feature_devs_info struktúrát, inicializálja.
    A .parent_dev egy szülő sysfs könyvtárra (intel-fpga-dev.id) van beállítva, amely tartalmazza az FME és a Port sysfs könyvtárat.
• parse_feature_list()
  • Sétáljon a BAR0 eszközfunkciók listáján, hogy felfedezze az FME-t, a portot és azok privát funkcióit.
• parse_feature() parse_feature_afus() parse_feature_fme()
  • Ha FME-vel találkozik:
• build_info_create_dev()
  • Rendeljen ki egy platformeszközt az FME számára, a build_feature_devs_info.feature_dev helyen tárolva.
  • A feature_dev.id az idr_alloc(fpga_ids[FME_ID],
  • A feature_dev.parent a build_feature_devs_info.parent_dev értékre van állítva.
  • Rendeljen ki egy struct erőforrás tömböt a feature_dev.resource fájlban.
• Rendeljen ki egy feature_platform_data struktúrát, inicializálja, és tároljon egy mutatót a feature_dev.dev.platform_data fájlban
  • create_feature_instance() build_info_add_sub_feature()
  • Inicializálja a feature_dev.resource[FME_FEATURE_ID_HEADER].
  • feature_platform_data_add()
  • Inicializálja a feature_platform_data.features[FME_FEATURE_ID_HEADER]-et, mindent, kivéve a .fops-t.
• parse_feature() parse_feature_afus() parse_feature_port()
  • Amikor találkozik egy port:
• build_info_create_dev()
  • Rendeljen ki egy platformeszközt a porthoz, a build_feature_devs_info.feature_dev helyen tárolva.
  • A feature_dev.id az idr_alloc(fpga_ids[PORT_ID],
  • A feature_dev.parent a build_feature_devs_info.parent_dev értékre van állítva.
  • Rendeljen ki egy struct erőforrás tömböt a feature_dev.resource fájlban.
  • Rendeljen ki egy feature_platform_data struktúrát, inicializálja, és tároljon egy mutatót a feature_dev.dev.platform_data fájlban
• build_info_commit_dev()
  • Adja hozzá a porthoz tartozó struct feature_platform_data.node értéket a struct cci_drvdata.port_dev_list portlistájához.
• create_feature_instance() build_info_add_sub_feature()
  • A feature_dev.resource[PORT_FEATURE_ID_HEADER] inicializálása.
• feature_platform_data_add()
  • Inicializálja a feature_platform_data.features[PORT_FEATURE_ID_HEADER] fájlt, mindent, kivéve a .fops fájlt.
• parse_feature() parse_feature_afus() parse_feature_port_uafu()
  • Ha AFU-val találkozik:
• create_feature_instance() build_info_add_sub_feature()
  • Inicializálja a feature_dev.resource[PORT_FEATURE_ID_UAFU].
• feature_platform_data_add()
  • Inicializálja a feature_platform_data.features[PORT_FEATURE_ID_UAFU]-t, mindent, kivéve a .fops-t.
• parse_feature() parse_feature_private() parse_feature_fme_private()
  • Ha FME privát funkcióval találkozik:
• create_feature_instance() build_info_add_sub_feature()
  • Inicializálja a feature_dev.resource[id].
• feature_platform_data_add()
  • Inicializálja a feature_platform_data.features[id]-et, mindent, kivéve a .fops-t.
• parse_feature() parse_feature_private() parse_feature_port_private()
• Amikor egy Port privát szolgáltatással találkozik: * create_feature_instance() build_info_add_sub_feature() * Inicializálja a feature_dev.resource[id] funkciót. * feature_platform_data_add() Inicializálja a feature_platform_data.features[id]-et, mindent, kivéve a .fops-t.
• parse_ports_from_fme()
  • Ha az illesztőprogram a fizikai funkcióra (PF) van betöltve, akkor:
• Futtassa a parse_feature_list() folyamatot az FME fejlécben leírt minden egyes porton.
• Használja a fejlécben minden Port bejegyzésben említett BAR-t.

FME platform eszköz inicializálása
Ez a rész áttekintést adview az intel-fpga-fme.ko által végrehajtott FME-eszköz inicializálásához szükséges kódfolyamból. A fő adatstruktúrák és funkciók kiemelve vannak. Ezt a részt a legjobb követni, amikor viewa kísérő forráskód (fme-main.c) megadása.

FME platform eszköz adatstruktúrák

struct feature_ops {
int (*init)(struct platform_device *pdev, struct feature *feature);
int (*uinit)(struct platform_device *pdev, struct feature *feature);
long (*ioctl)(struct platform_device *pdev, struct szolgáltatás *feature,
unsigned int cmd, unsigned long arg);
int (*teszt)(struct platform_device *pdev, struct feature *feature);
};
struct feature {
const char *név;
int erőforrás_index;
void __iomem *ioaddr;
struct feature_ops *ops;
};
struct feature_platform_data {
struct list_head node;
struct mutex zár;
unsigned long dev_status;
struct cdev cdev;
struct platform_device *dev;
unsigned int disable_count;
void *privát;
int szám;
int (*config_port)(struct platform_device *, u32, bool);
struct platform_device *(*fpga_for_each_port)(struct platform_device *,
void *, int (*match)(struct platform_device *, void *)); struct
jellemző tulajdonságok[0];
};
struct perf_object {
te kezed;
const struct attribútumcsoport **attr_groups;
struct eszköz *fme_dev;
struct list_head node;
struct list_head gyerekek;
struct kobject kobj;
};
struct fpga_fme {
u8 port_id;
u64 pr_err;
struct eszköz *dev_err;
struct perf_object *perf_dev;
struct feature_platform_data *pdata;
};

FME platform eszköz inicializálási folyamata

FME inicializálási folyamat

• fme_probe() fme_dev_init()
  • Inicializáljon egy fpga_fme struct-ot, és tárolja a feature_platform_data.private mezőben.
• fme_probe() fpga_dev_feature_init() feature_instance_init()
  • Mentse el a feature_ops struct-ot a feature_platform_data.features fájlba minden egyes feltöltött jellemzőhöz.
  • Hívja meg a teszt függvényt, ha van, a struct-ból.
  • Hívja meg az init függvényt a structból.
• fme_probe() fpga_register_dev_ops()
  • Hozza létre az FME karakter eszköz csomópontját, regisztráljon egy struktúrát file_tevékenységek.

Portplatform eszköz inicializálása
Ez a rész áttekintést adview az intel-fpga-afu.ko által végrehajtott port eszköz inicializálásának kódfolyama. A főbb adatstruktúrák és funkciók kiemelve vannak. Ezt a részt a legjobb követni, amikor viewa kísérő forráskód (afu.c) megadása.

Portplatform eszköz adatstruktúrák

struct feature_ops {
int (*init)(struct platform_device *pdev, struct feature *feature);
int (*uinit)(struct platform_device *pdev, struct feature *feature);
long (*ioctl)(struct platform_device *pdev, struct szolgáltatás *feature,
unsigned int cmd, unsigned long arg);
int (*teszt)(struct platform_device *pdev, struct feature *feature);
};
struct feature {
const char *név;
int erőforrás_index;
void __iomem *ioaddr;
struct feature_ops *ops;
};
struct feature_platform_data {
struct list_head node;
struct mutex zár;
unsigned long dev_status;
struct cdev cdev;
struct platform_device *dev;
unsigned int disable_count;
void *privát;
int szám;
int (*config_port)(struct platform_device *, u32, bool);
struct platform_device *(*fpga_for_each_port)(struct platform_device *,
void *, int (*match)(struct platform_device *, void *));
struct feature features[0];
};
struct fpga_afu_region {
u32 index;
u32 zászlók;
u64-es méret;
u64 eltolás;
u64 fiz.
struct list_head node;
};
struct fpga_afu_dma_region {
u64 user_addr;
u64 hosszúság;
u64 iova;
struct oldal **oldalak;
struct rb_node csomópont;
bool in_use;
};
struct fpga_afu {
u64 region_cur_offset;
int régiók száma;
u8 num_umsgs;
struct list_head régiók;
struct rb_root dma_regions;
struct feature_platform_data *pdata;
};

Portplatform eszköz inicializálási folyamata

Port inicializálási folyamata

• afu_probe() afu_dev_init()
  • Inicializáljon egy fpga_afu struktúrát, és tárolja a feature_platform_data.private mezőben.
• afu_probe() fpga_dev_feature_init() feature_instance_init()
  • Mentse el a feature_ops struct-ot a feature_platform_data.features fájlba minden egyes feltöltött jellemzőhöz.
  • Hívja meg a teszt függvényt, ha van, a struct-ból.
  • Hívja meg az init függvényt a structból.
• afu_probe() fpga_register_dev_ops()
  • Hozza létre a Port karakter eszköz csomópontját, regisztráljon egy struktúrát file_tevékenységek.

FME IOCTL-ek
IOCTL-ek, amelyeket megnyitáskor hívnak meg file leíró /dev/intel-fpga-fme.j FPGA_GET_API_VERSION – az aktuális verzió egész számként való visszaadása, 0-tól kezdve.

FPGA_CHECK_EXTENSION – jelenleg nem támogatott.

FPGA_FME_PORT_RELEASE – az arg egy mutató a következőre:

struct fpga_fme_port_release {
__u32 argsz; // in: sizeof(struct fpga_fme_port_release)
__u32 zászlók; // in: 0-nak kell lennie
__u32 port_id; // in: portazonosító (0-tól) a kiadáshoz.
};

FPGA_FME_PORT_ASSIGN – az arg egy mutató egy:

struct fpga_fme_port_assign {
__u32 argsz; // in: sizeof(struct fpga_fme_port_assign)
__u32 zászlók; // in: 0-nak kell lennie
__u32 port_id; // in: port ID (0-tól) hozzárendelni. (lehetett
korábban az FPGA_FME_PORT_RELEASE által kiadott)
};

FPGA_FME_PORT_PR — az arg egy mutató a következőre:

struct fpga_fme_port_pr {
__u32 argsz; // in: sizeof(struct fpga_fme_port_pr)
__u32 zászlók; // in: 0-nak kell lennie
__u32 port_id; // in: portazonosító (0-tól)
__u32 puffer_size; // in: a bitfolyam puffer mérete bájtban. 4 bájtosnak kell lennie
igazítva.
__u64 puffer_cím; // in: a bitfolyam puffer folyamatcíme
__u64 állapot; // ki: hibaállapot (bitmaszk)
};

Port IOCTLs
IOCTL-ek, amelyeket megnyitáskor hívnak meg file leíró /dev/intel-fpga-port.k FPGA_GET_API_VERSION – az aktuális verziót adja vissza egész számként, 0-tól kezdve. FPGA_CHECK_EXTENSION – jelenleg nem támogatott.

FPGA_PORT_GET_INFO — az arg egy mutató a következőre:

struct fpga_port_info {
__u32 argsz; // in: sizeof(struct fpga_port_info)
__u32 zászlók; // ki: 0-t ad vissza
__u32 régiók száma; // ki: MMIO régiók száma, 2 (1 az AFU-hoz és 1 az
STP)
__u32 num_umsgs; // out: a hardver által támogatott UMsg-k száma
};

FPGA_PORT_GET_REGION_INFO — az arg egy mutató egy:

struct fpga_port_region_info {
__u32 argsz; // in: sizeof(struct fpga_port_region_info)
__u32 zászlók; // ki: (bitmaszk) { FPGA_REGION_READ, FPGA_REGION_WRITE,
FPGA_REGION_MMAP }
__u32 index; // in: FPGA_PORT_INDEX_UAFU vagy FPGA_PORT_INDEX_STP
__u32 padding; // in: 0-nak kell lennie
__u64 méret; // out: az MMIO régió mérete bájtban
__u64 offset; // out: az MMIO régió eltolása az eszköz kezdetétől fd
};

FPGA_PORT_DMA_MAP — az arg egy mutató a következőre:
struct fpga_port_dma_map {
__u32 argsz; // in: sizeof(struct fpga_port_dma_map)
__u32 zászlók; // in: 0-nak kell lennie __u64 user_addr; // in: virtuális folyamat
cím. Oldalhoz igazítani kell.
__u64 hosszúság; // in: a leképezés hossza bájtban. Többoldalasnak kell lennie
méret.
__u64 iova; // ki: IO virtuális cím };

FPGA_PORT_DMA_UNMAP — az arg egy mutató a következőre:
struct fpga_port_dma_unmap {
__u32 argsz; // in: sizeof(struct fpga_port_dma_unmap)
__u32 zászlók; // in: 0-nak kell lennie
__u64 iova; // in: Az előző által visszaadott IO virtuális cím
FPGA_PORT_DMA_MAP };

• FPGA_PORT_RESET — az arg értékének NULL-nak kell lennie.
• FPGA_PORT_UMSG_ENABLE – az arg értékének NULL-nak kell lennie.
• FPGA_PORT_UMSG_DISABLE – az argoknak NULL-nak kell lenniük.

FPGA_PORT_UMSG_SET_MODE — az arg egy mutató a következőre:

struct fpga_port_umsg_cfg {
__u32 argsz; // in: sizeof(struct fpga_port_umsg_cfg)
__u32 zászlók; // in: 0-nak kell lennie
__u32 hint_bitmap; // in: UMsg tipp mód bittérkép. Jelzi, hogy mely UMsg-k vannak
engedélyezve van.
};

FPGA_PORT_UMSG_SET_BASE_ADDR—

• Az UMsg-t le kell tiltani az ioctl kiadása előtt.
• Az iova mezőnek elég nagy puffernek kell lennie az összes UMsg számára (num_umsgs * PAGE_SIZE).
  • A puffert az illesztőprogram pufferkezelése „használatban”-ként jelöli meg.
  • Ha az iova értéke NULL, akkor a korábbi régiók „használatban” jelölése megszűnik.
• Az arg egy mutató a következőre:
  struct fpga_port_umsg_base_addr {
  • u32 argsz; // in: sizeof(struct fpga_port_umsg_base_addr)
  • u32 zászlók; // in: 0-nak kell lennie
  • u64 iova; // in: IO virtuális cím az FPGA_PORT_DMA_MAP-ről. };

Jegyzet:

• A porthibák törléséhez meg kell írni az aktuális hibák pontos bitmaszkját, plample, macska hibák > egyértelmű
• Az UMsg-t csak az Acceleration Stack támogatja az Intel Xeon processzorhoz integrált FPGA-val.

sysfs Files

FME Header sysfs files
intel-fpga-dev.i/intel-fpga-fme.j/

sysfs file	mmio mező	típus	hozzáférés
portok_száma	fme_header.capability.num_ports	decimális int	Csak olvasható
cache_size	fme_header.capability.cache_size	decimális int	Csak olvasható
változat	fme_header.capability.fabric_verid	decimális int	Csak olvasható
socket_id	fme_header.capability.socket_id	decimális int	Csak olvasható
bitfolyam_id	fme_header.bitstream_id	hex uint64_t	Csak olvasható
bitfolyam_metadata	fme_header.bitstream_md	hex uint64_t	Csak olvasható

FME Thermal Management sysfs files
intel-fpga-dev.i/intel-fpga-fme.j/thermal_mgmt/

sysfs file	mmio mező	típus	hozzáférés
küszöb1	thermo.threshold.tmp_thshold1	decimális int	Felhasználó: Csak olvasható Root: Írható-olvasható
küszöb2	thermo.threshold.tmp_thshold2	decimális int	Felhasználó: Csak olvasható Root: Írható-olvasható
küszöb_utazás	thermo.threshold.therm_trip_thshold	decimális int	Csak olvasható
threshold1_reached	thermo.threshold.thshold1_status	decimális int	Csak olvasható
threshold2_reached	thermo.threshold.thshold2_status	decimális int	Csak olvasható
threshold1_policy	termikus. threshold.thshold_policy	decimális int	Felhasználó: Csak olvasható Root: Írható-olvasható
hőmérséklet	thermo.rdsensor_fm1.fpga_temp	decimális int	Csak olvasható

FME Power Management sysfs files
intel-fpga-dev.i/intel-fpga-fme.j/power_mgmt/

sysfs file	mmio mező	típus	hozzáférés
elfogyasztott	power.status.pwr_consumed	hex uint64_t	Csak olvasható
küszöb1	teljesítmény.küszöb.küszöb1	hex uint64_t	Felhasználó: Csak olvasható Root: Írható-olvasható
küszöb2	teljesítmény.küszöb.küszöb2	hex uint64_t	Felhasználó: Csak olvasható Root: Írható-olvasható
threshold1_status	power.threshold.threshold1_status	decimális előjel nélküli	Csak olvasható
threshold2_status	power.threshold.threshold2_status	decimális előjel nélküli	Csak olvasható
rtl	power.status.fpga_latency_report	decimális előjel nélküli	Csak olvasható

FME Global Error sysfs files
intel-fpga-dev.i/intel-fpga-fme.j/errors/

sysfs file	mmio mező	típus	hozzáférés
pcie0_errors	gerror.pcie0_err	hex uint64_t	Ír olvas
pcie1_errors	gerror.pcie1_err	hex uint64_t	Ír olvas
inject_error	gerror.ras_error_inj	hex uint64_t	Ír olvas

intel-fpga-dev.i/intel-fpga-fme.j/errors/fme-errors/

sysfs file	mmio mező	típus	hozzáférés
hibákat	gerror.fme_err	hex uint64_t	Csak olvasható
first_error	gerror.fme_first_err.err_reg_status	hex uint64_t	Csak olvasható
következő_hiba	gerror.fme_next_err.err_reg_status	hex uint64_t	Csak olvasható
világos	Törli a hibákat, first_error, next_error	különféle uint64_t	Csak írható

Jegyzet:
Az FME hibák törléséhez meg kell írni az aktuális hibák pontos bitmaszkját, plample cat errors > egyértelmű.

FME Partial Reconfiguration sysfs files
intel-fpga-dev.i/intel-fpga-fme.j/pr/

sysfs file	mmio mező	típus	hozzáférés
interface_id	pr.fme_pr_intfc_id0_h, pr.fme_pre_intfc_id0_l	hexadecimális 16 bájtos	Csak olvasható

FME Global Performance sysfs files
intel-fpga-dev.i/intel-fpga-fme.j/dperf/clock

sysfs file	mmio mező	típus	hozzáférés
óra	gperf.clk.afu_interf_clock	hex uint64_t	Csak olvasható

intel-fpga-dev.i/intel-fpga-fme.j/dperf/cache/ (Nem érvényes az FPGA-val rendelkező Intel Xeon CPU-hoz készült Acceleration Stack esetén)

sysfs file	mmio mező	típus	hozzáférés
fagy	gperf.ch_ctl.freeze	decimális int	Ír olvas
read_hit	gperf.CACHE_RD_HIT	hex uint64_t	Csak olvasható
read_miss	gperf.CACHE_RD_MISS	hex uint64_t	Csak olvasható
write_hit	gperf.CACHE_WR_HIT	hex uint64_t	Csak olvasható
write_miss	gperf.CACHE_WR_MISS	hex uint64_t	Csak olvasható
hold_request	gperf.CACHE_HOLD_REQ	hex uint64_t	Csak olvasható
tx_req_stall	gperf.CACHE_TX_REQ_STALL	hex uint64_t	Csak olvasható

sysfs file	mmio mező	típus	hozzáférés
rx_req_stall	gperf.CACHE_RX_REQ_STALL	hex uint64_t	Csak olvasható
data_write_port_contention	gperf.CACHE_DATA_WR_PORT_CONTEN	hex uint64_t	Csak olvasható
tag_write_port_contention	gperf.CACHE_TAG_WR_PORT_CONTEN	hex uint64_t	Csak olvasható

intel-fpga-dev.i/intel-fpga-fme.j/dperf/iommu/ (Nem érvényes az FPGA-val rendelkező Intel Xeon CPU-hoz készült Acceleration Stack esetén)

sysfs file	mmio mező	típus	hozzáférés
fagy	gperf.vtd_ctl.freeze	decimális int	Felhasználó: Csak olvasható Root: Írható-olvasható

intel-fpga-dev.i/intel-fpga-fme.j/dperf/iommu/afuk/ (Nem érvényes az FPGA-val rendelkező Intel Xeon CPU gyorsítási veremére)

sysfs file	mmio mező	típus	hozzáférés
read_transaction	gperf.VTD_AFU0_MEM_RD_TRANS	hex uint64_t	Csak olvasható
write_transaction	gperf.VTD_AFU0_MEM_WR_TRANS	hex uint64_t	Csak olvasható
tlb_read_hit	gperf.VTD_AFU0_TLB_RD_HIT	hex uint64_t	Csak olvasható
tlb_write_hit	gperf.VTD_AFU0_TLB_WR_HIT	hex uint64_t	Csak olvasható

intel-fpga-dev.i/intel-fpga-fme.j/dperf/fabric/

sysfs file	mmio mező	típus	hozzáférés
engedélyezze	gperf.fab_ctl.(engedélyezve)	decimális int	Felhasználó: Csak olvasható Root: Írható-olvasható
fagy	gperf.fab_ctl.freeze	decimális int	Felhasználó: Csak olvasható Root: Írható-olvasható
pcie0_read	gperf.FAB_PCIE0_RD	hex uint64_t	Csak olvasható
pcie0_write	gperf.FAB_PCIE0_WR	hex uint64_t	Csak olvasható
pcie1_read	gperf.FAB_PCIE1_RD	hex uint64_t	Csak olvasható
pcie1_write	gperf.FAB_PCIE1_WR	hex uint64_t	Csak olvasható
upi_read	gperf.FAB_UPI_RD	hex uint64_t	Csak olvasható
upi_write	gperf.FAB_UPI_WR	hex uint64_t	Csak olvasható

intel-fpga-ev.i/intel-fpga/fme.j/dperf/fabric/portk/

sysfs file	mmio mező	típus	hozzáférés
pcie0_read	gperf.FAB_PCIE0_RD	hex uint64_t	Csak olvasható
pcie0_write	gperf.FAB_PCIE0_WR	hex uint64_t	Csak olvasható
pcie1_read	gperf.FAB_PCIE1_RD	hex uint64_t	Csak olvasható
pcie1_write	gperf.FAB_PCIE1_WR	hex uint64_t	Csak olvasható
upi_read	gperf.FAB_UPI_RD	hex uint64_t	Csak olvasható
upi_write	gperf.FAB_UPI_WR	hex uint64_t	Csak olvasható

Port fejléc sysfs files
intel-fpga-dev.i/intel-fpga-port.k/

sysfs file	mmio mező	típus	hozzáférés
id	port_header.capability.port_number	decimális int	Csak olvasható
ltr	port_header.control.latency_tolerance	decimális int	Csak olvasható

Port AFU fejléc sysfs files
intel-fpga-dev.i/intel-fpga-port.k/

sysfs file	mmio mező	típus	hozzáférés
afu_id	afu_header.guid	hexadecimális 16 bájtos	Csak olvasható

Port hiba sysfs files
intel-fpga-dev.i/intel-fpga-port.k/errors/

sysfs file	mmio mező	típus	hozzáférés
hibákat	perror.port_error	hex uint64_t	Csak olvasható
first_error	perror.port_first_error	hex uint64_t	Csak olvasható
first_malformed_req	perror.malreq	hexadecimális 16 bájtos	Csak olvasható
világos	hiba. (minden hiba)	különféle uint64_t	Csak írható

Jegyzet:
A Port hibák törléséhez meg kell írni az aktuális hibák pontos bitmaszkját, plample cat errors > egyértelmű.

Revíziótörténet

Dokumentum verzió	Változások
2017.10.02	Kezdeti kiadás.

OPAE Intel FPGA Linux Device Driver Architecture Guide

Dokumentumok / Források

intel OPAE FPGA Linux Device Driver Architecture [pdf] Felhasználói útmutató OPAE FPGA Linux-eszközillesztő-architektúra, OPAE FPGA, Linux-eszköz-illesztőprogram-architektúra, illesztőprogram-architektúra, architektúra

Hivatkozások

• Felhasználói kézikönyv