architektura ovladačů zařízení intel OPAE FPGA Linux

Architektura ovladačů zařízení pro operační systém Intel FPGA Linux

Ovladač OPAE Intel FPGA poskytuje rozhraní pro aplikace v uživatelském prostoru pro konfiguraci, výčet, otevírání a přístup k akcelerátorům FPGA na platformách vybavených řešeními Intel FPGA a umožňuje funkce správy na úrovni systému, jako je rekonfigurace FPGA, správa napájení a virtualizace.

Hardwarová architektura

Z pohledu OS viewFPGA hardware vypadá jako běžné PCIe zařízení. Paměť zařízení FPGA je organizována pomocí předdefinované datové struktury (Device Feature List). Funkce podporované zařízením FPGA jsou vystaveny prostřednictvím těchto datových struktur, jak je znázorněno níže na následujícím obrázku:

Zařízení FPGA PCIe

Ovladač podporuje PCIe SR-IOV pro vytváření virtuálních funkcí (VF), které lze použít k přiřazení jednotlivých akcelerátorů virtuálním strojům.

Intel Corporation. Všechna práva vyhrazena. Intel, logo Intel a další značky Intel jsou ochranné známky společnosti Intel Corporation nebo jejích dceřiných společností. Společnost Intel zaručuje výkon svých FPGA a polovodičových produktů podle aktuálních specifikací v souladu se standardní zárukou společnosti Intel, ale vyhrazuje si právo provádět změny jakýchkoli produktů a služeb kdykoli bez upozornění. Společnost Intel nepřebírá žádnou odpovědnost nebo závazky vyplývající z aplikace nebo použití jakýchkoli informací, produktů nebo služeb popsaných v tomto dokumentu, pokud to není výslovně písemně odsouhlaseno společností Intel. Zákazníkům společnosti Intel se doporučuje získat nejnovější verzi specifikací zařízení dříve, než se budou spoléhat na jakékoli zveřejněné informace a než zadají objednávky na produkty nebo služby.

Jiná jména a značky mohou být nárokovány jako vlastnictví jiných.

Virtualizované FPGA PCIe zařízení

FPGA Management Engine (FME)
FPGA Management Engine provádí správu napájení a teploty, hlášení chyb, rekonfiguraci, hlášení výkonu a další funkce infrastruktury. Každé FPGA má jeden FME, ke kterému je vždy přístup prostřednictvím fyzické funkce (PF). Aplikace v uživatelském prostoru mohou získat výhradní přístup k FME pomocí open() a uvolnit jej pomocí close() jako privilegovaný uživatel (root).

Přístav
Port představuje rozhraní mezi statickou strukturou FPGA („FPGA Interface Manager (FIM)“) a částečně rekonfigurovatelnou oblastí obsahující funkci akcelerátoru (AF). Port řídí komunikaci ze softwaru do akcelerátoru a zpřístupňuje funkce, jako je reset a ladění. Zařízení PCIe může mít několik portů a každý port lze zpřístupnit prostřednictvím VF jeho přiřazením pomocí ioctl FPGA_FME_PORT_ASSIGN na zařízení FME.

Jednotka funkce akcelerátoru (AF).

• Jednotka Accelerator Function (AF) je připojena k portu a zpřístupňuje oblast 256K MMIO, kterou lze použít pro řídicí registry specifické pro akcelerátor.
• Aplikace v uživatelském prostoru mohou získat výhradní přístup k AFU připojenému k portu pomocí open() na zařízení Port a uvolnit jej pomocí close().
• Aplikace v uživatelském prostoru mohou také oblasti MMIO akcelerátoru mmap().

Částečná rekonfigurace
Jak bylo uvedeno výše, akcelerátory lze překonfigurovat prostřednictvím částečné rekonfigurace funkce akcelerátoru (AF) file. Funkce akcelerátoru (AF) musí být vygenerována pro přesnou FIM a cílovou statickou oblast (Port) FPGA; jinak se operace rekonfigurace nezdaří a může způsobit nestabilitu systému. Tuto kompatibilitu lze zkontrolovat porovnáním ID rozhraní uvedeného v záhlaví AF s ID rozhraní vystaveným FME prostřednictvím sysfs. Tuto kontrolu obvykle provádí uživatelský prostor před voláním rekonfiguračního IOCTL.

