Intel OPAE FPGA Linux-apparaatstuurprogramma-architectuur

OPAE Intel FPGA Linux-apparaatstuurprogramma-architectuur

Het OPAE Intel FPGA-stuurprogramma biedt interfaces voor toepassingen in de gebruikersruimte voor het configureren, opsommen, openen en openen van FPGA-accelerators op platforms die zijn uitgerust met Intel FPGA-oplossingen en maakt beheerfuncties op systeemniveau mogelijk, zoals FPGA-herconfiguratie, energiebeheer en virtualisatie.

Hardware-architectuur

Vanuit het besturingssysteempunt view, verschijnt de FPGA-hardware als een gewoon PCIe-apparaat. Het FPGA-apparaatgeheugen is georganiseerd met behulp van een vooraf gedefinieerde datastructuur (Device Feature List). Functies die door het FPGA-apparaat worden ondersteund, worden zichtbaar via deze datastructuren, zoals hieronder geïllustreerd in de volgende afbeelding:

FPGA PCIe-apparaat

Het stuurprogramma ondersteunt PCIe SR-IOV om virtuele functies (VF's) te creëren die kunnen worden gebruikt om individuele versnellers aan virtuele machines toe te wijzen.

Intel Corporation. Alle rechten voorbehouden. Intel, het Intel-logo en andere Intel-merken zijn handelsmerken van Intel Corporation of haar dochterondernemingen. Intel garandeert de prestaties van zijn FPGA- en halfgeleiderproducten volgens de huidige specificaties in overeenstemming met de standaardgarantie van Intel, maar behoudt zich het recht voor om op elk moment zonder voorafgaande kennisgeving wijzigingen aan te brengen in producten en diensten. Intel aanvaardt geen verantwoordelijkheid of aansprakelijkheid die voortvloeit uit de toepassing of het gebruik van enige informatie, product of dienst die hierin wordt beschreven, behalve zoals uitdrukkelijk schriftelijk overeengekomen door Intel. Intel-klanten wordt geadviseerd om de nieuwste versie van de apparaatspecificaties te verkrijgen voordat ze vertrouwen op gepubliceerde informatie en voordat ze producten of diensten bestellen.

Andere namen en merken kunnen als eigendom van anderen worden opgeëist.

Gevirtualiseerd FPGA PCIe-apparaat

FPGA-beheerengine (FME)
De FPGA Management Engine voert stroom- en thermisch beheer, foutrapportage, herconfiguratie, prestatierapportage en andere infrastructuurfuncties uit. Elke FPGA heeft één FME, die altijd toegankelijk is via de Physical Function (PF). Toepassingen in de gebruikersruimte kunnen exclusieve toegang tot de FME verkrijgen met behulp van open(), en deze vrijgeven met behulp van close() als een bevoorrechte gebruiker (root).

Haven
Een poort vertegenwoordigt de interface tussen de statische FPGA-structuur (de “FPGA Interface Manager (FIM)”) en een gedeeltelijk herconfigureerbare regio die een Accelerator-functie (AF) bevat. De poort regelt de communicatie van software naar de accelerator en biedt functies zoals reset en debug. Een PCIe-apparaat kan meerdere poorten hebben, en elke poort kan worden vrijgegeven via een VF door deze toe te wijzen met behulp van de FPGA_FME_PORT_ASSIGN ioctl op het FME-apparaat.

Acceleratorfunctie (AF)-eenheid

• Een Accelerator Function (AF)-eenheid is aangesloten op een poort en stelt een 256K MMIO-gebied bloot dat kan worden gebruikt voor versneller-specifieke controleregisters.
• Toepassingen in de gebruikersruimte kunnen exclusieve toegang verkrijgen tot een AFU die is aangesloten op een poort door open() op het poortapparaat te gebruiken, en deze vrijgeven met close().
• Gebruikersruimtetoepassingen kunnen ook MMIO-regio's van de mmap()-accelerator gebruiken.

Gedeeltelijke herconfiguratie
Zoals hierboven vermeld, kunnen versnellers opnieuw worden geconfigureerd door gedeeltelijke herconfiguratie van een versnellerfunctie (AF) file. De acceleratorfunctie (AF) moet zijn gegenereerd voor de exacte FIM en het beoogde statische gebied (poort) van de FPGA; anders zal de herconfiguratiebewerking mislukken en mogelijk systeeminstabiliteit veroorzaken. Deze compatibiliteit kan worden gecontroleerd door de interface-ID genoteerd in de AF-header te vergelijken met de interface-ID die door de FME via sysfs wordt vrijgegeven. Deze controle wordt meestal uitgevoerd door de gebruikersruimte voordat de herconfiguratie IOCTL wordt aangeroepen.

Opmerking:
Momenteel moet elk softwareprogramma dat toegang heeft tot de FPGA, inclusief programma's die op een gevirtualiseerde host draaien, worden gesloten voordat een gedeeltelijke herconfiguratie wordt geprobeerd. De stappen zouden zijn:

1. Ontlaad de chauffeur van de gast
2. Koppel de VF los van de gast
3. Schakel SR-IOV uit
4. Voer een gedeeltelijke herconfiguratie uit
5. Schakel SR-IOV in
6. Sluit de VF aan op de gast
7. Laad de driver in de gast

FPGA-virtualisatie
Om toegang tot een accelerator mogelijk te maken vanuit applicaties die op een VM draaien, moet de betreffende AFU-poort worden toegewezen aan een VF met behulp van de volgende stappen:

1. De PF is standaard eigenaar van alle AFU-poorten. Elke poort die opnieuw moet worden toegewezen aan een VF moet eerst worden vrijgegeven van de PF via de FPGA_FME_PORT_RELEASE ioctl op het FME-apparaat.
2. Zodra N-poorten zijn vrijgegeven van de PF, kan de onderstaande opdracht worden gebruikt om SRIOV en VF's in te schakelen. Elke VF bezit slechts één haven met AFU. echo N > PCI_DEVICE_PATH/sriov_numvfs
3. Geef de VF's door aan VM's.
4. De AFU onder VF is toegankelijk vanuit toepassingen in VM (met behulp van hetzelfde stuurprogramma binnen de VF).

Opmerking:
Een FME kan niet worden toegewezen aan een VF, dus PR en andere managementfuncties zijn alleen beschikbaar via de PF.

Chauffeur Organisatie

PCIe-module apparaatstuurprogramma

Chauffeur Organisatie

De FPGA-apparaten verschijnen als gewone PCIe-apparaten; het FPGA PCIe-apparaatstuurprogramma (intel-FPGA-PCI.ko) wordt dus altijd eerst geladen zodra een FPGA PCIe PF of VF wordt gedetecteerd. Deze driver speelt een infrastructurele rol in de driverarchitectuur. Het:

• Creëert een FPGA-containerapparaat als ouder van de functieapparaten.
• Loopt door de Device Feature List, die is geïmplementeerd in het PCIe-apparaat BAR-geheugen, om feature-apparaten en hun subfuncties te ontdekken en platformapparaten voor hen te maken onder het containerapparaat.
• Ondersteunt SR-IOV.
• Introduceert de feature-apparaatinfrastructuur, die bewerkingen voor subfuncties abstraheert en gemeenschappelijke functies blootlegt aan feature-apparaatstuurprogramma's.

Functies van stuurprogramma voor PCIe-module

• Bevat PCIe-detectie, apparaatopsomming en functiedetectie.
• Creëert sysfs-mappen voor het bovenliggende apparaat, FPGA Management Engine (FME) en Port.
• Creëert de platformstuurprogramma-instanties, waardoor de Linux-kernel de respectievelijke platformmodulestuurprogramma's laadt.

FME-platformmodule apparaatstuurprogramma

• Energie- en thermisch beheer, foutrapportage, prestatierapportage en andere infrastructuurfuncties. U hebt toegang tot deze functies via sysfs-interfaces die worden weergegeven door het FME-stuurprogramma.
• Gedeeltelijke herconfiguratie. Het FME-stuurprogramma registreert een FPGA-manager tijdens de initialisatie van de PR-subfunctie; zodra het een FPGA_FME_PORT_PR ioctl van u ontvangt, roept het de gemeenschappelijke interfacefunctie van FPGA Manager aan om de gedeeltelijke herconfiguratie van de bitstream naar de gegeven poort te voltooien.
• Havenbeheer voor virtualisatie. Het FME-stuurprogramma introduceert twee ioctls, FPGA_FME_PORT_RELEASE, die de gegeven poort vrijgeeft van PF; en FPGA_FME_PORT_ASSIGN, dat de poort terug aan PF toewijst. Zodra de poort is vrijgegeven door de PF, kan deze worden toegewezen aan de VF via de SR-IOV-interfaces die door het PCIe-stuurprogramma worden geleverd. Voor meer informatie raadpleegt u “FPGA-virtualisatie”.

FME-platformmodule Apparaatstuurprogrammafuncties

• Creëert het FME-tekenapparaatknooppunt.
• Creëert de FME-sysfs files en implementeert de FME sysfs file accessoires.
• Implementeert de FME-subdrivers voor privéfuncties.
• Subdrivers voor FME-privéfuncties:
  • FME-koptekst
  • Thermisch beheer
  • Energiebeheer
  • Globale fout
  • Gedeeltelijke herconfiguratie
  • Mondiale prestaties

Poortplatformmodule apparaatstuurprogramma
Net als bij het FME-stuurprogramma wordt het FPGA-poort- (en AFU-) stuurprogramma (intel-fpga-afu. ko) onderzocht zodra het poortplatformapparaat is gemaakt. De belangrijkste functie van deze module is het bieden van een interface voor toepassingen in de gebruikersruimte om toegang te krijgen tot de individuele versnellers, inclusief basisresetcontrole op poort, AFU MMIO-regio-export, DMA-buffertoewijzingsservice, UMsg(1)-melding en functies voor foutopsporing op afstand ( zie hierboven).

UMsg wordt alleen ondersteund via Acceleration Stack voor Intel Xeon®-processor met geïntegreerde FPGA.

Poortplatformmodule Apparaatstuurprogrammafuncties

• Creëert het poorttekenapparaatknooppunt.
• Creëert de poort sysfs files en implementeert de poort sysfs file accessoires.
• Implementeert de subdrivers voor de privéfunctie van Port.
• Sub-stuurprogramma's voor privéfuncties van poorten:
  • Poortkop
  • AFU
  • Poortfout
  • UMsg(2)
  • Signaal tik

Toepassing FPGA-apparaatopsomming
In deze sectie wordt geïntroduceerd hoe toepassingen het FPGA-apparaat opsommen uit de sysfs-hiërarchie onder /sys/class/fpga. In de exampHieronder zijn twee Intel FPGA-apparaten op de host geïnstalleerd. Elk FPGA-apparaat heeft één FME en twee poorten (AFU's). Voor elk FPGA-apparaat wordt een apparaatmap aangemaakt onder /sys/class/fpga:

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

Elk knooppunt heeft één FME en twee poorten (AFU's) als onderliggende apparaten:
/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

Over het algemeen worden de FME/Port sysfs-interfaces als volgt genoemd:
/sys/class/fpga/intel-fpga-dev.i/intel-fpga-fme.j/
/sys/class/fpga/intel-fpga-dev.i/intel-fpga-port.k/

waarbij I alle containerapparaten opeenvolgend nummert, j opeenvolgend de FME's nummert en k opeenvolgend alle poorten nummert.

Er kan naar de apparaatknooppunten die worden gebruikt voor ioctl() en mmap() worden verwezen via:
/dev/intel-fpga-fme.j
/dev/intel-fpga-port.k

PCIe-stuurprogramma-opsomming
Dit gedeelte geeft een overview van de codestroom voor apparaatopsomming uitgevoerd door intel-fpga-pci.ko. De belangrijkste datastructuren en functies worden gemarkeerd. Dit gedeelte kan het beste worden gevolgd wanneer viewmet de bijbehorende broncode (pcie.c).

Opsommingsgegevensstructuren

enum fpga_id_type {
OUDER ID,
FME_ID,
PORT_ID,
FPGA_ID_MAX
};
statische structuur-idr fpga_ids[FPGA_ID_MAX];
struct fpga_chardev_info {
const char * naam;
dev_t devt;
};
struct fpga_chardev_info fpga_chrdevs[] = {
{ .name = FPGA_FEATURE_DEV_FME },
{ .name = FPGA_FEATURE_DEV_PORT },
};
statische struct-klasse *fpga_class;
statische structuur 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,}
};
statische structuur pci_driver cci_pci_driver = {
.name = DRV_NAME,
.id_table = cci_pcie_id_tbl,
.probe = cci_pci_probe,
.verwijder = cci_pci_verwijder,
.sriov_configure = cci_pci_sriov_configure
};
struct cci_drvdata {
int apparaat_id;
struct-apparaat *fme_dev;
structuur mutex slot;
struct list_head port_dev_list;
int vrijgegeven_poort_num;
struct list_head-regio's;
};
struct build_feature_devs_info {
struct pci_dev *pdev;
ongeldig __iomem *ioaddr;
leegte __iomem *ioend;
int huidige_bar;
ongeldig __iomem *pfme_hdr;
struct-apparaat *parent_dev;
struct platform_apparaat *feature_dev;
};

Opsommingsstroom

• ccidrv_init()
  • Initialiseer fpga_ids met idr_init().
  • Initialiseer fpga_chrdevs[i].devt met alloc_chrdev_region().
  • Initialiseer fpga_class met class_create().
  • pci_register_driver(&cci_pci_driver);
• cci_pci_probe()
  • Schakel het PCI-apparaat in, vraag toegang tot de regio's, stel de PCI-mastermodus in en configureer DMA.
• cci_pci_create_feature_devs() build_info_alloc_and_init()
  • Wijs een struct build_feature_devs_info toe en initialiseer deze.
    .parent_dev is ingesteld op een bovenliggende sysfs-map (intel-fpga-dev.id) die de FME- en Port sysfs-mappen bevat.
• parse_feature_list()
  • Loop door de BAR0 Device Feature List om de FME, de poort en hun privéfuncties te ontdekken.
• parse_feature() parse_feature_afus() parse_feature_fme()
  • Wanneer een FME wordt aangetroffen:
• build_info_create_dev()
  • Wijs een platformapparaat toe voor de FME, en sla dit op in build_feature_devs_info.feature_dev.
  • feature_dev.id wordt geïnitialiseerd op het resultaat van idr_alloc(fpga_ids[FME_ID],
  • feature_dev.parent is ingesteld op build_feature_devs_info.parent_dev.
  • Wijs een array van struct-resources toe in feature_dev.resource.
• Wijs een struct feature_platform_data toe, initialiseer deze en sla een pointer op in feature_dev.dev.platform_data
  • create_feature_instance() build_info_add_sub_feature()
  • Initialiseer feature_dev.resource[FME_FEATURE_ID_HEADER].
  • feature_platform_data_add()
  • Initialiseer feature_platform_data.features[FME_FEATURE_ID_HEADER], alles behalve .fops.
• parse_feature() parse_feature_afus() parse_feature_port()
  • Wanneer een poort wordt aangetroffen:
• build_info_create_dev()
  • Wijs een platformapparaat toe voor de poort en sla dit op in build_feature_devs_info.feature_dev.
  • feature_dev.id wordt geïnitialiseerd op het resultaat van idr_alloc(fpga_ids[PORT_ID],
  • feature_dev.parent is ingesteld op build_feature_devs_info.parent_dev.
  • Wijs een array met struct-resources toe in feature_dev.resource.
  • Wijs een struct feature_platform_data toe, initialiseer deze en sla een pointer op in feature_dev.dev.platform_data
• build_info_commit_dev()
  • Voeg de struct feature_platform_data.node voor de poort toe aan de lijst met poorten in struct cci_drvdata.port_dev_list
• create_feature_instance() build_info_add_sub_feature()
  • Initialiseer feature_dev.resource[PORT_FEATURE_ID_HEADER].
• feature_platform_data_add()
  • Initialiseer feature_platform_data.features[PORT_FEATURE_ID_HEADER], alles behalve .fops.
• parse_feature() parse_feature_afus() parse_feature_port_uafu()
  • Wanneer een AFU wordt aangetroffen:
• create_feature_instance() build_info_add_sub_feature()
  • Initialiseer feature_dev.resource[PORT_FEATURE_ID_UAFU].
• feature_platform_data_add()
  • Initialiseer feature_platform_data.features[PORT_FEATURE_ID_UAFU], alles behalve .fops.
• parse_feature() parse_feature_private() parse_feature_fme_private()
  • Wanneer een FME-privéfunctie wordt aangetroffen:
• create_feature_instance() build_info_add_sub_feature()
  • Initialiseer feature_dev.resource[id].
• feature_platform_data_add()
  • Initialiseer feature_platform_data.features[id], alles behalve .fops.
• parse_feature() parse_feature_private() parse_feature_port_private()
• Wanneer een privé-functie van een poort wordt aangetroffen: * create_feature_instance() build_info_add_sub_feature() * Initialiseer feature_dev.resource[id]. * feature_platform_data_add() Initialiseer feature_platform_data.features[id], alles behalve .fops.
• parse_ports_from_fme()
  • Als de driver wordt geladen op de fysieke functie (PF), dan:
• Voer de parse_feature_list()-stroom uit op elke poort die wordt beschreven in de FME-header.
• Gebruik de BAR die vermeld staat in elk poortitem in de header.

Initialisatie van FME-platformapparaat
Dit gedeelte geeft een overview van de codestroom voor FME-apparaatinitialisatie uitgevoerd door intel-fpga-fme.ko. De belangrijkste datastructuren en functies zijn gemarkeerd. Dit gedeelte kan het beste worden gevolgd wanneer viewmet de bijbehorende broncode (fme-main.c).

FME-platformapparaatgegevensstructuren

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 feature *feature,
unsigned int cmd, unsigned long arg);
int (*test)(struct platform_device *pdev, struct feature *feature);
};
struct-functie {
const char * naam;
int resource_index;
ongeldig __iomem *ioaddr;
struct feature_ops *ops;
};
struct feature_platform_data {
struct list_head knooppunt;
structuur mutex slot;
niet-ondertekende lange dev_status;
struct cdev cdev;
struct platform_apparaat *dev;
niet-ondertekende int Disable_count;
ongeldig *privé;
int getal;
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 *)); structureren
functiekenmerken[0];
};
struct perf_object {
int-id;
const struct attribuut_groep **attr_groups;
struct-apparaat *fme_dev;
struct list_head knooppunt;
struct list_head kinderen;
struct kobject kobj;
};
struct fpga_fme {
u8 poort_id;
u64 pr_err;
struct-apparaat *dev_err;
struct perf_object *perf_dev;
struct feature_platform_data *pdata;
};

