intel OPAE FPGA Linux enhetsdrivrutinarkitektur

OPAE Intel FPGA Linux enhetsdrivrutinsarkitektur

OPAE Intel FPGA-drivrutinen tillhandahåller gränssnitt för användarutrymmesapplikationer för att konfigurera, räkna upp, öppna och komma åt FPGA-acceleratorer på plattformar utrustade med Intel FPGA-lösningar och möjliggör hanteringsfunktioner på systemnivå som FPGA-omkonfiguration, energihantering och virtualisering.

Hårdvaruarkitektur

Från OS:s synpunkt view, visas FPGA-hårdvaran som en vanlig PCIe-enhet. FPGA-enhetsminnet är organiserat med hjälp av en fördefinierad datastruktur (Device Feature List). Funktioner som stöds av FPGA-enheten exponeras genom dessa datastrukturer, som illustreras nedan i följande figur:

FPGA PCIe-enhet

Drivrutinen stöder PCIe SR-IOV för att skapa virtuella funktioner (VF) som kan användas för att tilldela individuella acceleratorer till virtuella maskiner.

Intel Corporation. Alla rättigheter förbehållna. Intel, Intels logotyp och andra Intel-märken är varumärken som tillhör Intel Corporation eller dess dotterbolag. Intel garanterar prestandan för sina FPGA- och halvledarprodukter enligt gällande specifikationer i enlighet med Intels standardgaranti men förbehåller sig rätten att göra ändringar av alla produkter och tjänster när som helst utan föregående meddelande. Intel tar inget ansvar eller ansvar som uppstår till följd av applikationen eller användningen av någon information, produkt eller tjänst som beskrivs här, förutom vad som uttryckligen har godkänts skriftligen av Intel. Intel-kunder rekommenderas att skaffa den senaste versionen av enhetsspecifikationerna innan de förlitar sig på någon publicerad information och innan de beställer produkter eller tjänster.

Andra namn och varumärken kan göras anspråk på att vara andras egendom.

Virtualiserad FPGA PCIe-enhet

FPGA Management Engine (FME)
FPGA Management Engine utför effekt- och värmehantering, felrapportering, omkonfigurering, prestandarapportering och andra infrastrukturfunktioner. Varje FPGA har en FME, som alltid nås via den fysiska funktionen (PF). Användarutrymmesapplikationer kan skaffa exklusiv åtkomst till FME med open(), och släppa den med close() som en privilegierad användare (root).

Hamn
En port representerar gränssnittet mellan det statiska FPGA-tyget ("FPGA Interface Manager (FIM)") och en delvis omkonfigurerbar region som innehåller en acceleratorfunktion (AF). Porten styr kommunikationen från programvaran till acceleratorn och exponerar funktioner som återställning och felsökning. En PCIe-enhet kan ha flera portar och varje port kan exponeras genom en VF genom att tilldela den med FPGA_FME_PORT_ASSIGN ioctl på FME-enheten.

Acceleratorfunktion (AF)-enhet

• En Accelerator Function (AF)-enhet är ansluten till en port och exponerar en 256K MMIO-region som ska användas för acceleratorspecifika kontrollregister.
• Användarutrymmesapplikationer kan få exklusiv åtkomst till en AFU kopplad till en port genom att använda open() på portenheten och släppa den med close().
• Användarutrymmesapplikationer kan också mmap() accelerator MMIO-regioner.

Partiell omkonfiguration
Som nämnts ovan kan acceleratorer konfigureras om genom partiell omkonfigurering av en acceleratorfunktion (AF) file. Acceleratorfunktionen (AF) måste ha genererats för den exakta FIM och den statiska målregionen (Port) för FPGA:n; annars kommer omkonfigureringsoperationen att misslyckas och eventuellt orsaka systeminstabilitet. Denna kompatibilitet kan kontrolleras genom att jämföra gränssnitts-ID som anges i AF-huvudet med gränssnitts-ID som exponeras av FME via sysfs. Denna kontroll görs vanligtvis av användarutrymmet innan omkonfigurationen IOCTL anropas.

Notera:
För närvarande måste alla program som har åtkomst till FPGA:n, inklusive de som körs i en virtualiserad värd, stängas innan du försöker göra en partiell omkonfiguration. Stegen skulle vara:

1. Lossa föraren från gästen
2. Koppla bort VF från gästen
3. Inaktivera SR-IOV
4. Utför partiell omkonfiguration
5. Aktivera SR-IOV
6. Anslut VF till gästen
7. Ladda föraren i gästen

FPGA-virtualisering
För att möjliggöra åtkomst till en accelerator från applikationer som körs i en virtuell dator måste respektive AFU:s port tilldelas en VF med följande steg:

1. PF äger alla AFU-portar som standard. Alla portar som behöver omtilldelas till en VF måste först frigöras från PF via FPGA_FME_PORT_RELEASE ioctl på FME-enheten.
2. När N portar har släppts från PF kan kommandot nedan användas för att aktivera SRIOV och VF. Varje VF äger endast en port med AFU. echo N > PCI_DEVICE_PATH/sriov_numvfs
3. Passera genom VF till virtuella datorer.
4. AFU under VF är tillgänglig från applikationer i VM (med samma drivrutin inuti VF).

Notera:
En FME kan inte tilldelas en VF, därför är PR och andra hanteringsfunktioner endast tillgängliga via PF.

Förarorganisation

PCIe-modulens enhetsdrivrutin

Förarorganisation

FPGA-enheterna visas som vanliga PCIe-enheter; sålunda laddas FPGA PCIe-enhetsdrivrutinen (intel-FPGA-PCI.ko) alltid först när en FPGA PCIe PF eller VF detekteras. Denna drivrutin spelar en infrastrukturell roll i förararkitekturen. Det:

• Skapar en FPGA-containerenhet som en förälder till funktionsenheterna.
• Går igenom Device Feature List, som är implementerad i PCIe-enhetens BAR-minne, för att upptäcka funktionsenheter och deras underfunktioner och skapa plattformsenheter för dem under containerenheten.
• Stöder SR-IOV.
• Introducerar funktionsenhetsinfrastrukturen, som abstraherar operationer för underfunktioner och exponerar vanliga funktioner för funktionsenhetsdrivrutiner.

PCIe-modulens enhetsdrivrutinsfunktioner

• Innehåller PCIe-upptäckt, enhetsuppräkning och funktionsupptäckt.
• Skapar sysfs-kataloger för den överordnade enheten, FPGA Management Engine (FME) och port.
• Skapar plattformsdrivrutininstanserna, vilket gör att Linux-kärnan laddar sina respektive plattformsmoduldrivrutiner.

FME Platform Module Device Driver

• Ström- och värmehantering, felrapportering, resultatrapportering och andra infrastrukturfunktioner. Du kan komma åt dessa funktioner via sysfs-gränssnitt som exponeras av FME-drivrutinen.
• Partiell omkonfiguration. FME-drivrutinen registrerar en FPGA Manager under PR-underfunktionsinitiering; när den väl tar emot en FPGA_FME_PORT_PR ioctl från dig, anropar den den gemensamma gränssnittsfunktionen från FPGA Manager för att slutföra den partiella omkonfigureringen av bitströmmen till den givna porten.
• Porthantering för virtualisering. FME-drivrutinen introducerar två ioctls, FPGA_FME_PORT_RELEASE, som släpper den givna porten från PF; och FPGA_FME_PORT_ASSIGN, som tilldelar porten tillbaka till PF. När porten har släppts från PF kan den tilldelas till VF via SR-IOV-gränssnitten som tillhandahålls av PCIe-drivrutinen. För mer information, se "FPGA-virtualisering".

FME-plattformsmodulens enhetsdrivrutinsfunktioner

• Skapar enhetsnoden för FME-tecken.
• Skapar FME sysfs files och implementerar FME sysfs file tillbehör.
• Implementerar underdrivrutinerna för FMEs privata funktion.
• FME privata underdrivrutiner:
  • FME Header
  • Termisk hantering
  • Power Management
  • Globalt fel
  • Partiell omkonfiguration
  • Global prestanda