Poznámka:
V současné době musí být jakýkoli softwarový program přistupující k FPGA, včetně těch, které běží na virtualizovaném hostiteli, před pokusem o částečnou rekonfiguraci ukončen. Kroky by byly:

1. Vyjměte ovladač od hosta
2. Odpojte VF od hosta
3. Zakázat SR-IOV
4. Proveďte částečnou rekonfiguraci
5. Povolit SR-IOV
6. Připojte VF k hostovi
7. Nahrajte ovladač do hosta

Virtualizace FPGA
Chcete-li povolit přístup k akcelerátoru z aplikací spuštěných na virtuálním počítači, je třeba příslušný port AFU přiřadit k VF pomocí následujících kroků:

1. PF ve výchozím nastavení vlastní všechny porty AFU. Jakýkoli port, který je třeba znovu přiřadit k VF, musí být nejprve uvolněn z PF prostřednictvím ioctl FPGA_FME_PORT_RELEASE na zařízení FME.
2. Po uvolnění N portů z PF lze níže uvedený příkaz použít k povolení SRIOV a VF. Každý VF vlastní pouze jeden port s AFU. echo N > PCI_DEVICE_PATH/sriov_numvfs
3. Projděte virtuálními počítači do virtuálních počítačů.
4. AFU pod VF je přístupné z aplikací ve VM (pomocí stejného ovladače uvnitř VF).

Poznámka:
FME nelze přiřadit k VF, takže PR a další funkce řízení jsou dostupné pouze prostřednictvím PF.

Organizace řidičů

Ovladač zařízení modulu PCIe

Organizace řidičů

Zařízení FPGA se jeví jako běžná zařízení PCIe; tedy ovladač zařízení FPGA PCIe (intel-FPGA-PCI.ko) je vždy načten jako první, jakmile je detekován FPGA PCIe PF nebo VF. Tento ovladač hraje roli infrastruktury v architektuře ovladače. To:

• Vytvoří kontejnerové zařízení FPGA jako nadřazené zařízení funkcí.
• Prochází seznamem funkcí zařízení, který je implementován v paměti BAR zařízení PCIe, aby objevil zařízení funkcí a jejich dílčí funkce a vytvořil pro ně platformová zařízení pod kontejnerovým zařízením.
• Podporuje SR-IOV.
• Představuje infrastrukturu zařízení funkcí, která abstrahuje operace pro dílčí funkce a zpřístupňuje běžné funkce ovladačům zařízení.

Funkce ovladače zařízení modulu PCIe

• Obsahuje zjišťování PCIe, výčet zařízení a zjišťování funkcí.
• Vytváří adresáře sysfs pro nadřazené zařízení, FPGA Management Engine (FME) a ​​Port.
• Vytvoří instance ovladačů platformy, což způsobí, že linuxové jádro načte příslušné ovladače platforem.

Ovladač zařízení FME Platform Module

• Správa napájení a teploty, hlášení chyb, hlášení výkonu a další funkce infrastruktury. K těmto funkcím můžete přistupovat prostřednictvím rozhraní sysfs vystavených ovladačem FME.
• Částečná rekonfigurace. Ovladač FME registruje správce FPGA během inicializace dílčí funkce PR; jakmile od vás obdrží ioctl FPGA_FME_PORT_PR, vyvolá funkci společného rozhraní ze Správce FPGA, aby dokončil částečnou rekonfiguraci bitového toku na daný port.
• Správa portů pro virtualizaci. Ovladač FME zavádí dva ioctly, FPGA_FME_PORT_RELEASE, které uvolňují daný port z PF; a FPGA_FME_PORT_ASSIGN, který přiřadí port zpět k PF. Jakmile je port uvolněn z PF, může být přiřazen k VF prostřednictvím rozhraní SR-IOV poskytovaných ovladačem PCIe. Další informace naleznete v části „Virtualizace FPGA“.

Funkce ovladače zařízení FME Platform Module

• Vytvoří uzel znakového zařízení FME.
• Vytvoří FME sysfs files a implementuje FME sysfs file příslušenství.
• Implementuje dílčí ovladače soukromých funkcí FME.
• Dílčí ovladače soukromých funkcí FME:
  • Záhlaví FME
  • Tepelný management
  • Správa napájení
  • Globální chyba
  • Částečná rekonfigurace
  • Globální výkon

