intel OPAE FPGA Linux ierīces draivera arhitektūra

OPAE Intel FPGA Linux ierīces draivera arhitektūra

OPAE Intel FPGA draiveris nodrošina saskarnes lietotāja telpas lietojumprogrammām, lai konfigurētu, uzskaitītu, atvērtu FPGA paātrinātājus un piekļūtu tiem platformās, kas aprīkotas ar Intel FPGA risinājumiem, un nodrošina sistēmas līmeņa pārvaldības funkcijas, piemēram, FPGA pārkonfigurāciju, enerģijas pārvaldību un virtualizāciju.

Aparatūras arhitektūra

No OS viedokļa viewFPGA aparatūra parādās kā parasta PCIe ierīce. FPGA ierīces atmiņa tiek organizēta, izmantojot iepriekš noteiktu datu struktūru (Device Feature List). FPGA ierīces atbalstītās funkcijas tiek atklātas, izmantojot šīs datu struktūras, kā parādīts tālāk esošajā attēlā:

FPGA PCIe ierīce

Draiveris atbalsta PCIe SR-IOV, lai izveidotu virtuālās funkcijas (VF), kuras var izmantot, lai virtuālajām mašīnām piešķirtu atsevišķus paātrinātājus.

Intel korporācija. Visas tiesības aizsargātas. Intel, Intel logotips un citas Intel preču zīmes ir Intel Corporation vai tās meitasuzņēmumu preču zīmes. Intel garantē savu FPGA un pusvadītāju produktu veiktspēju atbilstoši pašreizējām specifikācijām saskaņā ar Intel standarta garantiju, taču patur tiesības jebkurā laikā bez brīdinājuma veikt izmaiņas jebkuros produktos un pakalpojumos. Intel neuzņemas nekādu atbildību vai saistības, kas izriet no jebkādas šeit aprakstītās informācijas, produkta vai pakalpojuma lietojuma vai izmantošanas, izņemot gadījumus, kad Intel ir nepārprotami rakstiski piekritis. Intel klientiem ieteicams iegūt jaunāko ierīces specifikāciju versiju, pirms paļauties uz jebkādu publicētu informāciju un pirms preču vai pakalpojumu pasūtījumu veikšanas.

Citi nosaukumi un zīmoli var tikt uzskatīti par citu personu īpašumu.

Virtualizēta FPGA PCIe ierīce

FPGA pārvaldības dzinējs (FME)
FPGA pārvaldības dzinējs veic jaudas un siltuma pārvaldību, kļūdu ziņošanu, pārkonfigurēšanu, veiktspējas atskaites un citas infrastruktūras funkcijas. Katrai FPGA ir viena FME, kurai vienmēr var piekļūt, izmantojot fizisko funkciju (PF). Lietotāju vietas lietojumprogrammas var iegūt ekskluzīvu piekļuvi FME, izmantojot open(), un atbrīvot to, izmantojot close() kā priviliģētu lietotāju (root).

Osta
Ports ir saskarne starp statisko FPGA audumu (“FPGA interfeisa pārvaldnieku (FIM)”) un daļēji pārkonfigurējamu reģionu, kurā ir paātrinātāja funkcija (AF). Ports kontrolē saziņu no programmatūras uz akseleratoru un atklāj tādas funkcijas kā atiestatīšana un atkļūdošana. PCIe ierīcei var būt vairāki porti, un katru portu var atvērt, izmantojot VF, piešķirot to, izmantojot FME ierīces FPGA_FME_PORT_ASSIGN ioctl.

Akseleratora funkcijas (AF) vienība

• Akseleratora funkcijas (AF) vienība ir pievienota pieslēgvietai, un tā atklāj 256 K MMIO reģionu, ko izmantot akseleratoram specifiskiem vadības reģistriem.
• Lietotāja vietas lietojumprogrammas var iegūt ekskluzīvu piekļuvi portam pievienotajam AFU, porta ierīcē izmantojot opciju open(), un atbrīvot to, izmantojot close().
• Lietotāja vietas lietojumprogrammas var arī mmap() paātrinātāja MMIO reģionus.

Daļēja pārkonfigurācija
Kā minēts iepriekš, paātrinātājus var pārkonfigurēt, daļēji pārkonfigurējot akseleratora funkciju (AF). file. Akseleratora funkcijai (AF) jābūt ģenerētai precīzam FIM un mērķētā FPGA statiskajam reģionam (Portam); pretējā gadījumā pārkonfigurācijas darbība neizdosies un, iespējams, izraisīs sistēmas nestabilitāti. Šo saderību var pārbaudīt, salīdzinot interfeisa ID, kas norādīts AF galvenē, ar saskarnes ID, ko FME atklāj, izmantojot sysfs. Šo pārbaudi parasti veic lietotāja telpa pirms pārkonfigurācijas IOCTL izsaukšanas.

