intel OPAE FPGA Linux įrenginio tvarkyklės architektūra

OPAE Intel FPGA Linux įrenginio tvarkyklės architektūra

OPAE Intel FPGA tvarkyklė suteikia sąsajas vartotojo erdvėje esančioms programoms, skirtas konfigūruoti, išvardyti, atidaryti ir pasiekti FPGA spartintuvus platformose, kuriose įrengti Intel FPGA sprendimai, ir įgalina sistemos lygio valdymo funkcijas, tokias kaip FPGA perkonfigūravimas, maitinimo valdymas ir virtualizavimas.

Aparatinės įrangos architektūra

Iš OS pusės viewFPGA aparatinė įranga atrodo kaip įprastas PCIe įrenginys. FPGA įrenginio atmintis tvarkoma naudojant iš anksto nustatytą duomenų struktūrą (įrenginių funkcijų sąrašą). Funkcijos, kurias palaiko FPGA įrenginys, rodomos per šias duomenų struktūras, kaip parodyta toliau esančiame paveikslėlyje:

FPGA PCIe įrenginys

Vairuotojas palaiko PCIe SR-IOV, kad sukurtų virtualias funkcijas (VF), kurias galima naudoti norint priskirti atskirus greitintuvus virtualioms mašinoms.

Intel korporacija. Visos teisės saugomos. „Intel“, „Intel“ logotipas ir kiti „Intel“ ženklai yra „Intel Corporation“ arba jos dukterinių įmonių prekių ženklai. „Intel“ garantuoja savo FPGA ir puslaidininkinių produktų veikimą pagal dabartines specifikacijas pagal standartinę „Intel“ garantiją, tačiau pasilieka teisę bet kuriuo metu be įspėjimo keisti bet kokius gaminius ir paslaugas. „Intel“ neprisiima jokios atsakomybės ar įsipareigojimų, kylančių dėl bet kokios čia aprašytos informacijos, produkto ar paslaugos taikymo ar naudojimo, išskyrus atvejus, kai „Intel“ aiškiai sutiko raštu. „Intel“ klientams patariama įsigyti naujausią įrenginio specifikacijų versiją prieš pasikliaujant bet kokia paskelbta informacija ir prieš užsakant produktus ar paslaugas.

Kiti pavadinimai ir prekės ženklai gali būti laikomi kitų nuosavybe.

Virtualizuotas FPGA PCIe įrenginys

FPGA valdymo variklis (FME)
FPGA valdymo variklis atlieka galios ir šilumos valdymą, klaidų ataskaitų teikimą, perkonfigūravimą, našumo ataskaitas ir kitas infrastruktūros funkcijas. Kiekvienas FPGA turi vieną FME, kuris visada pasiekiamas per fizinę funkciją (PF). Vartotojo erdvės programos gali įgyti išskirtinę prieigą prie FME naudodami open() ir išleisti ją naudodami close() kaip privilegijuotas vartotojas (root).

Uostas
Prievadas yra sąsaja tarp statinio FPGA audinio („FPGA sąsajos tvarkyklė (FIM)“) ir iš dalies perkonfigūruojamos srities, kurioje yra greitintuvo funkcija (AF). Prievadas valdo ryšį iš programinės įrangos į greitintuvą ir atskleidžia tokias funkcijas kaip nustatymas iš naujo ir derinimas. PCIe įrenginys gali turėti kelis prievadus, o kiekvienas prievadas gali būti atskleistas per VF, priskiriant jį naudojant FME įrenginio FPGA_FME_PORT_ASSIGN ioctl.

Akceleratoriaus funkcijos (AF) blokas

• Greitintuvo funkcijos (AF) blokas yra prijungtas prie prievado ir atskleidžia 256K MMIO sritį, kuri bus naudojama konkretiems greitintuvo valdymo registrams.
• Naudotojo erdvės programos gali įgyti išskirtinę prieigą prie AFU, prijungtos prie prievado, naudodami open() prievado įrenginyje, ir atleisti ją naudodami close ().
• Vartotojo erdvės programos taip pat gali mmap() spartintuvo MMIO regionus.

Dalinis perkonfigūravimas
Kaip minėta aukščiau, greitintuvus galima perkonfigūruoti iš dalies perkonfigūruojant greitintuvo funkciją (AF). file. Greitinimo funkcija (AF) turi būti sukurta tiksliai FIM ir tikslinei FPGA statinei sričiai (prievadui); Priešingu atveju perkonfigūravimo operacija nepavyks ir gali sukelti sistemos nestabilumą. Šį suderinamumą galima patikrinti lyginant sąsajos ID, nurodytą AF antraštėje, su sąsajos ID, kurį FME atskleidžia per sysfs. Šį patikrinimą paprastai atlieka vartotojo erdvė prieš iškviečiant perkonfigūraciją IOCTL.

Pastaba:
Šiuo metu bet kokia programinė įranga, pasiekianti FPGA, įskaitant tas, kurios veikia virtualizuotame pagrindiniame kompiuteryje, turi būti uždarytos prieš bandant iš dalies pakeisti konfigūraciją. Žingsniai būtų tokie:

1. Iškrauti vairuotoją iš svečio
2. Atjunkite VF nuo svečio
3. Išjungti SR-IOV
4. Atlikite dalinį konfigūravimą
5. Įgalinti SR-IOV
6. Prijunkite VF prie svečio
7. Įkelkite vairuotoją į svečią

FPGA virtualizavimas
Kad būtų galima pasiekti greitintuvą iš programų, veikiančių VM, atitinkamas AFU prievadas turi būti priskirtas VF, atliekant šiuos veiksmus:

1. Pagal numatytuosius nustatymus PF priklauso visi AFU prievadai. Bet koks prievadas, kurį reikia iš naujo priskirti VF, pirmiausia turi būti atlaisvintas iš PF per FME įrenginio FPGA_FME_PORT_RELEASE ioctl.
2. Kai iš PF atleidžiamas N prievadas, toliau pateikta komanda gali būti naudojama SRIOV ir VF įjungti. Kiekvienam VF priklauso tik vienas prievadas su AFU. echo N > PCI_DEVICE_PATH/sriov_numvfs
3. Per VF į VM.
4. AFU pagal VF pasiekiamas iš programų VM (naudojant tą pačią tvarkyklę VF viduje).

Pastaba:
FME negalima priskirti VF, todėl PR ir kitos valdymo funkcijos pasiekiamos tik per PF.

Vairuotojų organizacija

PCIe modulio įrenginio tvarkyklė

Vairuotojų organizacija

FPGA įrenginiai atrodo kaip įprasti PCIe įrenginiai; taigi, aptikus FPGA PCIe PF arba VF, FPGA PCIe įrenginio tvarkyklė (intel-FPGA-PCI.ko) visada įkeliama pirmiausia. Ši tvarkyklė vaidina infrastruktūrinį vaidmenį tvarkyklės architektūroje. Tai:

• Sukuria FPGA konteinerio įrenginį kaip pagrindinį funkcijų įrenginių.
• Eikite per įrenginių funkcijų sąrašą, kuris yra įdiegtas PCIe įrenginio BAR atmintyje, kad atrastų funkcijų įrenginius ir jų papildomas funkcijas ir sukurtų jiems platforminius įrenginius po konteinerio įrenginiu.
• Palaiko SR-IOV.
• Pristato funkcijų įrenginio infrastruktūrą, kuri abstrahuoja antrinių funkcijų operacijas ir atskleidžia bendras funkcijas funkcijų įrenginių tvarkyklėms.

PCIe modulio įrenginio tvarkyklės funkcijos

• Yra PCIe atradimas, įrenginių sąrašas ir funkcijų atradimas.
• Sukuria sysfs katalogus pirminiam įrenginiui, FPGA valdymo moduliui (FME) ir prievadui.
• Sukuria platformos tvarkyklės egzempliorius, todėl Linux branduolys įkelia atitinkamas platformos modulio tvarkykles.

FME platformos modulio įrenginio tvarkyklė

• Galios ir šilumos valdymas, klaidų ataskaitų teikimas, našumo ataskaitos ir kitos infrastruktūros funkcijos. Šias funkcijas galite pasiekti per sysf sąsajas, kurias atskleidžia FME tvarkyklė.
• Dalinis perkonfigūravimas. FME tvarkyklė registruoja FPGA tvarkyklę PR antrinės funkcijos inicijavimo metu; gavęs iš jūsų FPGA_FME_PORT_PR ioctl, jis iškviečia bendrą sąsajos funkciją iš FPGA tvarkyklės, kad užbaigtų dalinį bitų srauto perkonfigūravimą į nurodytą prievadą.
• Prievado valdymas virtualizavimui. FME tvarkyklė pristato du ioctls, FPGA_FME_PORT_RELEASE, kurie išlaisvina nurodytą prievadą iš PF; ir FPGA_FME_PORT_ASSIGN, kuris grąžina prievadą PF. Kai prievadas atleidžiamas iš PF, jį galima priskirti VF per PCIe tvarkyklės pateiktas SR-IOV sąsajas. Daugiau informacijos rasite „FPGA virtualizavimas“.

FME platformos modulio įrenginio tvarkyklės funkcijos

• Sukuria FME simbolio įrenginio mazgą.
• Sukuria FME sysfs files ir įgyvendina FME sysfs file priedai.
• Įdiegia FME privačių funkcijų antrinius tvarkykles.
• FME privačių funkcijų antrinės tvarkyklės:
  • FME antraštė
  • Šilumos valdymas
  • Energijos valdymas
  • Visuotinė klaida
  • Dalinis perkonfigūravimas
  • Pasaulinis našumas

Prievado platformos modulio įrenginio tvarkyklė
Panašiai kaip ir FME tvarkyklė, FPGA prievado (ir AFU) tvarkyklė (intel-fpga-afu. ko) tikrinama, kai sukuriamas prievado platformos įrenginys. Pagrindinė šio modulio funkcija yra suteikti sąsają vartotojo erdvės programoms pasiekti atskirus greitintuvus, įskaitant pagrindinį prievado atstatymo valdymą, AFU MMIO regiono eksportą, DMA buferio susiejimo paslaugą, UMsg(1) pranešimus ir nuotolinio derinimo funkcijas ( pažiūrėkite aukščiau).

UMsg palaikoma tik naudojant „Intel Xeon®“ procesoriaus su integruotu FPGA „Acceleration Stack“.

Prievado platformos modulio įrenginio tvarkyklės funkcijos

• Sukuria prievado simbolio įrenginio mazgą.
• Sukuria prievadą sysfs files ir įgyvendina Port sysfs file priedai.
• Įdiegia prievado privačių funkcijų antrines tvarkykles.
• Prievado privačios funkcijos antrinės tvarkyklės:
  • Prievado antraštė
  • AFU
  • Prievado klaida
  • UMsg(2)
  • Signalo bakstelėjimas

Taikymas FPGA įrenginių išvardijimas
Šiame skyriuje aprašoma, kaip programos išvardija FPGA įrenginį iš sysfs hierarchijos, esančios /sys/class/fpga. BuvusiojeampŽemiau esančiame pagrindiniame kompiuteryje yra įdiegti du „Intel FPGA“ įrenginiai. Kiekvienas FPGA įrenginys turi vieną FME ir du prievadus (AFU). Kiekvienam FPGA įrenginiui /sys/class/fpga sukuriamas įrenginių katalogas:

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

Kiekvienas mazgas turi vieną FME ir du prievadus (AFU) kaip antrinius įrenginius:
/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

Apskritai FME/Port sysfs sąsajos pavadintos taip:
/sys/class/fpga/intel-fpga-dev.i/intel-fpga-fme.j/
/sys/class/fpga/intel-fpga-dev.i/intel-fpga-port.k/

I nuosekliai sunumeruojant visus konteinerio įrenginius, j iš eilės numeruojant FME ir k iš eilės numeruojant visus prievadus.

Įrenginio mazgus, naudojamus ioctl() ir mmap(), galima nurodyti naudojant:
/dev/intel-fpga-fme.j
/dev/intel-fpga-port.k

PCIe tvarkyklės sąrašas
Šiame skyriuje pateikiama peržiūraview intel-fpga-pci.ko atliekamo įrenginių surašymo kodo srauto. Paryškintos pagrindinės duomenų struktūros ir funkcijos. Šį skyrių geriausia sekti, kai viewkartu su šaltinio kodu (pcie.c).

Sąrašų duomenų struktūros

enum fpga_id_type {
PARENT_ID,
FME_ID,
PORT_ID,
FPGA_ID_MAX
};
statinė struktūra idr fpga_ids[FPGA_ID_MAX];
struct fpga_chardev_info {
const char *vardas;
dev_t devt;
};
struct fpga_chardev_info fpga_chrdevs[] = {
{ .name = FPGA_FEATURE_DEV_FME },
{ .name = FPGA_FEATURE_DEV_PORT },
};
statinės struktūros klasė *fpga_class;
statinė struktūra 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,}
};
statinė struktūra 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 įrenginio_id;
struct įrenginys *fme_dev;
struct mutex lock;
struct list_head port_dev_list;
int išleistas_porto numeris;
struct list_head regions;
};
struct build_feature_devs_info {
struct pci_dev *pdev;
negalioja __iomem *ioaddr;
negalioja __iomem *ioend;
int current_bar;
negalioja __iomem *pfme_hdr;
struct įrenginys *parent_dev;
struct platform_device *feature_dev;
};

Surašymo srautas

• ccidrv_init()
  • Inicijuoti fpga_ids naudodami idr_init().
  • Inicijuoti fpga_chrdevs[i].devt naudodami alloc_chrdev_region().
  • Inicijuoti fpga_class naudodami class_create().
  • pci_register_driver(&cci_pci_driver);
• cci_pci_probe()
  • Įgalinkite PCI įrenginį, paprašykite prieigos prie jo regionų, nustatykite pagrindinį PCI režimą ir sukonfigūruokite DMA.
• cci_pci_create_feature_devs() build_info_alloc_and_init()
  • Paskirkite struktūrą build_feature_devs_info, inicijuokite ją.
    .parent_dev yra nustatytas į pirminį sysfs katalogą (intel-fpga-dev.id), kuriame yra FME ir Port sysfs katalogai.
• parse_feature_list()
  • Eikite per BAR0 įrenginių funkcijų sąrašą, kad sužinotumėte FME, prievadą ir jų privačias funkcijas.
• parse_feature() parse_feature_afus() parse_feature_fme()
  • Kai susiduriama su FME:
• build_info_create_dev()
  • Priskirkite platformos įrenginį FME, saugomą adresu build_feature_devs_info.feature_dev.
  • feature_dev.id inicijuojamas pagal idr_alloc(fpga_ids[FME_ID] rezultatą,
  • feature_dev.parent nustatytas į build_feature_devs_info.parent_dev.
  • Paskirkite struktūrinių išteklių masyvą funkcija_dev.resource.
• Paskirkite struktūrą feature_platform_data, inicijuokite ją ir išsaugokite žymeklį feature_dev.dev.platform_data
  • Create_feature_instance() build_info_add_sub_feature()
  • Inicijuoti feature_dev.resource[FME_FEATURE_ID_HEADER].
  • feature_platform_data_add()
  • Inicijuoti feature_platform_data.features[FME_FEATURE_ID_HEADER], viską, išskyrus .fops.
• parse_feature() parse_feature_afus() parse_feature_port()
  • Kai aptinkamas prievadas:
• build_info_create_dev()
  • Prievadui priskirkite platformos įrenginį, saugomą adresu build_feature_devs_info.feature_dev.
  • feature_dev.id inicijuojamas pagal idr_alloc(fpga_ids[PORT_ID] rezultatą,
  • feature_dev.parent nustatytas į build_feature_devs_info.parent_dev.
  • Paskirkite struktūrinių išteklių masyvą funkcija_dev.resource.
  • Paskirkite struktūrą feature_platform_data, inicijuokite ją ir išsaugokite žymeklį feature_dev.dev.platform_data
• build_info_commit_dev()
  • Pridėkite prievado struct feature_platform_data.node prie prievadų sąrašo struct cci_drvdata.port_dev_list
• Create_feature_instance() build_info_add_sub_feature()
  • Inicijuoti feature_dev.resource[PORT_FEATURE_ID_HEADER].
• feature_platform_data_add()
  • Inicijuoti feature_platform_data.features[PORT_FEATURE_ID_HEADER], viską, išskyrus .fops.
• parse_feature() parse_feature_afus() parse_feature_port_uafu()
  • Kai susiduriama su AFU:
• Create_feature_instance() build_info_add_sub_feature()
  • Inicijuoti feature_dev.resource[PORT_FEATURE_ID_UAFU].
• feature_platform_data_add()
  • Inicijuoti feature_platform_data.features[PORT_FEATURE_ID_UAFU], viską, išskyrus .fops.
• parse_feature() parse_feature_private() parse_feature_fme_private()
  • Kai susiduriama su FME privačia funkcija:
• Create_feature_instance() build_info_add_sub_feature()
  • Inicijuoti feature_dev.resource[id].
• feature_platform_data_add()
  • Inicijuoti feature_platform_data.features[id], viską, išskyrus .fops.
• parse_feature() parse_feature_private() parse_feature_port_private()
• Kai susiduriama su prievado privačia funkcija: * create_feature_instance() build_info_add_sub_feature() * Inicijuoti feature_dev.resource[id]. * feature_platform_data_add() Inicijuoti feature_platform_data.features[id], viskas, išskyrus .fops.
• parse_ports_from_fme()
  • Jei vairuotojas įkeltas į fizinę funkciją (PF), tada:
• Paleiskite parse_feature_list() srautą kiekviename prievade, aprašytame FME antraštėje.
• Naudokite BAR, nurodytą kiekviename prievado įraše antraštėje.

FME platformos įrenginio inicijavimas
Šiame skyriuje pateikiama peržiūraview kodo srauto FME įrenginio inicijavimui, kurį atlieka intel-fpga-fme.ko. Paryškintos pagrindinės duomenų struktūros ir funkcijos. Šį skyrių geriausia sekti, kai viewkartu su šaltinio kodu (fme-main.c).

FME platformos įrenginio duomenų struktūros

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 funkcija *funkcija,
unsigned int cmd, unsigned long arg);
int (*testas)(struct platform_device *pdev, struct feature *feature);
};
struct funkcija {
const char *vardas;
int išteklių_indeksas;
negalioja __iomem *ioaddr;
struct feature_ops *ops;
};
struct feature_platform_data {
struct list_head mazgas;
struct mutex lock;
nepasirašytas ilgas dev_status;
struct cdev cdev;
struct platform_device *dev;
nepasirašytas int disable_count;
negaliojantis *privatus;
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 *)); struktūra
funkcijų savybės[0];
};
struct perf_object {
int id;
const struct atributo_grupė **attr_groups;
struct įrenginys *fme_dev;
struct list_head mazgas;
struct list_head vaikai;
struct kobject kobj;
};
struct fpga_fme {
u8 port_id;
u64 pr_err;
struct įrenginys *dev_err;
struct perf_object *perf_dev;
struct feature_platform_data *pdata;
};

FME platformos įrenginio inicijavimo srautas

FME inicijavimo srautas

• fme_probe() fme_dev_init()
  • Inicijuokite struktūrą fpga_fme ir išsaugokite ją lauke feature_platform_data.private.
• fme_probe() fpga_dev_feature_init() feature_instance_init()
  • Išsaugokite struct feature_ops kiekvienos užpildytos funkcijos faile feature_platform_data.features.
  • Iškvieskite testo funkciją, jei tokia yra, iš struktūros.
  • Iškvieskite init funkciją iš struktūros.
• fme_probe() fpga_register_dev_ops()
  • Sukurkite FME simbolio įrenginio mazgą, užregistruodami struktūrą file_operacijos.

Prievado platformos įrenginio inicijavimas
Šiame skyriuje pateikiama peržiūraview prievado įrenginio inicijavimo kodo srauto, kurį atlieka intel-fpga-afu.ko. Paryškintos pagrindinės duomenų struktūros ir funkcijos. Šį skyrių geriausia sekti, kai viewpateikiant pridedamą šaltinio kodą (afu.c).

Prievado platformos įrenginio duomenų struktūros

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 funkcija *funkcija,
unsigned int cmd, unsigned long arg);
int (*testas)(struct platform_device *pdev, struct feature *feature);
};
struct funkcija {
const char *vardas;
int išteklių_indeksas;
negalioja __iomem *ioaddr;
struct feature_ops *ops;
};
struct feature_platform_data {
struct list_head mazgas;
struct mutex lock;
nepasirašytas ilgas dev_status;
struct cdev cdev;
struct platform_device *dev;
nepasirašytas int disable_count;
negaliojantis *privatus;
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 indeksas;
u32 vėliavos;
u64 dydis;
u64 poslinkis;
u64 fiz.
struct list_head mazgas;
};
struct fpga_afu_dma_region {
u64 vartotojo_addr;
u64 ilgis;
u64 iova;
struct page **puslapiai;
struct rb_node mazgas;
bool in_use;
};
struct fpga_afu {
u64 regiono_cur_offset;
int regionų skaičius;
u8 num_umsgs;
struct list_head regions;
struct rb_root dma_regions;
struct feature_platform_data *pdata;
};

Prievado platformos įrenginio inicijavimo srautas

Prievado inicijavimo srautas

• afu_probe() afu_dev_init()
  • Inicijuokite struktūrą fpga_afu ir išsaugokite ją lauke feature_platform_data.private.
• afu_probe() fpga_dev_feature_init() feature_instance_init()
  • Išsaugokite struct feature_ops kiekvienos užpildytos funkcijos faile feature_platform_data.features.
  • Iškvieskite testo funkciją, jei tokia yra, iš struktūros.
  • Iškvieskite init funkciją iš struktūros.
• afu_probe() fpga_register_dev_ops()
  • Sukurkite prievado simbolio įrenginio mazgą, užregistruodami struktūrą file_operacijos.

FME IOCTL
IOCTL, kurie iškviečiami atvirai file deskriptorius /dev/intel-fpga-fme.j FPGA_GET_API_VERSION – grąžinkite dabartinę versiją kaip sveikąjį skaičių, pradedant nuo 0.

FPGA_CHECK_EXTENSION – šiuo metu nepalaikomas.

FPGA_FME_PORT_RELEASE – arg yra rodyklė į:

struct fpga_fme_port_release {
__u32 argsz; // in: sizeof(struct fpga_fme_port_release)
__u32 vėliavėlės; // in: turi būti 0
__u32 port_id; // į: prievado ID (nuo 0), kad išleistų.
};

FPGA_FME_PORT_ASSIGN – arg yra rodyklė į:

struct fpga_fme_port_assign {
__u32 argsz; // in: sizeof(struct fpga_fme_port_assign)
__u32 vėliavėlės; // in: turi būti 0
__u32 port_id; // į: prievado ID (nuo 0), kurį reikia priskirti. (turėjo būti
anksčiau išleido FPGA_FME_PORT_RELEASE)
};

FPGA_FME_PORT_PR – arg yra rodyklė į:

struct fpga_fme_port_pr {
__u32 argsz; // in: sizeof(struct fpga_fme_port_pr)
__u32 vėliavėlės; // in: turi būti 0
__u32 port_id; // į: prievado ID (nuo 0)
__u32 buferio_dydis; // in: bitų srauto buferio dydis baitais. Turi būti 4 baitų
sulygintas.
__u64 buferio_adresas; // į: bitų srauto buferio proceso adresas
__u64 būsena; // out: klaidos būsena (bitmask)
};

Uosto IOCTL
IOCTL, kurie iškviečiami atvirai file deskriptorius /dev/intel-fpga-port.k FPGA_GET_API_VERSION – grąžinti dabartinę versiją kaip sveikąjį skaičių, pradedant nuo 0. FPGA_CHECK_EXTENSION – šiuo metu nepalaikoma.

FPGA_PORT_GET_INFO – arg yra rodyklė į:

struct fpga_port_info {
__u32 argsz; // in: sizeof(struct fpga_port_info)
__u32 vėliavėlės; // out: grąžina 0
__u32 regionų skaičius; // out: MMIO regionų skaičius, 2 (1 AFU ir 1
STP)
__u32 num_umsgs; // out: aparatinės įrangos palaikomų UMsg skaičius
};

FPGA_PORT_GET_REGION_INFO – arg yra rodyklė į:

struct fpga_port_region_info {
__u32 argsz; // in: sizeof(struct fpga_port_region_info)
__u32 vėliavėlės; // out: (bitmask) { FPGA_REGION_READ, FPGA_REGION_WRITE,
FPGA_REGION_MMAP }
__u32 indeksas; // į: FPGA_PORT_INDEX_UAFU arba FPGA_PORT_INDEX_STP
__u32 padding; // in: turi būti 0
__u64 dydis; // out: MMIO srities dydis baitais
__u64 poslinkis; // out: MMIO srities poslinkis nuo įrenginio pradžios fd
};

FPGA_PORT_DMA_MAP – arg yra rodyklė į:
struct fpga_port_dma_map {
__u32 argsz; // in: sizeof(struct fpga_port_dma_map)
__u32 vėliavėlės; // in: turi būti 0 __u64 user_addr; // in: procesas virtualus
adresu. Turi būti sulygiuotas puslapis.
__u64 ilgis; // in: atvaizdavimo ilgis baitais. Turi būti puslapio kartotinis
dydis.
__u64 iova; // out: IO virtualus adresas };

FPGA_PORT_DMA_UNMAP – arg yra rodyklė į:
struct fpga_port_dma_unmap {
__u32 argsz; // in: sizeof(struct fpga_port_dma_unmap)
__u32 vėliavėlės; // in: turi būti 0
__u64 iova; // in: IO virtualus adresas, grąžintas ankstesnio
FPGA_PORT_DMA_MAP };

• FPGA_PORT_RESET – arg turi būti NULL.
• FPGA_PORT_UMSG_ENABLE – arg turi būti NULL.
• FPGA_PORT_UMSG_DISABLE – args turi būti NULL.

FPGA_PORT_UMSG_SET_MODE – arg yra rodyklė į:

struct fpga_port_umsg_cfg {
__u32 argsz; // in: sizeof(struct fpga_port_umsg_cfg)
__u32 vėliavėlės; // in: turi būti 0
__u32 hint_bitmap; // in: UMsg užuominų režimo bitmap. Nurodo, kurie yra UMsg
įjungta.
};

FPGA_PORT_UMSG_SET_BASE_ADDR –

• UMsg turi būti išjungtas prieš išleidžiant šį ioctl.
• „iova“ laukas turi būti pakankamai didelis buferiui visiems UMsg (num_umsgs * PAGE_SIZE).
  • Vairuotojo buferio valdymas buferį pažymėjo kaip „naudojamas“.
  • Jei iova yra NULL, bet kuris ankstesnis regionas nepažymėtas kaip „naudojamas“.
• arg yra rodyklė į:
  struct fpga_port_umsg_base_addr {
  • u32 argsz; // in: sizeof(struct fpga_port_umsg_base_addr)
  • u32 vėliavos; // in: turi būti 0
  • u64 iova; // į: IO virtualus adresas iš FPGA_PORT_DMA_MAP. };

Pastaba:

• Norėdami išvalyti prievado klaidas, turite parašyti tikslią esamų klaidų kaukę, pvz.,ample, kačių klaidos > aišku
• UMsg palaikoma tik naudojant „Intel Xeon“ procesoriaus su integruotu FPGA „Acceleration Stack“.

sysfs Files

FME antraštės sysfs files
intel-fpga-dev.i/intel-fpga-fme.j/

sysfs file	mmio laukas	tipo	prieiga
ports_num	fme_header.capability.num_ports	dešimtainis tarpt	Tik skaityti
talpyklos_dydis	fme_header.capability.cache_size	dešimtainis tarpt	Tik skaityti
versija	fme_header.capability.fabric_verid	dešimtainis tarpt	Tik skaityti
lizdo_id	fme_header.capability.socket_id	dešimtainis tarpt	Tik skaityti
bitstream_id	fme_header.bitstream_id	šešiakampis uint64_t	Tik skaityti
bitstream_metadata	fme_header.bitstream_md	šešiakampis uint64_t	Tik skaityti

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

sysfs file	mmio laukas	tipo	prieiga
slenkstis1	thermo.threshold.tmp_thshold1	dešimtainis tarpt	Vartotojas: Tik skaitomas Šaknis: skaitymas-rašymas
slenkstis2	thermo.threshold.tmp_thshold2	dešimtainis tarpt	Vartotojas: Tik skaitomas Šaknis: skaitymas-rašymas
slenkstis_kelionė	thermo.threshold.therm_trip_thshold	dešimtainis tarpt	Tik skaityti
slenkstis1_pasiektas	terminis.slenkstis.slenkstis1_būsena	dešimtainis tarpt	Tik skaityti
slenkstis2_pasiektas	terminis.slenkstis.slenkstis2_būsena	dešimtainis tarpt	Tik skaityti
slenkstis1_politika	terminis. slenkstis.thshold_policy	dešimtainis tarpt	Vartotojas: Tik skaitomas Šaknis: skaitymas-rašymas
temperatūros	thermo.rdsensor_fm1.fpga_temp	dešimtainis tarpt	Tik skaityti

FME maitinimo valdymo sysfs files
intel-fpga-dev.i/intel-fpga-fme.j/power_mgmt/

sysfs file	mmio laukas	tipo	prieiga
suvartojama	power.status.pwr_consumed	šešiakampis uint64_t	Tik skaityti
slenkstis1	galia.slenkstis.slenkstis1	šešiakampis uint64_t	Vartotojas: Tik skaitomas Šaknis: skaitymas-rašymas
slenkstis2	galia.slenkstis.slenkstis2	šešiakampis uint64_t	Vartotojas: Tik skaitomas Šaknis: skaitymas-rašymas
slenkstis1_statusas	power.threshold.threshold1_status	dešimtainis nepasirašytas	Tik skaityti
slenkstis2_statusas	power.threshold.threshold2_status	dešimtainis nepasirašytas	Tik skaityti
rtl	power.status.fpga_latency_report	dešimtainis nepasirašytas	Tik skaityti

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

sysfs file	mmio laukas	tipo	prieiga
pcie0_errors	gerror.pcie0_err	šešiakampis uint64_t	Skaityk rašyk
pcie1_errors	gerror.pcie1_err	šešiakampis uint64_t	Skaityk rašyk
inject_error	gerror.ras_error_inj	šešiakampis uint64_t	Skaityk rašyk

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

sysfs file	mmio laukas	tipo	prieiga
klaidų	gerror.fme_err	šešiakampis uint64_t	Tik skaityti
pirmoji_klaida	gerror.fme_first_err.err_reg_status	šešiakampis uint64_t	Tik skaityti
next_error	gerror.fme_next_err.err_reg_status	šešiakampis uint64_t	Tik skaityti
aišku	Išvalo klaidas, pirmoji_klaida, kita_klaida	įvairių uint64_t	Tik rašoma

Pastaba:
Norėdami išvalyti FME klaidas, turite parašyti tikslią esamų klaidų kaukę, pvz.,ample katės klaidos > aišku.

FME dalinis perkonfigūravimas sysfs files
intel-fpga-dev.i/intel-fpga-fme.j/pr/

sysfs file	mmio laukas	tipo	prieiga
sąsajos_id	pr.fme_pr_intfc_id0_h, pr.fme_pre_intfc_id0_l	šešioliktainis 16 baitų	Tik skaityti

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

sysfs file	mmio laukas	tipo	prieiga
laikrodis	gperf.clk.afu_interf_clock	šešiakampis uint64_t	Tik skaityti

intel-fpga-dev.i/intel-fpga-fme.j/dperf/cache/ (Negalioja „Intel Xeon“ procesoriaus su FPGA pagreičio kaminui)

sysfs file	mmio laukas	tipo	prieiga
užšaldyti	gperf.ch_ctl.freeze	dešimtainis tarpt	Skaityk rašyk
read_hit	gperf.CACHE_RD_HIT	šešiakampis uint64_t	Tik skaityti
read_miss	gperf.CACHE_RD_MISS	šešiakampis uint64_t	Tik skaityti
rašyti_hit	gperf.CACHE_WR_HIT	šešiakampis uint64_t	Tik skaityti
rašyti_praleisti	gperf.CACHE_WR_MISS	šešiakampis uint64_t	Tik skaityti
hold_request	gperf.CACHE_HOLD_REQ	šešiakampis uint64_t	Tik skaityti
tx_req_stall	gperf.CACHE_TX_REQ_STALL	šešiakampis uint64_t	Tik skaityti

sysfs file	mmio laukas	tipo	prieiga
rx_req_stall	gperf.CACHE_RX_REQ_STALL	šešiakampis uint64_t	Tik skaityti
data_write_port_contention	gperf.CACHE_DATA_WR_PORT_CONTEN	šešiakampis uint64_t	Tik skaityti
tag_write_port_contention	gperf.CACHE_TAG_WR_PORT_CONTEN	šešiakampis uint64_t	Tik skaityti

intel-fpga-dev.i/intel-fpga-fme.j/dperf/iommu/ (Negalioja „Intel Xeon“ procesoriaus su FPGA pagreičio kaminui)

sysfs file	mmio laukas	tipo	prieiga
užšaldyti	gperf.vtd_ctl.freeze	dešimtainis tarpt	Vartotojas: Tik skaitomas Šaknis: skaitymas-rašymas

intel-fpga-dev.i/intel-fpga-fme.j/dperf/iommu/afuk/ (Negalioja „Intel Xeon“ procesoriaus su FPGA pagreičio kaminui)

sysfs file	mmio laukas	tipo	prieiga
read_transaction	gperf.VTD_AFU0_MEM_RD_TRANS	šešiakampis uint64_t	Tik skaityti
rašyti_transakcijos	gperf.VTD_AFU0_MEM_WR_TRANS	šešiakampis uint64_t	Tik skaityti
tlb_read_hit	gperf.VTD_AFU0_TLB_RD_HIT	šešiakampis uint64_t	Tik skaityti
tlb_write_hit	gperf.VTD_AFU0_TLB_WR_HIT	šešiakampis uint64_t	Tik skaityti

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

sysfs file	mmio laukas	tipo	prieiga
įjungti	gperf.fab_ctl.(įjungta)	dešimtainis tarpt	Vartotojas: Tik skaitomas Šaknis: skaitymas-rašymas
užšaldyti	gperf.fab_ctl.freeze	dešimtainis tarpt	Vartotojas: Tik skaitomas Šaknis: skaitymas-rašymas
pcie0_read	gperf.FAB_PCIE0_RD	šešiakampis uint64_t	Tik skaityti
pcie0_write	gperf.FAB_PCIE0_WR	šešiakampis uint64_t	Tik skaityti
pcie1_read	gperf.FAB_PCIE1_RD	šešiakampis uint64_t	Tik skaityti
pcie1_write	gperf.FAB_PCIE1_WR	šešiakampis uint64_t	Tik skaityti
upi_read	gperf.FAB_UPI_RD	šešiakampis uint64_t	Tik skaityti
upi_write	gperf.FAB_UPI_WR	šešiakampis uint64_t	Tik skaityti

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

sysfs file	mmio laukas	tipo	prieiga
pcie0_read	gperf.FAB_PCIE0_RD	šešiakampis uint64_t	Tik skaityti
pcie0_write	gperf.FAB_PCIE0_WR	šešiakampis uint64_t	Tik skaityti
pcie1_read	gperf.FAB_PCIE1_RD	šešiakampis uint64_t	Tik skaityti
pcie1_write	gperf.FAB_PCIE1_WR	šešiakampis uint64_t	Tik skaityti
upi_read	gperf.FAB_UPI_RD	šešiakampis uint64_t	Tik skaityti
upi_write	gperf.FAB_UPI_WR	šešiakampis uint64_t	Tik skaityti

Prievado antraštė sysfs files
intel-fpga-dev.i/intel-fpga-port.k/

sysfs file	mmio laukas	tipo	prieiga
id	port_header.capability.port_number	dešimtainis tarpt	Tik skaityti
ltr	port_header.control.latency_tolerance	dešimtainis tarpt	Tik skaityti

Prievado AFU antraštės sysfs files
intel-fpga-dev.i/intel-fpga-port.k/

sysfs file	mmio laukas	tipo	prieiga
afu_id	afu_header.guid	šešioliktainis 16 baitų	Tik skaityti

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

sysfs file	mmio laukas	tipo	prieiga
klaidų	perror.port_error	šešiakampis uint64_t	Tik skaityti
pirmoji_klaida	perror.port_first_error	šešiakampis uint64_t	Tik skaityti
first_neformed_req	perror.malreq	šešioliktainis 16 baitų	Tik skaityti
aišku	klaida.(visos klaidos)	įvairių uint64_t	Tik rašoma

Pastaba:
Norėdami išvalyti prievado klaidas, turite parašyti tikslią esamų klaidų kaukę, pvz.,ample katės klaidos > aišku.

Revizijos istorija

Dokumento versija	Pakeitimai
2017.10.02	Pradinis leidimas.

OPAE Intel FPGA Linux įrenginių tvarkyklės architektūros vadovas

Dokumentai / Ištekliai

intel OPAE FPGA Linux įrenginio tvarkyklės architektūra [pdfVartotojo vadovas OPAE FPGA Linux įrenginio tvarkyklės architektūra, OPAE FPGA, Linux įrenginio tvarkyklės architektūra, tvarkyklės architektūra, architektūra

Nuorodos

• Vartotojo vadovas