Ovladač zařízení modulu Port Platform
Podobně jako u ovladače FME je po vytvoření zařízení platformy Port testován ovladač portu FPGA (a AFU) (intel-fpga-afu. ko). Hlavní funkcí tohoto modulu je poskytnout rozhraní pro aplikace v uživatelském prostoru pro přístup k jednotlivým akcelerátorům, včetně ovládání základního resetu na portu, exportu regionu AFU MMIO, služby mapování vyrovnávací paměti DMA, upozornění UMsg(1) a funkcí vzdáleného ladění ( viz výše).

UMsg je podporováno pouze prostřednictvím Acceleration Stack pro procesor Intel Xeon® s integrovaným FPGA.

Funkce ovladače zařízení modulu Port Platform

• Vytvoří uzel znakového zařízení portu.
• Vytvoří Port sysfs files a implementuje Port sysfs file příslušenství.
• Implementuje dílčí ovladače funkce Port private.
• Dílčí ovladače pro soukromé funkce portu:
  • Záhlaví portu
  • AFU
  • Chyba portu
  • UMsg(2)
  • Klepněte na signál

Aplikace Výčet zařízení FPGA
Tato část uvádí, jak aplikace vyčíslují zařízení FPGA z hierarchie sysfs pod /sys/class/fpga. V exampNíže jsou v hostiteli nainstalována dvě zařízení Intel FPGA. Každé zařízení FPGA má jeden FME a dva porty (AFU). Pro každé zařízení FPGA je vytvořen adresář zařízení pod /sys/class/fpga:

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

Každý uzel má jeden FME a dva porty (AFU) jako podřízená zařízení:
/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

Obecně jsou rozhraní FME/Port sysfs pojmenována takto:
/sys/class/fpga/intel-fpga-dev.i/intel-fpga-fme.j/
/sys/class/fpga/intel-fpga-dev.i/intel-fpga-port.k/

s I postupným číslováním všech kontejnerových zařízení, j postupným číslováním FME a k postupným číslováním všech portů.

Na uzly zařízení používané pro ioctl() a mmap() lze odkazovat pomocí:
/dev/intel-fpga-fme.j
/dev/intel-fpga-port.k

Výčet ovladačů PCIe
Tato sekce dává konecview toku kódu pro výčet zařízení prováděný intel-fpga-pci.ko. Hlavní datové struktury a funkce jsou zvýrazněny. Tento oddíl je nejlépe dodržet, když viewv doprovodném zdrojovém kódu (pcie.c).

Výčtové datové struktury

enum fpga_id_type {
PARENT_ID,
FME_ID,
PORT_ID,
FPGA_ID_MAX
};
statická struktura idr fpga_ids[FPGA_ID_MAX];
struct fpga_chardev_info {
const char *jméno;
dev_t devt;
};
struct fpga_chardev_info fpga_chrdevs[] = {
{ .name = FPGA_FEATURE_DEV_FME },
{ .name = FPGA_FEATURE_DEV_PORT },
};
statická struct class *fpga_class;
statická struktura 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,}
};
statická struktura 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 device_id;
struct device *fme_dev;
struct mutex lock;
struct list_head port_dev_list;
int číslo_uvolněného_portu;
struct list_head regiony;
};
struct build_feature_devs_info {
struct pci_dev *pdev;
void __iomem *ioaddr;
void __iomem *ioend;
int aktuální_bar;
void __iomem *pfme_hdr;
struct zařízení *parent_dev;
struct platform_device *feature_dev;
};

Tok výčtu

• ccidrv_init()
  • Inicializujte fpga_ids pomocí idr_init().
  • Inicializujte fpga_chrdevs[i].devt pomocí alloc_chrdev_region().
  • Inicializujte fpga_class pomocí class_create().
  • pci_register_driver(&cci_pci_driver);
• cci_pci_probe()
  • Povolte zařízení PCI, požádejte o přístup k jeho regionům, nastavte režim PCI master a nakonfigurujte DMA.
• cci_pci_create_feature_devs() build_info_alloc_and_init()
  • Přidělte strukturu build_feature_devs_info, inicializujte ji.
    .parent_dev je nastaven na nadřazený adresář sysfs (intel-fpga-dev.id), který obsahuje adresáře FME a Port sysfs.
