intel OPAE FPGA Linux Driver Driver Architecture

OPAE Intel FPGA Linux ארכיטקטורת מנהלי התקנים

מנהל ההתקן של OPAE Intel FPGA מספק ממשקים עבור יישומי מרחב משתמש לקביעת תצורה, ספירה, פתיחה וגישה של מאיצי FPGA בפלטפורמות המצוידות בפתרונות Intel FPGA ומאפשר פונקציות ניהול ברמת המערכת כגון קביעת תצורה מחדש של FPGA, ניהול צריכת חשמל ווירטואליזציה.

ארכיטקטורת חומרה

מהנקודה של מערכת ההפעלה של view, חומרת ה-FPGA מופיעה כהתקן PCIe רגיל. זיכרון מכשיר ה-FPGA מאורגן באמצעות מבנה נתונים מוגדר מראש (רשימת תכונות התקנים). תכונות הנתמכות על ידי התקן FPGA נחשפות דרך מבני נתונים אלה, כפי שמוצג להלן באיור הבא:

מכשיר FPGA PCIe

הדרייבר תומך ב-PCIe SR-IOV ליצירת פונקציות וירטואליות (VFs) שניתן להשתמש בהן כדי להקצות מאיצים בודדים למכונות וירטואליות.

תאגיד אינטל. כל הזכויות שמורות. Intel, הלוגו של Intel וסימני Intel אחרים הם סימנים מסחריים של Intel Corporation או של חברות הבת שלה. אינטל מתחייבת לביצועים של מוצרי ה-FPGA והמוליכים למחצה שלה למפרטים הנוכחיים בהתאם לאחריות הסטנדרטית של אינטל, אך שומרת לעצמה את הזכות לבצע שינויים בכל מוצר ושירות בכל עת ללא הודעה מוקדמת. אינטל אינה נושאת באחריות או חבות הנובעת מהיישום או השימוש בכל מידע, מוצר או שירות המתוארים כאן, למעט כפי שהוסכם במפורש בכתב על ידי אינטל. ללקוחות אינטל מומלץ להשיג את הגרסה העדכנית ביותר של מפרטי המכשיר לפני הסתמכות על מידע שפורסם ולפני ביצוע הזמנות של מוצרים או שירותים.

ניתן לתבוע שמות ומותגים אחרים כרכושם של אחרים.

מכשיר FPGA PCIe וירטואלי

מנוע ניהול FPGA (FME)
מנוע הניהול של FPGA מבצע ניהול הספק ותרמי, דיווח שגיאות, תצורה מחדש, דיווח ביצועים ופונקציות תשתית אחרות. לכל FPGA יש FME אחד, אליו ניתן לגשת תמיד דרך הפונקציה הפיזית (PF). יישומי מרחב משתמש יכולים לרכוש גישה בלעדית ל-FME באמצעות open(), ולשחרר אותו באמצעות close() כמשתמש מועדף (root).

נָמָל
יציאה מייצגת את הממשק בין מארג ה-FPGA הסטטי ("מנהל ממשק FPGA (FIM)") לבין אזור שניתן להגדרה מחדש חלקית המכיל פונקציית מאיץ (AF). הפורט שולט בתקשורת מהתוכנה למאיץ וחושף תכונות כמו איפוס וניפוי באגים. להתקן PCIe עשויים להיות מספר יציאות, וכל יציאה יכולה להיחשף באמצעות VF על ידי הקצאתו באמצעות FPGA_FME_PORT_ASSIGN ioctl בהתקן FME.

יחידת תפקוד מאיץ (AF).

• יחידת פונקציית מאיץ (AF) מחוברת לפורט וחושפת אזור 256K MMIO לשימוש עבור אוגרי בקרה ספציפיים למאיץ.
• יישומי מרחב משתמש יכולים לקבל גישה בלעדית ל-AFU המחובר לפורט באמצעות open() במכשיר הפורט, ולשחרר אותו באמצעות close().
• יישומי מרחב משתמש יכולים גם למאיץ () 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. ה-PF הוא הבעלים של כל יציאות 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

ארגון נהגים

