एसपीआई बस का अवलोकन और एम्बेडेड लिनक्स के लिए गुलाम एसपीआई डिवाइस के लिए ड्राइवर का विकास (भाग दो, व्यावहारिक)

यह लिनक्स में दास एसपीआई उपकरणों के लिए विकासशील ड्राइवरों पर मेरे लेख का दूसरा हिस्सा है। पिछला हिस्सा यहाँ है ।

3. spidev का उपयोग करके यूजरस्पेस प्रोटोकॉल एसपीआई ड्राइवर का विकास

जैसा कि ऊपर उल्लेख किया गया है, एसपीआई उपकरणों के लिए यूजर्स एपीआई के लिए सीमित समर्थन है, जिसमें मूल आधा-डुप्लेक्स पढ़ने () और लिखने () के लिए दास एसपीआई उपकरणों का उपयोग करने के लिए समर्थन है। Ioctl () कॉल का उपयोग करके, आप एक दास डिवाइस के साथ पूर्ण-द्वैध डेटा विनिमय कर सकते हैं, साथ ही डिवाइस पैरामीटर भी बदल सकते हैं।

जब आप इस उपयोक्ता API का उपयोग करना चाहते हैं तो कई कारण हैं:

• एक वातावरण में प्रोटोटाइप घातक त्रुटियों की घटना से ग्रस्त नहीं है। उपयोगकर्ता स्थान में अमान्य पॉइंटर्स आमतौर पर पूरे सिस्टम को क्रैश नहीं कर सकते हैं।
• गुलाम एसपीआई डिवाइस के मोड में काम करने वाले माइक्रोकंट्रोलर्स के साथ डेटा एक्सचेंज के लिए उपयोग किए जाने वाले सरल प्रोटोकॉल का विकास, जिसे अक्सर बदलने की आवश्यकता होती है।

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

Spidev समर्थन सक्षम करने के लिए:
1. जब menuconfig में कर्नेल को कॉन्फ़िगर करते हैं, तो आइटम को सक्रिय करें:

Device Drivers SPI support User mode SPI device driver support 

2. बोर्ड की फ़ाइल में पिछले पैराग्राफ में चर्चा की गई संरचनाओं की सरणी में spi_board_info जोड़ें:

 { /* spidev */ .modalias = "spidev", .chip_select = 2, .max_speed_hz = 15 * 1000 * 1000, .mode = SPI_MODE_0, .bus_num = 1, }, 

नए कर्नेल के पुनर्निर्माण और लोड करने के बाद, संबंधित डिवाइस सिस्टम में फॉर्म के नाम के साथ दिखाई देगा /dev/spidevB.C, जहां B SPI बस नंबर है और C चिप सेलेक्ट नंबर है। यह डिवाइस मैन्युअल रूप से mknod के माध्यम से नहीं बनाया जा सकता है, udv / mdev जैसी सेवाओं को स्वचालित रूप से इसे बनाना चाहिए।

महान, हमारे पास एक उपकरण है। उसके साथ कैसे काम करना है, यह सीखना बाकी है। मान लीजिए कि हम एसटीआई 1 पर लटकने वाले डिवाइस को बाइट 0x8 ई को सीएस 2 नंबर के साथ भेजना चाहते हैं। संभवतः ऐसा करने का सबसे आसान तरीका इस प्रकार है:

 echo -ne "\x8e">/dev/spidev1.2 

उसके बाद, मेरे परीक्षण उपकरण पर, कोई निम्नलिखित चित्र का अवलोकन कर सकता है:


परीक्षण उपकरण के बारे में कुछ शब्द। संभवतः सबसे महत्वपूर्ण बात यह है कि यह लगभग बेकार है और केवल लिनक्स में एसपीआई के साथ काम करने के लिए अध्ययन किया गया था। इसे एक शिफ्ट रजिस्टर 74HC164N पर बनाया गया है, और 3 तत्वों पर 2I-NOT 74HC132N से किसी प्रकार का चिपसेलेक्शन बनाया गया है, जो इनपुट ~ CS पर केवल निम्न स्तर पर सिंक्रोनाइज़ेशन सिग्नल की अनुमति देता है (मैं तुरंत नोट करना चाहता हूं, हां, मुझे 74HC595 के अस्तित्व के बारे में पता है। लेकिन मैं इसे अपने शहर में नहीं पा सकता)। इस डिवाइस का केवल एक ही कार्य है - एल ई डी पर लिखे गए अंतिम बाइट को प्रदर्शित करना। चूंकि मेरा उपकरण पूरी तरह से "ईमानदार" नहीं है, इसलिए इसे पढ़ने से हमें वह नहीं मिलेगा जो हमने लिखा था (जैसा कि यह होना चाहिए था), लेकिन मूल्य एक बिट से बाईं ओर स्थानांतरित हो गया।

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