• parse_feature_list()
  • Projděte si seznam funkcí zařízení BAR0 a objevte FME, port a jejich soukromé funkce.
• parse_feature() parse_feature_afus() parse_feature_fme()
  • Když narazíte na FME:
• build_info_create_dev()
  • Přidělte platformové zařízení pro FME a uložte jej do build_feature_devs_info.feature_dev.
  • feature_dev.id je inicializován na výsledek idr_alloc(fpga_ids[FME_ID],
  • feature_dev.parent je nastaven na build_feature_devs_info.parent_dev.
  • Přidělte pole prostředků struktur v feature_dev.resource.
• Přidělte strukturu feature_platform_data, inicializujte ji a uložte ukazatel do feature_dev.dev.platform_data
  • create_feature_instance() build_info_add_sub_feature()
  • Inicializujte feature_dev.resource[FME_FEATURE_ID_HEADER].
  • feature_platform_data_add()
  • Inicializujte feature_platform_data.features[FME_FEATURE_ID_HEADER], vše kromě .fops.
• parse_feature() parse_feature_afus() parse_feature_port()
  • Když narazíte na port:
• build_info_create_dev()
  • Přidělte platformu pro port a uložte jej do build_feature_devs_info.feature_dev.
  • feature_dev.id je inicializován na výsledek idr_alloc(fpga_ids[PORT_ID],
  • feature_dev.parent je nastaven na build_feature_devs_info.parent_dev.
  • Přidělte pole prostředků struct v feature_dev.resource.
  • Přidělte strukturu feature_platform_data, inicializujte ji a uložte ukazatel do feature_dev.dev.platform_data
• build_info_commit_dev()
  • Přidejte struct feature_platform_data.node pro port do seznamu portů ve struct cci_drvdata.port_dev_list
• create_feature_instance() build_info_add_sub_feature()
  • Inicializujte feature_dev.resource[PORT_FEATURE_ID_HEADER].
• feature_platform_data_add()
  • Inicializujte feature_platform_data.features[PORT_FEATURE_ID_HEADER], vše kromě .fops.
• parse_feature() parse_feature_afus() parse_feature_port_uafu()
  • Když narazíte na AFU:
• create_feature_instance() build_info_add_sub_feature()
  • Inicializujte feature_dev.resource[PORT_FEATURE_ID_UAFU].
• feature_platform_data_add()
  • Inicializujte feature_platform_data.features[PORT_FEATURE_ID_UAFU], vše kromě .fops.
• parse_feature() parse_feature_private() parse_feature_fme_private()
  • Když narazíte na soukromou funkci FME:
• create_feature_instance() build_info_add_sub_feature()
  • Inicializujte feature_dev.resource[id].
• feature_platform_data_add()
  • Inicializujte feature_platform_data.features[id], vše kromě .fops.
• parse_feature() parse_feature_private() parse_feature_port_private()
• Když narazíte na soukromou funkci portu: * create_feature_instance() build_info_add_sub_feature() * Inicializujte feature_dev.resource[id]. * feature_platform_data_add() Inicializuje feature_platform_data.features[id], vše kromě .fops.
• parse_ports_from_fme()
  • Pokud je ovladač načten ve fyzické funkci (PF), pak:
• Spusťte tok parse_feature_list() na každém portu popsaném v hlavičce FME.
• Použijte BAR uvedený v každé položce Port v záhlaví.

Inicializace zařízení platformy FME
Tato sekce dává konecview toku kódu pro inicializaci zařízení FME prováděnou intel-fpga-fme.ko. Hlavní datové struktury a funkce jsou zvýrazněny. Tento oddíl je nejlépe dodržet, když viewpomocí přiloženého zdrojového kódu (fme-main.c).

Datové struktury zařízení platformy FME

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 feature {
const char *jméno;
int zdroj_index;
void __iomem *ioaddr;
struct feature_ops *ops;
};
struct feature_platform_data {
struct list_head uzel;
struct mutex lock;
unsigned long dev_status;
struct cdev cdev;
struct platform_device *dev;
unsigned int disable_count;
neplatný *soukromý;
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 *)); strukturovat
rysy[0];
};
struct perf_object {
int id;
const struct atribut_group **attr_groups;
struct device *fme_dev;
struct list_head uzel;
struct list_head children;
struct kobject kobj;
};
struct fpga_fme {
u8 port_id;
u64 pr_err;
struct device *dev_err;
struct perf_object *perf_dev;
struct feature_platform_data *pdata;
};

