Intel OPAE FPGA Linux Device Driver Architecture

Architettura del driver di dispositivo Linux FPGA Intel OPAE

Il driver OPAE Intel FPGA fornisce interfacce per le applicazioni in spazio utente per configurare, enumerare, aprire e accedere agli acceleratori FPGA su piattaforme dotate di soluzioni Intel FPGA e abilita funzioni di gestione a livello di sistema come la riconfigurazione FPGA, la gestione dell'alimentazione e la virtualizzazione.

Architettura hardware

Dal punto di vista del sistema operativo view, l'hardware FPGA appare come un normale dispositivo PCIe. La memoria del dispositivo FPGA è organizzata utilizzando una struttura dati predefinita (Device Feature List). Le funzionalità supportate dal dispositivo FPGA sono esposte attraverso queste strutture di dati, come illustrato di seguito nella figura seguente:

Dispositivo PCIe FPGA

Il driver supporta PCIe SR-IOV per creare funzioni virtuali (VF) che possono essere utilizzate per assegnare singoli acceleratori alle macchine virtuali.

Società Intel. Tutti i diritti riservati. Intel, il logo Intel e altri marchi Intel sono marchi di Intel Corporation o delle sue consociate. Intel garantisce le prestazioni dei suoi prodotti FPGA e semiconduttori in base alle specifiche correnti in conformità con la garanzia standard di Intel, ma si riserva il diritto di apportare modifiche a qualsiasi prodotto e servizio in qualsiasi momento senza preavviso. Intel non si assume alcuna responsabilità derivante dall'applicazione o dall'uso di informazioni, prodotti o servizi qui descritti, salvo quanto espressamente concordato per iscritto da Intel. Si consiglia ai clienti Intel di ottenere la versione più recente delle specifiche del dispositivo prima di fare affidamento su qualsiasi informazione pubblicata e prima di effettuare ordini per prodotti o servizi.

Altri nomi e marchi potrebbero essere rivendicati come proprietà di terzi.

Dispositivo PCIe FPGA virtualizzato

Motore di gestione FPGA (FME)
Il motore di gestione FPGA esegue la gestione dell'alimentazione e della temperatura, la segnalazione degli errori, la riconfigurazione, la segnalazione delle prestazioni e altre funzioni dell'infrastruttura. Ogni FPGA ha un FME, a cui si accede sempre tramite la funzione fisica (PF). Le applicazioni in spazio utente possono acquisire l'accesso esclusivo all'FME utilizzando open() e rilasciarlo utilizzando close() come utente privilegiato (root).

Porta
Una porta rappresenta l'interfaccia tra la struttura FPGA statica (l'"FPGA Interface Manager (FIM)") e una regione parzialmente riconfigurabile contenente una funzione di accelerazione (AF). La porta controlla la comunicazione dal software all'acceleratore ed espone funzionalità come il ripristino e il debug. Un dispositivo PCIe può avere diverse porte e ciascuna porta può essere esposta tramite un VF assegnandola utilizzando l'ioctl FPGA_FME_PORT_ASSIGN sul dispositivo FME.

Unità funzione acceleratore (AF).

• Un'unità della funzione di accelerazione (AF) è collegata a una porta ed espone una regione MMIO da 256 K da utilizzare per i registri di controllo specifici dell'acceleratore.
• Le applicazioni in spazio utente possono acquisire l'accesso esclusivo a un AFU collegato a una porta utilizzando open() sul dispositivo Port e rilasciarlo utilizzando close().
• Le applicazioni in spazio utente possono anche regioni MMIO dell'acceleratore mmap().

Riconfigurazione parziale
Come accennato in precedenza, gli acceleratori possono essere riconfigurati attraverso la riconfigurazione parziale di una funzione di accelerazione (AF) file. La funzione di accelerazione (AF) deve essere stata generata per l'esatto FIM e la regione statica mirata (porta) dell'FPGA; in caso contrario, l'operazione di riconfigurazione fallirà e potrebbe causare instabilità del sistema. Questa compatibilità può essere verificata confrontando l'ID interfaccia annotato nell'intestazione AF con l'ID interfaccia esposto dall'FME tramite sysfs. Questo controllo viene solitamente eseguito dallo spazio utente prima di chiamare la riconfigurazione IOCTL.

Nota:
Attualmente, qualsiasi programma software che accede all'FPGA, inclusi quelli in esecuzione su un host virtualizzato, deve essere chiuso prima di tentare una riconfigurazione parziale. I passaggi sarebbero:

1. Scarica l'autista dall'ospite
2. Scollegare il VF dall'ospite
3. Disattiva SR-IOV
4. Eseguire una riconfigurazione parziale
5. Abilita SR-IOV
6. Collegare il VF all'ospite
7. Carica il driver nel guest

Virtualizzazione FPGA
Per abilitare l'accesso a un acceleratore dalle applicazioni in esecuzione in una macchina virtuale, la rispettiva porta dell'AFU deve essere assegnata a un VF utilizzando i seguenti passaggi:

1. Il PF possiede tutte le porte AFU per impostazione predefinita. Qualsiasi porta che deve essere riassegnata a un VF deve prima essere rilasciata dal PF tramite ioctl FPGA_FME_PORT_RELEASE sul dispositivo FME.
2. Una volta rilasciate N porte dal PF, è possibile utilizzare il comando seguente per abilitare SRIOV e VF. Ogni VF possiede un solo porto con AFU. echo N > PCI_DEVICE_PATH/sriov_numvfs
3. Passa attraverso i VF alle VM.
4. L'AFU in VF è accessibile dalle applicazioni in VM (utilizzando lo stesso driver all'interno di VF).

Nota:
Un FME non può essere assegnato a un VF, quindi PR e altre funzioni di gestione sono disponibili solo tramite il PF.

Organizzazione dei conducenti

Driver del dispositivo del modulo PCIe

Organizzazione dei conducenti

I dispositivi FPGA appaiono come normali dispositivi PCIe; pertanto, il driver del dispositivo FPGA PCIe (intel-FPGA-PCI.ko) viene sempre caricato per primo una volta rilevato un FPGA PCIe PF o VF. Questo driver svolge un ruolo infrastrutturale nell'architettura del driver. Esso:

• Crea un dispositivo contenitore FPGA come padre dei dispositivi di funzionalità.
• Esamina l'elenco delle funzionalità del dispositivo, implementato nella memoria BAR del dispositivo PCIe, per scoprire i dispositivi delle funzionalità e le relative funzionalità secondarie e creare dispositivi di piattaforma per essi sotto il dispositivo contenitore.
• Supporta SR-IOV.
• Introduce l'infrastruttura del dispositivo delle funzionalità, che astrae le operazioni per le funzionalità secondarie ed espone le funzioni comuni ai driver dei dispositivi delle funzionalità.

Funzioni del driver del dispositivo del modulo PCIe

• Contiene il rilevamento PCIe, l'enumerazione dei dispositivi e il rilevamento delle funzionalità.
• Crea directory sysfs per il dispositivo padre, FPGA Management Engine (FME) e Port.
• Crea le istanze del driver della piattaforma, facendo in modo che il kernel Linux carichi i rispettivi driver del modulo della piattaforma.

Driver del dispositivo del modulo della piattaforma FME

• Gestione dell'alimentazione e della temperatura, segnalazione degli errori, segnalazione delle prestazioni e altre funzioni dell'infrastruttura. È possibile accedere a queste funzioni tramite le interfacce sysfs esposte dal driver FME.
• Riconfigurazione parziale. Il driver FME registra un gestore FPGA durante l'inizializzazione della funzione secondaria PR; una volta ricevuto un ioctl FPGA_FME_PORT_PR dall'utente, richiama la funzione di interfaccia comune da FPGA Manager per completare la riconfigurazione parziale del flusso di bit sulla porta specificata.
• Gestione delle porte per la virtualizzazione. Il driver FME introduce due ioctls, FPGA_FME_PORT_RELEASE, che rilascia la porta data da PF; e FPGA_FME_PORT_ASSIGN, che assegna nuovamente la porta a PF. Una volta che la porta è stata rilasciata dal PF, può essere assegnata al VF tramite le interfacce SR-IOV fornite dal driver PCIe. Per ulteriori informazioni, fare riferimento a "Virtualizzazione FPGA".

Funzioni del driver del dispositivo del modulo della piattaforma FME

• Crea il nodo del dispositivo a caratteri FME.
• Crea il file sysfs FME filese implementa FME sysfs file accessori.
• Implementa i driver secondari della funzionalità privata FME.
• Driver secondari delle funzionalità private FME:
  • Intestazione FME
  • Gestione termica
  • Gestione dell'alimentazione
  • Errore globale
  • Riconfigurazione parziale
  • Prestazioni globali