התקני FPGA מופיעים כהתקני PCIe רגילים; לפיכך, מנהל ההתקן של FPGA PCIe (intel-FPGA-PCI.ko) נטען תמיד ראשון ברגע שמזהים FPGA PCIe PF או VF. דרייבר זה ממלא תפקיד תשתיתי בארכיטקטורת הדרייברים. זה:

• יוצר התקן מיכל FPGA כהורה של ההתקנים המאפיינים.
• עובר על רשימת תכונות ההתקנים, המיושמת בזיכרון BAR של מכשירי PCIe, כדי לגלות התקני תכונה ותכונות המשנה שלהם וליצור עבורם התקני פלטפורמה מתחת למכשיר המכולה.
• תומך ב-SR-IOV.
• מציג את תשתית התקן תכונה, אשר מופשטת פעולות עבור תכונות משנה וחושפת פונקציות נפוצות למנהלי התקנים תכונה.

פונקציות מנהל ההתקן של מודול PCIe

• מכיל גילוי PCIe, ספירת מכשירים וגילוי תכונות.
• יוצר ספריות sysfs עבור מכשיר האב, מנוע ניהול FPGA (FME) ויציאה.
• יוצר את מופעי מנהלי ההתקן של הפלטפורמה, מה שגורם לגרעין הלינוקס לטעון את מנהלי ההתקן של מודול הפלטפורמה שלהם.

מנהל התקן של מודול פלטפורמת FME

• ניהול חשמל ותרמי, דיווח שגיאות, דיווח ביצועים ופונקציות תשתית אחרות. אתה יכול לגשת לפונקציות אלה באמצעות ממשקי sysfs שנחשפו על ידי מנהל ההתקן של FME.
• הגדרה מחדש חלקית. מנהל ההתקן של FME רושם מנהל FPGA במהלך אתחול תכונת המשנה של PR; ברגע שהוא מקבל ממך FPGA_FME_PORT_PR ioctl, הוא מפעיל את פונקציית הממשק המשותף ממנהל FPGA כדי להשלים את ההגדרה מחדש החלקית של זרם הסיביות ליציאה הנתונה.
• ניהול פורטים עבור וירטואליזציה. מנהל ההתקן של FME מציג שני ioctls, FPGA_FME_PORT_RELEASE, המשחרר את הפורט הנתון מ-PF; ו-FPGA_FME_PORT_ASSIGN, אשר מקצה את הפורט בחזרה ל-PF. לאחר שחרור הפורט מה-PF, ניתן להקצות אותו ל-VF דרך ממשקי SR-IOV שסופקו על ידי מנהל ההתקן של PCIe. למידע נוסף, עיין ב"וירטואליזציה של FPGA".

פונקציות מנהל ההתקן של מודול פלטפורמת FME

• יוצר את צומת התקן תו FME.
• יוצר את ה-FME sysfs files ומיישם את ה-FME sysfs file אביזרים.
• מיישמת מנהלי המשנה של תכונה פרטית של FME.
• מנהלי משנה של תכונות פרטיות של FME:
  • כותרת FME
  • ניהול תרמי
  • ניהול חשמל
  • שגיאה גלובלית
  • הגדרה מחדש חלקית
  • ביצועים גלובליים

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

UMsg נתמך רק באמצעות Acceleration Stack עבור מעבד Intel Xeon® עם FPGA משולב.

פונקציות מנהל ההתקן של מודול פלטפורמת יציאה

• יוצר את צומת התקן תו Port.
• יוצר את ה-Port sysfs files ומיישם את ה-Port sysfs file אביזרים.
• מיישמת מנהלי המשנה של התכונה הפרטית של הפורט.
• מנהלי משנה תכונה פרטית של יציאה:
  • כותרת יציאה
  • AFU
  • שגיאת יציאה
  • UMsg(2)
  • הקשה על אות

ספירת התקני FPGA של יישום
סעיף זה מציג כיצד יישומים מונים את התקן FPGA מהיררכיית sysfs תחת /sys/class/fpga. באקסampלהלן, שני התקני Intel FPGA מותקנים במארח. לכל מכשיר FPGA יש FME אחד ושתי יציאות (AFU). עבור כל מכשיר 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/

כאשר I מספור ברציפות את כל מכשירי המכולה, j מספור רצוף את ה-FME ו-k מספור ברציפות את כל הפורטים.

