אינהאַלט באַהאַלטן
1 Intel OPAE FPGA Linux Device Driver Architecture
2 OPAE Intel FPGA Linux Device Driver Architecture
2.1 ייַזנוואַרג אַרטשיטעקטורע
2.2 דרייווער ארגאניזאציע
3 sysfs Files
4 רעוויזיע געשיכטע
5 דאָקומענטן / רעסאָורסעס
5.1 רעפערענצן
6 Related Posts

ינטעל לאָגאָ

Intel OPAE FPGA Linux Device Driver Architecture

ינטעל-OPAE-FPGA-Linux-Device-Driver-Architecture-product

OPAE Intel FPGA Linux Device Driver Architecture

די OPAE Intel FPGA שאָפער גיט ינטערפייסיז פֿאַר באַניצער-פּלאַץ אַפּלאַקיישאַנז צו קאַנפיגיער, ינומערייט, עפֿענען און אַקסעס FPGA אַקסעלערייטערז אויף פּלאַטפאָרמס יקוויפּט מיט Intel FPGA סאַלושאַנז און ינייבאַלז סיסטעם פאַרוואַלטונג פאַנגקשאַנז אַזאַ ווי FPGA ריקאַנפיגיעריישאַן, מאַכט פאַרוואַלטונג און ווירטואַליזאַטיאָן.

ייַזנוואַרג אַרטשיטעקטורע

פון די OS ס פונט פון view, די FPGA ייַזנוואַרג איז אַ רעגולער PCIe מיטל. די FPGA מיטל זכּרון איז אָרגאַניזירט מיט אַ פּרעדעפינעד דאַטן סטרוקטור (דיווייס פיטשער רשימה). פֿעיִקייטן געשטיצט דורך די FPGA מיטל זענען יקספּאָוזד דורך די דאַטן סטראַקטשערז, ווי ילאַסטרייטיד אונטן אין די פאלגענדע פיגור:

FPGA PCIe מיטל

intel-OPAE-FPGA-Linux-Device-Driver-Architecture-fig- (1)

דער שאָפער שטיצט PCIe SR-IOV צו שאַפֿן ווירטואַל פאַנגקשאַנז (VFs) וואָס קענען זיין געוויינט צו באַשטימען יחיד אַקסעלערייטערז צו ווירטואַל מאשינען.

Intel Corporation. אלע רעכטן רעזערווירט. ינטעל, די ינטעל לאָגאָ און אנדערע ינטעל מאַרקס זענען טריידמאַרקס פון ינטעל קאָרפּאָראַטיאָן אָדער זייַן סאַבסידיעריז. ינטעל וואָראַנטיז די פאָרשטעלונג פון זייַן FPGA און סעמיקאַנדאַקטער פּראָדוקטן צו קראַנט ספּעסאַפאַקיישאַנז אין לויט מיט ינטעל ס נאָרמאַל וואָראַנטי אָבער ריזערווז די רעכט צו מאַכן ענדערונגען צו קיין פּראָדוקטן און באַדינונגס אין קיין צייט אָן באַמערקן. ינטעל אַסומז קיין פֿאַראַנטוואָרטלעכקייט אָדער אַכרייַעס וואָס איז שטייענדיק פֿון די אַפּלאַקיישאַן אָדער נוצן פון קיין אינפֿאָרמאַציע, פּראָדוקט אָדער דינסט דיסקרייבד דאָ, אַחוץ ווי ינטעל איז עקספּרעסלי מסכים צו שרייבן. ינטעל קאַסטאַמערז זענען אַדווייזד צו קריגן די לעצטע ווערסיע פון ​​די מיטל ספּעסאַפאַקיישאַנז איידער זיי פאַרלאָזנ אויף קיין ארויס אינפֿאָרמאַציע און איידער פּלייסינג אָרדערס פֿאַר פּראָדוקטן אָדער באַדינונגס.

אנדערע נעמען און בראַנדז קענען זיין קליימד ווי די פאַרמאָג פון אנדערע.

ווירטואַליזעד FPGA PCIe מיטל

intel-OPAE-FPGA-Linux-Device-Driver-Architecture-fig- (2)

FPGA מאַנאַגעמענט ענגינע (FME)
די FPGA מאַנאַגעמענט ענגינע פּערפאָרמז מאַכט און טערמאַל פאַרוואַלטונג, טעות ריפּאָרטינג, ריקאַנפיגיעריישאַן, פאָרשטעלונג ריפּאָרטינג און אנדערע ינפראַסטראַקטשער פאַנגקשאַנז. יעדער FPGA האט איין FME, וואָס איז שטענדיק אַקסעסט דורך די פיזיקאַל פונקציע (PF). באַניצער-פּלאַץ אַפּלאַקיישאַנז קענען קריגן ויסשליסיק אַקסעס צו די FME ניצן עפענען (), און מעלדונג עס מיט נאָענט () ווי אַ פּריוולידזשד באַניצער (וואָרצל).

פּאָרט
א פּאָרט רעפּראַזענץ די צובינד צווישן די סטאַטיק FPGA שטאָף (די "FPGA צובינד מאַנאַגער (FIM)") און אַ טייל רעקאָנפיגוראַבלע געגנט מיט אַ אַקסעלעראַטאָר פונקציע (AF). די פּאָרט קאָנטראָלס די קאָמוניקאַציע פון ​​ווייכווארג צו די אַקסעלעראַטאָר און יקספּאָוזיז פֿעיִקייטן אַזאַ ווי באַשטעטיק און דיבאַג. א PCIe מיטל קען האָבן עטלעכע פּאָרץ, און יעדער פּאָרט קענען זיין יקספּאָוזד דורך אַ VF דורך אַסיינינג עס מיט די FPGA_FME_PORT_ASSIGN ioctl אויף די FME מיטל.

אַקסעלעראַטאָר פֿונקציע (AF) אַפּאַראַט

  • אַן אַקסעלעראַטאָר פֿונקציע (AF) אַפּאַראַט איז אַטאַטשט צו אַ פּאָרט און יקספּאָוזיז אַ 256K MMIO געגנט צו זיין געוויינט פֿאַר אַקסעלעראַטאָר-ספּעציפיש קאָנטראָל רעדזשיסטערס.
  • באַניצער-פּלאַץ אַפּלאַקיישאַנז קענען קריגן ויסשליסיק אַקסעס צו אַ AFU אַטאַטשט צו אַ פּאָרט דורך ניצן עפענען () אויף די פּאָרט מיטל, און מעלדונג עס מיט נאָענט ().
  • באַניצער-פּלאַץ אַפּלאַקיישאַנז קענען אויך mmap () אַקסעלעראַטאָר MMIO מקומות.