Port Platform Module Device Driver
I likhet med FME-drivrutinen undersöks FPGA-portens (och AFU)-drivrutinen (intel-fpga-afu. ko) när portplattformsenheten har skapats. Huvudfunktionen för denna modul är att tillhandahålla ett gränssnitt för användarutrymmesapplikationer för åtkomst till de individuella acceleratorerna, inklusive grundläggande återställningskontroll på port, AFU MMIO-regionexport, DMA-buffertmappningstjänst, UMsg(1)-avisering och fjärrfelsökningsfunktioner ( se ovan).

UMsg stöds endast genom Acceleration Stack för Intel Xeon®-processor med integrerad FPGA.

Port Platform Module Device Driver Funktioner

• Skapar enhetsnoden för porttecken.
• Skapar port sysfs files och implementerar Port sysfs file tillbehör.
• Implementerar underdrivrutinerna för portprivatfunktionen.
• Underdrivrutiner för portprivata funktioner:
  • Porthuvud
  • AFU
  • Portfel
  • UMsg(2)
  • Signaltryck

Application FPGA Device Enumeration
Det här avsnittet introducerar hur applikationer räknar upp FPGA-enheten från sysfs-hierarkin under /sys/class/fpga. I exampnedan är två Intel FPGA-enheter installerade i värden. Varje FPGA-enhet har en FME och två portar (AFU). För varje FPGA-enhet skapas en enhetskatalog under /sys/class/fpga:

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

Varje nod har en FME och två portar (AFU) som underordnade enheter:
/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

I allmänhet heter FME/Port sysfs-gränssnitten enligt följande:
/sys/class/fpga/intel-fpga-dev.i/intel-fpga-fme.j/
/sys/class/fpga/intel-fpga-dev.i/intel-fpga-port.k/

med I konsekutiv numrering av alla behållaranordningar, j numrerar i följd FME:erna och k numrerar i följd alla portar.

Enhetsnoderna som används för ioctl() och mmap() kan refereras genom:
/dev/intel-fpga-fme.j
/dev/intel-fpga-port.k

PCIe-drivrutinsuppräkning
Detta avsnitt ger en överview av kodflödet för enhetsuppräkning utförd av intel-fpga-pci.ko. De viktigaste datastrukturerna och funktionerna är markerade. Detta avsnitt följs bäst när viewmedföljande källkod (pcie.c).

Uppräkningsdatastrukturer

enum fpga_id_type {
PARENT_ID,
FME_ID,
PORT_ID,
FPGA_ID_MAX
};
statisk struktur idr fpga_ids[FPGA_ID_MAX];
struct fpga_chardev_info {
const char *namn;
dev_t devt;
};
struct fpga_chardev_info fpga_chrdevs[] = {
{ .name = FPGA_FEATURE_DEV_FME },
{ .name = FPGA_FEATURE_DEV_PORT },
};
statisk strukturklass *fpga_class;
statisk struktur 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,}
};
statisk struktur pci_drivrutin cci_pci_drivrutin = {
.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 device_id;
struct enhet *fme_dev;
struct mutex lås;
struct list_head port_dev_list;
int released_port_num;
struct list_head regioner;
};
struct build_feature_devs_info {
struct pci_dev *pdev;
void __iomem *ioaddr;
void __iomem *ioend;
int aktuell_bar;
void __iomem *pfme_hdr;
struct enhet *parent_dev;
struct platform_device *feature_dev;
};

Uppräkningsflöde

• ccidrv_init()
  • Initiera fpga_ids med idr_init().
  • Initiera fpga_chrdevs[i].devt med alloc_chrdev_region().
  • Initiera fpga_class med class_create().
  • pci_register_driver(&cci_pci_driver);
• cci_pci_probe()
  • Aktivera PCI-enheten, begär åtkomst till dess regioner, ställ in PCI-masterläge och konfigurera DMA.
• cci_pci_create_feature_devs() build_info_alloc_and_init()
  • Tilldela en struct build_feature_devs_info, initiera den.
    .parent_dev är satt till en överordnad sysfs-katalog (intel-fpga-dev.id) som innehåller katalogerna FME och Port sysfs.
• parse_feature_list()
  • Gå igenom BAR0 Device Feature List för att upptäcka FME, Porten och deras privata funktioner.
• parse_feature() parse_feature_afus() parse_feature_fme()
  • När en FME påträffas:
• build_info_create_dev()
  • Tilldela en plattformsenhet för FME, lagra i build_feature_devs_info.feature_dev.
  • feature_dev.id initieras till resultatet av idr_alloc(fpga_ids[FME_ID],
  • feature_dev.parent är inställd på build_feature_devs_info.parent_dev.
  • Tilldela en array av strukturresurser i feature_dev.resource.
• Tilldela en struct feature_platform_data, initiera den och lagra en pekare i feature_dev.dev.platform_data
  • create_feature_instance() build_info_add_sub_feature()
  • Initiera feature_dev.resource[FME_FEATURE_ID_HEADER].
  • feature_platform_data_add()
  • Initiera feature_platform_data.features[FME_FEATURE_ID_HEADER], allt utom .fops.
• parse_feature() parse_feature_afus() parse_feature_port()
  • När en hamn påträffas:
• build_info_create_dev()
  • Tilldela en plattformsenhet för porten, lagra i build_feature_devs_info.feature_dev.
  • feature_dev.id initieras till resultatet av idr_alloc(fpga_ids[PORT_ID],
  • feature_dev.parent är inställd på build_feature_devs_info.parent_dev.
  • Tilldela en array av strukturresurs i feature_dev.resource.
  • Tilldela en struct feature_platform_data, initiera den och lagra en pekare i feature_dev.dev.platform_data
• build_info_commit_dev()
  • Lägg till struct feature_platform_data.node för porten till listan över portar i struct cci_drvdata.port_dev_list
• create_feature_instance() build_info_add_sub_feature()
  • Initiera feature_dev.resource[PORT_FEATURE_ID_HEADER].
• feature_platform_data_add()
  • Initiera feature_platform_data.features[PORT_FEATURE_ID_HEADER], allt utom .fops.
• parse_feature() parse_feature_afus() parse_feature_port_uafu()
  • När en AFU påträffas:
• create_feature_instance() build_info_add_sub_feature()
  • Initiera feature_dev.resource[PORT_FEATURE_ID_UAFU].
• feature_platform_data_add()
  • Initiera feature_platform_data.features[PORT_FEATURE_ID_UAFU], allt utom .fops.
• parse_feature() parse_feature_private() parse_feature_fme_private()
  • När en privat FME-funktion påträffas:
• create_feature_instance() build_info_add_sub_feature()
  • Initiera feature_dev.resource[id].
• feature_platform_data_add()
  • Initiera feature_platform_data.features[id], allt utom .fops.
• parse_feature() parse_feature_private() parse_feature_port_private()
• När en port privat funktion påträffas: * create_feature_instance() build_info_add_sub_feature() * Initiera feature_dev.resource[id]. * feature_platform_data_add() Initiera feature_platform_data.features[id], allt utom .fops.
• parse_ports_from_fme()
  • Om drivrutinen är laddad på Physical Function (PF), då:
• Kör flödet parse_feature_list() på varje port som beskrivs i FME-huvudet.
• Använd den BAR som nämns i varje portpost i rubriken.

FME-plattformsenhetsinitiering
Detta avsnitt ger en överview av kodflödet för FME-enhetsinitiering utförd av intel-fpga-fme.ko. De viktigaste datastrukturerna och funktionerna är markerade. Detta avsnitt följs bäst när viewmedföljande källkod (fme-main.c).

FME Platform Device Data Structures

struct feature_ops {
int (*init)(struct platform_device *pdev, struct feature *feature);
int (*unit)(struct platform_device *pdev, struct feature *feature);
long (*ioctl)(struct platform_device *pdev, struct feature *feature,
unsigned int cmd, unsigned long arg);
int (*test)(struct platform_device *pdev, struct feature *feature);
};
struct feature {
const char *namn;
int resursindex;
void __iomem *ioaddr;
struct feature_ops *ops;
};
struct feature_platform_data {
struct list_head nod;
struct mutex lås;
osignerad lång dev_status;
struct cdev cdev;
struct platform_device *dev;
osignerad int disable_count;
void *privat;
int num;
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 *)); struktur
särdrag[0];
};
struct perf_object {
int id;
const struct attribute_group **attr_groups;
struct enhet *fme_dev;
struct list_head nod;
struct list_head barn;
struktur kobject kobj;
};
struct fpga_fme {
u8 port_id;
u64 pr_err;
struct enhet *dev_err;
struct perf_object *perf_dev;
struct feature_platform_data *pdata;
};