Piezīme:
Pašlaik jebkura programmatūra, kas piekļūst FPGA, tostarp tās, kas darbojas virtualizētā resursdatorā, ir jāaizver pirms daļējas pārkonfigurācijas. Darbības būtu šādas:

1. Izlādējiet vadītāju no viesa
2. Atvienojiet VF no viesa
3. Atspējot SR-IOV
4. Veiciet daļēju pārkonfigurāciju
5. Iespējot SR-IOV
6. Pievienojiet VF pie viesa
7. Ielādējiet šoferi viesos

FPGA virtualizācija
Lai iespējotu piekļuvi akseleratoram no lietojumprogrammām, kas darbojas virtuālajā mašīnā, attiecīgais AFU ports ir jāpiešķir VF, veicot šādas darbības:

1. PF pēc noklusējuma pieder visi AFU porti. Jebkurš ports, kas atkārtoti jāpiešķir VF, vispirms ir jāatbrīvo no PF, izmantojot FME ierīces FPGA_FME_PORT_RELEASE ioctl.
2. Kad no PF ir atbrīvoti N porti, tālāk norādīto komandu var izmantot, lai iespējotu SRIOV un VF. Katram VF pieder tikai viens ports ar AFU. echo N > PCI_DEVICE_PATH/sriov_numvfs
3. Pāriet caur VF uz virtuālajām mašīnām.
4. AFU zem VF ir pieejams no VM lietojumprogrammām (izmantojot to pašu draiveri VF iekšpusē).

Piezīme:
FME nevar piešķirt VF, tāpēc PR un citas pārvaldības funkcijas ir pieejamas tikai caur PF.

Autovadītāju organizācija

PCIe moduļa ierīces draiveris

Autovadītāju organizācija

FPGA ierīces parādās kā parastas PCIe ierīces; tādējādi FPGA PCIe ierīces draiveris (intel-FPGA-PCI.ko) vienmēr tiek ielādēts pirmais, tiklīdz tiek atklāts FPGA PCIe PF vai VF. Šim draiverim ir infrastruktūras nozīme draivera arhitektūrā. Tas:

• Izveido FPGA konteinera ierīci kā funkciju ierīču vecāku.
• Izstaigā ierīču funkciju sarakstu, kas ir ieviests PCIe ierīces BAR atmiņā, lai atklātu funkciju ierīces un to apakšfunkcijas un izveidotu tām platformas ierīces zem konteinera ierīces.
• Atbalsta SR-IOV.
• Iepazīstina ar līdzekļu ierīču infrastruktūru, kas abstrahē darbības apakšfunkcijām un parāda kopīgās funkcijas līdzekļu ierīču draiveriem.

PCIe moduļa ierīces draivera funkcijas

• Ietver PCIe atklāšanu, ierīču uzskaiti un funkciju atklāšanu.
• Izveido sysfs direktorijus vecākajai ierīcei, FPGA pārvaldības programmai (FME) un portam.
• Izveido platformas draivera gadījumus, liekot Linux kodolam ielādēt attiecīgos platformas moduļu draiverus.

FME platformas moduļa ierīces draiveris

• Enerģijas un siltuma pārvaldība, kļūdu ziņošana, veiktspējas ziņošana un citas infrastruktūras funkcijas. Jūs varat piekļūt šīm funkcijām, izmantojot sysf saskarnes, kuras atklāj FME draiveris.
• Daļēja pārkonfigurācija. FME draiveris PR apakšfunkcijas inicializācijas laikā reģistrē FPGA pārvaldnieku; kad tas saņem no jums FPGA_FME_PORT_PR ioctl, tas izsauc kopējo interfeisa funkciju no FPGA pārvaldnieka, lai pabeigtu bitu straumes daļēju pārkonfigurēšanu uz doto portu.
• Portu pārvaldība virtualizācijai. FME draiveris ievieš divus ioctls, FPGA_FME_PORT_RELEASE, kas atbrīvo doto portu no PF; un FPGA_FME_PORT_ASSIGN, kas piešķir portu atpakaļ PF. Kad ports ir atbrīvots no PF, to var piešķirt VF, izmantojot SR-IOV saskarnes, ko nodrošina PCIe draiveris. Papildinformāciju skatiet sadaļā “FPGA virtualizācija”.

FME platformas moduļa ierīces draivera funkcijas

• Izveido FME rakstzīmju ierīces mezglu.
• Izveido FME sysfs files un ievieš FME sysfs file aksesuāri.
• Ievieš FME privāto funkciju apakšdraiveri.
• FME privāto funkciju apakšdraiveri:
  • FME galvene
  • Siltuma vadība
  • Enerģijas pārvaldība
  • Globāla kļūda
  • Daļēja pārkonfigurācija
  • Globālā veiktspēja