Průběh inicializace zařízení platformy FME

Inicializační tok FME

• fme_probe() fme_dev_init()
  • Inicializujte strukturu fpga_fme a uložte ji do pole feature_platform_data.private.
• fme_probe() fpga_dev_feature_init() feature_instance_init()
  • Uložte struct feature_ops do feature_platform_data.features pro každý obsazený prvek.
  • Zavolejte testovací funkci, pokud existuje, ze struct.
  • Zavolejte funkci init ze struct.
• fme_probe() fpga_register_dev_ops()
  • Vytvořte uzel znakového zařízení FME a zaregistrujte strukturu file_operace.

Port Platform Inicializace zařízení
Tato sekce dává konecview toku kódu pro inicializaci portového zařízení prováděnou intel-fpga-afu.ko. Hlavní datové struktury a funkce jsou zvýrazněny. Tento oddíl je nejlépe dodržet, když views přiloženým zdrojovým kódem (afu.c).

Port Platform Datové struktury zařízení

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 feature {
const char *jméno;
int zdroj_index;
void __iomem *ioaddr;
struct feature_ops *ops;
};
struct feature_platform_data {
struct list_head uzel;
struct mutex lock;
unsigned long dev_status;
struct cdev cdev;
struct platform_device *dev;
unsigned int disable_count;
neplatný *soukromý;
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 {
index u32;
u32 vlajky;
velikost u64;
offset u64;
u64 fyz.;
struct list_head uzel;
};
struct fpga_afu_dma_region {
u64 user_addr;
délka u64;
u64 iova;
struct page **pages;
struct rb_node node;
bool in_use;
};
struct fpga_afu {
u64 region_cur_offset;
int počet_regionů;
u8 num_umsgs;
struct list_head regiony;
struct rb_root dma_regions;
struct feature_platform_data *pdata;
};

Průběh inicializace zařízení Port Platform

Průběh inicializace portu

• afu_probe() afu_dev_init()
  • Inicializujte strukturu fpga_afu a uložte ji do pole feature_platform_data.private.
• afu_probe() fpga_dev_feature_init() feature_instance_init()
  • Uložte struct feature_ops do feature_platform_data.features pro každý obsazený prvek.
  • Zavolejte testovací funkci, pokud existuje, ze struct.
  • Zavolejte funkci init ze struct.
• afu_probe() fpga_register_dev_ops()
  • Vytvořte uzel znakového zařízení Port a zaregistrujte strukturu file_operace.

FME IOCTL
IOCTL, které jsou volány na open file deskriptor pro /dev/intel-fpga-fme.j FPGA_GET_API_VERSION – vrátí aktuální verzi jako celé číslo, počínaje 0.

FPGA_CHECK_EXTENSION – aktuálně není podporováno.

FPGA_FME_PORT_RELEASE—arg je ukazatel na:

struct fpga_fme_port_release {
__u32 argsz; // in: sizeof(struct fpga_fme_port_release)
__u32 příznaky; // v: musí být 0
__u32 port_id; // in: ID portu (od 0) k uvolnění.
};

FPGA_FME_PORT_ASSIGN—arg je ukazatel na:

struct fpga_fme_port_assign {
__u32 argsz; // in: sizeof(struct fpga_fme_port_assign)
__u32 příznaky; // v: musí být 0
__u32 port_id; // in: ID portu (od 0) k přiřazení. (musel být
dříve vydané FPGA_FME_PORT_RELEASE)
};

FPGA_FME_PORT_PR—arg je ukazatel na:

struct fpga_fme_port_pr {
__u32 argsz; // in: sizeof(struct fpga_fme_port_pr)
__u32 příznaky; // v: musí být 0
__u32 port_id; // in: ID portu (od 0)
__u32 buffer_size; // in: velikost vyrovnávací paměti bitového toku v bajtech. Musí být 4bajtové
zarovnané.
__u64 adresa_bufferu; // in: adresa procesu vyrovnávací paměti bitového toku
stav __u64; // out: chybový stav (bitmask)
};

