एम्बेडेड लिनक्स के तहत एक एलसीडी डिस्प्ले के लिए ड्राइवर लिखना

इस लेख में मैं निर्माता न्यूहावेन्डिसप्लेज़ से 320x240 रंग प्रदर्शन के लिए एक लिनक्स ड्राइवर लिखने के अपने अनुभव को साझा करना चाहता हूं, अर्थात् एम्बेडेड लिनक्स के लिए NHD-5.7-320240WFB-CTXI-T1। एक लेख लिखने का विचार ठीक से पक गया है क्योंकि फ्रेमबुफर (एफबी) ड्राइवरों को लिखने के लिए बहुत सारे संसाधन नहीं हैं, खासकर रूसी में। मॉड्यूल नवीनतम कर्नेल (2.6.30) के लिए नहीं लिखा गया था, इसलिए मैं मानता हूं कि तब से एफबी इंटरफेस में बहुत सी चीजें बदल गई हैं। लेकिन, फिर भी, मुझे उम्मीद है कि लेख लाइनक्स कर्नेल स्तर को विकसित करने में रुचि रखने वालों के लिए दिलचस्प होगा। मैं बाहर नहीं करता हूं कि कार्यान्वयन को सरल और अधिक सुरुचिपूर्ण बनाया जा सकता है, इसलिए टिप्पणियों और टिप्पणियों का स्वागत है।





प्रागितिहास

प्रारंभ में, कार्य एक ड्राइवर लिखना था जिसे मानक उपकरणों जैसे क्यूटी एम्बेडेड का उपयोग करके एक्सेस किया जा सकता था, अंत में उपयोगकर्ता इंटरैक्शन के लिए आइकन और पाठ के साथ एक सरल मेनू बनाने के लिए। मंच AT91SAM9G45 पर एक दुपट्टा था, अधिक सटीक रूप से www.armdevs.com/IPC-SAM9G45.html
वीडियो को स्ट्रीम करने की योजना नहीं बनाई गई थी। AT91SAM9G45 में डीएमए समर्थन और एक उच्च गति वाली बस के साथ एक पूरी तरह कार्यात्मक अंतर्निहित एलसीडी नियंत्रक शामिल है, जिसके साथ वीडियो के लिए सभ्य गति प्राप्त करना संभव होगा, लेकिन अफसोस, यह SSD1963 के साथ संगत हार्डवेयर नहीं है। इसलिए, केवल उपलब्ध विकल्प के रूप में, इस उद्देश्य के लिए सामान्य GPIO इंटरफ़ेस का उपयोग करने का निर्णय लिया गया था।

SSD1963 नियंत्रक इंटरफ़ेस

कंट्रोलर डिस्प्ले इंटरफेसशीट से चित्र के रूप में प्रस्तुत करना सबसे आसान है:



ड्राइवर डेवलपर के दृष्टिकोण से, हम DB0 - DB7 पिन में रुचि रखते हैं। यह 8-बिट डेटा बस है, और DC, RD, WR, CS, RES पिन जो SSD1963 को डेटा ट्रांसफर करने की प्रक्रिया को नियंत्रित करने के लिए उपयोग किए जाते हैं।
प्रेषित डेटा के प्रारूप के रूप में, यह डिस्प्ले 888 प्रारूप का उपयोग करता है। इसका क्या अर्थ है: 8 बाइट्स - लाल, 8 बाइट्स - हरा, 8 बाइट्स - नीला। अभी भी अक्सर इस प्रकार के डिस्प्ले में आप विकल्प 555, 565 आदि पा सकते हैं, लेकिन यह हमारा मामला नहीं है। संचरित डेटा का प्रारूप चित्र में दिखाया गया है।



बस में डेटा का पहला बाइट सेट होने से पहले, CS और WR पिन 1 से 0. पर स्विच किए जाने चाहिए और डेटा बाइट सेट होने के बाद, CS और WR को 0 से 1 पर स्विच किया जाना चाहिए, जो वास्तव में बाइट को स्थानांतरित करता है। SSD1963 नियंत्रक को डेटा। संकेतों के अधिक विस्तृत तरंगों को नियंत्रक पर डेटाशीट में देखा जा सकता है। www.newhavendisplay.com/app_notes/SSD1963.pdf

स्रोत कोड में, हम GPIO पिन के सरणियों के साथ इंटरफेस का वर्णन करते हैं:

static unsigned int nhd_data_pin_config[] = { AT91_PIN_PE13, AT91_PIN_PE14, AT91_PIN_PE17, AT91_PIN_PE18, AT91_PIN_PE19, AT91_PIN_PE20, AT91_PIN_PE21, AT91_PIN_PE22 }; static unsigned int nhd_gpio_pin_config[] = { AT91_PIN_PE0, // RESET AT91_PIN_PE2, // DC AT91_PIN_PE5, // CLK AT91_PIN_PE6, // RD AT91_PIN_PE1 // WR }; 

इस इंटरफ़ेस पर बाइट ट्रांसफर फ़ंक्शन है:

 static void nhd_write_data(int command, unsigned short value) { int i; at91_set_gpio_output(AT91_PIN_PE12, 1); //R/D for (i=0; i<ARRAY_SIZE(nhd_data_pin_config); i++) at91_set_gpio_output(nhd_data_pin_config[i], (value>>i)&0x01); if (command) at91_set_gpio_output(AT91_PIN_PE10, 0); //D/C else at91_set_gpio_output(AT91_PIN_PE10, 1); //D/C at91_set_gpio_output(AT91_PIN_PE11, 0); //WR at91_set_gpio_output(AT91_PIN_PE26, 0); //CS at91_set_gpio_output(AT91_PIN_PE26, 1); //CS at91_set_gpio_output(AT91_PIN_PE11, 1); //WR } 

जैसा कि आप देख सकते हैं, इस फ़ंक्शन का उपयोग करके, आप एलसीडी नियंत्रक को कमांड भेज सकते हैं (उदाहरण के लिए, डिस्प्ले को कॉन्फ़िगर करने के लिए), साथ ही साथ पिक्सेल के रूप में डेटा।

फ़्रेमबफ़र कोर मॉडल

जैसा कि आप जानते हैं, लिनक्स कर्नेल विभिन्न प्रकार के डिवाइस ड्राइवरों के लिए इंटरफेस प्रदान करता है - चार ड्राइवर, ब्लॉक ड्राइवर, यूएसबी चालक, आदि। फ़्रेमबफ़र ड्राइवर लिनक्स ड्राइवर मॉडल में एक अलग उपतंत्र भी है। FB ड्राइवर का प्रतिनिधित्व करने के लिए उपयोग की जाने वाली मुख्य संरचना linux / fb.h में संरचनात्मक fb_info है। वैसे, यह हेडर फ़ाइल लिनक्स कर्नेल कोड में हास्य के प्रेमियों के लिए भी रूचि लेगी, क्योंकि इसमें एक दिलचस्प कहानी शामिल है -
#define STUPID_ACCELF_TEXT_SHIT मुझे लगता है कि नाम अपने लिए बोलता है। लेकिन वापस fb_info संरचना में। हम दो संरचनाओं में रुचि लेंगे, जिसमें यह शामिल है - fb_var_screeninfo और fb_fix_screeninfo । हम उन्हें अपने प्रदर्शन के मापदंडों के साथ आरंभ करते हैं।

 static struct fb_fix_screeninfo ssd1963_fix __initdata = { .id = "SSD1963", .type = FB_TYPE_PACKED_PIXELS, .visual = FB_VISUAL_TRUECOLOR, .accel = FB_ACCEL_NONE, .line_length = 320 * 4, }; static struct fb_var_screeninfo ssd1963_var __initdata = { .xres = 320, .yres = 240, .xres_virtual = 320, .yres_virtual = 240, .width = 320, .height = 240, .bits_per_pixel = 32, .transp = {24, 8, 0}, .red = {16, 8, 0}, .green = {8, 8, 0}, .blue = {0, 8, 0}, .activate = FB_ACTIVATE_NOW, .vmode = FB_VMODE_NONINTERLACED, }; 

हमारे मामले में, 4 बाइट्स एक पिक्सेल के लिए आवंटित किए जाएंगे: 8-रेड, 8-ग्रीन, 8-ब्लू, 8-ट्रांसपेरेंट
मैं कुछ संरचना क्षेत्रों की व्याख्या करूंगा:

.type बिट्स को मेमोरी में वर्णन करने वाले बिट्स रखने का एक तरीका है। पैक्ड पिक्सल का मतलब है कि बाइट्स (हमारे मामले में 8888 को क्रमिक रूप से एक के बाद एक रखा जाएगा)।

.visual - प्रदर्शन रंग गहराई। हमारे मामले में, यह ट्रूकॉलर है - 24 बिट रंग गहराई

.accel - हार्डवेयर त्वरण

.transp, लाल, हरा, नीला - बस हमारे 8,8,8,8 प्रारूप को तीन क्षेत्रों - ऑफसेट, लंबाई और msb_right के रूप में सेट करें ।

इसके अलावा, कर्नेल में हमारे ड्राइवर को पंजीकृत करने के लिए, दो और संस्थाओं - एक डिवाइस और एक ड्राइवर का वर्णन करना आवश्यक है। हम FB डिवाइस ( स्ट्रक्चर ssd1963 ) का वर्णन करते हैं जिसमें हमारी वीडियो मेमोरी के पेज होंगे ( स्ट्रक्चर ss1963- पेज ):

 struct ssd1963_page { unsigned short x; unsigned short y; unsigned long *buffer; unsigned short len; int must_update; }; struct ssd1963 { struct device *dev; struct fb_info *info; unsigned int pages_count; struct ssd1963_page *pages; }; struct platform_driver ssd1963_driver = { .probe = ssd1963_probe, .remove = ssd1963_remove, .driver = { .name = "ssd1963" } }; 

प्रारंभ

किसी भी अन्य लिनक्स कर्नेल मॉड्यूल के साथ, हम init / remove फ़ंक्शन के एक जोड़े का वर्णन करेंगे। आइए init से शुरू करते हैं। फ़्रेमबफ़र ड्राइवर आमतौर पर प्लेटफ़ॉर्म_ड्राइवर के रूप में सिस्टम में पंजीकृत होते हैं:

 static int __init ssd1963_init(void) { int ret = 0; ret = platform_driver_register(&ssd1963_driver); if (ret) { pr_err("%s: unable to platform_driver_register\n", __func__); } return ret; } module_init(ssd1963_init); 

मंच चालक, बदले में, एक विशिष्ट चालक के लिए जांच फ़ंक्शन को कॉल करता है, जो सभी आवश्यक संचालन करता है - मेमोरी आवंटन, संसाधन आरक्षण, संरचना आरंभीकरण, आदि। यहाँ ssd1963_probe फ़ंक्शन का एक उदाहरण दिया गया है:

 static int __init ssd1963_probe(struct platform_device *dev) { int ret = 0; struct ssd1963 *item; struct fb_info *info; // Allocating memory for ssd1663 device item = kzalloc(sizeof(struct ssd1963), GFP_KERNEL); if (!item) { dev_err(&dev->dev, "%s: unable to kzalloc for ssd1963\n", __func__); ret = -ENOMEM; goto out; } item->dev = &dev->dev; dev_set_drvdata(&dev->dev, item); // Initializing fb_info struct using kernel framebuffer API info = framebuffer_alloc(sizeof(struct ssd1963), &dev->dev); if (!info) { ret = -ENOMEM; dev_err(&dev->dev, "%s: unable to framebuffer_alloc\n", __func__); goto out_item; } item->info = info; //Here info->par pointer is commonly used to store private data // In our case, we can use it to store pointer to ssd1963 device info->par = item; info->dev = &dev->dev; info->fbops = &ssd1963_fbops; info->flags = FBINFO_FLAG_DEFAULT; info->fix = ssd1963_fix; info->var = ssd1963_var; ret = ssd1963_video_alloc(item); if (ret) { dev_err(&dev->dev, "%s: unable to ssd1963_video_alloc\n", __func__); goto out_info; } info->screen_base = (char __iomem *)item->info->fix.smem_start; ret = ssd1963_pages_alloc(item); if (ret < 0) { dev_err(&dev->dev, "%s: unable to ssd1963_pages_init\n", __func__); goto out_video; } info->fbdefio = &ssd1963_defio; fb_deferred_io_init(info); ret = register_framebuffer(info); if (ret < 0) { dev_err(&dev->dev, "%s: unable to register_frambuffer\n", __func__); goto out_pages; } ssd1963_setup(item); ssd1963_update_all(item); return ret; out_pages: ssd1963_pages_free(item); out_video: ssd1963_video_free(item); out_info: framebuffer_release(info); out_item: kfree(item); out: return ret; } 

फ़ंक्शन पर कुछ टिप्पणियां। यहाँ हम क्रम में हैं:
- हमारे ssd1963 डिवाइस के लिए मेमोरी आवंटित करें
- हम मेमोरी आवंटित करते हैं और डिफ़ॉल्ट मानों (फ्रेमबफ़र_लॉक) के साथ सबसे पहले fb_info संरचना को शुरू करते हैं, क्योंकि हमें कई मापदंडों को बदलने की आवश्यकता नहीं है, और फिर हमारे ड्राइवर के लिए विशिष्ट मानों जैसे कि fb_var_screeninfo, fb_fix_screeninfo और fb_ops , जो हम थोड़ी देर बाद चर्चा करेंगे।
- वर्चुअल मेमोरी में पिक्सल के निरंतर बफर के लिए मेमोरी आवंटित करता है, जिसका उपयोग उपयोगकर्ता-अंतरिक्ष प्रक्रियाओं द्वारा रिकॉर्डिंग के लिए किया जाएगा।
- फ़्रेमबफ़र वर्चुअल मेमोरी में प्रत्येक पृष्ठ के लिए ssd1963_page का चयन करें। प्रत्येक ssd1963_page में साझा एफबी बफर, एक एक्स ऑफसेट, एक वाई ऑफसेट और एक पेज बफर लंबाई के संबंध में पृष्ठ बफर का प्रारंभ पता होगा। हमारे मामले में, फ़्रेमबफ़र क्षमता = लाइन_लेंथ * ऊंचाई = 320 * 4 * 240 = 307200 बाइट्स। ऐसी बफर क्षमता के लिए, हमें line_length * ऊंचाई / PAGE_SIZE = 307200/4096 = 75 पृष्ठ चाहिए। ध्यान दें कि वे एफबी मेमोरी में कैसे स्थित होंगे। थोड़ी देर बाद ssd1963_copy फ़ंक्शन को देखने पर इस पृष्ठ लेआउट को समझना आसान हो जाता है:



- हम अपने FB को सिस्टम में रजिस्टर करते हैं ( register_framebuffer ) और आस्थगित डेटा अपडेट ( fb_deferred_io_init ) के लिए प्रक्रिया आरंभ करते हैं, इस बारे में "सेक्शन" फ्रेमबफ़र के साथ ऑपरेशन "में और अधिक।
- ssd1963_setup AT91SAM9G45 CPU पर आवश्यक GPIO को कॉन्फ़िगर करता है और एलसीडी कंट्रोलर के शुरुआती सेटअप को निष्पादित करता है। हेक्स में रहस्यमय बाइट्स का एक सेट भेजने के रूप में प्रारंभिक कॉन्फ़िगरेशन एल्गोरिथ्म SSD1963 के लिए प्रलेखन से लिया गया है, इसलिए मैं यहां केवल फ़ंक्शन का हिस्सा दूंगा:

  void ssd1963_setup(struct ssd1963 *item) { nhd_init_gpio_regs(); //initializations of pins in nhd_data-gpio_pin_config at91_set_gpio_output(AT91_PIN_PE27, 0); //RESET udelay(5); at91_set_gpio_output(AT91_PIN_PE27, 1); //RESET udelay(100); nhd_write_data(NHD_COMMAND, 0x01); //Software Reset ... nhd_write_to_register(0xe0, 0x03); //LOCK PLL nhd_write_data(NHD_COMMAND, 0xb0); //SET LCD MODE TFT 18Bits nhd_write_data(NHD_DATA, 0x0c); //SET MODE 24 bits & hsync+Vsync+DEN … } 

- ssd1963_update_all सभी पृष्ठों के लिए must_update = 1 ध्वज सेट करता है और शेड्यूल_डेलएड_वर्क ((मद-> जानकारी- deferred_work, fbdefio-> देरी) को कॉल करके एक आस्थगित संदर्भ में प्रदर्शन अद्यतन तंत्र आरंभ करता है ;

इसलिए, हमें पता चला कि निष्कासन कार्य बहुत सरल है, आवंटित मेमोरी को मुक्त करें, और kB को एफबी संरचनाओं को लौटाएं:

 static int ssd1963_remove(struct platform_device *device) { struct fb_info *info = platform_get_drvdata(device); struct ssd1963 *item = (struct ssd1963 *)info->par; if (info) { unregister_framebuffer(info); ssd1963_pages_free(item); ssd1963_video_free(item); framebuffer_release(info); kfree(item); } return 0; } 

फ़्रेमबफ़र संचालन

तो, यह fb_ops संरचना पर विचार करने का समय है:

 static struct fb_ops ssd1963_fbops = { .owner = THIS_MODULE, .fb_read = fb_sys_read, .fb_write = ssd1963_write, .fb_fillrect = ssd1963_fillrect, .fb_copyarea = ssd1963_copyarea, .fb_imageblit = ssd1963_imageblit, .fb_setcolreg = ssd1963_setcolreg, .fb_blank = ssd1963_blank, }; 

मैं यहां सभी संरचना विधियां नहीं देता, एक जिज्ञासु पाठक उन्हें मॉड्यूल स्रोत कोड में या ड्राइवर / वीडियो निर्देशिका में कर्नेल कोड में किसी अन्य ड्राइवर में ढूंढने में सक्षम होगा। जैसा कि आपने अनुमान लगाया होगा, fb_ops संरचना उन कार्यों का वर्णन करती है जो हमारे ड्राइवर ले सकते हैं। सौभाग्य से, कर्नेल डेवलपर्स ने आंशिक रूप से sb_ या fb_sys प्रत्यय के साथ FB के साथ काम करने के लिए मानक कार्य प्रदान करके हमारे काम को सुगम बनाया, उदाहरण के लिए fb_sys_read । हमें सिर्फ fb_ops ( ssd1963_read, ssd1963_write , आदि) से कार्यों के हमारे कार्यान्वयन के लिए कार्यक्षमता जोड़ने की आवश्यकता है जो हमें जरूरत पड़ने पर हमारे impromptu वीडियो मेमोरी में डेटा को अपडेट करने की अनुमति देता है।

उदाहरण के लिए, ssd1963_fillrect फंक्शन इस तरह दिखेगा:

 static void ssd1963_fillrect(struct fb_info *p, const struct fb_fillrect *rect) { sys_fillrect(p, rect); ssd1963_touch(p, rect->dx, rect->dy, rect->width, rect->height); } 

जाहिर है, fb_fillrect system कॉल वीडियो डेटा को स्क्रीन के एक निश्चित आयताकार क्षेत्र में अपडेट करेगा , इसलिए हमें यह निर्दिष्ट करने की आवश्यकता है कि हमें किन पृष्ठों को must_update ध्वज के साथ चिह्नित करके अपडेट करना होगा, और फिर मैन्युअल रूप से वीडियो मेमोरी अपडेट प्रक्रिया को कॉल करना होगा:

 static void ssd1963_touch(struct fb_info *info, int x, int y, int w, int h) { struct fb_deferred_io *fbdefio = info->fbdefio; struct ssd1963 *item = (struct ssd1963 *)info->par; int i, ystart, yend; if (fbdefio) { //Touch the pages, so the deferred io will update them. for (i=0; i<item->pages_count; i++) { ystart=item->pages[i].y; yend=item->pages[i].y+(item->pages[i].len/info->fix.line_length)+1; if (!((y+h)<ystart || y>yend)) { item->pages[i].must_update=1; } } //Schedule the deferred IO to kick in after a delay. schedule_delayed_work(&info->deferred_work, fbdefio->delay); } } 

वीडियो मेमोरी में डेटा को आस्थगित संदर्भ के रूप में अपडेट किया जाता है। एक यूजर-स्पेस एप्लिकेशन जो ग्राफिक्स के साथ काम करता है, वीडियो मेमोरी में प्रत्येक फ्रेम को रिकॉर्ड करने के पूरा होने का इंतजार नहीं करेगा, जो काफी तार्किक है। Fb_info में स्थगित प्रसंस्करण को fb_deferred_io संरचना के रूप में परिभाषित किया गया है:

 static struct fb_deferred_io ssd1963_defio = { .delay = HZ / 20, .deferred_io = &ssd1963_update, }; 

प्रोटोटाइप के साथ Ssd1963_update फ़ंक्शन
void ssd1963_update (संरचना fb_info * जानकारी, संरचना list_head * pagelist);
यह सभी पृष्ठों को ताज़ा नहीं करता है, लेकिन केवल एक प्रक्रिया द्वारा उपयोगकर्ता-स्थान के पुनर्लेखन के परिणामस्वरूप या सिस्टम कॉल के परिणामस्वरूप, जैसे कि fb_fillrect और कंपनी के परिणाम के रूप में परिवर्तित किए गए पृष्ठ। तदनुसार, फ़ंक्शन का रूप है:

 static void ssd1963_update(struct fb_info *info, struct list_head *pagelist) { struct ssd1963 *item = (struct ssd1963 *)info->par; struct page *page; int i; list_for_each_entry(page, pagelist, lru) { item->pages[page->index].must_update=1; } //Copy changed pages. for (i=0; i<item->pages_count; i++) { if (item->pages[i].must_update) { item->pages[i].must_update=0; ssd1963_copy(item, i); } } } 

इस बिंदु पर, आपने शायद सोचा कि ssd1963_copy फ़ंक्शन क्या करता है । यह सिर्फ वीडियो मेमोरी पेजों से डेटा को कृत्रिम रूप से निर्मित, 8-बिट GPIO- आधारित बस में स्थानांतरित करने के सभी गंदे काम करता है।

Ssd1963_copy फ़ंक्शन

यहां उस आंकड़े को याद करना आवश्यक है, जो दिखाता है कि मेमोरी में हमारे पेज डिस्प्ले पिक्सल के साथ कैसे मेल खाते हैं। हम देखते हैं, उदाहरण के लिए, वह पृष्ठ [0] 320 पिक्सेल के शीर्ष तीन प्रदर्शन लाइनों और 4 वीं पंक्ति के लिए 64 पिक्सेल के लिए जानकारी संग्रहीत करता है। हमारे पास ऐसे 75 पृष्ठ हैं, और चित्र से चित्र है, और यह नोटिस करना मुश्किल नहीं है, पृष्ठ [5] 320 की 3 पंक्तियों को देखेंगे - 64 में से एक और तदनुसार, एक फ़ंक्शन जो पेज इंडेक्स को पैरामीटर के रूप में लेता है, उसमें स्विच (इंडेक्स%) होगा। 5) और प्रत्येक विशिष्ट पृष्ठ के लिए ऑफसेट के आधार पर, प्रदर्शन मेमोरी में इसे आवंटित "विंडो" पर डेटा भेजें। समारोह काफी लंबा है, इसलिए मैं इसका केवल एक हिस्सा दूंगा:

 static void ssd1963_copy(struct ssd1963 *item, unsigned int index) { unsigned short x,y, startx, endx, starty, endy, offset; unsigned long *buffer; unsigned int len; unsigned int count; x = item->pages[index].x; y = item->pages[index].y; buffer = item->pages[index].buffer; len = item->pages[index].len; switch (index%5) { case 0: offset = 0; startx = x; starty = y; endx = 319; endy = y+2; len = 960; nhd_set_window(startx, endx, starty, endy); nhd_write_data(NHD_COMMAND, 0x2c); for (count = 0; count < len; count++) { nhd_write_data(NHD_DATA,(unsigned char)((buffer[count+offset])>>16)); //red nhd_write_data(NHD_DATA,(unsigned char)((buffer[count+offset])>>8)); //green nhd_write_data(NHD_DATA,(unsigned char)(buffer[count+offset])); //blue } offset = len; startx = x; starty = y+3; endx = x+63; endy = y+3; len = 64; nhd_set_window(startx, endx, starty, endy); nhd_write_data(NHD_COMMAND, 0x2c); for (count = 0; count < len; count++) { nhd_write_data(NHD_DATA,(unsigned char)((buffer[count+offset])>>16)); //red nhd_write_data(NHD_DATA,(unsigned char)((buffer[count+offset])>>8)); //green nhd_write_data(NHD_DATA,(unsigned char)(buffer[count+offset])); //blue } break; case 1: …. 

यहाँ, nhd_set_window फ़ंक्शन nhd_write_data (NHD_COMMAND, ...) का उपयोग करके कॉन्फ़िगर किया गया है ; प्रदर्शन क्षेत्र जिसमें डेटा (पिक्सेल) दर्ज किया जाएगा।
nhd_write_data (NHD_COMMAND, 0x2c); - एलसीडी कंट्रोलर को एक कमांड जो अब डेटा स्ट्रीम का पालन करेगा।

और अंत में, एक डिस्प्ले वाले डिवाइस पर tslib पैकेज से ts_calibrate प्रोग्राम का स्क्रीनशॉट।
कौन परवाह करता है - मैं मॉड्यूल का पूरा कोड भेज सकता हूं: