intel OPAE FPGA Linux ਡਿਵਾਈਸ ਡਰਾਈਵਰ ਆਰਕੀਟੈਕਚਰ

OPAE Intel FPGA Linux ਡਿਵਾਈਸ ਡਰਾਈਵਰ ਆਰਕੀਟੈਕਚਰ

OPAE Intel FPGA ਡਰਾਈਵਰ ਯੂਜ਼ਰ-ਸਪੇਸ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਇੰਟੈੱਲ FPGA ਹੱਲਾਂ ਨਾਲ ਲੈਸ ਪਲੇਟਫਾਰਮਾਂ 'ਤੇ FPGA ਐਕਸਲੇਟਰਾਂ ਦੀ ਸੰਰਚਨਾ, ਗਿਣਤੀ ਕਰਨ, ਖੋਲ੍ਹਣ ਅਤੇ ਐਕਸੈਸ ਕਰਨ ਲਈ ਇੰਟਰਫੇਸ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਅਤੇ ਸਿਸਟਮ-ਪੱਧਰ ਪ੍ਰਬੰਧਨ ਫੰਕਸ਼ਨਾਂ ਜਿਵੇਂ ਕਿ FPGA ਪੁਨਰ-ਸੰਰਚਨਾ, ਪਾਵਰ ਪ੍ਰਬੰਧਨ, ਅਤੇ ਵਰਚੁਅਲਾਈਜੇਸ਼ਨ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ।

ਹਾਰਡਵੇਅਰ ਆਰਕੀਟੈਕਚਰ

ਦੇ OS ਦੇ ਬਿੰਦੂ ਤੋਂ view, FPGA ਹਾਰਡਵੇਅਰ ਇੱਕ ਨਿਯਮਤ PCIe ਡਿਵਾਈਸ ਦੇ ਰੂਪ ਵਿੱਚ ਪ੍ਰਗਟ ਹੁੰਦਾ ਹੈ। FPGA ਡਿਵਾਈਸ ਮੈਮੋਰੀ ਨੂੰ ਇੱਕ ਪੂਰਵ-ਪ੍ਰਭਾਸ਼ਿਤ ਡੇਟਾ ਢਾਂਚੇ (ਡਿਵਾਈਸ ਫੀਚਰ ਲਿਸਟ) ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸੰਗਠਿਤ ਕੀਤਾ ਗਿਆ ਹੈ। FPGA ਡਿਵਾਈਸ ਦੁਆਰਾ ਸਮਰਥਿਤ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਇਹਨਾਂ ਡੇਟਾ ਢਾਂਚੇ ਦੁਆਰਾ ਪ੍ਰਗਟ ਕੀਤੀਆਂ ਗਈਆਂ ਹਨ, ਜਿਵੇਂ ਕਿ ਹੇਠਾਂ ਦਿੱਤੇ ਚਿੱਤਰ ਵਿੱਚ ਦਰਸਾਇਆ ਗਿਆ ਹੈ:

FPGA PCIe ਡਿਵਾਈਸ

ਡਰਾਈਵਰ ਵਰਚੁਅਲ ਫੰਕਸ਼ਨ (VFs) ਬਣਾਉਣ ਲਈ PCIe SR-IOV ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ ਜੋ ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ ਨੂੰ ਵਿਅਕਤੀਗਤ ਐਕਸਲੇਟਰ ਦੇਣ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।

ਇੰਟੇਲ ਕਾਰਪੋਰੇਸ਼ਨ. ਸਾਰੇ ਹੱਕ ਰਾਖਵੇਂ ਹਨ. Intel, Intel ਲੋਗੋ, ਅਤੇ ਹੋਰ Intel ਚਿੰਨ੍ਹ Intel ਕਾਰਪੋਰੇਸ਼ਨ ਜਾਂ ਇਸਦੀਆਂ ਸਹਾਇਕ ਕੰਪਨੀਆਂ ਦੇ ਟ੍ਰੇਡਮਾਰਕ ਹਨ। Intel ਆਪਣੇ FPGA ਅਤੇ ਸੈਮੀਕੰਡਕਟਰ ਉਤਪਾਦਾਂ ਦੇ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ Intel ਦੀ ਮਿਆਰੀ ਵਾਰੰਟੀ ਦੇ ਅਨੁਸਾਰ ਮੌਜੂਦਾ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੇ ਅਨੁਸਾਰ ਵਾਰੰਟ ਦਿੰਦਾ ਹੈ ਪਰ ਬਿਨਾਂ ਨੋਟਿਸ ਦੇ ਕਿਸੇ ਵੀ ਸਮੇਂ ਕਿਸੇ ਵੀ ਉਤਪਾਦ ਅਤੇ ਸੇਵਾਵਾਂ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਕਰਨ ਦਾ ਅਧਿਕਾਰ ਰਾਖਵਾਂ ਰੱਖਦਾ ਹੈ। ਇੰਟੇਲ ਇੱਥੇ ਵਰਣਿਤ ਕਿਸੇ ਵੀ ਜਾਣਕਾਰੀ, ਉਤਪਾਦ, ਜਾਂ ਸੇਵਾ ਦੀ ਅਰਜ਼ੀ ਜਾਂ ਵਰਤੋਂ ਤੋਂ ਪੈਦਾ ਹੋਣ ਵਾਲੀ ਕੋਈ ਜ਼ਿੰਮੇਵਾਰੀ ਜਾਂ ਜ਼ਿੰਮੇਵਾਰੀ ਨਹੀਂ ਲੈਂਦਾ, ਸਿਵਾਏ ਇੰਟੇਲ ਦੁਆਰਾ ਲਿਖਤੀ ਤੌਰ 'ਤੇ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਸਹਿਮਤ ਹੋਏ। Intel ਗਾਹਕਾਂ ਨੂੰ ਕਿਸੇ ਵੀ ਪ੍ਰਕਾਸ਼ਿਤ ਜਾਣਕਾਰੀ 'ਤੇ ਭਰੋਸਾ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਅਤੇ ਉਤਪਾਦਾਂ ਜਾਂ ਸੇਵਾਵਾਂ ਲਈ ਆਰਡਰ ਦੇਣ ਤੋਂ ਪਹਿਲਾਂ ਡਿਵਾਈਸ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦਾ ਨਵੀਨਤਮ ਸੰਸਕਰਣ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਸਲਾਹ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ।

ਹੋਰ ਨਾਵਾਂ ਅਤੇ ਬ੍ਰਾਂਡਾਂ 'ਤੇ ਦੂਜਿਆਂ ਦੀ ਸੰਪਤੀ ਵਜੋਂ ਦਾਅਵਾ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

ਵਰਚੁਅਲਾਈਜ਼ਡ FPGA PCIe ਡਿਵਾਈਸ

FPGA ਪ੍ਰਬੰਧਨ ਇੰਜਣ (FME)
FPGA ਪ੍ਰਬੰਧਨ ਇੰਜਣ ਪਾਵਰ ਅਤੇ ਥਰਮਲ ਪ੍ਰਬੰਧਨ, ਗਲਤੀ ਰਿਪੋਰਟਿੰਗ, ਪੁਨਰ-ਸੰਰਚਨਾ, ਪ੍ਰਦਰਸ਼ਨ ਰਿਪੋਰਟਿੰਗ, ਅਤੇ ਹੋਰ ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਦੇ ਕੰਮ ਕਰਦਾ ਹੈ। ਹਰੇਕ FPGA ਦਾ ਇੱਕ FME ਹੁੰਦਾ ਹੈ, ਜਿਸਨੂੰ ਹਮੇਸ਼ਾ ਫਿਜ਼ੀਕਲ ਫੰਕਸ਼ਨ (PF) ਰਾਹੀਂ ਐਕਸੈਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਯੂਜ਼ਰ-ਸਪੇਸ ਐਪਲੀਕੇਸ਼ਨ ਓਪਨ() ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਐਫਐਮਈ ਤੱਕ ਵਿਸ਼ੇਸ਼ ਪਹੁੰਚ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੀਆਂ ਹਨ, ਅਤੇ ਇਸਨੂੰ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਅਧਿਕਾਰ ਪ੍ਰਾਪਤ ਉਪਭੋਗਤਾ (ਰੂਟ) ਵਜੋਂ close() ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਜਾਰੀ ਕਰ ਸਕਦੀਆਂ ਹਨ।

ਪੋਰਟ
ਇੱਕ ਪੋਰਟ ਸਥਿਰ FPGA ਫੈਬਰਿਕ ("FPGA ਇੰਟਰਫੇਸ ਮੈਨੇਜਰ (FIM)") ਅਤੇ ਇੱਕ ਐਕਸਲੇਟਰ ਫੰਕਸ਼ਨ (AF) ਵਾਲੇ ਅੰਸ਼ਕ ਤੌਰ 'ਤੇ ਮੁੜ ਸੰਰਚਨਾਯੋਗ ਖੇਤਰ ਦੇ ਵਿਚਕਾਰ ਇੰਟਰਫੇਸ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। ਪੋਰਟ ਸੌਫਟਵੇਅਰ ਤੋਂ ਐਕਸਲੇਟਰ ਤੱਕ ਸੰਚਾਰ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਦਾ ਹੈ ਅਤੇ ਰੀਸੈਟ ਅਤੇ ਡੀਬੱਗ ਵਰਗੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਉਜਾਗਰ ਕਰਦਾ ਹੈ। ਇੱਕ PCIe ਡਿਵਾਈਸ ਵਿੱਚ ਕਈ ਪੋਰਟ ਹੋ ਸਕਦੇ ਹਨ, ਅਤੇ ਹਰੇਕ ਪੋਰਟ ਨੂੰ FME ਡਿਵਾਈਸ ਉੱਤੇ FPGA_FME_PORT_ASSIGN ioctl ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ VF ਦੁਆਰਾ ਐਕਸਪੋਜ਼ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

ਐਕਸਲੇਟਰ ਫੰਕਸ਼ਨ (AF) ਯੂਨਿਟ

• ਇੱਕ ਐਕਸਲੇਟਰ ਫੰਕਸ਼ਨ (AF) ਯੂਨਿਟ ਇੱਕ ਪੋਰਟ ਨਾਲ ਜੁੜਿਆ ਹੋਇਆ ਹੈ ਅਤੇ ਐਕਸਲੇਟਰ-ਵਿਸ਼ੇਸ਼ ਨਿਯੰਤਰਣ ਰਜਿਸਟਰਾਂ ਲਈ ਵਰਤੇ ਜਾਣ ਲਈ ਇੱਕ 256K MMIO ਖੇਤਰ ਦਾ ਪਰਦਾਫਾਸ਼ ਕਰਦਾ ਹੈ।
• ਯੂਜ਼ਰ-ਸਪੇਸ ਐਪਲੀਕੇਸ਼ਨਾਂ ਪੋਰਟ ਡਿਵਾਈਸ 'ਤੇ open() ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪੋਰਟ ਨਾਲ ਜੁੜੇ AFU ਤੱਕ ਵਿਸ਼ੇਸ਼ ਪਹੁੰਚ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੀਆਂ ਹਨ, ਅਤੇ ਇਸਨੂੰ close() ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਛੱਡ ਸਕਦੀਆਂ ਹਨ।
• ਯੂਜ਼ਰ-ਸਪੇਸ ਐਪਲੀਕੇਸ਼ਨ mmap() ਐਕਸਲੇਟਰ MMIO ਖੇਤਰ ਵੀ ਕਰ ਸਕਦੇ ਹਨ।

ਅੰਸ਼ਕ ਮੁੜ ਸੰਰਚਨਾ
ਜਿਵੇਂ ਕਿ ਉੱਪਰ ਦੱਸਿਆ ਗਿਆ ਹੈ, ਐਕਸਲੇਟਰ ਫੰਕਸ਼ਨ (ਏਐਫ) ਦੇ ਅੰਸ਼ਕ ਪੁਨਰ-ਸੰਰਚਨਾ ਦੁਆਰਾ ਐਕਸਲੇਟਰਾਂ ਨੂੰ ਮੁੜ ਸੰਰਚਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ. 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 ਨੂੰ ਮੁੜ-ਸਾਈਨ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਪਹਿਲਾਂ PF ਤੋਂ FME ਡਿਵਾਈਸ 'ਤੇ FPGA_FME_PORT_RELEASE ioctl ਰਾਹੀਂ ਜਾਰੀ ਕੀਤੀ ਜਾਣੀ ਚਾਹੀਦੀ ਹੈ।
2. ਇੱਕ ਵਾਰ N ਪੋਰਟਾਂ ਨੂੰ PF ਤੋਂ ਜਾਰੀ ਕੀਤੇ ਜਾਣ ਤੋਂ ਬਾਅਦ, ਹੇਠਾਂ ਦਿੱਤੀ ਕਮਾਂਡ ਨੂੰ SRIOV ਅਤੇ VF ਨੂੰ ਸਮਰੱਥ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਹਰੇਕ VF ਕੋਲ AFU ਨਾਲ ਸਿਰਫ਼ ਇੱਕ ਪੋਰਟ ਹੈ। echo N > PCI_DEVICE_PATH/sriov_numvfs
3. VFs ਤੋਂ VMs ਨੂੰ ਪਾਸ ਕਰੋ।
4. VF ਅਧੀਨ AFU VM ਵਿੱਚ ਐਪਲੀਕੇਸ਼ਨਾਂ ਤੋਂ ਪਹੁੰਚਯੋਗ ਹੈ (VF ਦੇ ਅੰਦਰ ਉਸੇ ਡਰਾਈਵਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ)।

ਨੋਟ:
ਇੱਕ FME ਨੂੰ ਇੱਕ VF ਨੂੰ ਸੌਂਪਿਆ ਨਹੀਂ ਜਾ ਸਕਦਾ ਹੈ, ਇਸ ਤਰ੍ਹਾਂ PR ਅਤੇ ਹੋਰ ਪ੍ਰਬੰਧਨ ਫੰਕਸ਼ਨ PF ਦੁਆਰਾ ਹੀ ਉਪਲਬਧ ਹਨ।

ਡਰਾਈਵਰ ਸੰਗਠਨ

PCIe ਮੋਡੀਊਲ ਜੰਤਰ ਡਰਾਈਵਰ

ਡਰਾਈਵਰ ਸੰਗਠਨ

FPGA ਯੰਤਰ ਨਿਯਮਤ PCIe ਯੰਤਰਾਂ ਦੇ ਰੂਪ ਵਿੱਚ ਦਿਖਾਈ ਦਿੰਦੇ ਹਨ; ਇਸ ਤਰ੍ਹਾਂ, FPGA PCIe ਜੰਤਰ ਡਰਾਈਵਰ (intel-FPGA-PCI.ko) ਇੱਕ ਵਾਰ FPGA PCIe PF ਜਾਂ VF ਖੋਜੇ ਜਾਣ 'ਤੇ ਹਮੇਸ਼ਾ ਪਹਿਲਾਂ ਲੋਡ ਹੁੰਦਾ ਹੈ। ਇਹ ਡਰਾਈਵਰ ਡਰਾਈਵਰ ਆਰਕੀਟੈਕਚਰ ਵਿੱਚ ਇੱਕ ਬੁਨਿਆਦੀ ਭੂਮਿਕਾ ਨਿਭਾਉਂਦਾ ਹੈ। ਇਹ:

• ਵਿਸ਼ੇਸ਼ਤਾ ਡਿਵਾਈਸਾਂ ਦੇ ਮਾਤਾ-ਪਿਤਾ ਵਜੋਂ ਇੱਕ FPGA ਕੰਟੇਨਰ ਡਿਵਾਈਸ ਬਣਾਉਂਦਾ ਹੈ।
• ਡਿਵਾਈਸ ਫੀਚਰ ਲਿਸਟ ਦੁਆਰਾ ਚੱਲਦਾ ਹੈ, ਜੋ ਕਿ PCIe ਡਿਵਾਈਸ ਬਾਰ ਮੈਮੋਰੀ ਵਿੱਚ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ, ਫੀਚਰ ਡਿਵਾਈਸਾਂ ਅਤੇ ਉਹਨਾਂ ਦੀਆਂ ਉਪ-ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਖੋਜਣ ਅਤੇ ਕੰਟੇਨਰ ਡਿਵਾਈਸ ਦੇ ਅਧੀਨ ਉਹਨਾਂ ਲਈ ਪਲੇਟਫਾਰਮ ਡਿਵਾਈਸਾਂ ਬਣਾਉਣ ਲਈ.
• SR-IOV ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ।
• ਫੀਚਰ ਡਿਵਾਈਸ ਬੁਨਿਆਦੀ ਢਾਂਚਾ ਪੇਸ਼ ਕਰਦਾ ਹੈ, ਜੋ ਉਪ-ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਲਈ ਸੰਚਾਲਨ ਨੂੰ ਐਬਸਟਰੈਕਟ ਕਰਦਾ ਹੈ ਅਤੇ ਵਿਸ਼ੇਸ਼ਤਾ ਡਿਵਾਈਸ ਡਰਾਈਵਰਾਂ ਲਈ ਆਮ ਫੰਕਸ਼ਨਾਂ ਦਾ ਪਰਦਾਫਾਸ਼ ਕਰਦਾ ਹੈ।

PCIe ਮੋਡੀਊਲ ਡਿਵਾਈਸ ਡਰਾਈਵਰ ਫੰਕਸ਼ਨ

• ਇਸ ਵਿੱਚ PCIe ਖੋਜ, ਡਿਵਾਈਸ ਗਣਨਾ, ਅਤੇ ਵਿਸ਼ੇਸ਼ਤਾ ਖੋਜ ਸ਼ਾਮਲ ਹੈ।
• ਮੂਲ ਜੰਤਰ, FPGA ਪ੍ਰਬੰਧਨ ਇੰਜਣ (FME), ਅਤੇ ਪੋਰਟ ਲਈ sysfs ਡਾਇਰੈਕਟਰੀਆਂ ਬਣਾਉਂਦਾ ਹੈ।
• ਪਲੇਟਫਾਰਮ ਡਰਾਈਵਰ ਉਦਾਹਰਨਾਂ ਬਣਾਉਂਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਲੀਨਕਸ ਕਰਨਲ ਉਹਨਾਂ ਦੇ ਪਲੇਟਫਾਰਮ ਮੋਡੀਊਲ ਡਰਾਈਵਰਾਂ ਨੂੰ ਲੋਡ ਕਰਦਾ ਹੈ।

FME ਪਲੇਟਫਾਰਮ ਮੋਡੀਊਲ ਜੰਤਰ ਡਰਾਈਵਰ

• ਪਾਵਰ ਅਤੇ ਥਰਮਲ ਪ੍ਰਬੰਧਨ, ਗਲਤੀ ਰਿਪੋਰਟਿੰਗ, ਪ੍ਰਦਰਸ਼ਨ ਰਿਪੋਰਟਿੰਗ, ਅਤੇ ਹੋਰ ਬੁਨਿਆਦੀ ਫੰਕਸ਼ਨ. ਤੁਸੀਂ ਇਹਨਾਂ ਫੰਕਸ਼ਨਾਂ ਨੂੰ FME ਡਰਾਈਵਰ ਦੁਆਰਾ sysfs ਇੰਟਰਫੇਸ ਰਾਹੀਂ ਐਕਸੈਸ ਕਰ ਸਕਦੇ ਹੋ।
• ਅੰਸ਼ਕ ਮੁੜ ਸੰਰਚਨਾ। FME ਡਰਾਈਵਰ PR ਉਪ-ਵਿਸ਼ੇਸ਼ਤਾ ਸ਼ੁਰੂਆਤ ਦੇ ਦੌਰਾਨ ਇੱਕ 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];
struct fpga_chardev_info {
const char *ਨਾਮ;
dev_t devt;
};
struct 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
};
struct cci_drvdata {
int device_id;
struct ਡਿਵਾਈਸ *fme_dev;
struct mutex ਲਾਕ;
struct list_head port_dev_list;
int ਰਿਲੀਜ਼_ਪੋਰਟ_ਨਮ;
struct list_head ਖੇਤਰ;
};
struct build_feature_devs_info {
struct pci_dev *pdev;
void __iomem *ioaddr;
void __iomem *ioend;
int current_bar;
void __iomem *pfme_hdr;
struct ਡਿਵਾਈਸ *parent_dev;
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()
  • ਇੱਕ struct 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 ਵਿੱਚ struct ਸਰੋਤਾਂ ਦੀ ਇੱਕ ਐਰੇ ਨਿਰਧਾਰਤ ਕਰੋ।
• ਇੱਕ ਢਾਂਚਾ ਫੀਚਰ_ਪਲੇਟਫਾਰਮ_ਡਾਟਾ ਨਿਰਧਾਰਤ ਕਰੋ, ਇਸਨੂੰ ਸ਼ੁਰੂ ਕਰੋ, ਅਤੇ ਫੀਚਰ_dev.dev.platform_data ਵਿੱਚ ਇੱਕ ਪੁਆਇੰਟਰ ਸਟੋਰ ਕਰੋ
  • create_feature_instance() build_info_add_sub_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 ਵਿੱਚ struct ਸਰੋਤ ਦੀ ਇੱਕ ਐਰੇ ਨਿਰਧਾਰਤ ਕਰੋ।
  • ਇੱਕ ਢਾਂਚਾ ਫੀਚਰ_ਪਲੇਟਫਾਰਮ_ਡਾਟਾ ਨਿਰਧਾਰਤ ਕਰੋ, ਇਸਨੂੰ ਸ਼ੁਰੂ ਕਰੋ, ਅਤੇ ਫੀਚਰ_dev.dev.platform_data ਵਿੱਚ ਇੱਕ ਪੁਆਇੰਟਰ ਸਟੋਰ ਕਰੋ
• build_info_commit_dev()
  • struct cci_drvdata.port_dev_list ਵਿੱਚ ਪੋਰਟਾਂ ਦੀ ਸੂਚੀ ਵਿੱਚ ਪੋਰਟ ਲਈ struct feature_platform_data.node ਸ਼ਾਮਲ ਕਰੋ
• create_feature_instance() build_info_add_sub_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()
  • ਫੀਚਰ_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()
  • ਫੀਚਰ_dev.resource[id] ਸ਼ੁਰੂ ਕਰੋ।
• ਫੀਚਰ_ਪਲੇਟਫਾਰਮ_ਡਾਟਾ_ਐਡ()
  • ਫੀਚਰ_ਪਲੇਟਫਾਰਮ_ਡਾਟਾ. ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ[id] ਸ਼ੁਰੂ ਕਰੋ, .fops ਤੋਂ ਇਲਾਵਾ ਸਭ ਕੁਝ।
• parse_feature() parse_feature_private() parse_feature_port_private()
• ਜਦੋਂ ਇੱਕ ਪੋਰਟ ਪ੍ਰਾਈਵੇਟ ਵਿਸ਼ੇਸ਼ਤਾ ਦਾ ਸਾਹਮਣਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ: * create_feature_instance() build_info_add_sub_feature() * ਫੀਚਰ_dev.resource[id] ਸ਼ੁਰੂ ਕਰੋ। * ਫੀਚਰ_ਪਲੇਟਫਾਰਮ_ਡਾਟਾ_ਐਡ() ਫੀਚਰ_ਪਲੇਟਫਾਰਮ_ਡਾਟਾ. ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ[id] ਸ਼ੁਰੂ ਕਰੋ, .fops ਤੋਂ ਇਲਾਵਾ ਸਭ ਕੁਝ।
• parse_ports_from_fme()
  • ਜੇਕਰ ਡਰਾਈਵਰ ਫਿਜ਼ੀਕਲ ਫੰਕਸ਼ਨ (PF) 'ਤੇ ਲੋਡ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ:
• FME ਸਿਰਲੇਖ ਵਿੱਚ ਵਰਣਿਤ ਹਰੇਕ ਪੋਰਟ 'ਤੇ parse_feature_list() ਪ੍ਰਵਾਹ ਚਲਾਓ।
• ਸਿਰਲੇਖ ਵਿੱਚ ਹਰੇਕ ਪੋਰਟ ਐਂਟਰੀ ਵਿੱਚ ਦਰਸਾਏ ਗਏ ਬਾਰ ਦੀ ਵਰਤੋਂ ਕਰੋ।

FME ਪਲੇਟਫਾਰਮ ਡਿਵਾਈਸ ਸ਼ੁਰੂਆਤੀ
ਇਹ ਭਾਗ ਇੱਕ ਓਵਰ ਦਿੰਦਾ ਹੈview intel-fpga-fme.ko ਦੁਆਰਾ ਕੀਤੇ ਗਏ FME ਡਿਵਾਈਸ ਸ਼ੁਰੂਆਤੀਕਰਣ ਲਈ ਕੋਡ ਪ੍ਰਵਾਹ ਦਾ। ਮੁੱਖ ਡਾਟਾ ਢਾਂਚੇ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਉਜਾਗਰ ਕੀਤਾ ਗਿਆ ਹੈ। ਇਸ ਭਾਗ ਦੀ ਸਭ ਤੋਂ ਵਧੀਆ ਪਾਲਣਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਦੋਂ viewਨਾਲ ਦਿੱਤੇ ਸਰੋਤ ਕੋਡ (fme-main.c) ਨੂੰ ਸ਼ਾਮਲ ਕਰੋ।

FME ਪਲੇਟਫਾਰਮ ਡਿਵਾਈਸ ਡਾਟਾ ਸਟ੍ਰਕਚਰ

struct ਫੀਚਰ_ਓਪਸ {
int (*init)(struct platform_device *pdev, struct ਵਿਸ਼ੇਸ਼ਤਾ *ਵਿਸ਼ੇਸ਼ਤਾ);
int (*uinit)(struct platform_device *pdev, struct ਫੀਚਰ *ਫੀਚਰ);
ਲੰਬੀ (*ioctl)(struct platform_device *pdev, struct ਵਿਸ਼ੇਸ਼ਤਾ *ਵਿਸ਼ੇਸ਼ਤਾ,
ਹਸਤਾਖਰਿਤ int cmd, ਗੈਰ-ਹਸਤਾਖਰਿਤ ਲੰਬੀ ਆਰਗ);
int (*ਟੈਸਟ)(struct platform_device *pdev, struct ਵਿਸ਼ੇਸ਼ਤਾ *ਵਿਸ਼ੇਸ਼ਤਾ);
};
ਸੰਰਚਨਾ ਵਿਸ਼ੇਸ਼ਤਾ {
const char *ਨਾਮ;
int resource_index;
void __iomem *ioaddr;
struct ਫੀਚਰ_ਓਪਸ *ਓਪਸ;
};
struct ਫੀਚਰ_ਪਲੇਟਫਾਰਮ_ਡਾਟਾ {
struct list_head ਨੋਡ;
struct mutex ਲਾਕ;
ਅਣਹਸਤਾਖਰਿਤ ਲੰਬੀ dev_status;
struct cdev cdev;
struct platform_device *dev;
unsigned int 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 id;
const struct ਗੁਣ_ਗਰੁੱਪ **attr_groups;
struct ਡਿਵਾਈਸ *fme_dev;
struct list_head ਨੋਡ;
struct list_head ਬੱਚੇ;
struct kobject kobj;
};
struct fpga_fme {
u8 ਪੋਰਟ_ਆਈਡੀ;
u64 pr_err;
struct ਡਿਵਾਈਸ *dev_err;
struct perf_object *perf_dev;
struct ਫੀਚਰ_ਪਲੇਟਫਾਰਮ_ਡਾਟਾ *ਪੀਡਾਟਾ;
};

FME ਪਲੇਟਫਾਰਮ ਡਿਵਾਈਸ ਸ਼ੁਰੂਆਤੀ ਪ੍ਰਵਾਹ

FME ਸ਼ੁਰੂਆਤੀ ਪ੍ਰਵਾਹ

• fme_probe() fme_dev_init()
  • ਇੱਕ struct fpga_fme ਸ਼ੁਰੂ ਕਰੋ ਅਤੇ ਇਸਨੂੰ ਫੀਚਰ_ਪਲੇਟਫਾਰਮ_ਡਾਟਾ.ਪ੍ਰਾਈਵੇਟ ਖੇਤਰ ਵਿੱਚ ਸਟੋਰ ਕਰੋ।
• fme_probe() fpga_dev_feature_init() feature_instance_init()
  • ਹਰੇਕ ਆਬਾਦੀ ਵਾਲੀ ਵਿਸ਼ੇਸ਼ਤਾ ਲਈ ਫੀਚਰ_ਪਲੇਟਫਾਰਮ_ਡਾਟਾ. ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਿੱਚ ਇੱਕ ਸਟ੍ਰਕਚਰ ਫੀਚਰ_ਓਪਸ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰੋ।
  • ਟੈਸਟ ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰੋ, ਜੇਕਰ ਕੋਈ ਹੈ, ਸਟ੍ਰਕਚਰ ਤੋਂ।
  • init ਫੰਕਸ਼ਨ ਨੂੰ struct ਤੋਂ ਕਾਲ ਕਰੋ।
• fme_probe() fpga_register_dev_ops()
  • FME ਅੱਖਰ ਜੰਤਰ ਨੋਡ ਬਣਾਓ, ਇੱਕ struct ਨੂੰ ਰਜਿਸਟਰ file_ਓਪਰੇਸ਼ਨ

ਪੋਰਟ ਪਲੇਟਫਾਰਮ ਡਿਵਾਈਸ ਸ਼ੁਰੂਆਤੀ
ਇਹ ਭਾਗ ਇੱਕ ਓਵਰ ਦਿੰਦਾ ਹੈview intel-fpga-afu.ko ਦੁਆਰਾ ਕੀਤੇ ਪੋਰਟ ਡਿਵਾਈਸ ਸ਼ੁਰੂਆਤੀਕਰਣ ਲਈ ਕੋਡ ਪ੍ਰਵਾਹ ਦਾ। ਮੁੱਖ ਡਾਟਾ ਢਾਂਚੇ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਉਜਾਗਰ ਕੀਤਾ ਗਿਆ ਹੈ। ਇਸ ਭਾਗ ਦੀ ਸਭ ਤੋਂ ਵਧੀਆ ਪਾਲਣਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਦੋਂ viewਨਾਲ ਸਰੋਤ ਕੋਡ (afu.c) ਦਿਓ।

ਪੋਰਟ ਪਲੇਟਫਾਰਮ ਡਿਵਾਈਸ ਡਾਟਾ ਸਟ੍ਰਕਚਰ

struct ਫੀਚਰ_ਓਪਸ {
int (*init)(struct platform_device *pdev, struct ਵਿਸ਼ੇਸ਼ਤਾ *ਵਿਸ਼ੇਸ਼ਤਾ);
int (*uinit)(struct platform_device *pdev, struct ਫੀਚਰ *ਫੀਚਰ);
ਲੰਬੀ (*ioctl)(struct platform_device *pdev, struct ਵਿਸ਼ੇਸ਼ਤਾ *ਵਿਸ਼ੇਸ਼ਤਾ,
ਹਸਤਾਖਰਿਤ int cmd, ਗੈਰ-ਹਸਤਾਖਰਿਤ ਲੰਬੀ ਆਰਗ);
int (*ਟੈਸਟ)(struct platform_device *pdev, struct ਵਿਸ਼ੇਸ਼ਤਾ *ਵਿਸ਼ੇਸ਼ਤਾ);
};
ਸੰਰਚਨਾ ਵਿਸ਼ੇਸ਼ਤਾ {
const char *ਨਾਮ;
int resource_index;
void __iomem *ioaddr;
struct ਫੀਚਰ_ਓਪਸ *ਓਪਸ;
};
struct ਫੀਚਰ_ਪਲੇਟਫਾਰਮ_ਡਾਟਾ {
struct list_head ਨੋਡ;
struct mutex ਲਾਕ;
ਅਣਹਸਤਾਖਰਿਤ ਲੰਬੀ dev_status;
struct cdev cdev;
struct platform_device *dev;
unsigned int 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 ਫਿਜ਼;
struct list_head ਨੋਡ;
};
struct fpga_afu_dma_region {
u64 user_addr;
u64 ਲੰਬਾਈ;
u64 iova;
struct ਪੰਨਾ ** ਪੰਨੇ;
struct rb_node ਨੋਡ;
bool in_use;
};
struct fpga_afu {
u64 ਖੇਤਰ_ਕਰ_ਆਫਸੈੱਟ;
int num_regions;
u8 num_umsgs;
struct list_head ਖੇਤਰ;
struct rb_root dma_regions;
struct ਫੀਚਰ_ਪਲੇਟਫਾਰਮ_ਡਾਟਾ *ਪੀਡਾਟਾ;
};

ਪੋਰਟ ਪਲੇਟਫਾਰਮ ਡਿਵਾਈਸ ਸ਼ੁਰੂਆਤੀ ਪ੍ਰਵਾਹ

ਪੋਰਟ ਸ਼ੁਰੂਆਤੀ ਪ੍ਰਵਾਹ

• afu_probe() afu_dev_init()
  • ਇੱਕ struct fpga_afu ਸ਼ੁਰੂ ਕਰੋ ਅਤੇ ਇਸਨੂੰ ਫੀਚਰ_ਪਲੇਟਫਾਰਮ_ਡਾਟਾ.ਪ੍ਰਾਈਵੇਟ ਖੇਤਰ ਵਿੱਚ ਸਟੋਰ ਕਰੋ।
• afu_probe() fpga_dev_feature_init() feature_instance_init()
  • ਹਰੇਕ ਆਬਾਦੀ ਵਾਲੀ ਵਿਸ਼ੇਸ਼ਤਾ ਲਈ ਫੀਚਰ_ਪਲੇਟਫਾਰਮ_ਡਾਟਾ. ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਿੱਚ ਇੱਕ ਸਟ੍ਰਕਚਰ ਫੀਚਰ_ਓਪਸ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰੋ।
  • ਟੈਸਟ ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰੋ, ਜੇਕਰ ਕੋਈ ਹੈ, ਸਟ੍ਰਕਚਰ ਤੋਂ।
  • init ਫੰਕਸ਼ਨ ਨੂੰ struct ਤੋਂ ਕਾਲ ਕਰੋ।
• afu_probe() fpga_register_dev_ops()
  • ਪੋਰਟ ਅੱਖਰ ਜੰਤਰ ਨੋਡ ਬਣਾਓ, ਇੱਕ struct ਨੂੰ ਰਜਿਸਟਰ 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; // in: sizeof(struct fpga_fme_port_release)
__u32 ਝੰਡੇ; // ਵਿੱਚ: 0 ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ
__u32 ਪੋਰਟ_ਆਈਡੀ; // ਵਿੱਚ: ਪੋਰਟ ID (0 ਤੋਂ) ਰਿਲੀਜ਼ ਕਰਨ ਲਈ।
};