• SPI_IOC_RD_MODE, SPI_IOC_WR_MODE - रीड (आरडी) के लिए बाइट जिसमें पॉइंटर स्थानांतरित किया जाता है, के मामले में, वर्तमान एसपीआई मोड का मान असाइन किया गया है। रिकॉर्डिंग (WR) के मामले में, डिवाइस संचरित पॉइंटर के बाइट मान के अनुरूप एक मोड पर सेट है। मोड सेट करने के लिए, कॉन्स्टेंट्स SPI_MODE_0 ... SPI_MODE_3 का उपयोग किया जाता है, या कॉन्स्टेंट्स SPI_CPHA (सिंक्रोनाइज़ेशन फेज, लीडिंग एज कैप्चर, यदि सेट किया जाता है) और SPI_CPOD (सिंक्रोनाइज़ेशन पोलरिटी, सिंक्रोनाइज़ेशन सिग्नल उच्च स्तर से शुरू होता है) बिटवाइज़ के माध्यम से "या"।
• SPI_IOC_RD_LSB_FIRST, SPI_IOC_WR_LSB_FIRST - एक सूचक को एक बाइट से गुजारें जो SPI शब्दों को प्रसारित करते समय बिट्स के संरेखण को निर्धारित करता है। शून्य का एक मान बताता है कि सबसे महत्वपूर्ण बिट पहला (MSB-पहला) है, अन्य मान इंगित करते हैं कि एक दुर्लभ संस्करण का उपयोग किया जाता है, और सबसे कम महत्वपूर्ण बिट पहला (LSB-पहला) है। दोनों मामलों में, प्रत्येक शब्द सही होगा, ताकि अप्रयुक्त / अपरिभाषित बिट्स उच्च क्रम में होंगे। आरडी / डब्ल्यूआर - पढ़ने / लिखने का पैरामीटर जो शब्दों में बिट्स के संरेखण को क्रमशः निर्धारित करता है।
• SPI_IOC_RD_BITS_PER_WORD, SPI_IOC_WR_BITS_PER_WORD - एक सूचक को एक बाइट से गुजरता है जो SPI द्वारा डेटा संचारित करते समय प्रति शब्द बिट्स की संख्या निर्धारित करता है। एक शून्य मान आठ बिट्स से मेल खाता है। RD / WR - क्रमशः प्रति शब्द बिट्स की संख्या को पढ़ें / लिखें।
• SPI_IOC_RD_MAX_SPEED_HZ, SPI_IOC_WR_MAX_SPEED_HZ - u32 चर के लिए एक सूचक देता है, जो Hz में SPI के लिए अधिकतम डेटा दर निर्धारित करता है। एक नियम के रूप में, नियंत्रक सेट गति को ठीक से निर्धारित नहीं कर सकता है।

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

अब मैं एक और महत्वपूर्ण बिंदु बनाना चाहता हूं, बिट्स के क्रम में परिवर्तन फिर से सभी नियंत्रकों द्वारा समर्थित नहीं है। यह पता लगाने के लिए कि नियंत्रक किस कार्य का समर्थन करता है, आपको बिट मास्क spi_master.mode_bits को देखने की आवश्यकता है। आप spi_device संरचना में झंडे की परिभाषा से मुखौटा में बिट्स के मूल्य को निर्धारित कर सकते हैं। मैं यहाँ spi_device और spi_master संरचनाओं का पूर्ण विवरण नहीं दूंगा, क्योंकि वे इस मामले में समझने के लिए महत्वपूर्ण नहीं हैं। दस्तावेज़ीकरण की एक कड़ी, जिसमें आप इन सभी संरचनाओं के विवरण पा सकते हैं, मैं लेख के अंत में दूंगा।

जैसा कि मैंने शुरुआत में उल्लेख किया था, स्पिडव इसी ioctl () कमांड का उपयोग करके आधे-द्वैध स्थानान्तरण की अनुमति देता है:

 int ret; ret = ioctl(fd, SPI_IOC_MESSAGE(num), tr); 

जहाँ संख्या spi_ioc_transfer की संरचनाओं की सरणी में स्थानान्तरण की संख्या है;
tr - संरचनाओं की एक सरणी के लिए सूचक spi_ioc_transfer;
विफलता के मामले में, एक नकारात्मक मान लौटाया जाता है, सफलता के मामले में, सभी स्थानान्तरण के लिए सफलतापूर्वक प्रेषित बाइट्स की कुल संख्या।
पारेषण संरचना में स्वयं निम्नलिखित रूप हैं:

 struct spi_ioc_transfer { __u64 tx_buf; __u64 rx_buf; __u32 len; __u32 speed_hz; __u16 delay_usecs; __u8 bits_per_word; __u8 cs_change; __u32 pad; }; 

tx_buf और rx_buf - क्रमशः डेटा को प्रसारित / प्राप्त करने के लिए एक बफर में उपयोगकर्ता स्थान में स्टोर पॉइंटर्स। यदि tx_buf NULL है, तो शून्य पॉप हो जाएगा। यदि rx_buf को NULL पर सेट किया जाता है, तो दास से प्राप्त डेटा को अनदेखा कर दिया जाता है।
लीन बाइट्स में प्राप्त करने और संचारित बफ़र्स (आरएक्स और टीएक्स) की लंबाई है।
speed_hz - किसी दिए गए स्थानांतरण के लिए डेटा दर को ओवरराइड करता है।
बिट्स_पर_शब्द - दिए गए ट्रांसमिशन के लिए प्रति शब्द बिट्स की संख्या को फिर से परिभाषित करता है।
delay_usecs - अंतिम बिट डेटा संचारित करने के बाद डिवाइस को निष्क्रिय करने से पहले (cs_deactivate को कॉल करने से पहले) माइक्रोसेकंड में देरी।

Spi_ioc_transfer संरचना के लगभग सभी क्षेत्र spi_transfer संरचना के क्षेत्रों के अनुरूप हैं। डेटा बफ़र्स spidev ड्राइवर के आंत्र में copy_from_user () / copy_to_user () फ़ंक्शन का उपयोग करके कर्नेल स्थान से / से पहले कॉपी किए जाते हैं।
जैसा कि मैंने ऊपर कहा, सभी नियंत्रक प्रत्येक ट्रांसमिशन के लिए एक शब्द की गति और आकार को अलग-अलग बदलने की क्षमता का समर्थन नहीं करते हैं, इसलिए यदि आप एक पोर्टेबल कोड प्राप्त करना चाहते हैं तो वहां शून्य डालना बेहतर है। यही कारण है कि फुल डुप्लेक्स मोड में स्पाइडव के साथ काम करने के लिए मानक उदाहरण, जो कर्नेल डॉक्यूमेंटेशन के साथ आता है, एट १ ९ १ परिवार से चिप्स पर spi_ioc_transfer संरचना के आरंभीकरण में सुधार के बिना काम नहीं करेगा।

टिप्पणी:

• फिलहाल, इस डिवाइस के लिए डेटा बिट्स को पुश / कैप्चर करने की वास्तविक गति प्राप्त करने का कोई तरीका नहीं है।
• फिलहाल, आप spidev के माध्यम से चिप का चयन ध्रुवता को उल्टा नहीं कर सकते। प्रत्येक दास डिवाइस निष्क्रिय है जब यह सक्रिय उपयोग में नहीं है, अन्य ड्राइवरों को अपने संबंधित उपकरणों के साथ संवाद करने की अनुमति देता है।
• प्रत्येक I / O अनुरोध के साथ प्रेषित बाइट्स की संख्या पर एक सीमा होती है। आमतौर पर, सीमा स्मृति के एक पृष्ठ के आकार से मेल खाती है। कर्नेल मॉड्यूल पैरामीटर का उपयोग करके इस मान को बदला जा सकता है।
• चूंकि एसपीआई में डिलीवरी की पुष्टि करने की निम्न-स्तरीय पद्धति नहीं है, इसलिए यह पता लगाने का कोई तरीका नहीं है कि ट्रांसमिशन में कोई त्रुटियां हैं, या, उदाहरण के लिए, जब कोई भी कोई भी उपकरण नहीं है।

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

 #include <stdint.h> #include <unistd.h> #include <stdio.h> #include <stdlib.h> #include <getopt.h> #include <fcntl.h> #include <sys/ioctl.h> #include <linux/types.h> #include <linux/spi/spidev.h> static void pabort(const char *s) { perror(s); abort(); } static uint8_t mode = SPI_MODE_0; static uint8_t bits = 0; static uint32_t speed = 500000; int main(int argc, char *argv[]) { int ret = 0; int fd; uint8_t tx[] = { 0x81, 0x18 }; uint8_t rx[] = {0, 0 }; if(argc!=2) { fprintf(stderr, "Usage: %s <spidev>\n", argv[0]); exit(1); } fd = open(argv[1], O_RDWR); if (fd < 0) pabort("can't open device"); /* spi mode */ ret = ioctl(fd, SPI_IOC_WR_MODE, &mode); if (ret == -1) pabort("can't set spi mode"); ret = ioctl(fd, SPI_IOC_RD_MODE, &mode); if (ret == -1) pabort("can't get spi mode"); /* bits per word */ ret = ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &bits); if (ret == -1) pabort("can't set bits per word"); ret = ioctl(fd, SPI_IOC_RD_BITS_PER_WORD, &bits); if (ret == -1) pabort("can't get bits per word"); /* max speed hz */ ret = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed); if (ret == -1) pabort("can't set max speed hz"); ret = ioctl(fd, SPI_IOC_RD_MAX_SPEED_HZ, &speed); if (ret == -1) pabort("can't get max speed hz"); printf("spi mode: %d\n", mode); printf("bits per word: %d\n", bits); printf("max speed: %d Hz (%d KHz)\n", speed, speed/1000); /* full-duplex transfer */ struct spi_ioc_transfer tr = { .tx_buf = (unsigned long)tx, .rx_buf = (unsigned long)rx, .len = 2, .delay_usecs = 0, .speed_hz = 0, .bits_per_word = bits, }; ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr); if (ret < 1) pabort("can't send spi message"); for (ret = 0; ret < 2; ret++) { printf("%.2X ", rx[ret]); } puts(""); close(fd); return ret; } 

मुझे लगता है कि यहां सब कुछ काफी स्पष्ट है, हमने पहले ही ioctl () के माध्यम से डिवाइस को प्रेषित सभी अनुरोधों को हल कर दिया है। यह केवल बनाने के लिए Makefile लाने के लिए बनी हुई है:

 all: spidev_test CC = /opt/arm-2010q1/bin/arm-none-linux-gnueabi-gcc INCLUDES = -I. CCFLAGS = -O2 -Wall clean: rm -f spidev_test spidev_test: spidev_test.c $(CC) $(INCLUDES) $(CCFLAGS) spidev_test.c -o spidev_test 

केवल एक चीज यह है कि आपको सीसी चर में अपना रास्ता क्रॉस-कंपाइलर को निर्दिष्ट करने की आवश्यकता है।

4. एक कर्नेल-स्तर प्रोटोकॉल SPI ड्राइवर का विकास