פּאַרטיייש רעקאָנפיגוראַטיאָן
ווי דערמאנט אויבן, אַקסעלעראַטאָרס קענען זיין ריקאַנפיגיערד דורך פּאַרטיייש ריקאַנפיגיעריישאַן פון אַ אַקסעלעראַטאָר פונקציע (AF) file. די אַקסעלעראַטאָר פֿונקציע (AF) מוזן זיין דזשענערייטאַד פֿאַר די פּינטלעך FIM און טאַרגעטעד סטאַטיק געגנט (פּאָרט) פון די FPGA; אַנדערש, די ריקאַנפיגיעריישאַן אָפּעראַציע וועט פאַרלאָזן און עפשער פאַרשאַפן סיסטעם ינסטאַביליטי. די קאַמפּאַטאַבילאַטי קענען זיין אָפּגעשטעלט דורך קאַמפּערינג די צובינד שייַן אנגעוויזן אין די AF כעדער קעגן די צובינד שייַן יקספּאָוזד דורך די FME דורך sysfs. דעם טשעק איז יוזשאַוואַלי דורכגעקאָכט דורך באַניצער פּלאַץ איידער רופן די ריקאַנפיגיעריישאַן IOCTL.

באַמערקונג:
דערווייַל, קיין ווייכווארג פּראָגראַם וואָס אַקסעס די FPGA, אַרייַנגערעכנט יענע וואָס לויפן אין אַ ווירטואַליזעד באַלעבאָס, מוזן זיין פארמאכט איידער איר פּרווון אַ פּאַרטיייש ריקאַנפיגיעריישאַן. די סטעפּס זאָל זיין:

  1. אַנלאָוד די שאָפער פון די גאַסט
  2. אָפּשטויסן די VF פון די גאַסט
  3. דיסייבאַל SR-IOV
  4. דורכפירן פּאַרטיייש ריקאַנפיגיעריישאַן
  5. געבן SR-IOV
  6. צאַפּן די VF צו דער גאַסט
  7. לאָדן דעם שאָפער אין דעם גאַסט

FPGA ווירטואַליזאַטיאָן
צו געבן אַקסעס צו אַ אַקסעלעראַטאָר פֿון אַפּלאַקיישאַנז וואָס לויפן אין אַ VM, די ריספּעקטיוו AFU פּאָרט דאַרף זיין אַסיינד צו אַ VF מיט די פאלגענדע סטעפּס:

  1. די פּף אָונז אַלע AFU פּאָרץ דורך פעליקייַט. יעדער פּאָרט וואָס דאַרף זיין ריאַסיינד צו אַ VF מוזן ערשטער זיין באפרייט פון די PF דורך די FPGA_FME_PORT_RELEASE ioctl אויף די FME מיטל.
  2. אַמאָל N פּאָרץ זענען באפרייט פון די PF, די באַפֿעל אונטן קענען זיין געוויינט צו געבן SRIOV און VFs. יעדער VF אָונז בלויז איין פּאָרט מיט AFU. echo N > PCI_DEVICE_PATH/sriov_numvfs
  3. פאָרן דורך די VFs צו VMs.
  4. די AFU אונטער VF איז צוטריטלעך פֿון אַפּלאַקיישאַנז אין VM (ניצן די זעלבע שאָפער אין די VF).

באַמערקונג:
אַ FME קענען ניט זיין אַסיינד צו אַ VF, אַזוי פּר און אנדערע פאַרוואַלטונג פאַנגקשאַנז זענען בלויז בנימצא דורך די PF.

דרייווער ארגאניזאציע

PCIe מאָדולע דיווייס דרייווער

דרייווער ארגאניזאציע

intel-OPAE-FPGA-Linux-Device-Driver-Architecture-fig- (3)

די FPGA דעוויסעס דערשייַנען ווי רעגולער PCIe דעוויסעס; דער FPGA PCIe מיטל דרייווער (intel-FPGA-PCI.ko) איז שטענדיק לאָודיד ערשטער אַמאָל אַ FPGA PCIe PF אָדער VF איז דיטעקטאַד. דער שאָפער פיעסעס אַ ינפראַסטראַקטשעראַל ראָלע אין דער שאָפער אַרקאַטעקטשער. עס:

  • קריייץ אַ FPGA קאַנטיינער מיטל ווי אַ פאָטער פון די שטריך דעוויסעס.
  • גייט דורך די Device Feature List, וואָס איז ימפּלאַמענאַד אין PCIe מיטל BAR זכּרון, צו אַנטדעקן שטריך דעוויסעס און זייער סאַב-פאַנגקשאַנז און שאַפֿן פּלאַטפאָרמע דעוויסעס פֿאַר זיי אונטער די קאַנטיינער מיטל.
  • שטיצט SR-IOV.
  • ינטראַדוסיז די פונקציע מיטל ינפראַסטראַקטשער, וואָס אַבסטראַקץ אַפּעריישאַנז פֿאַר סאַב-פאַנגקשאַנז און יקספּאָוזיז פּראָסט פאַנגקשאַנז צו שטריך מיטל דריווערס.

PCIe מאָדולע דיווייס דרייווער פאַנגקשאַנז

  • כּולל PCIe ופדעקונג, מיטל ינומעריישאַן און שטריך ופדעקונג.
  • קרעאַטעס sysfs דירעקטעריז פֿאַר די פאָטער מיטל, FPGA מאַנאַגעמענט ענגינע (FME) און פּאָרט.
  • קרעאַטעס די פּלאַטפאָרמע דרייווער ינסטאַנסיז, וואָס די לינוקס קערן לאָודיד זייער ריספּעקטיוו פּלאַטפאָרמע מאָדולע דריווערס.

