您的位置 首页 电路

ARM-Linux驱动–MTD驱动剖析(三)

2020年9月18日 15:03 阅读(305)

主机：GentooLinux112withlinuxkernel306硬件平台：FL2440（S3C2440）withlinuxkernel2635原创作品，转载请标明出

主机：Gentoo Linux 11.2 with linux kernel 3.0.6

硬件渠道：FL2440（S3C2440）with linux kernel 2.6.35

本文剖析MTD设备的分区办理机制

分区办理实际上是将一个MTD设备分红几个分区，将其作为独自的MTD原始设备进行办理。

1、分区的结构体描绘结构体mtd_part

  1. /*Ourpartitionnodestructure*/
  2. //分区结构信息
  3. structmtd_part{
  4. structmtd_infomtd;//mtd_info数据结构，会被参加mtd_table中
  5. structmtd_info*master;//该分区的主分区
  6. uint64_toffset;//该分区的偏移地址
  7. structlist_headlist;
  8. };

2、分区链表mtd_partitions

  1. /*Ourpartitionlinkedlist*/
  2. //声明mtd_partitions链表
  3. staticLIST_HEAD(mtd_partitions);

3、add_mtd_partitions函数

  1. /*
  2. *Thisfunction,givenamasterMTDobjectandapartitiontable,creates
  3. *andregistersslaveMTDobjectswhichareboundtothemasteraccordingto
  4. *thepartitiondefinitions.
  5. *
  6. *Wedontregisterthemaster,orexpectthecallertohavedoneso,
  7. *forreasonsofdataintegrity.
  8. */
  9. //依据一个MTD主设备和分区表，创立新的主设备下的副设备并记录到分区表中
  10. //这儿咱们不将打针被注册到分区表中，只注册副设备到到分区表中
  11. intadd_mtd_partitions(structmtd_info*master,
  12. conststructmtd_partition*parts,
  13. intnbparts)
  14. {
  15. structmtd_part*slave;
  16. uint64_tcur_offset=0;
  17. inti;
  19. printk(KERN_NOTICE”Creating%dMTDpartitionson\”%s\”:\n”,nbparts,master->name);
  21. for(i=0;i
  22. slave=add_one_partition(master,parts+i,i,cur_offset);
  23. if(!slave)
  24. return-ENOMEM;
  25. cur_offset=slave->offset+slave->mtd.size;
  26. }
  28. return0;
  29. }
  30. EXPORT_SYMBOL(add_mtd_partitions);

