Android教程網
設為首頁|加入收藏
  1. 首頁
  2. Android 技術
  3. Android 手機
  4. Android 系統教程
  5. Android 游戲
 Android教程網 >> Android技術 >> 關於Android編程 >> Ubuntu中為Android系統上編寫Linux內核驅動程序實現方法

Ubuntu中為Android系統上編寫Linux內核驅動程序實現方法

編輯：關於Android編程

        在智能手機時代，每個品牌的手機都有自己的個性特點。正是依靠這種與眾不同的個性來吸引用戶，營造品牌凝聚力和用戶忠城度，典型的代表非iphone莫屬了。據統計，截止2011年5月，AppStore的應用軟件數量達381062個，位居第一，而Android Market的應用軟件數量達294738，緊隨AppStore後面，並有望在8月份越過AppStore。隨著Android系統逐步擴大市場占有率，終端設備的多樣性亟需更多的移動開發人員的參與。據業內統計，Android研發人才缺口至少30萬。目前，對Android人才需求一類是偏向硬件驅動的Android人才需求，一類是偏向軟件應用的Android人才需求。總的來說，對有志於從事Android硬件驅動的開發工程師來說，現在是一個大展拳腳的機會。那麼，就讓我們一起來看看如何為Android系統編寫內核驅動程序吧。

        這裡，我們不會為真實的硬件設備編寫內核驅動程序。為了方便描述為Android系統編寫內核驅動程序的過程，我們使用一個虛擬的硬件設備，這個設備只有一個4字節的寄存器，它可讀可寫。想起我們第一次學習程序語言時，都喜歡用“Hello, World”作為例子，這裡，我們就把這個虛擬的設備命名為“hello”，而這個內核驅動程序也命名為hello驅動程序。其實，Android內核驅動程序和一般Linux內核驅動程序的編寫方法是一樣的，都是以Linux模塊的形式實現的，具體可參考前面Android學習啟動篇一文中提到的Linux Device Drivers一書。不過，這裡我們還是從Android系統的角度來描述Android內核驅動程序的編寫和編譯過程。

       一. 參照前面兩篇文章Android源碼 在Ubuntu上下載,編譯和安裝和在Android內核源碼 在Ubuntu上下載,編譯,安裝（Linux Kernel）准備好Android內核驅動程序開發環境。

       二. 進入到kernel/common/drivers目錄，新建hello目錄：

             USER-NAME@MACHINE-NAME:~/Android$ cd kernel/common/drivers

             USER-NAME@MACHINE-NAME:~/Android/kernel/common/drivers$ mkdir hello

      三. 在hello目錄中增加hello.h文件：

#ifndef _HELLO_ANDROID_H_
#define _HELLO_ANDROID_H_

#include <linux/cdev.h>
#include <linux/semaphore.h>

#define HELLO_DEVICE_NODE_NAME "hello"
#define HELLO_DEVICE_FILE_NAME "hello"
#define HELLO_DEVICE_PROC_NAME "hello"
#define HELLO_DEVICE_CLASS_NAME "hello"

struct hello_android_dev {
	int val;
	struct semaphore sem;
	struct cdev dev;
};

#endif

        這個頭文件定義了一些字符串常量宏，在後面我們要用到。此外，還定義了一個字符設備結構體hello_android_dev，這個就是我們虛擬的硬件設備了，val成員變量就代表設備裡面的寄存器，它的類型為int，sem成員變量是一個信號量，是用同步訪問寄存器val的，dev成員變量是一個內嵌的字符設備，這個Linux驅動程序自定義字符設備結構體的標准方法。

        四.在hello目錄中增加hello.c文件，這是驅動程序的實現部分。

        驅動程序的功能主要是向上層提供訪問設備的寄存器的值，包括讀和寫。這裡，提供了三種訪問設備寄存器的方法，一是通過proc文件系統來訪問，二是通過傳統的設備文件的方法來訪問，三是通過devfs文件系統來訪問。下面分段描述該驅動程序的實現。

         首先是包含必要的頭文件和定義三種訪問設備的方法：