FME פּלאַטפאָרמע מאָדולע דיווייס דרייווער

  • מאַכט און טערמאַל פאַרוואַלטונג, טעות ריפּאָרטינג, פאָרשטעלונג ריפּאָרטינג און אנדערע ינפראַסטראַקטשער פאַנגקשאַנז. איר קענט אַקסעס די פאַנגקשאַנז דורך Sysfs ינטערפייסיז יקספּאָוזד דורך די FME שאָפער.
  • פּאַרטיייש רעקאָנפיגוראַטיאָן. דער FME שאָפער רעדזשיסטערז אַ FPGA מאַנאַגער בעשאַס פּר סאַב-שטריך יניטיאַליזיישאַן; אַמאָל עס נעמט אַן FPGA_FME_PORT_PR ioctl פון איר, עס ינוואָוקס די פּראָסט צובינד פונקציע פון ​​FPGA מאַנאַגער צו פאַרענדיקן די פּאַרטיייש ריקאַנפיגיעריישאַן פון די ביטסטרים צו די געגעבן פּאָרט.
  • פּאָרט פאַרוואַלטונג פֿאַר ווירטואַליזאַטיאָן. דער FME שאָפער ינטראַדוסיז צוויי יאָקטלס, FPGA_FME_PORT_RELEASE, וואָס ריליסיז די געגעבן פּאָרט פֿון PF; און FPGA_FME_PORT_ASSIGN, וואָס אַסיינז די פּאָרט צוריק צו PF. אַמאָל די פּאָרט איז באפרייט פון די PF, עס קענען זיין אַסיינד צו די VF דורך די SR-IOV ינטערפייסיז צוגעשטעלט דורך די PCIe שאָפער. פֿאַר מער אינפֿאָרמאַציע, אָפּשיקן צו "FPGA ווירטואַליזאַטיאָן".

פמע פּלאַטפאָרם מאָדולע דיווייס דרייווער פאַנגקשאַנז

  • קריייץ די FME כאַראַקטער מיטל נאָדע.
  • קרעאַטעס די FME sysfs files און ימפּלאַמאַנץ די FME sysfs file אַקסעססאָריעס.
  • ימפּלאַמאַנץ די FME פּריוואַט שטריך סאַב-דריווערס.
  • FME פּריוואַט שטריך סאַב-דריווערס:
    • FME כעדער
    • טערמאַל מאַנאַגעמענט
    • מאַכט מאַנאַגעמענט
    • גלאבאלע טעות
    • פּאַרטיייש רעקאָנפיגוראַטיאָן
    • גלאבאלע פאָרשטעלונג

פּאָרט פּלאַטפאָרמע מאָדולע דיווייס דרייווער
ענלעך צו די FME שאָפער, די FPGA פּאָרט (און AFU) שאָפער (intel-fpga-afu. ko) איז פּראָוד אַמאָל די פּאָרט פּלאַטפאָרמע מיטל איז באשאפן. די הויפּט פֿונקציע פון ​​דעם מאָדולע איז צו צושטעלן אַ צובינד פֿאַר באַניצער-פּלאַץ אַפּלאַקיישאַנז צו אַקסעס די יחיד אַקסעלערייטערז, אַרייַנגערעכנט יקערדיק באַשטעטיק קאָנטראָל אויף פּאָרט, AFU MMIO געגנט אַרויספירן, DMA באַפער מאַפּינג דינסט, UMsg (1) אָנזאָג און ווייַט דיבאַג פאַנגקשאַנז ( זען אויבן).

UMsg איז בלויז געשטיצט דורך אַקסעלעריישאַן סטאַק פֿאַר Intel Xeon® פּראַסעסער מיט ינטעגראַטעד FPGA.

פּאָרט פּלאַטפאָרם מאָדולע דיווייס דרייווער פאַנגקשאַנז

  • קריייץ די פּאָרט כאַראַקטער מיטל נאָדע.
  • קריייץ די פּאָרט sysfs files און ימפּלאַמאַנץ די פּאָרט sysfs file אַקסעססאָריעס.
  • ימפּלאַמאַנץ די פּאָרט פּריוואַט שטריך סאַב-דריווערס.
  • פּאָרט פּריוואַט שטריך סאַב-דריווערס:
    • פּאָרט כעדער
    • AFU
    • פּאָרט טעות
    • UMsg(2)
    • סיגנאַל טאַפּ

אַפּפּליקאַטיאָן FPGA מיטל ענומעריישאַן
דער אָפּטיילונג ינטראַדוסיז ווי אַפּלאַקיישאַנז ינומערייט די FPGA מיטל פֿון די sysfs כייעראַרקי אונטער /sys/class/fpga. אין די עקסampונטער, צוויי Intel FPGA דעוויסעס זענען אינסטאַלירן אין דער באַלעבאָס. יעדער FPGA מיטל האט איין FME און צוויי פּאָרץ (AFUS). פֿאַר יעדער FPGA מיטל, אַ מיטל וועגווייַזער איז באשאפן אונטער /sys/class/fpga:

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

יעדער נאָדע האט איין FME און צוויי פּאָרץ (AFUS) ווי קינד דעוויסעס:
/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

אין אַלגעמיין, די FME / Port sysfs ינטערפייסיז זענען געהייסן ווי גייט:
/sys/class/fpga/intel-fpga-dev.i/intel-fpga-fme.j/
/sys/class/fpga/intel-fpga-dev.i/intel-fpga-port.k/

מיט איך קאַנסעקיאַטיוו נומערינג אַלע די קאַנטיינער דעוויסעס, j קאַנסעקיאַטיוו נומערינג די FME ס און ק קאַנסעקיאַטיוו נומערינג אַלע פּאָרץ.

די מיטל נאָודז געניצט פֿאַר ioctl () און mmap () קענען זיין רעפעראַנסט דורך:
/dev/intel-fpga-fme.j
/dev/intel-fpga-port.k

PCIe Driver Enumeration
דער אָפּטיילונג גיט אַן איבערview פון די קאָד לויפן פֿאַר מיטל ינומעריישאַן דורכגעקאָכט דורך intel-fpga-pci.ko. די הויפּט דאַטן סטראַקטשערז און פאַנגקשאַנז זענען כיילייטיד. דעם אָפּטיילונג איז בעסטער נאכגעגאנגען ווען viewאין די אַקאַמפּאַניינג מקור קאָד (pcie.c).

ענומעריישאַן דאַטאַ סטראַקטשערז

