Intel OPAE FPGA Linux Device Driver Architecture

Arquitectura del controlador de dispositiu OPAE Intel FPGA Linux

El controlador OPAE Intel FPGA proporciona interfícies per a aplicacions d'espai d'usuari per configurar, enumerar, obrir i accedir als acceleradors FPGA en plataformes equipades amb solucions Intel FPGA i permet funcions de gestió a nivell de sistema com ara la reconfiguració d'FPGA, la gestió de l'energia i la virtualització.

Arquitectura de maquinari

Des del punt de vista del sistema operatiu view, el maquinari FPGA apareix com un dispositiu PCIe normal. La memòria del dispositiu FPGA s'organitza mitjançant una estructura de dades predefinida (Llista de característiques del dispositiu). Les característiques compatibles amb el dispositiu FPGA s'exposen a través d'aquestes estructures de dades, tal com es mostra a continuació a la figura següent:

Dispositiu FPGA PCIe

El controlador admet PCIe SR-IOV per crear funcions virtuals (VF) que es poden utilitzar per assignar acceleradors individuals a màquines virtuals.

Intel Corporation. Tots els drets reservats. Intel, el logotip d'Intel i altres marques d'Intel són marques comercials d'Intel Corporation o de les seves filials. Intel garanteix el rendiment dels seus productes FPGA i semiconductors amb les especificacions actuals d'acord amb la garantia estàndard d'Intel, però es reserva el dret de fer canvis a qualsevol producte i servei en qualsevol moment sense previ avís. Intel no assumeix cap responsabilitat derivada de l'aplicació o l'ús de qualsevol informació, producte o servei descrit aquí, tret que Intel ho acordi expressament per escrit. Es recomana als clients d'Intel que obtinguin la darrera versió de les especificacions del dispositiu abans de confiar en qualsevol informació publicada i abans de fer comandes de productes o serveis.

Altres noms i marques es poden reclamar com a propietat d'altres.

Dispositiu PCIe FPGA virtualitzat

Motor de gestió FPGA (FME)
El motor de gestió FPGA realitza la gestió de l'energia i la tèrmica, informes d'errors, reconfiguració, informes de rendiment i altres funcions d'infraestructura. Cada FPGA té un FME, al qual sempre s'accedeix mitjançant la funció física (PF). Les aplicacions d'espai d'usuari poden adquirir accés exclusiu a l'FME mitjançant open(), i alliberar-lo mitjançant close() com a usuari privilegiat (arrel).

Port
Un port representa la interfície entre el teixit FPGA estàtic (el "Gestor d'interfícies FPGA (FIM)") i una regió parcialment reconfigurable que conté una funció d'acceleració (AF). El port controla la comunicació del programari a l'accelerador i exposa funcions com ara el restabliment i la depuració. Un dispositiu PCIe pot tenir diversos ports i cada port es pot exposar mitjançant un VF assignant-lo mitjançant l'octl FPGA_FME_PORT_ASSIGN del dispositiu FME.

Unitat de la funció d'acceleració (AF).

• Una unitat de funció d'accelerador (AF) està connectada a un port i exposa una regió MMIO de 256K per utilitzar-la per als registres de control específics de l'accelerador.
• Les aplicacions d'espai d'usuari poden obtenir accés exclusiu a una AFU connectada a un port mitjançant open() al dispositiu Port, i alliberar-la mitjançant close().
• Les aplicacions d'espai d'usuari també poden accelerar mmap() regions MMIO.

Reconfiguració parcial
Com s'ha esmentat anteriorment, els acceleradors es poden reconfigurar mitjançant la reconfiguració parcial d'una funció d'accelerador (AF) file. La funció d'acceleració (AF) s'ha d'haver generat per a la FIM exacta i la regió estàtica (Port) objectiu de l'FPGA; en cas contrari, l'operació de reconfiguració fallarà i possiblement provocarà inestabilitat del sistema. Aquesta compatibilitat es pot comprovar comparant l'ID de la interfície indicat a la capçalera AF amb l'ID de la interfície exposat per l'FME a través de sysfs. Aquesta comprovació la fa normalment l'espai d'usuari abans de cridar l'IOCTL de reconfiguració.

Nota:
Actualment, qualsevol programa de programari que accedeixi a l'FPGA, inclosos els que s'executen en un host virtualitzat, s'han de tancar abans d'intentar una reconfiguració parcial. Els passos serien:

1. Descarregueu el conductor del convidat
2. Desconnecteu el VF del convidat
3. Desactiva SR-IOV
4. Realitzeu una reconfiguració parcial
5. Activa SR-IOV
6. Connecteu el VF al convidat
7. Carregueu el conductor al convidat

Virtualització FPGA
Per permetre l'accés a un accelerador des d'aplicacions que s'executen en una màquina virtual, el port de l'AFU corresponent s'ha d'assignar a un VF mitjançant els passos següents:

1. El PF és propietari de tots els ports AFU per defecte. Qualsevol port que s'hagi de reassignar a un VF primer s'ha d'alliberar del PF mitjançant l'octl FPGA_FME_PORT_RELEASE del dispositiu FME.
2. Un cop s'alliberin N ports del PF, es pot utilitzar l'ordre següent per habilitar SRIOV i VF. Cada VF només té un port amb AFU. echo N > PCI_DEVICE_PATH/sriov_numvfs
3. Passeu els VF a les VM.
4. L'AFU sota VF és accessible des d'aplicacions a VM (utilitzant el mateix controlador dins del VF).

Nota:
No es pot assignar un FME a un VF, per tant, les relacions públiques i altres funcions de gestió només estan disponibles a través del PF.

Organització del conductor

Controlador de dispositiu del mòdul PCIe

Organització del conductor

Els dispositius FPGA apareixen com a dispositius PCIe normals; per tant, el controlador de dispositiu FPGA PCIe (intel-FPGA-PCI.ko) sempre es carrega primer un cop es detecta un FPGA PCIe PF o VF. Aquest controlador té un paper d'infraestructura en l'arquitectura del controlador. Això:

• Crea un dispositiu contenidor FPGA com a pare dels dispositius amb funcions.
• Passa per la llista de característiques del dispositiu, que s'implementa a la memòria BAR del dispositiu PCIe, per descobrir dispositius amb funcions i les seves subcaracterístiques i crear-los dispositius de plataforma sota el dispositiu contenidor.
• Suporta SR-IOV.
• Presenta la infraestructura de dispositius de característiques, que resumeix les operacions de les sub-funcions i exposa les funcions comunes als controladors de dispositius de característiques.

Funcions del controlador del dispositiu del mòdul PCIe

• Conté descobriment de PCIe, enumeració de dispositius i descobriment de funcions.
• Crea directoris sysfs per al dispositiu pare, el motor de gestió FPGA (FME) i el port.
• Crea les instàncies del controlador de la plataforma, fent que el nucli de Linux carregui els seus respectius controladors de mòdul de plataforma.

Controlador de dispositiu del mòdul de plataforma FME

• Gestió d'energia i tèrmica, informes d'errors, informes de rendiment i altres funcions d'infraestructura. Podeu accedir a aquestes funcions mitjançant les interfícies sysfs exposades pel controlador FME.
• Reconfiguració parcial. El controlador FME registra un gestor FPGA durant la inicialització de la subfunció PR; una vegada que rep un ioctl FPGA_FME_PORT_PR de tu, invoca la funció d'interfície comuna de FPGA Manager per completar la reconfiguració parcial del flux de bits al port donat.
• Gestió de ports per a la virtualització. El controlador FME introdueix dos ioctls, FPGA_FME_PORT_RELEASE, que allibera el port donat de PF; i FPGA_FME_PORT_ASSIGN, que torna a assignar el port a PF. Un cop alliberat el port del PF, es pot assignar al VF mitjançant les interfícies SR-IOV proporcionades pel controlador PCIe. Per obtenir més informació, consulteu "Virtualització FPGA".

Funcions del controlador del dispositiu del mòdul de plataforma FME

• Crea el node del dispositiu de caràcters FME.
• Crea els sysfs FME files i implementa els sysfs FME file accessoris.
• Implementa els subcontroladors de funció privada FME.
• Subconductors de funció privada de FME:
  • Capçalera FME
  • Gestió tèrmica
  • Gestió d'energia
  • Error global
  • Reconfiguració parcial
  • Rendiment global

Controlador de dispositiu del mòdul de plataforma de ports
De manera similar al controlador FME, el controlador del port FPGA (i AFU) (intel-fpga-afu. ko) es prova un cop es crea el dispositiu de la plataforma del port. La funció principal d'aquest mòdul és proporcionar una interfície per a les aplicacions d'espai d'usuari per accedir als acceleradors individuals, inclòs el control bàsic de restabliment del port, l'exportació de la regió AFU MMIO, el servei de mapatge de memòria intermèdia DMA, la notificació UMsg(1) i les funcions de depuració remota ( veure més amunt).