#include <linux/init.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/proc_fs.h>
#include <linux/device.h>
#include <asm/uaccess.h>

#include "hello.h"

/*主設備和從設備號變量*/
static int hello_major = 0;
static int hello_minor = 0;

/*設備類別和設備變量*/
static struct class* hello_class = NULL;
static struct hello_android_dev* hello_dev = NULL;

/*傳統的設備文件操作方法*/
static int hello_open(struct inode* inode, struct file* filp);
static int hello_release(struct inode* inode, struct file* filp);
static ssize_t hello_read(struct file* filp, char __user *buf, size_t count, loff_t* f_pos);
static ssize_t hello_write(struct file* filp, const char __user *buf, size_t count, loff_t* f_pos);

/*設備文件操作方法表*/
static struct file_operations hello_fops = {
	.owner = THIS_MODULE,
	.open = hello_open,
	.release = hello_release,
	.read = hello_read,
	.write = hello_write, 
};

/*訪問設置屬性方法*/
static ssize_t hello_val_show(struct device* dev, struct device_attribute* attr, char* buf);
static ssize_t hello_val_store(struct device* dev, struct device_attribute* attr, const char* buf, size_t count);

/*定義設備屬性*/
static DEVICE_ATTR(val, S_IRUGO | S_IWUSR, hello_val_show, hello_val_store);

   定義傳統的設備文件訪問方法，主要是定義hello_open、hello_release、hello_read和hello_write這四個打開、釋放、讀和寫設備文件的方法：

/*打開設備方法*/
static int hello_open(struct inode* inode, struct file* filp) {
	struct hello_android_dev* dev; 
	
	/*將自定義設備結構體保存在文件指針的私有數據域中，以便訪問設備時拿來用*/
	dev = container_of(inode->i_cdev, struct hello_android_dev, dev);
	filp->private_data = dev;
	
	return 0;
}

/*設備文件釋放時調用，空實現*/
static int hello_release(struct inode* inode, struct file* filp) {
	return 0;
}

/*讀取設備的寄存器val的值*/
static ssize_t hello_read(struct file* filp, char __user *buf, size_t count, loff_t* f_pos) {
	ssize_t err = 0;
	struct hello_android_dev* dev = filp->private_data; 

	/*同步訪問*/
	if(down_interruptible(&(dev->sem))) {
		return -ERESTARTSYS;
	}

	if(count < sizeof(dev->val)) {
		goto out;
	} 

	/*將寄存器val的值拷貝到用戶提供的緩沖區*/
	if(copy_to_user(buf, &(dev->val), sizeof(dev->val))) {
		err = -EFAULT;
		goto out;
	}

	err = sizeof(dev->val);

out:
	up(&(dev->sem));
	return err;
}

/*寫設備的寄存器值val*/
static ssize_t hello_write(struct file* filp, const char __user *buf, size_t count, loff_t* f_pos) {
	struct hello_android_dev* dev = filp->private_data;
	ssize_t err = 0; 

	/*同步訪問*/
	if(down_interruptible(&(dev->sem))) {
		return -ERESTARTSYS; 
	} 

	if(count != sizeof(dev->val)) {
		goto out; 
	} 

	/*將用戶提供的緩沖區的值寫到設備寄存器去*/
	if(copy_from_user(&(dev->val), buf, count)) {
		err = -EFAULT;
		goto out;
	}

	err = sizeof(dev->val);

out:
	up(&(dev->sem));
	return err;
}

定義通過devfs文件系統訪問方法，這裡把設備的寄存器val看成是設備的一個屬性，通過讀寫這個屬性來對設備進行訪問，主要是實現hello_val_show和hello_val_store兩個方法，同時定義了兩個內部使用的訪問val值的方法__hello_get_val和__hello_set_val：

/*讀取寄存器val的值到緩沖區buf中，內部使用*/
static ssize_t __hello_get_val(struct hello_android_dev* dev, char* buf) {
	int val = 0; 

	/*同步訪問*/
	if(down_interruptible(&(dev->sem))) { 
		return -ERESTARTSYS; 
	} 

	val = dev->val; 
	up(&(dev->sem)); 

	return snprintf(buf, PAGE_SIZE, "%d\n", val);
}