FME-platform apparaatinitialisatiestroom

FME-initialisatiestroom

• fme_probe() fme_dev_init()
  • Initialiseer een struct fpga_fme en sla deze op in het feature_platform_data.private veld.
• fme_probe() fpga_dev_feature_init() feature_instance_init()
  • Sla een struct feature_ops op in feature_platform_data.features voor elke ingevulde feature.
  • Roep de testfunctie, indien aanwezig, aan vanuit de struct.
  • Roep de init-functie aan vanuit de struct.
• fme_probe() fpga_register_dev_ops()
  • Maak het FME-tekenapparaatknooppunt en registreer een struct file_activiteiten.

Initialisatie van poortplatformapparaat
Dit gedeelte geeft een overview van de codestroom voor poortapparaatinitialisatie uitgevoerd door intel-fpga-afu.ko. De belangrijkste datastructuren en functies worden gemarkeerd. Dit gedeelte kan het beste worden gevolgd wanneer viewmet de bijbehorende broncode (afu.c).

Gegevensstructuren van poortplatformapparaten

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 feature *feature,
unsigned int cmd, unsigned long arg);
int (*test)(struct platform_device *pdev, struct feature *feature);
};
struct-functie {
const char * naam;
int resource_index;
ongeldig __iomem *ioaddr;
struct feature_ops *ops;
};
struct feature_platform_data {
struct list_head knooppunt;
structuur mutex slot;
niet-ondertekende lange dev_status;
struct cdev cdev;
struct platform_apparaat *dev;
niet-ondertekende int Disable_count;
ongeldig *privé;
int getal;
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-functiefuncties [0];
};
struct fpga_afu_region {
u32-index;
u32 vlaggen;
u64 maat;
u64-verschuiving;
u64 fysio;
struct list_head knooppunt;
};
struct fpga_afu_dma_region {
u64 gebruiker_adres;
u64 lengte;
u64 iova;
struct pagina **pagina's;
struct rb_node knooppunt;
bool in_use;
};
struct fpga_afu {
u64 regio_cur_offset;
int aantal_regio's;
u8 aantal_umsgs;
struct list_head-regio's;
struct rb_root dma_regions;
struct feature_platform_data *pdata;
};