FME-plattformsenhetsinitieringsflöde

FME-initieringsflöde

• fme_probe() fme_dev_init()
  • Initiera en struct fpga_fme och lagra den i fältet feature_platform_data.private.
• fme_probe() fpga_dev_feature_init() feature_instance_init()
  • Spara en struct feature_ops i feature_platform_data.features för varje ifylld funktion.
  • Anropa testfunktionen, om någon, från strukturen.
  • Anropa init-funktionen från struct.
• fme_probe() fpga_register_dev_ops()
  • Skapa enhetsnoden för FME-tecken, registrera en struktur file_operationer.

Initiering av portplattformsenhet
Detta avsnitt ger en överview av kodflödet för portenhetsinitiering utförd av intel-fpga-afu.ko. De viktigaste datastrukturerna och funktionerna är markerade. Detta avsnitt följs bäst när viewmedföljande källkod (afu.c).

Port Platform Device Data Structures

struct feature_ops {
int (*init)(struct platform_device *pdev, struct feature *feature);
int (*unit)(struct platform_device *pdev, struct feature *feature);
long (*ioctl)(struct platform_device *pdev, struct feature *feature,
unsigned int cmd, unsigned long arg);
int (*test)(struct platform_device *pdev, struct feature *feature);
};
struct feature {
const char *namn;
int resursindex;
void __iomem *ioaddr;
struct feature_ops *ops;
};
struct feature_platform_data {
struct list_head nod;
struct mutex lås;
osignerad lång dev_status;
struct cdev cdev;
struct platform_device *dev;
osignerad int disable_count;
void *privat;
int num;
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 flaggor;
storlek u64;
u64 offset;
u64 fysik;
struct list_head nod;
};
struct fpga_afu_dma_region {
u64 user_addr;
u64 längd;
u64 iova;
struct sida **sidor;
struct rb_node nod;
bool in_use;
};
struct fpga_afu {
u64 region_cur_offset;
int antal_regioner;
u8 num_umsgs;
struct list_head regioner;
struct rb_root dma_regions;
struct feature_platform_data *pdata;
};

Port Platform Device Initialization Flow

Portinitieringsflöde

• afu_probe() afu_dev_init()
  • Initiera en struktur fpga_afu och lagra den i fältet feature_platform_data.private.
• afu_probe() fpga_dev_feature_init() feature_instance_init()
  • Spara en struct feature_ops i feature_platform_data.features för varje ifylld funktion.
  • Anropa testfunktionen, om någon, från strukturen.
  • Anropa init-funktionen från struct.
• afu_probe() fpga_register_dev_ops()
  • Skapa enhetsnoden för portkaraktären och registrera en struktur file_operationer.

FME IOCTLs
IOCTLs som anropas på en öppen file deskriptor för /dev/intel-fpga-fme.j FPGA_GET_API_VERSION – returnera den aktuella versionen som ett heltal, med start från 0.

FPGA_CHECK_EXTENSION – stöds inte för närvarande.

FPGA_FME_PORT_RELEASE—arg är en pekare till en:

struct fpga_fme_port_release {
__u32 argsz; // i: sizeof(struct fpga_fme_port_release)
__u32 flaggor; // in: måste vara 0
__u32 port_id; // in: port-ID (från 0) för att släppa.
};

FPGA_FME_PORT_ASSIGN—arg är en pekare till en:

struct fpga_fme_port_assign {
__u32 argsz; // i: sizeof(struct fpga_fme_port_assign)
__u32 flaggor; // in: måste vara 0
__u32 port_id; // in: port-ID (från 0) att tilldela. (måste ha varit det
tidigare släppt av FPGA_FME_PORT_RELEASE)
};

FPGA_FME_PORT_PR—arg är en pekare till en:

struct fpga_fme_port_pr {
__u32 argsz; // i: sizeof(struct fpga_fme_port_pr)
__u32 flaggor; // in: måste vara 0
__u32 port_id; // in: port-ID (från 0)
__u32 buffertstorlek; // in: storleken på bitströmsbufferten i byte. Måste vara 4-byte
inriktad.
__u64 buffertadress; // in: processadress för bitströmsbuffert
__u64 status; // ut: felstatus (bitmask)
};

