FLASH 驱动程序设计 --- 块设备驱动设计

最新推荐文章于 2024-08-11 15:36:39 发布

ZhY_Rening

最新推荐文章于 2024-08-11 15:36:39 发布

阅读量584

点赞数

分类专栏：嵌入式Linux内核驱动开发文章标签：块设备 Flash MTD系统 Nand-Flash

嵌入式Linux内核驱动开发专栏收录该内容

21 篇文章 4 订阅

订阅专栏

块设备概念

块设备是指只能以块为单位进行访问的设备，块大小一般是512个字节的整数倍。常见的块设备包括硬盘，SD卡，光盘等。

这里讲的512个字节是指，对设备一次访问最少会读出一个块的内容，用户可以对这个块中的某一个字节进行操作，并不是用户不能操作某一单个的字节。

块设备驱动系统架构

块设备的驱动系统架构如下图所示：
这里写图片描述

虚拟文件系统（VFS）：
VFS是对各种具体文件系统的一种封装，为用户程序访问文件提供统一的接口。如下图所示：
这里写图片描述

磁盘缓存（Cache）：
当用户发起文件访问请求的时候，首先会到Disk Cache中寻找文件是否被缓存了，如果在cache中，则直接从cache中读取。如果数据不在缓存中，就必须要到具体的文件系统中读取数据了。

影射层（Mapping Layer）：
1、首先确定文件系统的 block size ，然后计算所请求的数据包含多少个block。
2、调用具体文件系统的函数来访问文件的 inode 结构，确定所请求的数据在磁盘上的地址。

通用块层（Generic Block Layer）：
Linux内核把把块设备看作是由若干个扇区组成的数据空间。上层的读写请求在通用块层被构造成一个或多个bio结构。

I/O调度层（I/O Scheduler Layer）：
I/O调度层负责采用某种算法(如：电梯调度算法)将I/O操作进行排序。
电梯调度算法的基本原则：如果电梯现在朝上运动，如果当前楼层的上方和下方都有请求，则先响应所有上方的请求，然后才向下响应下方的请求；如果电梯向下运动，则刚好相反。

块设备驱动：
在块系统架构的最底层，由块设备驱动根据排序好的请求，对硬件进行数据访问。

块设备驱动设计

块设备初始化：
这里写图片描述

块设备访问请求处理函数：
这里写图片描述

块设备范例代码：

#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/kernel.h> /*  printk()     */
#include <linux/slab.h>   /*  kmalloc()    */
#include <linux/fs.h>     /*  everything...*/
#include <linux/errno.h>  /*  error codes  */
#include <linux/timer.h>
#include <linux/types.h>  /*  size_t       */
#include <linux/fcntl.h>  /*  O_ACCMODE    */
#include <linux/hdreg.h>  /*  HDIO_GETGEO  */
#include <linux/kdev_t.h>
#include <linux/vmalloc.h>
#include <linux/genhd.h>
#include <linux/blkdev.h>
#include <linux/buffer_head.h> /* invalidate_bdev */
#include <linux/bio.h>

MODULE_LICENSE("Dual BSD/GPL");

static int major = 0;
static int sect_size = 512;
static int nsectors = 1024; 

// The internal representation of our device.
struct blk_dev{
         int size;                        /* Device size in sectors */
         u8 *data;                        /* The data array */
         struct request_queue *queue;     /* The device request queue */
         struct gendisk *gd;              /* The gendisk structure */
};

struct blk_dev *dev;

// Handle an I/O request, in sectors.
static void blk_transfer(struct blk_dev *dev, unsigned long sector,
   unsigned long nsect, char *buffer, int write)//硬件访问函数
{
    unsigned long offset = sector*sect_size;
    unsigned long nbytes = nsect*sect_size;

    if ((offset + nbytes) > dev->size) {
       printk (KERN_NOTICE "Beyond-end write (%ld %ld)\n", offset, nbytes);
       return;
    }
    if (write)
        memcpy(dev->data + offset, buffer, nbytes);
    else
        memcpy(buffer, dev->data + offset, nbytes);
}

// The simple form of the request function.
static void blk_request(struct request_queue *q) //请求处理函数
{
    struct request *req;

    //取出一个要处理的请求
    req = blk_fetch_request(q);
    while (req != NULL) {
        struct blk_dev *dev = req->rq_disk->private_data;

        //根据请求信息访问硬件，获取数据
        blk_transfer(dev, blk_rq_pos(req), blk_rq_cur_sectors(req), req->buffer, rq_data_dir(req));

        //检查是否还有其他请求
        if(!__blk_end_request_cur(req, 0)) 
        {
            req = blk_fetch_request(q);
        }
    }
}

// The device operations structure.
static struct block_device_operations blk_ops = {
    .owner            = THIS_MODULE,
};

// Set up our internal device.
static void setup_device()
{
    // Get some memory.
    dev->size = nsectors*sect_size;
    dev->data = vmalloc(dev->size);
    if (dev->data == NULL) {
       printk (KERN_NOTICE "vmalloc failure.\n");
       return;
    }

    //2、初始化请求队列，指明请求处理函数 blk_request
    dev->queue = blk_init_queue(blk_request, NULL);
    if (dev->queue == NULL)
        goto out_vfree;

    //3、指明扇区大小
    blk_queue_logical_block_size(dev->queue, sect_size);
    dev->queue->queuedata = dev;

    // And the gendisk structure. 4、为设备分配gendisk结构
    dev->gd = alloc_disk(1);
    if (! dev->gd) {
       printk (KERN_NOTICE "alloc_disk failure\n");
       goto out_vfree;
    }

    //5、初始化gendisk结构
    dev->gd->major = major;
    dev->gd->first_minor = 0;
    dev->gd->fops = &blk_ops;
    dev->gd->queue = dev->queue;
    dev->gd->private_data = dev;
    sprintf (dev->gd->disk_name, "simp_blk%d", 0);
    set_capacity(dev->gd, nsectors*(sect_size/sect_size));

    //6、出册块设备
    add_disk(dev->gd);
    return;

out_vfree:
    if (dev->data)
        vfree(dev->data);
}

static int __init blk_init(void) //入口函数
{
    // Get registered. 1、注册块设备驱动程序
    major = register_blkdev(major, "blk");
    if (major <= 0) {
       printk(KERN_WARNING "blk: unable to get major number\n");
       return -EBUSY;
    }

    dev = kmalloc(sizeof(struct blk_dev), GFP_KERNEL);
    if (dev == NULL)
       goto out_unregister; 
    setup_device();      
    return 0;

out_unregister:
    unregister_blkdev(major, "sbd");
    return -ENOMEM;
}

static void blk_exit(void) //出口函数
{
    if (dev->gd) {
        del_gendisk(dev->gd);
        put_disk(dev->gd);
    }
    if (dev->queue)
        blk_cleanup_queue(dev->queue);
    if (dev->data)
        vfree(dev->data);

    unregister_blkdev(major, "blk");
    kfree(dev);
}

module_init(blk_init);
module_exit(blk_exit);