Driver del dispositivo del modulo della piattaforma della porta
Analogamente al driver FME, il driver FPGA Port (e AFU) (intel-fpga-afu.ko) viene analizzato una volta creato il dispositivo della piattaforma Port. La funzione principale di questo modulo è fornire un'interfaccia per le applicazioni in spazio utente per accedere ai singoli acceleratori, incluso il controllo di ripristino di base sulla porta, l'esportazione della regione MMIO AFU, il servizio di mappatura del buffer DMA, la notifica UMsg(1) e le funzioni di debug remoto ( vedi sopra).

UMsg è supportato solo tramite lo stack di accelerazione per il processore Intel Xeon® con FPGA integrato.

Funzioni del driver del dispositivo del modulo della piattaforma della porta

• Crea il nodo del dispositivo del carattere della porta.
• Crea la porta sysfs filese implementa il port sysfs file accessori.
• Implementa i driver secondari della funzionalità Port private.
• Driver secondari della funzionalità Port Private:
  • Intestazione del porto
  • AFU
  • Errore di porta
  • Messaggi di messaggistica unificata(2)
  • Tocca il segnale

Enumerazione del dispositivo FPGA dell'applicazione
Questa sezione introduce il modo in cui le applicazioni enumerano il dispositivo FPGA dalla gerarchia sysfs in /sys/class/fpga. Nell'esample sotto, nell'host sono installati due dispositivi Intel FPGA. Ogni dispositivo FPGA ha un FME e due porte (AFU). Per ogni dispositivo FPGA, viene creata una directory del dispositivo in /sys/class/fpga:

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

Ogni nodo ha un FME e due porte (AFU) come dispositivi figli:
/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

In generale, le interfacce FME/Port sysfs sono denominate come segue:
/sys/class/fpga/intel-fpga-dev.i/intel-fpga-fme.j/
/sys/class/fpga/intel-fpga-dev.i/intel-fpga-port.k/

con I che numera consecutivamente tutti i dispositivi contenitore, j numerando consecutivamente gli FME ek numerando consecutivamente tutti i Port.

È possibile fare riferimento ai nodi del dispositivo utilizzati per ioctl() e mmap() tramite:
/dev/intel-fpga-fme.j
/dev/intel-fpga-port.k

Enumerazione dei driver PCIe
Questa sezione dà un overview del flusso di codice per l'enumerazione dei dispositivi eseguita da intel-fpga-pci.ko. Vengono evidenziate le principali strutture dati e funzioni. Questa sezione è meglio seguita quando viewing il codice sorgente di accompagnamento (pcie.c).

Strutture di dati di enumerazione

enum fpga_id_type {
GENITORE_ID,
ID_FME,
ID_PORTA,
FPGA_ID_MAX
};
idr struttura statica fpga_ids[FPGA_ID_MAX];
struttura fpga_chardev_info {
const char *nome;
dev_t dev;
};
struttura fpga_chardev_info fpga_chrdevs[] = {
{ .nome = FPGA_FEATURE_DEV_FME },
{ .nome = FPGA_FEATURE_DEV_PORT },
};
classe struct statica *fpga_class;
struttura statica 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,}
};
struttura statica pci_driver cci_pci_driver = {
.nome = DRV_NAME,
.id_table = cci_pcie_id_tbl,
.probe = cci_pci_probe,
.remove = cci_pci_remove,
.sriov_configure = cci_pci_sriov_configure
};
struttura cci_drvdata {
int ID_dispositivo;
struct dispositivo *fme_dev;
struct blocco mutex;
struttura list_head port_dev_list;
int numero_porta_rilasciato;
struct list_head regioni;
};
struct build_feature_devs_info {
struttura pci_dev *pdev;
void __iomem *ioaddr;
vuoto __iomem *ioend;
int barra_corrente;
void __iomem *pfme_hdr;
struct dispositivo *parent_dev;
struttura platform_device *feature_dev;
};

Flusso di enumerazione

• ccidrv_init()
  • Inizializza fpga_ids usando idr_init().
  • Inizializza fpga_chrdevs[i].devt usando alloc_chrdev_region().
  • Inizializza fpga_class usando class_create().
  • pci_register_driver(&cci_pci_driver);
• cci_pci_probe()
  • Abilita il dispositivo PCI, richiedi l'accesso alle sue regioni, imposta la modalità master PCI e configura DMA.
• cci_pci_create_feature_devs() build_info_alloc_and_init()
  • Allocare una struttura build_feature_devs_info, inizializzarla.
    .parent_dev è impostato su una directory sysfs padre (intel-fpga-dev.id) che contiene le directory FME e Port sysfs.
• parse_feature_list()
  • Percorri l'elenco delle funzionalità del dispositivo BAR0 per scoprire l'FME, la porta e le loro funzionalità private.
• parse_feature() parse_feature_afus() parse_feature_fme()
  • Quando si incontra un FME:
• build_info_create_dev()
  • Assegna un dispositivo di piattaforma per FME, memorizzandolo in build_feature_devs_info.feature_dev.
  • feature_dev.id è inizializzato al risultato di idr_alloc(fpga_ids[FME_ID],
  • feature_dev.parent è impostato su build_feature_devs_info.parent_dev.
  • Allocare un array di risorse struct in feature_dev.resource.
• Alloca una struttura feature_platform_data, inizializzala e memorizza un puntatore in feature_dev.dev.platform_data
  • create_feature_instance() build_info_add_sub_feature()
  • Inizializza feature_dev.resource[FME_FEATURE_ID_HEADER].
  • feature_platform_data_add()
  • Inizializza feature_platform_data.features[FME_FEATURE_ID_HEADER], tutto tranne .fops.
• parse_feature() parse_feature_afus() parse_feature_port()
  • Quando si incontra una porta:
• build_info_create_dev()
  • Assegna un dispositivo di piattaforma per il port, archiviandolo in build_feature_devs_info.feature_dev.
  • feature_dev.id è inizializzato al risultato di idr_alloc(fpga_ids[PORT_ID],
  • feature_dev.parent è impostato su build_feature_devs_info.parent_dev.
  • Allocare un array di risorse struct in feature_dev.resource.
  • Alloca una struttura feature_platform_data, inizializzala e memorizza un puntatore in feature_dev.dev.platform_data
• build_info_commit_dev()
  • Aggiungere la struttura feature_platform_data.node per la porta all'elenco delle porte nella struttura cci_drvdata.port_dev_list
• create_feature_instance() build_info_add_sub_feature()
  • Inizializza feature_dev.resource[PORT_FEATURE_ID_HEADER].
• feature_platform_data_add()
  • Inizializza feature_platform_data.features[PORT_FEATURE_ID_HEADER], tutto tranne .fops.
• parse_feature() parse_feature_afus() parse_feature_port_uafu()
  • Quando si incontra un AFU:
• create_feature_instance() build_info_add_sub_feature()
  • Inizializza feature_dev.resource[PORT_FEATURE_ID_UAFU].
• feature_platform_data_add()
  • Inizializza feature_platform_data.features[PORT_FEATURE_ID_UAFU], tutto tranne .fops.
• parse_feature() parse_feature_private() parse_feature_fme_private()
  • Quando viene rilevata una funzionalità privata FME:
• create_feature_instance() build_info_add_sub_feature()
  • Inizializza feature_dev.resource[id].
• feature_platform_data_add()
  • Inizializza feature_platform_data.features[id], tutto tranne .fops.
• parse_feature() parse_feature_private() parse_feature_port_private()
• Quando viene rilevata una funzionalità Port private: * create_feature_instance() build_info_add_sub_feature() * Inizializza feature_dev.resource[id]. * feature_platform_data_add() Inizializza feature_platform_data.features[id], tutto tranne .fops.
• parse_ports_from_fme()
  • Se il driver è caricato sulla funzione fisica (PF), allora:
• Eseguire il flusso parse_feature_list() su ciascuna porta descritta nell'intestazione FME.
• Utilizzare la BAR indicata in ciascuna voce Port nell'intestazione.

Inizializzazione del dispositivo della piattaforma FME
Questa sezione dà un overview del flusso di codice per l'inizializzazione del dispositivo FME eseguita da intel-fpga-fme.ko. Le principali strutture dati e funzioni sono evidenziate. Questa sezione è meglio seguita quando viewing il codice sorgente di accompagnamento (fme-main.c).

Strutture dati dispositivo piattaforma FME

struttura 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);
};
caratteristica della struttura {
const char *nome;
int indice_risorsa;
void __iomem *ioaddr;
struttura feature_ops *ops;
};
struttura feature_platform_data {
struct list_head nodo;
struct blocco mutex;
unsigned lungo dev_status;
struttura cdev cdev;
struct piattaforma_dispositivo *dev;
unsigned int disattiva_conta;
nullo *privato;
numero intero;
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 *)); struttura
caratteristiche caratteristiche[0];
};
struct oggetto_perf {
ID int;
const struct attributo_gruppo **attr_groups;
struct dispositivo *fme_dev;
struct list_head nodo;
struct list_head bambini;
struttura kooggetto kobj;
};
struttura fpga_fme {
u8 id_porta;
u64pr_err;
struct dispositivo *dev_err;
struttura perf_object *perf_dev;
struttura feature_platform_data *pdata;
};