Port IOCTLs
IOCTLs som anropas på en öppen file deskriptor för /dev/intel-fpga-port.k FPGA_GET_API_VERSION – returnera den aktuella versionen som ett heltal, med start från 0. FPGA_CHECK_EXTENSION – stöds inte för närvarande.

FPGA_PORT_GET_INFO—arg är en pekare till en:

struct fpga_port_info {
__u32 argsz; // i: sizeof(struct fpga_port_info)
__u32 flaggor; // ut: returnerar 0
__u32 antal_regioner; // ut: antal MMIO-regioner, 2 (1 för AFU och 1 för
STP)
__u32 num_umsgs; // ut: antal UMsg:er som stöds av hårdvaran
};

FPGA_PORT_GET_REGION_INFO—arg är en pekare till en:

struct fpga_port_region_info {
__u32 argsz; // i: sizeof(struct fpga_port_region_info)
__u32 flaggor; // ut: (bitmask) { FPGA_REGION_READ, FPGA_REGION_WRITE,
FPGA_REGION_MMAP }
__u32 index; // i: FPGA_PORT_INDEX_UAFU eller FPGA_PORT_INDEX_STP
__u32 stoppning; // in: måste vara 0
__u64 storlek; // ut: storleken på MMIO-regionen i byte
__u64 offset; // ut: förskjutning av MMIO-regionen från början av enheten fd
};

