intel OPAE FPGA Linuxi seadme draiveri arhitektuur

OPAE Intel FPGA Linuxi seadme draiveri arhitektuur

OPAE Inteli FPGA draiver pakub kasutajaruumi rakendustele liideseid FPGA kiirendite konfigureerimiseks, loendamiseks, avamiseks ja juurdepääsuks Inteli FPGA lahendustega platvormidel ning võimaldab süsteemitasemel haldusfunktsioone, nagu FPGA ümberkonfigureerimine, toitehaldus ja virtualiseerimine.

Riistvara arhitektuur

OS-i seisukohast viewFPGA riistvara kuvatakse tavalise PCIe-seadmena. FPGA-seadme mälu korraldatakse eelnevalt määratletud andmestruktuuri (Device Feature List) abil. FPGA-seadme toetatud funktsioonid kuvatakse nende andmestruktuuride kaudu, nagu on näidatud alloleval joonisel.

FPGA PCIe seade

Draiver toetab PCIe SR-IOV-i, et luua virtuaalseid funktsioone (VF), mida saab kasutada virtuaalmasinatele üksikute kiirendite määramiseks.

Intel Corporation. Kõik õigused kaitstud. Intel, Inteli logo ja muud Inteli kaubamärgid on Intel Corporationi või selle tütarettevõtete kaubamärgid. Intel garanteerib oma FPGA- ja pooljuhttoodete jõudluse praeguste spetsifikatsioonide kohaselt vastavalt Inteli standardgarantiile, kuid jätab endale õiguse teha mis tahes tooteid ja teenuseid igal ajal ette teatamata. Intel ei võta endale mingit vastutust ega kohustusi, mis tulenevad siin kirjeldatud teabe, toote või teenuse rakendusest või kasutamisest, välja arvatud juhul, kui Intel on sellega sõnaselgelt kirjalikult nõustunud. Inteli klientidel soovitatakse hankida seadme spetsifikatsioonide uusim versioon enne avaldatud teabele tuginemist ja enne toodete või teenuste tellimuste esitamist.

Teisi nimesid ja kaubamärke võidakse pidada teiste omandiks.

Virtualiseeritud FPGA PCIe seade

FPGA haldusmootor (FME)
FPGA haldusmootor teostab toite- ja soojushaldust, veateadet, ümberkonfigureerimist, jõudluse aruandlust ja muid infrastruktuuri funktsioone. Igal FPGA-l on üks FME, millele pääseb alati juurde füüsilise funktsiooni (PF) kaudu. Kasutajaruumi rakendused saavad hankida eksklusiivse juurdepääsu FME-le kasutades open() ja vabastada selle privilegeeritud kasutajana (root) kasutades close().

Port
Port tähistab liidest staatilise FPGA kanga (FPGA liidesehaldur (FIM)) ja kiirendusfunktsiooni (AF) sisaldava osaliselt ümberkonfigureeritava piirkonna vahel. Port juhib suhtlust tarkvarast kiirendini ja paljastab sellised funktsioonid nagu lähtestamine ja silumine. PCIe-seadmel võib olla mitu porti ja iga pordi saab kuvada VF-i kaudu, määrates selle FME-seadme ioctl-i FPGA_FME_PORT_ASSIGN abil.

Kiirendi funktsiooni (AF) seade

• Kiirendifunktsiooni (AF) seade on ühendatud pordiga ja paljastab 256K MMIO piirkonna, mida kasutatakse kiirendispetsiifiliste juhtimisregistrite jaoks.
• Kasutajaruumi rakendused saavad hankida eksklusiivse juurdepääsu pordiga ühendatud AFU-le, kasutades pordiseadmes funktsiooni open(), ja vabastada selle käsuga close().
• Kasutajaruumi rakendused saavad ka mmap() kiirendi MMIO piirkondi.

Osaline ümberseadistamine
Nagu eespool mainitud, saab kiirendeid ümber konfigureerida kiirendifunktsiooni (AF) osalise ümberseadistamisega. file. Kiirendi funktsioon (AF) peab olema loodud FPGA täpse FIM-i ja sihitud staatilise piirkonna (pordi) jaoks; vastasel juhul nurjub ümberseadistamise toiming ja see võib põhjustada süsteemi ebastabiilsust. Seda ühilduvust saab kontrollida, võrreldes AF päises märgitud liidese ID-d FME poolt sysf-ide kaudu avaldatud liidese ID-ga. Selle kontrolli teeb tavaliselt kasutajaruum enne IOCTL-i ümberseadistamist.

Märkus.
Praegu tuleb kõik FPGA-le juurde pääsevad tarkvaraprogrammid, sealhulgas need, mis töötavad virtualiseeritud hostis, enne osalise ümberkonfigureerimise katset sulgeda. Sammud oleksid järgmised:

1. Laadige juht külalisest maha
2. Ühendage VF külalise küljest lahti
3. Keela SR-IOV
4. Tehke osaline ümberseadistamine
5. Luba SR-IOV
6. Ühendage VF külalisega
7. Laadige juht külalisesse

FPGA virtualiseerimine
Kiirendile juurdepääsu võimaldamiseks VM-is töötavatest rakendustest tuleb vastava AFU-port määrata VF-ile, järgides järgmisi samme.

1. PF-ile kuuluvad vaikimisi kõik AFU-pordid. Kõik pordid, mis tuleb VF-ile ümber määrata, tuleb esmalt PF-st vabastada FME-seadme ioctl-i FPGA_FME_PORT_RELEASE kaudu.
2. Kui N porti PF-ist vabastatakse, saab allolevat käsku kasutada SRIOV-i ja VF-ide lubamiseks. Igal VF-il on ainult üks AFU-port. echo N > PCI_DEVICE_PATH/sriov_numvfs
3. Viige läbi VF-id VM-idesse.
4. VF-i all olevale AFU-le pääseb juurde VM-i rakendustest (kasutades sama draiverit VF-is).

Märkus.
FME-d ei saa määrata VF-ile, seega on suhtekorraldus ja muud haldusfunktsioonid saadaval ainult PF-i kaudu.

Autojuhi organisatsioon

PCIe mooduli seadme draiver

Autojuhi organisatsioon

FPGA-seadmed kuvatakse tavaliste PCIe-seadmetena; seega laaditakse FPGA PCIe PF või VF tuvastamisel alati esimesena FPGA PCIe seadme draiver (intel-FPGA-PCI.ko). Sellel draiveril on draiveri arhitektuuris infrastruktuuriline roll. See:

• Loob funktsiooniseadmete vanemana FPGA konteineriseadme.
• Kõnnib läbi seadme funktsioonide loendi, mis on realiseeritud PCIe seadme BAR-mälus, et avastada funktsiooniseadmeid ja nende alamfunktsioone ning luua neile konteinerseadme all platvormseadmeid.
• Toetab SR-IOV-i.
• Tutvustatakse funktsiooniseadmete infrastruktuuri, mis võtab alamfunktsioonide toimingud kokku ja paljastab tavalised funktsioonid funktsiooniseadme draiveritele.

PCIe mooduli seadme draiveri funktsioonid

• Sisaldab PCIe avastamist, seadmete loendit ja funktsioonide avastamist.
• Loob sysfsi kataloogid põhiseadme, FPGA haldusmootori (FME) ja pordi jaoks.
• Loob platvormi draiveri eksemplarid, mille tulemusena laadib Linuxi kernel nende vastavad platvormi mooduli draiverid.

FME platvormi mooduli seadme draiver

• Toite- ja soojushaldus, veateade, jõudluse aruandlus ja muud infrastruktuuri funktsioonid. Nendele funktsioonidele pääsete juurde FME draiveri paljastatud sysf-liideste kaudu.
• Osaline ümberseadistamine. FME draiver registreerib PR alamfunktsiooni lähtestamise ajal FPGA halduri; kui see saab teilt FPGA_FME_PORT_PR ioctl, kutsub see FPGA haldurilt välja ühise liidese funktsiooni, et viia lõpule bitivoo osaline ümberseadistamine antud pordile.
• Pordihaldus virtualiseerimiseks. FME draiver tutvustab kahte ioctl-i, FPGA_FME_PORT_RELEASE, mis vabastab antud pordi PF-st; ja FPGA_FME_PORT_ASSIGN, mis määrab pordi tagasi PF-ile. Kui port on PF-ist vabastatud, saab selle PCIe draiveri pakutavate SR-IOV liideste kaudu VF-ile määrata. Lisateabe saamiseks vaadake jaotist "FPGA virtualiseerimine".

FME platvormi mooduli seadme draiveri funktsioonid

• Loob FME märgi seadme sõlme.
• Loob FME sysfs files ja rakendab FME sysfs file tarvikud.
• Rakendab FME privaatfunktsiooni alamdraivereid.
• FME privaatsete funktsioonide alamdraiverid:
  • FME päis
  • Soojusjuhtimine
  • Toitehaldus
  • Globaalne viga
  • Osaline ümberseadistamine
  • Ülemaailmne jõudlus

Pordiplatvormi mooduli seadme draiver
Sarnaselt FME draiveriga kontrollitakse FPGA-pordi (ja AFU) draiverit (intel-fpga-afu.ko) pärast pordiplatvormi seadme loomist. Selle mooduli põhifunktsioon on pakkuda kasutajaruumi rakendustele liidest, et pääseda juurde üksikutele kiirenditele, sealhulgas pordi põhi lähtestamise juhtimine, AFU MMIO piirkonna eksport, DMA puhvri kaardistamise teenus, UMsg(1) teavitus ja kaugsilumisfunktsioonid ( vt eespool).

UMsg-d toetatakse ainult integreeritud FPGA-ga Intel Xeon® protsessori Acceleration Stacki kaudu.

Pordiplatvormi mooduli seadme draiveri funktsioonid

• Loob pordi märgi seadme sõlme.
• Loob porti sysfs files ja rakendab Port sysfs file tarvikud.
• Rakendab pordi privaatfunktsiooni alamdraivereid.
• Pordi privaatsete funktsioonide alamdraiverid:
  • Pordi päis
  • AFU
  • Pordi viga
  • UMsg(2)
  • Signaal Puuduta

Rakenduse FPGA-seadmete loend
See jaotis tutvustab, kuidas rakendused loetlevad FPGA-seadme sysfs-i hierarhiast /sys/class/fpga all. EksisampAllpool on hosti installitud kaks Inteli FPGA-seadet. Igal FPGA-seadmel on üks FME ja kaks porti (AFU). Iga FPGA-seadme jaoks luuakse /sys/class/fpga alla seadmekataloog:

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

Igal sõlmel on lapsseadmetena üks FME ja kaks porti (AFU):
/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

Üldiselt on FME/Port sysfsi liidesed nimetatud järgmiselt:
/sys/class/fpga/intel-fpga-dev.i/intel-fpga-fme.j/
/sys/class/fpga/intel-fpga-dev.i/intel-fpga-port.k/

I järjestikuliselt nummerdades kõik konteinerseadmed, j järjestikku FME-d ja k järjestikuselt kõik pordid.

Seadme sõlmedele, mida kasutatakse ioctl() ja mmap() jaoks, saab viidata läbi:
/dev/intel-fpga-fme.j
/dev/intel-fpga-port.k

PCIe draiverite loend
See jaotis annab ülevaateview intel-fpga-pci.ko teostatud seadmete loendamise koodivoost. Peamised andmestruktuurid ja funktsioonid on esile tõstetud. Seda jaotist on kõige parem jälgida, kui viewkaasasoleva lähtekoodi (pcie.c) lisamine.

Loendamisandmestruktuurid

enum fpga_id_type {
PARENT_ID,
FME_ID,
PORT_ID,
FPGA_ID_MAX
};
staatiline struktuur idr fpga_ids[FPGA_ID_MAX];
struct fpga_chardev_info {
const char *nimi;
dev_t devt;
};
struct fpga_chardev_info fpga_chrdevs[] = {
{ .name = FPGA_FEATURE_DEV_FME },
{ .name = FPGA_FEATURE_DEV_PORT },
};
staatilise struktuuri klass *fpga_klass;
staatiline struktuur 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,}
};
staatiline struktuur 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 seadme_id;
struct seade *fme_dev;
struct mutex lock;
struct list_head port_dev_list;
int vabastatud_pordi_number;
struct list_head regions;
};
struct build_feature_devs_info {
struct pci_dev *pdev;
tühine __iomem *ioaddr;
tühine __iomem *ioend;
int praeguse_riba;
tühine __iomem *pfme_hdr;
struct seade *parent_dev;
struct platvormi_seade *funktsioon_dev;
};

Loendamise voog

• ccidrv_init()
  • Initsialiseerige fpga_ids, kasutades idr_init().
  • Initsialiseerige fpga_chrdevs[i].devt, kasutades alloc_chrdev_region().
  • Initsialiseerige fpga_class, kasutades class_create().
  • pci_register_driver(&cci_pci_driver);
• cci_pci_probe()
  • Lubage PCI-seade, taotlege juurdepääsu selle piirkondadele, määrake PCI põhirežiim ja konfigureerige DMA.
• cci_pci_create_feature_devs() build_info_alloc_and_init()
  • Määrake struktuur build_feature_devs_info, lähtestage see.
    .parent_dev on seatud sysfsi vanemkataloogiks (intel-fpga-dev.id), mis sisaldab FME ja Port sysfs katalooge.
• parse_feature_list()
  • FME, pordi ja nende privaatsete funktsioonide avastamiseks kõndige BAR0 seadme funktsioonide loendis.
• parse_feature() parse_feature_afus() parse_feature_fme()
  • Kui puutute kokku FME-ga:
• build_info_create_dev()
  • Määrake FME jaoks platvormseade, mis salvestatakse failis build_feature_devs_info.feature_dev.
  • Funktsioon feature_dev.id lähtestatakse idr_alloc(fpga_ids[FME_ID],
  • feature_dev.parent on seatud väärtusele build_feature_devs_info.parent_dev.
  • Jaotage failis feature_dev.resource struktuuriressursside massiiv.
• Määrake struktuur feature_platform_data, lähtestage see ja salvestage kursor failis feature_dev.dev.platform_data
  • create_feature_instance() build_info_add_sub_feature()
  • Initsialiseerige feature_dev.resource[FME_FEATURE_ID_HEADER].
  • feature_platform_data_add()
  • Initsialiseerige feature_platform_data.features[FME_FEATURE_ID_HEADER], kõik peale .fops.
• parse_feature() parse_feature_afus() parse_feature_port()
  • Kui kohtate porti:
• build_info_create_dev()
  • Eraldage pordi jaoks platvormseade, mis salvestatakse failis build_feature_devs_info.feature_dev.
  • Funktsioon feature_dev.id lähtestatakse idr_alloc(fpga_ids[PORT_ID] tulemuseks,
  • feature_dev.parent on seatud väärtusele build_feature_devs_info.parent_dev.
  • Jaotage failis feature_dev.resource struktuuriressursside massiiv.
  • Määrake struktuur feature_platform_data, lähtestage see ja salvestage kursor failis feature_dev.dev.platform_data
• build_info_commit_dev()
  • Lisage pordi struct feature_platform_data.node portide loendisse struct cci_drvdata.port_dev_list
• create_feature_instance() build_info_add_sub_feature()
  • Initsialiseeri feature_dev.resource[PORT_FEATURE_ID_HEADER].
• feature_platform_data_add()
  • Initsialiseerige feature_platform_data.features[PORT_FEATURE_ID_HEADER], kõik peale .fops.
• parse_feature() parse_feature_afus() parse_feature_port_uafu()
  • Kui ilmneb AFU:
• create_feature_instance() build_info_add_sub_feature()
  • Initsialiseeri feature_dev.resource[PORT_FEATURE_ID_UAFU].
• feature_platform_data_add()
  • Initsialiseerige feature_platform_data.features[PORT_FEATURE_ID_UAFU], kõik peale .fops.
• parse_feature() parse_feature_private() parse_feature_fme_private()
  • Kui avastatakse FME privaatne funktsioon:
• create_feature_instance() build_info_add_sub_feature()
  • Initsialiseerige feature_dev.resource[id].
• feature_platform_data_add()
  • Initsialiseerige feature_platform_data.features[id], kõik peale .fops.
• parse_feature() parse_feature_private() parse_feature_port_private()
• Kui avastatakse pordi privaatne funktsioon: * create_feature_instance() build_info_add_sub_feature() * Initsialiseeri funktsiooni_dev.resource[id]. * feature_platform_data_add() Initsialiseeri feature_platform_data.features[id], kõik peale .fops.
• parse_ports_from_fme()
  • Kui draiver on laaditud füüsilisele funktsioonile (PF), siis:
• Käivitage parse_feature_list() voog igas FME päises kirjeldatud pordis.
• Kasutage päises igas pordikirjes mainitud BAR-i.

FME platvormi seadme lähtestamine
See jaotis annab ülevaateview intel-fpga-fme.ko läbiviidud FME-seadme lähtestamise koodivoo osa. Peamised andmestruktuurid ja funktsioonid on esile tõstetud. Seda jaotist on kõige parem jälgida, kui viewkaasasoleva lähtekoodi (fme-main.c) lisamine.

FME platvormi seadme andmestruktuurid

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 funktsioon *funktsioon,
märgita int cmd, märgita pikk arg);
int (*test)(struct platform_device *pdev, struct feature *feature);
};
struktuuri funktsioon {
const char *nimi;
int ressursi_indeks;
tühine __iomem *ioaddr;
struct feature_ops *ops;
};
struct feature_platform_data {
struct list_head node;
struct mutex lock;
allkirjastamata pikk dev_status;
struct cdev cdev;
struct platvormi_seade *dev;
allkirjastamata int disable_count;
tühine *privaatne;
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 *)); struktuur
funktsiooni funktsioonid[0];
};
struct perf_object {
teie käsi;
const struct atribuudi_rühm **attr_groups;
struct seade *fme_dev;
struct list_head node;
struct list_head lapsed;
struct kobject kobj;
};
struct fpga_fme {
u8 pordi_id;
u64 pr_err;
struct seade *dev_err;
struct perf_object *perf_dev;
struct funktsiooni_platvormi_andmed *pdata;
};

