रूसी में EHCI मानवीय रूप से

परिचय

मैं सभी का स्वागत करता हूं। आज मैं अपने अनुभव को साझा करना चाहता हूं और फिर भी, मेरी राय में, पहली नज़र में, यूएसबी 2.0 होस्ट नियंत्रक के लिए एक सरल मानक, इस बारे में स्पष्ट रूप से बताएं।

प्रारंभ में, आप कल्पना कर सकते हैं कि एक यूएसबी 2.0 पोर्ट सिर्फ 4 पिन है, जिनमें से दो बस डेटा संचारित करते हैं (उदाहरण के लिए, एक COM पोर्ट), लेकिन वास्तव में, सब कुछ ऐसा नहीं है, और यहां तक ​​कि इसके विपरीत भी। USB नियंत्रक, सिद्धांत रूप में, हमें नियमित COM पोर्ट के माध्यम से डेटा स्थानांतरित करने की अनुमति नहीं देता है। ईएचसीआई एक बल्कि जटिल मानक है जो विश्वसनीय और तेज डेटा ट्रांसफर को सॉफ्टवेयर से डिवाइस में ही करने की अनुमति देता है, और विपरीत दिशा में।

आपको यह लेख उपयोगी लग सकता है, उदाहरण के लिए, आपके पास ड्राइवरों के लिए पर्याप्त लेखन कौशल और हार्डवेयर के लिए दस्तावेज़ीकरण पढ़ना नहीं है। एक सरल उदाहरण: आप अपने ओएस को एक मिनी-पीसी के लिए लिखना चाहते हैं, ताकि कुछ विंडोज या अन्य लिनक्स वितरण लोहा डाउनलोड न करें, और आप इसकी सभी शक्ति का उपयोग विशेष रूप से अपने स्वयं के प्रयोजनों के लिए करते हैं।

ईएचसीआई क्या है

अच्छा, चलिए शुरू करते हैं। EHCI - एन्हांस्ड होस्ट कंट्रोलर इंटरफ़ेस, USB डिवाइस और अन्य दिशा में डेटा और नियंत्रण अनुरोधों को स्थानांतरित करने के लिए डिज़ाइन किया गया है, और 99% मामलों में यह किसी भी सॉफ़्टवेयर और एक भौतिक डिवाइस के बीच एक लिंक है। EHCI एक PCI डिवाइस के रूप में काम करता है, और तदनुसार नियंत्रक को नियंत्रित करने के लिए MMIO (मेमोरी-मैप्ड-IO) का उपयोग करता है (हाँ, मुझे पता है कि कुछ PCI डिवाइस पोर्ट का उपयोग करते हैं, लेकिन यहां मैंने सब कुछ सामान्य कर दिया है)। इंटेल से प्रलेखन केवल ऑपरेशन के सिद्धांत का वर्णन करता है, और कम से कम छद्म कोड में लिखे गए सभी एल्गोरिदम में कोई संकेत नहीं हैं। EHCI में 2 प्रकार के MMIO रजिस्टर हैं: क्षमता और परिचालन। पूर्व नियंत्रक की विशेषताओं को प्राप्त करने के लिए सेवा करते हैं, जबकि बाद वाले इसे नियंत्रित करने के लिए सेवा करते हैं। वास्तव में, मैं सॉफ्टवेयर और EHCI कंट्रोलर के बीच कनेक्शन का बहुत सार संलग्न करूंगा:



प्रत्येक ईएचसीआई नियंत्रक में कई पोर्ट हैं, जिनमें से प्रत्येक को किसी भी यूएसबी डिवाइस से जोड़ा जा सकता है। इसके अलावा, कृपया ध्यान दें कि ईएचसीआई यूएचसीआई का एक उन्नत संस्करण है, जिसे कुछ साल पहले इंटेल द्वारा भी विकसित किया गया था। पिछड़े संगतता के लिए, कोई भी UHCI / OHCI नियंत्रक जिसका EHCI से कम संस्करण है, EHCI का साथी होगा। उदाहरण के लिए, आपके पास एक USB कीबोर्ड (और वर्ष के अधिकांश कीबोर्ड अभी तक ऐसे ही हैं) जो USB 1.1 पर काम करते हैं (ध्यान दें कि USB 1.1 की अधिकतम गति 12 मेगाबिट प्रति सेकंड है, और FullSpeed ​​USB 2.0 में बैंडविड्थ है जितना अधिक 480 एमबीपीएस), और आपके पास एक यूएसबी 2.0 पोर्ट वाला कंप्यूटर है, जब कीबोर्ड को कंप्यूटर से जोड़ते हैं, तो ईएचसीआई होस्ट नियंत्रक यूएसबी 1.1 के साथ किसी भी तरह से काम करेगा। यह मॉडल निम्नलिखित चित्र में दिखाया गया है:



