intel OPAE FPGA Linux Device Driver Architecture

OPAE Intel FPGA Linux Device Driver Architecture

OPAE Intel FPGA დრაივერი უზრუნველყოფს ინტერფეისებს მომხმარებლის სივრცის აპლიკაციებისთვის, რათა დააკონფიგურიროთ, ჩამოთვალოთ, გახსნათ და წვდეთ FPGA ამაჩქარებლებს Intel FPGA გადაწყვეტილებებით აღჭურვილ პლატფორმებზე და იძლევა სისტემის დონის მართვის ფუნქციებს, როგორიცაა FPGA ხელახალი კონფიგურაცია, ენერგიის მენეჯმენტი და ვირტუალიზაცია.

ტექნიკის არქიტექტურა

OS-ის თვალსაზრისით view, FPGA აპარატურა გამოჩნდება როგორც ჩვეულებრივი PCIe მოწყობილობა. FPGA მოწყობილობის მეხსიერება ორგანიზებულია წინასწარ განსაზღვრული მონაცემთა სტრუქტურის გამოყენებით (მოწყობილობის მახასიათებლების სია). FPGA მოწყობილობის მიერ მხარდაჭერილი ფუნქციები ვლინდება ამ მონაცემთა სტრუქტურების მეშვეობით, როგორც ეს ნაჩვენებია ქვემოთ მოცემულ ფიგურაში:

FPGA PCIe მოწყობილობა

დრაივერი მხარს უჭერს PCIe SR-IOV-ს ვირტუალური ფუნქციების (VF) შესაქმნელად, რომლებიც შეიძლება გამოყენებულ იქნას ვირტუალურ მანქანებზე ინდივიდუალური ამაჩქარებლების მინიჭებისთვის.

ინტელის კორპორაცია. Ყველა უფლება დაცულია. Intel, Intel-ის ლოგო და სხვა Intel ნიშნები არის Intel Corporation-ის ან მისი შვილობილი კომპანიების სავაჭრო ნიშნები. Intel იძლევა გარანტიას მისი FPGA და ნახევარგამტარული პროდუქტების შესრულებაზე მიმდინარე სპეციფიკაციების შესაბამისად Intel-ის სტანდარტული გარანტიის შესაბამისად, მაგრამ იტოვებს უფლებას ნებისმიერ დროს შეიტანოს ცვლილებები ნებისმიერ პროდუქტსა და სერვისში შეტყობინების გარეშე. Intel არ იღებს პასუხისმგებლობას ან პასუხისმგებლობას, რომელიც წარმოიქმნება აქ აღწერილი ნებისმიერი ინფორმაციის, პროდუქტის ან სერვისის აპლიკაციის ან გამოყენების შედეგად, გარდა იმ შემთხვევისა, რაც წერილობით არის დათანხმებული Intel-ის მიერ. Intel-ის მომხმარებლებს ურჩევენ, მიიღონ მოწყობილობის სპეციფიკაციების უახლესი ვერსია, სანამ დაეყრდნონ რაიმე გამოქვეყნებულ ინფორმაციას და განათავსონ შეკვეთები პროდუქტებსა და სერვისებზე.

სხვა სახელები და ბრენდები შეიძლება მოითხოვონ, როგორც სხვების საკუთრება.

ვირტუალიზებული 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) უნდა იყოს გენერირებული FPGA-ს ზუსტი FIM და მიზნობრივი სტატიკური რეგიონისთვის (პორტი); წინააღმდეგ შემთხვევაში, ხელახალი კონფიგურაციის ოპერაცია ჩაიშლება და შესაძლოა გამოიწვიოს სისტემის არასტაბილურობა. ეს თავსებადობა შეიძლება შემოწმდეს AF სათაურში მითითებული ინტერფეისის ID-ის შედარებით FME-ის მიერ sysfs-ის მეშვეობით გამოვლენილ ინტერფეისის ID-თან. ეს შემოწმება ჩვეულებრივ კეთდება მომხმარებლის სივრცის მიერ 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 და VF-ების გასააქტიურებლად. თითოეული VF ფლობს მხოლოდ ერთ პორტს AFU-ით. echo N > PCI_DEVICE_PATH/sriov_numvfs
3. VF-ების მეშვეობით VM-ებზე გადასვლა.
4. AFU ქვეშ VF ხელმისაწვდომია აპლიკაციებიდან VM-ში (იგივე დრაივერის გამოყენებით VF-ში).