/*把緩沖區buf的值寫到設備寄存器val中去，內部使用*/
static ssize_t __hello_set_val(struct hello_android_dev* dev, const char* buf, size_t count) {
	int val = 0; 

	/*將字符串轉換成數字*/ 
	val = simple_strtol(buf, NULL, 10); 

	/*同步訪問*/ 
	if(down_interruptible(&(dev->sem))) { 
		return -ERESTARTSYS; 
	} 

	dev->val = val; 
	up(&(dev->sem));

	return count;
}

/*讀取設備屬性val*/
static ssize_t hello_val_show(struct device* dev, struct device_attribute* attr, char* buf) {
	struct hello_android_dev* hdev = (struct hello_android_dev*)dev_get_drvdata(dev); 

	return __hello_get_val(hdev, buf);
}

/*寫設備屬性val*/
static ssize_t hello_val_store(struct device* dev, struct device_attribute* attr, const char* buf, size_t count) { 
	struct hello_android_dev* hdev = (struct hello_android_dev*)dev_get_drvdata(dev); 
	
	return __hello_set_val(hdev, buf, count);
}

  定義通過proc文件系統訪問方法，主要實現了hello_proc_read和hello_proc_write兩個方法，同時定義了在proc文件系統創建和刪除文件的方法hello_create_proc和hello_remove_proc：

/*讀取設備寄存器val的值，保存在page緩沖區中*/
static ssize_t hello_proc_read(char* page, char** start, off_t off, int count, int* eof, void* data) {
	if(off > 0) {
		*eof = 1;
		return 0;
	}

	return __hello_get_val(hello_dev, page);
}

/*把緩沖區的值buff保存到設備寄存器val中去*/
static ssize_t hello_proc_write(struct file* filp, const char __user *buff, unsigned long len, void* data) {
	int err = 0;
	char* page = NULL;

	if(len > PAGE_SIZE) {
		printk(KERN_ALERT"The buff is too large: %lu.\n", len);
		return -EFAULT;
	}

	page = (char*)__get_free_page(GFP_KERNEL);
	if(!page) { 
		printk(KERN_ALERT"Failed to alloc page.\n");
		return -ENOMEM;
	} 

	/*先把用戶提供的緩沖區值拷貝到內核緩沖區中去*/
	if(copy_from_user(page, buff, len)) {
		printk(KERN_ALERT"Failed to copy buff from user.\n"); 
		err = -EFAULT;
		goto out;
	}

	err = __hello_set_val(hello_dev, page, len);

out:
	free_page((unsigned long)page);
	return err;
}
/*創建/proc/hello文件*/
static void hello_create_proc(void) {
	struct proc_dir_entry* entry;
	
	entry = create_proc_entry(HELLO_DEVICE_PROC_NAME, 0, NULL);
	if(entry) {
		entry->owner = THIS_MODULE;
		entry->read_proc = hello_proc_read;
		entry->write_proc = hello_proc_write;
	}
}

/*刪除/proc/hello文件*/
static void hello_remove_proc(void) {
	remove_proc_entry(HELLO_DEVICE_PROC_NAME, NULL);
}

 最後，定義模塊加載和卸載方法，這裡只要是執行設備注冊和初始化操作：

static int __hello_setup_dev(struct hello_android_dev* dev) {
	int err;
	dev_t devno = MKDEV(hello_major, hello_minor);

	memset(dev, 0, sizeof(struct hello_android_dev));

	cdev_init(&(dev->dev), &hello_fops);
	dev->dev.owner = THIS_MODULE;
	dev->dev.ops = &hello_fops; 

	/*注冊字符設備*/
	err = cdev_add(&(dev->dev),devno, 1);
	if(err) {
		return err;
	} 

	/*初始化信號量和寄存器val的值*/
	init_MUTEX(&(dev->sem));
	dev->val = 0;

	return 0;
}

