ARM的嵌入式Linux移植体验之设备驱动

4.块设备驱动

　　块设备驱动程序的编写是一个浩繁的工程，其难度远超过字符设备，上千行的代码往往只能搞定一个简单的块设备，而数十行代码就可能搞定一个字符设备。因此，非得有相当的基本功才能完成此项工作。下面先给出一个实例，即mtdblock块设备的驱动。我们通过分析此实例中的代码来说明块设备驱动程序的写法（由于篇幅的关系，大量的代码被省略，只保留了必要的主干）：

#include <linux/config.h> #include <linux/devfs_fs_kernel.h> static void mtd_notify_add(struct mtd_info* mtd); static void mtd_notify_remove(struct mtd_info* mtd); static struct mtd_notifier notifier = { 　mtd_notify_add, 　mtd_notify_remove, 　NULL }; static devfs_handle_t devfs_dir_handle = NULL; static devfs_handle_t devfs_rw_handle[MAX_MTD_DEVICES]; static struct mtdblk_dev { 　struct mtd_info *mtd; /* Locked */ 　int count; 　struct semaphore cache_sem; 　unsigned char *cache_data; 　unsigned long cache_offset; 　unsigned int cache_size; 　enum { STATE_EMPTY, STATE_CLEAN, STATE_DIRTY } cache_state; } *mtdblks[MAX_MTD_DEVICES]; static spinlock_t mtdblks_lock; /* this lock is used just in kernels >= 2.5.x */ static spinlock_t mtdblock_lock; static int mtd_sizes[MAX_MTD_DEVICES]; static int mtd_blksizes[MAX_MTD_DEVICES]; static void erase_callback(struct erase_info *done) { 　wait_queue_head_t *wait_q = (wait_queue_head_t *)done->priv; 　wake_up(wait_q); } static int erase_write (struct mtd_info *mtd, unsigned long pos, int len, const char *buf) { 　struct erase_info erase; 　DECLARE_WAITQUEUE(wait, current); 　wait_queue_head_t wait_q; 　size_t retlen; 　int ret; 　/* 　* First, let's erase the flash block. 　*/ 　init_waitqueue_head(&wait_q); 　erase.mtd = mtd; 　erase.callback = erase_callback; 　erase.addr = pos; 　erase.len = len; 　erase.priv = (u_long)&wait_q; 　set_current_state(TASK_INTERRUPTIBLE); 　add_wait_queue(&wait_q, &wait); 　ret = MTD_ERASE(mtd, &erase); 　if (ret) { 　　set_current_state(TASK_RUNNING); 　　remove_wait_queue(&wait_q, &wait); 　　printk (KERN_WARNING "mtdblock: erase of region [0x%lx, 0x%x] " "on \"%s\" failed\n", pos, len, mtd->name); 　　return ret; 　} 　schedule(); /* Wait for erase to finish. */ 　remove_wait_queue(&wait_q, &wait); 　/* 　* Next, writhe data to flash. 　*/ 　ret = MTD_WRITE (mtd, pos, len, &retlen, buf); 　if (ret) 　　return ret; 　if (retlen != len) 　　return -EIO; 　return 0; } static int write_cached_data (struct mtdblk_dev *mtdblk) { 　struct mtd_info *mtd = mtdblk->mtd; 　int ret; 　if (mtdblk->cache_state != STATE_DIRTY) 　　return 0; 　DEBUG(MTD_DEBUG_LEVEL2, "mtdblock: writing cached data for \"%s\" " "at 0x%lx, size 0x%x\n", mtd->name, mtdblk->cache_offset, mtdblk->cache_size); 　ret = erase_write (mtd, mtdblk->cache_offset, mtdblk->cache_size, mtdblk->cache_data); 　if (ret) 　　return ret; 　mtdblk->cache_state = STATE_EMPTY; 　return 0; } static int do_cached_write (struct mtdblk_dev *mtdblk, unsigned long pos, int len, const char *buf) { 　… } static int do_cached_read (struct mtdblk_dev *mtdblk, unsigned long pos, int len, char *buf) { 　… } static int mtdblock_open(struct inode *inode, struct file *file) { 　… } static release_t mtdblock_release(struct inode *inode, struct file *file) { 　int dev; 　struct mtdblk_dev *mtdblk; 　DEBUG(MTD_DEBUG_LEVEL1, "mtdblock_release\n"); 　if (inode == NULL) 　　release_return(-ENODEV); 　dev = minor(inode->i_rdev); 　mtdblk = mtdblks[dev]; 　down(&mtdblk->cache_sem); 　write_cached_data(mtdblk); 　up(&mtdblk->cache_sem); 　spin_lock(&mtdblks_lock); 　if (!--mtdblk->count) { 　　/* It was the last usage. Free the device */ 　　mtdblks[dev] = NULL; 　　spin_unlock(&mtdblks_lock); 　　if (mtdblk->mtd->sync) 　　　mtdblk->mtd->sync(mtdblk->mtd); 　　　put_mtd_device(mtdblk->mtd); 　　　vfree(mtdblk->cache_data); 　　　kfree(mtdblk); 　} else { 　　spin_unlock(&mtdblks_lock); 　} 　DEBUG(MTD_DEBUG_LEVEL1, "ok\n"); 　 　BLK_DEC_USE_COUNT; 　release_return(0); } /* * This is a special request_fn because it is executed in a process context * to be able to sleep independently of the caller. The * io_request_lock (for <2.5) or queue_lock (for >=2.5) is held upon entry * and exit. The head of our request queue is considered active so there is * no need to dequeue requests before we are done. */ static void handle_mtdblock_request(void) { 　struct request *req; 　struct mtdblk_dev *mtdblk; 　unsigned int res; 　for (;;) { 　　INIT_REQUEST; 　　req = CURRENT; 　　spin_unlock_irq(QUEUE_LOCK(QUEUE)); 　　mtdblk = mtdblks[minor(req->rq_dev)]; 　　res = 0; 　　if (minor(req->rq_dev) >= MAX_MTD_DEVICES) 　　　panic("%s : minor out of bound", __FUNCTION__); 　　if (!IS_REQ_CMD(req)) 　　　goto end_req; 　　if ((req->sector + req->current_nr_sectors) > (mtdblk->mtd->size >> 9)) 　　　goto end_req; 　　// Handle the request 　　switch (rq_data_dir(req)) 　　{ 　　　int err; 　　　case READ: 　　　　down(&mtdblk->cache_sem); 　　　　err = do_cached_read (mtdblk, req->sector << 9, req->current_nr_sectors << 9, req->buffer); 　　　　up(&mtdblk->cache_sem); 　　　　if (!err) 　　　　　res = 1; 　　　　break; 　　　case WRITE: 　　　　// Read only device 　　　　if ( !(mtdblk->mtd->flags & MTD_WRITEABLE) ) 　　　　　break; 　　　　// Do the write 　　　　down(&mtdblk->cache_sem); 　　　　err = do_cached_write (mtdblk, req->sector << 9,req->current_nr_sectors << 9, req->buffer); 　　　　up(&mtdblk->cache_sem); 　　　　if (!err) 　　　　　res = 1; 　　　　break; 　　} 　end_req: 　spin_lock_irq(QUEUE_LOCK(QUEUE)); 　end_request(res); } } static volatile int leaving = 0; static DECLARE_MUTEX_LOCKED(thread_sem); static DECLARE_WAIT_QUEUE_HEAD(thr_wq); int mtdblock_thread(void *dummy) { 　… } #define RQFUNC_ARG request_queue_t *q static void mtdblock_request(RQFUNC_ARG) { 　/* Don't do anything, except wake the thread if necessary */ 　wake_up(&thr_wq); } static int mtdblock_ioctl(struct inode * inode, struct file * file, unsigned int cmd, unsigned long arg) { 　struct mtdblk_dev *mtdblk; 　mtdblk = mtdblks[minor(inode->i_rdev)]; 　switch (cmd) { 　　case BLKGETSIZE: /* Return device size */ 　　　return put_user((mtdblk->mtd->size >> 9), (unsigned long *) arg); 　　case BLKFLSBUF: 　　　if(!capable(CAP_SYS_ADMIN)) 　　　　return -EACCES; 　　　fsync_dev(inode->i_rdev); 　　　invalidate_buffers(inode->i_rdev); 　　　down(&mtdblk->cache_sem); 　　　write_cached_data(mtdblk); 　　　up(&mtdblk->cache_sem); 　　　if (mtdblk->mtd->sync) 　　　　mtdblk->mtd->sync(mtdblk->mtd); 　　　　return 0; 　　default: 　　　return -EINVAL; 　} } static struct block_device_operations mtd_fops = { 　owner: THIS_MODULE, 　open: mtdblock_open, 　release: mtdblock_release, 　ioctl: mtdblock_ioctl }; static void mtd_notify_add(struct mtd_info* mtd) { 　… } static void mtd_notify_remove(struct mtd_info* mtd) { 　if (!mtd || mtd->type == MTD_ABSENT) 　　return; 　devfs_unregister(devfs_rw_handle[mtd->index]); } int __init init_mtdblock(void) { 　int i; 　spin_lock_init(&mtdblks_lock); 　/* this lock is used just in kernels >= 2.5.x */ 　spin_lock_init(&mtdblock_lock); 　#ifdef CONFIG_DEVFS_FS 　if (devfs_register_blkdev(MTD_BLOCK_MAJOR, DEVICE_NAME, &mtd_fops)) 　{ 　　printk(KERN_NOTICE "Can't allocate major number %d for Memory Technology Devices.\n", MTD_BLOCK_MAJOR); 　　return -EAGAIN; 　} 　devfs_dir_handle = devfs_mk_dir(NULL, DEVICE_NAME, NULL); 　register_mtd_user(&notifier); 　#else 　　if (register_blkdev(MAJOR_NR,DEVICE_NAME,&mtd_fops)) { 　　　printk(KERN_NOTICE "Can't allocate major number %d for Memory Technology Devices.\n", MTD_BLOCK_MAJOR); 　　return -EAGAIN; 　} 　#endif /* We fill it in at open() time. */ for (i=0; i< MAX_MTD_DEVICES; i++) { 　mtd_sizes[i] = 0; 　mtd_blksizes[i] = BLOCK_SIZE; } init_waitqueue_head(&thr_wq); /* Allow the block size to default to BLOCK_SIZE. */ blksize_size[MAJOR_NR] = mtd_blksizes; blk_size[MAJOR_NR] = mtd_sizes; BLK_INIT_QUEUE(BLK_DEFAULT_QUEUE(MAJOR_NR), &mtdblock_request, &mtdblock_lock); kernel_thread (mtdblock_thread, NULL, CLONE_FS|CLONE_FILES|CLONE_SIGHAND); return 0; } static void __exit cleanup_mtdblock(void) { 　leaving = 1; 　wake_up(&thr_wq); 　down(&thread_sem); 　#ifdef CONFIG_DEVFS_FS 　　unregister_mtd_user(&notifier); 　　devfs_unregister(devfs_dir_handle); 　　devfs_unregister_blkdev(MTD_BLOCK_MAJOR, DEVICE_NAME); 　#else 　　unregister_blkdev(MAJOR_NR,DEVICE_NAME); 　#endif 　blk_cleanup_queue(BLK_DEFAULT_QUEUE(MAJOR_NR)); 　blksize_size[MAJOR_NR] = NULL; 　blk_size[MAJOR_NR] = NULL; } module_init(init_mtdblock); module_exit(cleanup_mtdblock);