Initialisatiestroom van poortplatformapparaat

Poortinitialisatiestroom

• afu_probe() afu_dev_init()
  • Initialiseer een struct fpga_afu en sla deze op in het feature_platform_data.private veld.
• afu_probe() fpga_dev_feature_init() feature_instance_init()
  • Sla een struct feature_ops op in feature_platform_data.features voor elke ingevulde feature.
  • Roep de testfunctie, indien aanwezig, aan vanuit de struct.
  • Roep de init-functie aan vanuit de struct.
• afu_probe() fpga_register_dev_ops()
  • Maak het poorttekenapparaatknooppunt en registreer een struct file_activiteiten.

FME IOCTL's
IOCTL's die worden aangeroepen op een open file descriptor voor /dev/intel-fpga-fme.j FPGA_GET_API_VERSION: retourneert de huidige versie als een geheel getal, beginnend bij 0.

FPGA_CHECK_EXTENSION: momenteel niet ondersteund.

FPGA_FME_PORT_RELEASE—arg is een verwijzing naar een:

struct fpga_fme_port_release {
__u32 argsz; // in: sizeof(struct fpga_fme_port_release)
__u32 vlaggen; // in: moet 0 zijn
__u32 poort_id; // in: poort-ID (van 0) naar release.
};

FPGA_FME_PORT_ASSIGN—arg is een verwijzing naar een:

struct fpga_fme_port_assign {
__u32 argsz; // in: sizeof(struct fpga_fme_port_assign)
__u32 vlaggen; // in: moet 0 zijn
__u32 poort_id; // in: poort-ID (vanaf 0) om toe te wijzen. (moet geweest zijn
eerder uitgebracht door FPGA_FME_PORT_RELEASE)
};

FPGA_FME_PORT_PR—arg is een verwijzing naar een:

struct fpga_fme_port_pr {
__u32 argsz; // in: sizeof(struct fpga_fme_port_pr)
__u32 vlaggen; // in: moet 0 zijn
__u32 poort_id; // in: poort-ID (vanaf 0)
__u32 buffergrootte; // in: grootte van bitstreambuffer in bytes. Moet 4 bytes zijn
uitgelijnd.
__u64 bufferadres; // in: procesadres van bitstreambuffer
__u64-status; // uit: foutstatus (bitmask)
};

Poort IOCTL's
IOCTL's die worden aangeroepen op een open file descriptor voor /dev/intel-fpga-port.k FPGA_GET_API_VERSION: retourneert de huidige versie als een geheel getal, beginnend bij 0. FPGA_CHECK_EXTENSION: momenteel niet ondersteund.

FPGA_PORT_GET_INFO—arg is een verwijzing naar een:

struct fpga_port_info {
__u32 argsz; // in: sizeof(struct fpga_port_info)
__u32 vlaggen; // uit: retourneert 0
__u32 aantal_regio's; // out: aantal MMIO-regio's, 2 (1 voor AFU en 1 voor
STP)
__u32 aantal_umsgs; // out: aantal UMsg's ondersteund door de hardware
};

FPGA_PORT_GET_REGION_INFO—arg is een verwijzing naar een:

struct fpga_port_region_info {
__u32 argsz; // in: sizeof(struct fpga_port_region_info)
__u32 vlaggen; // uit: (bitmasker) { FPGA_REGION_READ, FPGA_REGION_WRITE,
FPGA_REGION_MMAP }
__u32-index; // in: FPGA_PORT_INDEX_UAFU of FPGA_PORT_INDEX_STP
__u32 opvulling; // in: moet 0 zijn
__u64 maat; // out: grootte van de MMIO-regio in bytes
__u64 verschuiving; // out: offset van MMIO-regio vanaf het begin van apparaat fd
};

FPGA_PORT_DMA_MAP—arg is een verwijzing naar een:
struct fpga_port_dma_map {
__u32 argsz; // in: sizeof(struct fpga_port_dma_map)
__u32 vlaggen; // in: moet 0 __u64 user_addr zijn; // in: virtueel verwerken
adres. Moet pagina-uitgelijnd zijn.
__u64 lengte; // in: lengte van de mapping in bytes. Moet een veelvoud van pagina's zijn
maat.
__u64 iova; // uit: virtueel IO-adres };

FPGA_PORT_DMA_UNMAP—arg is een verwijzing naar een:
struct fpga_port_dma_unmap {
__u32 argsz; // in: sizeof(struct fpga_port_dma_unmap)
__u32 vlaggen; // in: moet 0 zijn
__u64 iova; // in: virtueel IO-adres geretourneerd door een vorig
FPGA_PORT_DMA_MAP };

• FPGA_PORT_RESET: arg moet NULL zijn.
• FPGA_PORT_UMSG_ENABLE: arg moet NULL zijn.
• FPGA_PORT_UMSG_DISABLE: argumenten moeten NULL zijn.

FPGA_PORT_UMSG_SET_MODE: arg is een verwijzing naar een:

struct fpga_port_umsg_cfg {
__u32 argsz; // in: sizeof(struct fpga_port_umsg_cfg)
__u32 vlaggen; // in: moet 0 zijn
__u32 hint_bitmap; // in: bitmap in UMsg-hintmodus. Geeft aan welke UMsg's zijn
ingeschakeld.
};

FPGA_PORT_UMSG_SET_BASE_ADDR—

• UMsg moet worden uitgeschakeld voordat dit ioctl wordt uitgegeven.
• Het iova-veld moet een buffer zijn die groot genoeg is voor alle UMsg's (num_umsgs * PAGE_SIZE).
  • De buffer wordt door het bufferbeheer van de chauffeur gemarkeerd als “in gebruik”.
  • Als iova NULL is, wordt elke voorgaande regio niet gemarkeerd als "in gebruik".
• arg is een verwijzing naar een:
  struct fpga_port_umsg_base_addr {
  • u32 argsz; // in: sizeof(struct fpga_port_umsg_base_addr)
  • u32 vlaggen; // in: moet 0 zijn
  • u64 iova; // in: virtueel IO-adres van FPGA_PORT_DMA_MAP. };

Opmerking:

• Om de poortfouten te wissen, moet u bijvoorbeeld het exacte bitmasker van de huidige fouten schrijvenample, kattenfouten> duidelijk
• UMsg wordt alleen ondersteund via Acceleration Stack voor Intel Xeon-processor met geïntegreerde FPGA.

sysfs Files

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

sysfs file	mmio-veld	type	toegang
poorten_num	fme_header.capability.num_ports	decimaal int	Alleen-lezen
cache_grootte	fme_header.capability.cache_size	decimaal int	Alleen-lezen
versie	fme_header.capability.fabric_verid	decimaal int	Alleen-lezen
socket_id	fme_header.capability.socket_id	decimaal int	Alleen-lezen
bitstream_id	fme_header.bitstream_id	hex uint64_t	Alleen-lezen
bitstream_metadata	fme_header.bitstream_md	hex uint64_t	Alleen-lezen

FME Thermisch Management systeem files
intel-fpga-dev.i/intel-fpga-fme.j/thermal_mgmt/

sysfs file	mmio-veld	type	toegang
drempel1	thermische.drempel.tmp_thshold1	decimaal int	Gebruiker: Alleen-lezen Root: Lezen-schrijven
drempel2	thermische.drempel.tmp_thshold2	decimaal int	Gebruiker: Alleen-lezen Root: Lezen-schrijven
drempel_reis	thermische.drempel.therm_trip_thshold	decimaal int	Alleen-lezen
drempel1_bereikt	thermische.drempel.thshold1_status	decimaal int	Alleen-lezen
drempel2_bereikt	thermische.drempel.thshold2_status	decimaal int	Alleen-lezen
drempel1_beleid	thermisch. drempel.thshold_policy	decimaal int	Gebruiker: Alleen-lezen Root: Lezen-schrijven
temperatuur	thermische.rdsensor_fm1.fpga_temp	decimaal int	Alleen-lezen

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

sysfs file	mmio-veld	type	toegang
verbruikt	power.status.pwr_consumed	hex uint64_t	Alleen-lezen
drempel1	vermogensdrempel.drempel1	hex uint64_t	Gebruiker: Alleen-lezen Root: Lezen-schrijven
drempel2	vermogensdrempel.drempel2	hex uint64_t	Gebruiker: Alleen-lezen Root: Lezen-schrijven
drempel1_status	power.threshold.threshold1_status	decimaal niet ondertekend	Alleen-lezen
drempel2_status	power.threshold.threshold2_status	decimaal niet ondertekend	Alleen-lezen
rtl	power.status.fpga_latency_report	decimaal niet ondertekend	Alleen-lezen

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

sysfs file	mmio-veld	type	toegang
pcie0_fouten	gerror.pcie0_err	hex uint64_t	Lezen schrijven
pcie1_fouten	gerror.pcie1_err	hex uint64_t	Lezen schrijven
inject_fout	gerror.ras_error_inj	hex uint64_t	Lezen schrijven

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

sysfs file	mmio-veld	type	toegang
fouten	gerror.fme_err	hex uint64_t	Alleen-lezen
eerste_fout	gerror.fme_first_err.err_reg_status	hex uint64_t	Alleen-lezen
volgende_fout	gerror.fme_next_err.err_reg_status	hex uint64_t	Alleen-lezen
duidelijk	Wist fouten, eerste_fout, volgende_fout	verschillende uint64_t	Alleen schrijven

Opmerking:
Om de FME-fouten te wissen, moet u bijvoorbeeld het exacte bitmasker van de huidige fouten schrijvenample cat-fouten> duidelijk.

FME Gedeeltelijke herconfiguratie sysfs files
intel-fpga-dev.i/intel-fpga-fme.j/pr/

sysfs file	mmio-veld	type	toegang
interface_id	pr.fme_pr_intfc_id0_h, pr.fme_pre_intfc_id0_l	hexadecimaal 16 bytes	Alleen-lezen

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

sysfs file	mmio-veld	type	toegang
klok	gperf.clk.afu_interf_clock	hex uint64_t	Alleen-lezen

intel-fpga-dev.i/intel-fpga-fme.j/dperf/cache/ (Niet geldig voor Acceleration Stack voor Intel Xeon CPU met FPGA's)

sysfs file	mmio-veld	type	toegang
bevriezen	gperf.ch_ctl.freeze	decimaal int	Lezen schrijven
lees_hit	gperf.CACHE_RD_HIT	hex uint64_t	Alleen-lezen
lees_miss	gperf.CACHE_RD_MISS	hex uint64_t	Alleen-lezen
schrijf_hit	gperf.CACHE_WR_HIT	hex uint64_t	Alleen-lezen
schrijf_miss	gperf.CACHE_WR_MISS	hex uint64_t	Alleen-lezen
hold_request	gperf.CACHE_HOLD_REQ	hex uint64_t	Alleen-lezen
tx_req_stall	gperf.CACHE_TX_REQ_STALL	hex uint64_t	Alleen-lezen

sysfs file	mmio-veld	type	toegang
rx_req_stall	gperf.CACHE_RX_REQ_STALL	hex uint64_t	Alleen-lezen
data_write_port_conflict	gperf.CACHE_DATA_WR_PORT_CONTEN	hex uint64_t	Alleen-lezen
tag_write_port_conflict	gperf.CACHE_TAG_WR_PORT_CONTEN	hex uint64_t	Alleen-lezen

intel-fpga-dev.i/intel-fpga-fme.j/dperf/iommu/ (Niet geldig voor Acceleration Stack voor Intel Xeon CPU met FPGA's)

sysfs file	mmio-veld	type	toegang
bevriezen	gperf.vtd_ctl.freeze	decimaal int	Gebruiker: Alleen-lezen Root: Lezen-schrijven

intel-fpga-dev.i/intel-fpga-fme.j/dperf/iommu/afuk/ (Niet geldig voor Acceleration Stack voor Intel Xeon CPU met FPGA's)

sysfs file	mmio-veld	type	toegang
lees_transactie	gperf.VTD_AFU0_MEM_RD_TRANS	hex uint64_t	Alleen-lezen
schrijf_transactie	gperf.VTD_AFU0_MEM_WR_TRANS	hex uint64_t	Alleen-lezen
tlb_read_hit	gperf.VTD_AFU0_TLB_RD_HIT	hex uint64_t	Alleen-lezen
tlb_write_hit	gperf.VTD_AFU0_TLB_WR_HIT	hex uint64_t	Alleen-lezen

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

sysfs file	mmio-veld	type	toegang
inschakelen	gperf.fab_ctl.(ingeschakeld)	decimaal int	Gebruiker: Alleen-lezen Root: Lezen-schrijven
bevriezen	gperf.fab_ctl.freeze	decimaal int	Gebruiker: Alleen-lezen Root: Lezen-schrijven
pcie0_lezen	gperf.FAB_PCIE0_RD	hex uint64_t	Alleen-lezen
pcie0_write	gperf.FAB_PCIE0_WR	hex uint64_t	Alleen-lezen
pcie1_lezen	gperf.FAB_PCIE1_RD	hex uint64_t	Alleen-lezen
pcie1_write	gperf.FAB_PCIE1_WR	hex uint64_t	Alleen-lezen
upi_lezen	gperf.FAB_UPI_RD	hex uint64_t	Alleen-lezen
upi_write	gperf.FAB_UPI_WR	hex uint64_t	Alleen-lezen

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

sysfs file	mmio-veld	type	toegang
pcie0_lezen	gperf.FAB_PCIE0_RD	hex uint64_t	Alleen-lezen
pcie0_write	gperf.FAB_PCIE0_WR	hex uint64_t	Alleen-lezen
pcie1_lezen	gperf.FAB_PCIE1_RD	hex uint64_t	Alleen-lezen
pcie1_write	gperf.FAB_PCIE1_WR	hex uint64_t	Alleen-lezen
upi_lezen	gperf.FAB_UPI_RD	hex uint64_t	Alleen-lezen
upi_write	gperf.FAB_UPI_WR	hex uint64_t	Alleen-lezen

Poortheader sysfs files
intel-fpga-dev.i/intel-fpga-port.k/

sysfs file	mmio-veld	type	toegang
id	poort_header.capability.poort_nummer	decimaal int	Alleen-lezen
ltr	port_header.control.latency_tolerance	decimaal int	Alleen-lezen

Poort AFU-header sysfs files
intel-fpga-dev.i/intel-fpga-port.k/

sysfs file	mmio-veld	type	toegang
afu_id	afu_header.guid	hexadecimaal 16 bytes	Alleen-lezen

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

sysfs file	mmio-veld	type	toegang
fouten	perror.port_error	hex uint64_t	Alleen-lezen
eerste_fout	perror.port_first_error	hex uint64_t	Alleen-lezen
eerste_misvormde_req	perror.malreq	hexadecimaal 16 bytes	Alleen-lezen
duidelijk	perr.(alle fouten)	verschillende uint64_t	Alleen schrijven

Opmerking:
Om de poortfouten te wissen, moet u bijvoorbeeld het exacte bitmasker van de huidige fouten schrijvenample cat-fouten> duidelijk.

Revisiegeschiedenis

Documentversie	Wijzigingen
2017.10.02	Eerste release.

OPAE Intel FPGA Linux Architectuurgids voor apparaatstuurprogramma's

Documenten / Bronnen

Intel OPAE FPGA Linux-apparaatstuurprogramma-architectuur [pdf] Gebruikershandleiding OPAE FPGA Linux-apparaatstuurprogramma-architectuur, OPAE FPGA, Linux-apparaatstuurprogramma-architectuur, stuurprogramma-architectuur, architectuur

Referenties

• Gebruiksaanwijzing