而add_one_partition函数完成如下：

  1. //创立一个分区
  2. staticstructmtd_part*add_one_partition(structmtd_info*master,
  3. conststructmtd_partition*part,intpartno,
  4. uint64_tcur_offset)
  5. {
  6. structmtd_part*slave;
  8. /*allocatethepartitionstructure*/
  9. slave=kzalloc(sizeof(*slave),GFP_KERNEL);//分配内存
  10. if(!slave){
  11. printk(KERN_ERR”memoryallocationerrorwhilecreatingpartitionsfor\”%s\”\n”,
  12. master->name);
  13. del_mtd_partitions(master);
  14. returnNULL;
  15. }
  16. list_add(&slave->list,&mtd_partitions);//将原始设备表增加到分区表中
  18. /*setuptheMTDobjectforthispartition*/
  19. //大部分依据master相应的信息设置MTD分区slave的信息
  20. slave->mtd.type=master->type;
  21. slave->mtd.flags=master->flags&~part->mask_flags;
  22. slave->mtd.size=part->size;
  23. slave->mtd.writesize=master->writesize;
  24. slave->mtd.oobsize=master->oobsize;
  25. slave->mtd.oobavail=master->oobavail;
  26. slave->mtd.subpage_sft=master->subpage_sft;
  28. slave->mtd.name=part->name;
  29. slave->mtd.owner=master->owner;
  30. slave->mtd.backing_dev_info=master->backing_dev_info;
  32. /*NOTE:wedontarrangeMTDsasatree;itdbeerror-prone
  33. *tohavethesamedatabeintwodifferentpartitions.
  34. */
  35. slave->mtd.dev.parent=master->dev.parent;
  37. slave->mtd.read=part_read;
  38. slave->mtd.write=part_write;
  40. if(master->panic_write)
  41. slave->mtd.panic_write=part_panic_write;
  43. if(master->point&&master->unpoint){
  44. slave->mtd.point=part_point;
  45. slave->mtd.unpoint=part_unpoint;
  46. }
  48. if(master->get_unmapped_area)
  49. slave->mtd.get_unmapped_area=part_get_unmapped_area;
  50. if(master->read_oob)
  51. slave->mtd.read_oob=part_read_oob;
  52. if(master->write_oob)
  53. slave->mtd.write_oob=part_write_oob;
  54. if(master->read_user_prot_reg)
  55. slave->mtd.read_user_prot_reg=part_read_user_prot_reg;
  56. if(master->read_fact_prot_reg)
  57. slave->mtd.read_fact_prot_reg=part_read_fact_prot_reg;
  58. if(master->write_user_prot_reg)
  59. slave->mtd.write_user_prot_reg=part_write_user_prot_reg;
  60. if(master->lock_user_prot_reg)
  61. slave->mtd.lock_user_prot_reg=part_lock_user_prot_reg;
  62. if(master->get_user_prot_info)
  63. slave->mtd.get_user_prot_info=part_get_user_prot_info;
  64. if(master->get_fact_prot_info)
  65. slave->mtd.get_fact_prot_info=part_get_fact_prot_info;
  66. if(master->sync)
  67. slave->mtd.sync=part_sync;
  68. if(!partno&&!master->dev.class&&master->suspend&&master->resume){
  69. slave->mtd.suspend=part_suspend;
  70. slave->mtd.resume=part_resume;
  71. }
  72. if(master->writev)
  73. slave->mtd.writev=part_writev;
  74. if(master->lock)
  75. slave->mtd.lock=part_lock;
  76. if(master->unlock)
  77. slave->mtd.unlock=part_unlock;
  78. if(master->block_isbad)
  79. slave->mtd.block_isbad=part_block_isbad;
  80. if(master->block_markbad)
  81. slave->mtd.block_markbad=part_block_markbad;
  82. slave->mtd.erase=part_erase;
  83. slave->master=master;
  84. slave->offset=part->offset;
  86. if(slave->offset==MTDPART_OFS_APPEND)
  87. slave->offset=cur_offset;
  88. if(slave->offset==MTDPART_OFS_NXTBLK){
  89. slave->offset=cur_offset;
  90. if(mtd_mod_by_eb(cur_offset,master)!=0){
  91. /*Rounduptonexterasesize*/
  92. slave->offset=(mtd_div_by_eb(cur_offset,master)+1)*master->erasesize;
  93. printk(KERN_NOTICE”Movingpartition%d:”
  94. “0x%012llx->0x%012llx\n”,partno,
  95. (unsignedlonglong)cur_offset,(unsignedlonglong)slave->offset);
  96. }
  97. }
  98. if(slave->mtd.size==MTDPART_SIZ_FULL)
  99. slave->mtd.size=master->size-slave->offset;
  101. printk(KERN_NOTICE”0x%012llx-0x%012llx:\”%s\”\n”,(unsignedlonglong)slave->offset,
  102. (unsignedlonglong)(slave->offset+slave->mtd.size),slave->mtd.name);
  104. /*letsdosomesanitychecks*/
  105. if(slave->offset>=master->size){
  106. /*letsregisteritanywaytopreserveordering*/
  107. slave->offset=0;
  108. slave->mtd.size=0;
  109. printk(KERN_ERR”mtd:partition\”%s\”isoutofreach–disabled\n”,
  110. part->name);
  111. gotoout_register;
  112. }
  113. if(slave->offset+slave->mtd.size>master->size){
  114. slave->mtd.size=master->size-slave->offset;
  115. printk(KERN_WARNING”mtd:partition\”%s\”extendsbeyondtheendofdevice\”%s\”–sizetruncatedto%#llx\n”,
  116. part->name,master->name,(unsignedlonglong)slave->mtd.size);
  117. }
  118. if(master->numeraseregions>1){
  119. /*Dealwithvariableerasesizestuff*/
  120. inti,max=master->numeraseregions;
  121. u64end=slave->offset+slave->mtd.size;
  122. structmtd_erase_region_info*regions=master->eraseregions;
  124. /*Findthefirsteraseregionswhichispartofthis
  125. *partition.*/
  126. for(i=0;ioffset;i++)
  127. ;
  128. /*Theloopsearchedfortheregion_behind_thefirstone*/
  129. if(i>0)
  130. i–;
  132. /*Pickbiggesterasesize*/
  133. for(;i
  134. if(slave->mtd.erasesize
  135. slave->mtd.erasesize=regions[i].erasesize;
  136. }
  137. }
  138. BUG_ON(slave->mtd.erasesize==0);
  139. }else{
  140. /*Singleerasesize*/
  141. slave->mtd.erasesize=master->erasesize;
  142. }
  144. if((slave->mtd.flags&MTD_WRITEABLE)&&
  145. mtd_mod_by_eb(slave->offset,&slave->mtd)){
  146. /*Doesntstartonaboundaryofmajorerasesize*/
  147. /*FIXME:Letitbewritableifitisonaboundaryof
  148. *_minor_erasesizethough*/
  149. slave->mtd.flags&=~MTD_WRITEABLE;
  150. printk(KERN_WARNING”mtd:partition\”%s\”doesntstartonaneraseblockboundary–forceread-only\n”,
  151. part->name);
  152. }
  153. if((slave->mtd.flags&MTD_WRITEABLE)&&
  154. mtd_mod_by_eb(slave->mtd.size,&slave->mtd)){
  155. slave->mtd.flags&=~MTD_WRITEABLE;
  156. printk(KERN_WARNING”mtd:partition\”%s\”doesntendonaneraseblock–forceread-only\n”,
  157. part->name);
  158. }
  160. slave->mtd.ecclayout=master->ecclayout;
  161. if(master->block_isbad){
  162. uint64_toffs=0;
  164. while(offsmtd.size){
  165. if(master->block_isbad(master,
  166. offs+slave->offset))
  167. slave->mtd.ecc_stats.badblocks++;
  168. offs+=slave->mtd.erasesize;
  169. }
  170. }
  172. out_register:
  173. /*registerourpartition*/
  174. //最终调用add_mtd_device依据该设备的mtd_info信息增加设备链表，将其作为一个独立的MTD原始设备
  175. add_mtd_device(&slave->mtd);
  177. returnslave;
  178. }

