Linux驱动开发: 块设备驱动开发

你家不科学

Linux内乱核版本: 3.5
测试装备:  和睦之臂Tiny4412开拓板  （CPU型号:  三星Exynos4412）
2019年三星公布的Galaxy S II战MX接纳的便是那款CPU。

1、块装备介绍

         块是一种具有必然规划的随机存与装备，对这类装备的读写是按块停止的，他利用缓冲区去寄存临时的数据，待前提成生后，从缓存一次性写进装备大要从装备一次性读到缓冲区。
块装备是取字符装备并列的观点， 那两类装备正在 Linux 中驱动的规划有较年夜差别，整体而行， 块装备驱动比字符装备驱动要庞大很多，正在 I/O 操纵上表现出极年夜的差别，缓冲、 I/O 调理、恳求行列等皆是取块装备驱动相干的观点。
         正在Linux中，驱动对块装备的输进或输出(I/O)操纵，城市背块装备收回一个恳求，正在驱动顶用request规划体形貌。但关于一些磁盘装备而行恳求的速率很缓，这时候候内乱核便供给一种行列的机造把那些I/O恳求增加到行列中（即：恳求行列），正在驱动顶用request_queue规划体形貌。正在背块装备提交那些恳求前内乱核会先施行恳求的兼并战排序预操纵，以进步会见的服从，然后再由内乱核中的I/O调理法式子体系去卖力提交  I/O 恳求，  调理法式将磁盘资本分派给体系中一切挂起的块 I/O  恳求，其事情是办理块装备的恳求行列，决议行列中的恳求的布列挨次和甚么时分派收恳求到装备。
         由通用块层(Generic Block Layer)卖力保持一个I/O恳求正在上层文件体系取底层物理磁盘之间的干系。正在通用块层中，凡是用一个bio规划体去对应一个I/O恳求。
          Linux供给了一个gendisk数据规划体，用去暗示一个自力的磁盘装备或分区，用于对底层物理磁盘停止会见。正在gendisk中有一个相同字符装备中file_operations的硬件操纵规划指针，是block_device_operations规划体。
     编写块装备驱动时，利用的一些单位介绍:
 1. 扇区(Sectors)：任何块装备硬件对数据处理的底子单位。凡是，1个扇区的大小为512字节。(对装备而行)
2. 块 (Blocks)：由Linux订定对内乱核或文件体系等数据处理的底子单位。凡是，1个块由1个或多个扇区构成。(对Linux操纵体系而行)
3. 段(Segments)：由多少个相邻的块构成。是Linux内乱存办理机造中一个内乱存页大要内乱存页的一部分。

 
 IO调理器
          便是电梯算法。我们明白，磁盘是的读写是经由过程机械性的挪动磁头去完成读写的，实际上磁盘装备满意块装备的随机读写的请求，可是出于节流磁盘，进步服从的思索，我们期望当磁头处于某一个地位的时分，一同将近来需求写正在四周的数据写进，而没有是那写一下，那写一下然后再返来，IO调理便是将上层收下去的IO恳求的挨次停止从头排序和对多个恳求停止兼并，如许就能够完成上述的进步服从、节流磁盘的目标。这类处理成绩的思绪利用电梯算法，一个运转中的电梯，一小我私家20楼->1楼，此外一小我私家15->5楼，电梯没有会先将第一小我私家收到1楼再来15楼接第两小我私家将其收到5楼，而是从20楼下去，到15楼的时分停下接人，到5楼将第两个放下，最初抵达1楼，一句话，电梯算法终极效劳的劣先挨次其实不根据按按钮的前后挨次。
Linux内乱核中供给了上面的几种电梯算法去完成IO调理：
1.    No-op I/O scheduler只完成了俭朴的FIFO的，只停止最俭朴的兼并，比力合适基于Flash的存储
2.    Anticipatory I/O scheduler推延IO恳求(约莫几个微秒)，以期能对他们停止排序，得到更下服从
3.    Deadline I/O scheduler试图把每次恳求的提早降到最低，同时也会对BIO从头排序，出格合用于读与较多的场合，好比数据库
4.    CFQ I/O scheduler为体系内乱一切的使命分派平均的IO带宽，供给一个公允的事情情况，正在多媒体情况中，能包管音视频及时从磁盘中读与数据，是当前内乱核默许的调理器
我们能够经由过程内乱核传参的方法指定利用的调理算法:  kernel elevator=deadline
大要，利用以下号令改动内乱核调理算法:

1. echo SCHEDULER > /sys/block/DEVICE/queue/scheduler

复造代码

2、块装备规划介绍

2.1 内乱核自带可参考的块装备驱动源码

1. drivers\block\z2ram.c
2. drivers\block\xd.c
3. \drivers\mmc\host\sdhci-s3c.c

复造代码

2.2 块装备注册取登记函数

1. 注册函数

int register_blkdev(unsigned int major, const char *name)

 函数功用介绍:  注册一个新的块装备
函数参数介绍:
@major:块装备的主装备号[1..255]。 假如major = 0，暗示测验考试分派已利用的主装备号，返回值便暗示分派胜利的主装备号。
@name:新块装备的称号。 留意: 称号必需包管正在体系中是独一的（不克不及取装备称号重名）。
注册示例:

int Tiny4412_block_major = register_blkdev(0, "Tiny4412_block");

2. 登记函数

void unregister_blkdev(unsigned int major, const char *name)

 函数工程介绍： 登记已注册的块装备。
函数参数介绍:
@major: 主装备号
@name: 装备称号
登记示例:

unregister_blkdev(Tiny4412_block_major, "Tiny4412_block");

2.3 静态分派恳求行列

struct request_queue *blk_alloc_queue(gfp_t gfp_mask)

函数功用介绍: 分派一个默许的恳求行列，用该函数天生的恳求行列出有设置默许的IO调理器，假如编写的块装备是内乱存模仿块装备大要是SD卡、Flash等装备，就能够用此函数分派恳求行列。
函数参数介绍:
@ gfp_mask : 内乱存分派的方法。 GFP_KERNEL战GFP_ATOMIC,
  GFP_ATOMIC: 用去从中止处理战历程高低文以外的其他代码平分配内乱存. 从没有就寝
GFP_KERNEL: 内乱核内乱存的一般分派. 能够就寝
分派恳求行列示例:

struct request_queue *queue= =blk_alloc_queue(GFP_KERNEL);

卸载驱动时，能够经由过程kfree开释空间。
假如需求会见内部硬件，好比: 光盘、磁盘等内部物理装备时，要设置默许的调理器，能够挪用blk_init_queue函数分派恳求行列。

struct request_queue *blk_init_queue(request_fn_proc *rfn, spinlock_t *lock)

blk_init_queue()必需取blk_cleanup_queue()挪用配对。
函数参数介绍:
 @ rfn 是一个函数指针,规范为 typedef void (request_fn_proc) (struct request_queue *q);
 @ lock 自旋锁


2.4 绑定恳求行列

void blk_queue_make_request(struct request_queue *q, make_request_fn *mfn)

