સામગ્રી છુપાવો
1 intel OPAE FPGA Linux ઉપકરણ ડ્રાઈવર આર્કિટેક્ચર
2 OPAE Intel FPGA Linux ઉપકરણ ડ્રાઈવર આર્કિટેક્ચર
2.1 હાર્ડવેર આર્કિટેક્ચર
2.2 ડ્રાઇવર સંસ્થા
3 sysfs Files
4 પુનરાવર્તન ઇતિહાસ
5 દસ્તાવેજો / સંસાધનો
5.1 સંદર્ભો
6 સંબંધિત પોસ્ટ્સ

ઇન્ટેલ-લોગો

intel OPAE FPGA Linux ઉપકરણ ડ્રાઈવર આર્કિટેક્ચર

intel-OPAE-FPGA-Linux-ડિવાઈસ-ડ્રાઈવર-આર્કિટેક્ચર-ઉત્પાદન

OPAE Intel FPGA Linux ઉપકરણ ડ્રાઈવર આર્કિટેક્ચર

OPAE Intel FPGA ડ્રાઇવર, Intel FPGA સોલ્યુશન્સથી સજ્જ પ્લેટફોર્મ્સ પર FPGA એક્સિલરેટરને ગોઠવવા, ગણતરી કરવા, ખોલવા અને ઍક્સેસ કરવા માટે વપરાશકર્તા-સ્પેસ એપ્લિકેશનો માટે ઇન્ટરફેસ પૂરા પાડે છે અને FPGA પુનઃરૂપરેખાંકન, પાવર મેનેજમેન્ટ અને વર્ચ્યુઅલાઈઝેશન જેવા સિસ્ટમ-લેવલ મેનેજમેન્ટ કાર્યોને સક્ષમ કરે છે.

હાર્ડવેર આર્કિટેક્ચર

OS ના બિંદુ પરથી view, FPGA હાર્ડવેર નિયમિત PCIe ઉપકરણ તરીકે દેખાય છે. FPGA ઉપકરણ મેમરીને પૂર્વવ્યાખ્યાયિત ડેટા સ્ટ્રક્ચર (ઉપકરણ સુવિધા સૂચિ) નો ઉપયોગ કરીને ગોઠવવામાં આવે છે. FPGA ઉપકરણ દ્વારા સમર્થિત સુવિધાઓ આ ડેટા સ્ટ્રક્ચર્સ દ્વારા ખુલ્લી પાડવામાં આવે છે, જે નીચેની આકૃતિમાં નીચે દર્શાવેલ છે:

FPGA PCIe ઉપકરણ

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

વર્ચ્યુઅલ ફંક્શન્સ (VFs) બનાવવા માટે ડ્રાઈવર PCIe SR-IOV ને સપોર્ટ કરે છે જેનો ઉપયોગ વર્ચ્યુઅલ મશીનોને વ્યક્તિગત એક્સિલરેટર્સ સોંપવા માટે થઈ શકે છે.

ઇન્ટેલ કોર્પોરેશન. બધા હકો અમારી પાસે રાખેલા છે. ઇન્ટેલ, ઇન્ટેલ લોગો અને અન્ય ઇન્ટેલ ચિહ્નો ઇન્ટેલ કોર્પોરેશન અથવા તેની પેટાકંપનીઓના ટ્રેડમાર્ક છે. ઇન્ટેલ તેના એફપીજીએ અને સેમિકન્ડક્ટર ઉત્પાદનોના પ્રદર્શનને ઇન્ટેલની માનક વોરંટી અનુસાર વર્તમાન સ્પષ્ટીકરણો માટે વોરંટી આપે છે પરંતુ સૂચના વિના કોઈપણ સમયે કોઈપણ ઉત્પાદનો અને સેવાઓમાં ફેરફાર કરવાનો અધિકાર અનામત રાખે છે. Intel દ્વારા લેખિતમાં સ્પષ્ટપણે સંમત થયા સિવાય અહીં વર્ણવેલ કોઈપણ માહિતી, ઉત્પાદન અથવા સેવાના એપ્લિકેશન અથવા ઉપયોગથી ઉદ્ભવતી કોઈ જવાબદારી અથવા જવાબદારી સ્વીકારતી નથી. ઇન્ટેલ ગ્રાહકોને સલાહ આપવામાં આવે છે કે તેઓ કોઈપણ પ્રકાશિત માહિતી પર આધાર રાખતા પહેલા અને ઉત્પાદનો અથવા સેવાઓ માટે ઓર્ડર આપતા પહેલા ઉપકરણ વિશિષ્ટતાઓનું નવીનતમ સંસ્કરણ પ્રાપ્ત કરે.

અન્ય નામો અને બ્રાન્ડનો દાવો અન્યની મિલકત તરીકે થઈ શકે છે.

વર્ચ્યુઅલાઈઝ્ડ FPGA PCIe ઉપકરણ

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

FPGA મેનેજમેન્ટ એન્જિન (FME)
FPGA મેનેજમેન્ટ એન્જિન પાવર અને થર્મલ મેનેજમેન્ટ, એરર રિપોર્ટિંગ, રિકોન્ફિગરેશન, પરફોર્મન્સ રિપોર્ટિંગ અને અન્ય ઈન્ફ્રાસ્ટ્રક્ચર ફંક્શન્સ કરે છે. દરેક FPGA માં એક FME હોય છે, જે હંમેશા ફિઝિકલ ફંક્શન (PF) દ્વારા એક્સેસ કરવામાં આવે છે. યુઝર-સ્પેસ એપ્લીકેશન ઓપન() નો ઉપયોગ કરીને એફએમઈ માટે વિશિષ્ટ એક્સેસ મેળવી શકે છે અને તેને વિશેષાધિકૃત વપરાશકર્તા (રુટ) તરીકે close() નો ઉપયોગ કરીને રિલીઝ કરી શકે છે.