कर्नेल मॉड्यूल का विकास एक अधिक व्यापक विषय है, इसलिए इस मामले में हम दूसरे तरीके से जाएंगे: मैं पहले कोड का एक उदाहरण दूंगा, फिर मैं इसके संचालन का एक संक्षिप्त विवरण दूंगा, और समझाऊंगा कि इसका उपयोग कैसे किया जाए। मैं सभी विवरणों का वर्णन नहीं करूंगा, अन्यथा पर्याप्त लेख नहीं होगा, मैं सिर्फ सबसे महत्वपूर्ण बिंदुओं को इंगित करूंगा, प्रलेखन पर लेख के अनुभाग में आप सभी आवश्यक जानकारी के लिंक पा सकते हैं। इस उदाहरण में, मैं दिखाऊंगा कि कैसे sysfs के माध्यम से डिवाइस विशेषताओं को उपलब्ध कराया जाए। डिवाइस फ़ाइल के माध्यम से डिवाइस तक पहुंच प्रदान करने वाले ड्राइवर को कैसे लागू किया जाए, इस पर पहले ही चर्चा हो चुकी है: एक , दो
मेरा ड्राइवर उपयोगकर्ता को दो विशेषताओं को बदलने की क्षमता प्रदान करेगा:
मूल्य - इसमें आप एक संख्या लिख ​​सकते हैं जिसे आप एलईडी का उपयोग करके द्विआधारी रूप में प्रदर्शित करना चाहते हैं;
मोड - मोड स्विच, आपको तीन ऑपरेटिंग मोड में से एक को सेट करने की अनुमति देता है। निम्नलिखित मोड समर्थित हैं: 0 - बाइनरी रूप में एक संख्या प्रदर्शित करने के लिए मानक मोड, 1 - बाएं से दाएं प्रदर्शन के साथ प्रगति बार मोड, 2 - दाएं से बाएं प्रदर्शन के साथ प्रगति बार मोड;
प्रगति बार मोड में, डिवाइस एल ई डी की एक निष्क्रिय रेखा प्रदर्शित करेगा, जिसमें दर्शाया गया है कि मूल्य में दर्ज किया गया प्रतिशत 256 से कितना है। उदाहरण के लिए, यदि आप मोड 1 में लिखते हैं, और मूल्य 128 में, तो बाईं ओर 8 से 4 एल ई डी प्रकाश होगा।
यदि आप मोड संख्या में तीसरा बिट सेट करते हैं, तो पूर्ण-द्वैध मोड (fdx_transfer () फ़ंक्शन) का उपयोग किया जाएगा, बजाय एसिंक्रोनस कॉल के spi_write () और spi_read () के लिए। गैर-पूर्ण द्वैध मोड क्रमशः 4.5.6 होगा। मोड संख्या 3 0 से मेल खाती है।
खैर, अब कोड ही:

 #include <linux/module.h> #include <linux/init.h> #include <linux/spi/spi.h> #define SPI_LED_DRV_NAME "spi_led" #define DRIVER_VERSION "1.0" static unsigned char led_mode=0; static unsigned char fduplex_mode=0; unsigned char retval=0; char *mtx, *mrx; static unsigned char stbl_tmp; enum led_mode_t {LED_MODE_DEF, LED_MODE_L2R, LED_MODE_R2L }; static inline unsigned char led_progress(unsigned long val) { unsigned char i, result=0x00; val++; val/=32; for(i = 0; i < val; i++) { if(led_mode==LED_MODE_R2L) result|=(0x01<<i); else result|=(0x80>>i); } return (unsigned char)result; } static int fdx_transfer(struct spi_device *spi, unsigned char *val) { int ret; struct spi_transfer t = { .tx_buf = mtx, .rx_buf = mrx, .len = 1, }; struct spi_message m; mtx[0]=*val; mrx[0]=0; spi_message_init(&m); spi_message_add_tail(&t, &m); if((ret=spi_sync(spi, &m))<0) return ret; retval=mrx[0]; return ret; } static ssize_t spi_led_store_val(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct spi_device *spi = to_spi_device(dev); unsigned char tmp; unsigned long val; if (strict_strtoul(buf, 10, &val) < 0) return -EINVAL; if (val > 255) return -EINVAL; switch(led_mode) { case LED_MODE_L2R: case LED_MODE_R2L: tmp = led_progress(val); break; default: tmp = (unsigned char)val; } stbl_tmp=tmp; if(fduplex_mode) fdx_transfer(spi, &tmp); else spi_write(spi, &tmp, sizeof(tmp)); return count; } static ssize_t spi_led_show_val(struct device *dev, struct device_attribute *attr, char *buf) { unsigned char val; struct spi_device *spi = to_spi_device(dev); if(!fduplex_mode) spi_read(spi, &val, sizeof(val)); return scnprintf(buf, PAGE_SIZE, "%d\n", fduplex_mode ? retval : val); } static ssize_t spi_led_store_mode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { unsigned long tmp; if (strict_strtoul(buf, 10, &tmp) < 0) return -EINVAL; if(tmp>6) return -EINVAL; led_mode = (unsigned char)tmp&0x03; fduplex_mode = ((unsigned char)tmp&0x04)>>2; return count; } static ssize_t spi_led_show_mode(struct device *dev, struct device_attribute *attr, char *buf) { return scnprintf(buf, PAGE_SIZE, "%d\n", led_mode); } static DEVICE_ATTR(value, S_IWUSR|S_IRUSR, spi_led_show_val, spi_led_store_val); static DEVICE_ATTR(mode, S_IWUSR|S_IRUSR, spi_led_show_mode, spi_led_store_mode); static struct attribute *spi_led_attributes[] = { &dev_attr_value.attr, &dev_attr_mode.attr, NULL }; static const struct attribute_group spi_led_attr_group = { .attrs = spi_led_attributes, }; static int __devinit spi_led_probe(struct spi_device *spi) { int ret; spi->bits_per_word = 8; spi->mode = SPI_MODE_0; spi->max_speed_hz = 500000; ret = spi_setup(spi); if(ret<0) return ret; return sysfs_create_group(&spi->dev.kobj, &spi_led_attr_group); } static int __devexit spi_led_remove(struct spi_device *spi) { sysfs_remove_group(&spi->dev.kobj, &spi_led_attr_group); return 0; } static struct spi_driver spi_led_driver = { .driver = { .name = SPI_LED_DRV_NAME, .owner = THIS_MODULE, }, .probe = spi_led_probe, .remove = __devexit_p(spi_led_remove), }; static int __init spi_led_init(void) { mtx=kzalloc(1, GFP_KERNEL); mrx=kzalloc(1, GFP_KERNEL); return spi_register_driver(&spi_led_driver); } static void __exit spi_led_exit(void) { kfree(mtx); kfree(mrx); spi_unregister_driver(&spi_led_driver); } MODULE_AUTHOR("Lampus"); MODULE_DESCRIPTION("spi_led 8-bit"); MODULE_LICENSE("GPL v2"); MODULE_VERSION(DRIVER_VERSION); module_init(spi_led_init); module_exit(spi_led_exit); 

अब, हमें अपने डिवाइस को बोर्ड फ़ाइल में एसपीआई उपकरणों की सूची में जोड़ने की आवश्यकता है। मेरे SK-AT91SAM9260 के लिए, मुझे फ़ाइल आर्क / आर्म / मच-एट91 / बोर्ड-सम -9260ek.c खोलने की जरूरत है और इसे हमारे डिवाइस के लिए संरचनाओं की हमारे सरणी में जोड़ें। spi_board_info हमारे डिवाइस के लिए (spidev के समान):

 { /* LED SPI */ .modalias = "spi_led", .chip_select = 1, .max_speed_hz = 15 * 1000 * 1000, .mode = SPI_MODE_0, .bus_num = 1, }, 

जैसा कि आप ऊपर दिए गए कोड से देख सकते हैं, मेरा डिवाइस 15 मेगाहर्ट्ज की आवृत्ति पर चल रहा है, CSI 1 के साथ SPI1 पर लटका हुआ है। यदि ऐसा नहीं किया जाता है, तो जब मॉड्यूल लोड होता है, तो ड्राइवर डिवाइस के साथ संबद्ध नहीं होगा।
मॉड्यूल का निर्माण करने के लिए, मैं निम्नलिखित मेकफाइल का उपयोग करता हूं:

 ifneq ($(KERNELRELEASE),) obj-m := spi_led.o else KDIR := /media/stuff/StarterKit/new_src/linux-2.6.39.1_st3 all: $(MAKE) -C $(KDIR) M=`pwd` modules endif 

केडीआईआर चर को कर्नेल स्रोतों के साथ अपने पथ को इंगित करना चाहिए।
विधानसभा इस प्रकार है:

 ARCH=arm CROSS_COMPILE=/opt/arm-2010q1/bin/arm-none-linux-gnueabi- make 

जहाँ CROSS_COMPILE वैरिएबल आपके क्रॉस-कंपाइलर उपसर्ग को इंगित करता है।
अब हम कर्नेल का पुनर्निर्माण करते हैं, हमारे मॉड्यूल को बोर्ड में स्थानांतरित करते हैं और इसे लोड करते हैं:

 insmod /path/to/spi_led.ko 

जिसके बाद डिवाइस की विशेषताएँ सिस्टम में दिखाई देंगी, और इसमें हम निम्नलिखित चित्र देखेंगे:

 ls /sys/module/spi_led/drivers/spi:spi_led/spi1.1 driver modalias mode power subsystem uevent value 

अब हम सीधे कोड पर लौटेंगे। देखो अंत से शुरू होना चाहिए। मैक्रोज़ MODULE_AUTHOR, MODULE_DESCRIPTION, MODULE_LICENSE, MODULE_VERSION उन सूचनाओं का निर्धारण करते हैं जो क्रमशः modinfo कमांड, लेखक का नाम, मॉड्यूल विवरण, लाइसेंस और संस्करण का उपयोग करके उपलब्ध होंगी। लाइसेंस का संकेत सबसे महत्वपूर्ण है, क्योंकि यदि आप गैर-जीपीएल लाइसेंस का उपयोग कर रहे हैं, तो आप जीपीएल लाइसेंस का उपयोग करके मॉड्यूल से कोड नहीं खींच पाएंगे।

मैक्रोज़ मॉड्यूल_इनिट () और मॉड्यूल_एक्सिट () क्रमशः मॉड्यूल इनिशियलाइज़ेशन और अनलोड कार्यों को परिभाषित करते हैं। यदि मॉड्यूल सांख्यिकीय रूप से बनाया गया है, तो मॉड्यूल_एक्सिट मैक्रो में निर्दिष्ट फ़ंक्शन कभी नहीं कहा जाएगा।

संरचना में संरचना spi_driver spi_led_driver, लिंक ड्राइवर से डिवाइस बाइंडिंग फ़ंक्शंस (जांच), डिवाइस डिस्कनेक्शन फ़ंक्शंस (निकालें) के लिए सेट हैं, और ड्राइवर का नाम भी स्वामी है। इसके अलावा, ऊर्जा-बचत मोड (सस्पेंड) में संक्रमण के कार्यों के लिंक और इससे बाहर निकलने (फिर से शुरू) को वहां सेट किया जा सकता है। यदि ड्राइवर एक ही वर्ग के कई अलग-अलग उपकरणों का समर्थन करता है, तो उनके पहचानकर्ता id_table फ़ील्ड में संग्रहीत किए जाते हैं।

सिस्टम में SPI ड्राइवर को पंजीकृत करना spi_register_driver फ़ंक्शन (संरचना spi_driver * sdrv) का उपयोग करके किया जाता है। यह पंजीकरण के बाद है कि डिवाइस और ड्राइवर जुड़ा हो सकता है। यदि सब ठीक हो जाता है, तो अगला फ़ंक्शन जांच सूचक में परिभाषित के रूप में कहा जाएगा। आप क्रमशः spi_unregister_driver फ़ंक्शन (संरचना spi_driver * sdrv) का उपयोग करके सिस्टम से ड्राइवर पंजीकरण हटा सकते हैं

Spi_led_probe () फ़ंक्शन पहले से spi_board_info में परिभाषित spi_device संरचना में डिवाइस के साथ काम करने के लिए नियंत्रक पैरामीटर सेट करता है। Spi_device संरचना में आवश्यक फ़ील्ड को ओवरराइड करने के बाद, spi_setup () नियंत्रक कॉन्फ़िगरेशन फ़ंक्शन कहा जाता है।

अब विशेषताओं पर चर्चा करें। आप दस्तावेज़ / फ़ाइल सिस्टम / sysfs.txt फ़ाइल में sysfs के माध्यम से उपकरण विशेषताओं के साथ काम करने के बारे में पढ़ सकते हैं। मैक्रो DEVICE_ATTR का उपयोग डिवाइस_टैटर की संरचना को परिभाषित करने के लिए किया जाता है। उदाहरण के लिए, ऐसी परिभाषा

 static DEVICE_ATTR(foo, S_IWUSR | S_IRUGO, show_foo, store_foo); 

निम्न के बराबर:

 static struct device_attribute dev_attr_foo = { .attr = { .name = "foo", .mode = S_IWUSR | S_IRUGO, .show = show_foo, .store = store_foo, }, }; 

जहां शो विशेषता फ़ाइल खोलने पर निष्पादित करने के लिए फ़ंक्शन का एक संकेतक है;
स्टोर - विशेषता फ़ाइल पर लिखते समय निष्पादित फ़ंक्शन के लिए एक संकेतक;
मोड - विशेषता फ़ाइल तक पहुँच अधिकार को परिभाषित करता है;
नाम - विशेषता फ़ाइल का नाम।
एक उदाहरण के लिए एक लाइन देखें

 static DEVICE_ATTR(value, S_IWUSR|S_IRUSR, spi_led_show_val, spi_led_store_val); 

यह नाम के साथ डिवाइस विशेषता को परिभाषित करता है, जिसे उपयोगकर्ता द्वारा पढ़ा / लिखा जाने की अनुमति है, विशेषता के रिकॉर्ड का प्रोसेसर फ़ंक्शन spi_led_store_val है, विशेषता पढ़ने का प्रोसेसर फ़ंक्शन spi_led_show_val है। फ़ंक्शन को स्टोर / शो करने के लिए एक बिंदु NULL हो सकता है यदि इस विशेषता का कोई लेखन / रीड उपलब्ध नहीं है।
आइए देखें कि इस विशेषता के साथ काम कैसा दिखता है:

 cd /sys/module/spi_led/drivers/spi:spi_led/spi1.1 ls -l value -rw------- 1 root root 4096 Jun 29 14:10 value echo "32">value cat value 64 

