OpenWRT के साथ एक राउटर से मिनीकंप्यूटर: लिनक्स के लिए USB क्लास-ड्राइवर लिखना

परिचय

कार्यक्षेत्र तैयार करना

#include <linux/module.h> /* Needed by all modules */ #include <linux/kernel.h> /* Needed for KERN_INFO */ #include <linux/init.h> /* Needed for the macros */ #define DRIVER_AUTHOR "Amon-Ra" #define DRIVER_DESC "USB STM32-based LCD module driver" static int __init lcddriver_init(void) { printk(KERN_INFO "Hello, world!\n"); return 0; } static void __exit lcddriver_exit(void) { printk(KERN_INFO "Goodbye, world!\n"); } module_init(lcddriver_init); module_exit(lcddriver_exit); MODULE_LICENSE("GPL"); MODULE_AUTHOR(DRIVER_AUTHOR); MODULE_DESCRIPTION(DRIVER_DESC); 

1. हम लक्ष्य / linux / ar71xx / files / ड्राइवर में जाते हैं और वहां mkdir वीडियो चलाते हैं, जो हमारे ड्राइवर के लिए एक निर्देशिका बनाता है । Buildroot स्रोत ट्री की संगत निर्देशिकाओं में फ़ाइलों की सामग्री को स्कैन करता है। हम नए बनाए गए फ़ोल्डर में usblcd.c फ़ाइल डालते हैं।
2. लक्ष्य / linux / ar71xx / मॉड्यूल.mk में हम नए कर्नेल पैकेज के लिए एक प्रविष्टि जोड़ते हैं। यह याद रखना चाहिए कि कर्नेल पैकेज कर्नेल मॉड्यूल के समान नहीं हैं। कर्नेल पैकेज OpenWRT में ओपका उपयोगिता के लिए अभिप्रेत पैकेज हैं, उन्हें एक छवि में बनाया जा सकता है या एक अलग पैकेज के रूप में संकलित किया जा सकता है, लेकिन यह प्रभावित नहीं करेगा कि संबंधित कर्नेल मॉड्यूल कैसे बनाया जाता है।
   सीधे शब्दों में कहें - अगर हमारे पास किसी तरह का बाइनरी है, तो हम या तो अधिक कुछ नहीं करने के लिए इसे पैकेज में धकेल सकते हैं (विकल्प एम मेनुकोनफिग में विकल्प), इसे बंडल पैकेज के साथ डायरेक्टरी में रहने के लिए, या निर्माणाधीन इमेज के फाइल सिस्टम में निर्माण करने के लिए, पूर्व-स्थापित करें डिफ़ॉल्ट रूप से। इसके अलावा, अगर यह बाइनरी एक कर्नेल मॉड्यूल है, तो, कर्नेल को संकलित करते समय, निश्चित रूप से, इसे एक अलग मॉड्यूल के रूप में बनाया जाएगा ताकि इसे पैकेज में धकेल दिया जा सके। आप कर्नेल में कर्नेल मॉड्यूल को केवल कर्नेल_मेन्यूकोफिग (या इन कर्नेल कॉन्फिगर फ़ाइलों के लिए पैच के माध्यम से) में एम्बेड कर सकते हैं।
   यह, पहली बार में, कुछ भ्रम पैदा कर सकता है और पता लगा सकता है कि क्यों एक पैकेज जो स्पष्ट रूप से अंतर्निहित कर्नेल मॉड्यूल उत्पन्न करता है। हालांकि, यदि आप इस तंत्र को समझ लेते हैं, तो सब कुछ स्पष्ट और तार्किक हो जाता है।
   हम ड्राइवर को एक अलग मॉड्यूल के रूप में बनाएंगे, और इसे एफएस में बनाने के लिए या नहीं, यह हर बार फिर से हल करना संभव होगा, विधानसभा को मेन्यूकोफिग के माध्यम से पुन: कॉन्फ़िगर करके।
   
   
   Mod.mk को लिखना

    define KernelPackage/usb-lcd SUBMENU:=$(USB_MENU) TITLE:=USB STM32-based LCD module DEPENDS:=@TARGET_ar71xx KCONFIG:=CONFIG_STM32_USB_LCD FILES:=$(LINUX_DIR)/drivers/video/usblcd.ko endef define KernelPackage/usb-lcd/description Kernel module for USB STM32-based LCD module. endef $(eval $(call KernelPackage,usb-lcd)) 

   
   
   
   यहां हमने मेनुकोनफिग द्वारा बनाई गई नई प्रविष्टि के लिए नियम निर्धारित किए हैं - हम कहते हैं कि पैकेज USB सबमेनू में होगा, जो हम सेट करते हैं, AR71xx- आधारित प्लेटफॉर्म से संबंधित है।
   इसके बाद, हम सूचित करते हैं कि यह किस कर्नेल विकल्प को सक्रिय करता है - इसे CONFIG_STM32_USB_LCD कहें।
   फिर फाइल का नाम आता है कि सिस्टम पैकेज में बंद हो जाएगा - संकलन के बाद, हमारा मॉड्यूल usblcd.ko बन जाएगा, और इसे निर्दिष्ट करें। फिर हम विवरण सेट करते हैं और इस सभी के स्क्रिप्ट प्रसंस्करण को खींचने वाली अंतिम पंक्ति को नहीं भूलते हैं।
   