enum fpga_id_type {
PARENT_ID,
FME_ID,
PORT_ID,
FPGA_ID_MAX
};
סטאַטיק סטרוקטור idr fpga_ids[FPGA_ID_MAX];
struct fpga_chardev_info {
קאָנסט טשאַר * נאָמען;
dev_t devt;
};
struct fpga_chardev_info fpga_chrdevs[] = {
{.נאָמען = FPGA_FEATURE_DEV_FME},
{.נאָמען = FPGA_FEATURE_DEV_PORT},
};
סטאַטיק סטרוקטור קלאַס * פפּגאַ_קלאַס;
סטאַטיק סטרוקטור 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,}
};
סטאַטיק סטרוקטור pci_driver cci_pci_driver = {
.נאָמען = DRV_NAME,
.יד_טאַבלע = cci_pcie_id_tbl,
.פּראָבע = cci_pci_probe,
.remove = cci_pci_remove,
.סריאָוו_קאָנפיגורע = cci_pci_sriov_configure
};
struct cci_drvdata {
int device_id;
סטרוקטור מיטל * fme_dev;
סטרוקטור מוטעקס שלאָס;
סטרוקטור ליסט_העאַד פּאָרט_דעוו_ליסט;
int released_port_num;
סטרוקטור ליסט_העאַד מקומות;
};
struct build_feature_devs_info {
סטרוקטור פּסי_דעוו *פּדעוו;
פּאָסל __יאָמעם *יאָאַדדר;
פּאָסל __יאָמעם *יאָענד;
int current_bar;
פּאָסל __יאָמעם *פּפמע_הדר;
סטרוקטור מיטל * פּאַרענט_דעוו;
struct platform_device * feature_dev;
};