函数功用介绍:  绑定blk_alloc_queue函数到恳求行列。
上一步介绍的blk_alloc_queue函数分派的恳求行列，因为没有会利用默许的IO调理器，此中的make_request_fn是出有赋值的，由于上层代码背恳求行列发作恳求时皆是经由过程make_request_fn那个函数去完成的。关于上层代码收回的恳求，能够间接用make_request_fn函数去完成恳求并间接将成果返回给上层的代码。
函数参数介绍:
struct request_queue *q :恳求行列指针。
make_request_fn *mfn : make_request_fn函数指针。
函数指针的本型以下:

typedef void (make_request_fn) (struct request_queue *q, struct bio *bio);

该函数指针正在Blkdev.h界说。

 绑定恳求行列示例:

blk_queue_make_request(queue, Tiny4412_block_make_request);

2.5 make_request_fn处理函数编写

//间接提交恳求,行列处理 static void Tiny4412_block_make_request(struct request_queue *q, struct bio *bio) {         int i;         struct bio_vec *bvec;         sector_t sector = bio->bi_sector;         /*经由过程for轮回遍历一个bio中一切的segment恳求*/         bio_for_each_segment(bvec, bio, i)         {                          char *buffer = __bio_kmap_atomic(bio, i, KM_USER0); /*映照内乱存空间(申请空间)*/                          Tiny4412_block_dev_sector_read_write(sector, bio_cur_bytes(bio)>>9 ,buffer, bio_data_dir(bio) == WRITE);                          /*                                  sector: 当前扇区地位                                  bio_cur_bytes(bio)>>9: 扇区读写数目                                  buffer :读写的缓冲区指针尾地点                                  bio_data_dir(bio): 判定是读仍是写                          */                          sector += bio_cur_bytes(bio)>>9;     /*偏偏移扇区*/                          __bio_kunmap_atomic(bio, KM_USER0);  /*打消映照(开释空间)*/         }         bio_endio(bio, 0); /*完毕处理*/         return; }

make_request_fn函数指针传进的参数介绍:
struct bio *bio: 形貌块数据传收时如何完成添补或读与块给driver
struct request_queue *q :传进的恳求行列

2.6 扇区读写函数完成

代码示例:

unsigned long sector:  当前扇区地位 unsigned long nsect :  扇区读写数目 char *buffer        :  读写的缓冲区指针 int write           :  是读仍是写 */ static void Tiny4412_block_dev_sector_read_write(unsigned long sector,unsigned long nsect, char *buffer, int write) {                 /*块装备最小单位是一个扇区，一个扇区的字节数是512字节*/                 unsigned long offset = sector*512;                 unsigned long nbytes = nsect*512;                 if((offset + nbytes)>TINY4412_BLKDEV_BYTES)                 {                          printk(KERN_NOTICE "写超越范畴,强迫完毕(%ld %ld)\n", offset, nbytes);                          return;                 }                 if(write)   /*为实,暗示是写*/                 memcpy(tiny4412_blkdev_data + offset, buffer, nbytes);                 else      /*读操纵*/                 memcpy(buffer,tiny4412_blkdev_data + offset, nbytes); }

2.7 分派一个gendisk规划

struct gendisk *alloc_disk(int minors)   //静态分派gendisk void del_gendisk(struct gendisk *disk)  //登记gendisk

函数功用介绍:每一个块装备皆对应一个gendisk规划，函数alloc_disk用于分派一个gendisk规划。
函数参数介绍:
@minors: 数目
给分派的规划添补参数:

/*静态分派次装备号规划*/         gd=alloc_disk(1);/*分派一个gendisk，1暗示不克不及停止分区,只能牢固一个分区。 >1暗示撑持分区的数目 分区能够经由过程fdsik号令停止操纵*/         gd->major=Tiny4412_block_major;      /*主装备号*/         gd->first_minor=0;                               /*次装备号*/         gd->fops=&Tiny4412_block_ops;      /*文件操纵汇合*/         gd->queue=queue;                                   /*将恳求行列联系关系到gendisk规划*/         snprintf(gd->disk_name, 32, "Tiny4412_block_%c",'a'); //设置磁盘称号,正在/dev下能够查察该称号 //块装备底子皆是利用文件体系函数停止操纵，该文件操纵汇合能够不消本人完成 static struct block_device_operations Tiny4412_block_ops= {         .owner = THIS_MODULE, };

驱动装置以后，查察的节面疑息: 

 设置磁盘的容量

/*留意: 块装备的大小利用扇区做为单位设置，而扇区的大小默许是512字节。           cat /sys/block/xxxx/size 能够查察到设置的大小           把字节为单位的大小转换为以扇区为单位时，我们需求除以512，大要左移9位         */         set_capacity(gd,TINY4412_BLKDEV_BYTES>>9);

2.8 增加磁盘分区疑息到内乱核

void add_disk(struct gendisk *disk)

函数功用介绍: 将分区疑息增加到内乱核。
函数参数: 添补好gendisk规划。
示例:

add_disk(gd);

12.9 初初化一个恳求行列

struct request_queue *blk_init_queue(request_fn_proc *rfn, spinlock_t *lock)

示例:

tiny4412_blockdev_queue = blk_init_queue(do_tiny4412_blockdev_request, &tiny4412_blockdev_lock);

该函数里挪用了默许的IO调理器。 代码能够参考内乱核文件: drivers\block\z2ram.c

3、块装备示例代码

 
3.1 内乱存模仿块装备(没有利用IO调理器)

内乱存空间接纳vmalloc函数停止分派。