შენიშვნა:
FME არ შეიძლება მიენიჭოს VF-ს, ამიტომ PR და სხვა მართვის ფუნქციები ხელმისაწვდომია მხოლოდ PF-ის მეშვეობით.

მძღოლის ორგანიზაცია

PCIe Module Device Driver

მძღოლის ორგანიზაცია

FPGA მოწყობილობები გამოჩნდება როგორც ჩვეულებრივი PCIe მოწყობილობები; ამრიგად, FPGA PCIe მოწყობილობის დრაივერი (intel-FPGA-PCI.ko) ყოველთვის პირველად იტვირთება FPGA PCIe PF ან VF გამოვლენის შემდეგ. ეს დრაივერი ასრულებს ინფრასტრუქტურულ როლს მძღოლის არქიტექტურაში. ეს:

• ქმნის FPGA კონტეინერის მოწყობილობას, როგორც ფუნქციური მოწყობილობების მშობელს.
• გადის მოწყობილობის მახასიათებლების სიაში, რომელიც დანერგილია PCIe მოწყობილობის BAR მეხსიერებაში, რათა აღმოაჩინოს ფუნქციური მოწყობილობები და მათი ქვეფუნქციები და შექმნას პლატფორმის მოწყობილობები მათთვის კონტეინერის მოწყობილობის ქვეშ.
• მხარს უჭერს SR-IOV.
• წარმოგიდგენთ ფუნქციური მოწყობილობის ინფრასტრუქტურას, რომელიც აბსტრაქტებს ოპერაციებს ქვეფუნქციებისთვის და ავლენს საერთო ფუნქციებს ფუნქციური მოწყობილობის დრაივერებისთვის.

PCIe Module Device Driver ფუნქციები

• შეიცავს PCIe აღმოჩენას, მოწყობილობების ჩამოთვლას და ფუნქციების აღმოჩენას.
• ქმნის sysfs საქაღალდეებს მთავარი მოწყობილობისთვის, FPGA მართვის ძრავისთვის (FME) და პორტისთვის.
• ქმნის პლატფორმის დრაივერების ინსტანციებს, რაც იწვევს Linux-ის ბირთვს მათი შესაბამისი პლატფორმის მოდულის დრაივერების ჩატვირთვას.

FME პლატფორმის მოდულის მოწყობილობის დრაივერი