UMsg només és compatible amb Acceleration Stack per al processador Intel Xeon® amb FPGA integrat.

Funcions del controlador del dispositiu del mòdul de la plataforma de ports

• Crea el node de dispositiu de caràcter Port.
• Crea el port sysfs files i implementa el port sysfs file accessoris.
• Implementa els subcontroladors de la funció privada del port.
• Subconductors de funció privada del port:
  • Capçalera del port
  • AFU
  • Error de port
  • UMsg(2)
  • Toc de senyal

Aplicació Enumeració de dispositius FPGA
Aquesta secció presenta com les aplicacions enumeren el dispositiu FPGA de la jerarquia sysfs a /sys/class/fpga. En l'exampA continuació, hi ha dos dispositius Intel FPGA instal·lats a l'amfitrió. Cada dispositiu FPGA té un FME i dos ports (AFU). Per a cada dispositiu FPGA, es crea un directori de dispositius a /sys/class/fpga:

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

Cada node té un FME i dos ports (AFU) com a dispositius secundaris:
/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

En general, les interfícies FME/Port sysfs s'anomenen de la següent manera:
/sys/class/fpga/intel-fpga-dev.i/intel-fpga-fme.j/
/sys/class/fpga/intel-fpga-dev.i/intel-fpga-port.k/

amb I numerant consecutivament tots els dispositius contenidors, j numerant consecutivament els FME i k numerant consecutivament tots els ports.

Els nodes de dispositiu utilitzats per a ioctl() i mmap() es poden fer referència a través de:
/dev/intel-fpga-fme.j
/dev/intel-fpga-port.k

Enumeració del controlador PCIe
Aquesta secció dóna un finalview del flux de codi per a l'enumeració de dispositius realitzada per intel-fpga-pci.ko. Es destaquen les principals estructures i funcions de dades. Aquesta secció es segueix millor quan viewintroduint el codi font adjunt (pcie.c).

Estructures de dades d'enumeració

enumeració fpga_id_type {
PARENT_ID,
FME_ID,
PORT_ID,
FPGA_ID_MAX
};
idr d'estructura estàtica fpga_ids[FPGA_ID_MAX];
struct fpga_chardev_info {
const char *nom;
dev_t devt;
};
struct fpga_chardev_info fpga_chrdevs[] = {
{ .name = FPGA_FEATURE_DEV_FME },
{ .name = FPGA_FEATURE_DEV_PORT },
};
classe d'estructura estàtica *fpga_class;
estructura estàtica 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,}
};
Estructura estàtica 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 identificador_dispositiu;
dispositiu struct *fme_dev;
bloqueig struct mutex;
struct list_head port_dev_list;
int número_port_alliberat;
struct list_head regions;
};
struct build_feature_devs_info {
struct pci_dev *pdev;
void __iomem *ioaddr;
void __iomem *ioend;
int barra_actual;
void __iomem *pfme_hdr;
dispositiu struct *parent_dev;
struct platform_device *feature_dev;
};

Flux d'enumeració

• ccidrv_init()
  • Inicialitzeu fpga_ids utilitzant idr_init().
  • Inicialitzeu fpga_chrdevs[i].devt mitjançant alloc_chrdev_region().
  • Inicialitzeu fpga_class utilitzant class_create().
  • pci_register_driver(&cci_pci_driver);
• cci_pci_probe()
  • Habiliteu el dispositiu PCI, sol·liciteu accés a les seves regions, configureu el mode mestre PCI i configureu DMA.
• cci_pci_create_feature_devs() build_info_alloc_and_init()
  • Asigneu una estructura build_feature_devs_info, inicialitzeu-la.
    .parent_dev s'estableix en un directori sysfs principal (intel-fpga-dev.id) que conté els directoris FME i Port sysfs.
• parse_feature_list()
  • Passeu per la llista de funcions del dispositiu BAR0 per descobrir el FME, el port i les seves característiques privades.
• parse_feature() parse_feature_afus() parse_feature_fme()
  • Quan es troba un FME:
• build_info_create_dev()
  • Assigna un dispositiu de plataforma per a l'FME, emmagatzemant a build_feature_devs_info.feature_dev.
  • feature_dev.id s'inicialitza amb el resultat de idr_alloc(fpga_ids[FME_ID],
  • feature_dev.parent està configurat com a build_feature_devs_info.parent_dev.
  • Assigna una matriu de recursos d'estructura a feature_dev.resource.
• Assigna una estructura feature_platform_data, inicialitza-la i emmagatzema un punter a feature_dev.dev.platform_data
  • create_feature_instance() build_info_add_sub_feature()
  • Inicialitza feature_dev.resource[FME_FEATURE_ID_HEADER].
  • feature_platform_data_add()
  • Inicialitzeu feature_platform_data.features[FME_FEATURE_ID_HEADER], tot menys .fops.
• parse_feature() parse_feature_afus() parse_feature_port()
  • Quan es troba un port:
• build_info_create_dev()
  • Assigna un dispositiu de plataforma per al port, emmagatzemant a build_feature_devs_info.feature_dev.
  • feature_dev.id s'inicialitza amb el resultat de idr_alloc(fpga_ids[PORT_ID],
  • feature_dev.parent està configurat com a build_feature_devs_info.parent_dev.
  • Assigna una matriu de recursos d'estructura a feature_dev.resource.
  • Assigna una estructura feature_platform_data, inicialitza-la i emmagatzema un punter a feature_dev.dev.platform_data
• build_info_commit_dev()
  • Afegiu l'estructura feature_platform_data.node per al port a la llista de ports a struct cci_drvdata.port_dev_list
• create_feature_instance() build_info_add_sub_feature()
  • Inicialitza feature_dev.resource[PORT_FEATURE_ID_HEADER].
• feature_platform_data_add()
  • Inicialitzeu feature_platform_data.features[PORT_FEATURE_ID_HEADER], tot menys .fops.
• parse_feature() parse_feature_afus() parse_feature_port_uafu()
  • Quan es troba una AFU:
• create_feature_instance() build_info_add_sub_feature()
  • Inicialitza feature_dev.resource[PORT_FEATURE_ID_UAFU].
• feature_platform_data_add()
  • Inicialitzeu feature_platform_data.features[PORT_FEATURE_ID_UAFU], tot menys .fops.
• parse_feature() parse_feature_private() parse_feature_fme_private()
  • Quan es troba una funció privada de FME:
• create_feature_instance() build_info_add_sub_feature()
  • Inicialitzar feature_dev.resource[id].
• feature_platform_data_add()
  • Inicialitzeu feature_platform_data.features[id], tot menys .fops.
• parse_feature() parse_feature_private() parse_feature_port_private()
• Quan es troba una característica privada del port: * create_feature_instance() build_info_add_sub_feature() * Inicialitza feature_dev.resource[id]. * feature_platform_data_add() Inicialitzeu feature_platform_data.features[id], tot menys .fops.
• parse_ports_from_fme()
  • Si el controlador està carregat a la funció física (PF), aleshores:
• Executeu el flux parse_feature_list() a cada port descrit a la capçalera FME.
• Utilitzeu la BAR esmentada a cada entrada de Port a la capçalera.

Inicialització del dispositiu de la plataforma FME
Aquesta secció dóna un finalview del flux de codi per a la inicialització del dispositiu FME realitzada per intel-fpga-fme.ko. Es destaquen les principals estructures i funcions de dades. Aquesta secció es segueix millor quan viewfent servir el codi font adjunt (fme-main.c).

Estructures de dades del dispositiu de la plataforma FME

struct feature_ops {
int (*init)(struct platform_device *pdev, struct feature *feature);
int (*uinit)(struct platform_device *pdev, struct feature *feature);
llarg (*ioctl)(struct platform_device *pdev, característica struct *funció,
unsigned int cmd, unsigned long arg);
int (*test)(struct platform_device *pdev, struct feature *feature);
};
característica d'estructura {
const char *nom;
int índex_recursos;
void __iomem *ioaddr;
struct feature_ops *ops;
};
struct feature_platform_data {
struct list_head node;
bloqueig struct mutex;
dev_status llarg sense signar;
struct cdev cdev;
struct platform_device *dev;
unsigned int disable_count;
buit *privat;
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 *)); estructura
característiques de les característiques[0];
};
struct perf_object {
int id;
const struct grup_atributs **grups_attr;
dispositiu struct *fme_dev;
struct list_head node;
struct list_head fills;
struct kobject kobj;
};
struct fpga_fme {
u8 port_id;
u64 pr_err;
dispositiu struct *dev_err;
struct perf_object *perf_dev;
struct feature_platform_data *pdata;
};