FME platvormi seadme lähtestamise voog

FME initsialiseerimise voog

• fme_probe() fme_dev_init()
  • Initsialiseerige struktuur fpga_fme ja salvestage see väljale feature_platform_data.private.
• fme_probe() fpga_dev_feature_init() feature_instance_init()
  • Salvestage iga asustatud funktsiooni jaoks struct feature_ops kausta feature_platform_data.features.
  • Kutsuge struktuurist välja testfunktsioon, kui see on olemas.
  • Kutsuge struktuurist välja init-funktsioon.
• fme_probe() fpga_register_dev_ops()
  • Looge FME märgiseadme sõlm, registreerides struktuuri file_operatsioonid.

Pordiplatvormi seadme initsialiseerimine
See jaotis annab ülevaateview port-seadme lähtestamise koodivoost, mida teostab intel-fpga-afu.ko. Peamised andmestruktuurid ja funktsioonid on esile tõstetud. Seda jaotist on kõige parem jälgida, kui viewkaasasoleva lähtekoodi (afu.c) lisamine.

Pordiplatvormi seadme andmestruktuurid

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 funktsioon *funktsioon,
märgita int cmd, märgita pikk arg);
int (*test)(struct platform_device *pdev, struct feature *feature);
};
struktuuri funktsioon {
const char *nimi;
int ressursi_indeks;
tühine __iomem *ioaddr;
struct feature_ops *ops;
};
struct feature_platform_data {
struct list_head node;
struct mutex lock;
allkirjastamata pikk dev_status;
struct cdev cdev;
struct platvormi_seade *dev;
allkirjastamata int disable_count;
tühine *privaatne;
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 funktsiooni omadused[0];
};
struct fpga_afu_region {
u32 indeks;
u32 lipud;
u64 suurus;
u64 nihe;
u64 phys;
struct list_head node;
};
struct fpga_afu_dma_region {
u64 kasutaja_aadress;
u64 pikkus;
u64 iova;
struct page **pages;
struct rb_node node;
bool in_use;
};
struct fpga_afu {
u64 region_cur_offset;
int piirkondade_arv;
u8 num_umsgs;
struct list_head regions;
struct rb_root dma_regions;
struct funktsiooni_platvormi_andmed *pdata;
};

Pordiplatvormi seadme lähtestamise voog

Pordi initsialiseerimise voog

• afu_probe() afu_dev_init()
  • Initsialiseerige struktuur fpga_afu ja salvestage see väljale feature_platform_data.private.
• afu_probe() fpga_dev_feature_init() feature_instance_init()
  • Salvestage iga asustatud funktsiooni jaoks struct feature_ops kausta feature_platform_data.features.
  • Kutsuge struktuurist välja testfunktsioon, kui see on olemas.
  • Kutsuge struktuurist välja init-funktsioon.
• afu_probe() fpga_register_dev_ops()
  • Looge pordi märgi seadme sõlm, registreerides struktuuri file_operatsioonid.

FME IOCTL-id
IOCTL-id, millele kutsutakse avatud file /dev/intel-fpga-fme.j deskriptor FPGA_GET_API_VERSION – tagastab praeguse versiooni täisarvuna, alustades nullist.

FPGA_CHECK_EXTENSION – praegu ei toetata.

FPGA_FME_PORT_RELEASE — arg on kursor:

struct fpga_fme_port_release {
__u32 argsz; // in: sizeof(struct fpga_fme_port_release)
__u32 lipud; // in: peab olema 0
__u32 pordi_id; // sisse: pordi ID (alates 0) vabastamiseks.
};

FPGA_FME_PORT_ASSIGN — arg on kursor:

struct fpga_fme_port_assign {
__u32 argsz; // in: sizeof(struct fpga_fme_port_assign)
__u32 lipud; // in: peab olema 0
__u32 pordi_id; // sisse: pordi ID (alates 0) määramiseks. (pidi olema
varem välja antud FPGA_FME_PORT_RELEASE)
};

FPGA_FME_PORT_PR — arg on kursor järgmisele:

struct fpga_fme_port_pr {
__u32 argsz; // in: sizeof(struct fpga_fme_port_pr)
__u32 lipud; // in: peab olema 0
__u32 pordi_id; // sisse: pordi ID (alates 0)
__u32 puhvri_suurus; // in: bitivoopuhvri suurus baitides. Peab olema 4-baidine
joondatud.
__u64 puhvri_aadress; // in: bitivoopuhvri protsessiaadress
__u64 olek; // välja: veaolek (bitmask)
};

IOCTL-id
IOCTL-id, millele kutsutakse avatud file /dev/intel-fpga-port.k deskriptor FPGA_GET_API_VERSION — tagastab praeguse versiooni täisarvuna, alates 0. FPGA_CHECK_EXTENSION — praegu ei toetata.

FPGA_PORT_GET_INFO — arg on kursor:

struct fpga_port_info {
__u32 argsz; // in: sizeof(struct fpga_port_info)
__u32 lipud; // välja: tagastab 0
__u32 piirkondade_arv; // välja: MMIO piirkondade arv, 2 (1 AFU jaoks ja 1 jaoks
STP)
__u32 num_umsgs; // out: riistvara toetatud UM-ide arv
};

FPGA_PORT_GET_REGION_INFO — arg on kursor:

struct fpga_port_region_info {
__u32 argsz; // in: sizeof(struct fpga_port_region_info)
__u32 lipud; // välja: (bitmask) { FPGA_REGION_READ, FPGA_REGION_WRITE,
FPGA_REGION_MMAP }
__u32 indeks; // asukohas: FPGA_PORT_INDEX_UAFU või FPGA_PORT_INDEX_STP
__u32 polster; // in: peab olema 0
__u64 suurus; // välja: MMIO piirkonna suurus baitides
__u64 nihe; // out: MMIO piirkonna nihe seadme algusest fd
};

FPGA_PORT_DMA_MAP — arg on kursor:
struct fpga_port_dma_map {
__u32 argsz; // in: sizeof(struct fpga_port_dma_map)
__u32 lipud; // in: peab olema 0 __u64 user_addr; // in: protsess virtuaalne
aadress. Peab olema lehega joondatud.
__u64 pikkus; // in: vastenduse pikkus baitides. Peab olema lehe kordne
suurus.
__u64 iova; // välja: IO virtuaalne aadress };

FPGA_PORT_DMA_UNMAP — arg on kursor:
struct fpga_port_dma_unmap {
__u32 argsz; // in: sizeof(struct fpga_port_dma_unmap)
__u32 lipud; // in: peab olema 0
__u64 iova; // in: IO virtuaalne aadress, mille on tagastanud eelmine
FPGA_PORT_DMA_MAP };

• FPGA_PORT_RESET — arg peab olema NULL.
• FPGA_PORT_UMSG_ENABLE — arg peab olema NULL.
• FPGA_PORT_UMSG_DISABLE — argid peavad olema NULL.

FPGA_PORT_UMSG_SET_MODE — arg on kursor:

struct fpga_port_umsg_cfg {
__u32 argsz; // in: sizeof(struct fpga_port_umsg_cfg)
__u32 lipud; // in: peab olema 0
__u32 vihje_bitmap; // in: UMsg vihje režiim bitmap. Tähistab, millised UM-id on
lubatud.
};

FPGA_PORT_UMSG_SET_BASE_ADDR —

• Enne selle ioctl väljastamist tuleb UMsg keelata.
• Iova väli peab olema piisavalt suur puhvri jaoks kõigi UM-ide jaoks (num_umsgs * PAGE_SIZE).
  • Juhi puhvrihaldus on tähistanud puhvri kui "kasutatud".
  • Kui iova on NULL, eemaldatakse mis tahes eelneva piirkonna märge kasutusel olevaks.
• arg on kursor a:
  struct fpga_port_umsg_base_addr {
  • u32 argsz; // in: sizeof(struct fpga_port_umsg_base_addr)
  • u32 lipud; // in: peab olema 0
  • u64 iova; // in: IO virtuaalne aadress FPGA_PORT_DMA_MAP-st. };

Märkus.

• Pordivigade kustutamiseks peate kirjutama praeguste vigade täpse bitmaski, ntample, kassi vead > selge
• UMsg-d toetatakse ainult integreeritud FPGA-ga Intel Xeoni protsessori Acceleration Stacki kaudu.

sysfs Files

FME päise sysfs files
intel-fpga-dev.i/intel-fpga-fme.j/

sysfs file	mmio väli	tüüp	juurdepääs
pordi_number	fme_header.capability.num_ports	kümnendkoha vahev	Kirjutuskaitstud
vahemälu_suurus	fme_header.capability.cache_size	kümnendkoha vahev	Kirjutuskaitstud
versioon	fme_header.capability.fabric_verid	kümnendkoha vahev	Kirjutuskaitstud
sokli_id	fme_header.capability.socket_id	kümnendkoha vahev	Kirjutuskaitstud
bitstream_id	fme_header.bitstream_id	hex uint64_t	Kirjutuskaitstud
bitstream_metadata	fme_header.bitstream_md	hex uint64_t	Kirjutuskaitstud

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

sysfs file	mmio väli	tüüp	juurdepääs
lävi1	thermo.threshold.tmp_thshold1	kümnendkoha vahev	Kasutaja: kirjutuskaitstud Root: lugemine-kirjutamine
lävi2	thermo.threshold.tmp_thshold2	kümnendkoha vahev	Kasutaja: kirjutuskaitstud Root: lugemine-kirjutamine
läve_reis	thermo.threshold.therm_trip_thshold	kümnendkoha vahev	Kirjutuskaitstud
threshold1_reached	thermo.threshold.thshold1_status	kümnendkoha vahev	Kirjutuskaitstud
threshold2_reached	thermo.threshold.thshold2_status	kümnendkoha vahev	Kirjutuskaitstud
lävi1_poliitika	soojus. künnis.thshold_policy	kümnendkoha vahev	Kasutaja: kirjutuskaitstud Root: lugemine-kirjutamine
temperatuuri	thermo.rdsensor_fm1.fpga_temp	kümnendkoha vahev	Kirjutuskaitstud

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

sysfs file	mmio väli	tüüp	juurdepääs
tarbitud	power.status.pwr_consumed	hex uint64_t	Kirjutuskaitstud
lävi1	võimsus.lävi.lävi1	hex uint64_t	Kasutaja: kirjutuskaitstud Root: lugemine-kirjutamine
lävi2	võimsus.lävi.lävi2	hex uint64_t	Kasutaja: kirjutuskaitstud Root: lugemine-kirjutamine
lävi1_olek	power.threshold.threshold1_status	koma märgita	Kirjutuskaitstud
lävi2_olek	power.threshold.threshold2_status	koma märgita	Kirjutuskaitstud
rtl	power.status.fpga_latency_report	koma märgita	Kirjutuskaitstud

FME globaalne viga sysfs files
intel-fpga-dev.i/intel-fpga-fme.j/errors/

sysfs file	mmio väli	tüüp	juurdepääs
pcie0_errors	gerror.pcie0_err	hex uint64_t	Lugema kirjutama
pcie1_errors	gerror.pcie1_err	hex uint64_t	Lugema kirjutama
inject_error	gerror.ras_error_inj	hex uint64_t	Lugema kirjutama

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

sysfs file	mmio väli	tüüp	juurdepääs
vead	gerror.fme_err	hex uint64_t	Kirjutuskaitstud
esimene_viga	gerror.fme_first_err.err_reg_status	hex uint64_t	Kirjutuskaitstud
järgmine_viga	gerror.fme_next_err.err_reg_status	hex uint64_t	Kirjutuskaitstud
selge	Kustutab vead, esimene_viga, järgmine_viga	mitmesugused uint64_t	Ainult kirjutatav

Märkus.
FME vigade kustutamiseks peate kirjutama praeguste vigade täpse bitmaski, ntample kassi vead > selge.

FME osalise ümberkonfigureerimise sysfs files
intel-fpga-dev.i/intel-fpga-fme.j/pr/

sysfs file	mmio väli	tüüp	juurdepääs
liidese_id	pr.fme_pr_intfc_id0_h, pr.fme_pre_intfc_id0_l	kuusteist 16-baiti	Kirjutuskaitstud

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

sysfs file	mmio väli	tüüp	juurdepääs
kella	gperf.clk.afu_interf_clock	hex uint64_t	Kirjutuskaitstud

intel-fpga-dev.i/intel-fpga-fme.j/dperf/cache/ (ei kehti FPGA-ga Intel Xeoni protsessori kiirenduspinu jaoks)

sysfs file	mmio väli	tüüp	juurdepääs
külmutada	gperf.ch_ctl.freeze	kümnendkoha vahev	Lugema kirjutama
loe_hit	gperf.CACHE_RD_HIT	hex uint64_t	Kirjutuskaitstud
loe_miss	gperf.CACHE_RD_MISS	hex uint64_t	Kirjutuskaitstud
write_hit	gperf.CACHE_WR_HIT	hex uint64_t	Kirjutuskaitstud
kirjuta_miss	gperf.CACHE_WR_MISS	hex uint64_t	Kirjutuskaitstud
kinni_taotlus	gperf.CACHE_HOLD_REQ	hex uint64_t	Kirjutuskaitstud
tx_req_stall	gperf.CACHE_TX_REQ_STALL	hex uint64_t	Kirjutuskaitstud

sysfs file	mmio väli	tüüp	juurdepääs
rx_req_stall	gperf.CACHE_RX_REQ_STALL	hex uint64_t	Kirjutuskaitstud
data_write_port_contention	gperf.CACHE_DATA_WR_PORT_CONTEN	hex uint64_t	Kirjutuskaitstud
tag_write_port_contention	gperf.CACHE_TAG_WR_PORT_CONTEN	hex uint64_t	Kirjutuskaitstud

intel-fpga-dev.i/intel-fpga-fme.j/dperf/iommu/ (ei kehti FPGA-dega Intel Xeoni protsessori kiirenduspinu jaoks)

sysfs file	mmio väli	tüüp	juurdepääs
külmutada	gperf.vtd_ctl.freeze	kümnendkoha vahev	Kasutaja: kirjutuskaitstud Root: lugemine-kirjutamine

intel-fpga-dev.i/intel-fpga-fme.j/dperf/iommu/afuk/ (ei kehti FPGA-ga Intel Xeoni protsessori kiirenduspinu jaoks)

sysfs file	mmio väli	tüüp	juurdepääs
loe_tehing	gperf.VTD_AFU0_MEM_RD_TRANS	hex uint64_t	Kirjutuskaitstud
kirjuta_tehing	gperf.VTD_AFU0_MEM_WR_TRANS	hex uint64_t	Kirjutuskaitstud
tlb_read_hit	gperf.VTD_AFU0_TLB_RD_HIT	hex uint64_t	Kirjutuskaitstud
tlb_write_hit	gperf.VTD_AFU0_TLB_WR_HIT	hex uint64_t	Kirjutuskaitstud

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

sysfs file	mmio väli	tüüp	juurdepääs
lubada	gperf.fab_ctl. (lubatud)	kümnendkoha vahev	Kasutaja: kirjutuskaitstud Root: lugemine-kirjutamine
külmutada	gperf.fab_ctl.freeze	kümnendkoha vahev	Kasutaja: kirjutuskaitstud Root: lugemine-kirjutamine
pcie0_read	gperf.FAB_PCIE0_RD	hex uint64_t	Kirjutuskaitstud
pcie0_write	gperf.FAB_PCIE0_WR	hex uint64_t	Kirjutuskaitstud
pcie1_read	gperf.FAB_PCIE1_RD	hex uint64_t	Kirjutuskaitstud
pcie1_write	gperf.FAB_PCIE1_WR	hex uint64_t	Kirjutuskaitstud
upi_read	gperf.FAB_UPI_RD	hex uint64_t	Kirjutuskaitstud
upi_write	gperf.FAB_UPI_WR	hex uint64_t	Kirjutuskaitstud

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

sysfs file	mmio väli	tüüp	juurdepääs
pcie0_read	gperf.FAB_PCIE0_RD	hex uint64_t	Kirjutuskaitstud
pcie0_write	gperf.FAB_PCIE0_WR	hex uint64_t	Kirjutuskaitstud
pcie1_read	gperf.FAB_PCIE1_RD	hex uint64_t	Kirjutuskaitstud
pcie1_write	gperf.FAB_PCIE1_WR	hex uint64_t	Kirjutuskaitstud
upi_read	gperf.FAB_UPI_RD	hex uint64_t	Kirjutuskaitstud
upi_write	gperf.FAB_UPI_WR	hex uint64_t	Kirjutuskaitstud

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

sysfs file	mmio väli	tüüp	juurdepääs
id	port_header.capability.port_number	kümnendkoha vahev	Kirjutuskaitstud
ltr	port_header.control.latency_tolerance	kümnendkoha vahev	Kirjutuskaitstud

Port AFU päise sysfs files
intel-fpga-dev.i/intel-fpga-port.k/

sysfs file	mmio väli	tüüp	juurdepääs
afu_id	afu_header.guid	kuusteist 16-baiti	Kirjutuskaitstud

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

sysfs file	mmio väli	tüüp	juurdepääs
vead	perror.port_error	hex uint64_t	Kirjutuskaitstud
esimene_viga	perror.port_first_error	hex uint64_t	Kirjutuskaitstud
esimene_väärakujunenud_nõue	perror.malreq	kuusteist 16-baiti	Kirjutuskaitstud
selge	viga (kõik vead)	mitmesugused uint64_t	Ainult kirjutatav

Märkus.
Pordivigade kustutamiseks peate kirjutama praeguste vigade täpse bitmaski, ntample kassi vead > selge.

Läbivaatamise ajalugu

Dokumendi versioon	Muudatused
2017.10.02	Esialgne väljalase.

OPAE Intel FPGA Linuxi seadme draiveri arhitektuuri juhend

Dokumendid / Ressursid

intel OPAE FPGA Linuxi seadme draiveri arhitektuur [pdfKasutusjuhend OPAE FPGA Linuxi seadme draiveri arhitektuur, OPAE FPGA, Linuxi seadme draiveri arhitektuur, draiveri arhitektuur, arhitektuur

Viited

• Kasutusjuhend