开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
mtdconcat.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：16k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

mtdconcat.c：源码内容
  1. /*
  2.  * MTD device concatenation layer
  3.  *
  4.  * (C) 2002 Robert Kaiser <rkaiser@sysgo.de>
  5.  *
  6.  * This code is GPL
  7.  *
  8.  * $Id: mtdconcat.c,v 1.2 2002/03/22 08:45:22 dwmw2 Exp $
  9.  */
  11. #include <linux/module.h>
  12. #include <linux/types.h>
  13. #include <linux/kernel.h>
  14. #include <linux/slab.h>
  16. #include <linux/mtd/mtd.h>
  17. #include <linux/mtd/concat.h>
  19. /*
  20.  * Our storage structure:
  21.  * Subdev points to an array of pointers to struct mtd_info objects
  22.  * which is allocated along with this structure
  23.  *
  24.  */
  25. struct mtd_concat {
  26. struct mtd_info mtd;
  27. int             num_subdev;
  28. struct mtd_info **subdev;
  29. };
  31. /*
  32.  * how to calculate the size required for the above structure,
  33.  * including the pointer array subdev points to:
  34.  */
  35. #define SIZEOF_STRUCT_MTD_CONCAT(num_subdev)
  36. ((sizeof(struct mtd_concat) + (num_subdev) * sizeof(struct mtd_info *)))
  39. /*
  40.  * Given a pointer to the MTD object in the mtd_concat structure,
  41.  * we can retrieve the pointer to that structure with this macro.
  42.  */
  43. #define CONCAT(x)  ((struct mtd_concat *)(x))
  46. /* 
  47.  * MTD methods which look up the relevant subdevice, translate the
  48.  * effective address and pass through to the subdevice.
  49.  */
  51. static int concat_read (struct mtd_info *mtd, loff_t from, size_t len, 
  52. size_t *retlen, u_char *buf)
  53. {
  54. struct mtd_concat *concat = CONCAT(mtd);
  55. int err = -EINVAL;
  56. int i;
  58. *retlen = 0;
  60. for(i = 0; i < concat->num_subdev; i++)
  61. {
  62. struct mtd_info *subdev = concat->subdev[i];
  63. size_t size, retsize;
  65. if (from >= subdev->size)
  66. {
  67. size  = 0;
  68. from -= subdev->size;
  69. }
  70. else
  71. {
  72. if (from + len > subdev->size)
  73. size = subdev->size - from;
  74. else
  75. size = len;
  77. err = subdev->read(subdev, from, size, &retsize, buf);
  79. if(err)
  80. break;
  82. *retlen += retsize;
  83. len -= size;
  84. if(len == 0)
  85. break;
  87. err = -EINVAL;
  88. buf += size;
  89. from = 0;
  90. }
  91. }
  92. return err;
  93. }
  95. static int concat_write (struct mtd_info *mtd, loff_t to, size_t len,
  96. size_t *retlen, const u_char *buf)
  97. {
  98. struct mtd_concat *concat = CONCAT(mtd);
  99. int err = -EINVAL;
  100. int i;
  102. if (!(mtd->flags & MTD_WRITEABLE))
  103. return -EROFS;
  105. *retlen = 0;
  107. for(i = 0; i < concat->num_subdev; i++)
  108. {
  109. struct mtd_info *subdev = concat->subdev[i];
  110. size_t size, retsize;
  112. if (to >= subdev->size)
  113. {
  114. size  = 0;
  115. to -= subdev->size;
  116. }
  117. else
  118. {
  119. if (to + len > subdev->size)
  120. size = subdev->size - to;
  121. else
  122. size = len;
  124. if (!(subdev->flags & MTD_WRITEABLE))
  125. err = -EROFS;
  126. else
  127. err = subdev->write(subdev, to, size, &retsize, buf);
  129. if(err)
  130. break;
  132. *retlen += retsize;
  133. len -= size;
  134. if(len == 0)
  135. break;
  137. err = -EINVAL;
  138. buf += size;
  139. to = 0;
  140. }
  141. }
  142. return err;
  143. }
  145. static void concat_erase_callback (struct erase_info *instr)
  146. {
  147. wake_up((wait_queue_head_t *)instr->priv);
  148. }
  150. static int concat_dev_erase(struct mtd_info *mtd, struct erase_info *erase)
  151. {
  152. int err;
  153. wait_queue_head_t waitq;
  154. DECLARE_WAITQUEUE(wait, current);
  156. /*
  157.  * This code was stol^H^H^H^Hinspired by mtdchar.c
  158.  */
  159. init_waitqueue_head(&waitq);
  161. erase->mtd = mtd;
  162. erase->callback = concat_erase_callback;
  163. erase->priv = (unsigned long)&waitq;
  165. /*
  166.  * FIXME: Allow INTERRUPTIBLE. Which means
  167.  * not having the wait_queue head on the stack.
  168.  */
  169. err = mtd->erase(mtd, erase);
  170. if (!err)
  171. {
  172. set_current_state(TASK_UNINTERRUPTIBLE);
  173. add_wait_queue(&waitq, &wait);
  174. if (erase->state != MTD_ERASE_DONE && erase->state != MTD_ERASE_FAILED)
  175. schedule();
  176. remove_wait_queue(&waitq, &wait);
  177. set_current_state(TASK_RUNNING);
  179. err = (erase->state == MTD_ERASE_FAILED) ? -EIO : 0;
  180. }
  181. return err;
  182. }
  184. static int concat_erase (struct mtd_info *mtd, struct erase_info *instr)
  185. {
  186. struct mtd_concat *concat = CONCAT(mtd);
  187. struct mtd_info *subdev;
  188. int i, err;
  189. u_int32_t length;
  190. struct erase_info *erase;
  192. if (!(mtd->flags & MTD_WRITEABLE))
  193. return -EROFS;
  195. if(instr->addr > concat->mtd.size)
  196. return -EINVAL;
  198. if(instr->len + instr->addr > concat->mtd.size)
  199. return -EINVAL;
  201. /*
  202.  * Check for proper erase block alignment of the to-be-erased area.
  203.  * It is easier to do this based on the super device's erase
  204.  * region info rather than looking at each particular sub-device
  205.  * in turn.
  206.  */
  207. if (!concat->mtd.numeraseregions)
  208. { /* the easy case: device has uniform erase block size */
  209. if(instr->addr & (concat->mtd.erasesize - 1))
  210. return -EINVAL;
  211. if(instr->len & (concat->mtd.erasesize - 1))
  212. return -EINVAL;
  213. }
  214. else
  215. { /* device has variable erase size */
  216. struct mtd_erase_region_info *erase_regions = concat->mtd.eraseregions;
  218. /*
  219.  * Find the erase region where the to-be-erased area begins:
  220.  */
  221. for(i = 0; i < concat->mtd.numeraseregions && 
  222.            instr->addr >= erase_regions[i].offset; i++)
  223. ;
  224. --i;
  226. /*
  227.  * Now erase_regions[i] is the region in which the
  228.  * to-be-erased area begins. Verify that the starting
  229.  * offset is aligned to this region's erase size:
  230.  */
  231. if (instr->addr & (erase_regions[i].erasesize-1))
  232. return -EINVAL;
  234. /*
  235.  * now find the erase region where the to-be-erased area ends:
  236.  */
  237. for(; i < concat->mtd.numeraseregions && 
  238.       (instr->addr + instr->len) >=  erase_regions[i].offset ; ++i)
  239. ;
  240. --i;
  241. /*
  242.  * check if the ending offset is aligned to this region's erase size
  243.  */
  244. if ((instr->addr + instr->len) & (erase_regions[i].erasesize-1))
  245. return -EINVAL;
  246. }
  248. /* make a local copy of instr to avoid modifying the caller's struct */
  249. erase = kmalloc(sizeof(struct erase_info),GFP_KERNEL);
  251. if (!erase)
  252. return -ENOMEM;
  254. *erase = *instr;
  255. length = instr->len;
  257. /*
  258.  * find the subdevice where the to-be-erased area begins, adjust
  259.  * starting offset to be relative to the subdevice start
  260.  */
  261. for(i = 0; i < concat->num_subdev; i++)
  262. {
  263. subdev = concat->subdev[i];
  264. if(subdev->size <= erase->addr)
  265. erase->addr -= subdev->size;
  266. else
  267. break;
  268.     }
  269. if(i >= concat->num_subdev) /* must never happen since size */
  270. BUG(); /* limit has been verified above */
  272. /* now do the erase: */
  273. err = 0;
  274. for(;length > 0; i++) /* loop for all subevices affected by this request */
  275. {
  276. subdev = concat->subdev[i]; /* get current subdevice */
  278. /* limit length to subdevice's size: */
  279. if(erase->addr + length > subdev->size)
  280. erase->len = subdev->size - erase->addr;
  281. else
  282. erase->len = length;
  284. if (!(subdev->flags & MTD_WRITEABLE))
  285. {
  286. err = -EROFS;
  287. break;
  288. }
  289. length -= erase->len;
  290. if ((err = concat_dev_erase(subdev, erase)))
  291. {
  292. if(err == -EINVAL) /* sanity check: must never happen since */
  293. BUG(); /* block alignment has been checked above */
  294. break;
  295. }
  296. /*
  297.  * erase->addr specifies the offset of the area to be
  298.  * erased *within the current subdevice*. It can be
  299.  * non-zero only the first time through this loop, i.e.
  300.  * for the first subdevice where blocks need to be erased.
  301.  * All the following erases must begin at the start of the
  302.  * current subdevice, i.e. at offset zero.
  303.  */
  304. erase->addr = 0;
  305. }
  306. instr->state = MTD_ERASE_DONE;
  307. if (instr->callback)
  308. instr->callback(instr);
  309. kfree(erase);
  310. return err;
  311. }
  313. static int concat_lock (struct mtd_info *mtd, loff_t ofs, size_t len)
  314. {
  315. struct mtd_concat *concat = CONCAT(mtd);
  316. int i, err = -EINVAL;
  318. if ((len + ofs) > mtd->size) 
  319. return -EINVAL;
  321. for(i = 0; i < concat->num_subdev; i++)
  322. {
  323. struct mtd_info *subdev = concat->subdev[i];
  324. size_t size;
  326. if (ofs >= subdev->size)
  327. {
  328. size  = 0;
  329. ofs -= subdev->size;
  330. }
  331. else
  332. {
  333. if (ofs + len > subdev->size)
  334. size = subdev->size - ofs;
  335. else
  336. size = len;
  338. err = subdev->lock(subdev, ofs, size);
  340. if(err)
  341. break;
  343. len -= size;
  344. if(len == 0)
  345. break;
  347. err = -EINVAL;
  348. ofs = 0;
  349. }
  350. }
  351. return err;
  352. }
  354. static int concat_unlock (struct mtd_info *mtd, loff_t ofs, size_t len)
  355. {
  356. struct mtd_concat *concat = CONCAT(mtd);
  357. int i, err = 0;
  359. if ((len + ofs) > mtd->size) 
  360. return -EINVAL;
  362. for(i = 0; i < concat->num_subdev; i++)
  363. {
  364. struct mtd_info *subdev = concat->subdev[i];
  365. size_t size;
  367. if (ofs >= subdev->size)
  368. {
  369. size  = 0;
  370. ofs -= subdev->size;
  371. }
  372. else
  373. {
  374. if (ofs + len > subdev->size)
  375. size = subdev->size - ofs;
  376. else
  377. size = len;
  379. err = subdev->unlock(subdev, ofs, size);
  381. if(err)
  382. break;
  384. len -= size;
  385. if(len == 0)
  386. break;
  388. err = -EINVAL;
  389. ofs = 0;
  390. }
  391. }
  392. return err;
  393. }
  395. static void concat_sync(struct mtd_info *mtd)
  396. {
  397. struct mtd_concat *concat = CONCAT(mtd);
  398. int i;
  400. for(i = 0; i < concat->num_subdev; i++)
  401. {
  402. struct mtd_info *subdev = concat->subdev[i];
  403. subdev->sync(subdev);
  404. }
  405. }
  407. static int concat_suspend(struct mtd_info *mtd)
  408. {
  409. struct mtd_concat *concat = CONCAT(mtd);
  410. int i, rc = 0;
  412. for(i = 0; i < concat->num_subdev; i++)
  413. {
  414. struct mtd_info *subdev = concat->subdev[i];
  415. if((rc = subdev->suspend(subdev)) < 0)
  416. return rc;
  417. }
  418. return rc;
  419. }
  421. static void concat_resume(struct mtd_info *mtd)
  422. {
  423. struct mtd_concat *concat = CONCAT(mtd);
  424. int i;
  426. for(i = 0; i < concat->num_subdev; i++)
  427. {
  428. struct mtd_info *subdev = concat->subdev[i];
  429. subdev->resume(subdev);
  430. }
  431. }
  433. /*
  434.  * This function constructs a virtual MTD device by concatenating
  435.  * num_devs MTD devices. A pointer to the new device object is
  436.  * stored to *new_dev upon success. This function does _not_
  437.  * register any devices: this is the caller's responsibility.
  438.  */
  439. struct mtd_info *mtd_concat_create(
  440. struct mtd_info *subdev[], /* subdevices to concatenate */
  441. int num_devs, /* number of subdevices      */
  442. char *name) /* name for the new device   */
  443. {
  444. int i;
  445. size_t size;
  446. struct mtd_concat *concat;
  447. u_int32_t max_erasesize, curr_erasesize;
  448. int num_erase_region;
  450. printk(KERN_NOTICE "Concatenating MTD devices:n");
  451. for(i = 0; i < num_devs; i++)
  452. printk(KERN_NOTICE "(%d): "%s"n", i, subdev[i]->name);
  453. printk(KERN_NOTICE "into device "%s"n", name);
  455. /* allocate the device structure */
  456. size = SIZEOF_STRUCT_MTD_CONCAT(num_devs);
  457. concat = kmalloc (size, GFP_KERNEL);
  458. if(!concat)
  459. {
  460. printk ("memory allocation error while creating concatenated device "%s"n",
  461. name);
  462. return NULL;
  463. }
  464. memset(concat, 0, size);
  465. concat->subdev = (struct mtd_info **)(concat + 1);
  467. /*
  468.  * Set up the new "super" device's MTD object structure, check for
  469.  * incompatibilites between the subdevices.
  470.  */
  471. concat->mtd.type      = subdev[0]->type;
  472. concat->mtd.flags     = subdev[0]->flags;
  473. concat->mtd.size      = subdev[0]->size;
  474. concat->mtd.erasesize = subdev[0]->erasesize;
  475. concat->mtd.oobblock  = subdev[0]->oobblock;
  476. concat->mtd.oobsize   = subdev[0]->oobsize;
  477. concat->mtd.ecctype   = subdev[0]->ecctype;
  478. concat->mtd.eccsize   = subdev[0]->eccsize;
  480. concat->subdev[0]   = subdev[0];
  482. for(i = 1; i < num_devs; i++)
  483. {
  484. if(concat->mtd.type != subdev[i]->type)
  485. {
  486. kfree(concat);
  487. printk ("Incompatible device type on "%s"n", subdev[i]->name);
  488. return NULL;
  489. }
  490. if(concat->mtd.flags != subdev[i]->flags)
  491. { /*
  492.  * Expect all flags except MTD_WRITEABLE to be equal on
  493.  * all subdevices.
  494.  */
  495. if((concat->mtd.flags ^ subdev[i]->flags) & ~MTD_WRITEABLE)
  496. {
  497. kfree(concat);
  498. printk ("Incompatible device flags on "%s"n", subdev[i]->name);
  499. return NULL;
  500. }
  501. else /* if writeable attribute differs, make super device writeable */
  502. concat->mtd.flags |= subdev[i]->flags & MTD_WRITEABLE;
  503. }
  504. concat->mtd.size += subdev[i]->size;
  505. if(concat->mtd.oobblock != subdev[i]->oobblock ||
  506.    concat->mtd.oobsize  != subdev[i]->oobsize  ||
  507.    concat->mtd.ecctype  != subdev[i]->ecctype  ||
  508.    concat->mtd.eccsize  != subdev[i]->eccsize)
  509. {
  510. kfree(concat);
  511. printk ("Incompatible OOB or ECC data on "%s"n", subdev[i]->name);
  512. return NULL;
  513. }
  514. concat->subdev[i] = subdev[i];
  516. }
  518. concat->num_subdev  = num_devs;
  519. concat->mtd.name    = name;
  521. /*
  522.  * NOTE: for now, we do not provide any readv()/writev() methods
  523.  *       because they are messy to implement and they are not
  524.  *       used to a great extent anyway.
  525.  */
  526. concat->mtd.erase   = concat_erase;
  527. concat->mtd.read    = concat_read;
  528. concat->mtd.write   = concat_write;
  529. concat->mtd.sync    = concat_sync;
  530. concat->mtd.lock    = concat_lock;
  531. concat->mtd.unlock  = concat_unlock;
  532. concat->mtd.suspend = concat_suspend;
  533. concat->mtd.resume  = concat_resume;
  536. /*
  537.  * Combine the erase block size info of the subdevices:
  538.  *
  539.  * first, walk the map of the new device and see how
  540.  * many changes in erase size we have
  541.  */
  542. max_erasesize = curr_erasesize = subdev[0]->erasesize;
  543. num_erase_region = 1;
  544. for(i = 0; i < num_devs; i++)
  545. {
  546. if(subdev[i]->numeraseregions == 0)
  547. { /* current subdevice has uniform erase size */
  548. if(subdev[i]->erasesize != curr_erasesize)
  549. { /* if it differs from the last subdevice's erase size, count it */
  550. ++num_erase_region;
  551. curr_erasesize = subdev[i]->erasesize;
  552. if(curr_erasesize > max_erasesize)
  553. max_erasesize = curr_erasesize;
  554. }
  555. }
  556. else
  557. { /* current subdevice has variable erase size */
  558. int j;
  559. for(j = 0; j < subdev[i]->numeraseregions; j++)
  560. { /* walk the list of erase regions, count any changes */
  561. if(subdev[i]->eraseregions[j].erasesize != curr_erasesize)
  562. {
  563. ++num_erase_region;
  564. curr_erasesize = subdev[i]->eraseregions[j].erasesize;
  565. if(curr_erasesize > max_erasesize)
  566. max_erasesize = curr_erasesize;
  567. }
  568. }
  569. }
  570. }
  572. if(num_erase_region == 1)
  573. { /*
  574.  * All subdevices have the same uniform erase size.
  575.  * This is easy:
  576.  */
  577. concat->mtd.erasesize = curr_erasesize;
  578. concat->mtd.numeraseregions = 0;
  579. }
  580. else
  581. { /*
  582.  * erase block size varies across the subdevices: allocate
  583.  * space to store the data describing the variable erase regions
  584.  */
  585. struct mtd_erase_region_info *erase_region_p;
  586. u_int32_t begin, position;
  588. concat->mtd.erasesize = max_erasesize;
  589. concat->mtd.numeraseregions = num_erase_region;
  590. concat->mtd.eraseregions = erase_region_p = kmalloc (
  591.      num_erase_region * sizeof(struct mtd_erase_region_info), GFP_KERNEL);
  592. if(!erase_region_p)
  593. {
  594. kfree(concat);
  595. printk ("memory allocation error while creating erase region list"
  596.         " for device "%s"n", name);
  597. return NULL;
  598. }
  600. /*
  601.  * walk the map of the new device once more and fill in
  602.  * in erase region info:
  603.  */
  604. curr_erasesize = subdev[0]->erasesize;
  605. begin = position = 0;
  606. for(i = 0; i < num_devs; i++)
  607. {
  608. if(subdev[i]->numeraseregions == 0)
  609. { /* current subdevice has uniform erase size */
  610. if(subdev[i]->erasesize != curr_erasesize)
  611. { /*
  612.  *  fill in an mtd_erase_region_info structure for the area
  613.  *  we have walked so far:
  614.  */
  615. erase_region_p->offset    = begin;
  616. erase_region_p->erasesize = curr_erasesize;
  617. erase_region_p->numblocks = (position - begin) / curr_erasesize;
  618. begin = position;
  620. curr_erasesize = subdev[i]->erasesize;
  621. ++erase_region_p;
  622. }
  623. position += subdev[i]->size;
  624. }
  625. else
  626. { /* current subdevice has variable erase size */
  627. int j;
  628. for(j = 0; j < subdev[i]->numeraseregions; j++)
  629. { /* walk the list of erase regions, count any changes */
  630. if(subdev[i]->eraseregions[j].erasesize != curr_erasesize)
  631. {
  632. erase_region_p->offset    = begin;
  633. erase_region_p->erasesize = curr_erasesize;
  634. erase_region_p->numblocks = (position - begin) / curr_erasesize;
  635. begin = position;
  637. curr_erasesize = subdev[i]->eraseregions[j].erasesize;
  638. ++erase_region_p;
  639. }
  640. position += subdev[i]->eraseregions[j].numblocks * curr_erasesize;
  641. }
  642. }
  643. }
  644. /* Now write the final entry */
  645. erase_region_p->offset    = begin;
  646. erase_region_p->erasesize = curr_erasesize;
  647. erase_region_p->numblocks = (position - begin) / curr_erasesize;
  648. }
  650. return &concat->mtd;
  651. }
  653. /* 
  654.  * This function destroys an MTD object obtained from concat_mtd_devs()
  655.  */
  657. void mtd_concat_destroy(struct mtd_info *mtd)
  658. {
  659. struct mtd_concat *concat = CONCAT(mtd);
  660. if(concat->mtd.numeraseregions)
  661. kfree(concat->mtd.eraseregions);
  662. kfree(concat);
  663. }
  666. EXPORT_SYMBOL(mtd_concat_create);
  667. EXPORT_SYMBOL(mtd_concat_destroy);
  670. MODULE_LICENSE("GPL");
  671. MODULE_AUTHOR("Robert Kaiser <rkaiser@sysgo.de>");
  672. MODULE_DESCRIPTION("Generic support for concatenating of MTD devices");