mtdram.c 4.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187
  1. /*
  2. * mtdram - a test mtd device
  3. * Author: Alexander Larsson <[email protected]>
  4. *
  5. * Copyright (c) 1999 Alexander Larsson <[email protected]>
  6. * Copyright (c) 2005 Joern Engel <[email protected]>
  7. *
  8. * This code is GPL
  9. *
  10. */
  11. #include <linux/module.h>
  12. #include <linux/slab.h>
  13. #include <linux/ioport.h>
  14. #include <linux/vmalloc.h>
  15. #include <linux/mm.h>
  16. #include <linux/init.h>
  17. #include <linux/mtd/mtd.h>
  18. #include <linux/mtd/mtdram.h>
  19. static unsigned long total_size = CONFIG_MTDRAM_TOTAL_SIZE;
  20. static unsigned long erase_size = CONFIG_MTDRAM_ERASE_SIZE;
  21. static unsigned long writebuf_size = 64;
  22. #define MTDRAM_TOTAL_SIZE (total_size * 1024)
  23. #define MTDRAM_ERASE_SIZE (erase_size * 1024)
  24. module_param(total_size, ulong, 0);
  25. MODULE_PARM_DESC(total_size, "Total device size in KiB");
  26. module_param(erase_size, ulong, 0);
  27. MODULE_PARM_DESC(erase_size, "Device erase block size in KiB");
  28. module_param(writebuf_size, ulong, 0);
  29. MODULE_PARM_DESC(writebuf_size, "Device write buf size in Bytes (Default: 64)");
  30. // We could store these in the mtd structure, but we only support 1 device..
  31. static struct mtd_info *mtd_info;
  32. static int check_offs_len(struct mtd_info *mtd, loff_t ofs, uint64_t len)
  33. {
  34. int ret = 0;
  35. /* Start address must align on block boundary */
  36. if (mtd_mod_by_eb(ofs, mtd)) {
  37. pr_debug("%s: unaligned address\n", __func__);
  38. ret = -EINVAL;
  39. }
  40. /* Length must align on block boundary */
  41. if (mtd_mod_by_eb(len, mtd)) {
  42. pr_debug("%s: length not block aligned\n", __func__);
  43. ret = -EINVAL;
  44. }
  45. return ret;
  46. }
  47. static int ram_erase(struct mtd_info *mtd, struct erase_info *instr)
  48. {
  49. if (check_offs_len(mtd, instr->addr, instr->len))
  50. return -EINVAL;
  51. memset((char *)mtd->priv + instr->addr, 0xff, instr->len);
  52. return 0;
  53. }
  54. static int ram_point(struct mtd_info *mtd, loff_t from, size_t len,
  55. size_t *retlen, void **virt, resource_size_t *phys)
  56. {
  57. *virt = mtd->priv + from;
  58. *retlen = len;
  59. if (phys) {
  60. /* limit retlen to the number of contiguous physical pages */
  61. unsigned long page_ofs = offset_in_page(*virt);
  62. void *addr = *virt - page_ofs;
  63. unsigned long pfn1, pfn0 = vmalloc_to_pfn(addr);
  64. *phys = __pfn_to_phys(pfn0) + page_ofs;
  65. len += page_ofs;
  66. while (len > PAGE_SIZE) {
  67. len -= PAGE_SIZE;
  68. addr += PAGE_SIZE;
  69. pfn0++;
  70. pfn1 = vmalloc_to_pfn(addr);
  71. if (pfn1 != pfn0) {
  72. *retlen = addr - *virt;
  73. break;
  74. }
  75. }
  76. }
  77. return 0;
  78. }
  79. static int ram_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
  80. {
  81. return 0;
  82. }
  83. static int ram_read(struct mtd_info *mtd, loff_t from, size_t len,
  84. size_t *retlen, u_char *buf)
  85. {
  86. memcpy(buf, mtd->priv + from, len);
  87. *retlen = len;
  88. return 0;
  89. }
  90. static int ram_write(struct mtd_info *mtd, loff_t to, size_t len,
  91. size_t *retlen, const u_char *buf)
  92. {
  93. memcpy((char *)mtd->priv + to, buf, len);
  94. *retlen = len;
  95. return 0;
  96. }
  97. static void __exit cleanup_mtdram(void)
  98. {
  99. if (mtd_info) {
  100. mtd_device_unregister(mtd_info);
  101. vfree(mtd_info->priv);
  102. kfree(mtd_info);
  103. }
  104. }
  105. int mtdram_init_device(struct mtd_info *mtd, void *mapped_address,
  106. unsigned long size, const char *name)
  107. {
  108. memset(mtd, 0, sizeof(*mtd));
  109. /* Setup the MTD structure */
  110. mtd->name = name;
  111. mtd->type = MTD_RAM;
  112. mtd->flags = MTD_CAP_RAM;
  113. mtd->size = size;
  114. mtd->writesize = 1;
  115. mtd->writebufsize = writebuf_size;
  116. mtd->erasesize = MTDRAM_ERASE_SIZE;
  117. mtd->priv = mapped_address;
  118. mtd->owner = THIS_MODULE;
  119. mtd->_erase = ram_erase;
  120. mtd->_point = ram_point;
  121. mtd->_unpoint = ram_unpoint;
  122. mtd->_read = ram_read;
  123. mtd->_write = ram_write;
  124. if (mtd_device_register(mtd, NULL, 0))
  125. return -EIO;
  126. return 0;
  127. }
  128. static int __init init_mtdram(void)
  129. {
  130. void *addr;
  131. int err;
  132. if (!total_size)
  133. return -EINVAL;
  134. /* Allocate some memory */
  135. mtd_info = kmalloc(sizeof(struct mtd_info), GFP_KERNEL);
  136. if (!mtd_info)
  137. return -ENOMEM;
  138. addr = vmalloc(MTDRAM_TOTAL_SIZE);
  139. if (!addr) {
  140. kfree(mtd_info);
  141. mtd_info = NULL;
  142. return -ENOMEM;
  143. }
  144. err = mtdram_init_device(mtd_info, addr, MTDRAM_TOTAL_SIZE, "mtdram test device");
  145. if (err) {
  146. vfree(addr);
  147. kfree(mtd_info);
  148. mtd_info = NULL;
  149. return err;
  150. }
  151. memset(mtd_info->priv, 0xff, MTDRAM_TOTAL_SIZE);
  152. return err;
  153. }
  154. module_init(init_mtdram);
  155. module_exit(cleanup_mtdram);
  156. MODULE_LICENSE("GPL");
  157. MODULE_AUTHOR("Alexander Larsson <[email protected]>");
  158. MODULE_DESCRIPTION("Simulated MTD driver for testing");