FPGA_PORT_DMA_MAP—arg är en pekare till en:
struct fpga_port_dma_map {
__u32 argsz; // i: sizeof(struct fpga_port_dma_map)
__u32 flaggor; // in: måste vara 0 __u64 user_addr; // i: process virtuell
adress. Måste vara sidjusterad.
__u64 längd; // in: längden på mappningen i byte. Måste vara en multipel av sidor
storlek.
__u64 iova; // ut: IO virtuell adress };

FPGA_PORT_DMA_UNMAP—arg är en pekare till en:
struct fpga_port_dma_unmap {
__u32 argsz; // i: sizeof(struct fpga_port_dma_unmap)
__u32 flaggor; // in: måste vara 0
__u64 iova; // in: IO virtuell adress som returneras av en tidigare
FPGA_PORT_DMA_MAP };

• FPGA_PORT_RESET—arg måste vara NULL.
• FPGA_PORT_UMSG_ENABLE—arg måste vara NULL.
• FPGA_PORT_UMSG_DISABLE—args måste vara NULL.

FPGA_PORT_UMSG_SET_MODE—arg är en pekare till en:

struct fpga_port_umsg_cfg {
__u32 argsz; // i: sizeof(struct fpga_port_umsg_cfg)
__u32 flaggor; // in: måste vara 0
__u32 hint_bitmap; // i: UMsg tipsläge bitmapp. Anger vilka UMsg är
aktiverat.
};

FPGA_PORT_UMSG_SET_BASE_ADDR—

• UMsg måste inaktiveras innan denna ioctl utfärdas.
• Iova-fältet måste vara för en buffert som är tillräckligt stor för alla UMsg (num_umsgs * PAGE_SIZE).
  • Bufferten är markerad som "används" av förarens bufferthantering.
  • Om iova är NULL, avmarkeras alla tidigare regioner som "används".
• arg är en pekare till en:
  struct fpga_port_umsg_base_addr {
  • u32 argsz; // i: sizeof(struct fpga_port_umsg_base_addr)
  • u32 flaggor; // in: måste vara 0
  • u64 iova; // in: IO virtuell adress från FPGA_PORT_DMA_MAP. };

Notera:

• För att rensa portfelen måste du skriva den exakta bitmasken för de aktuella felen, till exempelample, kattfel > rensa
• UMsg stöds endast genom Acceleration Stack för Intel Xeon-processor med integrerad FPGA.

sysfs Files

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

sysfs file	mmio fält	typ	tillträde
ports_num	fme_header.capability.num_ports	decimal int	Skrivskyddad
cache_size	fme_header.capability.cache_size	decimal int	Skrivskyddad
version	fme_header.capability.fabric_verid	decimal int	Skrivskyddad
socket_id	fme_header.capability.socket_id	decimal int	Skrivskyddad
bitströms-id	fme_header.bitstream_id	hex uint64_t	Skrivskyddad
bitströmsmetadata	fme_header.bitstream_md	hex uint64_t	Skrivskyddad

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

sysfs file	mmio fält	typ	tillträde
tröskel 1	thermal.threshold.tmp_thshold1	decimal int	Användare: Skrivskyddad rot: Läs-skriv
tröskel 2	thermal.threshold.tmp_thshold2	decimal int	Användare: Skrivskyddad rot: Läs-skriv
threshold_trip	thermal.threshold.therm_trip_thshold	decimal int	Skrivskyddad
threshold1_reached	thermal.threshold.thshold1_status	decimal int	Skrivskyddad
threshold2_reached	thermal.threshold.thshold2_status	decimal int	Skrivskyddad
tröskel1_policy	termisk. threshold.thshold_policy	decimal int	Användare: Skrivskyddad rot: Läs-skriv
temperatur	thermal.rdsensor_fm1.fpga_temp	decimal int	Skrivskyddad

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

sysfs file	mmio fält	typ	tillträde
förbrukad	power.status.pwr_consumed	hex uint64_t	Skrivskyddad
tröskel 1	effekttröskel.tröskel1	hex uint64_t	Användare: Skrivskyddad rot: Läs-skriv
tröskel 2	effekttröskel.tröskel2	hex uint64_t	Användare: Skrivskyddad rot: Läs-skriv
tröskel1_status	power.threshold.threshold1_status	decimal utan tecken	Skrivskyddad
tröskel2_status	power.threshold.threshold2_status	decimal utan tecken	Skrivskyddad
rtl	power.status.fpga_latency_report	decimal utan tecken	Skrivskyddad

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

sysfs file	mmio fält	typ	tillträde
pcie0_errors	gerror.pcie0_err	hex uint64_t	Läsa skriva
pcie1_errors	gerror.pcie1_err	hex uint64_t	Läsa skriva
inject_error	gerror.ras_error_inj	hex uint64_t	Läsa skriva

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

sysfs file	mmio fält	typ	tillträde
fel	gerror.fme_err	hex uint64_t	Skrivskyddad
first_error	gerror.fme_first_err.err_reg_status	hex uint64_t	Skrivskyddad
nästa_fel	gerror.fme_next_err.err_reg_status	hex uint64_t	Skrivskyddad
rensa	Rensar fel, first_error, next_error	olika uint64_t	Skrivbara

Notera:
För att rensa FME-felen måste du skriva den exakta bitmasken för de aktuella felen, till exempelample cat-fel > rensa.

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

sysfs file	mmio fält	typ	tillträde
interface_id	pr.fme_pr_intfc_id0_h, pr.fme_pre_intfc_id0_l	hex 16-byte	Skrivskyddad

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

sysfs file	mmio fält	typ	tillträde
klocka	gperf.clk.afu_interf_clock	hex uint64_t	Skrivskyddad

intel-fpga-dev.i/intel-fpga-fme.j/dperf/cache/ (Gäller inte för Acceleration Stack för Intel Xeon CPU med FPGA)

sysfs file	mmio fält	typ	tillträde
frysa	gperf.ch_ctl.freeze	decimal int	Läsa skriva
read_hit	gperf.CACHE_RD_HIT	hex uint64_t	Skrivskyddad
läs_miss	gperf.CACHE_RD_MISS	hex uint64_t	Skrivskyddad
write_hit	gperf.CACHE_WR_HIT	hex uint64_t	Skrivskyddad
skriv_miss	gperf.CACHE_WR_MISS	hex uint64_t	Skrivskyddad
hold_request	gperf.CACHE_HOLD_REQ	hex uint64_t	Skrivskyddad
tx_req_stall	gperf.CACHE_TX_REQ_STALL	hex uint64_t	Skrivskyddad

sysfs file	mmio fält	typ	tillträde
rx_req_stall	gperf.CACHE_RX_REQ_STALL	hex uint64_t	Skrivskyddad
data_write_port_contention	gperf.CACHE_DATA_WR_PORT_CONTEN	hex uint64_t	Skrivskyddad
tag_write_port_contention	gperf.CACHE_TAG_WR_PORT_CONTEN	hex uint64_t	Skrivskyddad

intel-fpga-dev.i/intel-fpga-fme.j/dperf/iommu/ (Gäller inte för Acceleration Stack för Intel Xeon CPU med FPGA)

sysfs file	mmio fält	typ	tillträde
frysa	gperf.vtd_ctl.freeze	decimal int	Användare: Skrivskyddad rot: Läs-skriv

intel-fpga-dev.i/intel-fpga-fme.j/dperf/iommu/afuk/ (Gäller inte för Acceleration Stack för Intel Xeon CPU med FPGA)

sysfs file	mmio fält	typ	tillträde
läs_transaktion	gperf.VTD_AFU0_MEM_RD_TRANS	hex uint64_t	Skrivskyddad
skrivtransaktion	gperf.VTD_AFU0_MEM_WR_TRANS	hex uint64_t	Skrivskyddad
tlb_read_hit	gperf.VTD_AFU0_TLB_RD_HIT	hex uint64_t	Skrivskyddad
tlb_write_hit	gperf.VTD_AFU0_TLB_WR_HIT	hex uint64_t	Skrivskyddad

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

sysfs file	mmio fält	typ	tillträde
aktivera	gperf.fab_ctl.(aktiverad)	decimal int	Användare: Skrivskyddad rot: Läs-skriv
frysa	gperf.fab_ctl.freeze	decimal int	Användare: Skrivskyddad rot: Läs-skriv
pcie0_read	gperf.FAB_PCIE0_RD	hex uint64_t	Skrivskyddad
pcie0_write	gperf.FAB_PCIE0_WR	hex uint64_t	Skrivskyddad
pcie1_read	gperf.FAB_PCIE1_RD	hex uint64_t	Skrivskyddad
pcie1_write	gperf.FAB_PCIE1_WR	hex uint64_t	Skrivskyddad
upi_read	gperf.FAB_UPI_RD	hex uint64_t	Skrivskyddad
upi_write	gperf.FAB_UPI_WR	hex uint64_t	Skrivskyddad

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

sysfs file	mmio fält	typ	tillträde
pcie0_read	gperf.FAB_PCIE0_RD	hex uint64_t	Skrivskyddad
pcie0_write	gperf.FAB_PCIE0_WR	hex uint64_t	Skrivskyddad
pcie1_read	gperf.FAB_PCIE1_RD	hex uint64_t	Skrivskyddad
pcie1_write	gperf.FAB_PCIE1_WR	hex uint64_t	Skrivskyddad
upi_read	gperf.FAB_UPI_RD	hex uint64_t	Skrivskyddad
upi_write	gperf.FAB_UPI_WR	hex uint64_t	Skrivskyddad

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

sysfs file	mmio fält	typ	tillträde
id	port_header.capability.port_number	decimal int	Skrivskyddad
ltr	port_header.control.latency_tolerance	decimal int	Skrivskyddad

Port AFU Header sysfs files
intel-fpga-dev.i/intel-fpga-port.k/

sysfs file	mmio fält	typ	tillträde
afu_id	afu_header.guid	hex 16-byte	Skrivskyddad

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

sysfs file	mmio fält	typ	tillträde
fel	perror.port_error	hex uint64_t	Skrivskyddad
first_error	perror.port_first_error	hex uint64_t	Skrivskyddad
first_malformed_req	perror.malreq	hex 16-byte	Skrivskyddad
rensa	perror.(alla fel)	olika uint64_t	Skrivbara

Notera:
För att rensa portfelen måste du skriva den exakta bitmasken för de aktuella felen, till exempelample cat-fel > rensa.

Revisionshistorik

Dokumentversion	Ändringar
2017.10.02	Initial release.

OPAE Intel FPGA Linux Device Driver Architecture Guide

Dokument/resurser

intel OPAE FPGA Linux enhetsdrivrutinarkitektur [pdf] Användarhandbok OPAE FPGA Linux Device Driver Architecture, OPAE FPGA, Linux Device Driver Architecture, Driver Architecture, Architecture

Referenser

• Användarmanual