कस्टम लिनक्स ड्राइवर बनाना

मेरे कई दोस्त और परिचित मेरे मंदिर में उंगली घुमा रहे हैं या सोच रहे हैं कि क्या मेरी खोपड़ी निचोड़ रही है जब उन्हें पता चला कि मैं लिनक्स के लिए ड्राइवर लिखता हूं। शब्द "चालक" कुछ लगभग रहस्यमय अर्थ में डूबा हुआ है, और केवल चयनित गुरु ही इसके लेखन के ताओ को समझ सकते हैं।
सौभाग्य से, ऐसा नहीं है। मुझे पता नहीं है कि अन्य ऑपरेटिंग सिस्टम के लिए लिखने वाले ड्राइवरों के साथ चीजें कैसी हैं, सहित और सबसे लोकप्रिय, लेकिन ड्राइवर के हार्डवेयर आर्किटेक्चर की परवाह किए बिना, लिनक्स के तहत, वे बहुत सरल रूप से लिखे गए हैं। ड्राइवर लिखने के लिए, आपको सी भाषा का बुनियादी ज्ञान, लिनक्स ऑपरेटिंग सिस्टम (बुनियादी) की समझ, हमें जो कुछ भी प्राप्त करना है, उसकी एक समझ, प्रलेखन और स्रोत कोड पढ़ने की इच्छा और दृढ़ता की आवश्यकता है। वह सब है।
क्या आप देखना चाहते हैं कि अपने डिवाइस के लिए ड्राइवर कैसे लिखें? फिर बिल्ली के नीचे गोता!

ड्राइवरों को लिखने में आसानी इस तथ्य से समझाई जाती है कि लिनक्स स्रोत कोड शानदार दस्तावेज है और स्रोतों में उपलब्ध है, नेट पर बहुत सारे उदाहरण हैं और बहुत सारे साहित्य हैं। एक ड्राइवर बनाने के लिए, आपको केवल अपने पसंदीदा वितरण किट और कर्नेल स्रोतों की आवश्यकता होती है, और आपके लिए आवश्यक आर्किटेक्चर के लिए कंपाइलर। मैंने अपना पहला, प्रशिक्षण नहीं, पावरपीसी 8360 प्रोसेसर के लिए ड्राइवर लिखा, इसने FPGA चिप के साथ बातचीत की और डिफ़ॉल्ट सेटिंग्स को रीसेट किया। अजीब जैसा कि यह लगता है, मैंने इसे इस वास्तुकला के लिए एसपीआई ड्राइवर को फिर से लिखकर किया। मैं इस तथ्य से कहता हूं कि लिनक्स कर्नेल में प्रोग्राम लिखने का एक समान मानकीकरण ऐसी चीजों को करने की अनुमति देता है।
लिनक्स ड्राइवर ड्राइवर की हैंडबुक "लिनक्स डिवाइस ड्राइवर" है। पुस्तक विकास के लिए एक विस्तृत मार्गदर्शिका है और यदि पुस्तक में कुछ गायब है, तो आप निश्चित रूप से इसे कर्नेल स्रोत में पा सकते हैं। बेशक, इस पोस्ट ने इस अद्भुत पुस्तक को बदलने का नाटक नहीं किया है। इसके अलावा, यह इन कार्यों के पढ़ने के आधार पर लिखा गया था, लेकिन फिर भी यह इस पुस्तक का संक्षिप्त विवरण नहीं है। इन पंक्तियों के लेखक का उद्देश्य लिनक्स की सादगी और अनुग्रह में पाठक को दिलचस्पी देना है, और लोगों के लिए ड्राइवर विकास में प्रवेश करने के लिए सीमा को कम करना है। विश्वास करो - यह बहुत सरल है!

हम ड्राइवर के लिए क्या लिखेंगे

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

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

तो, हमें एक एलपीटी पोर्ट की आवश्यकता है; एक पुराने प्रिंटर के लिए एक कॉर्ड और वैकल्पिक रूप से एक 36-पिन CENTRONICS कनेक्टर, हालांकि आप बस केबल को अनपैक कर सकते हैं; बेशक, HD44780 पारिवारिक स्क्रीन, सबसे कम से कम 4x40 वर्ण हैं, हालांकि सबसे छोटे लोग भी करेंगे; ठीक है, इसके विपरीत समायोजित करने के लिए, 10 kOhm का एक वैरिएबल रेज़िस्टर। चूँकि मेरे पास एक एलपीटी पोर्ट बहुत पहले से था, इसलिए मैंने पहला पीसीआई कार्ड खरीदा था जो मुझे आया था (आप पीसीआई-ई का उपयोग भी कर सकते हैं)। इसके अलावा, बोर्ड इतने अधिक चीनी में आया कि मुझे इस पर टांका लगाने वाली चिप पर कोई दस्तावेज भी नहीं मिला। कुछ नहीं, हम इसे भी उलट देंगे :))))।


हार्डवेयर स्रोत

हम मानते हैं कि इन घटकों को प्राप्त करना मुश्किल नहीं था, और आपके हाथ सब कुछ करने के लिए अधीरता के साथ जल रहे हैं।

चेतावनी !!!
ध्यान से पढ़ें!

मैं यह संकेत देना चाहता हूं कि हम सबसे कठिन परिस्थितियों में काम करते हैं, लोहे के साथ, और हम मुख्य स्तर पर भी काम करेंगे। हम रहते हैं, इसलिए रोगी के अंदर बोलना है। कार्यक्रम में कोई त्रुटि और कर्नेल क्रैश। जिस समय यह कर्नेल_पनिक को लहराने का समय नहीं भी हो सकता है, बस अचानक सब कुछ काम करना बंद कर देता है। कृपया ध्यान दें कि आपने ड्राइवर को शुरू किया था, इसे उतार दिया, और अचानक अंतर्निहित गड़बड़ शुरू हो गया - यही वह है, आपका रास्ता रिबूट हो रहा है। यदि सिस्टम जीवित है, तो रिबूट कमांड। यदि पहले से नहीं है, तो हार्डवेयर रीसेट करें। हालांकि गंभीर मामलों में, कभी-कभी सिस्टम खुद को रिबूट कर सकता है।

साथ ही, यदि आप नहीं जानते कि आप क्या कर रहे हैं (पोर्ट पर लिख रहे हैं, मेमोरी क्षेत्रों तक पहुंच आदि), तो ऐसा न करना बेहतर है। इस सब के लिए, सबसे अच्छी तरह से, यह सेटिंग्स को नीचे गिरा सकता है (x86 में BIOS को रीसेट करने के लिए उपयोग किए जाने वाले पोर्ट 70h के लिए गलत मान) या यहां तक ​​कि उपकरण को बर्बाद कर सकता है (उदाहरण के लिए, जमीन पर GPIO पैर रखकर)। इसलिए, स्पष्ट रूप से समझें कि आप क्या कर रहे हैं, हार्डवेयर और सॉफ्टवेयर दोनों स्तरों पर!