4、del_mtd_partition函数

  1. /*
  2. *ThisfunctionunregistersanddestroyallslaveMTDobjectswhichare
  3. *attachedtothegivenmasterMTDobject.
  4. */
  5. //将一个主设备下的一切副设备删去
  6. intdel_mtd_partitions(structmtd_info*master)
  7. {
  8. structmtd_part*slave,*next;
  10. list_for_each_entry_safe(slave,next,&mtd_partitions,list)//遍历mtd_partitions链表，查找到指定的主设备
  11. if(slave->master==master){
  12. list_del(&slave->list);//将主设备下的隶属设备删去
  13. del_mtd_device(&slave->mtd);//调用del_mtd_device函数将每个设备从MTD原始设备表中删去
  14. kfree(slave);//开释内存
  15. }
  17. return0;
  18. }
  19. EXPORT_SYMBOL(del_mtd_partitions);

5、其他的分区办理函数

  1. /*
  2. *MTDmethodswhichsimplytranslatetheeffectiveaddressandpassthrough
  3. *tothe_real_device.
  4. */
  5. //读取某个分区的指定数据
  6. staticintpart_read(structmtd_info*mtd,loff_tfrom,size_tlen,
  7. size_t*retlen,u_char*buf)
  8. {
  9. structmtd_part*part=PART(mtd);
  10. structmtd_ecc_statsstats;
  11. intres;
  13. stats=part->master->ecc_stats;
  15. if(from>=mtd->size)
  16. len=0;
  17. elseif(from+len>mtd->size)
  18. len=mtd->size-from;
  19. res=part->master->read(part->master,from+part->offset,
  20. len,retlen,buf);
  21. if(unlikely(res)){
  22. if(res==-EUCLEAN)
  23. mtd->ecc_stats.corrected+=part->master->ecc_stats.corrected-stats.corrected;
  24. if(res==-EBADMSG)
  25. mtd->ecc_stats.failed+=part->master->ecc_stats.failed-stats.failed;
  26. }
  27. returnres;
  28. }
  30. staticintpart_point(structmtd_info*mtd,loff_tfrom,size_tlen,
  31. size_t*retlen,void**virt,resource_size_t*phys)
  32. {
  33. structmtd_part*part=PART(mtd);
  34. if(from>=mtd->size)
  35. len=0;
  36. elseif(from+len>mtd->size)
  37. len=mtd->size-from;
  38. returnpart->master->point(part->master,from+part->offset,
  39. len,retlen,virt,phys);
  40. }
  42. staticvoidpart_unpoint(structmtd_info*mtd,loff_tfrom,size_tlen)
  43. {
  44. structmtd_part*part=PART(mtd);
  46. part->master->unpoint(part->master,from+part->offset,len);
  47. }
  48. //获取闲暇的内存驱动
  49. staticunsignedlongpart_get_unmapped_area(structmtd_info*mtd,
  50. unsignedlonglen,
  51. unsignedlongoffset,
  52. unsignedlongflags)
  53. {
  54. structmtd_part*part=PART(mtd);
  56. offset+=part->offset;
  57. returnpart->master->get_unmapped_area(part->master,len,offset,
  58. flags);
  59. }
  61. staticintpart_read_oob(structmtd_info*mtd,loff_tfrom,
  62. structmtd_oob_ops*ops)
  63. {
  64. structmtd_part*part=PART(mtd);
  65. intres;
  67. if(from>=mtd->size)
  68. return-EINVAL;
  69. if(ops->datbuf&&from+ops->len>mtd->size)
  70. return-EINVAL;
  71. res=part->master->read_oob(part->master,from+part->offset,ops);
  73. if(unlikely(res)){
  74. if(res==-EUCLEAN)
  75. mtd->ecc_stats.corrected++;
  76. if(res==-EBADMSG)
  77. mtd->ecc_stats.failed++;
  78. }
  79. returnres;
  80. }
  82. staticintpart_read_user_prot_reg(structmtd_info*mtd,loff_tfrom,
  83. size_tlen,size_t*retlen,u_char*buf)
  84. {
  85. structmtd_part*part=PART(mtd);
  86. returnpart->master->read_user_prot_reg(part->master,from,
  87. len,retlen,buf);
  88. }
  90. staticintpart_get_user_prot_info(structmtd_info*mtd,
  91. structotp_info*buf,size_tlen)
  92. {
  93. structmtd_part*part=PART(mtd);
  94. returnpart->master->get_user_prot_info(part->master,buf,len);
  95. }
  97. staticintpart_read_fact_prot_reg(structmtd_info*mtd,loff_tfrom,
  98. size_tlen,size_t*retlen,u_char*buf)
  99. {
  100. structmtd_part*part=PART(mtd);
  101. returnpart->master->read_fact_prot_reg(part->master,from,
  102. len,retlen,buf);
  103. }
  105. staticintpart_get_fact_prot_info(structmtd_info*mtd,structotp_info*buf,
  106. size_tlen)
  107. {
  108. structmtd_part*part=PART(mtd);
  109. returnpart->master->get_fact_prot_info(part->master,buf,len);
  110. }
  111. //分区写函数
  112. staticintpart_write(structmtd_info*mtd,loff_tto,size_tlen,
  113. size_t*retlen,constu_char*buf)
  114. {
  115. structmtd_part*part=PART(mtd);
  116. if(!(mtd->flags&MTD_WRITEABLE))
  117. return-EROFS;
  118. if(to>=mtd->size)
  119. len=0;
  120. elseif(to+len>mtd->size)
  121. len=mtd->size-to;
  122. returnpart->master->write(part->master,to+part->offset,
  123. len,retlen,buf);
  124. }
  126. staticintpart_panic_write(structmtd_info*mtd,loff_tto,size_tlen,
  127. size_t*retlen,constu_char*buf)
  128. {
  129. structmtd_part*part=PART(mtd);
  130. if(!(mtd->flags&MTD_WRITEABLE))
  131. return-EROFS;
  132. if(to>=mtd->size)
  133. len=0;
  134. elseif(to+len>mtd->size)
  135. len=mtd->size-to;
  136. returnpart->master->panic_write(part->master,to+part->offset,
  137. len,retlen,buf);
  138. }
  140. staticintpart_write_oob(structmtd_info*mtd,loff_tto,
  141. structmtd_oob_ops*ops)
  142. {
  143. structmtd_part*part=PART(mtd);
  145. if(!(mtd->flags&MTD_WRITEABLE))
  146. return-EROFS;
  148. if(to>=mtd->size)
  149. return-EINVAL;
  150. if(ops->datbuf&&to+ops->len>mtd->size)
  151. return-EINVAL;
  152. returnpart->master->write_oob(part->master,to+part->offset,ops);
  153. }
  155. staticintpart_write_user_prot_reg(structmtd_info*mtd,loff_tfrom,
  156. size_tlen,size_t*retlen,u_char*buf)
  157. {
  158. structmtd_part*part=PART(mtd);
  159. returnpart->master->write_user_prot_reg(part->master,from,
  160. len,retlen,buf);
  161. }
  163. staticintpart_lock_user_prot_reg(structmtd_info*mtd,loff_tfrom,
  164. size_tlen)
  165. {
  166. structmtd_part*part=PART(mtd);
  167. returnpart->master->lock_user_prot_reg(part->master,from,len);
  168. }
  170. staticintpart_writev(structmtd_info*mtd,conststructkvec*vecs,
  171. unsignedlongcount,loff_tto,size_t*retlen)
  172. {
  173. structmtd_part*part=PART(mtd);
  174. if(!(mtd->flags&MTD_WRITEABLE))
  175. return-EROFS;
  176. returnpart->master->writev(part->master,vecs,count,
  177. to+part->offset,retlen);
  178. }
  180. staticintpart_erase(structmtd_info*mtd,structerase_info*instr)
  181. {
  182. structmtd_part*part=PART(mtd);
  183. intret;
  184. if(!(mtd->flags&MTD_WRITEABLE))
  185. return-EROFS;
  186. if(instr->addr>=mtd->size)
  187. return-EINVAL;
  188. instr->addr+=part->offset;
  189. ret=part->master->erase(part->master,instr);
  190. if(ret){
  191. if(instr->fail_addr!=MTD_FAIL_ADDR_UNKNOWN)
  192. instr->fail_addr-=part->offset;
  193. instr->addr-=part->offset;
  194. }
  195. returnret;
  196. }
  198. voidmtd_erase_callback(structerase_info*instr)
  199. {
  200. if(instr->mtd->erase==part_erase){
  201. structmtd_part*part=PART(instr->mtd);
  203. if(instr->fail_addr!=MTD_FAIL_ADDR_UNKNOWN)
  204. instr->fail_addr-=part->offset;
  205. instr->addr-=part->offset;
  206. }
  207. if(instr->callback)
  208. instr->callback(instr);
  209. }
  210. EXPORT_SYMBOL_GPL(mtd_erase_callback);
  212. staticintpart_lock(structmtd_info*mtd,loff_tofs,uint64_tlen)
  213. {
  214. structmtd_part*part=PART(mtd);
  215. if((len+ofs)>mtd->size)
  216. return-EINVAL;
  217. returnpart->master->lock(part->master,ofs+part->offset,len);
  218. }
  220. staticintpart_unlock(structmtd_info*mtd,loff_tofs,uint64_tlen)
  221. {
  222. structmtd_part*part=PART(mtd);
  223. if((len+ofs)>mtd->size)
  224. return-EINVAL;
  225. returnpart->master->unlock(part->master,ofs+part->offset,len);
  226. }
  227. //分区同步函数
  228. staticvoidpart_sync(structmtd_info*mtd)
  229. {
  230. structmtd_part*part=PART(mtd);
  231. part->master->sync(part->master);
  232. }
  233. //支撑电源办理的功用函数
  234. staticintpart_suspend(structmtd_info*mtd)
  235. {
  236. structmtd_part*part=PART(mtd);
  237. returnpart->master->suspend(part->master);
  238. }
  240. staticvoidpart_resume(structmtd_info*mtd)
  241. {
  242. structmtd_part*part=PART(mtd);
  243. part->master->resume(part->master);
  244. }
  246. staticintpart_block_isbad(structmtd_info*mtd,loff_tofs)
  247. {
  248. structmtd_part*part=PART(mtd);
  249. if(ofs>=mtd->size)
  250. return-EINVAL;
  251. ofs+=part->offset;
  252. returnpart->master->block_isbad(part->master,ofs);
  253. }
  254. //符号设备地址坏块
  255. staticintpart_block_markbad(structmtd_info*mtd,loff_tofs)
  256. {
  257. structmtd_part*part=PART(mtd);
  258. intres;
  260. if(!(mtd->flags&MTD_WRITEABLE))
  261. return-EROFS;
  262. if(ofs>=mtd->size)
  263. return-EINVAL;
  264. ofs+=part->offset;
  265. res=part->master->block_markbad(part->master,ofs);
  266. if(!res)
  267. mtd->ecc_stats.badblocks++;
  268. returnres;
  269. }

下篇剖析详细的MTD设备，字符设备和块设备，待续……..

声明：本文内容来自网络转载或用户投稿，文章版权归原作者和原出处所有。文中观点，不代表本站立场。若有侵权请联系本站删除（kf@86ic.com）https://www.86ic.net/fangan/dianlu/264551.html
4赞
标签:

为您推荐

车用TVS、电阻和温度传感器选型：三款位居C位的元件，推荐给你

并网型光伏系统结构及工作原理

电路仿真软件哪个比较好？

电路仿真软件哪个比较好？

嵌入式系统的微处理器选择

为什么运放会产生交越失真？

超小型滑动开关的选择及使用

联系我们

联系我们

在线咨询: QQ交谈

邮箱: kf@86ic.com

关注微信
微信扫一扫关注我们

微信扫一扫关注我们

返回顶部