נומעראַטיאָן לויפן

  • ccidrv_init()
    • יניטיאַליזירן fpga_ids ניצן idr_init ().
    • יניטיאַליזע fpga_chrdevs[i].devt ניצן alloc_chrdev_region().
    • יניטיאַליזע fpga_class ניצן class_create ().
    • pci_register_driver (&cci_pci_driver);
  • cci_pci_probe()
    • געבן די PCI מיטל, בעטן אַקסעס צו זייַן מקומות, שטעלן PCI בעל מאָדע און קאַנפיגיער DMA.
  • cci_pci_create_feature_devs() build_info_alloc_and_init()
    • אַלאַקייט אַ סטרוקטור build_feature_devs_info, ינישאַלייז עס.
      .parent_dev איז באַשטימט צו אַ פאָטער sysfs וועגווייַזער (intel-fpga-dev.id) וואָס כּולל די FME און Port sysfs דירעקטעריז.
  • פּאַרסע_פונקציע_ליסט ()
    • גיין צו די BAR0 Device Feature List צו אַנטדעקן די FME, די פּאָרט און זייער פּריוואַט פֿעיִקייטן.
  • parse_feature() parse_feature_afus() parse_feature_fme()
    • ווען אַ FME איז געפּלאָנטערט:
  • build_info_create_dev()
    • אַלאַקייט אַ פּלאַטפאָרמע מיטל פֿאַר די FME, סטאָרינג אין build_feature_devs_info.feature_dev.
    • feature_dev.id איז יניטיאַלייזד צו דער רעזולטאַט פון idr_alloc (fpga_ids [FME_ID],
    • feature_dev.parent איז באַשטימט צו build_feature_devs_info.parent_dev.
    • אַלאַקייט אַ מענגע פון ​​סטרוקטור רעסורסן אין feature_dev.resource.
  • אַלאַקייט אַ סטרוקטור feature_platform_data, ינישאַלייז עס און קראָם אַ טייַטל אין feature_dev.dev.platform_data
    • create_feature_instance() build_info_add_sub_feature()
    • יניטיאַליזירן feature_dev.resource[FME_FEATURE_ID_HEADER].
    • feature_platform_data_add()
    • יניטיאַליזירן feature_platform_data.features[FME_FEATURE_ID_HEADER], אַלץ אָבער .פאָפּס.
  • parse_feature() parse_feature_afus() parse_feature_port()
    • ווען אַ פּאָרט איז געפּלאָנטערט:
  • build_info_create_dev()
    • אַלאַקייט אַ פּלאַטפאָרמע מיטל פֿאַר די פּאָרט, סטאָרינג אין build_feature_devs_info.feature_dev.
    • feature_dev.id איז יניטיאַלייזד צו דער רעזולטאַט פון idr_alloc (fpga_ids [PORT_ID],
    • feature_dev.parent איז באַשטימט צו build_feature_devs_info.parent_dev.
    • אַלאַקייט אַ מענגע פון ​​סטרוקטור מיטל אין feature_dev.resource.
    • אַלאַקייט אַ סטרוקטור feature_platform_data, ינישאַלייז עס און קראָם אַ טייַטל אין feature_dev.dev.platform_data
  • build_info_commit_dev()
    • לייג די struct feature_platform_data.node פֿאַר די פּאָרט צו דער רשימה פון פּאָרץ אין struct cci_drvdata.port_dev_list
  • create_feature_instance() build_info_add_sub_feature()
    • יניטיאַליזירן feature_dev.resource[PORT_FEATURE_ID_HEADER].
  • feature_platform_data_add()
    • יניטיאַליזירן feature_platform_data.features[PORT_FEATURE_ID_HEADER], אַלץ אָבער .פאָפּס.
  • parse_feature() parse_feature_afus() parse_feature_port_uafu()
    • ווען אַ AFU איז געפּלאָנטערט:
  • create_feature_instance() build_info_add_sub_feature()
    • יניטיאַליזירן feature_dev.resource[PORT_FEATURE_ID_UAFU].
  • feature_platform_data_add()
    • יניטיאַליזירן feature_platform_data.features[PORT_FEATURE_ID_UAFU], אַלץ אָבער .פאָפּס.
  • parse_feature() parse_feature_private() parse_feature_fme_private()
    • ווען אַ FME פּריוואַט שטריך איז געפּלאָנטערט:
  • create_feature_instance() build_info_add_sub_feature()
    • יניטיאַליזירן feature_dev.resource[id].
  • feature_platform_data_add()
    • יניטיאַליזע שטריך_פּלאַטפאָרמע_דאַטאַ.פעאַטורעס [שייַן], אַלץ אָבער .פאָפּס.
  • parse_feature() parse_feature_private() parse_feature_port_private()
  • ווען אַ פּאָרט פּריוואַט שטריך איז געפּלאָנטערט: * create_feature_instance () build_info_add_sub_feature () * יניטיאַליזע feature_dev.resource[id]. * feature_platform_data_add() יניטיאַליזירן feature_platform_data.features[יד], אַלץ אָבער .פאָפּס.
  • parse_ports_from_fme()
    • אויב דער שאָפער איז לאָודיד אויף די פיזיקאַל פֿונקציע (PF), דעמאָלט:
  • לויפן די parse_feature_list () לויפן אויף יעדער פּאָרט דיסקרייבד אין די FME כעדער.
  • ניצן די BAR דערמאנט אין יעדער פּאָרט פּאָזיציע אין די כעדער.

פמע פּלאַטפאָרם מיטל יניטיאַליזאַטיאָן
דער אָפּטיילונג גיט אַן איבערview פון די קאָד לויפן פֿאַר פמע מיטל יניטיאַליזאַטיאָן דורכגעקאָכט דורך intel-fpga-fme.ko. די הויפּט דאַטן סטראַקטשערז און פאַנגקשאַנז זענען כיילייטיד. דעם אָפּטיילונג איז בעסטער נאכגעגאנגען ווען viewניצן די אַקאַמפּאַניינג מקור קאָד (fme-main.c).

FME פּלאַטפאָרם מיטל דאַטאַ סטראַקטשערז

struct feature_ops {
int (*יניט) (סטרוקט פּלאַטפאָרמ_דיווייס *פּדעוו, סטרוקטור שטריך * שטריך);
int (* וניט) (סטרוקט פּלאַטפאָרמ_דיווייס *פּדעוו, סטרוקטור שטריך * שטריך);
לאַנג (* ioctl) (סטרוקט פּלאַטפאָרמ_דיווייס *פּדעוו, סטרוקטור שטריך * שטריך,
אַנסיינד אינט קמד, אַנסיינד לאַנג אַרג);
int (* טעסט) (סטרוקט פּלאַטפאָרמ_דיווייס *פּדעוו, סטרוקטור שטריך * שטריך);
};
סטרוקטור שטריך {
קאָנסט טשאַר * נאָמען;
int resource_index;
פּאָסל __יאָמעם *יאָאַדדר;
struct feature_ops *אָפּס;
};
struct feature_platform_data {
סטרוקטור ליסט_העאַד נאָדע;
סטרוקטור מוטעקס שלאָס;
אַנסיינד לאַנג דעוו_סטאַטוס;
struct cdev cdev;
struct platform_device *dev;
אַנסיינד אינט דיסאַבלע_קאָונט;
בטל * פּריוואַט;
int num;
int (* קאָנפיג_פּאָרט) (סטרוקט פּלאַטפאָרמ_דיווייס *, ו32, בול);
struct platform_device *(*fpga_for_each_port)(struct platform_device *,
void *, int (* גלייַכן) (סטרוקט פּלאַטפאָרמ_דיווייס *, פּאָסל *)); סטרוקטור
שטריך פֿעיִקייטן[0];
};
struct perf_object {
int id;
קאָנסט סטרוקטור אַטריביוט_גרופּע **אַטטר_גרופּס;
סטרוקטור מיטל * fme_dev;
סטרוקטור ליסט_העאַד נאָדע;
סטרוקטור ליסט_העאַד קינדער;
struct kobject kobj;
};
struct fpga_fme {
ו8 פּאָרט_יד;
ו64 פּר_ערר;
סטרוקטור מיטל * דעוו_ערר;
struct perf_object *perf_dev;
סטרוקטור שטריך_פּלאַטפאָרמע_דאַטאַ *פּדאַטאַ;
};

FME פּלאַטפאָרם מיטל יניטיאַליזאַטיאָן לויפן

FME יניטיאַליזאַטיאָן לויפןintel-OPAE-FPGA-Linux-Device-Driver-Architecture-fig- (4)

  • fme_probe() fme_dev_init()
    • יניטיאַליזע אַ סטרוקטור fpga_fme און קראָם עס אין די feature_platform_data.private פעלד.
  • fme_probe() fpga_dev_feature_init() feature_instance_init()
    • היט אַ סטרוקטור feature_ops אין די feature_platform_data.features פֿאַר יעדער פּאַפּיאַלייטאַד שטריך.
    • רופן די פּראָבע פֿונקציע, אויב קיין, פֿון די סטרוקטור.
    • רופן די יניט פֿונקציע פֿון די סטרוקטור.
  • fme_probe() fpga_register_dev_ops()
    • שאַפֿן די FME כאַראַקטער מיטל נאָדע, רעדזשיסטערינג אַ סטרוקטור file_אָפּעראַטיאָנס.

פּאָרט פּלאַטפאָרם מיטל יניטיאַליזאַטיאָן
דער אָפּטיילונג גיט אַן איבערview פון די קאָד לויפן פֿאַר יניטיאַליזאַטיאָן פון פּאָרט מיטל דורכגעקאָכט דורך intel-fpga-afu.ko. די הויפּט דאַטן סטראַקטשערז און פאַנגקשאַנז זענען כיילייטיד. דעם אָפּטיילונג איז בעסטער נאכגעגאנגען ווען viewאין די אַקאַמפּאַניינג מקור קאָד (afu.c).

פּאָרט פּלאַטפאָרם מיטל דאַטאַ סטראַקטשערז

struct feature_ops {
int (*יניט) (סטרוקט פּלאַטפאָרמ_דיווייס *פּדעוו, סטרוקטור שטריך * שטריך);
int (* וניט) (סטרוקט פּלאַטפאָרמ_דיווייס *פּדעוו, סטרוקטור שטריך * שטריך);
לאַנג (* ioctl) (סטרוקט פּלאַטפאָרמ_דיווייס *פּדעוו, סטרוקטור שטריך * שטריך,
אַנסיינד אינט קמד, אַנסיינד לאַנג אַרג);
int (* טעסט) (סטרוקט פּלאַטפאָרמ_דיווייס *פּדעוו, סטרוקטור שטריך * שטריך);
};
סטרוקטור שטריך {
קאָנסט טשאַר * נאָמען;
int resource_index;
פּאָסל __יאָמעם *יאָאַדדר;
struct feature_ops *אָפּס;
};
struct feature_platform_data {
סטרוקטור ליסט_העאַד נאָדע;
סטרוקטור מוטעקס שלאָס;
אַנסיינד לאַנג דעוו_סטאַטוס;
struct cdev cdev;
struct platform_device *dev;
אַנסיינד אינט דיסאַבלע_קאָונט;
בטל * פּריוואַט;
int num;
int (* קאָנפיג_פּאָרט) (סטרוקט פּלאַטפאָרמ_דיווייס *, ו32, בול);
struct platform_device *(*fpga_for_each_port)(struct platform_device *,
void *, int (* גלייַכן) (סטרוקט פּלאַטפאָרמ_דיווייס *, פּאָסל *));
סטרוקטור שטריך פֿעיִקייטן[0];
};
struct fpga_afu_region {
ו32 אינדעקס;
u32 פלאַגס;
ו64 גרייס;
ו64 פאָטאָ;
ו64 פיזיש;
סטרוקטור ליסט_העאַד נאָדע;
};
struct fpga_afu_dma_region {
ו64 באַניצער_אַדדר;
ו64 לענג;
u64 iova;
סטרוקטור בלאַט ** בלעטער;
סטרוקטור רב_נאָדע נאָדע;
bool in_use;
};
struct fpga_afu {
u64 region_cur_offset;
int num_regions;
u8 num_umsgs;
סטרוקטור ליסט_העאַד מקומות;
struct rb_root dma_regions;
סטרוקטור שטריך_פּלאַטפאָרמע_דאַטאַ *פּדאַטאַ;
};

פּאָרט פּלאַטפאָרם מיטל יניטיאַליזאַטיאָן לויפן

פּאָרט יניטיאַליזאַטיאָן לויפןintel-OPAE-FPGA-Linux-Device-Driver-Architecture-fig- (5)

  • afu_probe() afu_dev_init()
    • יניטיאַליזע אַ סטרוקטור fpga_afu און קראָם עס אין די feature_platform_data.private פעלד.
  • afu_probe() fpga_dev_feature_init() feature_instance_init()
    • היט אַ סטרוקטור feature_ops אין די feature_platform_data.features פֿאַר יעדער פּאַפּיאַלייטאַד שטריך.
    • רופן די פּראָבע פֿונקציע, אויב קיין, פֿון די סטרוקטור.
    • רופן די יניט פֿונקציע פֿון די סטרוקטור.
  • afu_probe() fpga_register_dev_ops()
    • שאַפֿן די פּאָרט כאַראַקטער מיטל נאָדע, רעדזשיסטערינג אַ סטרוקטור file_אָפּעראַטיאָנס.

FME IOCTLs
IOCTLs וואָס זענען גערופן אויף אַ עפענען file דעסקריפּטאָר פֿאַר /dev/intel-fpga-fme.j FPGA_GET_API_VERSION - צוריקקומען די קראַנט ווערסיע ווי אַ גאַנץ נומער, סטאַרטינג פון 0.

FPGA_CHECK_EXTENSION — איצט ניט געשטיצט.

FPGA_FME_PORT_RELEASE - אַרג איז אַ טייַטל צו אַ:

struct fpga_fme_port_release {
__u32 argsz; // אין: sizeof (סטרוקט fpga_fme_port_release)
__u32 פלאַגס; // אין: מוזן זיין 0
__u32 פּאָרט_יד; // אין: פּאָרט שייַן (פון 0) צו מעלדונג.
};

FPGA_FME_PORT_ASSIGN - אַרג איז אַ טייַטל צו אַ:

struct fpga_fme_port_assign {
__u32 argsz; // אין: sizeof (סטרוקט fpga_fme_port_assign)
__u32 פלאַגס; // אין: מוזן זיין 0
__u32 פּאָרט_יד; // אין: פּאָרט שייַן (פון 0) צו באַשטימען. (מוז האָבן געווען
פריער באפרייט דורך FPGA_FME_PORT_RELEASE)
};

FPGA_FME_PORT_PR—אַרג איז אַ טייַטל צו אַ:

סטרוקטור fpga_fme_port_pr {
__u32 argsz; // אין: sizeof (סטרוקט fpga_fme_port_pr)
__u32 פלאַגס; // אין: מוזן זיין 0
__u32 פּאָרט_יד; // אין: פּאָרט שייַן (פון 0)
__ו32 באַפער_גרייס; // אין: גרייס פון ביטסטרים באַפער אין ביטעס. מוזן זיין 4-ביטע
אַליינד.
__ו64 באַפער_אַדרעס; // אין: פּראָצעס אַדרעס פון ביטסטרים באַפער
__u64 סטאַטוס; // אויס: טעות סטאַטוס (ביטמאַסק)
};

פּאָרט IOCTLs
IOCTLs וואָס זענען גערופן אויף אַ עפענען file דעסקריפּטאָר פֿאַר /dev/intel-fpga-port.k FPGA_GET_API_VERSION—צוריקקומען די קראַנט ווערסיע ווי אַ גאַנץ נומער, סטאַרטינג פון 0. FPGA_CHECK_EXTENSION—נישט איצט געשטיצט.

FPGA_PORT_GET_INFO - אַרג איז אַ טייַטל צו אַ:

struct fpga_port_info {
__u32 argsz; // אין: sizeof (סטרוקט fpga_port_info)
__u32 פלאַגס; // אויס: קערט 0
__ו32 נומער_רעגיאָנס; // אויס: נומער פון MMIO מקומות, 2 (1 פֿאַר AFU און 1 פֿאַר
STP)
__u32 num_umsgs; // אויס: נומער פון UMsg ס געשטיצט דורך די ייַזנוואַרג
};