ניתן להפנות לצמתי המכשיר המשמשים עבור ioctl() ו-mmap() באמצעות:
/dev/intel-fpga-fme.j
/dev/intel-fpga-port.k

ספירת מנהל התקן PCIe
סעיף זה נותן מעל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 {
const char *שם;
dev_t devt;
};
struct fpga_chardev_info fpga_chrdevs[] = {
{ .name = FPGA_FEATURE_DEV_FME },
{ .name = FPGA_FEATURE_DEV_PORT },
};
מחלקת מבנה סטטית *fpga_class;
מבנה סטטי 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 = {
.name = DRV_NAME,
.id_table = cci_pcie_id_tbl,
.probe = cci_pci_probe,
.remove = cci_pci_remove,
.sriov_configure = cci_pci_sriov_configure
};
struct cci_drvdata {
int device_id;
מכשיר struct *fme_dev;
מנעול struct mutex;
struct list_head port_dev_list;
int released_port_num;
struct list_head regions;
};
struct build_feature_devs_info {
struct pci_dev *pdev;
void __iomem *ioaddr;
void __iomem *ioend;
int current_bar;
void __iomem *pfme_hdr;
struct device *parent_dev;
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 master והגדר את ה-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.
• parse_feature_list()
  • עבור ברשימת התכונות של BAR0 כדי לגלות את ה-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.
  • הקצאת מערך של משאבי struct ב-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], הכל מלבד .fops.
• 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.
  • הקצאת מערך של משאב struct ב-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], הכל מלבד .fops.
• 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], הכל מלבד .fops.
• 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()
  • אתחול feature_platform_data.features[id], הכל מלבד .fops.
• parse_feature() parse_feature_private() parse_feature_port_private()
• כאשר נתקלים בתכונה פרטית של Port: * create_feature_instance() build_info_add_sub_feature() * אתחול feature_dev.resource[id]. * feature_platform_data_add() אתחול feature_platform_data.features[id], הכל מלבד .fops.
• parse_ports_from_fme()
  • אם מנהל ההתקן נטען על הפונקציה הפיזית (PF), אז:
• הפעל את זרימת parse_feature_list() בכל יציאה המתוארת בכותרת FME.
• השתמש ב-BAR המוזכר בכל ערך פורט בכותרת.

אתחול מכשירי פלטפורמת FME
סעיף זה נותן מעלview של זרימת הקוד לאתחול מכשיר FME שבוצע על ידי intel-fpga-fme.ko. מבני הנתונים והפונקציות העיקריים מודגשים. מומלץ לעקוב אחר סעיף זה מתי viewבאמצעות קוד המקור הנלווה (fme-main.c).

מבני נתונים של פלטפורמת FME

struct feature_ops {
int (*init)(struct platform_device *pdev, struct feature *feature);
int (*uniit)(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);
};
מבנה תכונה {
const char *שם;
int resource_index;
void __iomem *ioaddr;
struct feature_ops *אופס;
};
struct feature_platform_data {
struct list_head node;
מנעול struct mutex;
unsigned long dev_status;
struct cdev cdev;
struct platform_device *dev;
int unsigned disable_count;
בטל *פרטי;
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 *)); מבנה
תכונות תכונה[0];
};
struct perf_object {
מזהה int;
const struct attribute_group **attr_groups;
מכשיר struct *fme_dev;
struct list_head node;
struct list_head children;
struct kobject kobj;
};
struct fpga_fme {
u8 port_id;
u64 pr_err;
התקן struct *dev_err;
struct perf_object *perf_dev;
struct feature_platform_data *pdata;
};

זרימת אתחול מכשירי פלטפורמת FME

זרימת אתחול FME

• 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 עבור כל תכונה מאוכלסת.
  • קרא לפונקציית הבדיקה, אם בכלל, מהמבנה.
  • קרא לפונקציה init מהמבנה.
• fme_probe() fpga_register_dev_ops()
  • צור את צומת התקן תו FME, תוך רישום מבנה file_פעולות.

אתחול התקן פלטפורמת יציאה
סעיף זה נותן מעלview של זרימת הקוד לאתחול התקן יציאה שבוצע על ידי intel-fpga-afu.ko. מבני הנתונים והפונקציות העיקריים מודגשים. מומלץ לעקוב אחר סעיף זה מתי viewבקוד המקור הנלווה (afu.c).