Flusso di inizializzazione del dispositivo della piattaforma FME

Flusso di inizializzazione FME

• fme_probe() fme_dev_init()
  • Inizializza una struct fpga_fme e salvala nel campo feature_platform_data.private.
• fme_probe() fpga_dev_feature_init() feature_instance_init()
  • Salva una struttura feature_ops in feature_platform_data.features per ogni feature popolata.
  • Chiamare la funzione di test, se presente, dalla struttura.
  • Chiama la funzione init dalla struttura.
• fme_probe() fpga_register_dev_ops()
  • Crea il nodo del dispositivo a caratteri FME, registrando una struttura file_operazioni.

Inizializzazione del dispositivo della piattaforma della porta
Questa sezione dà un overview del flusso di codice per l'inizializzazione del dispositivo di porta eseguita da intel-fpga-afu.ko. Vengono evidenziate le principali strutture dati e funzioni. Questa sezione è meglio seguita quando viewing il codice sorgente di accompagnamento (afu.c).

Strutture dati del dispositivo della piattaforma portuale

struttura 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);
};
caratteristica della struttura {
const char *nome;
int indice_risorsa;
void __iomem *ioaddr;
struttura feature_ops *ops;
};
struttura feature_platform_data {
struct list_head nodo;
struct blocco mutex;
unsigned lungo dev_status;
struttura cdev cdev;
struct piattaforma_dispositivo *dev;
unsigned int disattiva_conta;
nullo *privato;
numero intero;
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 *));
caratteristiche della struttura della struttura[0];
};
struct fpga_afu_region {
indice u32;
bandiere u32;
dimensione u64;
offset u64;
u64 fisico;
struct list_head nodo;
};
struct fpga_afu_dma_region {
u64 indirizzo_utente;
lunghezza u64;
u64 iova;
struct pagina **pagine;
struct rb_node nodo;
bool in_uso;
};
struttura fpga_afu {
u64 regione_cur_offset;
int num_regioni;
u8 num_umsgs;
struct list_head regioni;
struttura rb_root dma_regions;
struttura feature_platform_data *pdata;
};

Flusso di inizializzazione del dispositivo della piattaforma portuale

Flusso di inizializzazione della porta

• afu_probe() afu_dev_init()
  • Inizializza una struct fpga_afu e salvala nel campo feature_platform_data.private.
• afu_probe() fpga_dev_feature_init() feature_instance_init()
  • Salva una struttura feature_ops in feature_platform_data.features per ogni feature popolata.
  • Chiamare la funzione di test, se presente, dalla struttura.
  • Chiama la funzione init dalla struttura.
• afu_probe() fpga_register_dev_ops()
  • Crea il nodo del dispositivo del carattere Port, registrando una struct file_operazioni.

FME IOCTL
IOCTL che vengono richiamati su un open file descrittore per /dev/intel-fpga-fme.j FPGA_GET_API_VERSION: restituisce la versione corrente come numero intero, a partire da 0.

FPGA_CHECK_EXTENSION: attualmente non supportato.

FPGA_FME_PORT_RELEASE—arg è un puntatore a:

struct fpga_fme_port_release {
__u32 argsz; // in: sizeof(struct fpga_fme_port_release)
__u32 flag; // in: deve essere 0
__u32 id_porta; // in: ID porta (da 0) da rilasciare.
};

FPGA_FME_PORT_ASSIGN—arg è un puntatore a:

struct fpga_fme_port_assign {
__u32 argsz; // in: sizeof(struct fpga_fme_port_assign)
__u32 flag; // in: deve essere 0
__u32 id_porta; // in: ID porta (da 0) da assegnare. (deve essere stato
precedentemente rilasciato da FPGA_FME_PORT_RELEASE)
};

FPGA_FME_PORT_PR—arg è un puntatore a:

struttura fpga_fme_port_pr {
__u32 argsz; // in: sizeof(struct fpga_fme_port_pr)
__u32 flag; // in: deve essere 0
__u32 id_porta; // in: ID porta (da 0)
__u32 dimensione_buffer; // in: dimensione del buffer bitstream in byte. Deve essere di 4 byte
allineati.
__u64 indirizzo_buffer; // in: indirizzo di processo del buffer bitstream
__u64 stato; // out: stato di errore (maschera di bit)
};