3. OpenWRT की जड़ से हम मेनुकोनफिग को निष्पादित करते हैं, कर्नेल मॉड्यूल / यूएसबी में हमारे पैकेज की तलाश करते हैं, और कहते हैं कि हम इसे परिणामी छवि में शामिल करना चाहते हैं।
   
4. यह मॉड्यूल के निर्माण के लिए पर्याप्त नहीं है, इस पैकेज का विकल्प केवल कर्नेल बनाते समय CONFIG_STM32_USB_LCD विकल्प निर्धारित करेगा। इस विकल्प का अर्थ कुछ भी करने के लिए, आपको <डायरेक्टरी से कर्नेल स्रोतों> / ड्राइवरों / वीडियो से कोन्कफिग और मेकफाइल फ़ाइलों को संपादित करने की आवश्यकता है। हालाँकि, अगर हम इसके लिए build_dir में आते हैं, तो हमें कुछ भी अच्छा नहीं मिलता है, हमें पहले ही पता चला है कि सामग्री हर बार पुनर्जीवित होती है। सही तरीका यह है कि कर्नेल फ़ाइलों के लिए एक बोर्ड-विशिष्ट पैच बनाएं और इसे / लक्ष्य / लिनक्स / ar71xx / पैच में रखें । इसके लिए हमें रजाई चाहिए - पैच के साथ काम करने के लिए एक प्रणाली। आप इसके बारे में विकी.ओपनडब्ल्यूआरटी के साथ लेख में और अधिक पढ़ सकते हैं।
   रजाई स्थापित करें (sudo apt-get install रजाई) और इसे विकी लेख का उपयोग करके कॉन्फ़िगर करें:
   
   

    cat > ~/.quiltrc <<EOF QUILT_DIFF_ARGS="--no-timestamps --no-index -pab --color=auto" QUILT_REFRESH_ARGS="--no-timestamps --no-index -pab" QUILT_PATCH_OPTS="--unified" QUILT_DIFF_OPTS="-p" EDITOR="nano" EOF 

   
   
5. आदेश निष्पादित करें
   
   

    make target/linux/{clean,prepare} V=s QUILT=1 

   
   वह हमें आगे के उपयोग के लिए build_dir में स्रोत पेड़ तैयार करेगा।
   
6. Build_dir में कर्नेल स्रोतों के साथ निर्देशिका पर जाएं। संस्करण भिन्न हो सकता है, इसलिए आपको कर्नेल के संस्करण संख्या के अनुसार पथ को समायोजित करने की आवश्यकता होगी।
   उसके बाद, हम उन सभी पैच को लागू करते हैं जो हमारी विधानसभा के लिए अभिप्रेत हैं।
   
   

    cd build_dir/target-mips_r2_uClibc-0.9.33.2/linux-ar71xx_generic/linux-3.6.9/ quilt push –a 

   
   
