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