מבני נתונים של התקן פלטפורמת יציאה

struct feature_ops {
int (*init)(struct platform_device *pdev, struct feature *feature);
int (*uniit)(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);
};
מבנה תכונה {
const char *שם;
int resource_index;
void __iomem *ioaddr;
struct feature_ops *אופס;
};
struct feature_platform_data {
struct list_head node;
מנעול struct mutex;
unsigned long dev_status;
struct cdev cdev;
struct platform_device *dev;
int unsigned disable_count;
בטל *פרטי;
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 *));
תכונות מבנה [0];
};
struct fpga_afu_region {
מדד u32;
דגלים u32;
גודל u64;
אופסט u64;
u64 physis;
struct list_head node;
};
struct fpga_afu_dma_region {
u64 user_addr;
אורך u64;
u64 iova;
עמוד struct **עמודים;
struct rb_node node;
bool in_use;
};
struct 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;
};

זרימת אתחול התקן פלטפורמת יציאה

זרימת אתחול הנמל

• 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 עבור כל תכונה מאוכלסת.
  • קרא לפונקציית הבדיקה, אם בכלל, מהמבנה.
  • קרא לפונקציה init מהמבנה.
• afu_probe() fpga_register_dev_ops()
  • צור את צומת התקן תו Port, תוך רישום מבנה file_פעולות.

FME IOCTLs
IOCTLs שנקראים על פתוח file מתאר עבור /dev/intel-fpga-fme.j FPGA_GET_API_VERSION—החזר את הגרסה הנוכחית כמספר שלם, החל מ-0.

FPGA_CHECK_EXTENSION—לא נתמך כרגע.

FPGA_FME_PORT_RELEASE—arg הוא מצביע ל:

struct fpga_fme_port_release {
__u32 argsz; // ב: sizeof(struct fpga_fme_port_release)
דגלים __u32; // ב: חייב להיות 0
__u32 port_id; // ב: מזהה יציאה (מ-0) לשחרור.
};

FPGA_FME_PORT_ASSIGN—arg הוא מצביע ל:

struct fpga_fme_port_assign {
__u32 argsz; // ב: sizeof(struct fpga_fme_port_assign)
דגלים __u32; // ב: חייב להיות 0
__u32 port_id; // ב: מזהה יציאה (מ-0) להקצאה. (בטח היה
שוחרר בעבר על ידי FPGA_FME_PORT_RELEASE)
};

FPGA_FME_PORT_PR—arg הוא מצביע ל:

struct fpga_fme_port_pr {
__u32 argsz; // ב: sizeof(struct fpga_fme_port_pr)
דגלים __u32; // ב: חייב להיות 0
__u32 port_id; // ב: מזהה יציאה (מ-0)
__u32 buffer_size; // in: גודל מאגר זרם סיביות בבתים. חייב להיות 4-בייט
מיושר.
__u64 buffer_address; // ב: כתובת תהליך של מאגר זרם סיביות
__u64 סטטוס; // out: מצב שגיאה (מסכת סיביות)
};

נמל IOCTLs
IOCTLs שנקראים על פתוח file מתאר עבור /dev/intel-fpga-port.k FPGA_GET_API_VERSION—החזר את הגרסה הנוכחית כמספר שלם, החל מ-0. FPGA_CHECK_EXTENSION—לא נתמך כרגע.

FPGA_PORT_GET_INFO—arg הוא מצביע ל:

struct fpga_port_info {
__u32 argsz; // ב: sizeof(struct fpga_port_info)
דגלים __u32; // החוצה: מחזירה 0
__u32 num_regions; // בחוץ: מספר אזורי MMIO, 2 (1 עבור AFU ו-1 עבור
STP)
__u32 num_umsgs; // out: מספר UMsg'ים הנתמכים על ידי החומרה
};

FPGA_PORT_GET_REGION_INFO—arg הוא מצביע ל:

struct fpga_port_region_info {
__u32 argsz; // ב: sizeof(struct fpga_port_region_info)
דגלים __u32; // החוצה: (מסכת סיביות) { FPGA_REGION_READ, FPGA_REGION_WRITE,
FPGA_REGION_MMAP }
__u32 index; // ב: FPGA_PORT_INDEX_UAFU או FPGA_PORT_INDEX_STP
ריפוד __u32; // ב: חייב להיות 0
גודל __u64; // out: גודל אזור MMIO בבתים
__u64 קיזוז; // out: היסט של אזור MMIO מתחילת המכשיר fd
};

FPGA_PORT_DMA_MAP—arg הוא מצביע ל:
struct fpga_port_dma_map {
__u32 argsz; // ב: sizeof(struct fpga_port_dma_map)
דגלים __u32; // ב: חייב להיות 0 __u64 user_addr; // ב: תהליך וירטואלי
כתובת. חייב להיות מיושר דפים.
אורך __u64; // in: אורך המיפוי בבתים. חייב להיות כפולה של עמודים
גוֹדֶל.
__u64 iova; // out: כתובת וירטואלית של IO };

FPGA_PORT_DMA_UNMAP—arg הוא מצביע ל:
struct fpga_port_dma_unmap {
__u32 argsz; // ב: sizeof(struct fpga_port_dma_unmap)
דגלים __u32; // ב: חייב להיות 0
__u64 iova; // ב: כתובת וירטואלית של IO שהוחזרה על ידי כתובת קודמת
FPGA_PORT_DMA_MAP };

• FPGA_PORT_RESET—arg חייב להיות NULL.
• FPGA_PORT_UMSG_ENABLE—arg חייב להיות NULL.
• FPGA_PORT_UMSG_DISABLE - ארגומנטים חייבים להיות NULL.

FPGA_PORT_UMSG_SET_MODE—arg הוא מצביע ל:

struct fpga_port_umsg_cfg {
__u32 argsz; // ב: sizeof(struct fpga_port_umsg_cfg)
דגלים __u32; // ב: חייב להיות 0
__u32 hint_bitmap; // ב: מצב רמז UMsg מפת סיביות. מציין אילו UMsg's הם
מופעל.
};

FPGA_PORT_UMSG_SET_BASE_ADDR—

• יש להשבית את UMsg לפני הנפקת ioctl זה.
• השדה iova חייב להיות עבור מאגר גדול מספיק עבור כל ה-UMsg (num_umsgs * PAGE_SIZE).
  • המאגר מסומן כ"בשימוש" על ידי ניהול המאגר של הנהג.
  • אם iova הוא NULL, כל אזור קודם לא מסומן כ"בשימוש".
• arg הוא מצביע על:
  struct fpga_port_umsg_base_addr {
  • u32 argsz; // ב: sizeof(struct fpga_port_umsg_base_addr)
  • דגלים u32; // ב: חייב להיות 0
  • u64 iova; // ב: כתובת וירטואלית של IO מ-FPGA_PORT_DMA_MAP. };

פֶּתֶק:

• כדי לנקות את שגיאות היציאה, עליך לכתוב את המסכת המדויקת של השגיאות הנוכחיות, למשלample, cat errors > clear
• UMsg נתמך רק באמצעות Acceleration Stack עבור מעבד 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	עשרוני int	לקריאה בלבד
cache_size	fme_header.capability.cache_size	עשרוני int	לקריאה בלבד
גִרְסָה	fme_header.capability.fabric_verid	עשרוני int	לקריאה בלבד
socket_id	fme_header.capability.socket_id	עשרוני int	לקריאה בלבד
bitstream_id	fme_header.bitstream_id	hex uint64_t	לקריאה בלבד
bitstream_metadata	fme_header.bitstream_md	hex uint64_t	לקריאה בלבד

מערכת ניהול תרמית של FME files
intel-fpga-dev.i/intel-fpga-fme.j/thermal_mgmt/

sysfs file	שדה mmio	סוּג	גִישָׁה
סף 1	thermo.threshold.tmp_thshold1	עשרוני int	משתמש: שורש לקריאה בלבד: קריאה-כתיבה
סף 2	thermo.threshold.tmp_thshold2	עשרוני int	משתמש: שורש לקריאה בלבד: קריאה-כתיבה
threshold_trip	thermal.threshold.therm_trip_thshold	עשרוני int	לקריאה בלבד
threshold1_reached	thermal.threshold.thshold1_status	עשרוני int	לקריאה בלבד
threshold2_reached	thermal.threshold.thshold2_status	עשרוני int	לקריאה בלבד
threshold1_policy	תֶרמִי. threshold.thshold_policy	עשרוני int	משתמש: שורש לקריאה בלבד: קריאה-כתיבה
טֶמפֶּרָטוּרָה	thermal.rdsensor_fm1.fpga_temp	עשרוני int	לקריאה בלבד

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

sysfs file	שדה mmio	סוּג	גִישָׁה
מְאוּכָּל	power.status.pwr_consumed	hex uint64_t	לקריאה בלבד
סף 1	סף.כוח1	hex uint64_t	משתמש: שורש לקריאה בלבד: קריאה-כתיבה
סף 2	סף.כוח2	hex uint64_t	משתמש: שורש לקריאה בלבד: קריאה-כתיבה
threshold1_status	power.threshold.threshold1_status	עשרוני ללא סימן	לקריאה בלבד
threshold2_status	power.threshold.threshold2_status	עשרוני ללא סימן	לקריאה בלבד
rtl	power.status.fpga_latency_report	עשרוני ללא סימן	לקריאה בלבד

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

sysfs file	שדה mmio	סוּג	גִישָׁה
pcie0_errors	gerror.pcie0_err	hex uint64_t	קרוא וכתוב
pcie1_errors	gerror.pcie1_err	hex uint64_t	קרוא וכתוב
inject_error	gerror.ras_error_inj	hex uint64_t	קרוא וכתוב

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

sysfs file	שדה mmio	סוּג	גִישָׁה
שגיאות	gerror.fme_err	hex uint64_t	לקריאה בלבד
first_error	gerror.fme_first_err.err_reg_status	hex uint64_t	לקריאה בלבד
שגיאה הבאה	gerror.fme_next_err.err_reg_status	hex uint64_t	לקריאה בלבד
בָּרוּר	מנקה שגיאות, first_error, next_error	uint64_t שונים	כתיבה בלבד

פֶּתֶק:
כדי לנקות את שגיאות ה-FME, עליך לכתוב את המסכת המדויקת של השגיאות הנוכחיות, למשלampשגיאות le cat > ברור.

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	hex 16-בתים	לקריאה בלבד

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

sysfs file	שדה mmio	סוּג	גִישָׁה
שָׁעוֹן	gperf.clk.afu_interf_clock	hex uint64_t	לקריאה בלבד

intel-fpga-dev.i/intel-fpga-fme.j/dperf/cache/ (לא תקף עבור מחסנית האצה עבור Intel Xeon CPU עם FPGAs)

sysfs file	שדה mmio	סוּג	גִישָׁה
הַקפָּאָה	gperf.ch_ctl.freeze	עשרוני int	קרוא וכתוב
קרא_פגע	gperf.CACHE_RD_HIT	hex uint64_t	לקריאה בלבד
לקרוא_פספוס	gperf.CACHE_RD_MISS	hex uint64_t	לקריאה בלבד
כתב_להיט	gperf.CACHE_WR_HIT	hex uint64_t	לקריאה בלבד
כתב_פספוס	gperf.CACHE_WR_MISS	hex uint64_t	לקריאה בלבד
hold_request	gperf.CACHE_HOLD_REQ	hex uint64_t	לקריאה בלבד
tx_req_stall	gperf.CACHE_TX_REQ_STALL	hex uint64_t	לקריאה בלבד

sysfs file	שדה mmio	סוּג	גִישָׁה
rx_req_stall	gperf.CACHE_RX_REQ_STALL	hex uint64_t	לקריאה בלבד
data_write_port_contention	gperf.CACHE_DATA_WR_PORT_CONTEN	hex uint64_t	לקריאה בלבד
tag_write_port_contention	gperf.CACHE_TAG_WR_PORT_CONTEN	hex uint64_t	לקריאה בלבד

intel-fpga-dev.i/intel-fpga-fme.j/dperf/iommu/ (לא תקף עבור Acceleration Stack עבור Intel Xeon CPU עם FPGAs)

sysfs file	שדה mmio	סוּג	גִישָׁה
הַקפָּאָה	gperf.vtd_ctl.freeze	עשרוני int	משתמש: שורש לקריאה בלבד: קריאה-כתיבה

intel-fpga-dev.i/intel-fpga-fme.j/dperf/iommu/afuk/ (לא תקף עבור Acceleration Stack עבור Intel Xeon CPU עם FPGAs)

sysfs file	שדה mmio	סוּג	גִישָׁה
קריאה_עסקה	gperf.VTD_AFU0_MEM_RD_TRANS	hex uint64_t	לקריאה בלבד
כתיבה_עסקה	gperf.VTD_AFU0_MEM_WR_TRANS	hex uint64_t	לקריאה בלבד
tlb_read_hit	gperf.VTD_AFU0_TLB_RD_HIT	hex uint64_t	לקריאה בלבד
tlb_write_hit	gperf.VTD_AFU0_TLB_WR_HIT	hex uint64_t	לקריאה בלבד

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

sysfs file	שדה mmio	סוּג	גִישָׁה
לְאַפשֵׁר	gperf.fab_ctl.(מופעל)	עשרוני int	משתמש: שורש לקריאה בלבד: קריאה-כתיבה
הַקפָּאָה	gperf.fab_ctl.freeze	עשרוני int	משתמש: שורש לקריאה בלבד: קריאה-כתיבה
pcie0_read	gperf.FAB_PCIE0_RD	hex uint64_t	לקריאה בלבד
pcie0_write	gperf.FAB_PCIE0_WR	hex uint64_t	לקריאה בלבד
pcie1_read	gperf.FAB_PCIE1_RD	hex uint64_t	לקריאה בלבד
pcie1_write	gperf.FAB_PCIE1_WR	hex uint64_t	לקריאה בלבד
upi_read	gperf.FAB_UPI_RD	hex uint64_t	לקריאה בלבד
upi_write	gperf.FAB_UPI_WR	hex uint64_t	לקריאה בלבד

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

sysfs file	שדה mmio	סוּג	גִישָׁה
pcie0_read	gperf.FAB_PCIE0_RD	hex uint64_t	לקריאה בלבד
pcie0_write	gperf.FAB_PCIE0_WR	hex uint64_t	לקריאה בלבד
pcie1_read	gperf.FAB_PCIE1_RD	hex uint64_t	לקריאה בלבד
pcie1_write	gperf.FAB_PCIE1_WR	hex uint64_t	לקריאה בלבד
upi_read	gperf.FAB_UPI_RD	hex uint64_t	לקריאה בלבד
upi_write	gperf.FAB_UPI_WR	hex uint64_t	לקריאה בלבד

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

sysfs file	שדה mmio	סוּג	גִישָׁה
id	port_header.capability.port_number	עשרוני int	לקריאה בלבד
ltr	port_header.control.latency_tolerance	עשרוני int	לקריאה בלבד

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

sysfs file	שדה mmio	סוּג	גִישָׁה
afu_id	afu_header.guid	hex 16-בתים	לקריאה בלבד

שגיאת יציאה sysfs files
intel-fpga-dev.i/intel-fpga-port.k/errors/

sysfs file	שדה mmio	סוּג	גִישָׁה
שגיאות	perror.port_error	hex uint64_t	לקריאה בלבד
first_error	perror.port_first_error	hex uint64_t	לקריאה בלבד
first_malformed_req	perror.malreq	hex 16-בתים	לקריאה בלבד
בָּרוּר	שגיאה.(כל השגיאות)	uint64_t שונים	כתיבה בלבד

פֶּתֶק:
כדי לנקות את שגיאות הפורט, עליך לכתוב את המסכת המדויקת של השגיאות הנוכחיות, למשלampשגיאות le cat > ברור.

היסטוריית גרסאות

גרסת מסמך	שינויים
2017.10.02	שחרור ראשוני.

OPAE Intel FPGA Linux מדריך ארכיטקטורת מנהל ההתקן

מסמכים / משאבים

intel OPAE FPGA Linux Driver Driver Architecture [pdfמדריך למשתמש OPAE FPGA Linux Device Driver Architecture, OPAE FPGA, Linux Device Driver Architecture, Driver Architecture, ארכיטקטורה

הפניות

• מדריך למשתמש