FPGA_PORT_GET_REGION_INFO - אַרג איז אַ טייַטל צו אַ:

struct fpga_port_region_info {
__u32 argsz; // אין: sizeof (סטרוקט fpga_port_region_info)
__u32 פלאַגס; // אויס: (ביטמאַסק) {FPGA_REGION_READ, FPGA_REGION_WRITE,
FPGA_REGION_MMAP }
__u32 אינדעקס; // אין: FPGA_PORT_INDEX_UAFU אָדער FPGA_PORT_INDEX_STP
__u32 וואַטן; // אין: מוזן זיין 0
__u64 גרייס; // אויס: גרייס פון MMIO געגנט אין ביטעס
__u64 פאָטאָ; // אויס: פאָטאָ פון MMIO געגנט פון אָנהייב פון מיטל fd
};

FPGA_PORT_DMA_MAP - אַרג איז אַ טייַטל צו אַ:
struct fpga_port_dma_map {
__u32 argsz; // אין: sizeof (סטרוקט fpga_port_dma_map)
__u32 פלאַגס; // אין: מוזן זיין 0 __ו64 באַניצער_אַדדר; // אין: פּראָצעס ווירטואַל
אַדרעס. מוז זיין בלאַט אַליינד.
__u64 לענג; // אין: לענג פון מאַפּינג אין ביטעס. מוזן זיין אַ קייפל פון בלאַט
גרייס.
__u64 יאָוואַ; // אויס: יאָ ווירטואַל אַדרעס };

FPGA_PORT_DMA_UNMAP - אַרג איז אַ טייַטל צו אַ:
struct fpga_port_dma_unmap {
__u32 argsz; // אין: sizeof (סטרוקט fpga_port_dma_unmap)
__u32 פלאַגס; // אין: מוזן זיין 0
__u64 יאָוואַ; // אין: יאָ ווירטואַל אַדרעס אומגעקערט דורך אַ פריערדיקן
FPGA_PORT_DMA_MAP };