1. #include <linux/module.h>
2. #include <linux/blkdev.h>
3. #include <linux/hdreg.h>
4. #include <linux/version.h>
6. /*
7. *     insmod tiny4412_blkdev.ko
8. *     # or insmod tiny4412_blkdev.ko size=numK/M/G/T
9. *     fdisk /dev/tiny4412_blkdev # create 2 patitions
10. *     mkfs.ext2 /dev/tiny4412_blkdev1
11. *     mkfs.ext2 /dev/tiny4412_blkdev2
12. *     mount /dev/tiny4412_blkdev1 /mnt/temp1/
13. *     mount /dev/tiny4412_blkdev2 /mnt/temp2/
14. *     # play in /mnt/temp1/ and /mnt/temp2/
15. *     umount /mnt/temp1/
16. *     umount /mnt/temp2/
17. *     rmmod tiny4412_blkdev.ko
18. *
19. */
20. static int Tiny4412_block_major=0;
21. static struct request_queue *tiny4412_blkdev_queue;
22. static struct gendisk *tiny4412_blkdev_disk;
24. static unsigned long long tiny4412_blkdev_bytes=1024*1024*10;//10M--空间容量
25. #define TINY4412_BLKDEV_BYTES_1        (1024*1024*10)  /*设置块装备的巨细*/
26. static unsigned char tiny4412_blkdev_data_1[TINY4412_BLKDEV_BYTES_1]; /*用于测试块装备的数组巨细*/
29. /*
30. * Handle an I/O request.
31. * 完成扇区的读写
33. unsigned long sector:  当前扇区地位
34. unsigned long nsect :  扇区读写数目
35. char *buffer        :  读写的缓冲区指针
36. int write           :  是读仍是写
37. */
38. static void Tiny4412_block_dev_sector_read_write(unsigned long sector,unsigned long nsect, char *buffer, int write)
39. {
40.                 /*块装备最小单元是一个扇区，一个扇区的字节数是512字节*/
41.                 unsigned long offset = sector;  /*写进数据的地位*/
42.                 unsigned long nbytes = nsect;   /*写进的少度*/
43.                 if((offset + nbytes)>TINY4412_BLKDEV_BYTES_1)
44.                 {
45.                         printk("写超越范畴,强迫完毕(%ld %ld)\n", offset, nbytes);
46.                         return;
47.                 }
48.                 if(write) /*为实,暗示是写*/
49.                 memcpy(tiny4412_blkdev_data_1 + offset, buffer, nbytes);
50.                 else      /*读操纵*/
51.                 memcpy(buffer,tiny4412_blkdev_data_1 + offset, nbytes);
52. }
55. /*
56. 处置恳求
57. */
58. static int tiny4412_blkdev_make_request(struct request_queue *q, struct bio *bio)
59. {
60.         int dir;
61.         unsigned long long dsk_offset;
62.         struct bio_vec *bvec;
63.         int i;
64.         void *iovec_mem;
65.        
66.         /*判定读写标的目的*/
67.         if(bio_data_dir(bio) == WRITE) dir = 1;
68.         else dir = 0;
69.         dsk_offset = bio->bi_sector << 9;
70.         bio_for_each_segment(bvec, bio, i)
71.         {
72.                 iovec_mem = kmap(bvec->bv_page) + bvec->bv_offset;
73.                
74.                 //肇端地位,少度,源数据,标的目的
75.                 Tiny4412_block_dev_sector_read_write(dsk_offset,bvec->bv_len,iovec_mem,dir);
76.                
77.                 kunmap(bvec->bv_page);
78.                 dsk_offset += bvec->bv_len;
79.         }
80.         bio_endio(bio, 0);
81.         return 0;
82. }
84. static int tiny4412_blockdev_getgeo(struct block_device *bdev, struct hd_geometry *geo)
85. {
86.         /* 容量=heads*cylinders*sectors*512
87.          * 存储容量 ＝ 磁头数 × 磁讲(柱里)数 × 每讲扇区数 × 每扇区字节数
88.          */
89.         geo->heads     = 2;  /*磁头(普通一个盘里有两个磁头，正里一个/背面一个)*/
90.         geo->cylinders = 32; /*柱里(普通一个盘里上有32个柱里)每一个盘片32个磁讲)*/
91.         geo->sectors   = TINY4412_BLKDEV_BYTES_1/2/32/512; /*扇区,普通每一个磁讲上有12个扇区，那里需求按照前里柱里战磁头停止计较，不克不及治挖*/
92.         return 0;
93. }
95. struct block_device_operations tiny4412_blkdev_fops =
96. {
97.     .owner= THIS_MODULE,
98.          /*fdisk号令分区时需求挪用该函数，用于读与磁头、柱里、扇区等疑息*/
99.         .getgeo        = tiny4412_blockdev_getgeo,
100. };
102. static int __init tiny4412_blkdev_init(void)
103. {
104.         /*静态分派恳求行列*/
105.         tiny4412_blkdev_queue = blk_alloc_queue(GFP_KERNEL);
106.        
107.         /*绑定恳求行列*/
108.         blk_queue_make_request(tiny4412_blkdev_queue,tiny4412_blkdev_make_request);
109.        
110.         /*静态分派次装备号构造*/
111.         /*每个磁盘(分区)皆是利用一个gendisk构造保留*/
112.         tiny4412_blkdev_disk = alloc_disk(64);
113.        
114.         /*磁盘称号赋值*/
115.         strcpy(tiny4412_blkdev_disk->disk_name, "tiny4412_blkdev");
117.         /*注册一个块装备,主动分派主装备号*/
118.         Tiny4412_block_major = register_blkdev(0,"Tiny4412_block");
119.         printk("Tiny4412_block_major=%d\n",Tiny4412_block_major);
120.        
121.         tiny4412_blkdev_disk->major=Tiny4412_block_major;           /*主装备号*/
122.         tiny4412_blkdev_disk->first_minor = 0;                                   /*次装备号*/
123.         tiny4412_blkdev_disk->fops = &tiny4412_blkdev_fops;   /*文件操纵分离*/
124.         tiny4412_blkdev_disk->queue = tiny4412_blkdev_queue;  /*处置数据恳求的行列*/
125.        
126.         /*设置磁盘构造 capacity 的容量*/
127.         /*留意: 块装备的巨细利用扇区做为单元设置，而扇区的巨细默许是512字节。
128.           cat /sys/block/xxxx/size 能够检察到设置的巨细
129.           把字节为单元的巨细转换为以扇区为单元时，我们需求除以512，大概左移9位
130.         */
131.         set_capacity(tiny4412_blkdev_disk,tiny4412_blkdev_bytes>>9);
132.        
133.         //增加磁盘疑息到内乱核
134.         add_disk(tiny4412_blkdev_disk);
135.         return 0;
136. }
138. static void __exit tiny4412_blkdev_exit(void)
139. {
140.         //删除磁盘
141.         del_gendisk(tiny4412_blkdev_disk);
142.        
143.         put_disk(tiny4412_blkdev_disk);
144.        
145.         //肃清行列
146.         blk_cleanup_queue(tiny4412_blkdev_queue);
147.        
148.         /*登记块装备*/
149.         unregister_blkdev(Tiny4412_block_major, "Tiny4412_block");
150.        
151. }
153. module_init(tiny4412_blkdev_init);
154. module_exit(tiny4412_blkdev_exit);
155. MODULE_LICENSE("GPL");

复造代码

块装备操纵历程:

[root@wbyq code]#ls tiny4412_block_device.ko [root@wbyq code]#insmod tiny4412_block_device.ko [  154.950000] Tiny4412_block_major=253 [  154.955000]  tiny4412_blkdev: unknown partition table (由于利用的内乱存装备模仿块装备，数组里出有分区表，以是第一次装置装备时，读与没有到装备分区表，那个提醒是一般的) [root@wbyq code]#fdisk /dev/tiny4412_blkdev Device contains neither a valid DOS partition table, nor Sun, SGI, OSF or GPT disklabel Building a new DOS disklabel. Changes will remain in memory only, until you decide to write them. After that the previous content won't be recoverable. Command (m for help): n (n暗示新建分区表) Command action    e   extended(暗示扩大分区)    p   primary partition (1-4)(暗示主分区) p (挑选p创立主分区) Partition number (1-4): 1 (创立的主分区编号为1) First cylinder (1-160, default 1): 1 (柱里肇端地位设置为1, 1-160暗示当前磁盘盈余的已分区的柱里范畴为1-160) Last cylinder or +size or +sizeM or +sizeK (1-160, default 160): 100 (设置柱里的完毕地位) Command (m for help): n (暗示主分区) Command action    e   extended    p   primary partition (1-4) p (挑选p创立主分区) Partition number (1-4): 2 (创立的主分区编号为2) First cylinder (101-160, default 101): 101 (柱里肇端地位设置为101, 101-160暗示当前磁盘盈余的已分区的柱里范畴为101-160) Last cylinder or +size or +sizeM or +sizeK (101-160, default 160): 160 (设置柱里的完毕地位) Command (m for help): p (挨印当前的分区状况) Disk /dev/tiny4412_blkdev: 10 MB, 10485760 bytes (磁盘的总容量: M单位,字节单位) 2 heads, 64 sectors/track, 160 cylinders (一个共有2个磁头,每一个柱里有64个扇区,160个柱里) (提醒: 存储容量 ＝ 磁头数 × 磁讲(柱里)数 × 每讲扇区数 × 每扇区字节数) Units = cylinders of 128 * 512 = 65536 bytes                              Device Boot      Start         End      Blocks  Id  System /dev/tiny4412_blkdev1               1         100        6368  83  Linux  (分区1的疑息) Partition 1 has different physical/logical endings:      phys=(355, 1, 0) logical=(99, 1, 64) Partition 1 does not end on cylinder boundary /dev/tiny4412_blkdev2             101         160        3840  83  Linux  (分区2的疑息) Partition 2 has different physical/logical endings:      phys=(415, 1, 0) logical=(159, 1, 64) Partition 2 does not end on cylinder boundary Command (m for help): w (w暗示保存分区表,写进磁盘，并退出fdisk号令止) The partition table has been altered. (提醒，分区暗示曾经变动) Calling ioctl() to re-read partition table (挪用ioctl()从头读与分区表) [  218.905000]  tiny4412_blkdev: tiny4412_blkdev1 tiny4412_blkdev2 (提醒分区以后创立胜利的装备节面) [root@wbyq code]#ls /dev/tiny4412_blkdev* -l (查察/dev下分区胜利的装备节面) brw-rw----    1 root     root      253,   0 Nov 24  2018 /dev/tiny4412_blkdev brw-rw----    1 root     root      253,   1 Nov 24  2018 /dev/tiny4412_blkdev1 brw-rw----    1 root     root      253,   2 Nov 24  2018 /dev/tiny4412_blkdev2  [root@wbyq code]#mkfs.ext2 /dev/tiny4412_blkdev1  (给第一个装备分区停止格局化文件体系) Filesystem label= OS type: Linux Block size=1024 (log=0) Fragment size=1024 (log=0) 1592 inodes, 6368 blocks 318 blocks (5%) reserved for the super user First data block=1 Maximum filesystem blocks=262144 1 block groups 8192 blocks per group, 8192 fragments per group 1592 inodes per group [root@wbyq code]#mkfs.ext2 /dev/tiny4412_blkdev2(给第两个装备分区停止格局化文件体系) Filesystem label= OS type: Linux Block size=1024 (log=0) Fragment size=1024 (log=0) 960 inodes, 3840 blocks 192 blocks (5%) reserved for the super user First data block=1 Maximum filesystem blocks=262144 1 block groups 8192 blocks per group, 8192 fragments per group 960 inodes per group [root@wbyq code]#mount /dev/tiny4412_blkdev1 /mnt/ (将第一个分区挂载到/mnt目次下) [root@wbyq code]#mount /dev/tiny4412_blkdev2 /tmp/ (将第两个分区挂载到/mnt目次下) [root@wbyq code]#df -h (查察当前体系磁盘的疑息) Filesystem                Size      Used Available Use% Mounted on 192.168.10.11:/work/rootfs/                          48.1G     16.5G     29.1G  36% / /dev/tiny4412_blkdev1                           6.0M     13.0K      5.7M   0% /mnt /dev/tiny4412_blkdev2                           3.6M     13.0K      3.4M   0% /tmp /*上面便是别离进进到挂载的目次下停止文件拷贝操纵，测试块装备能否一般，最初正在打消挂载退出*/ [root@wbyq code]#cd /mnt/ [root@wbyq mnt]#ls lost+found [root@wbyq mnt]#cp /123.mp3 ./ [root@wbyq mnt]# [root@wbyq mnt]#cd /tmp/ [root@wbyq tmp]#cp /123.mp3 ./ [root@wbyq tmp]# [root@wbyq tmp]#ls 123.mp3     lost+found [root@wbyq tmp]#cd / [root@wbyq ]#umount /tmp/ [root@wbyq ]#umount /mnt/

3.2 利用SD卡编写块装备(没有利用IO调理器)

SD卡接纳SPI和谈通讯，底层接纳模仿的SPI体系，出有利用SPI子体系。