याद रखें, मैंने उल्लेख किया है कि हार्डवेयर का मेरा टुकड़ा डेटा को पढ़ते समय बाईं ओर एक बिट स्थानांतरित करता है? यही वजह है कि हमें 32 दर्ज के बजाय 64 मिले। क्या होता है जब कोई संख्या विशेषता फ़ाइल में लिखी जाती है: सख्त_strtoul () फ़ंक्शन प्राप्त स्ट्रिंग बफर को एक संख्या में बदलने की कोशिश करता है, फिर मूर्ख से सुरक्षा होती है - यह जांचना कि संख्या 255 से अधिक नहीं है। अगर, फिर भी, यह अधिक है, तो हम एक त्रुटि लौटाते हैं। उपयोगकर्ता के लिए, यह इस तरह दिखेगा:

 # echo "257">value bash: echo: write error: Invalid argument 

अगला वर्तमान ऑपरेटिंग मोड की जांच कर रहा है और इसके आधार पर, tmp वेरिएबल सेट किया गया है। प्रगति बार मोड के मामले में, "inextricable" यूनिट बिट्स के साथ एक संख्या प्राप्त की जाएगी, अन्यथा परिवर्तन के बिना उपयोगकर्ता द्वारा निर्दिष्ट बाइट एसपीआई में प्रदर्शित किया जाएगा। Fduplex_mode ध्वज के आधार पर, ट्रांसमिशन विधि का चयन किया जाता है: आधा-द्वैध या पूर्ण-द्वैध। पहले मामले में, spi_write () फ़ंक्शन का उपयोग किया जाता है, दूसरे में स्व-लिखित spd_write ()।

अब पूरा डाटा ट्रांसफर पर जाएं। जैसा कि आप देख सकते हैं, ट्रांसमिशन के लिए बफ़र्स (mtx, mrx पॉइंटर्स) के लिए मेमोरी को kzmalloc फ़ंक्शन का उपयोग करके मुझे आवंटित किया गया है। जैसा कि मैंने कहा, यह डीएमए के लिए उपलब्ध मेमोरी क्षेत्र में बफ़र्स की आवश्यकता के कारण है। अब हम fdx_transfer () फ़ंक्शन को देखते हैं। वास्तव में, यह spi_message संदेश एकत्र करता है, और इसे spi_sync () फ़ंक्शन का उपयोग करके पास करता है । संदेश भेजने के दौरान प्राप्त होने वाली बाइट वैश्विक वैरिएबल रिटेल में संग्रहीत होती है, जिसे हमेशा fduplex_mode फ्लैग सेट के मामले में मान विशेषता रीडिंग फ़ंक्शन द्वारा वापस किया जाएगा।

मोड विशेषता के साथ काम करना केवल स्थानांतरित मोड को पार्स करने में शामिल है, इसे दो वैश्विक चर led_mode और fduplex_mode में पार्स करना, जो क्रमशः प्रदर्शन मोड और द्वैध निर्धारित करते हैं।

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

मुझे उम्मीद है कि समझने के लिए बाकी समस्याओं के साथ नहीं उठना चाहिए।

5. प्रलेखन

कोर प्रलेखन की खोज के मुद्दे पर पहले ही यहां चर्चा की जा चुकी है ।
कर्नेल स्रोत प्रलेखन / निर्देशिका में प्रलेखन के एक सेट के साथ आते हैं। , .
kerneldoc. API :

 sudo apt-get install xmlto make htmldocs 

: www.kernel.org/doc
, Unreliable Guide To Hacking The Linux Kernel: www.kernel.org/doc/htmldocs/kernel-hacking.html
c SPI Linux Documentation/spi, spi-summary spidev. spidev: spidev_fdx.c spidev_test.c; .
sysfs Documentation/filesystems/sysfs.txt.
API SPI : SPI Linux kernel API description www.kernel.org/doc/htmldocs/device-drivers/spi.html
- Linux Cross Reference: lxr.linux.no lxr.free-electrons.com
Free Electrons: free-electrons.com/docs Embedded Linux, .

, , .