  • FPGA_PORT_RESET-אַרג מוזן זיין NULL.
  • FPGA_PORT_UMSG_ENABLE-אַרג מוזן זיין NULL.
  • FPGA_PORT_UMSG_DISABLE-אַרגס מוזן זיין NULL.

FPGA_PORT_UMSG_SET_MODE - אַרג איז אַ טייַטל צו אַ:

struct fpga_port_umsg_cfg {
__u32 argsz; // אין: sizeof (סטרוקט fpga_port_umsg_cfg)
__u32 פלאַגס; // אין: מוזן זיין 0
__ו32 הינט_ביטמאַפּ; // אין: UMsg אָנצוהערעניש מאָדע ביטמאַפּ. סיגנאַפייז וואָס UMsg זענען
ענייבאַלד.
};

FPGA_PORT_UMSG_SET_BASE_ADDR—

  • UMsg מוזן זיין פאַרקריפּלט איידער איר אַרויסגעבן דעם יאָקטל.
  • די יאָוואַ פעלד מוזן זיין פֿאַר אַ באַפער גרויס גענוג פֿאַר אַלע UMsg ס (נומ_ומגס * PAGE_SIZE).
    • דער באַפער איז אנגעצייכנט ווי "אין נוצן" דורך די באַפער פאַרוואַלטונג פון די שאָפער.
    • אויב יאָוואַ איז NULL, קיין פריערדיקן געגנט איז אַנמאַרקט ווי "אין נוצן".
  • arg איז אַ אָנווייַז צו אַ:
    struct fpga_port_umsg_base_addr {
    • u32 argsz; // אין: גרייסאָפ (סטרוקט פפּגאַ_פּאָרט_ומג_באַסע_אַדדר)
    • u32 פלאַגס; // אין: מוזן זיין 0
    • u64 iova; // אין: יאָ ווירטואַל אַדרעס פֿון FPGA_PORT_DMA_MAP. };

באַמערקונג:

  • צו ויסמעקן די פּאָרט ערראָרס, איר מוזן שרייַבן די פּינטלעך ביטמאַסק פון די קראַנט ערראָרס, למשלample, קאַץ ערראָרס > קלאָר
  • UMsg איז בלויז געשטיצט דורך אַקסעלעריישאַן סטאַק פֿאַר Intel Xeon פּראַסעסער מיט ינטעגראַטעד FPGA.

sysfs Files

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

sysfs file mmio פעלד טיפּ צוטריט
ports_num fme_header.capability.num_ports דעצימאַל ינט בלויז לייענען
cache_size fme_header.capability.cache_size דעצימאַל ינט בלויז לייענען
ווערסיע fme_header.capability.fabric_verid דעצימאַל ינט בלויז לייענען
socket_id fme_header.capability.socket_id דעצימאַל ינט בלויז לייענען
bitstream_id fme_header.bitstream_id העקס uint64_t בלויז לייענען
ביטסטרעאַם_מעטאַדאַטאַ fme_header.bitstream_md העקס uint64_t בלויז לייענען

FME טערמאַל מאַנאַגעמענט sysfs files
intel-fpga-dev.i/intel-fpga-fme.j/thermal_mgmt/

sysfs file mmio פעלד טיפּ צוטריט
שוועל 1 termal.threshold.tmp_thshold1 דעצימאַל ינט באַניצער: לייענ-בלויז וואָרצל: לייענען-שרייַבן
שוועל 2 termal.threshold.tmp_thshold2 דעצימאַל ינט באַניצער: לייענ-בלויז וואָרצל: לייענען-שרייַבן
threshold_trip termal.threshold.therm_trip_thshold דעצימאַל ינט בלויז לייענען
threshold1_reached termal.threshold.thshold1_status דעצימאַל ינט בלויז לייענען
threshold2_reached termal.threshold.thshold2_status דעצימאַל ינט בלויז לייענען
threshold1_policy טערמאַל. threshold.thshold_policy דעצימאַל ינט באַניצער: לייענ-בלויז וואָרצל: לייענען-שרייַבן
טעמפּעראַטור thermal.rdsensor_fm1.fpga_temp דעצימאַל ינט בלויז לייענען

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

sysfs file mmio פעלד טיפּ צוטריט
קאַנסומד מאַכט.סטאַטוס.פּוור_קאַנסומד העקס uint64_t בלויז לייענען
שוועל 1 מאַכט שוועל 1 העקס uint64_t באַניצער: לייענ-בלויז וואָרצל: לייענען-שרייַבן
שוועל 2 מאַכט שוועל 2 העקס uint64_t באַניצער: לייענ-בלויז וואָרצל: לייענען-שרייַבן
threshold1_status power.threshold.threshold1_status דעצימאַל אַנסיינד בלויז לייענען
threshold2_status power.threshold.threshold2_status דעצימאַל אַנסיינד בלויז לייענען
rtl power.status.fpga_latency_report דעצימאַל אַנסיינד בלויז לייענען

FME גלאבאלע טעות סיספס files
intel-fpga-dev.i/intel-fpga-fme.j/errors/

sysfs file mmio פעלד טיפּ צוטריט
pcie0_errors gerror.pcie0_err העקס uint64_t לייענען-שרייַבן
pcie1_errors gerror.pcie1_err העקס uint64_t לייענען-שרייַבן
inject_error gerror.ras_error_inj העקס uint64_t לייענען-שרייַבן

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

sysfs file mmio פעלד טיפּ צוטריט
ערראָרס gerror.fme_err העקס uint64_t בלויז לייענען
first_error gerror.fme_first_err.err_reg_status העקס uint64_t בלויז לייענען
ווייַטער_טעות gerror.fme_next_err.err_reg_status העקס uint64_t בלויז לייענען
קלאָר קלירז ערראָרס, first_error, next_error פאַרשידן uint64_t שרייב-בלויז

באַמערקונג:
צו ויסמעקן די FME ערראָרס, איר מוזן שרייַבן די פּינטלעך ביטמאַסק פון די קראַנט ערראָרס, למשלampדי קאַץ ערראָרס > קלאָר.

FME פּאַרטיייש רעקאָנפיגוראַטיאָן sysfs files
intel-fpga-dev.i/intel-fpga-fme.j/pr/

sysfs file mmio פעלד טיפּ צוטריט
interface_id pr.fme_pr_intfc_id0_h, pr.fme_pre_intfc_id0_l העקס 16-בייט בלויז לייענען

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

sysfs file mmio פעלד טיפּ צוטריט
זייגער gperf.clk.afu_interf_clock העקס uint64_t בלויז לייענען

intel-fpga-dev.i/intel-fpga-fme.j/dperf/cache/ (ניט גילטיק פֿאַר אַקסעלעריישאַן סטאַק פֿאַר ינטעל קסעאָן קפּו מיט פפּגאַ)

sysfs file mmio פעלד טיפּ צוטריט
פרירן gperf.ch_ctl.freeze דעצימאַל ינט לייענען-שרייַבן
read_hit gperf.CACHE_RD_HIT העקס uint64_t בלויז לייענען
לייענען_מיס gperf.CACHE_RD_MISS העקס uint64_t בלויז לייענען
שרייַבן_היט gperf.CACHE_WR_HIT העקס uint64_t בלויז לייענען
שרייב_מיס gperf.CACHE_WR_MISS העקס uint64_t בלויז לייענען
האַלטן_רעקוועסט gperf.CACHE_HOLD_REQ העקס uint64_t בלויז לייענען
tx_req_stall gperf.CACHE_TX_REQ_STALL העקס uint64_t בלויז לייענען
sysfs file mmio פעלד טיפּ צוטריט
rx_req_stall gperf.CACHE_RX_REQ_STALL העקס uint64_t בלויז לייענען
data_write_port_contention gperf.CACHE_DATA_WR_PORT_CONTEN העקס uint64_t בלויז לייענען
tag_שרייב_פּאָרט_קאָנטענטיאָן gperf.CACHE_TAG_WR_PORT_CONTEN העקס uint64_t בלויז לייענען

intel-fpga-dev.i/intel-fpga-fme.j/dperf/iommu/ (ניט גילטיק פֿאַר אַקסעלעריישאַן סטאַק פֿאַר ינטעל קסעאָן קפּו מיט פפּגאַ)

sysfs file mmio פעלד טיפּ צוטריט
פרירן gperf.vtd_ctl.freeze דעצימאַל ינט באַניצער: לייענ-בלויז וואָרצל: לייענען-שרייַבן

intel-fpga-dev.i/intel-fpga-fme.j/dperf/iommu/afuk/ (ניט גילטיק פֿאַר אַקסעלעריישאַן סטאַק פֿאַר ינטעל קסעאָן קפּו מיט פפּגאַ)

sysfs file mmio פעלד טיפּ צוטריט
read_transaction gperf.VTD_AFU0_MEM_RD_TRANS העקס uint64_t בלויז לייענען
שרייַבן_טראַנסאַקטיאָן gperf.VTD_AFU0_MEM_WR_TRANS העקס uint64_t בלויז לייענען
tlb_read_hit gperf.VTD_AFU0_TLB_RD_HIT העקס uint64_t בלויז לייענען
tlb_write_hit gperf.VTD_AFU0_TLB_WR_HIT העקס uint64_t בלויז לייענען

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

sysfs file mmio פעלד טיפּ צוטריט
געבן gperf.fab_ctl.(ענייבאַלד) דעצימאַל ינט באַניצער: לייענ-בלויז וואָרצל: לייענען-שרייַבן
פרירן gperf.fab_ctl.freeze דעצימאַל ינט באַניצער: לייענ-בלויז וואָרצל: לייענען-שרייַבן
pcie0_read gperf.FAB_PCIE0_RD העקס uint64_t בלויז לייענען
pcie0_write gperf.FAB_PCIE0_WR העקס uint64_t בלויז לייענען
pcie1_read gperf.FAB_PCIE1_RD העקס uint64_t בלויז לייענען
pcie1_write gperf.FAB_PCIE1_WR העקס uint64_t בלויז לייענען
upi_read gperf.FAB_UPI_RD העקס uint64_t בלויז לייענען
upi_write gperf.FAB_UPI_WR העקס uint64_t בלויז לייענען

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

sysfs file mmio פעלד טיפּ צוטריט
pcie0_read gperf.FAB_PCIE0_RD העקס uint64_t בלויז לייענען
pcie0_write gperf.FAB_PCIE0_WR העקס uint64_t בלויז לייענען
pcie1_read gperf.FAB_PCIE1_RD העקס uint64_t בלויז לייענען
pcie1_write gperf.FAB_PCIE1_WR העקס uint64_t בלויז לייענען
upi_read gperf.FAB_UPI_RD העקס uint64_t בלויז לייענען
upi_write gperf.FAB_UPI_WR העקס uint64_t בלויז לייענען

פּאָרט כעדער sysfs files
intel-fpga-dev.i/intel-fpga-port.k/

sysfs file mmio פעלד טיפּ צוטריט
id פּאָרט_העדער.קאַפּאַביליטי.פּאָרט_נומער דעצימאַל ינט בלויז לייענען
ltr port_header.control.latency_tolerance דעצימאַל ינט בלויז לייענען

פּאָרט AFU כעדער sysfs files
intel-fpga-dev.i/intel-fpga-port.k/

sysfs file mmio פעלד טיפּ צוטריט
afu_id afu_header.guid העקס 16-בייט בלויז לייענען

פּאָרט טעות sysfs files
intel-fpga-dev.i/intel-fpga-port.k/errors/

sysfs file mmio פעלד טיפּ צוטריט
ערראָרס פּערראָר.פּאָרט_ערראָר העקס uint64_t בלויז לייענען
first_error perror.port_first_error העקס uint64_t בלויז לייענען
first_malformed_req perror.malreq העקס 16-בייט בלויז לייענען
קלאָר פּערראָ. (אַלע ערראָרס) פאַרשידן uint64_t שרייב-בלויז

באַמערקונג:
צו ויסמעקן די פּאָרט ערראָרס, איר מוזן שרייַבן די פּינטלעך ביטמאַסק פון די קראַנט ערראָרס, למשלampדי קאַץ ערראָרס > קלאָר.

רעוויזיע געשיכטע

דאָקומענט ווערסיע ענדערונגען
2017.10.02 ערשט מעלדונג.

OPAE Intel FPGA Linux Device Driver Architecture Guide

דאָקומענטן / רעסאָורסעס

Intel OPAE FPGA Linux Device Driver Architecture [pdfבאַניצער גייד
OPAE FPGA Linux Device Driver Architecture, OPAE FPGA, Linux Device Driver Architecture, Driver Architecture, Architecture

רעפערענצן

Related Posts

לאָזן אַ באַמערקונג

דיין בליצפּאָסט אַדרעס וועט נישט זיין ארויס. פארלאנגט פעלדער זענען אנגעצייכנט *