Port IOCTL
IOCTL, které jsou volány na open file deskriptor pro /dev/intel-fpga-port.k FPGA_GET_API_VERSION – vrátí aktuální verzi jako celé číslo počínaje 0. FPGA_CHECK_EXTENSION – aktuálně není podporováno.

FPGA_PORT_GET_INFO—arg je ukazatel na:

struct fpga_port_info {
__u32 argsz; // in: sizeof(struct fpga_port_info)
__u32 příznaky; // out: vrátí 0
__u32 num_regions; // out: počet oblastí MMIO, 2 (1 pro AFU a 1 pro
STP)
__u32 num_umsgs; // out: počet UMsg podporovaných hardwarem
};

FPGA_PORT_GET_REGION_INFO—arg je ukazatel na:

struct fpga_port_region_info {
__u32 argsz; // in: sizeof(struct fpga_port_region_info)
__u32 příznaky; // out: (bitmask) { FPGA_REGION_READ, FPGA_REGION_WRITE,
FPGA_REGION_MMAP }
__u32 index; // v: FPGA_PORT_INDEX_UAFU nebo FPGA_PORT_INDEX_STP
__u32 výplň; // v: musí být 0
velikost __u64; // out: velikost oblasti MMIO v bajtech
__u64 offset; // out: offset oblasti MMIO od začátku zařízení fd
};