• ელექტროენერგიის და თერმული მენეჯმენტი, შეცდომების შესახებ მოხსენება, შესრულების მოხსენება და სხვა ინფრასტრუქტურის ფუნქციები. ამ ფუნქციებზე წვდომა შეგიძლიათ FME დრაივერის მიერ გამოვლენილი sysfs ინტერფეისებით.
• ნაწილობრივი რეკონფიგურაცია. FME დრაივერი არეგისტრირებს FPGA მენეჯერს PR ქვეფუნქციის ინიციალიზაციის დროს; მას შემდეგ რაც ის მიიღებს FPGA_FME_PORT_PR ioctl-ს თქვენგან, ის გამოიძახებს საერთო ინტერფეისის ფუნქციას FPGA მენეჯერისგან, რათა დაასრულოს ბიტი ნაკადის ნაწილობრივი რეკონფიგურაცია მოცემულ პორტში.
• პორტის მართვა ვირტუალიზაციისთვის. FME დრაივერი შემოაქვს ორ ioctls-ს, FPGA_FME_PORT_RELEASE, რომელიც ათავისუფლებს მოცემულ პორტს PF-დან; და FPGA_FME_PORT_ASSIGN, რომელიც ანიჭებს პორტს PF-ს. მას შემდეგ, რაც პორტი გათავისუფლდება PF-დან, ის შეიძლება მიენიჭოს VF-ს PCIe დრაივერის მიერ მოწოდებული SR-IOV ინტერფეისების მეშვეობით. დამატებითი ინფორმაციისთვის იხილეთ „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 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 და ორი პორტი (AFU), როგორც საბავშვო მოწყობილობა:
/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-ებს და 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;
};
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,
.ზონდი = 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 release_port_num;
struct list_head რეგიონები;
};
struct build_feature_devs_info {
struct pci_dev *pdev;
ბათილად __iomem *ioaddr;
ბათილად __iomem *ioend;
int მიმდინარე_ბარი;
void __iomem *pfme_hdr;
struct მოწყობილობა *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 ძირითადი რეჟიმი და დააკონფიგურირეთ DMA.
• cci_pci_create_feature_devs() build_info_alloc_and_init()
  • გამოყავით struct 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.
  • გამოყავით სტრუქტურის რესურსების მასივი 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.
  • გამოყავით სტრუქტურის რესურსის მასივი 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()
• როდესაც პორტის პირადი ფუნქცია შეგხვდებათ: * create_feature_instance() build_info_add_sub_feature() * Initialize feature_dev.resource[id]. * feature_platform_data_add() ინიციალიზაცია feature_platform_data.features[id], ყველაფერი, გარდა .fops.
• parse_ports_from_fme()
  • თუ მძღოლი დატვირთულია ფიზიკურ ფუნქციაზე (PF), მაშინ:
• გაუშვით parse_feature_list() ნაკადი FME სათაურში აღწერილ თითოეულ პორტზე.
• გამოიყენეთ ბარი, რომელიც მითითებულია პორტის თითოეულ ჩანაწერში სათაურში.

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 (*uinit)(struct platform_device *pdev, struct feature *feature);
გრძელი (*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 რესურსის_ინდექსი;
ბათილად __iomem *ioaddr;
struct feature_ops *ops;
};
struct feature_platform_data {
struct list_head კვანძი;
struct mutex საკეტი;
ხელმოუწერელი long dev_status;
cdev cdev struct;
struct platform_device *dev;
ხელმოუწერელი int disable_count;
ბათილად *პირადი;
int num;
int (*config_port)(struct platform_device *, u32, bool);
struct platform_device *(*fpga_for_teach_port)(struct platform_device *,
void *, int (*match)(struct platform_device *, void *)); სტრუქტურა
ფუნქციის მახასიათებლები[0];
};
კონსტრუქცია perf_object {
int id;
const struct ატრიბუტი_ჯგუფი **attr_groups;
struct მოწყობილობა *fme_dev;
struct list_head კვანძი;
struct list_head ბავშვები;
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()
  • შეინახეთ struct 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 (*uinit)(struct platform_device *pdev, struct feature *feature);
გრძელი (*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 რესურსის_ინდექსი;
ბათილად __iomem *ioaddr;
struct feature_ops *ops;
};
struct feature_platform_data {
struct list_head კვანძი;
struct mutex საკეტი;
ხელმოუწერელი long dev_status;
cdev cdev struct;
struct platform_device *dev;
ხელმოუწერელი int disable_count;
ბათილად *პირადი;
int num;
int (*config_port)(struct platform_device *, u32, bool);
struct platform_device *(*fpga_for_teach_port)(struct platform_device *,
void *, int (*match)(struct platform_device *, void *));
სტრუქტურის მახასიათებლების მახასიათებლები[0];
};
struct fpga_afu_region {
u32 ინდექსი;
u32 დროშები;
u64 ზომა;
u64 ოფსეტი;
u64 ფიზ;
struct list_head კვანძი;
};
struct fpga_afu_dma_region {
u64 user_addr;
u64 სიგრძე;
u64 iova;
სტრუქტურის გვერდი **გვერდები;
struct rb_node კვანძი;
bool in_use;
};
კონსტრუქცია fpga_afu {
u64 რეგიონი_cur_offset;
int num_regions;
u8 num_umsgs;
struct list_head რეგიონები;
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()
  • შეინახეთ struct feature_ops feature_platform_data.features-ში თითოეული დასახლებული ფუნქციისთვის.
  • გამოიძახეთ ტესტის ფუნქცია, ასეთის არსებობის შემთხვევაში, სტრუქტურიდან.
  • გამოიძახეთ init ფუნქცია სტრუქტურიდან.
• afu_probe() fpga_register_dev_ops()
  • შექმენით პორტის სიმბოლო მოწყობილობის კვანძი, სტრუქტურის რეგისტრაცია file_ოპერაციები.

FME IOCTLs
IOCTL-ები, რომლებიც გამოძახებულია ღიაზე 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; // in: sizeof(struct fpga_fme_port_release)
__u32 დროშები; // in: უნდა იყოს 0
__u32 port_id; // in: პორტის ID (0-დან) გასაშვებად.
};

FPGA_FME_PORT_ASSIGN - arg არის მაჩვენებელი:

struct fpga_fme_port_assign {
__u32 argsz; // in: sizeof (სტრუქტურა fpga_fme_port_assign)
__u32 დროშები; // in: უნდა იყოს 0
__u32 port_id; // in: პორტის ID (0-დან) მინიჭება. (უნდა ყოფილიყო
ადრე გამოშვებული FPGA_FME_PORT_RELEASE)
};

FPGA_FME_PORT_PR-arg არის მაჩვენებელი:

struct fpga_fme_port_pr {
__u32 argsz; // in: sizeof(struct fpga_fme_port_pr)
__u32 დროშები; // in: უნდა იყოს 0
__u32 port_id; // in: პორტის ID (0-დან)
__u32 ბუფერული_ზომა; // in: ბიტტრიმინგის ბუფერის ზომა ბაიტებში. უნდა იყოს 4 ბაიტი
გასწორებული.
__u64 ბუფერული_მისამართი; // in: ბიტტრიმინგის ბუფერის პროცესის მისამართი
__u64 სტატუსი; // out: შეცდომის სტატუსი (bitmask)
};

პორტი IOCTLs
IOCTL-ები, რომლებიც გამოძახებულია ღიაზე 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; // in: sizeof(struct fpga_port_info)
__u32 დროშები; // out: აბრუნებს 0
__u32_რაიონი; // out: MMIO რეგიონების რაოდენობა, 2 (1 AFU-სთვის და 1 for
STP)
__u32 num_umsgs; // out: UMsg-ების რაოდენობა, რომლებიც მხარდაჭერილია აპარატურის მიერ
};