FPGA_FME_PORT_ASSIGN—arg ਇੱਕ ਪੁਆਇੰਟਰ ਹੈ:

struct 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 ਇੱਕ ਪੁਆਇੰਟਰ ਹੈ:

struct 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 ਇੱਕ ਪੁਆਇੰਟਰ ਹੈ:

struct fpga_port_info {
__u32 argsz; // in: sizeof(struct fpga_port_info)
__u32 ਝੰਡੇ; // ਬਾਹਰ: ਵਾਪਸੀ 0
__u32 ਨੰਬਰ_ਖੇਤਰ; // ਬਾਹਰ: MMIO ਖੇਤਰਾਂ ਦੀ ਸੰਖਿਆ, 2 (1 AFU ਲਈ ਅਤੇ 1 ਲਈ
STP)
__u32 num_umsgs; // ਬਾਹਰ: ਹਾਰਡਵੇਅਰ ਦੁਆਰਾ ਸਮਰਥਿਤ UMsg ਦੀ ਸੰਖਿਆ
};

FPGA_PORT_GET_REGION_INFO—arg ਇੱਕ ਪੁਆਇੰਟਰ ਹੈ:

struct 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 ਇੱਕ ਪੁਆਇੰਟਰ ਹੈ:
struct 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 ਇੱਕ ਪੁਆਇੰਟਰ ਹੈ:
struct 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—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(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 a ਲਈ ਇੱਕ ਸੰਕੇਤਕ ਹੈ:
  struct 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, cat errors > clear
• UMsg ਕੇਵਲ ਏਕੀਕ੍ਰਿਤ FPGA ਦੇ ਨਾਲ Intel Xeon ਪ੍ਰੋਸੈਸਰ ਲਈ ਐਕਸਲਰੇਸ਼ਨ ਸਟੈਕ ਦੁਆਰਾ ਸਮਰਥਿਤ ਹੈ।

sysfs Files

FME ਹੈਡਰ 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 ਥਰਮਲ ਪ੍ਰਬੰਧਨ sysfs files
intel-fpga-dev.i/intel-fpga-fme.j/thermal_mgmt/

sysfs file	mmio ਖੇਤਰ	ਕਿਸਮ	ਪਹੁੰਚ
ਥ੍ਰੈਸ਼ਹੋਲਡ1	thermal.threshold.tmp_thshold1	ਦਸ਼ਮਲਵ int	ਯੂਜ਼ਰ: ਰੀਡ-ਓਨਲੀ ਰੂਟ: ਪੜ੍ਹੋ-ਲਿਖੋ
ਥ੍ਰੈਸ਼ਹੋਲਡ2	thermal.threshold.tmp_thshold2	ਦਸ਼ਮਲਵ int	ਯੂਜ਼ਰ: ਰੀਡ-ਓਨਲੀ ਰੂਟ: ਪੜ੍ਹੋ-ਲਿਖੋ
threshold_trip	thermal.threshold.therm_trip_thshold	ਦਸ਼ਮਲਵ int	ਸਿਰਫ਼ ਪੜ੍ਹਨ ਲਈ
ਥ੍ਰੈਸ਼ਹੋਲਡ1_ਪਹੁੰਚਿਆ	thermal.threshold.thshold1_status	ਦਸ਼ਮਲਵ int	ਸਿਰਫ਼ ਪੜ੍ਹਨ ਲਈ
ਥ੍ਰੈਸ਼ਹੋਲਡ2_ਪਹੁੰਚਿਆ	thermal.threshold.thshold2_status	ਦਸ਼ਮਲਵ int	ਸਿਰਫ਼ ਪੜ੍ਹਨ ਲਈ
threshold1_policy	ਥਰਮਲ threshold.thshold_policy	ਦਸ਼ਮਲਵ int	ਯੂਜ਼ਰ: ਰੀਡ-ਓਨਲੀ ਰੂਟ: ਪੜ੍ਹੋ-ਲਿਖੋ
ਤਾਪਮਾਨ	thermal.rdsensor_fm1.fpga_temp	ਦਸ਼ਮਲਵ int	ਸਿਰਫ਼ ਪੜ੍ਹਨ ਲਈ

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	ਯੂਜ਼ਰ: ਰੀਡ-ਓਨਲੀ ਰੂਟ: ਪੜ੍ਹੋ-ਲਿਖੋ
threshold1_status	power.threshold.threshold1_status	ਦਸ਼ਮਲਵ ਹਸਤਾਖਰਿਤ	ਸਿਰਫ਼ ਪੜ੍ਹਨ ਲਈ
threshold2_status	power.threshold.threshold2_status	ਦਸ਼ਮਲਵ ਹਸਤਾਖਰਿਤ	ਸਿਰਫ਼ ਪੜ੍ਹਨ ਲਈ
rtl	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	ਸਿਰਫ਼ ਪੜ੍ਹਨ ਲਈ
ਸਾਫ਼	ਤਰੁੱਟੀਆਂ ਨੂੰ ਸਾਫ਼ ਕਰਦਾ ਹੈ, ਪਹਿਲੀ_ਤਰੁੱਟੀ, ਅਗਲੀ_ਤਰੁੱਟੀ	ਵੱਖ-ਵੱਖ 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	ਦਸ਼ਮਲਵ int	ਪੜ੍ਹੋ-ਲਿਖੋ
ਪੜ੍ਹੋ_ਹਿੱਟ	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	ਸਿਰਫ਼ ਪੜ੍ਹਨ ਲਈ
ਡਾਟਾ_ਰਾਈਟ_ਪੋਰਟ_ਸੰਬੰਧੀ	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/ (FPGAs ਦੇ ਨਾਲ Intel Xeon CPU ਲਈ ਐਕਸਲਰੇਸ਼ਨ ਸਟੈਕ ਲਈ ਵੈਧ ਨਹੀਂ)

sysfs file	mmio ਖੇਤਰ	ਕਿਸਮ	ਪਹੁੰਚ
ਫ੍ਰੀਜ਼	gperf.vtd_ctl.freeze	ਦਸ਼ਮਲਵ int	ਯੂਜ਼ਰ: ਰੀਡ-ਓਨਲੀ ਰੂਟ: ਪੜ੍ਹੋ-ਲਿਖੋ

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.(ਯੋਗ)	ਦਸ਼ਮਲਵ 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	ਸਿਰਫ਼ ਪੜ੍ਹਨ ਲਈ

ਪੋਰਟ ਹੈਡਰ sysfs files
intel-fpga-dev.i/intel-fpga-port.k/

sysfs file	mmio ਖੇਤਰ	ਕਿਸਮ	ਪਹੁੰਚ
id	port_header.capability.port_number	ਦਸ਼ਮਲਵ int	ਸਿਰਫ਼ ਪੜ੍ਹਨ ਲਈ
ਲਿਟਰ	port_header.control.latency_tolerance	ਦਸ਼ਮਲਵ int	ਸਿਰਫ਼ ਪੜ੍ਹਨ ਲਈ

ਪੋਰਟ 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	ਸਿਰਫ਼ ਪੜ੍ਹਨ ਲਈ
first_malformed_req	pererror.malreq	ਹੈਕਸ 16-ਬਾਈਟ	ਸਿਰਫ਼ ਪੜ੍ਹਨ ਲਈ
ਸਾਫ਼	ਗਲਤੀ। (ਸਾਰੀਆਂ ਗਲਤੀਆਂ)	ਵੱਖ-ਵੱਖ uint64_t	ਸਿਰਫ਼ ਲਿਖੋ

ਨੋਟ:
ਪੋਰਟ ਗਲਤੀਆਂ ਨੂੰ ਸਾਫ਼ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਮੌਜੂਦਾ ਤਰੁਟੀਆਂ ਦਾ ਸਹੀ ਬਿਟਮਾਸਕ ਲਿਖਣਾ ਚਾਹੀਦਾ ਹੈ, ਸਾਬਕਾ ਲਈample ਬਿੱਲੀ ਦੀਆਂ ਗਲਤੀਆਂ > ਸਾਫ਼।

ਸੰਸ਼ੋਧਨ ਇਤਿਹਾਸ

ਦਸਤਾਵੇਜ਼ ਸੰਸਕਰਣ	ਤਬਦੀਲੀਆਂ
2017.10.02	ਸ਼ੁਰੂਆਤੀ ਰਿਲੀਜ਼।

OPAE Intel FPGA Linux ਡਿਵਾਈਸ ਡਰਾਈਵਰ ਆਰਕੀਟੈਕਚਰ ਗਾਈਡ

ਦਸਤਾਵੇਜ਼ / ਸਰੋਤ

intel OPAE FPGA Linux ਡਿਵਾਈਸ ਡਰਾਈਵਰ ਆਰਕੀਟੈਕਚਰ [pdf] ਯੂਜ਼ਰ ਗਾਈਡ OPAE FPGA Linux ਡਿਵਾਈਸ ਡਰਾਈਵਰ ਆਰਕੀਟੈਕਚਰ, OPAE FPGA, ਲੀਨਕਸ ਡਿਵਾਈਸ ਡਰਾਈਵਰ ਆਰਕੀਟੈਕਚਰ, ਡਰਾਈਵਰ ਆਰਕੀਟੈਕਚਰ, ਆਰਕੀਟੈਕਚਰ

ਹਵਾਲੇ

• ਯੂਜ਼ਰ ਮੈਨੂਅਲ