　　从上述源代码中我们发现，块设备也以与字符设备register_chrdev、unregister_ chrdev 函数类似的方法进行设备的注册与释放：

int register_blkdev(unsigned int major, const char *name, struct block_device_operations *bdops); int unregister_blkdev(unsigned int major, const char *name);

　　但是，register_chrdev使用一个向 file_operations 结构的指针，而register_blkdev 则使用 block_device_operations 结构的指针，其中定义的open、release 和 ioctl 方法和字符设备的对应方法相同，但未定义 read 或者 write 操作。这是因为，所有涉及到块设备的 I/O 通常由系统进行缓冲处理。

　　块驱动程序最终必须提供完成实际块 I/O 操作的机制，在 Linux 当中，用于这些 I/O 操作的方法称为"request（请求）"。在块设备的注册过程中，需要初始化request队列，这一动作通过blk_init_queue来完成，blk_init_queue函数建立队列，并将该驱动程序的 request 函数关联到队列。在模块的清除阶段，应调用 blk_cleanup_queue 函数。

　　本例中相关的代码为：

BLK_INIT_QUEUE(BLK_DEFAULT_QUEUE(MAJOR_NR), &mtdblock_request, &mtdblock_lock); blk_cleanup_queue(BLK_DEFAULT_QUEUE(MAJOR_NR));