Porta platformas moduļa ierīces draiveris
Līdzīgi kā FME draiverim, FPGA porta (un AFU) draiveris (intel-fpga-afu. ko) tiek pārbaudīts, kad ir izveidota porta platformas ierīce. Šī moduļa galvenā funkcija ir nodrošināt saskarni lietotāja telpas lietojumprogrammām, lai piekļūtu atsevišķiem paātrinātājiem, ieskaitot pamata atiestatīšanas vadību portā, AFU MMIO reģiona eksportu, DMA bufera kartēšanas pakalpojumu, UMsg(1) paziņojumus un attālās atkļūdošanas funkcijas ( Skatīt iepriekš).

UMsg tiek atbalstīts tikai, izmantojot Intel Xeon® procesoru ar integrētu FPGA paredzēto paātrinājumu.

Portu platformas moduļa ierīces draivera funkcijas

• Izveido porta rakstzīmju ierīces mezglu.
• Izveido portu sysfs files un ievieš Port sysfs file aksesuāri.
• Ievieš Port privāto funkciju apakšdraiveri.
• Portu privāto funkciju apakšdraiveri:
  • Porta galvene
  • AFU
  • Porta kļūda
  • UMsg(2)
  • Signāla pieskāriens

Lietojumprogrammu FPGA ierīču uzskaitījums
Šajā sadaļā ir aprakstīts, kā lietojumprogrammas uzskaita FPGA ierīci no sysfs hierarhijas zem /sys/class/fpga. BijušajāampZemāk resursdatorā ir instalētas divas Intel FPGA ierīces. Katrai FPGA ierīcei ir viens FME un divi porti (AFU). Katrai FPGA ierīcei zem /sys/class/fpga tiek izveidots ierīču direktorijs:

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

Katram mezglam ir viens FME un divi porti (AFU) kā bērnu ierīces:
/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

Kopumā FME/Port sysfs saskarnes ir nosauktas šādi:
/sys/class/fpga/intel-fpga-dev.i/intel-fpga-fme.j/
/sys/class/fpga/intel-fpga-dev.i/intel-fpga-port.k/

ar I secīgi numurējot visas konteinera ierīces, j secīgi numurējot FME un k secīgi numurējot visas ostas.

Uz ierīces mezgliem, kas tiek izmantoti ioctl() un mmap(), var atsaukties, izmantojot:
/dev/intel-fpga-fme.j
/dev/intel-fpga-port.k

PCIe draiveru uzskaitījums
Šī sadaļa sniedz pārskatuview koda plūsmas ierīču uzskaitei, ko veic intel-fpga-pci.ko. Galvenās datu struktūras un funkcijas ir izceltas. Šo sadaļu vislabāk ievērot, kad viewpievienojot pievienoto pirmkodu (pcie.c).

Uzskaitīšanas datu struktūras

enum fpga_id_type {
PARENT_ID,
FME_ID,
PORT_ID,
FPGA_ID_MAX
};
statiskā struktūra idr fpga_ids[FPGA_ID_MAX];
struct fpga_chardev_info {
const char *nosaukums;
dev_t devt;
};
struct fpga_chardev_info fpga_chrdevs[] = {
{ .name = FPGA_FEATURE_DEV_FME },
{ .name = FPGA_FEATURE_DEV_PORT },
};
statiskās struktūras klase *fpga_class;
statiskā 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,}
};
statiskā 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 ierīces_id;
struct ierīce *fme_dev;
struct mutex lock;
struct list_head port_dev_list;
int atbrīvots_porta_numurs;
struct list_head regions;
};
struct build_feature_devs_info {
struct pci_dev *pdev;
spēkā neesošs __iomem *ioaddr;
spēkā neesošs __iomem *ioend;
int pašreizējā_josla;
spēkā neesošs __iomem *pfme_hdr;
struct ierīce *parent_dev;
struct platform_device *feature_dev;
};

Uzskaitīšanas plūsma

• ccidrv_init()
  • Inicializējiet fpga_ids, izmantojot idr_init().
  • Inicializējiet fpga_chrdevs[i].devt, izmantojot alloc_chrdev_region().
  • Inicializējiet fpga_class, izmantojot class_create().
  • pci_register_driver(&cci_pci_driver);
• cci_pci_probe()
  • Iespējojiet PCI ierīci, pieprasiet piekļuvi tās reģioniem, iestatiet PCI galveno režīmu un konfigurējiet DMA.
• cci_pci_create_feature_devs() build_info_alloc_and_init()
  • Piešķiriet struktūru build_feature_devs_info, inicializējiet to.
    .parent_dev ir iestatīts uz vecākdirektoriju sysfs (intel-fpga-dev.id), kurā ir FME un Port sysfs direktoriji.
• parse_feature_list()
  • Izstaigājiet BAR0 ierīču funkciju sarakstu, lai atklātu FME, portu un to privātās funkcijas.