FPGA_PORT_GET_REGION_INFO-arg არის მაჩვენებელი:

struct fpga_port_region_info {
__u32 argsz; // in: sizeof (სტრუქტურა fpga_port_region_info)
__u32 დროშები; // out: (bitmask) { FPGA_REGION_READ, FPGA_REGION_WRITE,
FPGA_REGION_MMAP }
__u32 ინდექსი; // in: FPGA_PORT_INDEX_UAFU ან FPGA_PORT_INDEX_STP
__u32 padding; // in: უნდა იყოს 0
__u64 ზომა; // out: MMIO რეგიონის ზომა ბაიტებში
__u64 ოფსეტური; // out: MMIO რეგიონის ოფსეტი მოწყობილობის დაწყებიდან fd
};

FPGA_PORT_DMA_MAP - arg არის მაჩვენებელი:
struct fpga_port_dma_map {
__u32 argsz; // in: sizeof (სტრუქტურა fpga_port_dma_map)
__u32 დროშები; // in: უნდა იყოს 0 __u64 user_addr; // in: ვირტუალური პროცესი
მისამართი. უნდა იყოს გვერდის გასწორება.
__u64 სიგრძე; // in: რუკების სიგრძე ბაიტებში. უნდა იყოს გვერდის მრავალჯერადი
ზომა.
__u64 iova; // out: IO ვირტუალური მისამართი };

FPGA_PORT_DMA_UNMAP - arg არის მაჩვენებელი:
struct fpga_port_dma_unmap {
__u32 argsz; // in: sizeof(struct fpga_port_dma_unmap)
__u32 დროშები; // in: უნდა იყოს 0
__u64 iova; // in: 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; // in: sizeof(სტრუქტურა fpga_port_umsg_cfg)
__u32 დროშები; // in: უნდა იყოს 0
__u32 მინიშნება_ბიტმაპი; // in: UMsg მინიშნება რეჟიმი bitmap. მიუთითებს რომელია UMsg
ჩართულია.
};

FPGA_PORT_UMSG_SET_BASE_ADDR-

• ამ ioctl-ის გაცემამდე UMsg უნდა იყოს გამორთული.
• iova ველი უნდა იყოს საკმარისად დიდი ბუფერისთვის ყველა UMsg-ისთვის (num_umsgs * PAGE_SIZE).
  • დრაივერის ბუფერული მენეჯმენტის მიერ ბუფერი მონიშნულია, როგორც „გამოყენებული“.
  • თუ iova არის NULL, ნებისმიერი წინა რეგიონი არ არის მონიშნული, როგორც „გამოყენებული“.
• arg არის მითითება:
  struct fpga_port_umsg_base_addr {
  • u32 argsz; // in: sizeof(struct fpga_port_umsg_base_addr)
  • u32 დროშები; // in: უნდა იყოს 0
  • u64 iova; // in: IO ვირტუალური მისამართი FPGA_PORT_DMA_MAP-დან. };

შენიშვნა:

• პორტის შეცდომების გასასუფთავებლად, თქვენ უნდა დაწეროთ მიმდინარე შეცდომების ზუსტი ბიტმასკი, მაგ.ample, cat შეცდომები > გასაგებია
• 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	ათობითი ინტ	მხოლოდ წაკითხვადი
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	hex uint64_t	მხოლოდ წაკითხვადი
bitstream_metadata	fme_header.bitstream_md	hex uint64_t	მხოლოდ წაკითხვადი

FME თერმული მენეჯმენტი sysfs files
intel-fpga-dev.i/intel-fpga-fme.j/thermal_mgmt/

sysfs file	mmio ველი	ტიპი	წვდომა
ბარიერი 1	თერმული.ზღურბლი.tmp_thshold1	ათობითი ინტ	მომხმარებელი: მხოლოდ წაკითხვადი Root: წაკითხვა-ჩაწერა
ბარიერი 2	თერმული.ზღურბლი.tmp_thshold2	ათობითი ინტ	მომხმარებელი: მხოლოდ წაკითხვადი Root: წაკითხვა-ჩაწერა
ბარიერი_მგზავრობა	თერმული.ზღურბლი.თერმ_ტრიპ_თშოლდი	ათობითი ინტ	მხოლოდ წაკითხვადი
ბარიერი1_მიაღწია	თერმული.ზღურბლი.thshold1_status	ათობითი ინტ	მხოლოდ წაკითხვადი
ბარიერი2_მიაღწია	თერმული.ზღურბლი.thshold2_status	ათობითი ინტ	მხოლოდ წაკითხვადი
ბარიერი1_პოლიტიკა	თერმული. ბარიერი.thshold_policy	ათობითი ინტ	მომხმარებელი: მხოლოდ წაკითხვადი Root: წაკითხვა-ჩაწერა
ტემპერატურა	thermal.rdsensor_fm1.fpga_temp	ათობითი ინტ	მხოლოდ წაკითხვადი

FME ენერგიის მენეჯმენტი 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	მომხმარებელი: მხოლოდ წაკითხვადი Root: წაკითხვა-ჩაწერა
ბარიერი 2	სიმძლავრე.ზღურბლი.ბარიერი2	hex uint64_t	მომხმარებელი: მხოლოდ წაკითხვადი Root: წაკითხვა-ჩაწერა
threshold1_status	სიმძლავრე.ზღურბლი.threshold1_status	ათობითი ხელმოუწერელი	მხოლოდ წაკითხვადი
threshold2_status	სიმძლავრე.ზღურბლი.threshold2_status	ათობითი ხელმოუწერელი	მხოლოდ წაკითხვადი
rtl	power.status.fpga_latency_report	ათობითი ხელმოუწერელი	მხოლოდ წაკითხვადი

FME გლობალური შეცდომა 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	მხოლოდ წაკითხვადი
პირველი_შეცდომა	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 შეცდომების გასასუფთავებლად, თქვენ უნდა დაწეროთ მიმდინარე შეცდომების ზუსტი ბიტმასკი, მაგ.ample cat შეცდომები > გასუფთავება.

FME ნაწილობრივი რეკონფიგურაცია sysfs files
intel-fpga-dev.i/intel-fpga-fme.j/pr/

sysfs file	mmio ველი	ტიპი	წვდომა
ინტერფეისი_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	hex uint64_t	მხოლოდ წაკითხვადი

intel-fpga-dev.i/intel-fpga-fme.j/dperf/cache/ (არ მოქმედებს Acceleration Stack-ისთვის Intel Xeon CPU-სთვის FPGA-ებით)

sysfs file	mmio ველი	ტიპი	წვდომა
გაყინვას	gperf.ch_ctl.freeze	ათობითი ინტ	Კითხვა წერა
წაკითხვა_დარტყმა	gperf.CACHE_RD_HIT	hex uint64_t	მხოლოდ წაკითხვადი
read_miss	gperf.CACHE_RD_MISS	hex uint64_t	მხოლოდ წაკითხვადი
დაწერე_დაარტყა	gperf.CACHE_WR_HIT	hex uint64_t	მხოლოდ წაკითხვადი
write_miss	gperf.CACHE_WR_MISS	hex uint64_t	მხოლოდ წაკითხვადი
შეჩერება_მოთხოვნა	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_წერის_პორტის_კონტენცია	gperf.CACHE_TAG_WR_PORT_CONTEN	hex uint64_t	მხოლოდ წაკითხვადი

intel-fpga-dev.i/intel-fpga-fme.j/dperf/iommu/ (არ მოქმედებს Acceleration Stack-ისთვის Intel Xeon CPU-სთვის FPGA-ებით)

sysfs file	mmio ველი	ტიპი	წვდომა
გაყინვას	gperf.vtd_ctl.freeze	ათობითი ინტ	მომხმარებელი: მხოლოდ წაკითხვადი Root: წაკითხვა-ჩაწერა

intel-fpga-dev.i/intel-fpga-fme.j/dperf/iommu/afuk/ (არ მოქმედებს Acceleration Stack-ისთვის Intel Xeon CPU-სთვის FPGA-ებით)

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.(ჩართულია)	ათობითი ინტ	მომხმარებელი: მხოლოდ წაკითხვადი Root: წაკითხვა-ჩაწერა
გაყინვას	gperf.fab_ctl.freeze	ათობითი ინტ	მომხმარებელი: მხოლოდ წაკითხვადი Root: წაკითხვა-ჩაწერა
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	მხოლოდ წაკითხვადი

პორტის სათაური sysfs files
intel-fpga-dev.i/intel-fpga-port.k/

sysfs file	mmio ველი	ტიპი	წვდომა
id	port_header.capability.port_number	ათობითი ინტ	მხოლოდ წაკითხვადი
ლტრ	port_header.control.latency_tolerance	ათობითი ინტ	მხოლოდ წაკითხვადი

Port AFU Header 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 ველი	ტიპი	წვდომა
შეცდომები	perrror.port_error	hex uint64_t	მხოლოდ წაკითხვადი
პირველი_შეცდომა	perrror.port_first_error	hex uint64_t	მხოლოდ წაკითხვადი
პირველი_არასწორი_რეკ	საშინელება.malreq	თექვსმეტი 16 ბაიტი	მხოლოდ წაკითხვადი
ნათელი	შეცდომა. (ყველა შეცდომა)	სხვადასხვა uint64_t	მხოლოდ წერა

შენიშვნა:
პორტის შეცდომების გასასუფთავებლად, თქვენ უნდა დაწეროთ მიმდინარე შეცდომების ზუსტი ბიტმასკი, მაგample cat შეცდომები > გასუფთავება.

გადასინჯვის ისტორია

დოკუმენტის ვერსია	ცვლილებები
2017.10.02	საწყისი გამოშვება.

OPAE Intel FPGA Linux მოწყობილობის დრაივერის არქიტექტურის სახელმძღვანელო

დოკუმენტები / რესურსები

intel OPAE FPGA Linux Device Driver Architecture [pdf] მომხმარებლის სახელმძღვანელო OPAE FPGA Linux Device Driver Architecture, OPAE FPGA, Linux Device Driver Architecture, Driver Architecture, Architecture

ცნობები

• მომხმარებლის სახელმძღვანელო