　　每个设备有一个默认使用的请求队列，必要时，可使用 BLK_DEFAULT_QUEUE(major) 宏得到该默认队列。这个宏在 blk_dev_struct 结构形成的全局数组（该数组名为 blk_dev）中搜索得到对应的默认队列。blk_dev 数组由内核维护，并可通过主设备号索引。blk_dev_struct 接口定义如下：

struct blk_dev_struct { 　/* 　* queue_proc has to be atomic 　*/ 　request_queue_t request_queue; 　queue_proc *queue; 　void *data; };

　　request_queue 成员包含了初始化之后的 I/O 请求队列，data 成员可由驱动程序使用，以便保存一些私有数据。

　　request_queue定义为：

struct request_queue { 　/* 　* the queue request freelist, one for reads and one for writes 　*/ 　struct request_list rq[2]; 　/* 　* Together with queue_head for cacheline sharing 　*/ 　struct list_head queue_head; 　elevator_t elevator; 　request_fn_proc * request_fn; 　merge_request_fn * back_merge_fn; 　merge_request_fn * front_merge_fn; 　merge_requests_fn * merge_requests_fn; 　make_request_fn * make_request_fn; 　plug_device_fn * plug_device_fn; 　/* 　* The queue owner gets to use this for whatever they like. 　* ll_rw_blk doesn't touch it. 　*/ 　void * queuedata; 　/* 　* This is used to remove the plug when tq_disk runs. 　*/ 　struct tq_struct plug_tq; 　/* 　* Boolean that indicates whether this queue is plugged or not. 　*/ 　char plugged; 　/* 　* Boolean that indicates whether current_request is active or 　* not. 　*/ 　char head_active; 　/* 　* Is meant to protect the queue in the future instead of 　* io_request_lock 　*/ 　spinlock_t queue_lock; 　/* 　* Tasks wait here for free request 　*/ 　wait_queue_head_t wait_for_request; };

　　下图表征了blk_dev、blk_dev_struct和request_queue的关系：


　　下图则表征了块设备的注册和释放过程：


　　5.小结

　　本章讲述了Linux设备驱动程序的入口函数及驱动程序中的内存申请、中断等，并分别以实例讲述了字符设备及块设备的驱动开发方法。

查看本文来源