• parse_feature() parse_feature_afus() parse_feature_fme()
  • Kad tiek konstatēts FME:
• build_info_create_dev()
  • Piešķiriet platformas ierīci FME, saglabājot to mapē build_feature_devs_info.feature_dev.
  • Feature_dev.id tiek inicializēts uz idr_alloc(fpga_ids[FME_ID],
  • feature_dev.parent ir iestatīts uz build_feature_devs_info.parent_dev.
  • Piešķiriet struktūras resursu masīvu failā feature_dev.resource.
• Piešķiriet struktūru feature_platform_data, inicializējiet to un saglabājiet rādītāju sadaļā feature_dev.dev.platform_data
  • create_feature_instance() build_info_add_sub_feature()
  • Inicializēt feature_dev.resource[FME_FEATURE_ID_HEADER].
  • feature_platform_data_add()
  • Inicializējiet feature_platform_data.features[FME_FEATURE_ID_HEADER], visu, izņemot .fops.
• parse_feature() parse_feature_afus() parse_feature_port()
  • Kad tiek konstatēts ports:
• build_info_create_dev()
  • Piešķiriet portam platformas ierīci, kas tiek saglabāta mapē build_feature_devs_info.feature_dev.
  • Feature_dev.id tiek inicializēts uz idr_alloc(fpga_ids[PORT_ID] rezultātu,
  • feature_dev.parent ir iestatīts uz build_feature_devs_info.parent_dev.
  • Piešķiriet struct resursa masīvu failā feature_dev.resource.
  • Piešķiriet struktūru feature_platform_data, inicializējiet to un saglabājiet rādītāju sadaļā feature_dev.dev.platform_data
• build_info_commit_dev()
  • Pievienojiet porta struct feature_platform_data.node portu sarakstam struct cci_drvdata.port_dev_list.
• create_feature_instance() build_info_add_sub_feature()
  • Inicializēt feature_dev.resource[PORT_FEATURE_ID_HEADER].
• feature_platform_data_add()
  • Inicializējiet feature_platform_data.features[PORT_FEATURE_ID_HEADER], visu, izņemot .fops.
• parse_feature() parse_feature_afus() parse_feature_port_uafu()
  • Kad tiek konstatēts AFU:
• create_feature_instance() build_info_add_sub_feature()
  • Inicializēt feature_dev.resource[PORT_FEATURE_ID_UAFU].
• feature_platform_data_add()
  • Inicializējiet feature_platform_data.features[PORT_FEATURE_ID_UAFU], visu, izņemot .fops.
• parse_feature() parse_feature_private() parse_feature_fme_private()
  • Ja tiek konstatēta FME privātā funkcija:
• create_feature_instance() build_info_add_sub_feature()
  • Inicializējiet feature_dev.resource[id].
• feature_platform_data_add()
  • Inicializējiet feature_platform_data.features[id], visu, izņemot .fops.
• parse_feature() parse_feature_private() parse_feature_port_private()
• Ja tiek atklāts porta privātais līdzeklis: * create_feature_instance() build_info_add_sub_feature() * Inicializējiet funkciju_dev.resource[id]. * feature_platform_data_add() Inicializējiet feature_platform_data.features[id], visu, izņemot .fops.
• parse_ports_from_fme()
  • Ja draiveris ir ielādēts fiziskajā funkcijā (PF), tad:
• Palaidiet parse_feature_list() plūsmu katrā portā, kas aprakstīts FME galvenē.
• Izmantojiet BAR, kas minēts katrā porta ierakstā galvenē.

FME platformas ierīces inicializācija
Šī sadaļa sniedz pārskatuview koda plūsmas FME ierīces inicializēšanai, ko veic intel-fpga-fme.ko. Galvenās datu struktūras un funkcijas ir izceltas. Šo sadaļu vislabāk ievērot, kad viewpievienojot pievienoto avota kodu (fme-main.c).

FME platformas ierīču datu struktūras

struct feature_ops {
int (*init)(struct platform_device *pdev, struct iezīme *funkcija);
int (*uinit)(struct platform_device *pdev, struct iezīme *funkcija);
garš (*ioctl) (struct platform_device *pdev, struct iezīme *funkcija,
neparakstīts int cmd, neparakstīts garš arg);
int (*test)(struct platform_device *pdev, struct iezīme *funkcija);
};
struct iezīme {
const char *nosaukums;
int resursa_indekss;
spēkā neesošs __iomem *ioaddr;
struct feature_ops *ops;
};
struct feature_platform_data {
struct list_head node;
struct mutex lock;
neparakstīts garš dev_status;
struct cdev cdev;
struct platform_device *dev;
neparakstīts int disable_count;
spēkā neesošs *privāts;
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
funkciju iezīmes[0];
};
struct perf_object {
int id;
const struct atribūtu_grupa **attr_groups;
struct ierīce *fme_dev;
struct list_head node;
struct list_head bērni;
struct kobject kobj;
};
struct fpga_fme {
u8 porta_id;
u64 pr_err;
struct ierīce *dev_err;
struct perf_object *perf_dev;
struct iezīme_platformas_data *pdata;
};

FME platformas ierīces inicializācijas plūsma

FME inicializācijas plūsma

• fme_probe() fme_dev_init()
  • Inicializējiet struct fpga_fme un saglabājiet to laukā feature_platform_data.private.
• fme_probe() fpga_dev_feature_init() feature_instance_init()
  • Katram aizpildītajam objektam saglabājiet struct feature_ops sadaļā feature_platform_data.features.
  • Izsauciet testa funkciju, ja tāda ir, no struktūras.
  • Izsauciet funkciju init no struktūras.
• fme_probe() fpga_register_dev_ops()
  • Izveidojiet FME rakstzīmju ierīces mezglu, reģistrējot struktūru file_operācijas.

Porta platformas ierīces inicializācija
Šī sadaļa sniedz pārskatuview koda plūsmas porta ierīces inicializācijai, ko veic intel-fpga-afu.ko. Galvenās datu struktūras un funkcijas ir izceltas. Šo sadaļu vislabāk ievērot, kad viewpievienojot pievienoto pirmkodu (afu.c).

Portu platformas ierīču datu struktūras

struct feature_ops {
int (*init)(struct platform_device *pdev, struct iezīme *funkcija);
int (*uinit)(struct platform_device *pdev, struct iezīme *funkcija);
garš (*ioctl) (struct platform_device *pdev, struct iezīme *funkcija,
neparakstīts int cmd, neparakstīts garš arg);
int (*test)(struct platform_device *pdev, struct iezīme *funkcija);
};
struct iezīme {
const char *nosaukums;
int resursa_indekss;
spēkā neesošs __iomem *ioaddr;
struct feature_ops *ops;
};
struct feature_platform_data {
struct list_head node;
struct mutex lock;
neparakstīts garš dev_status;
struct cdev cdev;
struct platform_device *dev;
neparakstīts int disable_count;
spēkā neesošs *privāts;
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 iezīme iezīmes[0];
};
struct fpga_afu_region {
u32 indekss;
u32 karogi;
u64 izmērs;
u64 nobīde;
u64 fiz.
struct list_head node;
};
struct fpga_afu_dma_region {
u64 lietotāja_adrese;
u64 garums;
u64 iova;
struct lapa **lapas;
struct rb_node node;
bool in_use;
};
struct fpga_afu {
u64 region_cur_offset;
int reģionu skaits;
u8 num_umsgs;
struct list_head regions;
struct rb_root dma_regions;
struct iezīme_platformas_data *pdata;
};

Portu platformas ierīces inicializācijas plūsma

Porta inicializācijas plūsma

• afu_probe() afu_dev_init()
  • Inicializējiet struktūru fpga_afu un saglabājiet to laukā feature_platform_data.private.
• afu_probe() fpga_dev_feature_init() feature_instance_init()
  • Katram aizpildītajam objektam saglabājiet struct feature_ops sadaļā feature_platform_data.features.
  • Izsauciet testa funkciju, ja tāda ir, no struktūras.
  • Izsauciet funkciju init no struktūras.
• afu_probe() fpga_register_dev_ops()
  • Izveidojiet Port rakstzīmju ierīces mezglu, reģistrējot struktūru file_operācijas.

FME IOCTL
IOCTL, kas tiek izsaukti atvēršanas laikā file deskriptors /dev/intel-fpga-fme.j FPGA_GET_API_VERSION — atgriež pašreizējo versiju kā veselu skaitli, sākot no 0.

FPGA_CHECK_EXTENSION — pašlaik netiek atbalstīts.

FPGA_FME_PORT_RELEASE — arg ir rādītājs uz:

struct fpga_fme_port_release {
__u32 argsz; // in: sizeof(struct fpga_fme_port_release)
__u32 karodziņi; // in: jābūt 0
__u32 porta_id; // iekšā: porta ID (no 0), lai atbrīvotu.
};

FPGA_FME_PORT_ASSIGN — arg ir rādītājs uz:

struct fpga_fme_port_assign {
__u32 argsz; // in: sizeof(struct fpga_fme_port_assign)
__u32 karodziņi; // in: jābūt 0
__u32 porta_id; // in: porta ID (no 0), lai piešķirtu. (vajadzēja būt
iepriekš izlaida FPGA_FME_PORT_RELEASE)
};

FPGA_FME_PORT_PR — arg ir rādītājs uz:

struct fpga_fme_port_pr {
__u32 argsz; // in: sizeof(struct fpga_fme_port_pr)
__u32 karodziņi; // in: jābūt 0
__u32 porta_id; // iekšā: porta ID (no 0)
__u32 bufera_izmērs; // in: bitu plūsmas bufera lielums baitos. Jābūt 4 baitiem
izlīdzināts.
__u64 bufera_adrese; // in: bitu plūsmas bufera procesa adrese
__u64 statuss; // out: kļūdas statuss (bitmaska)
};

Ostas IOCTL
IOCTL, kas tiek izsaukti atvēršanas laikā file /dev/intel-fpga-port.k deskriptors FPGA_GET_API_VERSION — atgriež pašreizējo versiju kā veselu skaitli, sākot no 0. FPGA_CHECK_EXTENSION — pašlaik netiek atbalstīts.

FPGA_PORT_GET_INFO — arg ir rādītājs uz:

struct fpga_port_info {
__u32 argsz; // in: sizeof(struct fpga_port_info)
__u32 karogi; // ārā: atgriež 0
__u32 reģionu skaits; // ārā: MMIO reģionu skaits, 2 (1 AFU un 1 —
STP)
__u32 num_umsgs; // out: aparatūras atbalstīto UMsg skaits
};