/*模塊加載方法*/
static int __init hello_init(void){ 
	int err = -1;
	dev_t dev = 0;
	struct device* temp = NULL;

	printk(KERN_ALERT"Initializing hello device.\n"); 

	/*動態分配主設備和從設備號*/
	err = alloc_chrdev_region(&dev, 0, 1, HELLO_DEVICE_NODE_NAME);
	if(err < 0) {
		printk(KERN_ALERT"Failed to alloc char dev region.\n");
		goto fail;
	}

	hello_major = MAJOR(dev);
	hello_minor = MINOR(dev); 

	/*分配helo設備結構體變量*/
	hello_dev = kmalloc(sizeof(struct hello_android_dev), GFP_KERNEL);
	if(!hello_dev) {
		err = -ENOMEM;
		printk(KERN_ALERT"Failed to alloc hello_dev.\n");
		goto unregister;
	} 

	/*初始化設備*/
	err = __hello_setup_dev(hello_dev);
	if(err) {
		printk(KERN_ALERT"Failed to setup dev: %d.\n", err);
		goto cleanup;
	} 

	/*在/sys/class/目錄下創建設備類別目錄hello*/
	hello_class = class_create(THIS_MODULE, HELLO_DEVICE_CLASS_NAME);
	if(IS_ERR(hello_class)) {
		err = PTR_ERR(hello_class);
		printk(KERN_ALERT"Failed to create hello class.\n");
		goto destroy_cdev;
	} 

	/*在/dev/目錄和/sys/class/hello目錄下分別創建設備文件hello*/
	temp = device_create(hello_class, NULL, dev, "%s", HELLO_DEVICE_FILE_NAME);
	if(IS_ERR(temp)) {
		err = PTR_ERR(temp);
		printk(KERN_ALERT"Failed to create hello device.");
		goto destroy_class;
	} 

	/*在/sys/class/hello/hello目錄下創建屬性文件val*/
	err = device_create_file(temp, &dev_attr_val);
	if(err < 0) {
		printk(KERN_ALERT"Failed to create attribute val."); 
		goto destroy_device;
	}

	dev_set_drvdata(temp, hello_dev); 

	/*創建/proc/hello文件*/
	hello_create_proc();

	printk(KERN_ALERT"Succedded to initialize hello device.\n");
	return 0;

destroy_device:
	device_destroy(hello_class, dev);

destroy_class:
	class_destroy(hello_class);

destroy_cdev:
	cdev_del(&(hello_dev->dev));

cleanup:
	kfree(hello_dev);

unregister:
	unregister_chrdev_region(MKDEV(hello_major, hello_minor), 1);

fail:
	return err;
}

/*模塊卸載方法*/
static void __exit hello_exit(void) {
	dev_t devno = MKDEV(hello_major, hello_minor);

	printk(KERN_ALERT"Destroy hello device.\n"); 

	/*刪除/proc/hello文件*/
	hello_remove_proc(); 

	/*銷毀設備類別和設備*/
	if(hello_class) {
		device_destroy(hello_class, MKDEV(hello_major, hello_minor));
		class_destroy(hello_class);
	} 

	/*刪除字符設備和釋放設備內存*/
	if(hello_dev) {
		cdev_del(&(hello_dev->dev));
		kfree(hello_dev);
	} 

	/*釋放設備號*/
	unregister_chrdev_region(devno, 1);
}

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("First Android Driver");

module_init(hello_init);
module_exit(hello_exit);

       五.在hello目錄中新增Kconfig和Makefile兩個文件，其中Kconfig是在編譯前執行配置命令make menuconfig時用到的，而Makefile是執行編譯命令make是用到的：

       Kconfig文件的內容

           config HELLO
           tristate "First Android Driver"
           default n
           help
           This is the first android driver.

       Makefile文件的內容     

       obj-$(CONFIG_HELLO) += hello.o

      在Kconfig文件中，tristate表示編譯選項HELLO支持在編譯內核時，hello模塊支持以模塊、內建和不編譯三種編譯方法，默認是不編譯，因此，在編譯內核前，我們還需要執行make menuconfig命令來配置編譯選項，使得hello可以以模塊或者內建的方法進行編譯。

      在Makefile文件中，根據選項HELLO的值，執行不同的編譯方法。

      六. 修改arch/arm/Kconfig和drivers/kconfig兩個文件，在menu "Device Drivers"和endmenu之間添加一行： 

           source "drivers/hello/Kconfig"   

       這樣，執行make menuconfig時，就可以配置hello模塊的編譯選項了。

      七. 修改drivers/Makefile文件，添加一行：    

           obj-$(CONFIG_HELLO) += hello/

       八. 配置編譯選項：

        USER-NAME@MACHINE-NAME:~/Android/kernel/common$ make menuconfig     

        找到"Device Drivers" => "First Android Drivers"選項，設置為y。       