બંદર
પોર્ટ સ્ટેટિક FPGA ફેબ્રિક ("FPGA ઈન્ટરફેસ મેનેજર (FIM)") અને એક્સિલરેટર ફંક્શન (AF) ધરાવતા આંશિક રીતે પુનઃરૂપરેખાંકિત ક્ષેત્ર વચ્ચેના ઈન્ટરફેસનું પ્રતિનિધિત્વ કરે છે. પોર્ટ સોફ્ટવેરથી એક્સિલરેટર સુધીના સંચારને નિયંત્રિત કરે છે અને રીસેટ અને ડીબગ જેવી સુવિધાઓને ઉજાગર કરે છે. PCIe ઉપકરણમાં ઘણાબધા પોર્ટ્સ હોઈ શકે છે, અને FME ઉપકરણ પર FPGA_FME_PORT_ASSIGN ioctl નો ઉપયોગ કરીને તેને સોંપીને VF દ્વારા દરેક પોર્ટને એક્સપોઝ કરી શકાય છે.

એક્સિલરેટર ફંક્શન (AF) યુનિટ

  • એક એક્સિલરેટર ફંક્શન (એએફ) યુનિટ પોર્ટ સાથે જોડાયેલ છે અને એક્સિલરેટર-વિશિષ્ટ નિયંત્રણ રજીસ્ટર માટે ઉપયોગમાં લેવા માટે 256K MMIO પ્રદેશને ઉજાગર કરે છે.
  • યુઝર-સ્પેસ એપ્લીકેશન્સ પોર્ટ ઉપકરણ પર ઓપન() નો ઉપયોગ કરીને પોર્ટ સાથે જોડાયેલ AFU નો એક્સક્લુઝિવ એક્સેસ મેળવી શકે છે અને તેને close() નો ઉપયોગ કરીને રિલીઝ કરી શકે છે.
  • યુઝર-સ્પેસ એપ્લીકેશન mmap() એક્સિલરેટર MMIO પ્રદેશો પણ કરી શકે છે.

આંશિક પુનઃરૂપરેખાંકન
ઉપર જણાવ્યા મુજબ, પ્રવેગક કાર્ય (AF) ના આંશિક પુનઃરૂપરેખાંકન દ્વારા પ્રવેગકને ફરીથી ગોઠવી શકાય છે. file. એક્સિલરેટર ફંક્શન (AF) FPGA ના ચોક્કસ FIM અને લક્ષિત સ્ટેટિક રિજન (પોર્ટ) માટે જનરેટ થયેલ હોવું જોઈએ; અન્યથા, પુનઃરૂપરેખાંકન કામગીરી નિષ્ફળ જશે અને સંભવતઃ સિસ્ટમ અસ્થિરતાનું કારણ બનશે. આ સુસંગતતા AF હેડરમાં નોંધેલ ઈન્ટરફેસ ID ને sysfs દ્વારા FME દ્વારા બહાર પાડવામાં આવેલ ઈન્ટરફેસ ID સામે સરખાવીને ચકાસી શકાય છે. આ ચેક સામાન્ય રીતે પુનઃરૂપરેખાંકન IOCTL ને કૉલ કરતા પહેલા વપરાશકર્તા જગ્યા દ્વારા કરવામાં આવે છે.

નોંધ:
હાલમાં, વર્ચ્યુઅલાઈઝ્ડ હોસ્ટમાં ચાલી રહેલા પ્રોગ્રામ સહિત, FPGA ને ઍક્સેસ કરતો કોઈપણ સોફ્ટવેર પ્રોગ્રામ આંશિક પુનઃરૂપરેખાંકનનો પ્રયાસ કરતા પહેલા બંધ હોવો જોઈએ. પગલાં હશે:

  1. અતિથિ પાસેથી ડ્રાઇવરને અનલોડ કરો
  2. અતિથિ પાસેથી VF ને અનપ્લગ કરો
  3. SR-IOV ને અક્ષમ કરો
  4. આંશિક પુનઃરૂપરેખાંકન કરો
  5. SR-IOV સક્ષમ કરો
  6. મહેમાનને VF પ્લગ કરો
  7. ડ્રાઇવરને ગેસ્ટમાં લોડ કરો

FPGA વર્ચ્યુઅલાઈઝેશન
VM માં ચાલતી એપ્લીકેશનમાંથી એક્સિલરેટરને એક્સેસ કરવાનું સક્ષમ કરવા માટે, સંબંધિત AFU ના પોર્ટને નીચેના પગલાંઓનો ઉપયોગ કરીને VF ને સોંપવાની જરૂર છે:

  1. PF મૂળભૂત રીતે તમામ AFU પોર્ટની માલિકી ધરાવે છે. કોઈપણ પોર્ટ કે જેને VF ને પુનઃસોંપણી કરવાની જરૂર છે તે પહેલા FME ઉપકરણ પર FPGA_FME_PORT_RELEASE ioctl દ્વારા PFમાંથી મુક્ત થવી જોઈએ.
  2. એકવાર N પોર્ટ્સ PF માંથી મુક્ત થઈ જાય, પછી નીચેના આદેશનો ઉપયોગ SRIOV અને VF ને સક્ષમ કરવા માટે થઈ શકે છે. દરેક VF AFU સાથે માત્ર એક જ પોર્ટ ધરાવે છે. echo N > PCI_DEVICE_PATH/sriov_numvfs
  3. VFs થી VM સુધી પસાર કરો.
  4. VF હેઠળ AFU એ VM (VF ની અંદર સમાન ડ્રાઇવરનો ઉપયોગ કરીને) એપ્લિકેશન્સમાંથી સુલભ છે.

નોંધ:
FME ને VF ને અસાઇન કરી શકાતું નથી, આમ PR અને અન્ય મેનેજમેન્ટ કાર્યો ફક્ત PF દ્વારા જ ઉપલબ્ધ છે.

ડ્રાઇવર સંસ્થા

PCIe મોડ્યુલ ઉપકરણ ડ્રાઈવર

ડ્રાઇવર સંસ્થા

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

FPGA ઉપકરણો નિયમિત PCIe ઉપકરણો તરીકે દેખાય છે; આમ, FPGA PCIe ઉપકરણ ડ્રાઇવર (intel-FPGA-PCI.ko) એ FPGA PCIe PF અથવા VF શોધાયા પછી હંમેશા પહેલા લોડ થાય છે. આ ડ્રાઇવર ડ્રાઇવર આર્કિટેક્ચરમાં ઇન્ફ્રાસ્ટ્રક્ચરલ ભૂમિકા ભજવે છે. તે:

  • લક્ષણ ઉપકરણોના માતાપિતા તરીકે FPGA કન્ટેનર ઉપકરણ બનાવે છે.
  • ઉપકરણ સુવિધા સૂચિમાંથી ચાલે છે, જે PCIe ઉપકરણ BAR મેમરીમાં લાગુ કરવામાં આવે છે, ફીચર ઉપકરણો અને તેમની પેટા-સુવિધાઓ શોધવા અને કન્ટેનર ઉપકરણ હેઠળ તેમના માટે પ્લેટફોર્મ ઉપકરણો બનાવવા માટે.
  • SR-IOV ને સપોર્ટ કરે છે.
  • ફિચર ડિવાઈસ ઈન્ફ્રાસ્ટ્રક્ચરનો પરિચય આપે છે, જે પેટા-સુવિધાઓ માટે કામગીરીને અમૂર્ત કરે છે અને ઉપકરણ ડ્રાઈવરો માટે સામાન્ય કાર્યોને ઉજાગર કરે છે.

PCIe મોડ્યુલ ઉપકરણ ડ્રાઈવર કાર્યો

  • PCIe શોધ, ઉપકરણ ગણતરી અને સુવિધા શોધ સમાવે છે.
  • પિતૃ ઉપકરણ, FPGA મેનેજમેન્ટ એન્જિન (FME), અને પોર્ટ માટે sysfs ડિરેક્ટરીઓ બનાવે છે.
  • પ્લેટફોર્મ ડ્રાઇવર ઉદાહરણો બનાવે છે, જેના કારણે Linux કર્નલ તેમના સંબંધિત પ્લેટફોર્મ મોડ્યુલ ડ્રાઇવરોને લોડ કરે છે.

FME પ્લેટફોર્મ મોડ્યુલ ઉપકરણ ડ્રાઈવર

  • પાવર અને થર્મલ મેનેજમેન્ટ, એરર રિપોર્ટિંગ, પરફોર્મન્સ રિપોર્ટિંગ અને અન્ય ઈન્ફ્રાસ્ટ્રક્ચર ફંક્શન્સ. તમે FME ડ્રાઈવર દ્વારા sysfs ઈન્ટરફેસો દ્વારા આ કાર્યોને એક્સેસ કરી શકો છો.
  • આંશિક પુનઃરૂપરેખાંકન. PR પેટા-સુવિધા આરંભ દરમિયાન FME ડ્રાઇવર FPGA મેનેજરની નોંધણી કરે છે; એકવાર તે તમારી પાસેથી FPGA_FME_PORT_PR ioctl મેળવે છે, તે આપેલ પોર્ટ પર બીટસ્ટ્રીમના આંશિક પુનઃરૂપરેખાંકનને પૂર્ણ કરવા માટે FPGA મેનેજર પાસેથી સામાન્ય ઇન્ટરફેસ ફંક્શનને બોલાવે છે.
  • વર્ચ્યુઅલાઈઝેશન માટે પોર્ટ મેનેજમેન્ટ. FME ડ્રાઇવર બે ioctls, FPGA_FME_PORT_RELEASE રજૂ કરે છે, જે આપેલ પોર્ટને PFમાંથી મુક્ત કરે છે; અને FPGA_FME_PORT_ASSIGN, જે પોર્ટને પાછા PF ને સોંપે છે. એકવાર પોર્ટ PFમાંથી મુક્ત થઈ જાય, તે PCIe ડ્રાઈવર દ્વારા પૂરા પાડવામાં આવેલ SR-IOV ઈન્ટરફેસ દ્વારા VF ને સોંપી શકાય છે. વધુ માહિતી માટે, "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 માત્ર ઇન્ટીગ્રેટેડ FPGA સાથે Intel Xeon® પ્રોસેસર માટે એક્સિલરેશન સ્ટેક દ્વારા જ સપોર્ટેડ છે.

