blob: 763d3f0a1f428104d7a630de7746a09bc9883bb9 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * Character-device access to raw MTD devices.
3 *
4 */
5
Thomas Gleixner15fdc522005-11-07 00:14:42 +01006#include <linux/device.h>
7#include <linux/fs.h>
Andrew Morton0c1eafd2007-08-10 13:01:06 -07008#include <linux/mm.h>
Artem Bityutskiy9c740342006-10-11 14:52:47 +03009#include <linux/err.h>
Thomas Gleixner15fdc522005-11-07 00:14:42 +010010#include <linux/init.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070011#include <linux/kernel.h>
12#include <linux/module.h>
Thomas Gleixner15fdc522005-11-07 00:14:42 +010013#include <linux/slab.h>
14#include <linux/sched.h>
Jonathan Corbet60712392008-05-15 10:10:37 -060015#include <linux/smp_lock.h>
David Howells402d3262009-02-12 10:40:00 +000016#include <linux/backing-dev.h>
Thomas Gleixner15fdc522005-11-07 00:14:42 +010017
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/mtd/mtd.h>
19#include <linux/mtd/compatmac.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020
Thomas Gleixner15fdc522005-11-07 00:14:42 +010021#include <asm/uaccess.h>
Todd Poynor9bc7b382005-06-30 01:23:27 +010022
Linus Torvalds1da177e2005-04-16 15:20:36 -070023
Nicolas Pitre045e9a52005-02-08 19:12:53 +000024/*
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +020025 * Data structure to hold the pointer to the mtd device as well
26 * as mode information ofr various use cases.
Nicolas Pitre045e9a52005-02-08 19:12:53 +000027 */
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +020028struct mtd_file_info {
29 struct mtd_info *mtd;
30 enum mtd_file_modes mode;
31};
Nicolas Pitre31f42332005-02-08 17:45:55 +000032
Linus Torvalds1da177e2005-04-16 15:20:36 -070033static loff_t mtd_lseek (struct file *file, loff_t offset, int orig)
34{
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +020035 struct mtd_file_info *mfi = file->private_data;
36 struct mtd_info *mtd = mfi->mtd;
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
38 switch (orig) {
Josef 'Jeff' Sipekea598302006-09-16 21:09:29 -040039 case SEEK_SET:
Linus Torvalds1da177e2005-04-16 15:20:36 -070040 break;
Josef 'Jeff' Sipekea598302006-09-16 21:09:29 -040041 case SEEK_CUR:
Todd Poynor8b491d72005-08-04 02:05:51 +010042 offset += file->f_pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -070043 break;
Josef 'Jeff' Sipekea598302006-09-16 21:09:29 -040044 case SEEK_END:
Todd Poynor8b491d72005-08-04 02:05:51 +010045 offset += mtd->size;
Linus Torvalds1da177e2005-04-16 15:20:36 -070046 break;
47 default:
48 return -EINVAL;
49 }
50
Herbert Valerio Riedel1887f512006-06-24 00:03:36 +020051 if (offset >= 0 && offset <= mtd->size)
Todd Poynor8b491d72005-08-04 02:05:51 +010052 return file->f_pos = offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
Todd Poynor8b491d72005-08-04 02:05:51 +010054 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -070055}
56
57
58
59static int mtd_open(struct inode *inode, struct file *file)
60{
61 int minor = iminor(inode);
62 int devnum = minor >> 1;
Jonathan Corbet60712392008-05-15 10:10:37 -060063 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070064 struct mtd_info *mtd;
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +020065 struct mtd_file_info *mfi;
Linus Torvalds1da177e2005-04-16 15:20:36 -070066
67 DEBUG(MTD_DEBUG_LEVEL0, "MTD_open\n");
68
69 if (devnum >= MAX_MTD_DEVICES)
70 return -ENODEV;
71
72 /* You can't open the RO devices RW */
Al Viroaeb5d722008-09-02 15:28:45 -040073 if ((file->f_mode & FMODE_WRITE) && (minor & 1))
Linus Torvalds1da177e2005-04-16 15:20:36 -070074 return -EACCES;
75
Jonathan Corbet60712392008-05-15 10:10:37 -060076 lock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -070077 mtd = get_mtd_device(NULL, devnum);
Thomas Gleixner97894cd2005-11-07 11:15:26 +000078
Jonathan Corbet60712392008-05-15 10:10:37 -060079 if (IS_ERR(mtd)) {
80 ret = PTR_ERR(mtd);
81 goto out;
82 }
Thomas Gleixner97894cd2005-11-07 11:15:26 +000083
David Howells402d3262009-02-12 10:40:00 +000084 if (mtd->type == MTD_ABSENT) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070085 put_mtd_device(mtd);
Jonathan Corbet60712392008-05-15 10:10:37 -060086 ret = -ENODEV;
87 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 }
89
David Howells402d3262009-02-12 10:40:00 +000090 if (mtd->backing_dev_info)
91 file->f_mapping->backing_dev_info = mtd->backing_dev_info;
92
Linus Torvalds1da177e2005-04-16 15:20:36 -070093 /* You can't open it RW if it's not a writeable device */
Al Viroaeb5d722008-09-02 15:28:45 -040094 if ((file->f_mode & FMODE_WRITE) && !(mtd->flags & MTD_WRITEABLE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 put_mtd_device(mtd);
Jonathan Corbet60712392008-05-15 10:10:37 -060096 ret = -EACCES;
97 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 }
Thomas Gleixner97894cd2005-11-07 11:15:26 +000099
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200100 mfi = kzalloc(sizeof(*mfi), GFP_KERNEL);
101 if (!mfi) {
102 put_mtd_device(mtd);
Jonathan Corbet60712392008-05-15 10:10:37 -0600103 ret = -ENOMEM;
104 goto out;
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200105 }
106 mfi->mtd = mtd;
107 file->private_data = mfi;
108
Jonathan Corbet60712392008-05-15 10:10:37 -0600109out:
110 unlock_kernel();
111 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112} /* mtd_open */
113
114/*====================================================================*/
115
116static int mtd_close(struct inode *inode, struct file *file)
117{
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200118 struct mtd_file_info *mfi = file->private_data;
119 struct mtd_info *mtd = mfi->mtd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120
121 DEBUG(MTD_DEBUG_LEVEL0, "MTD_close\n");
122
Joakim Tjernlund7eafaed2007-06-27 00:56:40 +0200123 /* Only sync if opened RW */
Al Viroaeb5d722008-09-02 15:28:45 -0400124 if ((file->f_mode & FMODE_WRITE) && mtd->sync)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 mtd->sync(mtd);
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000126
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 put_mtd_device(mtd);
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200128 file->private_data = NULL;
129 kfree(mfi);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130
131 return 0;
132} /* mtd_close */
133
134/* FIXME: This _really_ needs to die. In 2.5, we should lock the
135 userspace buffer down and use it directly with readv/writev.
136*/
137#define MAX_KMALLOC_SIZE 0x20000
138
139static ssize_t mtd_read(struct file *file, char __user *buf, size_t count,loff_t *ppos)
140{
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200141 struct mtd_file_info *mfi = file->private_data;
142 struct mtd_info *mtd = mfi->mtd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 size_t retlen=0;
144 size_t total_retlen=0;
145 int ret=0;
146 int len;
147 char *kbuf;
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000148
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 DEBUG(MTD_DEBUG_LEVEL0,"MTD_read\n");
150
151 if (*ppos + count > mtd->size)
152 count = mtd->size - *ppos;
153
154 if (!count)
155 return 0;
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000156
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 /* FIXME: Use kiovec in 2.5 to lock down the user's buffers
158 and pass them directly to the MTD functions */
Thago Galesib802c072006-04-17 17:38:15 +0100159
160 if (count > MAX_KMALLOC_SIZE)
161 kbuf=kmalloc(MAX_KMALLOC_SIZE, GFP_KERNEL);
162 else
163 kbuf=kmalloc(count, GFP_KERNEL);
164
165 if (!kbuf)
166 return -ENOMEM;
167
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 while (count) {
Thago Galesib802c072006-04-17 17:38:15 +0100169
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000170 if (count > MAX_KMALLOC_SIZE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 len = MAX_KMALLOC_SIZE;
172 else
173 len = count;
174
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200175 switch (mfi->mode) {
176 case MTD_MODE_OTP_FACTORY:
Nicolas Pitre31f42332005-02-08 17:45:55 +0000177 ret = mtd->read_fact_prot_reg(mtd, *ppos, len, &retlen, kbuf);
178 break;
179 case MTD_MODE_OTP_USER:
180 ret = mtd->read_user_prot_reg(mtd, *ppos, len, &retlen, kbuf);
181 break;
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200182 case MTD_MODE_RAW:
183 {
184 struct mtd_oob_ops ops;
185
186 ops.mode = MTD_OOB_RAW;
187 ops.datbuf = kbuf;
188 ops.oobbuf = NULL;
189 ops.len = len;
190
191 ret = mtd->read_oob(mtd, *ppos, &ops);
192 retlen = ops.retlen;
193 break;
194 }
Nicolas Pitre31f42332005-02-08 17:45:55 +0000195 default:
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200196 ret = mtd->read(mtd, *ppos, len, &retlen, kbuf);
Nicolas Pitre31f42332005-02-08 17:45:55 +0000197 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 /* Nand returns -EBADMSG on ecc errors, but it returns
199 * the data. For our userspace tools it is important
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000200 * to dump areas with ecc errors !
Thomas Gleixner9a1fcdf2006-05-29 14:56:39 +0200201 * For kernel internal usage it also might return -EUCLEAN
202 * to signal the caller that a bitflip has occured and has
203 * been corrected by the ECC algorithm.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 * Userspace software which accesses NAND this way
205 * must be aware of the fact that it deals with NAND
206 */
Thomas Gleixner9a1fcdf2006-05-29 14:56:39 +0200207 if (!ret || (ret == -EUCLEAN) || (ret == -EBADMSG)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 *ppos += retlen;
209 if (copy_to_user(buf, kbuf, retlen)) {
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200210 kfree(kbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 return -EFAULT;
212 }
213 else
214 total_retlen += retlen;
215
216 count -= retlen;
217 buf += retlen;
Nicolas Pitre31f42332005-02-08 17:45:55 +0000218 if (retlen == 0)
219 count = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 }
221 else {
222 kfree(kbuf);
223 return ret;
224 }
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000225
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 }
227
Thago Galesib802c072006-04-17 17:38:15 +0100228 kfree(kbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 return total_retlen;
230} /* mtd_read */
231
232static ssize_t mtd_write(struct file *file, const char __user *buf, size_t count,loff_t *ppos)
233{
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200234 struct mtd_file_info *mfi = file->private_data;
235 struct mtd_info *mtd = mfi->mtd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 char *kbuf;
237 size_t retlen;
238 size_t total_retlen=0;
239 int ret=0;
240 int len;
241
242 DEBUG(MTD_DEBUG_LEVEL0,"MTD_write\n");
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000243
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 if (*ppos == mtd->size)
245 return -ENOSPC;
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000246
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 if (*ppos + count > mtd->size)
248 count = mtd->size - *ppos;
249
250 if (!count)
251 return 0;
252
Thago Galesib802c072006-04-17 17:38:15 +0100253 if (count > MAX_KMALLOC_SIZE)
254 kbuf=kmalloc(MAX_KMALLOC_SIZE, GFP_KERNEL);
255 else
256 kbuf=kmalloc(count, GFP_KERNEL);
257
258 if (!kbuf)
259 return -ENOMEM;
260
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 while (count) {
Thago Galesib802c072006-04-17 17:38:15 +0100262
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000263 if (count > MAX_KMALLOC_SIZE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 len = MAX_KMALLOC_SIZE;
265 else
266 len = count;
267
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 if (copy_from_user(kbuf, buf, len)) {
269 kfree(kbuf);
270 return -EFAULT;
271 }
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000272
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200273 switch (mfi->mode) {
274 case MTD_MODE_OTP_FACTORY:
Nicolas Pitre31f42332005-02-08 17:45:55 +0000275 ret = -EROFS;
276 break;
277 case MTD_MODE_OTP_USER:
278 if (!mtd->write_user_prot_reg) {
279 ret = -EOPNOTSUPP;
280 break;
281 }
282 ret = mtd->write_user_prot_reg(mtd, *ppos, len, &retlen, kbuf);
283 break;
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200284
285 case MTD_MODE_RAW:
286 {
287 struct mtd_oob_ops ops;
288
289 ops.mode = MTD_OOB_RAW;
290 ops.datbuf = kbuf;
291 ops.oobbuf = NULL;
292 ops.len = len;
293
294 ret = mtd->write_oob(mtd, *ppos, &ops);
295 retlen = ops.retlen;
296 break;
297 }
298
Nicolas Pitre31f42332005-02-08 17:45:55 +0000299 default:
300 ret = (*(mtd->write))(mtd, *ppos, len, &retlen, kbuf);
301 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 if (!ret) {
303 *ppos += retlen;
304 total_retlen += retlen;
305 count -= retlen;
306 buf += retlen;
307 }
308 else {
309 kfree(kbuf);
310 return ret;
311 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 }
313
Thago Galesib802c072006-04-17 17:38:15 +0100314 kfree(kbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 return total_retlen;
316} /* mtd_write */
317
318/*======================================================================
319
320 IOCTL calls for getting device parameters.
321
322======================================================================*/
323static void mtdchar_erase_callback (struct erase_info *instr)
324{
325 wake_up((wait_queue_head_t *)instr->priv);
326}
327
David Brownell34a82442008-07-30 12:35:05 -0700328#ifdef CONFIG_HAVE_MTD_OTP
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200329static int otp_select_filemode(struct mtd_file_info *mfi, int mode)
330{
331 struct mtd_info *mtd = mfi->mtd;
332 int ret = 0;
333
334 switch (mode) {
335 case MTD_OTP_FACTORY:
336 if (!mtd->read_fact_prot_reg)
337 ret = -EOPNOTSUPP;
338 else
339 mfi->mode = MTD_MODE_OTP_FACTORY;
340 break;
341 case MTD_OTP_USER:
342 if (!mtd->read_fact_prot_reg)
343 ret = -EOPNOTSUPP;
344 else
345 mfi->mode = MTD_MODE_OTP_USER;
346 break;
347 default:
348 ret = -EINVAL;
349 case MTD_OTP_OFF:
350 break;
351 }
352 return ret;
353}
354#else
355# define otp_select_filemode(f,m) -EOPNOTSUPP
356#endif
357
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358static int mtd_ioctl(struct inode *inode, struct file *file,
359 u_int cmd, u_long arg)
360{
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200361 struct mtd_file_info *mfi = file->private_data;
362 struct mtd_info *mtd = mfi->mtd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 void __user *argp = (void __user *)arg;
364 int ret = 0;
365 u_long size;
Joern Engel73c619e2006-05-30 14:25:35 +0200366 struct mtd_info_user info;
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000367
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 DEBUG(MTD_DEBUG_LEVEL0, "MTD_ioctl\n");
369
370 size = (cmd & IOCSIZE_MASK) >> IOCSIZE_SHIFT;
371 if (cmd & IOC_IN) {
372 if (!access_ok(VERIFY_READ, argp, size))
373 return -EFAULT;
374 }
375 if (cmd & IOC_OUT) {
376 if (!access_ok(VERIFY_WRITE, argp, size))
377 return -EFAULT;
378 }
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000379
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 switch (cmd) {
381 case MEMGETREGIONCOUNT:
382 if (copy_to_user(argp, &(mtd->numeraseregions), sizeof(int)))
383 return -EFAULT;
384 break;
385
386 case MEMGETREGIONINFO:
387 {
Zev Weissb67c5f82008-09-01 05:02:12 -0700388 uint32_t ur_idx;
389 struct mtd_erase_region_info *kr;
390 struct region_info_user *ur = (struct region_info_user *) argp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391
Zev Weissb67c5f82008-09-01 05:02:12 -0700392 if (get_user(ur_idx, &(ur->regionindex)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 return -EFAULT;
394
Zev Weissb67c5f82008-09-01 05:02:12 -0700395 kr = &(mtd->eraseregions[ur_idx]);
396
397 if (put_user(kr->offset, &(ur->offset))
398 || put_user(kr->erasesize, &(ur->erasesize))
399 || put_user(kr->numblocks, &(ur->numblocks)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 return -EFAULT;
Zev Weissb67c5f82008-09-01 05:02:12 -0700401
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 break;
403 }
404
405 case MEMGETINFO:
Joern Engel73c619e2006-05-30 14:25:35 +0200406 info.type = mtd->type;
407 info.flags = mtd->flags;
408 info.size = mtd->size;
409 info.erasesize = mtd->erasesize;
410 info.writesize = mtd->writesize;
411 info.oobsize = mtd->oobsize;
Artem Bityutskiy64f60712007-01-30 10:50:43 +0200412 /* The below fields are obsolete */
413 info.ecctype = -1;
414 info.eccsize = 0;
Joern Engel73c619e2006-05-30 14:25:35 +0200415 if (copy_to_user(argp, &info, sizeof(struct mtd_info_user)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 return -EFAULT;
417 break;
418
419 case MEMERASE:
420 {
421 struct erase_info *erase;
422
Al Viroaeb5d722008-09-02 15:28:45 -0400423 if(!(file->f_mode & FMODE_WRITE))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 return -EPERM;
425
Burman Yan95b93a02006-11-15 21:10:29 +0200426 erase=kzalloc(sizeof(struct erase_info),GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 if (!erase)
428 ret = -ENOMEM;
429 else {
Adrian Hunter69423d92008-12-10 13:37:21 +0000430 struct erase_info_user einfo;
431
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 wait_queue_head_t waitq;
433 DECLARE_WAITQUEUE(wait, current);
434
435 init_waitqueue_head(&waitq);
436
Adrian Hunter69423d92008-12-10 13:37:21 +0000437 if (copy_from_user(&einfo, argp,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 sizeof(struct erase_info_user))) {
439 kfree(erase);
440 return -EFAULT;
441 }
Adrian Hunter69423d92008-12-10 13:37:21 +0000442 erase->addr = einfo.start;
443 erase->len = einfo.length;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 erase->mtd = mtd;
445 erase->callback = mtdchar_erase_callback;
446 erase->priv = (unsigned long)&waitq;
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000447
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 /*
449 FIXME: Allow INTERRUPTIBLE. Which means
450 not having the wait_queue head on the stack.
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000451
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 If the wq_head is on the stack, and we
453 leave because we got interrupted, then the
454 wq_head is no longer there when the
455 callback routine tries to wake us up.
456 */
457 ret = mtd->erase(mtd, erase);
458 if (!ret) {
459 set_current_state(TASK_UNINTERRUPTIBLE);
460 add_wait_queue(&waitq, &wait);
461 if (erase->state != MTD_ERASE_DONE &&
462 erase->state != MTD_ERASE_FAILED)
463 schedule();
464 remove_wait_queue(&waitq, &wait);
465 set_current_state(TASK_RUNNING);
466
467 ret = (erase->state == MTD_ERASE_FAILED)?-EIO:0;
468 }
469 kfree(erase);
470 }
471 break;
472 }
473
474 case MEMWRITEOOB:
475 {
476 struct mtd_oob_buf buf;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200477 struct mtd_oob_ops ops;
Harvey Harrison5f692832008-07-03 23:40:13 -0700478 struct mtd_oob_buf __user *user_buf = argp;
David Scidmoree9d8d482007-12-11 17:44:30 -0600479 uint32_t retlen;
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000480
Al Viroaeb5d722008-09-02 15:28:45 -0400481 if(!(file->f_mode & FMODE_WRITE))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 return -EPERM;
483
484 if (copy_from_user(&buf, argp, sizeof(struct mtd_oob_buf)))
485 return -EFAULT;
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000486
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200487 if (buf.length > 4096)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 return -EINVAL;
489
490 if (!mtd->write_oob)
491 ret = -EOPNOTSUPP;
492 else
493 ret = access_ok(VERIFY_READ, buf.ptr,
494 buf.length) ? 0 : EFAULT;
495
496 if (ret)
497 return ret;
498
Thomas Gleixner7bc33122006-06-20 20:05:05 +0200499 ops.ooblen = buf.length;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200500 ops.ooboffs = buf.start & (mtd->oobsize - 1);
501 ops.datbuf = NULL;
502 ops.mode = MTD_OOB_PLACE;
503
Vitaly Wool70145682006-11-03 18:20:38 +0300504 if (ops.ooboffs && ops.ooblen > (mtd->oobsize - ops.ooboffs))
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200505 return -EINVAL;
506
507 ops.oobbuf = kmalloc(buf.length, GFP_KERNEL);
508 if (!ops.oobbuf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 return -ENOMEM;
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000510
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200511 if (copy_from_user(ops.oobbuf, buf.ptr, buf.length)) {
512 kfree(ops.oobbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 return -EFAULT;
514 }
515
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200516 buf.start &= ~(mtd->oobsize - 1);
517 ret = mtd->write_oob(mtd, buf.start, &ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518
David Scidmoree9d8d482007-12-11 17:44:30 -0600519 if (ops.oobretlen > 0xFFFFFFFFU)
520 ret = -EOVERFLOW;
521 retlen = ops.oobretlen;
Harvey Harrison5f692832008-07-03 23:40:13 -0700522 if (copy_to_user(&user_buf->length, &retlen, sizeof(buf.length)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 ret = -EFAULT;
524
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200525 kfree(ops.oobbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 break;
527
528 }
529
530 case MEMREADOOB:
531 {
532 struct mtd_oob_buf buf;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200533 struct mtd_oob_ops ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534
535 if (copy_from_user(&buf, argp, sizeof(struct mtd_oob_buf)))
536 return -EFAULT;
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000537
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200538 if (buf.length > 4096)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 return -EINVAL;
540
541 if (!mtd->read_oob)
542 ret = -EOPNOTSUPP;
543 else
544 ret = access_ok(VERIFY_WRITE, buf.ptr,
545 buf.length) ? 0 : -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 if (ret)
547 return ret;
548
Thomas Gleixner7bc33122006-06-20 20:05:05 +0200549 ops.ooblen = buf.length;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200550 ops.ooboffs = buf.start & (mtd->oobsize - 1);
551 ops.datbuf = NULL;
552 ops.mode = MTD_OOB_PLACE;
553
Thomas Gleixner408b4832007-04-13 19:50:48 +0200554 if (ops.ooboffs && ops.ooblen > (mtd->oobsize - ops.ooboffs))
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200555 return -EINVAL;
556
557 ops.oobbuf = kmalloc(buf.length, GFP_KERNEL);
558 if (!ops.oobbuf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 return -ENOMEM;
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000560
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200561 buf.start &= ~(mtd->oobsize - 1);
562 ret = mtd->read_oob(mtd, buf.start, &ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563
Vitaly Wool70145682006-11-03 18:20:38 +0300564 if (put_user(ops.oobretlen, (uint32_t __user *)argp))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 ret = -EFAULT;
Vitaly Wool70145682006-11-03 18:20:38 +0300566 else if (ops.oobretlen && copy_to_user(buf.ptr, ops.oobbuf,
567 ops.oobretlen))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 ret = -EFAULT;
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000569
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200570 kfree(ops.oobbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 break;
572 }
573
574 case MEMLOCK:
575 {
Harvey Harrison175428b2008-07-03 23:40:14 -0700576 struct erase_info_user einfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577
Harvey Harrison175428b2008-07-03 23:40:14 -0700578 if (copy_from_user(&einfo, argp, sizeof(einfo)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 return -EFAULT;
580
581 if (!mtd->lock)
582 ret = -EOPNOTSUPP;
583 else
Harvey Harrison175428b2008-07-03 23:40:14 -0700584 ret = mtd->lock(mtd, einfo.start, einfo.length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 break;
586 }
587
588 case MEMUNLOCK:
589 {
Harvey Harrison175428b2008-07-03 23:40:14 -0700590 struct erase_info_user einfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591
Harvey Harrison175428b2008-07-03 23:40:14 -0700592 if (copy_from_user(&einfo, argp, sizeof(einfo)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 return -EFAULT;
594
595 if (!mtd->unlock)
596 ret = -EOPNOTSUPP;
597 else
Harvey Harrison175428b2008-07-03 23:40:14 -0700598 ret = mtd->unlock(mtd, einfo.start, einfo.length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 break;
600 }
601
Thomas Gleixner5bd34c02006-05-27 22:16:10 +0200602 /* Legacy interface */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 case MEMGETOOBSEL:
604 {
Thomas Gleixner5bd34c02006-05-27 22:16:10 +0200605 struct nand_oobinfo oi;
606
607 if (!mtd->ecclayout)
608 return -EOPNOTSUPP;
609 if (mtd->ecclayout->eccbytes > ARRAY_SIZE(oi.eccpos))
610 return -EINVAL;
611
612 oi.useecc = MTD_NANDECC_AUTOPLACE;
613 memcpy(&oi.eccpos, mtd->ecclayout->eccpos, sizeof(oi.eccpos));
614 memcpy(&oi.oobfree, mtd->ecclayout->oobfree,
615 sizeof(oi.oobfree));
Ricard Wanderlöfd25ade72006-10-17 17:27:11 +0200616 oi.eccbytes = mtd->ecclayout->eccbytes;
Thomas Gleixner5bd34c02006-05-27 22:16:10 +0200617
618 if (copy_to_user(argp, &oi, sizeof(struct nand_oobinfo)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 return -EFAULT;
620 break;
621 }
622
623 case MEMGETBADBLOCK:
624 {
625 loff_t offs;
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000626
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 if (copy_from_user(&offs, argp, sizeof(loff_t)))
628 return -EFAULT;
629 if (!mtd->block_isbad)
630 ret = -EOPNOTSUPP;
631 else
632 return mtd->block_isbad(mtd, offs);
633 break;
634 }
635
636 case MEMSETBADBLOCK:
637 {
638 loff_t offs;
639
640 if (copy_from_user(&offs, argp, sizeof(loff_t)))
641 return -EFAULT;
642 if (!mtd->block_markbad)
643 ret = -EOPNOTSUPP;
644 else
645 return mtd->block_markbad(mtd, offs);
646 break;
647 }
648
David Brownell34a82442008-07-30 12:35:05 -0700649#ifdef CONFIG_HAVE_MTD_OTP
Nicolas Pitre31f42332005-02-08 17:45:55 +0000650 case OTPSELECT:
651 {
652 int mode;
653 if (copy_from_user(&mode, argp, sizeof(int)))
654 return -EFAULT;
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200655
656 mfi->mode = MTD_MODE_NORMAL;
657
658 ret = otp_select_filemode(mfi, mode);
659
Nicolas Pitre81dba482005-04-01 16:36:15 +0100660 file->f_pos = 0;
Nicolas Pitre31f42332005-02-08 17:45:55 +0000661 break;
662 }
663
664 case OTPGETREGIONCOUNT:
665 case OTPGETREGIONINFO:
666 {
667 struct otp_info *buf = kmalloc(4096, GFP_KERNEL);
668 if (!buf)
669 return -ENOMEM;
670 ret = -EOPNOTSUPP;
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200671 switch (mfi->mode) {
672 case MTD_MODE_OTP_FACTORY:
Nicolas Pitre31f42332005-02-08 17:45:55 +0000673 if (mtd->get_fact_prot_info)
674 ret = mtd->get_fact_prot_info(mtd, buf, 4096);
675 break;
676 case MTD_MODE_OTP_USER:
677 if (mtd->get_user_prot_info)
678 ret = mtd->get_user_prot_info(mtd, buf, 4096);
679 break;
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200680 default:
681 break;
Nicolas Pitre31f42332005-02-08 17:45:55 +0000682 }
683 if (ret >= 0) {
684 if (cmd == OTPGETREGIONCOUNT) {
685 int nbr = ret / sizeof(struct otp_info);
686 ret = copy_to_user(argp, &nbr, sizeof(int));
687 } else
688 ret = copy_to_user(argp, buf, ret);
689 if (ret)
690 ret = -EFAULT;
691 }
692 kfree(buf);
693 break;
694 }
695
696 case OTPLOCK:
697 {
Harvey Harrison175428b2008-07-03 23:40:14 -0700698 struct otp_info oinfo;
Nicolas Pitre31f42332005-02-08 17:45:55 +0000699
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200700 if (mfi->mode != MTD_MODE_OTP_USER)
Nicolas Pitre31f42332005-02-08 17:45:55 +0000701 return -EINVAL;
Harvey Harrison175428b2008-07-03 23:40:14 -0700702 if (copy_from_user(&oinfo, argp, sizeof(oinfo)))
Nicolas Pitre31f42332005-02-08 17:45:55 +0000703 return -EFAULT;
704 if (!mtd->lock_user_prot_reg)
705 return -EOPNOTSUPP;
Harvey Harrison175428b2008-07-03 23:40:14 -0700706 ret = mtd->lock_user_prot_reg(mtd, oinfo.start, oinfo.length);
Nicolas Pitre31f42332005-02-08 17:45:55 +0000707 break;
708 }
709#endif
710
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200711 case ECCGETLAYOUT:
712 {
713 if (!mtd->ecclayout)
714 return -EOPNOTSUPP;
715
Ricard Wanderlöfd25ade72006-10-17 17:27:11 +0200716 if (copy_to_user(argp, mtd->ecclayout,
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200717 sizeof(struct nand_ecclayout)))
718 return -EFAULT;
719 break;
720 }
721
722 case ECCGETSTATS:
723 {
724 if (copy_to_user(argp, &mtd->ecc_stats,
725 sizeof(struct mtd_ecc_stats)))
726 return -EFAULT;
727 break;
728 }
729
730 case MTDFILEMODE:
731 {
732 mfi->mode = 0;
733
734 switch(arg) {
735 case MTD_MODE_OTP_FACTORY:
736 case MTD_MODE_OTP_USER:
737 ret = otp_select_filemode(mfi, arg);
738 break;
739
740 case MTD_MODE_RAW:
741 if (!mtd->read_oob || !mtd->write_oob)
742 return -EOPNOTSUPP;
743 mfi->mode = arg;
744
745 case MTD_MODE_NORMAL:
746 break;
747 default:
748 ret = -EINVAL;
749 }
750 file->f_pos = 0;
751 break;
752 }
753
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 default:
755 ret = -ENOTTY;
756 }
757
758 return ret;
759} /* memory_ioctl */
760
David Howells402d3262009-02-12 10:40:00 +0000761/*
762 * try to determine where a shared mapping can be made
763 * - only supported for NOMMU at the moment (MMU can't doesn't copy private
764 * mappings)
765 */
766#ifndef CONFIG_MMU
767static unsigned long mtd_get_unmapped_area(struct file *file,
768 unsigned long addr,
769 unsigned long len,
770 unsigned long pgoff,
771 unsigned long flags)
772{
773 struct mtd_file_info *mfi = file->private_data;
774 struct mtd_info *mtd = mfi->mtd;
775
776 if (mtd->get_unmapped_area) {
777 unsigned long offset;
778
779 if (addr != 0)
780 return (unsigned long) -EINVAL;
781
782 if (len > mtd->size || pgoff >= (mtd->size >> PAGE_SHIFT))
783 return (unsigned long) -EINVAL;
784
785 offset = pgoff << PAGE_SHIFT;
786 if (offset > mtd->size - len)
787 return (unsigned long) -EINVAL;
788
789 return mtd->get_unmapped_area(mtd, len, offset, flags);
790 }
791
792 /* can't map directly */
793 return (unsigned long) -ENOSYS;
794}
795#endif
796
797/*
798 * set up a mapping for shared memory segments
799 */
800static int mtd_mmap(struct file *file, struct vm_area_struct *vma)
801{
802#ifdef CONFIG_MMU
803 struct mtd_file_info *mfi = file->private_data;
804 struct mtd_info *mtd = mfi->mtd;
805
806 if (mtd->type == MTD_RAM || mtd->type == MTD_ROM)
807 return 0;
808 return -ENOSYS;
809#else
810 return vma->vm_flags & VM_SHARED ? 0 : -ENOSYS;
811#endif
812}
813
Arjan van de Vend54b1fd2007-02-12 00:55:34 -0800814static const struct file_operations mtd_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 .owner = THIS_MODULE,
816 .llseek = mtd_lseek,
817 .read = mtd_read,
818 .write = mtd_write,
819 .ioctl = mtd_ioctl,
820 .open = mtd_open,
821 .release = mtd_close,
David Howells402d3262009-02-12 10:40:00 +0000822 .mmap = mtd_mmap,
823#ifndef CONFIG_MMU
824 .get_unmapped_area = mtd_get_unmapped_area,
825#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826};
827
828static int __init init_mtdchar(void)
829{
David Brownell1f24b5a2009-03-26 00:42:41 -0700830 int status;
831
832 status = register_chrdev(MTD_CHAR_MAJOR, "mtd", &mtd_fops);
833 if (status < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 printk(KERN_NOTICE "Can't allocate major number %d for Memory Technology Devices.\n",
835 MTD_CHAR_MAJOR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836 }
837
David Brownell1f24b5a2009-03-26 00:42:41 -0700838 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839}
840
841static void __exit cleanup_mtdchar(void)
842{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 unregister_chrdev(MTD_CHAR_MAJOR, "mtd");
844}
845
846module_init(init_mtdchar);
847module_exit(cleanup_mtdchar);
848
David Brownell1f24b5a2009-03-26 00:42:41 -0700849MODULE_ALIAS_CHARDEV_MAJOR(MTD_CHAR_MAJOR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850
851MODULE_LICENSE("GPL");
852MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
853MODULE_DESCRIPTION("Direct character-device access to MTD devices");
Scott James Remnant90160e12009-03-02 18:42:39 +0000854MODULE_ALIAS_CHARDEV_MAJOR(MTD_CHAR_MAJOR);