注意，如果內核不支持動態加載模塊，這裡不能選擇m，雖然我們在Kconfig文件中配置了HELLO選項為tristate。要支持動態加載模塊選項，必須要在配置菜單中選擇Enable loadable module support選項；在支持動態卸載模塊選項，必須要在Enable loadable module support菜單項中，選擇Module unloading選項。

       九. 編譯：     

      USER-NAME@MACHINE-NAME:~/Android/kernel/common$ make       

      編譯成功後，就可以在hello目錄下看到hello.o文件了，這時候編譯出來的zImage已經包含了hello驅動。    

      十. 參照在Ubuntu上下載、編譯和安裝Android最新內核源代碼（Linux Kernel）一文所示，運行新編譯的內核文件，驗證hello驅動程序是否已經正常安裝：      

        USER-NAME@MACHINE-NAME:~/Android$ emulator -kernel ./kernel/common/arch/arm/boot/zImage &
        USER-NAME@MACHINE-NAME:~/Android$ adb shell      

        進入到dev目錄，可以看到hello設備文件：      

        root@android:/ # cd dev
        root@android:/dev # ls      

        進入到proc目錄，可以看到hello文件：   

        root@android:/ # cd proc
        root@android:/proc # ls    

        訪問hello文件的值：    

        root@android:/proc # cat hello
        0

        root@android:/proc # echo '5' > hello
        root@android:/proc # cat hello
        5

        進入到sys/class目錄，可以看到hello目錄：

        root@android:/ # cd sys/class
        root@android:/sys/class # ls

        進入到hello目錄，可以看到hello目錄：

        root@android:/sys/class # cd hello
        root@android:/sys/class/hello # ls

        進入到下一層hello目錄，可以看到val文件：

        root@android:/sys/class/hello # cd hello
        root@android:/sys/class/hello/hello # ls

        訪問屬性文件val的值：

        root@android:/sys/class/hello/hello # cat val
        5

        root@android:/sys/class/hello/hello # echo '0'  > val
        root@android:/sys/class/hello/hello # cat val
        0    

  至此，我們的hello內核驅動程序就完成了，並且驗證一切正常。這裡我們采用的是系統提供的方法和驅動程序進行交互，也就是通過proc文件系統和devfs文件系統的方法，下一篇文章中，我們將通過自己編譯的C語言程序來訪問/dev/hello文件來和hello驅動程序交互，敬請期待。

 後續繼續整理相關文章資料，希望能幫助研究Android源碼的朋友,謝謝大家支持!

  1. 上一頁:
  2. 下一頁:
關於Android編程
Android編程入門Android技術基礎Android資訊關於Android編程Android開發Android開發環境Android開發實例
相關文章
熱門文章
Android 百分比布局庫(percent-support-lib) 解析與擴展 Android 拍照、選擇圖片並裁剪 Android中的進程和線程 Smack核心機制淺析 Android中在ScrollView中顯示ListView Android中的指紋識別demo開發實例
android學習十（android的文件存儲）

在android系統中主要提供了三種方式用於簡單的實現數據持久化功能，即
Android Zipalign工具優化Android APK應用

      
Android中通過Notification&NotificationManager實現消息通知

notification是一種讓你的應用程序在沒有開啟情況下或在後台運行
詳解Android之圖片加載框架Fresco基本使用(二)

PS：最近看到很多人都開始寫年終總結了，時間過得飛快，又到年底了，又老了
閱讀排行版
Copyright © Android教程網 All Rights Reserved