IOCTL portuali
IOCTL che vengono richiamati su un open file descrittore per /dev/intel-fpga-port.k FPGA_GET_API_VERSION: restituisce la versione corrente come numero intero, a partire da 0. FPGA_CHECK_EXTENSION: attualmente non supportato.

FPGA_PORT_GET_INFO—arg è un puntatore a:

struct fpga_port_info {
__u32 argsz; // in: sizeof(struct fpga_port_info)
__u32 flag; // out: restituisce 0
__u32 num_regioni; // out: numero di regioni MMIO, 2 (1 per AFU e 1 per
PST)
__u32 num_umsgs; // out: numero di UMsg supportati dall'hardware
};

FPGA_PORT_GET_REGION_INFO—arg è un puntatore a:

struct fpga_port_region_info {
__u32 argsz; // in: sizeof(struct fpga_port_region_info)
__u32 flag; // out: (maschera di bit) { FPGA_REGION_READ, FPGA_REGION_WRITE,
FPGA_REGION_MMAP}
__u32 indice; // in: FPGA_PORT_INDEX_UAFU o FPGA_PORT_INDEX_STP
__u32 imbottitura; // in: deve essere 0
__u64 dimensione; // out: dimensione della regione MMIO in byte
__u64 scostamento; // out: offset della regione MMIO dall'inizio del dispositivo fd
};

FPGA_PORT_DMA_MAP—arg è un puntatore a:
struttura fpga_port_dma_map {
__u32 argsz; // in: sizeof(struct fpga_port_dma_map)
__u32 flag; // in: deve essere 0 __u64 user_addr; // in: processo virtuale
indirizzo. Deve essere allineato alla pagina.
__u64 lunghezza; // in: lunghezza della mappatura in byte. Deve essere un multiplo di pagina
misurare.
__u64 iova; // out: indirizzo virtuale IO };

FPGA_PORT_DMA_UNMAP—arg è un puntatore a:
struct fpga_port_dma_unmap {
__u32 argsz; // in: sizeof(struct fpga_port_dma_unmap)
__u32 flag; // in: deve essere 0
__u64 iova; // in: indirizzo virtuale IO restituito da un file precedente
FPGA_PORT_DMA_MAP};

• FPGA_PORT_RESET—l'argomento deve essere NULL.
• FPGA_PORT_UMSG_ENABLE—l'argomento deve essere NULL.
• FPGA_PORT_UMSG_DISABLE: gli argomenti devono essere NULL.

FPGA_PORT_UMSG_SET_MODE—arg è un puntatore a:

struct fpga_port_umsg_cfg {
__u32 argsz; // in: sizeof(struct fpga_port_umsg_cfg)
__u32 flag; // in: deve essere 0
__u32 hint_bitmap; // in: bitmap in modalità suggerimento UMsg. Indica quali sono gli UMsg
abilitato.
};

FPGA_PORT_UMSG_SET_BASE_ADDR—

• UMsg deve essere disabilitato prima di emettere questo ioctl.
• Il campo iova deve essere per un buffer sufficientemente grande per tutti gli UMsg (num_umsgs * PAGE_SIZE).
  • Il buffer è contrassegnato come "in uso" dalla gestione del buffer del conducente.
  • Se iova è NULL, qualsiasi regione precedente non è contrassegnata come "in uso".
• arg è un puntatore a:
  struct fpga_port_umsg_base_addr {
  • u32 argsz; // in: sizeof(struct fpga_port_umsg_base_addr)
  • bandiere u32; // in: deve essere 0
  • u64 iova; // in: indirizzo virtuale IO da FPGA_PORT_DMA_MAP. };

Nota:

• Per cancellare gli errori di porta, devi scrivere la maschera di bit esatta degli errori correnti, ad esample, errori cat > clear
• UMsg è supportato solo tramite lo stack di accelerazione per il processore Intel Xeon con FPGA integrato.

sistema operativo Files

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

sistema operativo file	campo mmio	tipo	accesso
porte_num	fme_header.capability.num_ports	decimale int	Di sola lettura
dimensione_cache	fme_header.capability.cache_size	decimale int	Di sola lettura
versione	fme_header.capability.fabric_verid	decimale int	Di sola lettura
socket_id	fme_header.capability.socket_id	decimale int	Di sola lettura
bitstream_id	fme_header.bitstream_id	esadecimale uint64_t	Di sola lettura
bitstream_metadati	fme_header.bitstream_md	esadecimale uint64_t	Di sola lettura

Sistemi di gestione termica FME files
intel-fpga-dev.i/intel-fpga-fme.j/thermal_mgmt/

sistema operativo file	campo mmio	tipo	accesso
soglia1	termica.soglia.tmp_thshold1	decimale int	Utente: sola lettura Root: lettura-scrittura
soglia2	termica.soglia.tmp_thshold2	decimale int	Utente: sola lettura Root: lettura-scrittura
soglia_viaggio	termica.soglia.therm_trip_thshold	decimale int	Di sola lettura
soglia1_raggiunta	Thermal.threshold.thshold1_status	decimale int	Di sola lettura
soglia2_raggiunta	Thermal.threshold.thshold2_status	decimale int	Di sola lettura
soglia1_politica	termico. threshold.thshold_policy	decimale int	Utente: sola lettura Root: lettura-scrittura
temperatura	termico.rdsensor_fm1.fpga_temp	decimale int	Di sola lettura

Sistema di gestione dell'alimentazione FME files
intel-fpga-dev.i/intel-fpga-fme.j/power_mgmt/

sistema operativo file	campo mmio	tipo	accesso
consumato	power.status.pwr_consumed	esadecimale uint64_t	Di sola lettura
soglia1	soglia.di.potenza.soglia1	esadecimale uint64_t	Utente: sola lettura Root: lettura-scrittura
soglia2	soglia.di.potenza.soglia2	esadecimale uint64_t	Utente: sola lettura Root: lettura-scrittura
soglia1_stato	power.threshold.threshold1_status	decimale senza segno	Di sola lettura
soglia2_stato	power.threshold.threshold2_status	decimale senza segno	Di sola lettura
in linea	power.status.fpga_latency_report	decimale senza segno	Di sola lettura

Errore globale FME sysfs files
intel-fpga-dev.i/intel-fpga-fme.j/errors/

sistema operativo file	campo mmio	tipo	accesso
pcie0_errori	gerror.pcie0_err	esadecimale uint64_t	Leggere scrivere
pcie1_errori	gerror.pcie1_err	esadecimale uint64_t	Leggere scrivere
iniezione_errore	gerror.ras_error_inj	esadecimale uint64_t	Leggere scrivere

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

sistema operativo file	campo mmio	tipo	accesso
errori	gerror.fme_err	esadecimale uint64_t	Di sola lettura
primo_errore	gerror.fme_first_err.err_reg_status	esadecimale uint64_t	Di sola lettura
prossimo_errore	gerror.fme_next_err.err_reg_status	esadecimale uint64_t	Di sola lettura
chiaro	Cancella gli errori, first_error, next_error	vari uint64_t	Solo scrittura

Nota:
Per cancellare gli errori FME, è necessario scrivere la maschera di bit esatta degli errori correnti, ad esamperrori le cat > cancella.

FME Riconfigurazione parziale sysfs files
intel-fpga-dev.i/intel-fpga-fme.j/pr/

sistema operativo file	campo mmio	tipo	accesso
interfaccia_id	pr.fme_pr_intfc_id0_h, pr.fme_pre_intfc_id0_l	esadecimale 16 byte	Di sola lettura

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

sistema operativo file	campo mmio	tipo	accesso
orologio	gperf.clk.afu_interf_clock	esadecimale uint64_t	Di sola lettura

intel-fpga-dev.i/intel-fpga-fme.j/dperf/cache/ (non valido per Acceleration Stack per CPU Intel Xeon con FPGA)

sistema operativo file	campo mmio	tipo	accesso
congelare	gperf.ch_ctl.freeze	decimale int	Leggere scrivere
leggi_colpisci	gperf.CACHE_RD_HIT	esadecimale uint64_t	Di sola lettura
read_miss	gperf.CACHE_RD_MISS	esadecimale uint64_t	Di sola lettura
write_hit	gperf.CACHE_WR_HIT	esadecimale uint64_t	Di sola lettura
write_miss	gperf.CACHE_WR_MISS	esadecimale uint64_t	Di sola lettura
attesa_richiesta	gperf.CACHE_HOLD_REQ	esadecimale uint64_t	Di sola lettura
tx_req_stall	gperf.CACHE_TX_REQ_STALL	esadecimale uint64_t	Di sola lettura

sistema operativo file	campo mmio	tipo	accesso
rx_req_stall	gperf.CACHE_RX_REQ_STALL	esadecimale uint64_t	Di sola lettura
data_write_port_contention	gperf.CACHE_DATA_WR_PORT_CONTEN	esadecimale uint64_t	Di sola lettura
tag_write_port_contention	gperf.CACHE_TAG_WR_PORT_CONTEN	esadecimale uint64_t	Di sola lettura

intel-fpga-dev.i/intel-fpga-fme.j/dperf/iommu/ (non valido per Acceleration Stack per CPU Intel Xeon con FPGA)

sistema operativo file	campo mmio	tipo	accesso
congelare	gperf.vtd_ctl.freeze	decimale int	Utente: sola lettura Root: lettura-scrittura

intel-fpga-dev.i/intel-fpga-fme.j/dperf/iommu/afuk/ (non valido per Acceleration Stack per CPU Intel Xeon con FPGA)

sistema operativo file	campo mmio	tipo	accesso
leggi_transazione	gperf.VTD_AFU0_MEM_RD_TRANS	esadecimale uint64_t	Di sola lettura
write_transaction	gperf.VTD_AFU0_MEM_WR_TRANS	esadecimale uint64_t	Di sola lettura
tlb_read_hit	gperf.VTD_AFU0_TLB_RD_HIT	esadecimale uint64_t	Di sola lettura
tlb_write_hit	gperf.VTD_AFU0_TLB_WR_HIT	esadecimale uint64_t	Di sola lettura

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

sistema operativo file	campo mmio	tipo	accesso
abilitare	gperf.fab_ctl.(abilitato)	decimale int	Utente: sola lettura Root: lettura-scrittura
congelare	gperf.fab_ctl.freeze	decimale int	Utente: sola lettura Root: lettura-scrittura
pcie0_read	gperf.FAB_PCIE0_RD	esadecimale uint64_t	Di sola lettura
pcie0_write	gperf.FAB_PCIE0_WR	esadecimale uint64_t	Di sola lettura
pcie1_read	gperf.FAB_PCIE1_RD	esadecimale uint64_t	Di sola lettura
pcie1_write	gperf.FAB_PCIE1_WR	esadecimale uint64_t	Di sola lettura
upi_read	gperf.FAB_UPI_RD	esadecimale uint64_t	Di sola lettura
upi_write	gperf.FAB_UPI_WR	esadecimale uint64_t	Di sola lettura

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

sistema operativo file	campo mmio	tipo	accesso
pcie0_read	gperf.FAB_PCIE0_RD	esadecimale uint64_t	Di sola lettura
pcie0_write	gperf.FAB_PCIE0_WR	esadecimale uint64_t	Di sola lettura
pcie1_read	gperf.FAB_PCIE1_RD	esadecimale uint64_t	Di sola lettura
pcie1_write	gperf.FAB_PCIE1_WR	esadecimale uint64_t	Di sola lettura
upi_read	gperf.FAB_UPI_RD	esadecimale uint64_t	Di sola lettura
upi_write	gperf.FAB_UPI_WR	esadecimale uint64_t	Di sola lettura

Sysfs intestazione porta files
intel-fpga-dev.i/intel-fpga-port.k/

sistema operativo file	campo mmio	tipo	accesso
id	port_header.capability.port_number	decimale int	Di sola lettura
litro	port_header.control.latency_tolerance	decimale int	Di sola lettura

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

sistema operativo file	campo mmio	tipo	accesso
afu_id	afu_header.guid	esadecimale 16 byte	Di sola lettura

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

sistema operativo file	campo mmio	tipo	accesso
errori	perror.porta_errore	esadecimale uint64_t	Di sola lettura
primo_errore	perror.port_first_error	esadecimale uint64_t	Di sola lettura
first_malformed_req	perror.malreq	esadecimale 16 byte	Di sola lettura
chiaro	perror.(tutti gli errori)	vari uint64_t	Solo scrittura

Nota:
Per cancellare gli errori di porta, devi scrivere la maschera di bit esatta degli errori correnti, ad esamperrori le cat > cancella.

Cronologia delle revisioni

Versione del documento	Cambiamenti
2017.10.02	Versione iniziale.

OPAE Intel FPGA Guida all'architettura dei driver di dispositivo Linux

Documenti / Risorse

Intel OPAE FPGA Linux Device Driver Architecture [pdf] Guida utente OPAE FPGA Linux Device Driver Architecture, OPAE FPGA, Linux Device Driver Architecture, Architettura driver, Architettura

Riferimenti

• Manuale d'uso