Flux d'inicialització del dispositiu de la plataforma FME

Flux d'inicialització FME

• fme_probe() fme_dev_init()
  • Inicialitzeu una estructura fpga_fme i deseu-la al camp feature_platform_data.private.
• fme_probe() fpga_dev_feature_init() feature_instance_init()
  • Deseu una estructura feature_ops a feature_platform_data.features per a cada característica emplenada.
  • Truqueu a la funció de prova, si n'hi ha, des de l'estructura.
  • Crida la funció init des de l'struct.
• fme_probe() fpga_register_dev_ops()
  • Creeu el node del dispositiu de caràcters FME, registrant una estructura file_operacions.

Inicialització del dispositiu de la plataforma del port
Aquesta secció dóna un finalview del flux de codi per a la inicialització del dispositiu de port realitzada per intel-fpga-afu.ko. Es destaquen les principals estructures i funcions de dades. Aquesta secció es segueix millor quan viewfent servir el codi font adjunt (afu.c).

Estructures de dades del dispositiu de la plataforma del port

struct feature_ops {
int (*init)(struct platform_device *pdev, struct feature *feature);
int (*uinit)(struct platform_device *pdev, struct feature *feature);
llarg (*ioctl)(struct platform_device *pdev, característica struct *funció,
unsigned int cmd, unsigned long arg);
int (*test)(struct platform_device *pdev, struct feature *feature);
};
característica d'estructura {
const char *nom;
int índex_recursos;
void __iomem *ioaddr;
struct feature_ops *ops;
};
struct feature_platform_data {
struct list_head node;
bloqueig struct mutex;
dev_status llarg sense signar;
struct cdev cdev;
struct platform_device *dev;
unsigned int disable_count;
buit *privat;
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 *));
característiques d'estructura[0];
};
struct fpga_afu_region {
índex u32;
banderes u32;
mida u64;
desplaçament u64;
u64 fis;
struct list_head node;
};
struct fpga_afu_dma_region {
u64 user_addr;
u64 llargada;
u64 iova;
struct pàgina **pàgines;
struct rb_node node;
bool in_use;
};
estructura fpga_afu {
u64 region_cur_offset;
int num_regions;
u8 num_umsgs;
struct list_head regions;
struct rb_root dma_regions;
struct feature_platform_data *pdata;
};

Flux d'inicialització del dispositiu de la plataforma del port

Flux d'inicialització del port

• afu_probe() afu_dev_init()
  • Inicialitzeu una estructura fpga_afu i emmagatzemeu-la al camp feature_platform_data.private.
• afu_probe() fpga_dev_feature_init() feature_instance_init()
  • Deseu una estructura feature_ops a feature_platform_data.features per a cada característica emplenada.
  • Truqueu a la funció de prova, si n'hi ha, des de l'estructura.
  • Crida la funció init des de l'struct.
• afu_probe() fpga_register_dev_ops()
  • Creeu el node de dispositiu de caràcter Port, registrant una estructura file_operacions.

IOCTL de FME
IOCTL que es convoquen en obert file descriptor per a /dev/intel-fpga-fme.j FPGA_GET_API_VERSION: retorna la versió actual com a nombre enter, començant per 0.

FPGA_CHECK_EXTENSION: actualment no és compatible.

FPGA_FME_PORT_RELEASE: arg és un punter a:

struct fpga_fme_port_release {
__u32 argsz; // a: sizeof(struct fpga_fme_port_release)
__u32 banderes; // a: ha de ser 0
__u32 port_id; // a: ID de port (a partir de 0) per alliberar.
};

FPGA_FME_PORT_ASSIGN: arg és un punter a:

struct fpga_fme_port_assign {
__u32 argsz; // a: sizeof(struct fpga_fme_port_assign)
__u32 banderes; // a: ha de ser 0
__u32 port_id; // a: ID de port (a partir de 0) per assignar. (devia ser
publicat anteriorment per FPGA_FME_PORT_RELEASE)
};

FPGA_FME_PORT_PR: arg és un punter a:

struct fpga_fme_port_pr {
__u32 argsz; // a: sizeof(struct fpga_fme_port_pr)
__u32 banderes; // a: ha de ser 0
__u32 port_id; // a: ID de port (a partir de 0)
__u32 buffer_size; // a: mida del buffer de flux de bits en bytes. Ha de ser de 4 bytes
alineats.
__u64 buffer_address; // a: adreça de procés del buffer de flux de bits
__u64 estat; // fora: estat d'error (màscara de bits)
};

Port IOCTLs
IOCTL que es convoquen en obert file descriptor per a /dev/intel-fpga-port.k FPGA_GET_API_VERSION: retorna la versió actual com a nombre enter, començant per 0. FPGA_CHECK_EXTENSION: no és compatible actualment.

FPGA_PORT_GET_INFO: arg és un punter a:

struct fpga_port_info {
__u32 argsz; // a: sizeof(struct fpga_port_info)
__u32 banderes; // fora: retorna 0
__u32 num_regions; // sortida: nombre de regions MMIO, 2 (1 per a AFU i 1 per a
STP)
__u32 num_umsgs; // out: nombre d'UMsg suportats pel maquinari
};

FPGA_PORT_GET_REGION_INFO: arg és un punter a:

struct fpga_port_region_info {
__u32 argsz; // a: sizeof(struct fpga_port_region_info)
__u32 banderes; // sortida: (màscara de bits) { FPGA_REGION_READ, FPGA_REGION_WRITE,
FPGA_REGION_MMAP }
__índex u32; // a: FPGA_PORT_INDEX_UAFU o FPGA_PORT_INDEX_STP
__u32 farciment; // a: ha de ser 0
__u64 mida; // fora: mida de la regió MMIO en bytes
__u64 desplaçament; // fora: desplaçament de la regió MMIO des de l'inici del dispositiu fd
};