FPGA_PORT_DMA_MAP—arg je ukazatel na:
struct fpga_port_dma_map {
__u32 argsz; // in: sizeof(struct fpga_port_dma_map)
__u32 příznaky; // v: musí být 0 __u64 user_addr; // v: proces virtuální
adresa. Musí být zarovnáno na stránku.
__u64 délka; // in: délka mapování v bajtech. Musí to být násobek stránky
velikost.
__u64 iova; // out: IO virtuální adresa };

FPGA_PORT_DMA_UNMAP—arg je ukazatel na:
struct fpga_port_dma_unmap {
__u32 argsz; // in: sizeof(struct fpga_port_dma_unmap)
__u32 příznaky; // v: musí být 0
__u64 iova; // in: IO virtuální adresa vrácená předchozím
FPGA_PORT_DMA_MAP };

• FPGA_PORT_RESET – argument musí mít hodnotu NULL.
• FPGA_PORT_UMSG_ENABLE – argument musí mít hodnotu NULL.
• FPGA_PORT_UMSG_DISABLE – argumenty musí mít hodnotu NULL.

FPGA_PORT_UMSG_SET_MODE—arg je ukazatel na:

struct fpga_port_umsg_cfg {
__u32 argsz; // in: sizeof(struct fpga_port_umsg_cfg)
__u32 příznaky; // v: musí být 0
__u32 hint_bitmap; // v: bitmapa režimu nápovědy UMsg. Označuje, které UMsg jsou
povoleno.
};

FPGA_PORT_UMSG_SET_BASE_ADDR—

• UMsg musí být před vydáním tohoto ioctl zakázáno.
• Pole iova musí být pro vyrovnávací paměť dostatečně velkou pro všechny UMsg (num_umsgs * PAGE_SIZE).
  • Vyrovnávací paměť je označena jako „použitá“ správou vyrovnávací paměti řidiče.
  • Pokud má iova hodnotu NULL, jakákoli předchozí oblast není označena jako „používá se“.
• arg je ukazatel na:
  struct fpga_port_umsg_base_addr {
  • u32 argsz; // in: sizeof(struct fpga_port_umsg_base_addr)
  • u32 vlajky; // v: musí být 0
  • u64 iova; // in: IO virtuální adresa z FPGA_PORT_DMA_MAP. };

Poznámka:

• Chcete-li odstranit chyby portu, musíte napsat přesnou bitovou masku aktuálních chyb, napřample, kočičí chyby > jasné
• UMsg je podporováno pouze prostřednictvím Acceleration Stack pro procesor Intel Xeon s integrovaným FPGA.

sysfs Files

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

sysfs file	pole mmio	typ	přístup
číslo_portů	fme_header.capability.num_ports	desetinná int	Pouze pro čtení
cache_size	fme_header.capability.cache_size	desetinná int	Pouze pro čtení
verze	fme_header.capability.fabric_verid	desetinná int	Pouze pro čtení
socket_id	fme_header.capability.socket_id	desetinná int	Pouze pro čtení
bitstream_id	fme_header.bitstream_id	hex uint64_t	Pouze pro čtení
bitstream_metadata	fme_header.bitstream_md	hex uint64_t	Pouze pro čtení

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

sysfs file	pole mmio	typ	přístup
práh1	tepelný.threshold.tmp_thshold1	desetinná int	Uživatel: Pouze pro čtení Root: Čtení-zápis
práh2	tepelný.threshold.tmp_thshold2	desetinná int	Uživatel: Pouze pro čtení Root: Čtení-zápis
prahová_výlet	termální.threshold.therm_trip_thshold	desetinná int	Pouze pro čtení
prahová hodnota1_dosažena	tepelný.prah.thshold1_status	desetinná int	Pouze pro čtení
prahová hodnota2_dosažena	tepelný.prah.thshold2_status	desetinná int	Pouze pro čtení
prahová hodnota1_policy	tepelný. prahová hodnota.thshold_policy	desetinná int	Uživatel: Pouze pro čtení Root: Čtení-zápis
teplota	teplotní.rdsensor_fm1.fpga_temp	desetinná int	Pouze pro čtení

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

sysfs file	pole mmio	typ	přístup
spotřebováno	power.status.pwr_consumed	hex uint64_t	Pouze pro čtení
práh1	práh výkonu.prah1	hex uint64_t	Uživatel: Pouze pro čtení Root: Čtení-zápis
práh2	práh výkonu.prah2	hex uint64_t	Uživatel: Pouze pro čtení Root: Čtení-zápis
práh1_stav	power.threshold.threshold1_status	desetinné bez znaménka	Pouze pro čtení
práh2_stav	power.threshold.threshold2_status	desetinné bez znaménka	Pouze pro čtení
rtl	power.status.fpga_latency_report	desetinné bez znaménka	Pouze pro čtení

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

sysfs file	pole mmio	typ	přístup
pcie0_errors	gerror.pcie0_err	hex uint64_t	Číst psát
pcie1_errors	gerror.pcie1_err	hex uint64_t	Číst psát
inject_error	gerror.ras_error_inj	hex uint64_t	Číst psát

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

sysfs file	pole mmio	typ	přístup
chyby	gerror.fme_err	hex uint64_t	Pouze pro čtení
first_error	gerror.fme_first_err.err_reg_status	hex uint64_t	Pouze pro čtení
další_chyba	gerror.fme_next_err.err_reg_status	hex uint64_t	Pouze pro čtení
jasný	Vymaže chyby, first_error, next_error	různé uint64_t	Pouze pro zápis

Poznámka:
Chcete-li odstranit chyby FME, musíte napsat přesnou bitovou masku aktuálních chyb, napřample kočičí chyby > jasné.

Částečná rekonfigurace FME sysfs files
intel-fpga-dev.i/intel-fpga-fme.j/pr/

sysfs file	pole mmio	typ	přístup
interface_id	pr.fme_pr_intfc_id0_h, pr.fme_pre_intfc_id0_l	hex 16bajtový	Pouze pro čtení

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

sysfs file	pole mmio	typ	přístup
hodiny	gperf.clk.afu_interf_clock	hex uint64_t	Pouze pro čtení

intel-fpga-dev.i/intel-fpga-fme.j/dperf/cache/ (Neplatí pro Acceleration Stack pro procesor Intel Xeon s FPGA)

sysfs file	pole mmio	typ	přístup
zmrazit	gperf.ch_ctl.freeze	desetinná int	Číst psát
read_hit	gperf.CACHE_RD_HIT	hex uint64_t	Pouze pro čtení
read_miss	gperf.CACHE_RD_MISS	hex uint64_t	Pouze pro čtení
write_hit	gperf.CACHE_WR_HIT	hex uint64_t	Pouze pro čtení
psát_miss	gperf.CACHE_WR_MISS	hex uint64_t	Pouze pro čtení
hold_request	gperf.CACHE_HOLD_REQ	hex uint64_t	Pouze pro čtení
tx_req_stall	gperf.CACHE_TX_REQ_STALL	hex uint64_t	Pouze pro čtení

sysfs file	pole mmio	typ	přístup
rx_req_stall	gperf.CACHE_RX_REQ_STALL	hex uint64_t	Pouze pro čtení
data_write_port_contention	gperf.CACHE_DATA_WR_PORT_CONTEN	hex uint64_t	Pouze pro čtení
tag_write_port_contention	gperf.CACHE_TAG_WR_PORT_CONTEN	hex uint64_t	Pouze pro čtení

intel-fpga-dev.i/intel-fpga-fme.j/dperf/iommu/ (Neplatí pro Acceleration Stack pro procesor Intel Xeon s FPGA)

sysfs file	pole mmio	typ	přístup
zmrazit	gperf.vtd_ctl.freeze	desetinná int	Uživatel: Pouze pro čtení Root: Čtení-zápis

intel-fpga-dev.i/intel-fpga-fme.j/dperf/iommu/afuk/ (Neplatí pro Acceleration Stack pro procesor Intel Xeon s FPGA)

sysfs file	pole mmio	typ	přístup
read_transaction	gperf.VTD_AFU0_MEM_RD_TRANS	hex uint64_t	Pouze pro čtení
write_transaction	gperf.VTD_AFU0_MEM_WR_TRANS	hex uint64_t	Pouze pro čtení
tlb_read_hit	gperf.VTD_AFU0_TLB_RD_HIT	hex uint64_t	Pouze pro čtení
tlb_write_hit	gperf.VTD_AFU0_TLB_WR_HIT	hex uint64_t	Pouze pro čtení

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

sysfs file	pole mmio	typ	přístup
umožnit	gperf.fab_ctl. (povoleno)	desetinná int	Uživatel: Pouze pro čtení Root: Čtení-zápis
zmrazit	gperf.fab_ctl.freeze	desetinná int	Uživatel: Pouze pro čtení Root: Čtení-zápis
pcie0_read	gperf.FAB_PCIE0_RD	hex uint64_t	Pouze pro čtení
pcie0_write	gperf.FAB_PCIE0_WR	hex uint64_t	Pouze pro čtení
pcie1_read	gperf.FAB_PCIE1_RD	hex uint64_t	Pouze pro čtení
pcie1_write	gperf.FAB_PCIE1_WR	hex uint64_t	Pouze pro čtení
upi_read	gperf.FAB_UPI_RD	hex uint64_t	Pouze pro čtení
upi_write	gperf.FAB_UPI_WR	hex uint64_t	Pouze pro čtení

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

sysfs file	pole mmio	typ	přístup
pcie0_read	gperf.FAB_PCIE0_RD	hex uint64_t	Pouze pro čtení
pcie0_write	gperf.FAB_PCIE0_WR	hex uint64_t	Pouze pro čtení
pcie1_read	gperf.FAB_PCIE1_RD	hex uint64_t	Pouze pro čtení
pcie1_write	gperf.FAB_PCIE1_WR	hex uint64_t	Pouze pro čtení
upi_read	gperf.FAB_UPI_RD	hex uint64_t	Pouze pro čtení
upi_write	gperf.FAB_UPI_WR	hex uint64_t	Pouze pro čtení

Záhlaví portu sysfs files
intel-fpga-dev.i/intel-fpga-port.k/

sysfs file	pole mmio	typ	přístup
id	port_header.capability.port_number	desetinná int	Pouze pro čtení
ltr	port_header.control.latency_tolerance	desetinná int	Pouze pro čtení

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

sysfs file	pole mmio	typ	přístup
afu_id	afu_header.guid	hex 16bajtový	Pouze pro čtení

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

sysfs file	pole mmio	typ	přístup
chyby	chyba.port_chyba	hex uint64_t	Pouze pro čtení
first_error	perror.port_first_error	hex uint64_t	Pouze pro čtení
first_malformed_req	chyba.malreq	hex 16bajtový	Pouze pro čtení
jasný	chyba. (všechny chyby)	různé uint64_t	Pouze pro zápis

Poznámka:
Chcete-li odstranit chyby portu, musíte napsat přesnou bitovou masku aktuálních chyb, napřample kočičí chyby > jasné.

Historie revizí

Verze dokumentu	Změny
2017.10.02	Počáteční vydání.

OPAE Intel FPGA Linux Device Driver Architecture Guide

Dokumenty / zdroje

architektura ovladačů zařízení intel OPAE FPGA Linux [pdfUživatelská příručka OPAE FPGA Linux Device Driver Architecture, OPAE FPGA, Linux Device Driver Architecture, Driver Architecture, Architecture

Reference

• Uživatelská příručka