7. अगला, आपको एक नाम के साथ एक पैच बनाने की ज़रूरत है जो एक विशिष्ट नियम से मेल खाती है - यह एक ऐसे नंबर से शुरू होना चाहिए जो मौजूदा पैच में से किसी से भी बड़ा हो - यह उस क्रम को प्रभावित करता है जिसमें पैच लागू होते हैं और टकराव से बचा जाता है। कर्नेल के इस संस्करण में कौन से पैच लागू किए गए हैं, यह जानने के लिए, रजाई सीरीज़ कमांड का उपयोग करें और जेनेरिक और प्लेटफ़ॉर्म-विशिष्ट पैच वाली एक बड़ी-बड़ी सूची प्राप्त करें। क्योंकि पैच प्लेटफ़ॉर्म-विशिष्ट होगा, प्लेटफ़ॉर्म / xxx- <name> .patch को देखें । मेरे पास जो संशोधन है, उसके लिए अंतिम एक प्लेटफॉर्म / a06-rb750_nand-add-बफर-वेरीफिकेशन.चैच है, तो चलिए संख्या b00 लेते हैं।
   हम अमल करते हैं
   
   

    quilt new platform/b00-usb-lcd.patch 

   
   
8. हम kilt को सूचित करेंगे कि कौन सी फाइलें हम पैच करेंगे:
   
   

    quilt add drivers/video/Kconfig quilt add drivers/video/Makefile 

   
   
9. संपादन फ़ाइलें अधिक सुविधाजनक है। आइए Kconfig से शुरू करें, जिसमें कर्नेल कॉन्फ़िगरेशन मेनू के लिए परिभाषाएँ हैं। हमारा ड्राइवर अभी तक एक "ईमानदार" फ्रेमबफ़र ड्राइवर नहीं है, इसलिए इसे रूट पर, अर्थात् लाइनों में जोड़ें
   menuconfig fb
   tristate "फ्रेम बफर उपकरणों के लिए समर्थन"
   
   हम लिखते हैं:
   
   

    config STM32_USB_LCD tristate "USB STM32-based LCD module support" help Simple USB STM32-based LCD module driver 

   
   यह ड्राइवर - ग्राफिक्स सपोर्ट मेनू में स्थित कर्नेल सेटिंग्स मेनू में एक नया आइटम पेश करेगा।
   अब Makefile को संपादित करें, # हार्डवेयर विशिष्ट ड्राइवरों के पहली पंक्ति में जाने के बाद इसे कहीं और जोड़ दें
   
   

    obj-$(CONFIG_STM32_USB_LCD) += usblcd.o 

   
   यह हमारे मॉड्यूल को संकलित लोगों की सूची में जोड़ देगा, जब तक कि निश्चित रूप से, यह कॉन्फ़िगरेशन में चयनित नहीं है।
   
10. हम यह सुनिश्चित करते हैं कि रजाई अलग-अलग कमांड जारी करके सब कुछ ठीक है, जिसके परिणामस्वरूप पैच फ़ाइल को आउटपुट करना चाहिए।
    हम रजाई ताज़ा कहते हैं, प्राप्त पैच को बचाने के बाद।
    
11. बिल्डरुट के रूट पर वापस जाएं और कहें कि टारगेट / लाइनक्स / अपडेट V = s करें
    हम जाँचते हैं कि कमांड के आउटपुट की अंतिम लाइनें कुछ इस तरह होंगी
    ' -सब-एलसीडी ’
    
