|
1 /* |
|
2 * Copyright (C) 1999-2003 David Woodhouse <dwmw2@infradead.org> et al. |
|
3 * |
|
4 * Released under GPL |
|
5 */ |
|
6 |
|
7 #ifndef __MTD_MTD_H__ |
|
8 #define __MTD_MTD_H__ |
|
9 |
|
10 #include <linux/types.h> |
|
11 #include <linux/module.h> |
|
12 #include <linux/uio.h> |
|
13 #include <linux/notifier.h> |
|
14 |
|
15 #include <linux/mtd/compatmac.h> |
|
16 #include <mtd/mtd-abi.h> |
|
17 |
|
18 #define MTD_CHAR_MAJOR 90 |
|
19 #define MTD_BLOCK_MAJOR 31 |
|
20 #define MAX_MTD_DEVICES 32 |
|
21 |
|
22 #define MTD_ERASE_PENDING 0x01 |
|
23 #define MTD_ERASING 0x02 |
|
24 #define MTD_ERASE_SUSPEND 0x04 |
|
25 #define MTD_ERASE_DONE 0x08 |
|
26 #define MTD_ERASE_FAILED 0x10 |
|
27 |
|
28 #define MTD_FAIL_ADDR_UNKNOWN 0xffffffff |
|
29 |
|
30 /* If the erase fails, fail_addr might indicate exactly which block failed. If |
|
31 fail_addr = MTD_FAIL_ADDR_UNKNOWN, the failure was not at the device level or was not |
|
32 specific to any particular block. */ |
|
33 struct erase_info { |
|
34 struct mtd_info *mtd; |
|
35 u_int32_t addr; |
|
36 u_int32_t len; |
|
37 u_int32_t fail_addr; |
|
38 u_long time; |
|
39 u_long retries; |
|
40 u_int dev; |
|
41 u_int cell; |
|
42 void (*callback) (struct erase_info *self); |
|
43 u_long priv; |
|
44 u_char state; |
|
45 struct erase_info *next; |
|
46 }; |
|
47 |
|
48 struct mtd_erase_region_info { |
|
49 u_int32_t offset; /* At which this region starts, from the beginning of the MTD */ |
|
50 u_int32_t erasesize; /* For this region */ |
|
51 u_int32_t numblocks; /* Number of blocks of erasesize in this region */ |
|
52 unsigned long *lockmap; /* If keeping bitmap of locks */ |
|
53 }; |
|
54 |
|
55 /* |
|
56 * oob operation modes |
|
57 * |
|
58 * MTD_OOB_PLACE: oob data are placed at the given offset |
|
59 * MTD_OOB_AUTO: oob data are automatically placed at the free areas |
|
60 * which are defined by the ecclayout |
|
61 * MTD_OOB_RAW: mode to read raw data+oob in one chunk. The oob data |
|
62 * is inserted into the data. Thats a raw image of the |
|
63 * flash contents. |
|
64 */ |
|
65 typedef enum { |
|
66 MTD_OOB_PLACE, |
|
67 MTD_OOB_AUTO, |
|
68 MTD_OOB_RAW, |
|
69 } mtd_oob_mode_t; |
|
70 |
|
71 /** |
|
72 * struct mtd_oob_ops - oob operation operands |
|
73 * @mode: operation mode |
|
74 * |
|
75 * @len: number of data bytes to write/read |
|
76 * |
|
77 * @retlen: number of data bytes written/read |
|
78 * |
|
79 * @ooblen: number of oob bytes to write/read |
|
80 * @oobretlen: number of oob bytes written/read |
|
81 * @ooboffs: offset of oob data in the oob area (only relevant when |
|
82 * mode = MTD_OOB_PLACE) |
|
83 * @datbuf: data buffer - if NULL only oob data are read/written |
|
84 * @oobbuf: oob data buffer |
|
85 * |
|
86 * Note, it is allowed to read more then one OOB area at one go, but not write. |
|
87 * The interface assumes that the OOB write requests program only one page's |
|
88 * OOB area. |
|
89 */ |
|
90 struct mtd_oob_ops { |
|
91 mtd_oob_mode_t mode; |
|
92 size_t len; |
|
93 size_t retlen; |
|
94 size_t ooblen; |
|
95 size_t oobretlen; |
|
96 uint32_t ooboffs; |
|
97 uint8_t *datbuf; |
|
98 uint8_t *oobbuf; |
|
99 }; |
|
100 |
|
101 struct mtd_info { |
|
102 u_char type; |
|
103 u_int32_t flags; |
|
104 u_int32_t size; // Total size of the MTD |
|
105 |
|
106 /* "Major" erase size for the device. Naïve users may take this |
|
107 * to be the only erase size available, or may use the more detailed |
|
108 * information below if they desire |
|
109 */ |
|
110 u_int32_t erasesize; |
|
111 /* Minimal writable flash unit size. In case of NOR flash it is 1 (even |
|
112 * though individual bits can be cleared), in case of NAND flash it is |
|
113 * one NAND page (or half, or one-fourths of it), in case of ECC-ed NOR |
|
114 * it is of ECC block size, etc. It is illegal to have writesize = 0. |
|
115 * Any driver registering a struct mtd_info must ensure a writesize of |
|
116 * 1 or larger. |
|
117 */ |
|
118 u_int32_t writesize; |
|
119 |
|
120 u_int32_t oobsize; // Amount of OOB data per block (e.g. 16) |
|
121 u_int32_t oobavail; // Available OOB bytes per block |
|
122 |
|
123 // Kernel-only stuff starts here. |
|
124 const char *name; |
|
125 int index; |
|
126 |
|
127 /* ecc layout structure pointer - read only ! */ |
|
128 struct nand_ecclayout *ecclayout; |
|
129 |
|
130 /* Data for variable erase regions. If numeraseregions is zero, |
|
131 * it means that the whole device has erasesize as given above. |
|
132 */ |
|
133 int numeraseregions; |
|
134 struct mtd_erase_region_info *eraseregions; |
|
135 |
|
136 /* |
|
137 * Erase is an asynchronous operation. Device drivers are supposed |
|
138 * to call instr->callback() whenever the operation completes, even |
|
139 * if it completes with a failure. |
|
140 * Callers are supposed to pass a callback function and wait for it |
|
141 * to be called before writing to the block. |
|
142 */ |
|
143 int (*erase) (struct mtd_info *mtd, struct erase_info *instr); |
|
144 |
|
145 /* This stuff for eXecute-In-Place */ |
|
146 /* phys is optional and may be set to NULL */ |
|
147 int (*point) (struct mtd_info *mtd, loff_t from, size_t len, |
|
148 size_t *retlen, void **virt, resource_size_t *phys); |
|
149 |
|
150 /* We probably shouldn't allow XIP if the unpoint isn't a NULL */ |
|
151 void (*unpoint) (struct mtd_info *mtd, loff_t from, size_t len); |
|
152 |
|
153 |
|
154 int (*read) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf); |
|
155 int (*write) (struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf); |
|
156 |
|
157 /* In blackbox flight recorder like scenarios we want to make successful |
|
158 writes in interrupt context. panic_write() is only intended to be |
|
159 called when its known the kernel is about to panic and we need the |
|
160 write to succeed. Since the kernel is not going to be running for much |
|
161 longer, this function can break locks and delay to ensure the write |
|
162 succeeds (but not sleep). */ |
|
163 |
|
164 int (*panic_write) (struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf); |
|
165 |
|
166 int (*read_oob) (struct mtd_info *mtd, loff_t from, |
|
167 struct mtd_oob_ops *ops); |
|
168 int (*write_oob) (struct mtd_info *mtd, loff_t to, |
|
169 struct mtd_oob_ops *ops); |
|
170 |
|
171 /* |
|
172 * Methods to access the protection register area, present in some |
|
173 * flash devices. The user data is one time programmable but the |
|
174 * factory data is read only. |
|
175 */ |
|
176 int (*get_fact_prot_info) (struct mtd_info *mtd, struct otp_info *buf, size_t len); |
|
177 int (*read_fact_prot_reg) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf); |
|
178 int (*get_user_prot_info) (struct mtd_info *mtd, struct otp_info *buf, size_t len); |
|
179 int (*read_user_prot_reg) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf); |
|
180 int (*write_user_prot_reg) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf); |
|
181 int (*lock_user_prot_reg) (struct mtd_info *mtd, loff_t from, size_t len); |
|
182 |
|
183 /* kvec-based read/write methods. |
|
184 NB: The 'count' parameter is the number of _vectors_, each of |
|
185 which contains an (ofs, len) tuple. |
|
186 */ |
|
187 int (*writev) (struct mtd_info *mtd, const struct kvec *vecs, unsigned long count, loff_t to, size_t *retlen); |
|
188 |
|
189 /* Sync */ |
|
190 void (*sync) (struct mtd_info *mtd); |
|
191 |
|
192 /* Chip-supported device locking */ |
|
193 int (*lock) (struct mtd_info *mtd, loff_t ofs, size_t len); |
|
194 int (*unlock) (struct mtd_info *mtd, loff_t ofs, size_t len); |
|
195 |
|
196 /* Power Management functions */ |
|
197 int (*suspend) (struct mtd_info *mtd); |
|
198 void (*resume) (struct mtd_info *mtd); |
|
199 |
|
200 /* Bad block management functions */ |
|
201 int (*block_isbad) (struct mtd_info *mtd, loff_t ofs); |
|
202 int (*block_markbad) (struct mtd_info *mtd, loff_t ofs); |
|
203 |
|
204 struct notifier_block reboot_notifier; /* default mode before reboot */ |
|
205 |
|
206 /* ECC status information */ |
|
207 struct mtd_ecc_stats ecc_stats; |
|
208 /* Subpage shift (NAND) */ |
|
209 int subpage_sft; |
|
210 |
|
211 void *priv; |
|
212 |
|
213 struct module *owner; |
|
214 int usecount; |
|
215 |
|
216 /* If the driver is something smart, like UBI, it may need to maintain |
|
217 * its own reference counting. The below functions are only for driver. |
|
218 * The driver may register its callbacks. These callbacks are not |
|
219 * supposed to be called by MTD users */ |
|
220 int (*get_device) (struct mtd_info *mtd); |
|
221 void (*put_device) (struct mtd_info *mtd); |
|
222 }; |
|
223 |
|
224 |
|
225 /* Kernel-side ioctl definitions */ |
|
226 |
|
227 extern int add_mtd_device(struct mtd_info *mtd); |
|
228 extern int del_mtd_device (struct mtd_info *mtd); |
|
229 |
|
230 extern struct mtd_info *get_mtd_device(struct mtd_info *mtd, int num); |
|
231 extern struct mtd_info *get_mtd_device_nm(const char *name); |
|
232 |
|
233 extern void put_mtd_device(struct mtd_info *mtd); |
|
234 |
|
235 |
|
236 struct mtd_notifier { |
|
237 void (*add)(struct mtd_info *mtd); |
|
238 void (*remove)(struct mtd_info *mtd); |
|
239 struct list_head list; |
|
240 }; |
|
241 |
|
242 |
|
243 extern void register_mtd_user (struct mtd_notifier *new); |
|
244 extern int unregister_mtd_user (struct mtd_notifier *old); |
|
245 |
|
246 int default_mtd_writev(struct mtd_info *mtd, const struct kvec *vecs, |
|
247 unsigned long count, loff_t to, size_t *retlen); |
|
248 |
|
249 int default_mtd_readv(struct mtd_info *mtd, struct kvec *vecs, |
|
250 unsigned long count, loff_t from, size_t *retlen); |
|
251 |
|
252 #ifdef CONFIG_MTD_PARTITIONS |
|
253 void mtd_erase_callback(struct erase_info *instr); |
|
254 #else |
|
255 static inline void mtd_erase_callback(struct erase_info *instr) |
|
256 { |
|
257 if (instr->callback) |
|
258 instr->callback(instr); |
|
259 } |
|
260 #endif |
|
261 |
|
262 /* |
|
263 * Debugging macro and defines |
|
264 */ |
|
265 #define MTD_DEBUG_LEVEL0 (0) /* Quiet */ |
|
266 #define MTD_DEBUG_LEVEL1 (1) /* Audible */ |
|
267 #define MTD_DEBUG_LEVEL2 (2) /* Loud */ |
|
268 #define MTD_DEBUG_LEVEL3 (3) /* Noisy */ |
|
269 |
|
270 #ifdef CONFIG_MTD_DEBUG |
|
271 #define DEBUG(n, args...) \ |
|
272 do { \ |
|
273 if (n <= CONFIG_MTD_DEBUG_VERBOSE) \ |
|
274 printk(KERN_INFO args); \ |
|
275 } while(0) |
|
276 #else /* CONFIG_MTD_DEBUG */ |
|
277 #define DEBUG(n, args...) \ |
|
278 do { \ |
|
279 if (0) \ |
|
280 printk(KERN_INFO args); \ |
|
281 } while(0) |
|
282 |
|
283 #endif /* CONFIG_MTD_DEBUG */ |
|
284 |
|
285 #endif /* __MTD_MTD_H__ */ |