नीचे उतर रहा है

मेरे कंप्यूटर में अंतर्निहित लेप्ट-पोर्ट के भाग्यशाली मालिकों के लिए, मैं कहूंगा कि आपके मामले में पोर्ट 378h के मानक पते पर रहता है । मुझे आधी रात को जगाया जा सकता है और मैं इस आंकड़े को कहूंगा, इतना कुछ इसके साथ जुड़ा हुआ है। लेकिन अब हमें एक दुश्मन भुगतान दिया गया है, और हमें इसे हराना है!
हम पीसीआई या पीसीआई-ई स्लॉट में बोर्ड डालते हैं, बूट करते हैं और देखते हैं कि निम्न आदेश के साथ पीसीआई बस में क्या होता है:

lspci -v … 05:01.0 Serial controller: Device 4348:5053 (rev 10) (prog-if 02 [16550]) Subsystem: Device 4348:5053 Flags: medium devsel, IRQ 18 I/O ports at c030 [size=8] I/O ports at c020 [size=8] Kernel driver in use: serial 

जैसा कि आप देख सकते हैं, लिनक्स ने पीसीआई बस में कुछ पाया, और यहां तक ​​कि इसे किसी तरह के बाएं, स्पष्ट रूप से गलत ड्राइवर देने की कोशिश की। लेकिन हम उन पतों में सबसे अधिक रुचि रखते हैं जिन पर यह पोर्ट बैठता है। ये पंक्तियाँ हैं: I / O पोर्ट, अर्थात् संख्या c030h और c020h ।
अब हमें यह पता लगाने की आवश्यकता है कि पते किसके लिए जिम्मेदार हैं। ऐसा करने के लिए, एल ई डी को प्रतिरोधों के साथ आउटपुट पोर्ट से लगभग उसी तरह से कनेक्ट करें (लगभग 310 ओम के प्रतिरोधक, या अधिक या कम, इससे कोई फर्क नहीं पड़ता)


सत्यापन योजना

चूंकि मेरे पास इस तरह के परीक्षण के लिए पहले से ही एल ई डी का एक रिक्त स्थान है, इसलिए मैंने तारों को सीधे CENTRONICS कनेक्टर में डाला और मैं सभी 8 टुकड़ों के तारों को फिट नहीं करता था, इसलिए मैंने केवल 6 (पहले 4 और अंतिम दो) सम्मिलित किए।


इकट्ठे पोर्ट परीक्षक

और हम सत्यापन के लिए एक छोटे से कार्यक्रम को स्केच करेंगे।

पोर्ट के साथ काम करने के लिए, मैंने यहां से एक उदाहरण लिया www.faqs.org/docs/Linux-mini/IO-Port-Programming.html#s9 । केवल एक चीज जिसे ठीक करने की आवश्यकता है वह है रेखा:

 #include <asm/io.h> 

पर

 #include <sys/io.h> 

हम प्रति सेकंड (100000) के बजाय सामान्य देरी करते हैं;
, स्लीप (1);) और क्रमिक रूप से पोर्ट में तीन आउटपुट बनाते हैं:

 outb(0, BASEPORT); sleep(1); outb(0xAA, BASEPORT); sleep(1); outb(0xFF, BASEPORT); sleep(1); 

0xc030 पोर्ट में #define आधार परिवर्तन को परिभाषित करें। हम संकलित करते हैं, रूट के नीचे से चलते हैं: एलईडी प्रकाश नहीं करते हैं। किसी अन्य अंक में बदलें - 0xc020 - ale op:


अशक्त


पिन पर एएएच


और, बेशक, एक दूसरे एफएफएच में

परिणाम स्पष्ट है। यानी पोर्ट संख्याओं के साथ हमने अनुमान लगाया, आप जलाऊ लकड़ी शुरू कर सकते हैं। इस बोर्ड का LPT पोर्ट पते पर रहता है। 0Xc020 !

मैं tinsmith प्रोग्रामर का ध्यान जादू की संख्या 0xAA पर आकर्षित करना चाहता हूं - यह लोगों और शून्य का एक क्रम है। इस तरह : 10101010b यह किसी भी डिबगिंग के लिए बहुत सुविधाजनक है। सामान्य तौर पर, जो कोई भी हार्डवेयर के साथ काम करता है, उसे मन में बाइनरी, दशमलव, हेक्साडेसिमल का आगे और पीछे आसानी से अनुवाद करना चाहिए।

तकी प्रदर्शन

ड्रम रोल, यह लोहे के टुकड़े को एक साथ रखने का समय है! ऐसा करने के लिए, हमें सब कुछ एक साथ मिलाप करना होगा। हम निम्नलिखित योजना के अनुसार सब कुछ एकत्र करते हैं।


मुझे पता है कि यह योजना GOST के अनुसार नहीं है, लेकिन यह रेडियो पत्रिका भी नहीं है

स्क्रीन को पावर करने के लिए, मैंने USB वायर को अनसुक्र किया, और अब मेरे पास स्क्रीन पर जाने वाले दो वायर हैं। एक मुश्किल विकल्प है, यह सिर्फ इतना है कि हाथों तक यह बिल्कुल नहीं पहुंचता है - यह एलपीटी तार में सीधे यूएसबी बिजली चालू करना है, कई पृथ्वी तारों में से एक को टांका लगाना। जैसे-जैसे हाथ पहुंचेंगे, मैं इसे जरूर करूंगा। मैं केवल इस लेख को जोड़ दूंगा :))))।
नतीजतन, बिजली देने के बाद, हमें कुछ इस तरह से मिलना चाहिए। एक रोकनेवाला के साथ चमक को समायोजित करें ताकि दो स्ट्रिप्स दिखाई दें। वे हमें दिखाते हैं कि प्रदर्शन आरंभिक नहीं है।


डिवाइस असेंबली

फू, हमने हार्डवेयर को समाप्त कर दिया, यह कार्यक्रम पर आगे बढ़ने का समय है।

कार्यक्रम में स्क्रीन के साथ बुरे प्रयोगों के लिए हो रही है

मैंने प्रदर्शन के साथ काम करने के लिए तैयार किए गए Arduino कोड का उपयोग यहां से किया है। मुझे यह प्लेटफ़ॉर्म भी पसंद नहीं है, लेकिन कोड I2C के माध्यम से जुड़े डिस्प्ले के लिए उपयुक्त है। यदि अंतिम शब्द आपको कुछ नहीं बताता है, तो चिंतित न हों। लब्बोलुआब यह है कि एक ही डिस्प्ले दो तारों (बस के नाम के रूप में) के माध्यम से जुड़ा हुआ है, और फिर एक रजिस्टर है जो फिर से प्रसारित बाइट को एक समानांतर बस में परिवर्तित करता है, ठीक हमारे LPT पोर्ट की तरह। नतीजतन, I2C के साथ काम का हिस्सा बाहर फेंकना, हमें एक अच्छा काम मिलता है।
स्वच्छता के लिए, मैंने इसे एक जगह फिर से लिखा, कुछ आवश्यक कार्यों को जोड़ा, कुछ परस्पर विरोधी नामों को बदल दिया, कुछ अन्य परिवर्तन किए (मुझे याद नहीं है, बहुत सारा पानी बह गया) और कैंडी मिला।
वैसे, कोड का उपयोग STM32 पर किया गया था, I2C के माध्यम से जुड़े डिस्प्ले के साथ भी। और अब हम इसे x86 और लिनक्स के तहत पहले से ही पोर्ट कर रहे हैं। यहाँ यह है - कोड पोर्टेबिलिटी की महान शक्ति! नए प्लेटफ़ॉर्म के लिए पहले से ही कोड को अनुकूलित करने के लिए केवल 10 मिनट का समय बिताया।
पोर्ट के साथ काम एक एकल फ़ंक्शन में किया जाता है - यह एक गैर-पोर्टेबल नोड है, और प्लेटफॉर्म के आधार पर, आउटपुट विधि को बदलना चाहिए। I2C पर एक निष्कर्ष था:

  void expanderWrite(unsigned char _data){ outb(((_data) | _backlightval), BASEPORT); //x86 instruction!!!!! } 

इस सुविधा पर ध्यान दें। इसे बदलकर, कोड को AVR, STM32, MIPS, आदि में चलाया जा सकता है।
बंदरगाह के लिए पहले से ही परिचित निष्कर्ष। पोर्ट को परिभाषित करें हेडर lcd.h में परिभाषित किया गया है। सब, अब हम निष्कर्ष निकालने की कोशिश कर सकते हैं। कार्यक्रम और भी आसान और अधिक दृश्य बन गया है।
प्रदर्शन के लिए print_to_string आवरण फ़ंक्शन का उपयोग किया जाता है।

 void print_to_string (unsigned char col, unsigned char row, unsigned char c[], unsigned char len); 

पहला पैरामीटर कॉलम संख्या (शून्य से 19 तक), दूसरी पंक्ति संख्या (शून्य से तीन तक), तीसरा वर्ण स्ट्रिंग का सूचक है और अंतिम स्ट्रिंग की लंबाई है। लाइन की समाप्ति "\ 0" के लिए नहीं की गई है, लंबाई को स्वतंत्र रूप से नियंत्रित किया जाना चाहिए! परिणामस्वरूप, प्रदर्शन का प्रयास करें:

 #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/io.h> #include "lcd.h" #define LCD_STRINGS 4 // #define LCD_COLUMNS 20 // int main() { LCD_init(0, LCD_COLUMNS, LCD_STRINGS);//  print_to_string (0, 0, "XXXXXXXXXXXXXXXXXXXX" , 20); print_to_string (0, 1, "YYYYYYYYYYYYYYYYYYYY" , 20); print_to_string (0, 2, "ZZZZZZZZZZZZZZZZZZZZ" , 20); print_to_string (0, 3, "MMMMMMMMMMMMMMMMMMMM" , 20); exit(0); } 

परिणामस्वरूप, स्क्रीन पर ऐसा कुछ दिखाई देना चाहिए:


हमारी पहली शुरुआत!

इस अश्लील साहित्य से चिंतित न हों। यह स्क्रीन टूटी हुई पिक्सेल के लिए लिखी गई थी, या यों कहें कि नियंत्रक बस स्थैतिक से मर गया था (उनमें से कई हैं)। यह काम के लिए उपयुक्त नहीं है, लेकिन ऐसे सभी प्रयोगों के लिए यह है। ऐसे चमकदार स्क्रीन चीनी करते हैं!

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

ड्राइवर का निर्माण उपकरण

ड्राइवर लिखना शुरू करने के लिए, आपको आवश्यक उपकरण स्थापित करने की आवश्यकता है। उबंटू और डेबियन के लिए उपकरण कैसे तैयार करें इस ब्लॉग में अच्छी तरह से वर्णित किया गया है। markloiseau.com/2012/04/hello-world-loadable-kernel-module-tutorial लेख
मैं बस संक्षेप में कहूंगा कि अगर आपको डेबियन पैकेज लेने की जरूरत नहीं है, और आप केवल अपने लिए मॉड्यूल लिखते हैं, तो यह निम्नलिखित कमांड के साथ आवश्यक घटक स्थापित करने के लिए पर्याप्त होगा:

 sudo apt-get install build-essential linux-headers-$(uname -r) 

मैं दृढ़ता से सलाह देता हूं कि आप अपने कर्नेल के स्रोतों को भी डाउनलोड करें। ऐसा करने के लिए दो विकल्प हैं। पहला, और स्पष्ट, लेकिन संभवतः थोड़ा बवासीर, कमांड के साथ अपने कर्नेल के संस्करण का पता लगाना है:

 uname - a 

और इसे www.kernel.org से डाउनलोड करें। मैं लिंक का पालन करने और कर्नेल के संस्करण की तलाश में एक आलसी व्यक्ति हूं, मुझे इस व्यवसाय स्वचालन पर भरोसा है।

 #    sudo -s cd /usr/src/ apt-get source linux-image-$(uname -r) #      . #      linux_3.8.0-9.18.tar.gz      /usr/src/linux-3.8.0 

Uso, इस पथ को याद रखें या इसके लिए एक लिंक जोड़ें, उदाहरण के लिए / usr / src / linux, लेकिन मैं ऐसा नहीं करता, क्योंकि गुठली को अपग्रेड करते हैं। होना या न होना, अपने लिए तय करना एक मूट पॉइंट है।
अब आपके पास एक वास्तविक खजाना है: अप-टू-डेट प्रलेखन का एक भंडार और स्रोत कोड उदाहरणों की एक राक्षसी राशि और निश्चित रूप से, मॉड्यूल के निर्माण के लिए आवश्यक ब्रिजहेड।
मैं दृढ़ता से अनुशंसा करता हूं कि आप दस्तावेज़ों, ड्राइवरों और अन्य लोगों को डैडी में चढ़ते हैं, स्रोत कोड ब्राउज़ करते हैं - यह अविश्वसनीय रूप से उपयोगी है!

खुद का ड्राइवर

यदि आपको लगता है कि हम सिर्फ मेकफाइल को ठीक करते हैं और तैयार ड्राइवर प्राप्त करते हैं, तो आप गहराई से गलत हैं। यही है, अब हम एक और दुनिया में हैं: उपयोगकर्ता स्थान में नहीं, कर्नेल स्थान में। और यहां पूरी तरह से अलग नियम लागू होते हैं।
स्थिति की सभी गरीबी का एहसास करने के लिए, आपको यह समझना चाहिए कि कर्नेल एक बड़ा, बड़ा कार्यक्रम है। और इसका मतलब है कि वैश्विक चर, कार्य, आदि। कर्नेल में कहीं और उपलब्ध हो सकता है! इसलिए, सभी वैश्विक चर (उन्हें अधिकतम से बचा जाना चाहिए) को स्थिर घोषित किया जाना चाहिए!
हम इसमें ड्राइवर को एम्बेड करके कर्नेल का पुनर्निर्माण नहीं करेंगे, और हर बार जब हम इसे पुनः आरंभ करते हैं, तो कोशिश करते हैं। यह निश्चित रूप से मजाकिया है, लेकिन बहुत लंबा है। इसके बजाय, हम एक कर्नेल मॉड्यूल बनाएंगे जिसे हम रनटाइम पर लोड और अनलोड करेंगे।
हमारे भविष्य के मॉड्यूल में, उपयोगकर्ता अंतरिक्ष के लिए कार्यक्रम की तुलना में, परिवर्तन बहुत महत्वपूर्ण नहीं होंगे। सबसे पहले, हम सभी फ़ाइलों को एक में स्थानांतरित करेंगे, ताकि संकलन के साथ समस्या न हो (अच्छी तरह से, या हम एक दूसरे में फ़ाइलों को शामिल करेंगे)। हम हेडर को छोड़ देते हैं, लेकिन फ़ंक्शन के सभी मापदंडों को स्पष्ट रूप से परिभाषित करते हैं (यदि कोई पैरामीटर नहीं हैं, तो शून्य पंजीकृत होना चाहिए)। हम याद करते हैं कि हम मुख्य स्थान पर हैं, और हमारे पास मौजूद सभी पुस्तकालय अलग-अलग हैं। सभी हेडर को परमाणु में बदलें:

 #include <linux/module.h> #include <linux/init.h> #include <linux/fs.h> /* everything... */ #include <asm/io.h> #include <linux/unistd.h> #include <linux/delay.h> /* udelay */ #include <asm/uaccess.h> #include <linux/miscdevice.h> 

ध्यान दें कि unistd.h और io.h भी परमाणु हो गए हैं।

ड्राइवर के प्राथमिक आधार के रूप में, हैलो वर्ल्ड मॉड्यूल लें। चलो init फ़ंक्शन को ठीक करें:

 static int __init hello_init(void) { LCD_init(0, LCD_COLUMNS, LCD_STRINGS); print_to_string (0, 1, "Hello Habrahabr " , 20); printk(KERN_INFO "Lpt module init\n"); return 0; // Non-zero return means that the module couldn't be loaded. } 

यहां सब कुछ व्यावहारिक रूप से अपरिवर्तित है। लोहे के साथ काम करने का कार्य बदल रहा है (सबसे प्लेटफ़ॉर्म-निर्भर), क्योंकि पोर्ट आउटपुट के लिए परमाणु उत्पादन के साथ पहले से ही काम करेगा:

 void expanderWrite(unsigned char _data){ //outb(((_data) | _backlightval), BASEPORT); //x86 instruction rootfs!!!!! outb_p(((_data) | _backlightval),BASEPORT); //x86 instruction kernel!!!!! } 

और, विचित्र रूप से पर्याप्त, विलंबित कार्य। सामान्य तौर पर, विलंब एक अलग गीत है, जिसे पूरे लेख के लिए समर्पित किया जा सकता है। हमारे पास सब कुछ जल्दी से होना चाहिए, और सभी प्रकार की बकवास के लिए जितना संभव हो उतना कोर पर कब्जा करना चाहिए। लेकिन फिर भी:

 static inline int delayMicroseconds(int value) { //usleep(value); //rootfs if (value > 1000) msleep(value/1000); udelay(value%1000); return 0; //kernel } 

इस धोखाधड़ी के लिए स्पष्टीकरण सरल है: कर्नेल के अंदर udelay एक हजार से अधिक मान नहीं ले सकता है। घटनाओं से बचने के लिए ऐसे ठूंठ की जरूरत होती है।
उसके बाद, हम इस तरह के मेकफाइल के साथ लगभग जमा करते हैं:

 TARGET = lptlcd obj-m := $(TARGET).o KERNELDIR ?= /lib/modules/$(shell uname -r)/build PWD := $(shell pwd) CC = gcc all: $(MAKE) -C $(KERNELDIR) M=$(PWD) clean: rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions 

और निम्न कमांड के साथ सिस्टम में मॉड्यूल लोड करें:

 sudo insmod lptlcd.ko 

यदि हमने सब कुछ सही ढंग से किया है, तो हमें त्रुटियां नहीं मिली हैं, और स्क्रीन को सही ढंग से आरंभ किया जाएगा और dmesg आपके मॉड्यूल के संदेश को अंतिम पंक्ति के रूप में दिखाएगी:

[10036.950566] Lpt module init

आप कमांड के साथ मॉड्यूल को अनलोड कर सकते हैं

 sudo rmmod lptlcd 

dmesg कहेंगे:

[10077.176714] Cleaning up module

सामान्य तौर पर, लगातार dmesg नहीं दबाने के लिए, एक स्क्रिप्ट होती है, एक समाधान होता है जो Jtu comrade ने मुझे सुझाया है:

 while true; do sudo dmesg -c; sleep 1; done 

या, यदि आप उबंटू के अलावा किसी वितरण का उपयोग कर रहे हैं, तो आपको इसे रूट के रूप में चलाना चाहिए और sudo को हटा देना चाहिए।

परिणाम स्क्रीन पर:


आपको नमस्कार है!

यदि आपने यह सब देखा - बधाई हो, तो यह आपका पहला काम करने वाला बेकार कर्नेल मॉड्यूल है जो स्क्रीन पर एक शिलालेख प्रदर्शित करता है! यह निश्चित रूप से मनोरंजक है, लेकिन हमें अभी भी अपने प्रयोगों को एक सामान्य ड्राइवर में बदलना होगा, जिसके साथ काम करना है। और इसके लिए, आपको अभी भी मैटरियल के बारे में बात करनी है, कम से कम थोड़ा।

मैटरियल के बारे में कुछ शब्द

यह पसंद है या नहीं, आप कुछ हार्डवेयर जाने बिना दूर नहीं जाते हैं। प्रतीकात्मक, ब्लॉक और नेटवर्क डिवाइस हैं। प्रत्येक डिवाइस में एक प्रमुख और मामूली डिवाइस नंबर भी होता है। पुस्तक " द लिनक्स कर्नेल मॉड्यूल प्रोग्रामिंग गाइड " से बेहतर कहना असंभव है, इसके लिए मैं पुस्तक को बिगाड़ने वाले से उद्धृत करूंगा:

डिवाइस फ़ाइल बनाएँ

हम चरित्र डिवाइस ड्राइवर फ़ाइल का उपयोग करेंगे। लिनक्स डिवाइस ड्राइवर को बुक करने के साथ-साथ अपने जीवन को आसान बनाने के लिए, मैंने इस लेख से एक चरित्र ड्राइवर को पंजीकृत करने के लिए एक तैयार उदाहरण लिया। यह लेख एक मुक्त निश्चित नाबालिग की खोज नहीं करता है, लेकिन एक गतिशील नाबालिग का उपयोग करता है। हमारे लिए, यह बहुत अच्छी बात है।

इसलिए, मॉड्यूल अब इस तरह दिखाई देगा: स्क्रीन के साथ काम जिसे हमने ऊपर लागू किया था, अपरिवर्तित रहता है, लेकिन हम इसे खरोंच से बाकी को फिर से लिखते हैं।
File_operations संरचना को परिभाषित करें

 static const struct file_operations lptlcd_fops = { .owner = THIS_MODULE, .read = dev_read, .write = dev_write, }; 

जहाँ dev_read और dev_write कार्य के लिए संकेत होते हैं (कॉलबैक दर्ज करना) जो क्रमशः डिवाइस फ़ाइल से पढ़ने और लिखने का काम करेगा। यहां आप अभी भी कर सकते हैं, लेकिन संभवत: आपको डिवाइस फ़ाइल के वन-टाइम खोलने और समापन की जांच करने के लिए .open और .release पॉइंटर्स को जोड़ना होगा, लेकिन अब मैं आलसी हूं।

ड्राइवर को पंजीकृत करने के लिए, हम इस संरचना को शुरू करते हैं

 static struct miscdevice lptlcd_dev = { MISC_DYNAMIC_MINOR, "lptlcd", &lptlcd_fops }; 

जहां MISC_DYNAMIC_MINOR डायनामिक माइनर के लिए एक मैक्रो है, लाइन "lptlcd" डिवाइस का नाम है, यह / dev / फ़ोल्डर में कैसे दिखेगा (हमारे मामले में यह / dev / lllcd होगा), और lptlcd_fops file_operations संरचना का एक सूचक है।

ड्राइवर पंजीकरण कोड भी काफी सरल है

 static int __init dev_init( void ) { int ret; //   ret = misc_register( &lptlcd_dev ); //    if( ret ) printk( KERN_ERR "=== Unable to register misc device\n" ); //  LCD_init(0, LCD_COLUMNS, LCD_STRINGS); print_to_string (0, 0, "lptlcd init " , 16); return ret; } 

डिवाइस डेरेग्यूशन सरल है:

 static void __exit dev_exit( void ) { misc_deregister( &lptlcd_dev ); } 

खैर, मैक्रो इंस्टॉलेशन कॉलबैक, लाइसेंस, लेखक और संस्करण को मत भूलना

 module_init( dev_init ); module_exit( dev_exit ); MODULE_LICENSE("GPL"); MODULE_AUTHOR( "Dolin Sergey <dlinyj@gmail.com>" ); MODULE_VERSION( "0.1" ); 

जादू की शुरुआत dev_read और dev_write फ़ंक्शन में होती है। मैं पहले से शुरू करता हूँ

 static char *info_str = "lcdlpt device driver\nAuthor Dolin Sergey aka dlinyj dliny@gmail.com\n"; // buffer! static ssize_t dev_read( struct file * file, char * buf, size_t count, loff_t *ppos ) { int len = strlen( info_str ); if( count < len ) return -EINVAL; if( *ppos != 0 ) { return 0; } if( copy_to_user( buf, info_str, len ) ) return -EINVAL; *ppos = len; return len; } 

वह निम्न कार्य करता है: यदि हम डिवाइस फ़ाइल पढ़ते हैं, उदाहरण के लिए, इस तरह:

 cat /dev/lptlcd 

फिर हम info_str पॉइंटर के बाद लाइन देखेंगे।
कोड इतना स्पष्ट है कि मुझे आशा है कि उसे किसी भी टिप्पणी की आवश्यकता नहीं है। केवल एक चीज यह है कि copy_to_user फ़ंक्शन, copy_from_user फ़ंक्शन के साथ, उपयोगकर्ता और कर्नेल एड्रेस स्पेस के बीच डेटा कॉपी का उपयोग करता है।

एक और dev_write फ़ंक्शन, यह डेटा को स्क्रीन में धकेलता है।

 static int str_pos = 0; //  static int col_pos = 0; //  static ssize_t dev_write( struct file *file, const char *buf, size_t count, loff_t *ppos ) { int i; //  . for (i=0; i<count;i++) { //     setCursor(col_pos, str_pos); //       ,    if ((col_pos==0) && (str_pos==0)) clear(); //   ,     if (buf[i] != '\n') { write_l(buf[i]); col_pos++; } //  ,      else {col_pos=LCD_COLUMNS;} //        if (col_pos == LCD_COLUMNS) { col_pos=0; str_pos++; //   ,      if (str_pos == LCD_STRINGS) { str_pos=0; } } } return count; } 

मेरी राय में, न जोड़ें या निकालें। मुझे उम्मीद है कि यहां सब कुछ स्पष्ट है।
हम संकलन करते हैं, मॉड्यूल को कर्नेल में जोड़ते हैं और देखते हैं कि हमारे पास एक फ़ाइल है:

 $ ls /dev/lptlcd /dev/ttylptlcd 

हम इसे पढ़ने और कुछ लिखने की कोशिश करते हैं:

 $ cat /dev/lptlcd lcdlpt device driver Author Dolin Sergey aka dlinyj dliny@gmail.com echo -ne "Trolo Pysh\nPysh" > /dev/lptlcd 

और हम इसे देखेंगे:


मैं एक यूएफओ चालक हूं।

सब कुछ, अब हमारे पास एक पूरी तरह से काम करने वाला ड्राइवर है और साथ में एक पारस्परिक डिवाइस है! बधाई हो, आप शैंपेन के लिए स्टोरहाउस में भाग सकते हैं, और फिर उपयोगकर्ता अंतरिक्ष में, जादू के बुलबुले का उपयोग करके इस डिवाइस का उपयोग करके जादू कार्यक्रम लिख सकते हैं।
लेकिन फिर भी, कुछ संदेह मुझे व्यक्तिगत रूप से परेशान करते हैं, यहाँ कुछ गलत है ...

मुझे और चाहिए !!!

इसलिए, अब हमने पूरी तरह से काम करने वाले ड्राइवर को लिखा है, जो पहले से ही रोजमर्रा के अभ्यास में इस्तेमाल किया जा सकता है। इस पर किसी भी पाठ को प्रदर्शित करने के लिए, यहां तक ​​कि एक फ़ाइल से पाठ, उनके कार्यक्रमों में उपयोग करने के लिए। लेकिन अपूर्णता, अपूर्णता की भावना है।
यदि आप स्क्रीन पर किसी भी दस्तावेज को लेते हैं और पढ़ते हैं, उदाहरण के लिए, AVR के लिए प्रदर्शन को शुरू करने पर DIHALT द्वारा लिखा गया एक लेख , तो आप अवसरों के धन पर आश्चर्यचकित होंगे। उदाहरण के लिए:
1. आप पाठ को मेमोरी में लोड कर सकते हैं, और फिर बस दृश्य क्षेत्र को स्थानांतरित कर सकते हैं, नए डेटा लोड करने के लिए घड़ी चक्र को बचा सकते हैं (जैसा कि हम याद करते हैं, हमारे पास शक्तिशाली विलंब हैं)।
2. आप पाठ को एक मनमाना स्थिति में प्रदर्शित कर सकते हैं।
3. आप स्क्रीन को साफ कर सकते हैं।
4. और हां, आप अपने खुद के फोंट अपलोड कर सकते हैं। इस बारे में अपने आप को चापलूसी मत करो, केवल 8 वर्ण उपलब्ध हैं। उदाहरण के लिए, लैटिन अक्षरों और आंशिक रूप से लोड किए गए रूसी (8 वर्णों) के साथ रूसी मेनू के बिना इस स्क्रीन के साथ एक रूसी मेनू को लागू करने का कार्य पूरे विभाग के लिए एक बहुत ही मनोरंजक रीबस में बदल जाता है (यह था, हंस)। तो यह कुछ विशिष्ट वर्णों के लिए उपयोग किया जाता है।

मुझे काम पर एक कॉफी मशीन पर फॉन्ट डाउनलोड सुविधा का उपयोग करने का एक अच्छा उदाहरण मिला, जिसमें एक समान स्क्रीन, बस Russified, स्थापित है।


कॉफी मशीन पर स्क्रीन

यहां आप स्पष्ट रूप से प्रतीकों का उपयोग देख सकते हैं:
- चीनी के लिए दो प्रतीक, एक खाली सर्कल (बंद करने के लिए नहीं सोचा था) और पूर्ण;
- एक रनिंग लाइन के पांच अक्षर (5 कॉलम के एक चरित्र में)।

कुल 2 + 5 - केवल एक अतिरिक्त वर्ण शेष रहता है, जिसका उपयोग संभवतः भी किया जाता है। वास्तव में भागना मत।

सामान्य तौर पर, डिस्प्ले में बहुत सारे चिप्स होते हैं, इतने कि मैं प्रलेखन में पढ़ने के लिए पहले से ही आलसी हूं। लेकिन, जैसा कि हम देखते हैं, हम यह सब अभी तक नहीं कर सकते हैं। और इस अद्भुत क्षण में, झाड़ियों से मेरे पियानो को पाने का समय था, जो लंबे समय से था।
इससे पहले कि मैं इस विचार को लागू करना शुरू करूं (इससे पहले कि मैंने भागों को खरीदना शुरू कर दिया), मैंने गुगली की, और किसी और ने किया। और, लो और निहारना (!) ऐसा ड्राइवर पहले से मौजूद है। उसने लिखामाइकल मैकलेलन और ड्राइवर यहां रहते हैं ।
ईमानदारी से, इस ड्राइवर ने मुझ पर मिश्रित प्रभाव डाला। मान लें कि यह एक महत्वपूर्ण मार्गदर्शिका बन गई है कि ड्राइवरों को कैसे नहीं लिखना है - एक अलग स्विचिंग योजना के तहत इसे फिर से लिखना एक गैर-तुच्छ कार्य होगा, क्योंकि बाइट्स का एक गूंगा रिकॉर्ड है, और यह स्पष्ट नहीं है कि कौन, कहाँ और क्यों। पोर्टेबिलिटी एक वर्ग के रूप में अनुपस्थित है। और अलग-अलग कोर के लिए डिफाइन-एस का एक गुच्छा मोस्क बनाते हैं। इसके अलावा, शुरू में चालक को एक पूर्ण वायरिंग आरेख के लिए कल्पना की गई थी (प्रति डेटा पोर्ट 8 बिट्स, देखें lcd-mod.sourceforge.net/wiring.php), और मुझे तुरंत 4-बिट बस का लक्ष्य दिया गया था। यद्यपि यह धीमा है (बाइट को दो पैकेजों में भेजे जाने के बाद से लगभग दो बार), लेकिन सबसे पहले, यह कम मिलाप करेगा, और दूसरी बात, अन्य बंदरगाहों को खोजने के लिए आवश्यक नहीं होगा। और तीसरा, मेरे पास पहले से ही 4-बिट बस के लिए एक उत्कृष्ट और तार्किक कोड था। नतीजतन, मैंने अपने ड्राइवर को खुद से और खरोंच से लिखने का फैसला किया, साथ ही साथ यह भी बताया कि यह कैसे करना है।

ठीक है, गीत के साथ नरक करने के लिए। उस ड्राइवर में एक अनमोल बात है - यह नियंत्रण अनुक्रम या ईएससी अनुक्रम प्रसंस्करण है। यदि आप कड़ी मेहनत करते हैं और इस "पियानो" को हिलाते हैं, तो आप सभी प्रकार के रीडमी और कैसे-कैसे पा सकते हैं। साथ ही ऑफसाइट पर भी एक तथ्य है। ताकि आपको यह सब डेटा चढ़ना न पड़े, मैंने सब कुछ एक ढेर में और रूसी में डालने का फैसला किया। सबसे पहले, इन अनुक्रमों के बारे में कुछ शब्द, आप सभी को पता चला जब प्रिंटफ़ ऑपरेटर ने '\ n' के रूप में एक पंक्ति फ़ीड जोड़ा - यह सबसे सरल ईएससी अनुक्रम है, जिसे ASCII में वर्ण 0Ah के रूप में व्याख्या किया गया है। इस प्रदर्शन के प्रबंधन में वही अजमोद निहित है।

तो, हमारी स्क्रीन के लिए दृश्यों को नियंत्रित करें:

• \ 033 = ESC अनुक्रम भेजना जिसके साथ कमांड शुरू होते हैं
• [A = कर्सर को एक पंक्ति ऊपर ले जाएं
• [B = कर्सर को एक रेखा से नीचे ले जाएँ
• [C = कर्सर को दाईं ओर ले जाएं
• [D = कर्सर को बाईं ओर ले जाएं
• [H = कर्सर को ऊपरी बाएँ कोने में ले जाएँ - घर (स्थिति 0,0)
• [जे = सब कुछ साफ़ करें, कर्सर घर वापस न करें!
• [K = पंक्ति के अंत में मिटाता है, कर्सर को घर नहीं लौटाता है!
• [M = नया चरित्र मानचित्र (DZ - समझाएं क्यों!)
• [Y = स्थिति Y (नीचे FAQ देखें)
• [X = स्थिति X (नीचे FAQ देखें)
• [R = CGRAM मेमोरी चयन
• [V = स्क्रॉल सक्षम किया गया
• [डब्ल्यू = स्क्रॉलिंग बंद
• [बी = बैकलाइट चालू / बंद है (यह हमारे लिए काम नहीं करेगा)।

अन्य उपयोगी कमांड \ 033 उपसर्ग के बिना काम करते हैं!

• \ r = कैरिज रिटर्न (वर्तमान लाइन पर कर्सर को स्थिति 0 पर लौटाएं!)
• \ n = नई पंक्ति
• \ t = टैब (डिफ़ॉल्ट 3 वर्ण)

यह विचार मुझे बहुत अच्छा लगा, और मैंने इस परियोजना में इस समारोह को उधार लेने का निश्चय किया।

वैसे, ये सभी क्रम नियमित रूप से कंसोल में अद्भुत रूप से काम करते हैं, इन्हें पाठ प्रदर्शित करते समय उपयोग किया जा सकता है।

जो अभी भी यह नहीं समझता है कि यह क्या है और क्यों है, फिर इसे यहाँ और अधिक विस्तार से वर्णित किया गया है lcd-mod.sourceforge.net/faq.php । पीड़ित नहीं होने के लिए, मैंने स्वतंत्र रूप से इसका अनुवाद किया और ध्यान से इसे चित्रों के साथ एक बिगाड़ने में डाल दिया



सामान्य तौर पर, जैसा कि आप देख सकते हैं, आपको dev_write फ़ंक्शन को फिर से लिखना होगा। और अब वह इस तरह दिखने लगी:

 static ssize_t dev_write( struct file *file, const char *buf, size_t count, loff_t *ppos ) { int i; for (i=0; i<count;i++) handleInput(buf[i]); return count; } 

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


ASCII-ART मूव! यह ईस्टर अंडे द्वारा लॉन्च किया गया है

जो मुझे अपनी स्क्रीन पर एक समान वीडियो दिखाते हैं उन्हें मुझसे एक उपहार मिलेगा!

सामान्य तौर पर, परिणामस्वरूप, हमें एक कोषेर स्क्रीन मिली, जिसका उपयोग विभिन्न उपयोगी और बेकार सूचनाओं को प्रदर्शित करने के लिए किया जा सकता है। यहां, उदाहरण के लिए, आप उस पर वर्तमान समय प्रदर्शित कर सकते हैं।

 while true; do echo -en "\033[H`date +\"%d.%m.%Y\"` \r\n`date +%r`" > /dev/lptlcd ; sleep 1s; done 

और वे अभी भी जाते हैं!

बेशक, उन्होंने लिखा - इसे लोगों के साथ साझा करें! स्रोत कोड यहां उपलब्ध हैं (मैं अभी भी कोड एक्सचेंज, शर्म के लिए जीथब का उपयोग करने का इरादा नहीं रखता हूं)।

मैं क्या करना चाहूंगा

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


एंबेडेड आर्टिस्ट क्रिस्टमास ट्री

आपको इस डिवाइस को Google नहीं करना चाहिए, आधिकारिक साइट से भी इसके सभी संदर्भ हटा दिए जाते हैं, और दुर्लभ संदर्भों के लिए इसे विशाल में भी खोजना मुश्किल है। इंटरनेट।
मैंने इस क्रिसमस ट्री का एक वीडियो भी शूट किया


क्रिसमस का पेड़ कैसे काम करता

है रोशनी की एक मजेदार झपकी के अलावा, इस मज़ेदार डिवाइस में एक शांत विशेषता थी - आप ऐसे क्रिसमस पेड़ों के अन्य मालिकों के साथ मेल खा सकते हैं। एक साइडबोर्ड था जहां आप एक विशेष फॉर्म के माध्यम से एक संदेश चला सकते थे और इसे क्रिसमस पेड़ों के माध्यम से बाहर भेजा गया था और स्क्रीन पर प्रदर्शित किया गया था। यह बहुत, बहुत अच्छा और मजेदार था।

अब ध्यान: विचार! अब एक महीने के लिए 500 रूबल का भुगतान करने के लिए कुछ भी नहीं रोकता है (और यदि हम बंद कर देते हैं, तो राशि काफी कम होगी), और एक वर्चुअल मशीन पर एक सर्वर किराए पर लें। वहां, एक प्रोग्राम डालें जो संदेश भेजेगा। या तो जैबर या कुछ अन्य तरीके (हाँ, कम से कम एनसी और टेलनेट सब कुछ करते हैं)। और कंप्यूटर पर इन संदेशों का रिसीवर डाल दिया। और नए साल पर हम सभी को बधाई होगी।
कौन इसे लागू करने में मदद करने के लिए तैयार है, और कौन अपने लिए ऐसी स्क्रीन बनाएगा? अगर हमारे पास कम से कम तीन लोग हैं, तो यह बहुत ही मजेदार होगा! डेवलपर्स के हैंगआउट में शामिल हों :))))। मैं किसी भी विचारों को सुनूंगा!

परिणाम

मैं संक्षिप्त रहूंगा।इस पोस्ट में, मैंने लक्ष्य निर्धारित किया है कि लिनक्स डिवाइस ड्राइवर्स बुक को दोबारा न लें, लेकिन केवल यह दिखाने के लिए कि फायरवुड लिखना एक तुच्छ कार्य है। मैंने जानबूझकर USB छोड़ा, क्योंकि सिद्धांत, नुकसान और अन्य बवासीर का एक बहुत कुछ है। लेकिन आप USB-LPT-lanyards के लिए इस मॉड्यूल को पूरी तरह से फिर से लिख सकते हैं, जैसे कि यह



अपेक्षाकृत सरल रूप से किया जाता है: usb के साथ विनिमय प्रोटोकॉल आपके प्रोग्राम में इंटरसेप्टेड और कार्यान्वित किया जाता है। मेरा विश्वास करो - यह सरल है। यह दिलचस्प होगा कि कैसे - मैं आपको बताऊंगा!

और यह ड्राइवर, केवल एक (!!!) पोर्ट के लिए आउटपुट की लाइन को बदलकर उपयोग के लिए फिर से लिखा जा सकता है, उदाहरण के लिए, GPIO पोर्ट पर रास्पबेरी पाई पर। वास्तव में, मैं आपको यह नहीं बताता कि क्या लिखना है, लेकिन सब कुछ तय प्रतिशत के लिए डेटाशीट पढ़ने से तय होता है और केवल कुछ मिनट लगते हैं।

धन्यवाद:

1. मैं अपने शिक्षक बोरोनिन सर्गेई सर्गेविच सेबरोनिन को लाइनक्स के तहत कार्यक्रम सीखने और लिनक्स के लिए ड्राइवरों को विकसित करने के लिए उत्कृष्ट पाठ्यक्रम के लिए अपना मुख्य आभार व्यक्त करना चाहता हूं । अपने पाठ्यक्रमों के लिए धन्यवाद, मैं एक डेवलपर के रूप में बहुत सफल रहा हूं।
2. कॉमरेड अरिमन ने राउटर ( पहले , दूसरे , तीसरे भाग (लेकिन चौथा वादा किया गया था ...) के लिए एक डिस्प्ले के विकास पर लेखों की अपनी अद्भुत श्रृंखला के साथ )। यह श्रृंखला, हालांकि बहुत विशिष्ट है, पूरी तरह से डिवाइस के निर्माण को दिखाता है और इसके लिए उपयुक्त ड्राइवर लिख रहा है। और मैं बार-बार, ड्राइवरों के विकास में और OpenWRT के लिए मॉड्यूल के विकास में, अमूल्य जानकारी के एक स्रोत के रूप में, उसकी ओर रुख किया है।
3. बेशक, "लिनक्स डिवाइस ड्राइवर" पुस्तक के लेखक ग्रेग क्रोहा-हार्टमैन हैं । यह पुस्तक सिर्फ बाइबिल है, और कर्नेल में आप अक्सर ऐसे ड्राइवर ढूंढ सकते हैं जो इसके उदाहरणों पर आधारित हों। उदाहरण के लिए, USB ड्राइवरों में मैं इस पार आया:

/drivers/usb/misc/idmouse.c
...
यूएसबी कंकाल चालक 1.1 से व्युत्पन्न,
कॉपीराइट © 2003 ग्रेग क्रोह-हार्टमैन (greg@kroah.com)
...

और इसलिए कई ड्राइवरों में। इसलिए पुस्तक का उपयोग करें - यह एक बाइबिल है।
4. माइकल मैकलेलन एक समान ड्राइवर के लेखक के लिए। जैसा कि वह अपने ड्राइवर में कहते हैं:

* HD44780 के लिए एलसीडी ड्राइवर समानांतर पोर्ट से जुड़े संगत डिस्प्ले,
* क्योंकि असली पुरुष डिवाइस फ़ाइलों का उपयोग करते हैं।

दुर्भाग्य से, मेरे पास इसके निर्देशांक नहीं हैं, केवल लिंकिन के लिंक को छोड़कर । उनके कार्यक्रमों से मेल अब काम नहीं करता है। इसलिए, मैं व्यक्तिगत रूप से उसे कैसे धन्यवाद देता हूं, मुझे नहीं पता ... अगर कोई भी उसे लिखता है, तो मैं बहुत आभारी रहूंगा।

संदर्भ

1. प्रदर्शन rootfs के साथ काम करने के लिए अपने कार्यक्रम के सूत्रों का कहना है स्विंग
2. मेरे कर्नेल मॉड्यूल है, जो हम इस पोस्ट में चर्चा के सूत्रों का कहना स्विंग
3. झाड़ियों »में" पियानो
4. dmilvdv.narod.ru/translate.html लेख के अनुवाद। हैंडबुक लिनक्स डिवाइस ड्राइवर्स, तीसरा संस्करण है। "
5. आईबीएम से रूसी में प्रोग्रामिंग पर लेखों का एक उत्कृष्ट पुस्तकालय यहां रहता है । विशेष रूप से कर्नेल मॉड्यूल के विकास पर ।
6. HD44780 डिस्प्ले का विवरण (AVR के लिए, लेकिन सामान्य तौर पर यह सार्वभौमिक है) easyelectronics.ru/avr -uchebnyj-kurs-podklyuchenie-k-avr-lcd-displeya-hd44780.html
7. माइकल मैकलेलन द्वारा प्रदर्शन कार्यक्रम (इस मॉड्यूल के लिए कर्नेल मॉड्यूल और स्पेक्ट्रम विश्लेषक)linux.downloadatoz.com/developer-michael-mclellan.html

PS पियानोवादक को गोली मत मारो, वह उतना ही अच्छा खेलता है जितना वह कर सकता है। मेरी जन्मजात अशिक्षा के साथ, इतना बड़ा लेख सामान्य रूप से नहीं लिखा जा सकता है। मुझे टिप्पणी, सुधार और परिवर्धन अवश्य भेजें, मैं बहुत आभारी रहूंगा !!!
PPS कुछ भी नहीं छोड़ दिया एक टिप्पणी की तरह आत्मा को गर्म करता है।
PPPS पाठ में एक ईस्टर अंडा भी होता है, जो कोई भी इसे खाता है वह स्वीटी है;)))

UPD तो मैंने उन लोगों के लिए एक समूह बनाया जो मैसेंजर में भाग लेना चाहते हैं :)
उन प्रतिभागियों के लिए जो चाहते हैं कि कृपया शामिल हों :))