इसके अलावा, भविष्य के लिए मैं तुरंत चेतावनी देना चाहता हूं कि ऐसी बेतुकी स्थिति के कारण आपका ड्राइवर सही तरीके से काम नहीं कर सकता है: आपने यूएचसीआई को इनिशियलाइज़ किया है, और फिर ईएचसीआई ने दो समान उपकरणों को जोड़ते हुए पोर्ट ओनर कंट्रोल बिट को पोर्ट रजिस्टर में सेट किया है, और फिर यूएचसीआई ने काम करना बंद कर दिया, इस तथ्य के कारण कि ईएचसीआई स्वचालित रूप से पोर्ट को खुद ही ड्रग्स करता है, और यूएचसीआई पर पोर्ट जवाब देना बंद कर देता है, इस स्थिति पर नजर रखने की जरूरत है।

इसके अलावा, आइए EHCI वास्तुकला को दिखाने वाले आरेख को स्वयं देखें:



दाईं ओर कतार के बारे में लिखा है - उनके बारे में थोड़ी देर बाद।

EHCI नियंत्रक पंजीकृत करता है

शुरू करने के लिए, मैं एक बार फिर स्पष्ट करना चाहता हूं कि इन रजिस्टरों के माध्यम से आप अपने डिवाइस को नियंत्रित करेंगे, इसलिए वे बहुत महत्वपूर्ण हैं - और उनके बिना ईएचसीआई प्रोग्रामिंग असंभव है।

पहले आपको MMIO पता प्राप्त करने की आवश्यकता है जो कि इस कंट्रोलर को दिया गया है, ऑफसेट + 0x10 पर हमारे लंबे समय से प्रतीक्षित रजिस्टरों का पता होगा। एक बात है: पहले, क्षमता रजिस्टर जाते हैं, और उनके बाद ही - ऑपरेशनल, इसलिए, ऑफसेट 0 पर (पिछले पते से जो हमें हमारे EHCI के MMIO की शुरुआत के सापेक्ष ऑफसेट 0x10 पर प्राप्त हुआ है) एक बाइट है - क्षमता रजिस्टरों की लंबाई।

क्षमता रजिस्टर

ऑफ़सेट 2 में, HCIVERSION रजिस्टर स्थित है - इस HC की संशोधन संख्या, जिसमें 2 बाइट्स हैं और इसमें संशोधन का BCD संस्करण (जो BCD विकिपीडिया पर पाया जा सकता है) शामिल है।
ऑफसेट +4 पर, HCSPARAMS रजिस्टर स्थित है , इसका आकार 2 शब्द है, इसमें डिवाइस के संरचनात्मक पैरामीटर शामिल हैं और इसके बिट्स निम्न दर्शाते हैं:

• बिट 16 - पोर्ट संकेतक - कनेक्टेड यूएसबी उपकरणों के लिए उपलब्ध एलईडी।
• 15:12 बिट्स - इस नियंत्रक को सौंपे गए साथी नियंत्रक की संख्या
• बिट्स 11: 8 - साथी नियंत्रक पर बंदरगाहों की संख्या
• बिट 7 - पोर्ट रूटिंग नियम - दिखाता है कि इन बंदरगाहों को साथी बंदरगाहों पर कैसे मैप किया जाता है
• बिट 4 - पोर्ट पावर कंट्रोल - इंगित करता है कि क्या प्रत्येक पोर्ट को पावर चालू करना आवश्यक है, 0 - पावर स्वचालित रूप से आपूर्ति की जाती है
• बिट्स 3: 0 - इस नियंत्रक के लिए बंदरगाहों की संख्या।
• ऑफसेट +8 में HCCPARAMS रजिस्टर निहित है - यह अनुकूलता मापदंडों को दर्शाता है, इसके बिट्स का अर्थ निम्न है:
• बिट 2 - अतुल्यकालिक कतार उपलब्धता,
• बिट 1 - आवधिक (अनुक्रमिक) कतार उपलब्धता
• बिट 0 - 64 बिट संगतता

ऑपरेशन रजिस्टर

ऑफ़सेट 0 पर, USBCMD रजिस्टर कंट्रोलर का कमांड रजिस्टर है, इसके बिट्स का मतलब निम्न है:

• बिट्स 23:16 - इंटरप्ट थ्रेशोल्ड कंट्रोल - दिखाता है कि एक नियमित फ्रेम के लिए कितने माइक्रो-फ्रेम का उपयोग किया जाएगा। बड़ा, तेज, लेकिन यदि 8 से अधिक है, तो माइक्रो-फ्रेम को 8 के लिए उसी गति से संसाधित किया जाएगा।
• बिट 6 - अतुल्यकालिक कतार में प्रत्येक लेनदेन के बाद रुकावट,
• बिट 5 - अतुल्यकालिक कतार का उपयोग किया जाता है
• बिट 4 - अनुक्रमिक कतार का उपयोग,
• बिट्स 3: 2 - फ्रेमलिस्ट का आकार (उस पर बाद में)। 0 का अर्थ है 1024 तत्व, 1 - 512, 2 - 256, 3 - आरक्षित
• बिट 1 - मेजबान नियंत्रक को रीसेट करने के लिए सेट करें।
• बिट 0 - रन / स्टॉप

।
अगला, ऑफसेट +4 पर, USBSTS रजिस्टर है - मेजबान नियंत्रक की स्थिति,

• बिट 15 इंगित करता है कि क्या एक अतुल्यकालिक कतार का उपयोग किया जा रहा है।
• बिट 14 इंगित करता है कि क्या अनुक्रमिक कतार का उपयोग किया जा रहा है,
• बिट 13 - इंगित करता है कि एक खाली अतुल्यकालिक कतार का पता चला है,
• बिट 12 को 1 पर सेट किया जाता है, यदि लेनदेन को संसाधित करते समय कोई त्रुटि हुई, तो मेजबान नियंत्रक सभी कतारों को रोक देगा।
• बिट 4 को 1 पर सेट किया जाता है, यदि कोई गंभीर त्रुटि होती है, तो होस्ट कंट्रोलर सभी कतारों को रोक देता है।
• बिट 3 फ्रेमलिस्ट (रजिस्टर) रोलओवर - 1 पर सेट जब होस्ट कंट्रोलर ने पूरे फ्रेमलिस्ट को संसाधित किया।
• बिट 1 - USB त्रुटि बाधा - क्या मैं एक त्रुटि अवरोध उत्पन्न करता हूं?
• बिट 0 - यूएसबी इंटरप्ट - सफल लेनदेन प्रसंस्करण के बाद सेट, अगर आईओडी टीडी में स्थापित किया गया था

नहीं थका? आप अपने आप को एक मजबूत सीगल डाल सकते हैं और जिगर ला सकते हैं, हम बहुत शुरुआत में हैं!

ऑफसेट +8 पर, एक USBINTR रजिस्टर है - इंटरप्ट इनेबल्ड रजिस्टर
लंबे समय तक नहीं लिखने के लिए, और इससे भी अधिक, आपके द्वारा लंबे समय तक नहीं पढ़ने के लिए, इस रजिस्टर के बिट्स के मान विनिर्देश में पाए जा सकते हैं, इसके लिए एक लिंक नीचे छोड़ दिया जाएगा। यहाँ मैं सिर्फ 0 लिखता हूँ, क्योंकि मुझे हैंडलर, मैप इंटरप्ट आदि लिखने की बिल्कुल इच्छा नहीं है, इसलिए मुझे लगता है कि यह लगभग पूरी तरह से व्यर्थ है।

ऑफसेट +12 (0x0C) पर, FRINDEX रजिस्टर स्थित है , जिसमें वर्तमान फ्रेम नंबर बस झूठ है, और मैं यह नोट करना चाहता हूं कि पिछले 4 बिट्स माइक्रो-फ्रेम नंबर दिखाते हैं, ऊपरी 28 बिट्स में फ्रेम नंबर (समान मूल्य आवश्यक रूप से फ्रेमलिस्ट आकार से कम नहीं है) लेकिन अगर आपको एक सूचकांक की आवश्यकता है, तो इसे 0x3FF (या 0x1FF, आदि) के मुखौटा के साथ लेना बेहतर है।

CTRLDSSEGMENT रजिस्टर ऑफसेट + 0x10 पर है, यह होस्ट कंट्रोलर को फ्रेम शीट के पते के सबसे महत्वपूर्ण 32 बिट्स दिखाता है।

PERIODICLISTBASE रजिस्टर में + 0x14 की एक ऑफसेट है, आप फ्रेम शीट के निचले 32 बिट्स को इसमें डाल सकते हैं, ध्यान दें कि पता को स्मृति पृष्ठ (4096) के आकार में संरेखित किया जाना चाहिए।

ASYNCLISTADDR रजिस्टर में + 0x18 की ऑफसेट है, आप इसमें एसिंक्रोनस कतार का पता डाल सकते हैं, ध्यान दें कि इसे 32 बाइट्स की सीमा में गठबंधन किया जाना चाहिए, जबकि यह भौतिक मेमोरी के पहले गीगाबाइट में होना चाहिए।

CONFIGFLAG रजिस्टर इंगित करता है कि डिवाइस कॉन्फ़िगर किया गया है या नहीं। डिवाइस सेटअप पूरा करने के बाद आपको बिट 0 सेट करना होगा, इसमें ऑफ़सेट 0x40 है।

पोर्ट रजिस्टरों पर चलते हैं। प्रत्येक पोर्ट का अपना कमांड-स्टेटस रजिस्टर है, प्रत्येक पोर्ट रजिस्टर ऑफसेट + 0x44 + (पोर्टनंबर - 1) * 4 है , इसके बिट्स का मतलब निम्न है:

• बिट 12 - पोर्ट पावर, 1 - बिजली की आपूर्ति की जाती है, 0 - नहीं।
• बिट 8 - पोर्ट रेस्ट - डिवाइस को रीसेट करने के लिए सेट किया गया है।
• 3 बिट - पोर्ट इनेबल / डिसेबल चेंज - पोर्ट के "इन्क्लूजन" का स्टेटस बदलते समय सेट करें।
• बिट 2 - पोर्ट ऑन / ऑफ।
• बिट 1 - कनेक्शन की स्थिति बदलें, 1 पर सेट है, उदाहरण के लिए, यदि आप एक यूएसबी डिवाइस से कनेक्ट या डिस्कनेक्ट हो गए हैं।
• बिट 0 - कनेक्शन स्थिति, 1 - जुड़ा हुआ, 0 - नहीं।

अब जूस पर ही चलते हैं।

डेटा ट्रांसफर और क्वेरी संरचनाएँ

प्रसंस्करण अनुरोधों के लिए एक संरचना के आयोजन में कतारों और हस्तांतरण विवरणकों (टीडीएस) शामिल हैं।

फिलहाल, हम केवल 3 संरचनाओं पर विचार करेंगे।

अनुक्रमिक सूची

अनुक्रमिक (आवधिक, पेरियोडिक) सूची इस प्रकार है:



जैसा कि आप आरेख में देख सकते हैं, प्रसंस्करण शीट फ्रेम से वांछित फ्रेम प्राप्त करने के साथ शुरू होता है, इसके प्रत्येक तत्व में 4 बाइट्स होते हैं और निम्नलिखित संरचना होती है:



जैसा कि आप चित्र में देख सकते हैं, कतार का पता / डिस्क्रिप्टर स्थानांतरण 32 बाइट्स की सीमा पर संरेखित है, बिट 0 का मतलब है कि मेजबान नियंत्रक इस तत्व को संसाधित नहीं करेगा, बिट्स 3: 1 संकेत करता है कि मेजबान नियंत्रक क्या प्रक्रिया करेगा: 0: isosynchronous TD (iTD), 1 - बारी, 2 और 3 इस लेख में मैं विचार नहीं करूंगा।

अतुल्यकालिक कतार

होस्ट कंट्रोलर इस कतार को तभी प्रोसेस करता है जब अनुक्रमिक फ्रेम खाली हो या होस्ट कंट्रोलर ने पूरी सीरियल लिस्ट को प्रोसेस कर दिया हो।

एक अतुल्यकालिक कतार एक कतार का एक संकेतक है जिसमें अन्य कतारें होती हैं जिन्हें प्रसंस्करण की आवश्यकता होती है। ड्राइविंग:

qTD (कतार तत्व स्थानांतरण डिस्क्रिप्टर)

इस टीडी में निम्नलिखित संरचना है:



अगला qTD पॉइंटर - प्रोसेसिंग के लिए कतार की निरंतरता के लिए एक सूचक (क्षैतिज निष्पादन के लिए), बिट 0 अगला qTD सूचक इंगित करता है कि आगे कोई कतार नहीं है।
qTD टोकन - टीडी टोकन, डेटा ट्रांसफर मापदंडों को दर्शाता है:

• बिट 31 - डेटा टॉगल (उस पर बाद में)
• बिट्स 30:16 - हस्तांतरण के लिए डेटा की मात्रा, लेनदेन के पूरा होने के बाद, स्थानांतरित किए गए डेटा की मात्रा से उनका मूल्य घट जाता है।
• बिट 15 - आईओसी - इंटरप्ट ऑन पूर्ण - डिस्क्रिप्टर प्रोसेसिंग पूरा होने के बाद रुकावट।
• बिट्स 14:12 वर्तमान बफ़र की संख्या को / जिससे डेटा का आदान-प्रदान होता है, इस पर बाद में दिखाता है।
• 11:10 बिट्स - त्रुटियों की अनुमति दी संख्या। जब त्रुटि गिनती कम हो जाती है तो यह तालिका दिखाती है:
  
  
  
  फुटनोट 1 - या तो बब्बल या स्टाल का पता लगाना स्वचालित रूप से कतार प्रमुख के निष्पादन को रोक देता है। फुटनोट 3 - डेटा बफ़र त्रुटियाँ होस्ट के साथ समस्याएँ हैं। वे डिवाइस रिट्रीट का हिसाब नहीं रखते हैं।
• 9: 8 - पीआईडी ​​कोड - टोकन का प्रकार: 0 - इनपुट से टोकन (डिवाइस से होस्ट तक), 1 - आउटपुट से टोकन (डिवाइस से होस्ट तक), 2 - "सेटअप" टोकन
• बिट्स 7: 0 टीडी स्थिति को दर्शाता है:
  बिट 7 इंगित करता है कि टीडी एक सक्रिय स्थिति में है (यानी, मेजबान नियंत्रक इस टीडी को संसाधित करता है)
  बिट 6 - रुकावट - इंगित करता है कि एक त्रुटि हुई है और टीडी निष्पादन बंद हो गया है।
  बिट 4 - बब्बल का पता लगाया - उस डेटा की मात्रा जिसे हमने डिवाइस पर भेजा था, या प्रति क्रांति, हम जो संचारित करते हैं, उससे कम है, उदाहरण के लिए, डिवाइस ने हमें 100 बाइट डेटा भेजा, और हम केवल 50 बाइट्स पढ़ते हैं, और फिर एक और 50 यदि इस बिट को 1 पर सेट किया गया है तो हॉल्टेड बिट भी सेट किया जाएगा।
  3 बिट - लेनदेन त्रुटि - लेन-देन के दौरान एक त्रुटि हुई।

qTD बफ़र पेज पॉइंटर सूची - 5 बफ़र्स में से कोई भी। इसमें एक लिंक होता है जहां मेमोरी में लेन-देन किया जाना चाहिए (डिवाइस से डेटा भेजें / डिवाइस से डेटा प्राप्त करें), बफ़र्स में सभी पते, पहले को छोड़कर, पृष्ठ के आकार (4096 बाइट्स) के लिए संरेखित होना चाहिए।

रेखा के प्रमुख

कतार प्रमुख की निम्नलिखित संरचना है:



कतार सिर क्षैतिज लिंक सूचक - अगली कतार के सूचक, बिट्स 2: 1 में कतार के प्रकार के आधार पर निम्नलिखित मान हैं:



समापन बिंदु क्षमताएँ / विशेषताएँ - कतार विशेषताएँ:

• 26:16 बिट्स में संचरण के लिए अधिकतम पैकेट आकार होता है
• बिट 14: डेटा टॉगल कंट्रोल - दिखाता है कि होस्ट कंट्रोलर को शुरुआती डेटा टॉगल वैल्यू कहां लेनी चाहिए, 0 - क्यूटीटी में डीटी बिट को अनदेखा करता है, क्यू हेड के लिए डीटी बिट को बचाता है।
• बिट 13:12 - संचरण दर विशेषताएं:
• बिट्स 11: 8 - अंतिम बिंदु की संख्या जिस पर अनुरोध किया गया है
• बिट्स 6: 0 - डिवाइस पता

समापन बिंदु क्षमताएं: कतार प्रमुख DWORD 2 - पिछले दोहरे शब्द की निरंतरता:

• बिट्स 29:23 - हब नंबर
• बिट्स 22:16 - हब एड्रेस

वर्तमान qTD लिंक सूचक - वर्तमान qTD को सूचक।

हम सबसे दिलचस्प से गुजरते हैं।

EHCI ड्राइवर

आइए शुरू करें कि ईएचसीआई किन प्रश्नों को पूरा कर सकता है। अनुरोध के 2 प्रकार हैं: नियंत्रण - एक ला कमांड, और बल्क - एंडपॉइंट्स के लिए, डेटा एक्सचेंज के लिए, उदाहरण के लिए, यूएसबी फ्लैश ड्राइव (यूएसबी मासस्टेज) के विशाल बहुमत डेटा ट्रांसफर प्रकार बल्क / बल्क / बल्क का उपयोग करते हैं। माउस और कीबोर्ड डेटा ट्रांसफर के लिए बल्क अनुरोधों का भी उपयोग करते हैं।

EHCI को प्रारंभ करें और अतुल्यकालिक और अनुक्रमिक कतारों को कॉन्फ़िगर करें:

// Base I/O Address PciBar bar; PciGetBar(&bar, id, 0); EhciController *hc = VMAlloc(sizeof(EhciController)); hc->capRegs = (EhciCapRegs *)(uintptr_t)bar.u.address; hc->opRegs = (EhciOpRegs *)(uintptr_t)(bar.u.address + hc->capRegs->capLength); // Read the Command register //    uint cmd = ROR(usbCmdO); // Write it back, setting bit 2 (the Reset bit) //   ,   2(Reset) // and making sure the two schedule Enable bits are clear. //  ,  2   WOR(usbCmdO, 2 | cmd & ~(CMD_ASE | CMD_PSE)); // A small delay here would be good. You don't want to read //     ,     // the register before it has a chance to actually set the bit //   ,         ROR(usbCmdO); // Now wait for the controller to clear the reset bit. //      Reset while (ROR(usbCmdO) & 2); // Again, a small delay here would be good to allow the // reset to actually become complete. //   ROR(usbCmdO); // wait for the halted bit to become set //    Halted    while (!(ROR(usbStsO) & STS_HCHALTED)); //     ,        // ,           128  hc->frameList = (u32 *)VMAlloc(1024 * sizeof(u32) + 8192 * 4); hc->frameList = (((uint)hc->frameList) / 16384) * 16384 + 16384; hc->qhPool = (EhciQH *)VMAlloc(sizeof(EhciQH) * MAX_QH + 8192 * 4); hc->tdPool = (EhciTD *)VMAlloc(sizeof(EhciTD) * MAX_TD + 8192 * 4); hc->qhPool = (((uint)hc->qhPool) / 16384) * 16384 + 16384; hc->tdPool = (((uint)hc->tdPool) / 16384) * 16384 + 16384; // Asynchronous queue setup //    EhciQH *qh = EhciAllocQH(hc); //     ,      // ,    qh->qhlp = (u32)(uintptr_t)qh | PTR_QH; //  ,  ,     qh->ch = QH_CH_H; qh->caps = 0; qh->curLink = 0; qh->nextLink = PTR_TERMINATE; qh->altLink = 0; qh->token = 0; //    for (uint i = 0; i < 5; ++i) { qh->buffer[i] = 0; qh->extBuffer[i] = 0; } hc->asyncQH = qh; // Periodic list queue setup //    qh = EhciAllocQH(hc); //     qh->qhlp = PTR_TERMINATE; qh->ch = 0; qh->caps = 0; qh->curLink = 0; qh->nextLink = PTR_TERMINATE; qh->altLink = 0; qh->token = 0; //   for (uint i = 0; i < 5; ++i) { qh->buffer[i] = 0; qh->extBuffer[i] = 0; } qh->transfer = 0; qh->qhLink.prev = &qh->qhLink; qh->qhLink.next = &qh->qhLink; hc->periodicQH = qh; //        for (uint i = 0; i < 1024; ++i) hc->frameList[i] = PTR_QH | (u32)(uintptr_t)qh; kprintf("FrameList filled. Turning off Legacy BIOS support..."); // Check extended capabilities //  BIOS Legacy support uint eecp = (RCR(hccParamsO) & HCCPARAMS_EECP_MASK) >> HCCPARAMS_EECP_SHIFT; if (eecp >= 0x40) { // Disable BIOS legacy support uint legsup = PciRead32(id, eecp + USBLEGSUP); kprintf("."); if (legsup & USBLEGSUP_HC_BIOS) { PciWrite32(id, eecp + USBLEGSUP, legsup | USBLEGSUP_HC_OS); kprintf("."); for (;;) { legsup = PciRead32(id, eecp + USBLEGSUP); kprintf("."); if (~legsup & USBLEGSUP_HC_BIOS && legsup & USBLEGSUP_HC_OS) { break; } } } } kprintf("Done\n"); // Disable interrupts //   //hc->opRegs->usbIntr = 0; MWIR(ehcibase, usbIntrO, 0); // Setup frame list //     //hc->opRegs->frameIndex = 0; WOR(frameIndexO, 0); //hc->opRegs->periodicListBase = (u32)(uintptr_t)hc->frameList; WOR(periodicListBaseO, (u32)(uintptr_t)hc->frameList); //       //hc->opRegs->asyncListAddr = (u32)(uintptr_t)hc->asyncQH; WOR(asyncListAddrO, (u32)(uintptr_t)hc->asyncQH); //    0 //hc->opRegs->ctrlDsSegment = 0; WOR(ctrlDsSegmentO, 0); // Clear status //   //hc->opRegs->usbSts = ~0; WOR(usbStsO, ~0); // Enable controller //  , 8 -,  //     //hc->opRegs->usbCmd = (8 << CMD_ITC_SHIFT) | CMD_PSE | CMD_ASE | CMD_RS; WOR(usbCmdO, (8 << CMD_ITC_SHIFT) | CMD_PSE | CMD_ASE | CMD_RS); while (ROR(usbStsO)&STS_HCHALTED); // Configure all devices to be managed by the EHCI // ,   //hc->opRegs->configFlag = 1; WOR(configFlagO, 1);\ // Probe devices //   EhciProbe(hc); 

दरअसल, पोर्ट को उसकी मूल स्थिति में रीसेट करने के लिए कोड:

  volatile u32 *reg = &hc->opRegs->ports[port]; //    ,  100 *reg|=(1<<12)|(1<<20); Wait(100); //  ,  50  EhciPortSet(reg, PORT_RESET | (1<<12) | (1<<20) | (1<<6)); Wait(50); EhciPortClr(reg, PORT_RESET); // Wait 100ms for port to enable (TODO - what is appropriate length of time?) //  100    ,   , //  100    uint status = 0; for (uint i = 0; i < 10; ++i) { // Delay Wait(10); // Get current status //    status = *reg; // Check if device is attached to port //      if (~status & PORT_CONNECTION) break; // Acknowledge change in status //    -    if (status & (PORT_ENABLE_CHANGE | PORT_CONNECTION_CHANGE)) { EhciPortClr(reg, PORT_ENABLE_CHANGE | PORT_CONNECTION_CHANGE); continue; } // Check if device is enabled //    ,    if (status & PORT_ENABLE) break; } return status; 

डिवाइस के लिए नियंत्रण अनुरोध:

 static void EhciDevControl(UsbDevice *dev, UsbTransfer *t) { EhciController *hc = (EhciController *)dev->hc; UsbDevReq *req = t->req; // Determine transfer properties //    uint speed = dev->speed; uint addr = dev->addr; uint maxSize = dev->maxPacketSize; uint type = req->type; uint len = req->len; // Create queue of transfer descriptors //   TDs EhciTD *td = EhciAllocTD(hc); if (!td) return; EhciTD *head = td; EhciTD *prev = 0; // Setup packet //   uint toggle = 0; uint packetType = USB_PACKET_SETUP; uint packetSize = sizeof(UsbDevReq); EhciInitTD(td, prev, toggle, packetType, packetSize, req); prev = td; // Data in/out packets packetType = type & RT_DEV_TO_HOST ? USB_PACKET_IN : USB_PACKET_OUT; u8 *it = (u8 *)t->data; u8 *end = it + len; //EhciPrintTD(td); while (it < end) { td = EhciAllocTD(hc); if (!td) return; toggle ^= 1; packetSize = end - it; if (packetSize > maxSize) packetSize = maxSize; EhciInitTD(td, prev, toggle, packetType, packetSize, it); it += packetSize; prev = td; } // Status packet //   td = EhciAllocTD(hc); if (!td) return; toggle = 1; packetType = type & RT_DEV_TO_HOST ? USB_PACKET_OUT : USB_PACKET_IN; EhciInitTD(td, prev, toggle, packetType, 0, 0); // Initialize queue head //   : EhciQH *qh = EhciAllocQH(hc); EhciInitQH(qh, t, head, dev->parent, false, speed, addr, 0, maxSize); // Wait until queue has been processed //       EhciInsertAsyncQH(hc->asyncQH, qh); EhciWaitForQH(hc, qh); } 

कतार प्रसंस्करण कोड:

  if (qh->token & TD_TOK_HALTED) { t->success = false; t->complete = true; } else if (qh->nextLink & PTR_TERMINATE) if (~qh->token & TD_TOK_ACTIVE) { if (qh->token & TD_TOK_DATABUFFER) kprintf(" Data Buffer Error\n"); if (qh->token & TD_TOK_BABBLE) kprintf(" Babble Detected\n"); if (qh->token & TD_TOK_XACT) kprintf(" Transaction Error\n"); if (qh->token & TD_TOK_MMF) kprintf(" Missed Micro-Frame\n"); t->success = true; t->complete = true; } if (t->complete) .... 

और अब समापन बिंदु अनुरोध (थोक अनुरोध)

 static void EhciDevIntr(UsbDevice *dev, UsbTransfer *t) { EhciController *hc = (EhciController *)dev->hc; // Determine transfer properties //    uint speed = dev->speed; uint addr = dev->addr; uint maxSize = t->endp->desc->maxPacketSize; uint endp = t->endp->desc->addr & 0xf; EhciTD *td = EhciAllocTD(hc); if (!td) { t->success = false; t->complete = true; return; } EhciTD *head = td; EhciTD *prev = 0; // Data in/out packets uint toggle = t->endp->toggle; uint packetType = t->endp->desc->addr & 0x80 ? USB_PACKET_IN : USB_PACKET_OUT; uint packetSize = t->len; EhciInitTD(td, prev, toggle, packetType, packetSize, t->data); // Initialize queue head //    EhciQH *qh = EhciAllocQH(hc); EhciInitQH(qh, t, head, dev->parent, true, speed, addr, endp, maxSize); //printQh(qh); // Schedule queue //    EhciInsertPeriodicQH(hc->periodicQH, qh); } 

मुझे लगता है कि विषय काफी दिलचस्प है, रूसी में इंटरनेट पर इस विषय पर लगभग कोई प्रलेखन, विवरण और लेख नहीं हैं, और यदि है, तो यह बहुत धुंधला है। यदि हार्डवेयर और ओएस विकास के साथ काम करने का विषय दिलचस्प है, तो बहुत कुछ बताना है।

डॉक्स: विशिष्टता