FPGA_PORT_GET_REGION_INFO — arg ir rādītājs uz:

struct fpga_port_region_info {
__u32 argsz; // in: sizeof(struct fpga_port_region_info)
__u32 karodziņi; // out: (bitmask) { FPGA_REGION_READ, FPGA_REGION_WRITE,
FPGA_REGION_MMAP}
__u32 indekss; // iekšā: FPGA_PORT_INDEX_UAFU vai FPGA_PORT_INDEX_STP
__u32 polsterējums; // in: jābūt 0
__u64 izmērs; // out: MMIO apgabala lielums baitos
__u64 nobīde; // out: MMIO apgabala nobīde no ierīces fd sākuma
};

FPGA_PORT_DMA_MAP — arg ir rādītājs uz:
struct fpga_port_dma_map {
__u32 argsz; // in: sizeof(struct fpga_port_dma_map)
__u32 karodziņi; // in: jābūt 0 __u64 user_addr; // in: process virtual
adrese. Jāizlīdzina lapa.
__u64 garums; // in: kartēšanas garums baitos. Jābūt vairākas lapas
izmērs.
__u64 iova; // out: IO virtuālā adrese };

FPGA_PORT_DMA_UNMAP — arg ir rādītājs uz:
struct fpga_port_dma_unmap {
__u32 argsz; // in: sizeof(struct fpga_port_dma_unmap)
__u32 karodziņi; // in: jābūt 0
__u64 iova; // in: IO virtuālā adrese, ko atgriezusi iepriekšējā
FPGA_PORT_DMA_MAP};

• FPGA_PORT_RESET — arg ir jābūt NULL.
• FPGA_PORT_UMSG_ENABLE — arg ir jābūt NULL.
• FPGA_PORT_UMSG_DISABLE — parametriem jābūt NULL.

FPGA_PORT_UMSG_SET_MODE — arg ir rādītājs uz:

struct fpga_port_umsg_cfg {
__u32 argsz; // in: sizeof(struct fpga_port_umsg_cfg)
__u32 karodziņi; // in: jābūt 0
__u32 hint_bitmap; // in: UMsg mājienu režīma bitkarte. Norāda, kuri ir UMsg
iespējots.
};

FPGA_PORT_UMSG_SET_BASE_ADDR —

• Pirms šī ioctl izdošanas UMsg ir jāatspējo.
• Iova laukam ir jābūt pietiekami lielam buferim visiem UMsg (num_umsgs * PAGE_SIZE).
  • Vadītāja bufera pārvaldība buferis ir atzīmēts kā “izmantots”.
  • Ja iova ir NULL, jebkurš iepriekšējais reģions netiek atzīmēts kā “izmantots”.
• arg ir rādītājs uz:
  struct fpga_port_umsg_base_addr {
  • u32 argsz; // in: sizeof(struct fpga_port_umsg_base_addr)
  • u32 karogi; // in: jābūt 0
  • u64 iova; // in: IO virtuālā adrese no FPGA_PORT_DMA_MAP. };

Piezīme:

• Lai notīrītu porta kļūdas, jums ir jāieraksta precīza pašreizējo kļūdu bitmaska, piemēram,ample, kaķa kļūdas > skaidrs
• UMsg tiek atbalstīts tikai, izmantojot Intel Xeon procesoru ar integrētu FPGA paredzēto paātrinājumu.

sysfs Files

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

sysfs file	mmio lauks	veids	piekļuvi
portu_numurs	fme_header.capability.num_ports	decimāldaļas starp	Tikai lasāms
cache_size	fme_header.capability.cache_size	decimāldaļas starp	Tikai lasāms
versija	fme_header.capability.fabric_verid	decimāldaļas starp	Tikai lasāms
ligzdas_id	fme_header.capability.socket_id	decimāldaļas starp	Tikai lasāms
bitstream_id	fme_header.bitstream_id	hex uint64_t	Tikai lasāms
bitstream_metadata	fme_header.bitstream_md	hex uint64_t	Tikai lasāms

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

sysfs file	mmio lauks	veids	piekļuvi
slieksnis1	thermo.threshold.tmp_thshold1	decimāldaļas starp	Lietotājs: tikai lasāms Sakne: lasīšana-rakstīšana
slieksnis2	thermo.threshold.tmp_thshold2	decimāldaļas starp	Lietotājs: tikai lasāms Sakne: lasīšana-rakstīšana
slieksnis_ceļojums	thermo.threshold.therm_trip_thshold	decimāldaļas starp	Tikai lasāms
slieksnis1_sasniegts	thermo.threshold.thshold1_status	decimāldaļas starp	Tikai lasāms
slieksnis2_sasniegts	thermo.threshold.thshold2_status	decimāldaļas starp	Tikai lasāms
slieksnis1_politika	termiskais. slieksnis.thshold_policy	decimāldaļas starp	Lietotājs: tikai lasāms Sakne: lasīšana-rakstīšana
temperatūra	thermo.rdsensor_fm1.fpga_temp	decimāldaļas starp	Tikai lasāms

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

sysfs file	mmio lauks	veids	piekļuvi
patērēts	power.status.pwr_consumed	hex uint64_t	Tikai lasāms
slieksnis1	jauda.slieksnis.slieksnis1	hex uint64_t	Lietotājs: tikai lasāms Sakne: lasīšana-rakstīšana
slieksnis2	jauda.slieksnis.slieksnis2	hex uint64_t	Lietotājs: tikai lasāms Sakne: lasīšana-rakstīšana
slieksnis1_statuss	power.threshold.threshold1_status	decimāldaļa bez paraksta	Tikai lasāms
slieksnis2_statuss	power.threshold.threshold2_status	decimāldaļa bez paraksta	Tikai lasāms
rtl	power.status.fpga_latency_report	decimāldaļa bez paraksta	Tikai lasāms

FME globālā kļūda sysfs files
intel-fpga-dev.i/intel-fpga-fme.j/errors/

sysfs file	mmio lauks	veids	piekļuvi
pcie0_errors	gerror.pcie0_err	hex uint64_t	Lasīt rakstīt
pcie1_errors	gerror.pcie1_err	hex uint64_t	Lasīt rakstīt
inject_error	gerror.ras_error_inj	hex uint64_t	Lasīt rakstīt

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

sysfs file	mmio lauks	veids	piekļuvi
kļūdas	gerror.fme_err	hex uint64_t	Tikai lasāms
pirmā_kļūda	gerror.fme_first_err.err_reg_status	hex uint64_t	Tikai lasāms
nākamā_kļūda	gerror.fme_next_err.err_reg_status	hex uint64_t	Tikai lasāms
skaidrs	Notīra kļūdas, first_error, next_error	dažādi uint64_t	Tikai rakstīšanai

Piezīme:
Lai notīrītu FME kļūdas, jums jāieraksta precīza pašreizējo kļūdu bitmaska, piemēram,ample cat errors > skaidrs.

FME daļēja pārkonfigurācija sysfs files
intel-fpga-dev.i/intel-fpga-fme.j/pr/

sysfs file	mmio lauks	veids	piekļuvi
interfeisa_id	pr.fme_pr_intfc_id0_h, pr.fme_pre_intfc_id0_l	hex 16 baiti	Tikai lasāms

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

sysfs file	mmio lauks	veids	piekļuvi
pulkstenis	gperf.clk.afu_interf_clock	hex uint64_t	Tikai lasāms

intel-fpga-dev.i/intel-fpga-fme.j/dperf/cache/ (nav derīgs Intel Xeon CPU ar FPGA paātrinājuma steksam)

sysfs file	mmio lauks	veids	piekļuvi
iesaldēt	gperf.ch_ctl.freeze	decimāldaļas starp	Lasīt rakstīt
lasīt_trāpījums	gperf.CACHE_RD_HIT	hex uint64_t	Tikai lasāms
lasīt_pietrūkst	gperf.CACHE_RD_MISS	hex uint64_t	Tikai lasāms
write_hit	gperf.CACHE_WR_HIT	hex uint64_t	Tikai lasāms
rakstīt_pietrūkst	gperf.CACHE_WR_MISS	hex uint64_t	Tikai lasāms
hold_request	gperf.CACHE_HOLD_REQ	hex uint64_t	Tikai lasāms
tx_req_stall	gperf.CACHE_TX_REQ_STALL	hex uint64_t	Tikai lasāms

sysfs file	mmio lauks	veids	piekļuvi
rx_req_stall	gperf.CACHE_RX_REQ_STALL	hex uint64_t	Tikai lasāms
data_write_port_contention	gperf.CACHE_DATA_WR_PORT_CONTEN	hex uint64_t	Tikai lasāms
tag_write_port_contention	gperf.CACHE_TAG_WR_PORT_CONTEN	hex uint64_t	Tikai lasāms

intel-fpga-dev.i/intel-fpga-fme.j/dperf/iommu/ (nav derīga Intel Xeon CPU ar FPGA paātrinājuma steksam)

sysfs file	mmio lauks	veids	piekļuvi
iesaldēt	gperf.vtd_ctl.freeze	decimāldaļas starp	Lietotājs: tikai lasāms Sakne: lasīšana-rakstīšana

intel-fpga-dev.i/intel-fpga-fme.j/dperf/iommu/afuk/ (Nav derīga Intel Xeon CPU ar FPGA paātrinājuma steksam)

sysfs file	mmio lauks	veids	piekļuvi
read_transaction	gperf.VTD_AFU0_MEM_RD_TRANS	hex uint64_t	Tikai lasāms
write_transaction	gperf.VTD_AFU0_MEM_WR_TRANS	hex uint64_t	Tikai lasāms
tlb_read_hit	gperf.VTD_AFU0_TLB_RD_HIT	hex uint64_t	Tikai lasāms
tlb_write_hit	gperf.VTD_AFU0_TLB_WR_HIT	hex uint64_t	Tikai lasāms

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

sysfs file	mmio lauks	veids	piekļuvi
iespējot	gperf.fab_ctl. (iespējots)	decimāldaļas starp	Lietotājs: tikai lasāms Sakne: lasīšana-rakstīšana
iesaldēt	gperf.fab_ctl.freeze	decimāldaļas starp	Lietotājs: tikai lasāms Sakne: lasīšana-rakstīšana
pcie0_read	gperf.FAB_PCIE0_RD	hex uint64_t	Tikai lasāms
pcie0_write	gperf.FAB_PCIE0_WR	hex uint64_t	Tikai lasāms
pcie1_read	gperf.FAB_PCIE1_RD	hex uint64_t	Tikai lasāms
pcie1_write	gperf.FAB_PCIE1_WR	hex uint64_t	Tikai lasāms
upi_read	gperf.FAB_UPI_RD	hex uint64_t	Tikai lasāms
upi_write	gperf.FAB_UPI_WR	hex uint64_t	Tikai lasāms

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

sysfs file	mmio lauks	veids	piekļuvi
pcie0_read	gperf.FAB_PCIE0_RD	hex uint64_t	Tikai lasāms
pcie0_write	gperf.FAB_PCIE0_WR	hex uint64_t	Tikai lasāms
pcie1_read	gperf.FAB_PCIE1_RD	hex uint64_t	Tikai lasāms
pcie1_write	gperf.FAB_PCIE1_WR	hex uint64_t	Tikai lasāms
upi_read	gperf.FAB_UPI_RD	hex uint64_t	Tikai lasāms
upi_write	gperf.FAB_UPI_WR	hex uint64_t	Tikai lasāms

Porta galvenes sysfs files
intel-fpga-dev.i/intel-fpga-port.k/

sysfs file	mmio lauks	veids	piekļuvi
id	port_header.capability.port_number	decimāldaļas starp	Tikai lasāms
ltr	port_header.control.latency_tolerance	decimāldaļas starp	Tikai lasāms

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

sysfs file	mmio lauks	veids	piekļuvi
afu_id	afu_header.guid	hex 16 baiti	Tikai lasāms

Porta kļūda sysfs files
intel-fpga-dev.i/intel-fpga-port.k/errors/

sysfs file	mmio lauks	veids	piekļuvi
kļūdas	perror.port_error	hex uint64_t	Tikai lasāms
pirmā_kļūda	perror.port_first_error	hex uint64_t	Tikai lasāms
pirmais_malformed_req	perror.malreq	hex 16 baiti	Tikai lasāms
skaidrs	kļūda (visas kļūdas)	dažādi uint64_t	Tikai rakstīšanai

Piezīme:
Lai notīrītu porta kļūdas, jums jāieraksta precīza pašreizējo kļūdu bitmaska, piemēram,ample cat errors > skaidrs.

Pārskatīšanas vēsture

Dokumenta versija	Izmaiņas
2017.10.02	Sākotnējā izlaišana.

OPAE Intel FPGA Linux ierīces draivera arhitektūras rokasgrāmata

Dokumenti / Resursi

intel OPAE FPGA Linux ierīces draivera arhitektūra [pdfLietotāja rokasgrāmata OPAE FPGA Linux ierīces draivera arhitektūra, OPAE FPGA, Linux ierīces draivera arhitektūra, draivera arhitektūra, arhitektūra

Atsauces

• Lietotāja rokasgrāmata