1. #include <linux/module.h>
2. #include <linux/moduleparam.h>
3. #include <linux/init.h>
4. #include <linux/sched.h>
5. #include <linux/kernel.h>       
6. #include <linux/slab.h>
7. #include <linux/fs.h>            /* everything... */
8. #include <linux/errno.h>        /* error codes */
9. #include <linux/timer.h>
10. #include <linux/types.h>        /* size_t */
11. #include <linux/fcntl.h>        /* O_ACCMODE */
12. #include <linux/hdreg.h>        /* HDIO_GETGEO */
13. #include <linux/kdev_t.h>
14. #include <linux/vmalloc.h>
15. #include <linux/genhd.h>
16. #include <linux/blkdev.h>
17. #include <linux/bio.h>
18. #include <linux/init.h>
19. #include <linux/module.h>
20. #include <linux/ioctl.h>
21. #include <linux/fs.h>
22. #include <linux/device.h>
23. #include <linux/err.h>
24. #include <linux/list.h>
25. #include <linux/errno.h>
26. #include <linux/mutex.h>
27. #include <linux/slab.h>
28. #include <linux/compat.h>
29. #include <linux/spi/spi.h>
30. #include <linux/spi/spidev.h>
31. #include <asm/uaccess.h>
32. #include <linux/gpio.h>
33. #include <mach/gpio.h>
34. #include <plat/gpio-cfg.h>
35. #include <linux/delay.h>
36. #include <linux/io.h>
37. #include <linux/mutex.h>
38. #include <linux/miscdevice.h>   /*纯项字符装备头文件*/
41. /*--------------------------------SD相干操纵代码---------------------------------------------*/
42. /*界说指针，用于领受假造地点*/
43. volatile unsigned int *SD_GPBCON;
44. volatile unsigned int *SD_GPBDAT;
45.        
46. /*
47. 函数功用：SD初初化
48. Tiny4412硬件毗连：
49.         DO--MISO :GPB_2
50.         DI--MOSI :GPB_3
51.         CLK-SCLK :GPB_0
52.         CS--CS   :GPB_1
53. */
54. void SDCardSpiInit(void)
55. {
56.         /*1. 初初化GPIO*/
57.         /*映照物理地点*/
58.         SD_GPBCON=ioremap(0x11400040,4);
59.         SD_GPBDAT=ioremap(0x11400044,4);
60.        
61.         *SD_GPBCON &= ~(0xf  << 0 * 4);*SD_GPBCON |=  (0x1   << 0 * 4);
62.         *SD_GPBCON &= ~(0xf  << 1 * 4);*SD_GPBCON |=  (0x1   << 1 * 4);
63.         *SD_GPBCON &= ~(0xf  << 2 * 4);
64.         *SD_GPBCON &= ~(0xf  << 3 * 4);*SD_GPBCON |=  (0x1   << 3 * 4);
65.        
66.         /*2. 上推GPIO心*/
67.         //*SD_GPBDAT &= ~(1 << 4);//输出0
68.         *SD_GPBDAT |= (1 << 0);   //输出1
69.         *SD_GPBDAT |= (1 << 1);   //输出1
70.         *SD_GPBDAT |= (1 << 3);   //输出1
71. }
73. // SD卡范例界说  
74. #define SDCard_TYPE_ERR     0X00  //卡范例毛病
75. #define SDCard_TYPE_MMC     0X01  //MMC卡
76. #define SDCard_TYPE_V1      0X02
77. #define SDCard_TYPE_V2      0X04
78. #define SDCard_TYPE_V2HC    0X06          
80. // SD卡指令表            
81. #define SDCard_CMD0    0       //卡复位
82. #define SDCard_CMD1    1
83. #define SDCard_CMD8    8       //号令8 ，SEND_IF_COND
84. #define SDCard_CMD9    9       //号令9 ，读CSD数据
85. #define SDCard_CMD10   10      //号令10，读CID数据
86. #define SDCard_CMD12   12      //号令12，截至数据传输
87. #define SDCard_CMD13   16      //号令16，设置扇区巨细 应返回0x00
88. #define SDCard_CMD17   17      //号令17，读扇区
89. #define SDCard_CMD18   18      //号令18，读Multi 扇区
90. #define SDCard_CMD23   23      //号令23，设置多扇区写进前预先擦除N个block
91. #define SDCard_CMD24   24      //号令24，写扇区
92. #define SDCard_CMD25   25      //号令25，写多个扇区
93. #define SDCard_CMD41   41      //号令41，应返回0x00
94. #define SDCard_CMD55   55      //号令55，应返回0x01
95. #define SDCard_CMD58   58      //号令58，读OCR疑息
96. #define SDCard_CMD59   59      //号令59，使能/制止CRC，应返回0x00、
98. /*SD卡回应标识表记标帜字*/
99. #define SDCard_RESPONSE_NO_ERROR      0x00   //准确回应
100. #define SDCard_SD_IN_IDLE_STATE       0x01   //忙置形态
101. #define SDCard_SD_ERASE_RESET         0x02   //擦除复位
102. #define SDCard_RESPONSE_FAILURE       0xFF   //呼应失利
103.                
104. //函数声明              
105. unsigned char SDCardReadWriteOneByte(unsigned char data);                 //底层接心，SPI读写字节函数
106. unsigned char SDCardWaitBusy(void);                                                                                   //等候SD卡筹办
107. unsigned char SDCardGetAck(unsigned char Response);                                                                               //得到应对
108. unsigned char SDCardDeviceInit(void);                                                                    //初初化
109. unsigned char SDCardReadData(unsigned char*buf,unsigned int sector,unsigned int cnt);                    //读块(扇区)
110. unsigned char SDCardWriteData(unsigned char*buf,unsigned int sector,unsigned int cnt);                  //写块(扇区)
111. unsigned int GetSDCardSectorCount(void);                                                   //读扇区数
112. unsigned char GetSDCardCISDCardOutnfo(unsigned char *cid_data);           //读SD卡CID
113. unsigned char GetSDCardCSSDCardOutnfo(unsigned char *csd_data);           //读SD卡CSD
114.           
115. static unsigned char  SD_Type=0;  //寄存SD卡的范例
117. /*
118. 函数功用：SD卡底层接心,经由过程SPI时序背SD卡读写一个字节
119. 函数参数：data是要写进的数据
120. 返 回 值：读到的数据
121. 阐明：时序是第两个上降沿收罗数据
122. */
123. unsigned char SDCardReadWriteOneByte(unsigned char data_tx)
124. {                 
125.    u8 data_rx=0;
126.          u8 i;
127.          for(i=0;i<8;i++)
128.          {
129.                 *SD_GPBDAT &= ~(1 << 0);//输出0
130.                 if(data_tx&0x80)*SD_GPBDAT |= (1 << 3);   //输出1
131.                 else *SD_GPBDAT &= ~(1 << 3);//输出0
132.                 data_tx<<=1; //持续收收下一个数据
134.                 *SD_GPBDAT |= (1 << 0);   //输出1
135.                 data_rx<<=1;
136.                 if((*SD_GPBDAT & (1 << 2)))data_rx|=0x01;
137.          }
138.          return data_rx;
139. }
142. /*
143. 函数功用：打消挑选,开释SPI总线
144. */
145. void SDCardCancelCS(void)
146. {
147.         *SD_GPBDAT |= (1 << 1);
148.         SDCardReadWriteOneByte(0xff);//供给分外的8个时钟
149. }
151. /*
152. 函数 功 能：挑选sd卡,而且等候卡筹办OK
153. 函数返回值：0,胜利;1,失利;
154. */
155. unsigned char SDCardSelectCS(void)
156. {
157.         *SD_GPBDAT &= ~(1 << 1);
158.         if(SDCardWaitBusy()==0)return 0;//等候胜利
159.         SDCardCancelCS();
160.         return 1;//等候失利
161. }
164. /*
165. 函数 功 能：等候卡筹办好
166. 函数返回值：0,筹办好了;其他,毛病代码
167. */
168. unsigned char SDCardWaitBusy(void)
169. {
170.         unsigned int t=0;
171.         do
172.         {
173.                 if(SDCardReadWriteOneByte(0XFF)==0XFF)return 0;//OK
174.                 t++;                  
175.         }while(t<0xFFFFFF);//等候
176.         return 1;
177. }
180. /*
181. 函数功用：等候SD卡回应
182. 函数参数：
183.                 Response:要获得的回应值
184. 返 回 值：
185.                 0,胜利获得了该回应值
186.                 其他,获得回应值失利
187. */
188. unsigned char SDCardGetAck(unsigned char Response)
189. {
190.         u16 Count=0xFFFF;//等候次数                                                             
191.         while((SDCardReadWriteOneByte(0XFF)!=Response)&&Count)Count--;//等候获得精确的回应            
192.         if(Count==0)return SDCard_RESPONSE_FAILURE;//获得回应失利   
193.         else return SDCard_RESPONSE_NO_ERROR;//准确回应
194. }
197. /*
198. 函数功用：从sd卡读与一个数据包的内乱容
199. 函数参数：
200.         buf:数据缓存区
201.         len:要读与的数据少度.
202. 返回值：
203. 0,胜利;其他,失利;       
204. */
205. unsigned char SDCardRecvData(unsigned char*buf,u16 len)
206. {                                    
207.         if(SDCardGetAck(0xFE))return 1;//等候SD卡发还数据肇端令牌0xFE
208.     while(len--)//开端领受数据
209.     {
210.         *buf=SDCardReadWriteOneByte(0xFF);
211.         buf++;
212.     }
213.     //上面是2个真CRC（dummy CRC）
214.     SDCardReadWriteOneByte(0xFF);
215.     SDCardReadWriteOneByte(0xFF);                                                                                                                      
216.     return 0;//读与胜利
217. }
220. /*
221. 函数功用：背sd卡写进一个数据包的内乱容 512字节
222. 函数参数：
223.         buf 数据缓存区
224.         cmd 指令
225. 返 回 值：0暗示胜利;其他值暗示失利;
226. */
227. unsigned char SDCardSendData(unsigned char*buf,unsigned char cmd)
228. {       
229.         u16 t;                            
230.         if(SDCardWaitBusy())return 1;  //等候筹办生效
231.         SDCardReadWriteOneByte(cmd);
232.         if(cmd!=0XFD)//没有是完毕指令
233.         {
234.                 for(t=0;t<512;t++)SDCardReadWriteOneByte(buf[t]);//进步速率,削减函数传参工夫
235.             SDCardReadWriteOneByte(0xFF); //疏忽crc
236.             SDCardReadWriteOneByte(0xFF);
237.                   t=SDCardReadWriteOneByte(0xFF); //领受呼应
238.                 if((t&0x1F)!=0x05)return 2;   //呼应毛病                                                                                                                      
239.         }                                                                                                                                                                       
240.     return 0;//写进胜利
241. }
245. /*
246. 函数功用：背SD卡收收一个号令
247. 函数参数：
248.                 unsigned char cmd   号令
249.                 unsigned int arg  号令参数
250.                 unsigned char crc   crc校验值       
251. 返回值:SD卡返回的呼应
252. */                                                                                                  
253. unsigned char SendSDCardCmd(unsigned char cmd, unsigned int arg, unsigned char crc)
254. {
255.         unsigned char r1;       
256.         unsigned char Retry=0;
257.                
258.         SDCardCancelCS();               //打消前次片选
259.         if(SDCardSelectCS())return 0XFF;//片选生效
260.         //收收数据
261.         SDCardReadWriteOneByte(cmd | 0x40);//别离写进号令
262.         SDCardReadWriteOneByte(arg >> 24);
263.         SDCardReadWriteOneByte(arg >> 16);
264.         SDCardReadWriteOneByte(arg >> 8);
265.         SDCardReadWriteOneByte(arg);          
266.         SDCardReadWriteOneByte(crc);
267.         if(cmd==SDCard_CMD12)SDCardReadWriteOneByte(0xff);//Skip a stuff byte when stop reading
268.         Retry=0X1F;
270.         do
271.         {
272.                 r1=SDCardReadWriteOneByte(0xFF);
273.         }while((r1&0X80) && Retry--);          //等候呼应，或超时退出
274.    return r1;        //返回形态值
275. }       
279. /*
280. 函数功用：获得SD卡的CID疑息，包罗制作商疑息
281. 函数参数：unsigned char *cid_data(寄存CID的内乱存，最少16Byte）          
282. 返 回 值：
283.                 0：胜利，1：毛病                               
284. */
285. unsigned char GetSDCardCISDCardOutnfo(unsigned char *cid_data)
286. {
287.     unsigned char r1;          
288.     //收SDCard_CMD10号令，读CID
289.     r1=SendSDCardCmd(SDCard_CMD10,0,0x01);
290.     if(r1==0x00)
291.           {
292.                         r1=SDCardRecvData(cid_data,16);//领受16个字节的数据         
293.     }
294.         SDCardCancelCS();//打消片选
295.         if(r1)return 1;
296.         else return 0;
297. }       
300. /*
301. 函数阐明：
302.         获得SD卡的CSD疑息，包罗容量战速率疑息
303. 函数参数：
304.         unsigned char *cid_data(寄存CID的内乱存，最少16Byte）            
305. 返 回 值：
306.         0：胜利，1：毛病       
307. */
308. unsigned char GetSDCardCSSDCardOutnfo(unsigned char *csd_data)
309. {
310.         unsigned char r1;         
311.         r1=SendSDCardCmd(SDCard_CMD9,0,0x01);    //收SDCard_CMD9号令，读CSD
312.         if(r1==0)
313.         {
314.                 r1=SDCardRecvData(csd_data, 16);//领受16个字节的数据
315.         }
316.         SDCardCancelCS();//打消片选
317.         if(r1)return 1;
318.         else return 0;
319. }  
322. /*
323. 函数功用：获得SD卡的总扇区数（扇区数）   
324. 返 回 值：
325.         0暗示容量检测堕落，其他值暗示SD卡的容量(扇区数/512字节)
326. 道   明：
327.         每扇区的字节数必为512字节，假如没有是512字节，则初初化不克不及经由过程.       
328. */
329. unsigned int GetSDCardSectorCount(void)
330. {
331.     unsigned char csd[16];
332.     unsigned int Capacity;  
333.     unsigned char n;
334.           u16 csize;                                              
335.     if(GetSDCardCSSDCardOutnfo(csd)!=0) return 0;        //与CSD疑息，假如时期堕落，返回0
336.     if((csd[0]&0xC0)==0x40)                //V2.00的卡,假如为SDHC卡，根据上面方法计较
337.     {       
338.                         csize = csd[9] + ((u16)csd[8] << 8) + 1;
339.                         Capacity = (unsigned int)csize << 10;//获得扇区数                           
340.     }
341.                 else//V1.XX的卡
342.     {       
343.                         n = (csd[5] & 15) + ((csd[10] & 128) >> 7) + ((csd[9] & 3) << 1) + 2;
344.                         csize = (csd[8] >> 6) + ((u16)csd[7] << 2) + ((u16)(csd[6] & 3) << 10) + 1;
345.                         Capacity= (unsigned int)csize << (n - 9);//获得扇区数   
346.     }
347.     return Capacity;
348. }
350. /*
351. 函数功用： 初初化SD卡
352. 返 回 值： 非0暗示初初化失利!
353. */
354. unsigned char SDCardDeviceInit(void)
355. {
356.   unsigned char r1;      // 寄存SD卡的返回值
357.   u16 retry;  // 用去停止超时计数
358.   unsigned char buf[4];  
359.         u16 i;
360.         SDCardSpiInit();                //初初化底层IO心
361.        
362.         for(i=0;i<10;i++)SDCardReadWriteOneByte(0XFF); //收收起码74个脉冲
363.         retry=20;
364.         do
365.         {
366.                 r1=SendSDCardCmd(SDCard_CMD0,0,0x95);//进进IDLE形态 忙置
367.         }while((r1!=0X01) && retry--);
368.         SD_Type=0;   //默许无卡
369.         if(r1==0X01)
370.         {
371.                 if(SendSDCardCmd(SDCard_CMD8,0x1AA,0x87)==1)  //SD V2.0
372.                 {
373.                         for(i=0;i<4;i++)buf[i]=SDCardReadWriteOneByte(0XFF);        //Get trailing return value of R7 resp
374.                         if(buf[2]==0X01&&buf[3]==0XAA)    //卡能否撑持2.7~3.6V
375.                         {
376.                                 retry=0XFFFE;
377.                                 do
378.                                 {
379.                                         SendSDCardCmd(SDCard_CMD55,0,0X01);            //收收SDCard_CMD55
380.                                         r1=SendSDCardCmd(SDCard_CMD41,0x40000000,0X01);//收收SDCard_CMD41
381.                                 }while(r1&&retry--);
382.                                 if(retry&&SendSDCardCmd(SDCard_CMD58,0,0X01)==0)//辨别SD2.0卡版本开端
383.                                 {
384.                                         for(i=0;i<4;i++)buf[i]=SDCardReadWriteOneByte(0XFF);//获得OCR值
385.                                         if(buf[0]&0x40)SD_Type=SDCard_TYPE_V2HC;    //查抄CCS
386.                                         else SD_Type=SDCard_TYPE_V2;   
387.                                 }
388.                         }
389.                 }
390.                 else//SD V1.x/ MMC        V3
391.                 {
392.                         SendSDCardCmd(SDCard_CMD55,0,0X01);                //收收SDCard_CMD55
393.                         r1=SendSDCardCmd(SDCard_CMD41,0,0X01);        //收收SDCard_CMD41
394.                         if(r1<=1)
395.                         {               
396.                                 SD_Type=SDCard_TYPE_V1;
397.                                 retry=0XFFFE;
398.                                 do //等候退出IDLE形式
399.                                 {
400.                                         SendSDCardCmd(SDCard_CMD55,0,0X01);        //收收SDCard_CMD55
401.                                         r1=SendSDCardCmd(SDCard_CMD41,0,0X01);//收收SDCard_CMD41
402.                                 }while(r1&&retry--);
403.                         }
404.                         else//MMC卡没有撑持SDCard_CMD55+SDCard_CMD41辨认
405.                         {
406.                                 SD_Type=SDCard_TYPE_MMC;//MMC V3
407.                                 retry=0XFFFE;
408.                                 do //等候退出IDLE形式
409.                                 {                                                                                            
410.                                         r1=SendSDCardCmd(SDCard_CMD1,0,0X01);//收收SDCard_CMD1
411.                                 }while(r1&&retry--);  
412.                         }
413.                         if(retry==0||SendSDCardCmd(SDCard_CMD13,512,0X01)!=0)SD_Type=SDCard_TYPE_ERR;//毛病的卡
414.                 }
415.         }
416.         SDCardCancelCS();       //打消片选
417.         if(SD_Type)return 0;  //初初化胜利返回0
418.         else if(r1)return r1; //返回值毛病值          
419.         return 0xaa;          //其他毛病
420. }
423. /*
424. 函数功用：读SD卡
425. 函数参数：
426.         buf:数据缓存区
427.         sector:扇区
428.         cnt:扇区数
429. 返回值:
430.         0,ok;其他,失利.
431. 道  明：
432.         SD卡一个扇区巨细512字节
433. */
434. unsigned char SDCardReadData(unsigned char*buf,unsigned int sector,unsigned int cnt)
435. {
436.         unsigned char r1;
437.         if(SD_Type!=SDCard_TYPE_V2HC)sector<<=9;//转换为字节地点
438.         if(cnt==1)
439.         {
440.                 r1=SendSDCardCmd(SDCard_CMD17,sector,0X01);//读号令
441.                 if(r1==0)                                                                                                  //指令收收胜利
442.                 {
443.                         r1=SDCardRecvData(buf,512);                        //领受512个字节          
444.                 }
445.         }else
446.         {
447.                 r1=SendSDCardCmd(SDCard_CMD18,sector,0X01);//持续读号令
448.                 do
449.                 {
450.                         r1=SDCardRecvData(buf,512);//领受512个字节         
451.                         buf+=512;  
452.                 }while(--cnt && r1==0);        
453.                 SendSDCardCmd(SDCard_CMD12,0,0X01);        //收收截至号令
454.         }   
455.         SDCardCancelCS();//打消片选
456.         return r1;//
457. }
462. /*
463. 函数功用：背SD卡写数据
464. 函数参数：
465.                 buf:数据缓存区
466.                 sector:肇端扇区
467.                 cnt:扇区数
468. 返回值：
469.                 0,ok;其他,失利.
470. 道  明：
471.                 SD卡一个扇区巨细512字节
472. */
473. unsigned char SDCardWriteData(unsigned char*buf,unsigned int sector,unsigned int cnt)
474. {
475.         unsigned char r1;
476.         if(SD_Type!=SDCard_TYPE_V2HC)sector *= 512;//转换为字节地点
477.         if(cnt==1)
478.         {
479.                 r1=SendSDCardCmd(SDCard_CMD24,sector,0X01);//读号令
480.                 if(r1==0)//指令收收胜利
481.                 {
482.                         r1=SDCardSendData(buf,0xFE);//写512个字节          
483.                 }
484.         }
485.         else
486.         {
487.                 if(SD_Type!=SDCard_TYPE_MMC)
488.                 {
489.                         SendSDCardCmd(SDCard_CMD55,0,0X01);       
490.                         SendSDCardCmd(SDCard_CMD23,cnt,0X01);//收收指令       
491.                 }
492.                 r1=SendSDCardCmd(SDCard_CMD25,sector,0X01);//持续读号令
493.                 if(r1==0)
494.                 {
495.                         do
496.                         {
497.                                 r1=SDCardSendData(buf,0xFC);//领受512个字节         
498.                                 buf+=512;  
499.                         }while(--cnt && r1==0);
500.                         r1=SDCardSendData(0,0xFD);//领受512个字节
501.                 }
502.         }   
503.         SDCardCancelCS();//打消片选
504.         return r1;//
505. }       
514. /*
515. 功用阐明:
516. 1. 撑持文件体系格局化: #mkfs.ext2 /dev/tiny4412_block_a
517. 2. 撑持mount挂载: #mount /dev/tiny4412_block_a /mnt/
518. 3. 撑持磁盘巨细检察: #cat /sys/block/Tiny4412_block_a/size
519.                      #df -h   
520. */
522. static struct request_queue *queue=NULL;  /* 装备恳求行列 */
523. static struct gendisk *gd;                    /* gendisk构造 */
524. static unsigned int sd_size=0;                  //寄存SD卡返回的容量扇区数目单元(512字节)
525. static int Tiny4412_block_major = 0;      /*寄存主装备号*/
526. static DEFINE_MUTEX(sd_mutex); /*静态界说互斥锁*/
529. /*
530. * Handle an I/O request.
531. * 完成扇区的读写
532. */
533. static void Tiny4412_block_dev_sector_read_write(unsigned long sector,unsigned long nsect, char *buffer, int write)
534. {
535.                 /*互斥锁，上锁*/       
536.                 mutex_lock(&sd_mutex);
537.                 sector>>=9;
538.                 nsect>>=9;
539.                
540.                 /*块装备最小单元是一个扇区，一个扇区的字节数是512字节*/
541.                 if(write)
542.                 {
543.                         if(SDCardWriteData(buffer,sector,nsect))
544.                         {
545.                                 printk(KERN_ERR"write error!\r\n");
546.                                 printk("write --->  nsect=%ld,sector=%ld\r\n",nsect,sector);
547.                         }
548.                 }
549.                 else
550.                 {
551.                         if(SDCardReadData(buffer,sector,nsect))
552.                         {
553.                                 printk(KERN_ERR"read error!\r\n");
554.                                 printk("read --->  nsect=%ld,sector=%ld\r\n",nsect,sector);
555.                         }
556.                 }
557.                
558.                 /*互斥锁解锁*/       
559.                 mutex_unlock(&sd_mutex);
560. }
563. /*
564. 处置恳求
565. */
566. static void Tiny4412_block_make_request(struct request_queue *q, struct bio *bio)
567. {
568.         int dir;
569.         unsigned long long dsk_offset;
570.         struct bio_vec *bvec;
571.         int i;
572.         void *iovec_mem;
573.        
574.         /*判定读写标的目的*/
575.         if(bio_data_dir(bio) == WRITE) dir = 1;
576.         else dir = 0;
577.         dsk_offset = bio->bi_sector << 9;
578.         bio_for_each_segment(bvec, bio, i)
579.         {
580.                 iovec_mem = kmap(bvec->bv_page) + bvec->bv_offset;
581.                
582.                 //肇端地位,少度,源数据,标的目的
583.                 Tiny4412_block_dev_sector_read_write(dsk_offset,bvec->bv_len,iovec_mem,dir);
584.                
585.                 kunmap(bvec->bv_page);
586.                 dsk_offset += bvec->bv_len;
587.         }
588.         bio_endio(bio, 0);
589. }
591. static int tiny4412_blockdev_getgeo(struct block_device *bdev, struct hd_geometry *geo)
592. {
593.         /* 容量=heads*cylinders*sectors*512
594.          * 存储容量 ＝ 磁头数 × 磁讲(柱里)数 × 每讲扇区数 × 每扇区字节数
595.          */
596.         geo->heads     = 2;  /*磁头(普通一个盘里有两个磁头，正里一个/背面一个)*/
597.         geo->cylinders = 32; /*柱里(普通一个盘里上有32个柱里)每一个盘片32个磁讲)*/
598.         geo->sectors   = sd_size/2/32; /*扇区,普通每一个磁讲上有12个扇区，那里需求按照前里柱里战磁头停止计较，不克不及治挖*/
599.         /*geo->sectors =存储容量/磁头数/柱里/每扇区字节数*/
600.         return 0;
601. }
603. /*
604. * 块装备文件操纵汇合接心
605. */
606. static struct block_device_operations Tiny4412_block_ops=
607. {
608.         .owner = THIS_MODULE,
609.          /*fdisk号令分区时需求挪用该函数，用于读与磁头、柱里、扇区等疑息*/
610.         .getgeo        = tiny4412_blockdev_getgeo,
611. };
614. /*
615. 驱动进口
616. */
617. static int __init Tiny4412_block_init(void)
618. {
619.         /*1. 初初化SD心*/
620.         if(SDCardDeviceInit())
621.         {
622.            printk("SD卡初初化失利!\r\n");
623.            return -1;
624.         }
625.        
626.         /*2. 检测SD卡巨细*/
627.         sd_size=GetSDCardSectorCount();        //检测SD卡巨细，返回值左移11位获得以M为单元的容量
628.         printk("SD卡Sizeof:%dM  secnt=%d\r\n",sd_size>>11,sd_size);
629.        
630.         /*注册一个块装备,主动分派主装备号*/
631.         Tiny4412_block_major = register_blkdev(0, "Tiny4412_SDdrv");
633.         /*静态分派恳求行列*/
634.         queue=blk_alloc_queue(GFP_KERNEL);
636.         /*绑定恳求行列*/
637.         blk_queue_make_request(queue, Tiny4412_block_make_request);
639.         /*静态分派次装备号构造*/
640.         gd=alloc_disk(16);/*分派一个gendisk，分区是一个*/
641.         gd->major=Tiny4412_block_major;          /*主装备号*/
642.         gd->first_minor=0;                                     /*次装备号*/
643.         gd->fops=&Tiny4412_block_ops;
644.         gd->queue=queue;                                           /*将恳求行列联系关系到gendisk构造*/
645.         snprintf(gd->disk_name, 32, "tiny4412_sd%c",&#39;a&#39;);
646.        
647.         /*设置磁盘构造 capacity 的容量*/
648.         /*留意: 块装备的巨细利用扇区做为单元设置，而扇区的巨细默许是512字节。
649.           cat /sys/block/xxxx/size 能够检察到设置的巨细
650.           把字节为单元的巨细转换为以扇区为单元时，我们需求除以512，大概左移9位
651.         */
652.         set_capacity(gd,sd_size);
654.         /*注册磁盘装备*/
655.         add_disk(gd);
656.         printk("块装备注册胜利!\r\n");
657.         return 0;
658. }
661. /*驱动出心*/
662. static void Tiny4412_block_exit(void)
663. {
664.         /*开释假造地点*/
665.         iounmap(SD_GPBCON);
666.         iounmap(SD_GPBDAT);
667.        
668.         /*登记磁盘装备*/
669.         if(gd)del_gendisk(gd);       
671.         /*登记块装备*/
672.         if(Tiny4412_block_major!=0)unregister_blkdev(Tiny4412_block_major, "Tiny4412_SDdrv");
673.        
674.         printk("块装备注消胜利!\r\n");
675. }
677. module_init(Tiny4412_block_init);
678. module_exit(Tiny4412_block_exit);
679. MODULE_LICENSE("GPL");

复造代码

 3.4 利用SD卡编写块装备(利用默许的IO调理器)

[code]/* 参考: * drivers\block\xd.c * drivers\block\z2ram.c */#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include  #include #include #include #include #include #include #include #include #include /*--------------------------------SD相干操纵代码---------------------------------------------*//*界说指针，用于领受假造地点*/volatile unsigned int *SD_GPBCON;volatile unsigned int *SD_GPBDAT;        /*函数功用：SD初初化Tiny4412硬件毗邻：        DO--MISO :GPB_2        DI--MOSI :GPB_3        CLK-SCLK :GPB_0        CS--CS   :GPB_1*/void SDCardSpiInit(void){        /*1. 初初化GPIO*/        /*映照物理地点*/        SD_GPBCON=ioremap(0x11400040,4);        SD_GPBDAT=ioremap(0x11400044,4);                *SD_GPBCON &= ~(0xf