પોર્ટ પ્લેટફોર્મ મોડ્યુલ ઉપકરણ ડ્રાઈવર કાર્યો

  • પોર્ટ અક્ષર ઉપકરણ નોડ બનાવે છે.
  • પોર્ટ sysfs બનાવે છે files અને પોર્ટ sysfs ને અમલમાં મૂકે છે file એક્સેસર્સ
  • પોર્ટ પ્રાઈવેટ ફીચર સબ-ડ્રાઈવર્સનો અમલ કરે છે.
  • પોર્ટ ખાનગી સુવિધા સબ-ડ્રાઈવર્સ:
    • પોર્ટ હેડર
    • એએફયુ
    • પોર્ટ ભૂલ
    • UMsg(2)
    • સિગ્નલ ટેપ

એપ્લિકેશન FPGA ઉપકરણ ગણતરી
આ વિભાગ પરિચય આપે છે કે કેવી રીતે કાર્યક્રમો /sys/class/fpga હેઠળ sysfs વંશવેલોમાંથી 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 ને નંબર આપીશ અને 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];
રચના fpga_chardev_info {
const char *નામ;
dev_t devt;
};
સ્ટ્રક્ચર fpga_chardev_info fpga_chrdevs[] = {
{ .નામ = FPGA_FEATURE_DEV_FME },
{ .નામ = 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 = {
.નામ = DRV_NAME,
.id_table = cci_pcie_id_tbl,
.probe = cci_pci_probe,
.remove = cci_pci_દૂર કરો,
.sriov_configure = cci_pci_sriov_configure
};
રચના cci_drvdata {
int device_id;
સ્ટ્રક્ચર ઉપકરણ *fme_dev;
સ્ટ્રક્ટ મ્યુટેક્સ લોક;
struct list_head port_dev_list;
int release_port_num;
struct list_head પ્રદેશો;
};
સ્ટ્રક્ચર બિલ્ડ_ફીચર_દેવ્સ_માહિતી {
struct pci_dev *pdev;
void __iomem *ioaddr;
void __iomem *ioend;
int current_bar;
void __iomem *pfme_hdr;
સ્ટ્રક્ચર ડિવાઇસ *પેરેન્ટ_દેવ;
struct platform_device *feature_dev;
};

ગણના પ્રવાહ

  • ccidrv_init()
    • idr_init() નો ઉપયોગ કરીને fpga_ids શરૂ કરો.
    • alloc_chrdev_region() નો ઉપયોગ કરીને fpga_chrdevs[i].devt પ્રારંભ કરો.
    • class_create() નો ઉપયોગ કરીને fpga_class શરૂ કરો.
    • 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 ડિરેક્ટરીઓ ધરાવે છે.
  • પાર્સ_સુવિધા_સૂચિ()
    • FME, પોર્ટ અને તેમની ખાનગી વિશેષતાઓ શોધવા માટે BAR0 ઉપકરણ વિશેષતા સૂચિ પર ચાલો.
  • 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 માં સ્ટ્રક્ચર સંસાધનોની એરે ફાળવો.
  • એક સ્ટ્રક્ચર ફિચર_પ્લેટફોર્મ_ડેટા ફાળવો, તેને પ્રારંભ કરો અને ફીચર_દેવ.દેવ.પ્લેટફોર્મ_ડેટામાં એક પોઇન્ટર સ્ટોર કરો
    • create_feature_instance() build_info_add_sub_feature()
    • feature_dev.resource[FME_FEATURE_ID_HEADER] શરૂ કરો.
    • ફીચર_પ્લેટફોર્મ_ડેટા_એડ()
    • ફીચર_પ્લેટફોર્મ_ડેટા.ફીચર્સ[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 માં સ્ટ્રક્ચર રિસોર્સની એરે ફાળવો.
    • એક સ્ટ્રક્ચર ફિચર_પ્લેટફોર્મ_ડેટા ફાળવો, તેને પ્રારંભ કરો અને ફીચર_દેવ.દેવ.પ્લેટફોર્મ_ડેટામાં એક પોઇન્ટર સ્ટોર કરો
  • build_info_commit_dev()
    • સ્ટ્રક્ટ cci_drvdata.port_dev_list માં પોર્ટની યાદીમાં પોર્ટ માટે struct feature_platform_data.node ઉમેરો.
  • create_feature_instance() build_info_add_sub_feature()
    • feature_dev.resource[PORT_FEATURE_ID_HEADER] શરૂ કરો.
  • ફીચર_પ્લેટફોર્મ_ડેટા_એડ()
    • ફીચર_પ્લેટફોર્મ_ડેટા.ફીચર્સ[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] શરૂ કરો.
  • ફીચર_પ્લેટફોર્મ_ડેટા_એડ()
    • ફીચર_પ્લેટફોર્મ_ડેટા.ફીચર્સ[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] શરૂ કરો.
  • ફીચર_પ્લેટફોર્મ_ડેટા_એડ()
    • ફીચર_પ્લેટફોર્મ_ડેટા.ફીચર્સ[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() ફીચર_પ્લેટફોર્મ_ડેટા.features[id] શરૂ કરો, .fops સિવાય બધું.
  • parse_ports_from_fme()
    • જો ડ્રાઈવર ફિઝિકલ ફંક્શન (PF) પર લોડ થયેલ હોય, તો:
  • FME હેડરમાં વર્ણવેલ દરેક પોર્ટ પર parse_feature_list() ફ્લો ચલાવો.
  • હેડરમાં દરેક પોર્ટ એન્ટ્રીમાં દર્શાવેલ બારનો ઉપયોગ કરો.

FME પ્લેટફોર્મ ઉપકરણ પ્રારંભ
આ વિભાગ એક ઓવર આપે છેview intel-fpga-fme.ko દ્વારા કરવામાં આવેલ FME ઉપકરણ આરંભ માટે કોડ ફ્લો. મુખ્ય ડેટા સ્ટ્રક્ચર્સ અને ફંક્શન હાઇલાઇટ કરવામાં આવ્યા છે. જ્યારે આ વિભાગને શ્રેષ્ઠ રીતે અનુસરવામાં આવે છે viewસાથેનો સ્રોત કોડ (fme-main.c) દાખલ કરો.

FME પ્લેટફોર્મ ઉપકરણ ડેટા સ્ટ્રક્ચર્સ

રચના લક્ષણ_ઓપ્સ {
int (*init)(સ્ટ્રક્ટ પ્લેટફોર્મ_ડિવાઈસ *pdev, સ્ટ્રક્ચર ફીચર *ફીચર);
int (*uinit)(સ્ટ્રક્ટ પ્લેટફોર્મ_ડિવાઈસ *pdev, સ્ટ્રક્ચર ફીચર *ફીચર);
લાંબી (*ioctl)(સ્ટ્રક્ચર પ્લેટફોર્મ_ડિવાઈસ *pdev, સ્ટ્રક્ચર ફીચર *ફીચર,
સહી વિનાનું int cmd, સહી વિનાનું લોંગ આર્ગ);
int (*ટેસ્ટ)(સ્ટ્રક્ટ પ્લેટફોર્મ_ડિવાઈસ *pdev, સ્ટ્રક્ચર ફીચર *ફીચર);
};
રચના લક્ષણ {
const char *નામ;
int resource_index;
void __iomem *ioaddr;
સ્ટ્રક્ચર ફીચર_ઓપ્સ *ઓપ્સ;
};
રચના લક્ષણ_પ્લેટફોર્મ_ડેટા {
struct list_head નોડ;
સ્ટ્રક્ટ મ્યુટેક્સ લોક;
સહી ન કરેલ લાંબી dev_status;
struct cdev cdev;
struct platform_device *dev;
સહી ન કરેલ પૂર્ણાંક disable_count;
રદબાતલ *ખાનગી;
પૂર્ણાંક સંખ્યા;
int (*config_port)(struct platform_device *, u32, bool);
સ્ટ્રક્ચર પ્લેટફોર્મ_ડિવાઈસ *(*fpga_for_each_port)(સ્ટ્રક્ચર પ્લેટફોર્મ_ડિવાઈસ *,
void *, int (*match)(struct platform_device *, void*)); રચના
લક્ષણ લક્ષણો[0];
};
રચના perf_object {
પૂર્ણાંક ID;
const સ્ટ્રક્ચર એટ્રિબ્યુટ_ગ્રુપ **attr_groups;
સ્ટ્રક્ચર ઉપકરણ *fme_dev;
struct list_head નોડ;
struct list_head બાળકો;
struct kobject kobj;
};
રચના fpga_fme {
u8 port_id;
u64 pr_err;
સ્ટ્રક્ચર ઉપકરણ *dev_err;
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_platform_data.features માં સ્ટ્રક્ચર ફીચર_ઓપ્સ સાચવો.
    • સ્ટ્રક્ચરમાંથી ટેસ્ટ ફંક્શન, જો કોઈ હોય તો, કૉલ કરો.
    • સ્ટ્રક્ચરમાંથી init ફંક્શનને કૉલ કરો.
  • fme_probe() fpga_register_dev_ops()
    • FME અક્ષર ઉપકરણ નોડ બનાવો, સ્ટ્રક્ચર રજીસ્ટર કરો file_ઓપરેશન્સ.

પોર્ટ પ્લેટફોર્મ ઉપકરણ પ્રારંભ
આ વિભાગ એક ઓવર આપે છેview intel-fpga-afu.ko દ્વારા કરવામાં આવેલ પોર્ટ ઉપકરણ આરંભ માટે કોડ ફ્લો. મુખ્ય ડેટા સ્ટ્રક્ચર્સ અને કાર્યો પ્રકાશિત થાય છે. જ્યારે આ વિભાગને શ્રેષ્ઠ રીતે અનુસરવામાં આવે છે viewસાથેનો સ્રોત કોડ (afu.c) દાખલ કરો.

પોર્ટ પ્લેટફોર્મ ઉપકરણ ડેટા સ્ટ્રક્ચર્સ

રચના લક્ષણ_ઓપ્સ {
int (*init)(સ્ટ્રક્ટ પ્લેટફોર્મ_ડિવાઈસ *pdev, સ્ટ્રક્ચર ફીચર *ફીચર);
int (*uinit)(સ્ટ્રક્ટ પ્લેટફોર્મ_ડિવાઈસ *pdev, સ્ટ્રક્ચર ફીચર *ફીચર);
લાંબી (*ioctl)(સ્ટ્રક્ચર પ્લેટફોર્મ_ડિવાઈસ *pdev, સ્ટ્રક્ચર ફીચર *ફીચર,
સહી વિનાનું int cmd, સહી વિનાનું લોંગ આર્ગ);
int (*ટેસ્ટ)(સ્ટ્રક્ટ પ્લેટફોર્મ_ડિવાઈસ *pdev, સ્ટ્રક્ચર ફીચર *ફીચર);
};
રચના લક્ષણ {
const char *નામ;
int resource_index;
void __iomem *ioaddr;
સ્ટ્રક્ચર ફીચર_ઓપ્સ *ઓપ્સ;
};
રચના લક્ષણ_પ્લેટફોર્મ_ડેટા {
struct list_head નોડ;
સ્ટ્રક્ટ મ્યુટેક્સ લોક;
સહી ન કરેલ લાંબી dev_status;
struct cdev cdev;
struct platform_device *dev;
સહી ન કરેલ પૂર્ણાંક disable_count;
રદબાતલ *ખાનગી;
પૂર્ણાંક સંખ્યા;
int (*config_port)(struct platform_device *, u32, bool);
સ્ટ્રક્ચર પ્લેટફોર્મ_ડિવાઈસ *(*fpga_for_each_port)(સ્ટ્રક્ચર પ્લેટફોર્મ_ડિવાઈસ *,
void *, int (*match)(struct platform_device *, void*));
સ્ટ્રક્ચર ફીચર ફીચર્સ[0];
};
સ્ટ્રક્ચર fpga_afu_region {
u32 અનુક્રમણિકા;
u32 ધ્વજ;
u64 કદ;
u64 ઓફસેટ;
u64 ફિઝ;
struct list_head નોડ;
};
સ્ટ્રક્ચર fpga_afu_dma_region {
u64 user_addr;
u64 લંબાઈ;
u64 iova;
રચના પૃષ્ઠ ** પૃષ્ઠો;
struct rb_node નોડ;
bool in_us;
};
રચના fpga_afu {
u64 પ્રદેશ_કર_ઓફસેટ;
int num_regions;
u8 num_umsgs;
struct list_head પ્રદેશો;
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_platform_data.features માં સ્ટ્રક્ચર ફીચર_ઓપ્સ સાચવો.
    • સ્ટ્રક્ચરમાંથી ટેસ્ટ ફંક્શન, જો કોઈ હોય તો, કૉલ કરો.
    • સ્ટ્રક્ચરમાંથી init ફંક્શનને કૉલ કરો.
  • 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—arg એ એક નિર્દેશક છે:

રચના fpga_fme_port_release {
__u32 argsz; // in: sizeof(struct fpga_fme_port_release)
__u32 ફ્લેગ્સ; // માં: 0 હોવું આવશ્યક છે
__u32 પોર્ટ_આઇડી; // માં: પોર્ટ ID (0 થી) રિલીઝ કરવા માટે.
};

FPGA_FME_PORT_ASSIGN—arg એ એક નિર્દેશક છે:

સ્ટ્રક્ચર fpga_fme_port_assign {
__u32 argsz; // in: sizeof(struct fpga_fme_port_assign)
__u32 ફ્લેગ્સ; // માં: 0 હોવું આવશ્યક છે
__u32 પોર્ટ_આઇડી; // માં: પોર્ટ ID (0 થી) સોંપવા માટે. (હોવું જોઈએ
અગાઉ FPGA_FME_PORT_RELEASE દ્વારા પ્રકાશિત)
};

FPGA_FME_PORT_PR—arg એ એક નિર્દેશક છે:

રચના fpga_fme_port_pr {
__u32 argsz; // in: sizeof(struct fpga_fme_port_pr)
__u32 ફ્લેગ્સ; // માં: 0 હોવું આવશ્યક છે
__u32 પોર્ટ_આઇડી; // માં: પોર્ટ ID (0 થી)
__u32 બફર_સાઇઝ; // માં: બાઇટ્સમાં બીટસ્ટ્રીમ બફરનું કદ. 4-બાઈટ હોવી જોઈએ
ગોઠવાયેલ.
__u64 બફર_સરનામું; // માં: બીટસ્ટ્રીમ બફરનું સરનામું
__u64 સ્થિતિ; // બહાર: ભૂલ સ્થિતિ (બિટમાસ્ક)
};

પોર્ટ IOCTLs
IOCTLs કે જેને ઓપન પર બોલાવવામાં આવે છે file /dev/intel-fpga-port.k FPGA_GET_API_VERSION માટે વર્ણનકર્તા—પૂર્ણાંક તરીકે વર્તમાન સંસ્કરણ પરત કરો, જે 0 થી શરૂ થાય છે. FPGA_CHECK_EXTENSION—હાલમાં સમર્થિત નથી.

FPGA_PORT_GET_INFO—arg એ એક નિર્દેશક છે:

સ્ટ્રક્ચર fpga_port_info {
__u32 argsz; // in: sizeof(struct fpga_port_info)
__u32 ફ્લેગ્સ; // આઉટ: 0 પરત કરે છે
__u32 સંખ્યા_પ્રદેશો; // બહાર: MMIO પ્રદેશોની સંખ્યા, 2 (AFU માટે 1 અને માટે 1
STP)
__u32 num_umsgs; // આઉટ: હાર્ડવેર દ્વારા સમર્થિત UMsg ની સંખ્યા
};

FPGA_PORT_GET_REGION_INFO—arg એ એક નિર્દેશક છે:

સ્ટ્રક્ચર fpga_port_region_info {
__u32 argsz; // in: sizeof(struct 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 ઓફસેટ; // બહાર: ઉપકરણ fd ની શરૂઆતથી MMIO પ્રદેશની ઑફસેટ
};

FPGA_PORT_DMA_MAP—arg એ એક નિર્દેશક છે:
સ્ટ્રક્ચર fpga_port_dma_map {
__u32 argsz; // in: sizeof(struct fpga_port_dma_map)
__u32 ફ્લેગ્સ; // માં: 0 __u64 user_addr હોવું આવશ્યક છે; // માં: પ્રક્રિયા વર્ચ્યુઅલ
સરનામું પૃષ્ઠ સંરેખિત હોવું આવશ્યક છે.
__u64 લંબાઈ; // માં: બાઇટ્સમાં મેપિંગની લંબાઈ. પૃષ્ઠનો બહુવિધ હોવો જોઈએ
કદ
__u64 iova; // બહાર: IO વર્ચ્યુઅલ સરનામું };

FPGA_PORT_DMA_UNMAP—arg એ એક નિર્દેશક છે:
સ્ટ્રક્ચર fpga_port_dma_unmap {
__u32 argsz; // in: sizeof(struct fpga_port_dma_unmap)
__u32 ફ્લેગ્સ; // માં: 0 હોવું આવશ્યક છે
__u64 iova; // માં: IO વર્ચ્યુઅલ સરનામું પાછલા દ્વારા પરત કરવામાં આવ્યું છે
FPGA_PORT_DMA_MAP };

  • FPGA_PORT_RESET—આર્ગ NULL હોવો જોઈએ.
  • FPGA_PORT_UMSG_ENABLE—આર્ગ NULL હોવો જોઈએ.
  • FPGA_PORT_UMSG_DISABLE—આર્ગ્સ NULL હોવા જોઈએ.

FPGA_PORT_UMSG_SET_MODE—arg એ એક નિર્દેશક છે:

રચના fpga_port_umsg_cfg {
__u32 argsz; // in: sizeof(struct fpga_port_umsg_cfg)
__u32 ફ્લેગ્સ; // માં: 0 હોવું આવશ્યક છે
__u32 hint_bitmap; // માં: UMsg સંકેત મોડ બીટમેપ. સૂચવે છે કે કયા UMsg છે
સક્ષમ
};

FPGA_PORT_UMSG_SET_BASE_ADDR-

  • આ ioctl જારી કરતા પહેલા UMsg અક્ષમ હોવું આવશ્યક છે.
  • iova ફીલ્ડ બધા UMsg (num_umsgs * PAGE_SIZE) માટે પૂરતા મોટા બફર માટે હોવું જોઈએ.
    • ડ્રાઇવરના બફર મેનેજમેન્ટ દ્વારા બફરને "ઉપયોગમાં" તરીકે ચિહ્નિત કરવામાં આવે છે.
    • જો iova NULL હોય, તો કોઈપણ અગાઉના પ્રદેશને "ઉપયોગમાં" તરીકે અચિહ્નિત કરવામાં આવે છે.
  • arg એ એક નિર્દેશક છે:
    સ્ટ્રક્ચર fpga_port_umsg_base_addr {
    • u32 argsz; // in: sizeof(struct fpga_port_umsg_base_addr)
    • u32 ધ્વજ; // માં: 0 હોવું આવશ્યક છે
    • u64 iova; // માં: FPGA_PORT_DMA_MAP માંથી IO વર્ચ્યુઅલ સરનામું. };

નોંધ:

  • પોર્ટ ભૂલોને સાફ કરવા માટે, તમારે વર્તમાન ભૂલોનું ચોક્કસ બીટમાસ્ક લખવું પડશે, ભૂતપૂર્વ માટેample, બિલાડીની ભૂલો > સાફ કરો
  • UMsg માત્ર ઇન્ટીગ્રેટેડ FPGA સાથે Intel Xeon પ્રોસેસર માટે એક્સિલરેશન સ્ટેક દ્વારા સપોર્ટેડ છે.

sysfs Files

FME હેડર sysfs files
intel-fpga-dev.i/intel-fpga-fme.j/

sysfs file mmio ક્ષેત્ર પ્રકાર પ્રવેશ
પોર્ટ્સ_સંખ્યા fme_header.capability.num_ports દશાંશ પૂર્ણાંક માત્ર વાંચવા માટે
કેશ_સાઇઝ fme_header.capability.cache_size દશાંશ પૂર્ણાંક માત્ર વાંચવા માટે
આવૃત્તિ fme_header.capability.fabric_verid દશાંશ પૂર્ણાંક માત્ર વાંચવા માટે
સોકેટ_આઈડી 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 thermal.threshold.tmp_thshold1 દશાંશ પૂર્ણાંક વપરાશકર્તા: ફક્ત વાંચવા માટે રુટ: વાંચો-લખો
થ્રેશોલ્ડ2 thermal.threshold.tmp_thshold2 દશાંશ પૂર્ણાંક વપરાશકર્તા: ફક્ત વાંચવા માટે રુટ: વાંચો-લખો
થ્રેશોલ્ડ_ટ્રીપ thermal.threshold.therm_trip_thshold દશાંશ પૂર્ણાંક માત્ર વાંચવા માટે
થ્રેશોલ્ડ1_એ પહોંચ્યો thermal.threshold.thshold1_status દશાંશ પૂર્ણાંક માત્ર વાંચવા માટે
થ્રેશોલ્ડ2_એ પહોંચ્યો thermal.threshold.thshold2_status દશાંશ પૂર્ણાંક માત્ર વાંચવા માટે
થ્રેશોલ્ડ1_નીતિ થર્મલ threshold.thshold_policy દશાંશ પૂર્ણાંક વપરાશકર્તા: ફક્ત વાંચવા માટે રુટ: વાંચો-લખો
તાપમાન 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 power.threshold.threshold1 hex uint64_t વપરાશકર્તા: ફક્ત વાંચવા માટે રુટ: વાંચો-લખો
થ્રેશોલ્ડ2 power.threshold.threshold2 hex uint64_t વપરાશકર્તા: ફક્ત વાંચવા માટે રુટ: વાંચો-લખો
થ્રેશોલ્ડ1_સ્થિતિ power.threshold.threshold1_status દશાંશ સહી વિનાનું માત્ર વાંચવા માટે
થ્રેશોલ્ડ2_સ્થિતિ power.threshold.threshold2_status દશાંશ સહી વિનાનું માત્ર વાંચવા માટે
આરટીએલ power.status.fpga_latency_report દશાંશ સહી વિનાનું માત્ર વાંચવા માટે

FME વૈશ્વિક ભૂલ sysfs files
intel-fpga-dev.i/intel-fpga-fme.j/errors/

sysfs file mmio ક્ષેત્ર પ્રકાર પ્રવેશ
pcie0_ભૂલો gerror.pcie0_err hex uint64_t વાંચો લખો
pcie1_ભૂલો 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 બિલાડી ભૂલો > સ્પષ્ટ.

FME આંશિક પુનઃરૂપરેખાંકન sysfs files
intel-fpga-dev.i/intel-fpga-fme.j/pr/

sysfs file mmio ક્ષેત્ર પ્રકાર પ્રવેશ
ઇન્ટરફેસ_આઇડી pr.fme_pr_intfc_id0_h, pr.fme_pre_intfc_id0_l હેક્સ 16-બાઇટ માત્ર વાંચવા માટે

FME ગ્લોબલ પરફોર્મન્સ 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/ (FPGAs સાથે Intel Xeon CPU માટે પ્રવેગક સ્ટેક માટે માન્ય નથી)

sysfs file mmio ક્ષેત્ર પ્રકાર પ્રવેશ
સ્થિર gperf.ch_ctl.freeze દશાંશ પૂર્ણાંક વાંચો લખો
વાંચો_હિટ 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 માત્ર વાંચવા માટે
હોલ્ડ_રિક્વેસ્ટ 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_content gperf.CACHE_DATA_WR_PORT_CONTEN hex uint64_t માત્ર વાંચવા માટે
tag_write_port_contension gperf.CACHE_TAG_WR_PORT_CONTEN hex uint64_t માત્ર વાંચવા માટે

intel-fpga-dev.i/intel-fpga-fme.j/dperf/iommu/ (FPGAs સાથે Intel Xeon CPU માટે પ્રવેગક સ્ટેક માટે માન્ય નથી)

sysfs file mmio ક્ષેત્ર પ્રકાર પ્રવેશ
સ્થિર gperf.vtd_ctl.freeze દશાંશ પૂર્ણાંક વપરાશકર્તા: ફક્ત વાંચવા માટે રુટ: વાંચો-લખો

intel-fpga-dev.i/intel-fpga-fme.j/dperf/iommu/afuk/ (FPGAs સાથે Intel Xeon CPU માટે પ્રવેગક સ્ટેક માટે માન્ય નથી)

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.(સક્ષમ) દશાંશ પૂર્ણાંક વપરાશકર્તા: ફક્ત વાંચવા માટે રુટ: વાંચો-લખો
સ્થિર gperf.fab_ctl.freeze દશાંશ પૂર્ણાંક વપરાશકર્તા: ફક્ત વાંચવા માટે રુટ: વાંચો-લખો
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 દશાંશ પૂર્ણાંક માત્ર વાંચવા માટે

પોર્ટ 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 ક્ષેત્ર પ્રકાર પ્રવેશ
ભૂલો pererror.port_error hex uint64_t માત્ર વાંચવા માટે
પ્રથમ_ભૂલ pererror.port_first_error hex uint64_t માત્ર વાંચવા માટે
પ્રથમ_વિકૃત_req pererror.malreq હેક્સ 16-બાઇટ માત્ર વાંચવા માટે
સ્પષ્ટ પેરર. (બધી ભૂલો) વિવિધ uint64_t ફક્ત લખો

નોંધ:
પોર્ટની ભૂલોને સાફ કરવા માટે, તમારે વર્તમાન ભૂલોનું ચોક્કસ બીટમાસ્ક લખવું જોઈએ, ઉદાહરણ તરીકેample બિલાડી ભૂલો > સ્પષ્ટ.

પુનરાવર્તન ઇતિહાસ

દસ્તાવેજ સંસ્કરણ ફેરફારો
2017.10.02 પ્રારંભિક પ્રકાશન.

OPAE Intel FPGA Linux ઉપકરણ ડ્રાઇવર આર્કિટેક્ચર માર્ગદર્શિકા

દસ્તાવેજો / સંસાધનો

intel OPAE FPGA Linux ઉપકરણ ડ્રાઈવર આર્કિટેક્ચર [પીડીએફ] વપરાશકર્તા માર્ગદર્શિકા
OPAE FPGA Linux ઉપકરણ ડ્રાઈવર આર્કિટેક્ચર, OPAE FPGA, Linux ઉપકરણ ડ્રાઈવર આર્કિટેક્ચર, ડ્રાઈવર આર્કિટેક્ચર, આર્કિટેક્ચર

સંદર્ભો

સંબંધિત પોસ્ટ્સ

એક ટિપ્પણી મૂકો

તમારું ઇમેઇલ સરનામું પ્રકાશિત કરવામાં આવશે નહીં. જરૂરી ક્ષેત્રો ચિહ્નિત થયેલ છે *