FPGA_PORT_DMA_MAP: arg és un punter a:
struct fpga_port_dma_map {
__u32 argsz; // a: sizeof(struct fpga_port_dma_map)
__u32 banderes; // a: ha de ser 0 __u64 user_addr; // a: procés virtual
adreça. Ha d'estar alineat a la pàgina.
__u64 llargada; // in: longitud del mapeig en bytes. Ha de ser un múltiple de pàgina
mida.
__u64 iova; // sortida: adreça virtual IO };

FPGA_PORT_DMA_UNMAP: arg és un punter a:
struct fpga_port_dma_unmap {
__u32 argsz; // a: sizeof(struct fpga_port_dma_unmap)
__u32 banderes; // a: ha de ser 0
__u64 iova; // a: adreça virtual IO retornada per una anterior
FPGA_PORT_DMA_MAP };

• FPGA_PORT_RESET: l'arg ha de ser NULL.
• FPGA_PORT_UMSG_ENABLE: l'arg ha de ser NULL.
• FPGA_PORT_UMSG_DISABLE: els arguments han de ser NULL.

FPGA_PORT_UMSG_SET_MODE: arg és un punter a:

estructura fpga_port_umsg_cfg {
__u32 argsz; // a: sizeof(struct fpga_port_umsg_cfg)
__u32 banderes; // a: ha de ser 0
__u32 hint_bitmap; // a: mapa de bits en mode suggeriment UMsg. Indica quins són els UMsg
habilitat.
};

FPGA_PORT_UMSG_SET_BASE_ADDR—

• UMsg s'ha de desactivar abans d'emetre aquest ioctl.
• El camp iova ha de ser per a una memòria intermèdia prou gran per a tots els UMsg (num_umsgs * PAGE_SIZE).
  • La memòria intermèdia està marcada com a "en ús" per la gestió de la memòria intermèdia del controlador.
  • Si iova és NULL, qualsevol regió anterior no es marca com a "en ús".
• arg és un punter a a:
  struct fpga_port_umsg_base_addr {
  • u32 argsz; // a: sizeof(struct fpga_port_umsg_base_addr)
  • banderes u32; // a: ha de ser 0
  • u64 iova; // a: adreça virtual IO de FPGA_PORT_DMA_MAP. };

Nota:

• Per esborrar els errors del port, heu d'escriure la màscara de bits exacta dels errors actuals, per exempleample, errors de gat > esborrar
• UMsg només és compatible amb Acceleration Stack per al processador Intel Xeon amb FPGA integrat.

sysfs Files

Capçalera FME sysfs files
intel-fpga-dev.i/intel-fpga-fme.j/

sysfs file	camp mmio	tipus	accés
ports_num	fme_header.capability.num_ports	decimal int	Només lectura
cache_size	fme_header.capability.cache_size	decimal int	Només lectura
versió	fme_header.capability.fabric_verid	decimal int	Només lectura
socket_id	fme_header.capability.socket_id	decimal int	Només lectura
bitstream_id	fme_header.bitstream_id	hex uint64_t	Només lectura
metadades_bitstream	fme_header.bitstream_md	hex uint64_t	Només lectura

Sistemes de gestió tèrmica FME files
intel-fpga-dev.i/intel-fpga-fme.j/thermal_mgmt/

sysfs file	camp mmio	tipus	accés
llindar 1	thermal.threshold.tmp_thshold1	decimal int	Usuari: només de lectura Arrel: lectura-escriptura
llindar 2	thermal.threshold.tmp_thshold2	decimal int	Usuari: només de lectura Arrel: lectura-escriptura
threshold_trip	thermal.threshold.therm_trip_thshold	decimal int	Només lectura
llindar1_assolit	llindar.tèrmic.thshold1_estat	decimal int	Només lectura
llindar2_assolit	llindar.tèrmic.thshold2_estat	decimal int	Només lectura
threshold1_policy	tèrmica. threshold.thshold_policy	decimal int	Usuari: només de lectura Arrel: lectura-escriptura
temperatura	thermal.rdsensor_fm1.fpga_temp	decimal int	Només lectura

Sistema de gestió d'energia FME files
intel-fpga-dev.i/intel-fpga-fme.j/power_mgmt/

sysfs file	camp mmio	tipus	accés
consumit	power.status.pwr_consumed	hex uint64_t	Només lectura
llindar 1	llindar.de.potència llindar1	hex uint64_t	Usuari: només de lectura Arrel: lectura-escriptura
llindar 2	llindar.de.potència llindar2	hex uint64_t	Usuari: només de lectura Arrel: lectura-escriptura
llindar1_estat	potència.llindar.llindar1_estat	decimal sense signe	Només lectura
llindar2_estat	potència.llindar.llindar2_estat	decimal sense signe	Només lectura
rtl	power.status.fpga_latency_report	decimal sense signe	Només lectura

FME error global sysfs files
intel-fpga-dev.i/intel-fpga-fme.j/errors/

sysfs file	camp mmio	tipus	accés
pcie0_errors	gerror.pcie0_err	hex uint64_t	Lectura-escriptura
pcie1_errors	gerror.pcie1_err	hex uint64_t	Lectura-escriptura
inject_error	gerror.ras_error_inj	hex uint64_t	Lectura-escriptura

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

sysfs file	camp mmio	tipus	accés
errors	gerror.fme_err	hex uint64_t	Només lectura
primer_error	gerror.fme_first_err.err_reg_status	hex uint64_t	Només lectura
següent_error	gerror.fme_next_err.err_reg_status	hex uint64_t	Només lectura
clar	Esborra errors, first_error, next_error	diversos uint64_t	Només d'escriptura

Nota:
Per esborrar els errors FME, heu d'escriure la màscara de bits exacta dels errors actuals, per exempleampli cat errors > esborrar.

Sysfs de reconfiguració parcial de FME files
intel-fpga-dev.i/intel-fpga-fme.j/pr/

sysfs file	camp mmio	tipus	accés
interface_id	pr.fme_pr_intfc_id0_h, pr.fme_pre_intfc_id0_l	hexadecimal de 16 bytes	Només lectura

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

sysfs file	camp mmio	tipus	accés
rellotge	gperf.clk.afu_interf_clock	hex uint64_t	Només lectura

intel-fpga-dev.i/intel-fpga-fme.j/dperf/cache/ (no vàlid per a la pila d'acceleració per a CPU Intel Xeon amb FPGA)

sysfs file	camp mmio	tipus	accés
congelar	gperf.ch_ctl.freeze	decimal int	Lectura-escriptura
read_hit	gperf.CACHE_RD_HIT	hex uint64_t	Només lectura
read_miss	gperf.CACHE_RD_MISS	hex uint64_t	Només lectura
write_hit	gperf.CACHE_WR_HIT	hex uint64_t	Només lectura
escriure_perdre	gperf.CACHE_WR_MISS	hex uint64_t	Només lectura
hold_request	gperf.CACHE_HOLD_REQ	hex uint64_t	Només lectura
tx_req_stall	gperf.CACHE_TX_REQ_STALL	hex uint64_t	Només lectura

sysfs file	camp mmio	tipus	accés
rx_req_stall	gperf.CACHE_RX_REQ_STALL	hex uint64_t	Només lectura
data_write_port_contention	gperf.CACHE_DATA_WR_PORT_CONTEN	hex uint64_t	Només lectura
tag_write_port_contention	gperf.CACHE_TAG_WR_PORT_CONTEN	hex uint64_t	Només lectura

intel-fpga-dev.i/intel-fpga-fme.j/dperf/iommu/ (no vàlid per a la pila d'acceleració per a CPU Intel Xeon amb FPGA)

sysfs file	camp mmio	tipus	accés
congelar	gperf.vtd_ctl.freeze	decimal int	Usuari: només de lectura Arrel: lectura-escriptura

intel-fpga-dev.i/intel-fpga-fme.j/dperf/iommu/afuk/ (no vàlid per a la pila d'acceleració per a CPU Intel Xeon amb FPGA)

sysfs file	camp mmio	tipus	accés
lectura_transacció	gperf.VTD_AFU0_MEM_RD_TRANS	hex uint64_t	Només lectura
transacció_escriptura	gperf.VTD_AFU0_MEM_WR_TRANS	hex uint64_t	Només lectura
tlb_read_hit	gperf.VTD_AFU0_TLB_RD_HIT	hex uint64_t	Només lectura
tlb_write_hit	gperf.VTD_AFU0_TLB_WR_HIT	hex uint64_t	Només lectura

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

sysfs file	camp mmio	tipus	accés
habilitar	gperf.fab_ctl.(activat)	decimal int	Usuari: només de lectura Arrel: lectura-escriptura
congelar	gperf.fab_ctl.freeze	decimal int	Usuari: només de lectura Arrel: lectura-escriptura
pcie0_read	gperf.FAB_PCIE0_RD	hex uint64_t	Només lectura
pcie0_write	gperf.FAB_PCIE0_WR	hex uint64_t	Només lectura
pcie1_read	gperf.FAB_PCIE1_RD	hex uint64_t	Només lectura
pcie1_write	gperf.FAB_PCIE1_WR	hex uint64_t	Només lectura
upi_read	gperf.FAB_UPI_RD	hex uint64_t	Només lectura
upi_write	gperf.FAB_UPI_WR	hex uint64_t	Només lectura

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

sysfs file	camp mmio	tipus	accés
pcie0_read	gperf.FAB_PCIE0_RD	hex uint64_t	Només lectura
pcie0_write	gperf.FAB_PCIE0_WR	hex uint64_t	Només lectura
pcie1_read	gperf.FAB_PCIE1_RD	hex uint64_t	Només lectura
pcie1_write	gperf.FAB_PCIE1_WR	hex uint64_t	Només lectura
upi_read	gperf.FAB_UPI_RD	hex uint64_t	Només lectura
upi_write	gperf.FAB_UPI_WR	hex uint64_t	Només lectura

Capçalera del port sysfs files
intel-fpga-dev.i/intel-fpga-port.k/

sysfs file	camp mmio	tipus	accés
id	port_header.capability.port_number	decimal int	Només lectura
ltr	port_header.control.latency_tolerance	decimal int	Només lectura

Port AFU Capçalera sysfs files
intel-fpga-dev.i/intel-fpga-port.k/

sysfs file	camp mmio	tipus	accés
afu_id	afu_header.guid	hexadecimal de 16 bytes	Només lectura

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

sysfs file	camp mmio	tipus	accés
errors	error.port_error	hex uint64_t	Només lectura
primer_error	error.port_primer_error	hex uint64_t	Només lectura
first_malformed_req	perror.malreq	hexadecimal de 16 bytes	Només lectura
clar	error.(tots els errors)	diversos uint64_t	Només d'escriptura

Nota:
Per esborrar els errors del port, heu d'escriure la màscara de bits exacta dels errors actuals, per exempleampli cat errors > esborrar.

Historial de revisions

Versió del document	Canvis
2017.10.02	Alliberament inicial.

Guia d'arquitectura del controlador de dispositiu Linux OPAE Intel FPGA

Documents/Recursos

Intel OPAE FPGA Linux Device Driver Architecture [pdfGuia de l'usuari OPAE FPGA Linux Device Driver Architecture, OPAE FPGA, Linux Device Driver Architecture, Driver Architecture, Architecture

Referències

• Manual d'usuari