12. हम कमांड को क्लीन एंड& मेक बनाते हैं , फ़र्मवेयर के लिए एक इमेज बनाते हैं , इसे राउटर (/ tmp में, उदाहरण के लिए) और रिफलैश पर अपलोड करते हैं। यह mtd के माध्यम से संभव है, यह sysupgrad के माध्यम से संभव है - दूसरे मामले में, आप अपनी सेटिंग्स / आदि को बचा सकते हैं, जो उपयोगी हो सकता है (स्विच -c):
    
    

     scp bin/openwrt-ar71xx-generic-tl-mr3020-v1-squashfs-sy supgrade.bin root@192.168.0.48:/tmp sysupgrade -c openwrt-ar71xx-generic-tl-mr3020-v1-squashfs-sy supgrade.bin 

    
    
13. हम SSH के माध्यम से राउटर पर जाते हैं, देखते हैं कि हमारे पास क्या / lib / मॉड्यूल हैं - यदि सब कुछ सही ढंग से किया गया था, अन्य कर्नेल मॉड्यूल के बीच में हमारा usblcd.ko होगा
    Insmod usblcd && rmmod usblcd चलाएँ
    कुछ भी नहीं गिरना चाहिए और आम तौर पर किसी भी तरह से प्रतिक्रिया करना चाहिए।
    हम dmesg लिखते हैं - और यहां हमें नवीनतम पोस्टों में देखना चाहिए:
    
    [२ ९ १.६३००००] नमस्कार, दुनिया!
    [२ ९ १.६४००००] अलविदा, दुनिया!

ड्राइवर

1. सबसे पहले, हमें एक संरचना की घोषणा करनी चाहिए जिसके द्वारा कर्नेल को पता चल जाएगा कि हम किन उपकरणों की सेवा कर सकते हैं। हम usb_device_id तालिका घोषित करते हैं:
   
   

    static struct usb_device_id lcd_table[]={ {USB_DEVICE(DEVICE_VENDOR_ID, DEVICE_PRODUCT_ID)}, { } }; 

   
   यहां DEVICE_VENDOR_ID और DEVICE_PRODUCT_ID परिभाषित VID और PID समान हैं, क्रमशः, 0xDEAD और 0xF00D - हमारे वीडियो कार्ड के समान हैं।
   
2. घोषणा के तुरंत बाद, हम मैक्रो कहते हैं
   MODULE_DEVICE_TABLE (usb, lcd_table);
   उपयोगकर्ताओं को सूचित करना कि हम तालिका में संकेतित उपकरणों को संसाधित करते हैं।
   
3. कॉलबैक की घोषणा
   शून्य LCDProbe (स्ट्रक्चर usb_interface * इंटरफ़ेस, कास्ट स्ट्रक्चर usb_device_id * id)
   और
   शून्य LCDDisconnect (स्ट्रक्चर usb_interface * इंटरफ़ेस)
   डिवाइस को कनेक्ट और डिस्कनेक्ट करते समय उन्हें बुलाया जाएगा। उन्हें अभी के लिए खाली छोड़ दें।
   
4. हम एक महत्वपूर्ण संरचना की घोषणा करते हैं जिसमें हम उपरोक्त सभी को जोड़ते हैं:
   
   
   Usb_driver संरचना

    struct usb_driver usblcd_driver={ .owner = THIS_MODULE, .name = "usblcd", .probe = LCDProbe, .disconnect = LCDDisconnect, .id_table = lcd_table, }; 

   
   
   
   
5. आमतौर पर, एक नया USB ड्राइवर मॉड्यूल_init में पंजीकृत होता है और मॉड्यूल_एक्सिट में deregistered होता है , लेकिन इन दो कॉलबैक का वर्णन करने के बजाय, एक सुविधाजनक मैक्रो है जो मैन्युअल रूप से मॉड्यूल इनिशियलाइज़ेशन और डीइनराइजेशन फ़ंक्शन का वर्णन करने की आवश्यकता को समाप्त करता है, वे मैक्रो और का उपयोग करते समय कोड में शामिल होंगे। usb_register (...) और usb_deregister (...) को कॉल करना, हमारे ड्राइवर को पंजीकृत / deregistering करना होगा, और इससे अधिक कुछ भी उनकी आवश्यकता नहीं है:
   
   

    module_usb_driver(usblcd_driver); 

   
   

 [ 6002.060000] usbcore: registered new interface driver usblcd [ 6010.850000] usb 1-1: new full-speed USB device number 2 using ehci-platform [ 6011.010000] USB STM32-based LCD module connected [ 6015.140000] usb 1-1: USB disconnect, device number 2 [ 6015.140000] USB STM32-based LCD module disconnected [ 6024.240000] usbcore: deregistering interface driver usblcd 

 static struct usb_class_driver usblcd_class = { .name = "lcd%d", .fops = &LCD_fops, .minor_base = LCD_MINOR_BASE, }; 

1. हम कॉलबैक घोषित करते हैं (शुरुआत के लिए, आप उन्हें कोड के बिना छोड़ सकते हैं, केवल रिटर्न 0 के साथ)
   
   
   कॉलबैक

    static int LCDOpen(struct inode *inode, struct file *filp); static int LCDrelease(struct inode *inode, struct file *file); static ssize_t LCDwrite(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos); 

   
   
   
   
2. File_operations संरचना की घोषणा करें:
   
   
   File_operations संरचना

    static struct file_operations LCD_fops = { .owner = THIS_MODULE, .write = LCDwrite, .open = LCDOpen, .release = LCDrelease, }; 

   
   
   
   एक .read कॉलबैक की अनुपस्थिति का मतलब है कि केवल-लेखन का उपयोग (इसी तरह, आप लेखन को जोड़े बिना कर सकते हैं। ओपन या रिलीज़ की कमी का मतलब यह नहीं होगा कि आप डिवाइस फ़ाइल को खोल या बंद नहीं कर सकते हैं, लेकिन, इसके विपरीत, इसका मतलब होगा कि ये ऑपरेशन हमेशा सफल हैं)।
   
3. लगभग हमेशा डिवाइस से जुड़े किसी प्रकार के वैश्विक डेटा को संग्रहीत करने और इन सभी कॉलबैक में स्थानांतरित करने की आवश्यकता होती है, इसलिए वे आमतौर पर अपनी स्वयं की कस्टम संरचना शुरू करते हैं, जिनमें से एक फ़ील्ड usb_device का एक संकेतक होगा, सिस्टम द्वारा हमें दिया जाता है जब जांच कॉलबैक कहा जाता है (या बल्कि, या जांच के लिए दिए गए इंटरफ़ेस से प्राप्त), शेष फ़ील्ड को आपकी इच्छानुसार सेट किया जा सकता है। तो, हम डिवाइस डिस्क्रिप्टर संरचना का वर्णन करते हैं:
   
   
   Usblcd डिवाइस डिस्क्रिप्टर संरचना

    struct usblcd { struct usb_device *udev; struct usb_interface *interface; unsigned char minor; struct usb_endpoint_descriptor *bulk_out_ep; unsigned int bulk_out_packet_size; unsigned char *videobuffer; }; 

   
   
   
   
4. हम कॉलबैक जांच का वर्णन करते हैं। इसमें, हम डिवाइस की संरचना को इनिशियलाइज़ करते हैं और डिवाइस से जुड़े बफ़र्स की सभी इनिशियलाइज़ेशन करते हैं। यदि हमारे पास बफ़र हैं जो डिवाइस फ़ाइल के प्रत्येक खुले उदाहरण के लिए अलग-अलग हैं, तो उन्हें LCD_fops.open में सूचित किया जाना चाहिए
   
   
   जांच कॉलबैक कोड

    static int LCDProbe(struct usb_interface *interface, const struct usb_device_id *id) { struct usblcd *dev; struct usb_host_interface *iface_desc; struct usb_endpoint_descriptor *endpoint; int retval = -ENODEV; int i; dev = kzalloc(sizeof(*dev), GFP_KERNEL); if (!dev) { dev_err(&interface->dev, "Out of memory\n"); retval = -ENOMEM; goto exit; } dev->udev=interface_to_usbdev(interface); mutex_init(&dev->io_mutex); dev->interface = interface; iface_desc = interface->cur_altsetting; for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { endpoint = &iface_desc->endpoint[i].desc; if(usb_endpoint_is_bulk_out(endpoint)) { dev->bulk_out_ep=endpoint; dev->bulk_out_packet_size = le16_to_cpu(endpoint->wMaxPacketSize); break; } } if(!dev->bulk_out_ep) { dev_err(&interface->dev, "Can not find bulk-out endpoint!\n"); retval = -EIO; goto error_dev; } dev->videobuffer=kmalloc(TOTAL_BUFFER_SIZE, GFP_KERNEL); if (!dev->videobuffer) { dev_err(&interface->dev, "Out of memory\n"); retval = -ENOMEM; goto error_dev; } usb_set_intfdata(interface, dev); retval = usb_register_dev(interface, &usblcd_class); if (retval) { dev_err(&interface->dev, "Not able to get a minor for this device."); usb_set_intfdata(interface, NULL); goto error_buff; } dev->minor = interface->minor; dev_info(&interface->dev, "USB STM32-based LCD module connected as lcd%d\n",dev->minor-LCD_MINOR_BASE); return 0; error_buff: kfree(dev->videobuffer); error_dev: kfree(dev); exit: return retval; } 

   
   
   
   Usb_device * udv को पॉइंटर इंटरफ़ेस से * usb_interface पॉइंटर से प्राप्त होता है जिसे कॉलबैक द्वारा interface_to_usbdev (इंटरफ़ेस) के माध्यम से कॉलबैक में दिया जाता है। चूंकि एक उपकरण में कई इंटरफेस हो सकते हैं, इसलिए हमें एक ही संरचना ( इंटरफ़ेस-> cur_altsetting (); ) के क्षेत्र से वर्तमान इंटरफ़ेस हैंडल ( usb_host_interface ) मिलता है ;
   अगला, हम इंटरफ़ेस के सभी समापन बिंदुओं के माध्यम से जाते हैं, यह देखने के लिए कि क्या हमें कोई ज़रूरत है, हमारे लिए पॉइंटर्स रखते हुए और हमारे डिवाइस डिस्क्रिप्टर संरचना के लिए त्वरित पहुँच के लिए एक स्वीकार्य पैकेट आकार है। बल्क एंडपॉइंट के लिए, भेजने के दौरान बफ़र आकार को इस मान से बड़ा किया जा सकता है, कर्नेल आपके डेटा को उचित आकार के पैकेट में तोड़ देगा, इसलिए, सिद्धांत रूप में, इस मान का उपयोग कोड में कहीं और नहीं किया गया है, मैंने इसे केवल अपनी मन की शांति के लिए बचाया है, यह सुनिश्चित कर रहा है वहाँ बिल्कुल उन 0x40 बाइट्स हैं जो मैंने डिस्क्रिप्टर में इंगित किए थे। जाँचता है कि एक बिंदु एक या दूसरे प्रकार से संबंधित है या नहीं फॉर्म usb_endpoint_is_bulk_out (समापन बिंदु) के मैक्रोज़ द्वारा किया जाता है। यह मत भूलो कि संख्यात्मक क्षेत्रों के मूल्यों को सही ढंग से प्राप्त करने के लिए, आपको उनके बाइट ऑर्डर को प्रोसेसर के अनुसार उपयोग करना होगा जैसे कि le16_to_cpu (थोड़ा एंडियन 16-बिट सीपीयू ऑर्डर) जैसे कार्यों के माध्यम से। जब सब कुछ आरंभीकृत किया जाता है, तो डिस्क्रिप्टर को पॉइंटर को कर्नेल की बहुत संरचना में संग्रहीत किया जाता है, जिसे वह कॉलबैक में पास करता है, एक कॉल के माध्यम से usb_set_intfdata (इंटरफ़ेस, देव) के लिए; Probe कार्यक्षमता में अंतिम चरण USB क्लास चालक को पंजीकृत करना है। इस बिंदु से, फ़ाइल / dev / lcd [n] / dev में दिखाई देगी, और LCD_fops से कॉलबैक फ़ंक्शन को किसी भी समय (डिवाइस फ़ाइल तक पहुंचते समय) कॉल किया जा सकता है। पंजीकरण का सफल समापन इंटरफ़ेस में दर्ज किया जाएगा-> हमारे द्वारा सौंपे गए मामूली नाबालिग । इससे LCD_MINOR_BASE घटाते हुए, हमें वह नंबर मिलता है जिसके तहत डिवाइस / dev / में दिखाई देगा क्योंकि हमारे पास एक प्रदर्शन है, तो नाबालिग क्रमशः LCD_MINOR_BASE के बराबर होगा, / dev / lcd0 / dev में दिखाई देगा।
5. तुरंत सममित रूप से डिस्कनेक्ट कॉलबैक कोड लिखें, कॉल देव = usb_get_intfdata (इंटरफ़ेस) के माध्यम से हमारे usblcd डिस्क्रिप्टर को एक सूचक प्राप्त करना ;
   
   
   कॉलबैक कोड डिस्कनेक्ट करें

    static void LCDDisconnect(struct usb_interface *interface) { struct usblcd *dev; int minor; dev = usb_get_intfdata(interface); minor=dev->minor; usb_set_intfdata(interface, NULL); usb_deregister_dev(interface, &usblcd_class); dev->interface = NULL; kfree(dev->videobuffer); kfree(dev); dev_info(&interface->dev,"USB STM32-based LCD module lcd%d disconnected\n",minor-LCD_MINOR_BASE); } 

   
   
   
   हम NULL में इंटरफ़ेस में डेटा के लिए पॉइंटर सेट करते हैं और ड्राइवर वर्ग को डीरेगिस्टर करते हैं। इस क्षण से, कोई भी हमें उपयोगकर्ता स्थान से नहीं खींचता है। उसके बाद, हम अपने सभी आवंटित बफ़र्स को साफ़ करते हैं और, अंतिम चरण के रूप में, हम मेमोरी को देव संरचना से ही साफ़ करते हैं। , LCD_fops, , , . , , . « , Disconnect Open? Write?»
   , , write.
6. , .
   , .
   , , . , , , , : static atomic_t DeviceFree=ATOMIC_INIT(1);
   Open , Linux Device Drivers:
   
   

    if(!atomic_dec_and_test(&DeviceFree)) { atomic_inc(&DeviceFree); return -EBUSY; } return 0; 

   
   atomic_dec_and_test , , (DeviceFree = 1), (DeviceFree = 0), true, .. true .
   (DeviceFree = 0), DeviceFree = -1 false. (.. ) — (EBUSY, ). , , , — , .. DeviceFree -2 false.
7. तुरंत कॉलबैक रिलीज़
   एटॉमिक_की (& डिवाइसफ़्री) में जोड़ें;
   डिवाइस मुक्त है कि रिपोर्टिंग।

 [ 9323.880000] usbcore: registered new interface driver usblcd [ 9334.640000] usb 1-1: new full-speed USB device number 4 using ehci-platform [ 9334.800000] usblcd 1-1:1.0: USB STM32-based LCD module connected as lcd0 

 root@OpenWrt:~# cat /dev/lcd0 cat: read error: Invalid argument 

 root@OpenWrt:~# cat /dev/urandom > /dev/lcd0 -ash: cannot create /dev/lcd0: Device or resource busy 

1. हम हेडर फ़ाइल <linux / mutex.h>
   को शामिल करते हैं, डिस्क्रिप्टर संरचना में फ़ील्ड स्ट्रक्चर म्यूटेक्स io_mutex जोड़ें ;
   जांच कॉलबैक में - mutex_init (& dev-> io_mutex) को कॉल करके इसका आरंभीकरण ;
2. Disconnect, -:
   
   
   Disconnect

    static void LCDDisconnect(struct usb_interface *interface) { struct usblcd *dev; int minor; dev = usb_get_intfdata(interface); minor=dev->minor; usb_set_intfdata(interface, NULL); usb_deregister_dev(interface, &usblcd_class); mutex_lock(&dev->io_mutex); dev->interface = NULL; mutex_unlock(&dev->io_mutex); kfree(dev->videobuffer); kfree(dev); dev_info(&interface->dev,"USB STM32-based LCD module lcd%d disconnected\n",minor-LCD_MINOR_BASE); } 

   
   
   
   , , - dev->interface . , io_mutex, , ( dev->interface ), ( NULL).
   
3. Open:
   , ,
   subminor = iminor(inode);
   usb_interface interface = usb_find_interface(&usblcd_driver, subminor);
   dev = usb_get_intfdata(interface); . , mutex_lock(&dev->io_mutex); , , .
   , , LCD_fops:
   filp->private_data = dev;
   
   
   Open

    static int LCDOpen(struct inode *inode, struct file *filp) { struct usblcd *dev; struct usb_interface *interface; int retval = 0; int subminor; filp->private_data=NULL; if(!atomic_dec_and_test(&DeviceFree)) { atomic_inc(&DeviceFree); retval = -EBUSY; goto exit; } subminor = iminor(inode); interface = usb_find_interface(&usblcd_driver, subminor); if (!interface) { printk(KERN_ERR "usblcd driver error, can't find device for minor %d\n", subminor); retval = -ENODEV; goto exit; } dev = usb_get_intfdata(interface); if (!dev) { retval = -ENODEV; goto exit; } mutex_lock(&dev->io_mutex); if(!dev->interface) { retval = -ENODEV; goto unlock_exit; } filp->private_data = dev; dev_info(&interface->dev, "usblcd: opened successfuly"); unlock_exit: mutex_unlock(&dev->io_mutex); exit: return retval; } 

   
   
   
   
4. , , ( ) X (unsigned short), Y (unsigned short), (unsgned long). Little Endian.
   
   
   Write

    static ssize_t LCDwrite(struct file *filp, const char __user *user_buf, size_t count, loff_t *ppos) { struct usblcd *dev; struct usb_interface *interface; int retval = -ENODEV; int usbSent; int writtenCount=count; int x,y; if(*ppos>=VB_SIZE*2) { retval = -ENOSPC; goto exit; } if(*ppos+count>VB_SIZE*2) writtenCount=VB_SIZE*2-*ppos; dev = filp->private_data; if (!dev) { printk(KERN_ERR "usblcd driver error, no device found\n"); retval = -ENODEV; goto exit; } mutex_lock(&dev->io_mutex); interface = dev->interface; if (!interface) { printk(KERN_ERR "usblcd driver error, no device found\n"); retval = -ENODEV; goto exit; } if (copy_from_user(dev->videobuffer+8, user_buf, writtenCount)) { retval = -EFAULT; goto unlock_exit; } y=((int)((*ppos)>>1)/(int)WIDTH); x=((int)((*ppos)>>1))-y*WIDTH; *(unsigned short*)(dev->videobuffer)=cpu_to_le16(x); *(unsigned short*)(dev->videobuffer+2)=cpu_to_le16(y); *(unsigned long*)(dev->videobuffer+4)=cpu_to_le32(writtenCount>>1); retval = usb_bulk_msg(dev->udev, usb_sndbulkpipe(dev->udev, 1),dev->videobuffer, 8+writtenCount, &usbSent, HZ*5); if (!retval) { retval = writtenCount; *ppos+=writtenCount; } else { retval=-EIO; goto unlock_exit; } unlock_exit: mutex_unlock(&dev->io_mutex); exit: return retval; } 

   
   
   
   , — 320*240*2 . — . *ppos, . , , , dev->interface — NULL . , , ( Endian ) usb_bulk_msg .
   , , , , .
   , , , , .. . .
   

 cat /dev/urandom > /dev/lcd0 

 cat /bin/busybox > /dev/lcd0 

 cat hobgoblin.raw > /dev/lcd0 

निष्कर्ष