?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add linux-next specific files for 20110831
[linux-2.6/next.git] / drivers / mtd / mtdchar.c
blobb206254751329a47f34fcfa8550d03993950d014
1 /*
2 * Copyright © 1999-2010 David Woodhouse <dwmw2@infradead.org>
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17 *
18 */
19
20 #include <linux/device.h>
21 #include <linux/fs.h>
22 #include <linux/mm.h>
23 #include <linux/err.h>
24 #include <linux/init.h>
25 #include <linux/kernel.h>
26 #include <linux/module.h>
27 #include <linux/slab.h>
28 #include <linux/sched.h>
29 #include <linux/mutex.h>
30 #include <linux/backing-dev.h>
31 #include <linux/compat.h>
32 #include <linux/mount.h>
33 #include <linux/blkpg.h>
34 #include <linux/mtd/mtd.h>
35 #include <linux/mtd/partitions.h>
36 #include <linux/mtd/map.h>
37
38 #include <asm/uaccess.h>
39
40 #define MTD_INODE_FS_MAGIC 0x11307854
41 static DEFINE_MUTEX(mtd_mutex);
42 static struct vfsmount *mtd_inode_mnt __read_mostly;
43
44 /*
45 * Data structure to hold the pointer to the mtd device as well
46 * as mode information of various use cases.
47 */
48 struct mtd_file_info {
49 struct mtd_info *mtd;
50 struct inode *ino;
51 enum mtd_file_modes mode;
52 };
53
54 static loff_t mtd_lseek (struct file *file, loff_t offset, int orig)
55 {
56 struct mtd_file_info *mfi = file->private_data;
57 struct mtd_info *mtd = mfi->mtd;
58
59 switch (orig) {
60 case SEEK_SET:
61 break;
62 case SEEK_CUR:
63 offset += file->f_pos;
64 break;
65 case SEEK_END:
66 offset += mtd->size;
67 break;
68 default:
69 return -EINVAL;
70 }
71
72 if (offset >= 0 && offset <= mtd->size)
73 return file->f_pos = offset;
74
75 return -EINVAL;
76 }
77
78
79
80 static int mtd_open(struct inode *inode, struct file *file)
81 {
82 int minor = iminor(inode);
83 int devnum = minor >> 1;
84 int ret = 0;
85 struct mtd_info *mtd;
86 struct mtd_file_info *mfi;
87 struct inode *mtd_ino;
88
89 pr_debug("MTD_open\n");
90
91 /* You can't open the RO devices RW */
92 if ((file->f_mode & FMODE_WRITE) && (minor & 1))
93 return -EACCES;
94
95 mutex_lock(&mtd_mutex);
96 mtd = get_mtd_device(NULL, devnum);
97
98 if (IS_ERR(mtd)) {
99 ret = PTR_ERR(mtd);
100 goto out;
101 }
102
103 if (mtd->type == MTD_ABSENT) {
104 put_mtd_device(mtd);
105 ret = -ENODEV;
106 goto out;
107 }
108
109 mtd_ino = iget_locked(mtd_inode_mnt->mnt_sb, devnum);
110 if (!mtd_ino) {
111 put_mtd_device(mtd);
112 ret = -ENOMEM;
113 goto out;
114 }
115 if (mtd_ino->i_state & I_NEW) {
116 mtd_ino->i_private = mtd;
117 mtd_ino->i_mode = S_IFCHR;
118 mtd_ino->i_data.backing_dev_info = mtd->backing_dev_info;
119 unlock_new_inode(mtd_ino);
120 }
121 file->f_mapping = mtd_ino->i_mapping;
122
123 /* You can't open it RW if it's not a writeable device */
124 if ((file->f_mode & FMODE_WRITE) && !(mtd->flags & MTD_WRITEABLE)) {
125 iput(mtd_ino);
126 put_mtd_device(mtd);
127 ret = -EACCES;
128 goto out;
129 }
130
131 mfi = kzalloc(sizeof(*mfi), GFP_KERNEL);
132 if (!mfi) {
133 iput(mtd_ino);
134 put_mtd_device(mtd);
135 ret = -ENOMEM;
136 goto out;
137 }
138 mfi->ino = mtd_ino;
139 mfi->mtd = mtd;
140 file->private_data = mfi;
141
142 out:
143 mutex_unlock(&mtd_mutex);
144 return ret;
145 } /* mtd_open */
146
147 /*====================================================================*/
148
149 static int mtd_close(struct inode *inode, struct file *file)
150 {
151 struct mtd_file_info *mfi = file->private_data;
152 struct mtd_info *mtd = mfi->mtd;
153
154 pr_debug("MTD_close\n");
155
156 /* Only sync if opened RW */
157 if ((file->f_mode & FMODE_WRITE) && mtd->sync)
158 mtd->sync(mtd);
159
160 iput(mfi->ino);
161
162 put_mtd_device(mtd);
163 file->private_data = NULL;
164 kfree(mfi);
165
166 return 0;
167 } /* mtd_close */
168
169 /* Back in June 2001, dwmw2 wrote:
170 *
171 * FIXME: This _really_ needs to die. In 2.5, we should lock the
172 * userspace buffer down and use it directly with readv/writev.
173 *
174 * The implementation below, using mtd_kmalloc_up_to, mitigates
175 * allocation failures when the system is under low-memory situations
176 * or if memory is highly fragmented at the cost of reducing the
177 * performance of the requested transfer due to a smaller buffer size.
178 *
179 * A more complex but more memory-efficient implementation based on
180 * get_user_pages and iovecs to cover extents of those pages is a
181 * longer-term goal, as intimated by dwmw2 above. However, for the
182 * write case, this requires yet more complex head and tail transfer
183 * handling when those head and tail offsets and sizes are such that
184 * alignment requirements are not met in the NAND subdriver.
185 */
186
187 static ssize_t mtd_read(struct file *file, char __user *buf, size_t count,loff_t *ppos)
188 {
189 struct mtd_file_info *mfi = file->private_data;
190 struct mtd_info *mtd = mfi->mtd;
191 size_t retlen=0;
192 size_t total_retlen=0;
193 int ret=0;
194 int len;
195 size_t size = count;
196 char *kbuf;
197
198 pr_debug("MTD_read\n");
199
200 if (*ppos + count > mtd->size)
201 count = mtd->size - *ppos;
202
203 if (!count)
204 return 0;
205
206 kbuf = mtd_kmalloc_up_to(mtd, &size);
207 if (!kbuf)
208 return -ENOMEM;
209
210 while (count) {
211 len = min_t(size_t, count, size);
212
213 switch (mfi->mode) {
214 case MTD_MODE_OTP_FACTORY:
215 ret = mtd->read_fact_prot_reg(mtd, *ppos, len, &retlen, kbuf);
216 break;
217 case MTD_MODE_OTP_USER:
218 ret = mtd->read_user_prot_reg(mtd, *ppos, len, &retlen, kbuf);
219 break;
220 case MTD_MODE_RAW:
221 {
222 struct mtd_oob_ops ops;
223
224 ops.mode = MTD_OOB_RAW;
225 ops.datbuf = kbuf;
226 ops.oobbuf = NULL;
227 ops.len = len;
228
229 ret = mtd->read_oob(mtd, *ppos, &ops);
230 retlen = ops.retlen;
231 break;
232 }
233 default:
234 ret = mtd->read(mtd, *ppos, len, &retlen, kbuf);
235 }
236 /* Nand returns -EBADMSG on ECC errors, but it returns
237 * the data. For our userspace tools it is important
238 * to dump areas with ECC errors!
239 * For kernel internal usage it also might return -EUCLEAN
240 * to signal the caller that a bitflip has occurred and has
241 * been corrected by the ECC algorithm.
242 * Userspace software which accesses NAND this way
243 * must be aware of the fact that it deals with NAND
244 */
245 if (!ret || (ret == -EUCLEAN) || (ret == -EBADMSG)) {
246 *ppos += retlen;
247 if (copy_to_user(buf, kbuf, retlen)) {
248 kfree(kbuf);
249 return -EFAULT;
250 }
251 else
252 total_retlen += retlen;
253
254 count -= retlen;
255 buf += retlen;
256 if (retlen == 0)
257 count = 0;
258 }
259 else {
260 kfree(kbuf);
261 return ret;
262 }
263
264 }
265
266 kfree(kbuf);
267 return total_retlen;
268 } /* mtd_read */
269
270 static ssize_t mtd_write(struct file *file, const char __user *buf, size_t count,loff_t *ppos)
271 {
272 struct mtd_file_info *mfi = file->private_data;
273 struct mtd_info *mtd = mfi->mtd;
274 size_t size = count;
275 char *kbuf;
276 size_t retlen;
277 size_t total_retlen=0;
278 int ret=0;
279 int len;
280
281 pr_debug("MTD_write\n");
282
283 if (*ppos == mtd->size)
284 return -ENOSPC;
285
286 if (*ppos + count > mtd->size)
287 count = mtd->size - *ppos;
288
289 if (!count)
290 return 0;
291
292 kbuf = mtd_kmalloc_up_to(mtd, &size);
293 if (!kbuf)
294 return -ENOMEM;
295
296 while (count) {
297 len = min_t(size_t, count, size);
298
299 if (copy_from_user(kbuf, buf, len)) {
300 kfree(kbuf);
301 return -EFAULT;
302 }
303
304 switch (mfi->mode) {
305 case MTD_MODE_OTP_FACTORY:
306 ret = -EROFS;
307 break;
308 case MTD_MODE_OTP_USER:
309 if (!mtd->write_user_prot_reg) {
310 ret = -EOPNOTSUPP;
311 break;
312 }
313 ret = mtd->write_user_prot_reg(mtd, *ppos, len, &retlen, kbuf);
314 break;
315
316 case MTD_MODE_RAW:
317 {
318 struct mtd_oob_ops ops;
319
320 ops.mode = MTD_OOB_RAW;
321 ops.datbuf = kbuf;
322 ops.oobbuf = NULL;
323 ops.ooboffs = 0;
324 ops.len = len;
325
326 ret = mtd->write_oob(mtd, *ppos, &ops);
327 retlen = ops.retlen;
328 break;
329 }
330
331 default:
332 ret = (*(mtd->write))(mtd, *ppos, len, &retlen, kbuf);
333 }
334 if (!ret) {
335 *ppos += retlen;
336 total_retlen += retlen;
337 count -= retlen;
338 buf += retlen;
339 }
340 else {
341 kfree(kbuf);
342 return ret;
343 }
344 }
345
346 kfree(kbuf);
347 return total_retlen;
348 } /* mtd_write */
349
350 /*======================================================================
351
352 IOCTL calls for getting device parameters.
353
354 ======================================================================*/
355 static void mtdchar_erase_callback (struct erase_info *instr)
356 {
357 wake_up((wait_queue_head_t *)instr->priv);
358 }
359
360 #ifdef CONFIG_HAVE_MTD_OTP
361 static int otp_select_filemode(struct mtd_file_info *mfi, int mode)
362 {
363 struct mtd_info *mtd = mfi->mtd;
364 int ret = 0;
365
366 switch (mode) {
367 case MTD_OTP_FACTORY:
368 if (!mtd->read_fact_prot_reg)
369 ret = -EOPNOTSUPP;
370 else
371 mfi->mode = MTD_MODE_OTP_FACTORY;
372 break;
373 case MTD_OTP_USER:
374 if (!mtd->read_fact_prot_reg)
375 ret = -EOPNOTSUPP;
376 else
377 mfi->mode = MTD_MODE_OTP_USER;
378 break;
379 default:
380 ret = -EINVAL;
381 case MTD_OTP_OFF:
382 break;
383 }
384 return ret;
385 }
386 #else
387 # define otp_select_filemode(f,m) -EOPNOTSUPP
388 #endif
389
390 static int mtd_do_writeoob(struct file *file, struct mtd_info *mtd,
391 uint64_t start, uint32_t length, void __user *ptr,
392 uint32_t __user *retp)
393 {
394 struct mtd_oob_ops ops;
395 uint32_t retlen;
396 int ret = 0;
397
398 if (!(file->f_mode & FMODE_WRITE))
399 return -EPERM;
400
401 if (length > 4096)
402 return -EINVAL;
403
404 if (!mtd->write_oob)
405 ret = -EOPNOTSUPP;
406 else
407 ret = access_ok(VERIFY_READ, ptr, length) ? 0 : -EFAULT;
408
409 if (ret)
410 return ret;
411
412 ops.ooblen = length;
413 ops.ooboffs = start & (mtd->writesize - 1);
414 ops.datbuf = NULL;
415 ops.mode = MTD_OOB_PLACE;
416
417 if (ops.ooboffs && ops.ooblen > (mtd->oobsize - ops.ooboffs))
418 return -EINVAL;
419
420 ops.oobbuf = memdup_user(ptr, length);
421 if (IS_ERR(ops.oobbuf))
422 return PTR_ERR(ops.oobbuf);
423
424 start &= ~((uint64_t)mtd->writesize - 1);
425 ret = mtd->write_oob(mtd, start, &ops);
426
427 if (ops.oobretlen > 0xFFFFFFFFU)
428 ret = -EOVERFLOW;
429 retlen = ops.oobretlen;
430 if (copy_to_user(retp, &retlen, sizeof(length)))
431 ret = -EFAULT;
432
433 kfree(ops.oobbuf);
434 return ret;
435 }
436
437 static int mtd_do_readoob(struct mtd_info *mtd, uint64_t start,
438 uint32_t length, void __user *ptr, uint32_t __user *retp)
439 {
440 struct mtd_oob_ops ops;
441 int ret = 0;
442
443 if (length > 4096)
444 return -EINVAL;
445
446 if (!mtd->read_oob)
447 ret = -EOPNOTSUPP;
448 else
449 ret = access_ok(VERIFY_WRITE, ptr,
450 length) ? 0 : -EFAULT;
451 if (ret)
452 return ret;
453
454 ops.ooblen = length;
455 ops.ooboffs = start & (mtd->writesize - 1);
456 ops.datbuf = NULL;
457 ops.mode = MTD_OOB_PLACE;
458
459 if (ops.ooboffs && ops.ooblen > (mtd->oobsize - ops.ooboffs))
460 return -EINVAL;
461
462 ops.oobbuf = kmalloc(length, GFP_KERNEL);
463 if (!ops.oobbuf)
464 return -ENOMEM;
465
466 start &= ~((uint64_t)mtd->writesize - 1);
467 ret = mtd->read_oob(mtd, start, &ops);
468
469 if (put_user(ops.oobretlen, retp))
470 ret = -EFAULT;
471 else if (ops.oobretlen && copy_to_user(ptr, ops.oobbuf,
472 ops.oobretlen))
473 ret = -EFAULT;
474
475 kfree(ops.oobbuf);
476
477 /*
478 * NAND returns -EBADMSG on ECC errors, but it returns the OOB
479 * data. For our userspace tools it is important to dump areas
480 * with ECC errors!
481 * For kernel internal usage it also might return -EUCLEAN
482 * to signal the caller that a bitflip has occured and has
483 * been corrected by the ECC algorithm.
484 *
485 * Note: currently the standard NAND function, nand_read_oob_std,
486 * does not calculate ECC for the OOB area, so do not rely on
487 * this behavior unless you have replaced it with your own.
488 */
489 if (ret == -EUCLEAN || ret == -EBADMSG)
490 return 0;
491
492 return ret;
493 }
494
495 /*
496 * Copies (and truncates, if necessary) data from the larger struct,
497 * nand_ecclayout, to the smaller, deprecated layout struct,
498 * nand_ecclayout_user. This is necessary only to support the deprecated
499 * API ioctl ECCGETLAYOUT while allowing all new functionality to use
500 * nand_ecclayout flexibly (i.e. the struct may change size in new
501 * releases without requiring major rewrites).
502 */
503 static int shrink_ecclayout(const struct nand_ecclayout *from,
504 struct nand_ecclayout_user *to)
505 {
506 int i;
507
508 if (!from || !to)
509 return -EINVAL;
510
511 memset(to, 0, sizeof(*to));
512
513 to->eccbytes = min((int)from->eccbytes, MTD_MAX_ECCPOS_ENTRIES);
514 for (i = 0; i < to->eccbytes; i++)
515 to->eccpos[i] = from->eccpos[i];
516
517 for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES; i++) {
518 if (from->oobfree[i].length == 0 &&
519 from->oobfree[i].offset == 0)
520 break;
521 to->oobavail += from->oobfree[i].length;
522 to->oobfree[i] = from->oobfree[i];
523 }
524
525 return 0;
526 }
527
528 static int mtd_blkpg_ioctl(struct mtd_info *mtd,
529 struct blkpg_ioctl_arg __user *arg)
530 {
531 struct blkpg_ioctl_arg a;
532 struct blkpg_partition p;
533
534 if (!capable(CAP_SYS_ADMIN))
535 return -EPERM;
536
537 if (copy_from_user(&a, arg, sizeof(struct blkpg_ioctl_arg)))
538 return -EFAULT;
539
540 if (copy_from_user(&p, a.data, sizeof(struct blkpg_partition)))
541 return -EFAULT;
542
543 switch (a.op) {
544 case BLKPG_ADD_PARTITION:
545
546 /* Only master mtd device must be used to add partitions */
547 if (mtd_is_partition(mtd))
548 return -EINVAL;
549
550 return mtd_add_partition(mtd, p.devname, p.start, p.length);
551
552 case BLKPG_DEL_PARTITION:
553
554 if (p.pno < 0)
555 return -EINVAL;
556
557 return mtd_del_partition(mtd, p.pno);
558
559 default:
560 return -EINVAL;
561 }
562 }
563
564 static int mtd_ioctl(struct file *file, u_int cmd, u_long arg)
565 {
566 struct mtd_file_info *mfi = file->private_data;
567 struct mtd_info *mtd = mfi->mtd;
568 void __user *argp = (void __user *)arg;
569 int ret = 0;
570 u_long size;
571 struct mtd_info_user info;
572
573 pr_debug("MTD_ioctl\n");
574
575 size = (cmd & IOCSIZE_MASK) >> IOCSIZE_SHIFT;
576 if (cmd & IOC_IN) {
577 if (!access_ok(VERIFY_READ, argp, size))
578 return -EFAULT;
579 }
580 if (cmd & IOC_OUT) {
581 if (!access_ok(VERIFY_WRITE, argp, size))
582 return -EFAULT;
583 }
584
585 switch (cmd) {
586 case MEMGETREGIONCOUNT:
587 if (copy_to_user(argp, &(mtd->numeraseregions), sizeof(int)))
588 return -EFAULT;
589 break;
590
591 case MEMGETREGIONINFO:
592 {
593 uint32_t ur_idx;
594 struct mtd_erase_region_info *kr;
595 struct region_info_user __user *ur = argp;
596
597 if (get_user(ur_idx, &(ur->regionindex)))
598 return -EFAULT;
599
600 if (ur_idx >= mtd->numeraseregions)
601 return -EINVAL;
602
603 kr = &(mtd->eraseregions[ur_idx]);
604
605 if (put_user(kr->offset, &(ur->offset))
606 || put_user(kr->erasesize, &(ur->erasesize))
607 || put_user(kr->numblocks, &(ur->numblocks)))
608 return -EFAULT;
609
610 break;
611 }
612
613 case MEMGETINFO:
614 memset(&info, 0, sizeof(info));
615 info.type = mtd->type;
616 info.flags = mtd->flags;
617 info.size = mtd->size;
618 info.erasesize = mtd->erasesize;
619 info.writesize = mtd->writesize;
620 info.oobsize = mtd->oobsize;
621 /* The below fields are obsolete */
622 info.ecctype = -1;
623 if (copy_to_user(argp, &info, sizeof(struct mtd_info_user)))
624 return -EFAULT;
625 break;
626
627 case MEMERASE:
628 case MEMERASE64:
629 {
630 struct erase_info *erase;
631
632 if(!(file->f_mode & FMODE_WRITE))
633 return -EPERM;
634
635 erase=kzalloc(sizeof(struct erase_info),GFP_KERNEL);
636 if (!erase)
637 ret = -ENOMEM;
638 else {
639 wait_queue_head_t waitq;
640 DECLARE_WAITQUEUE(wait, current);
641
642 init_waitqueue_head(&waitq);
643
644 if (cmd == MEMERASE64) {
645 struct erase_info_user64 einfo64;
646
647 if (copy_from_user(&einfo64, argp,
648 sizeof(struct erase_info_user64))) {
649 kfree(erase);
650 return -EFAULT;
651 }
652 erase->addr = einfo64.start;
653 erase->len = einfo64.length;
654 } else {
655 struct erase_info_user einfo32;
656
657 if (copy_from_user(&einfo32, argp,
658 sizeof(struct erase_info_user))) {
659 kfree(erase);
660 return -EFAULT;
661 }
662 erase->addr = einfo32.start;
663 erase->len = einfo32.length;
664 }
665 erase->mtd = mtd;
666 erase->callback = mtdchar_erase_callback;
667 erase->priv = (unsigned long)&waitq;
668
669 /*
670 FIXME: Allow INTERRUPTIBLE. Which means
671 not having the wait_queue head on the stack.
672
673 If the wq_head is on the stack, and we
674 leave because we got interrupted, then the
675 wq_head is no longer there when the
676 callback routine tries to wake us up.
677 */
678 ret = mtd->erase(mtd, erase);
679 if (!ret) {
680 set_current_state(TASK_UNINTERRUPTIBLE);
681 add_wait_queue(&waitq, &wait);
682 if (erase->state != MTD_ERASE_DONE &&
683 erase->state != MTD_ERASE_FAILED)
684 schedule();
685 remove_wait_queue(&waitq, &wait);
686 set_current_state(TASK_RUNNING);
687
688 ret = (erase->state == MTD_ERASE_FAILED)?-EIO:0;
689 }
690 kfree(erase);
691 }
692 break;
693 }
694
695 case MEMWRITEOOB:
696 {
697 struct mtd_oob_buf buf;
698 struct mtd_oob_buf __user *buf_user = argp;
699
700 /* NOTE: writes return length to buf_user->length */
701 if (copy_from_user(&buf, argp, sizeof(buf)))
702 ret = -EFAULT;
703 else
704 ret = mtd_do_writeoob(file, mtd, buf.start, buf.length,
705 buf.ptr, &buf_user->length);
706 break;
707 }
708
709 case MEMREADOOB:
710 {
711 struct mtd_oob_buf buf;
712 struct mtd_oob_buf __user *buf_user = argp;
713
714 /* NOTE: writes return length to buf_user->start */
715 if (copy_from_user(&buf, argp, sizeof(buf)))
716 ret = -EFAULT;
717 else
718 ret = mtd_do_readoob(mtd, buf.start, buf.length,
719 buf.ptr, &buf_user->start);
720 break;
721 }
722
723 case MEMWRITEOOB64:
724 {
725 struct mtd_oob_buf64 buf;
726 struct mtd_oob_buf64 __user *buf_user = argp;
727
728 if (copy_from_user(&buf, argp, sizeof(buf)))
729 ret = -EFAULT;
730 else
731 ret = mtd_do_writeoob(file, mtd, buf.start, buf.length,
732 (void __user *)(uintptr_t)buf.usr_ptr,
733 &buf_user->length);
734 break;
735 }
736
737 case MEMREADOOB64:
738 {
739 struct mtd_oob_buf64 buf;
740 struct mtd_oob_buf64 __user *buf_user = argp;
741
742 if (copy_from_user(&buf, argp, sizeof(buf)))
743 ret = -EFAULT;
744 else
745 ret = mtd_do_readoob(mtd, buf.start, buf.length,
746 (void __user *)(uintptr_t)buf.usr_ptr,
747 &buf_user->length);
748 break;
749 }
750
751 case MEMLOCK:
752 {
753 struct erase_info_user einfo;
754
755 if (copy_from_user(&einfo, argp, sizeof(einfo)))
756 return -EFAULT;
757
758 if (!mtd->lock)
759 ret = -EOPNOTSUPP;
760 else
761 ret = mtd->lock(mtd, einfo.start, einfo.length);
762 break;
763 }
764
765 case MEMUNLOCK:
766 {
767 struct erase_info_user einfo;
768
769 if (copy_from_user(&einfo, argp, sizeof(einfo)))
770 return -EFAULT;
771
772 if (!mtd->unlock)
773 ret = -EOPNOTSUPP;
774 else
775 ret = mtd->unlock(mtd, einfo.start, einfo.length);
776 break;
777 }
778
779 case MEMISLOCKED:
780 {
781 struct erase_info_user einfo;
782
783 if (copy_from_user(&einfo, argp, sizeof(einfo)))
784 return -EFAULT;
785
786 if (!mtd->is_locked)
787 ret = -EOPNOTSUPP;
788 else
789 ret = mtd->is_locked(mtd, einfo.start, einfo.length);
790 break;
791 }
792
793 /* Legacy interface */
794 case MEMGETOOBSEL:
795 {
796 struct nand_oobinfo oi;
797
798 if (!mtd->ecclayout)
799 return -EOPNOTSUPP;
800 if (mtd->ecclayout->eccbytes > ARRAY_SIZE(oi.eccpos))
801 return -EINVAL;
802
803 oi.useecc = MTD_NANDECC_AUTOPLACE;
804 memcpy(&oi.eccpos, mtd->ecclayout->eccpos, sizeof(oi.eccpos));
805 memcpy(&oi.oobfree, mtd->ecclayout->oobfree,
806 sizeof(oi.oobfree));
807 oi.eccbytes = mtd->ecclayout->eccbytes;
808
809 if (copy_to_user(argp, &oi, sizeof(struct nand_oobinfo)))
810 return -EFAULT;
811 break;
812 }
813
814 case MEMGETBADBLOCK:
815 {
816 loff_t offs;
817
818 if (copy_from_user(&offs, argp, sizeof(loff_t)))
819 return -EFAULT;
820 if (!mtd->block_isbad)
821 ret = -EOPNOTSUPP;
822 else
823 return mtd->block_isbad(mtd, offs);
824 break;
825 }
826
827 case MEMSETBADBLOCK:
828 {
829 loff_t offs;
830
831 if (copy_from_user(&offs, argp, sizeof(loff_t)))
832 return -EFAULT;
833 if (!mtd->block_markbad)
834 ret = -EOPNOTSUPP;
835 else
836 return mtd->block_markbad(mtd, offs);
837 break;
838 }
839
840 #ifdef CONFIG_HAVE_MTD_OTP
841 case OTPSELECT:
842 {
843 int mode;
844 if (copy_from_user(&mode, argp, sizeof(int)))
845 return -EFAULT;
846
847 mfi->mode = MTD_MODE_NORMAL;
848
849 ret = otp_select_filemode(mfi, mode);
850
851 file->f_pos = 0;
852 break;
853 }
854
855 case OTPGETREGIONCOUNT:
856 case OTPGETREGIONINFO:
857 {
858 struct otp_info *buf = kmalloc(4096, GFP_KERNEL);
859 if (!buf)
860 return -ENOMEM;
861 ret = -EOPNOTSUPP;
862 switch (mfi->mode) {
863 case MTD_MODE_OTP_FACTORY:
864 if (mtd->get_fact_prot_info)
865 ret = mtd->get_fact_prot_info(mtd, buf, 4096);
866 break;
867 case MTD_MODE_OTP_USER:
868 if (mtd->get_user_prot_info)
869 ret = mtd->get_user_prot_info(mtd, buf, 4096);
870 break;
871 default:
872 break;
873 }
874 if (ret >= 0) {
875 if (cmd == OTPGETREGIONCOUNT) {
876 int nbr = ret / sizeof(struct otp_info);
877 ret = copy_to_user(argp, &nbr, sizeof(int));
878 } else
879 ret = copy_to_user(argp, buf, ret);
880 if (ret)
881 ret = -EFAULT;
882 }
883 kfree(buf);
884 break;
885 }
886
887 case OTPLOCK:
888 {
889 struct otp_info oinfo;
890
891 if (mfi->mode != MTD_MODE_OTP_USER)
892 return -EINVAL;
893 if (copy_from_user(&oinfo, argp, sizeof(oinfo)))
894 return -EFAULT;
895 if (!mtd->lock_user_prot_reg)
896 return -EOPNOTSUPP;
897 ret = mtd->lock_user_prot_reg(mtd, oinfo.start, oinfo.length);
898 break;
899 }
900 #endif
901
902 /* This ioctl is being deprecated - it truncates the ECC layout */
903 case ECCGETLAYOUT:
904 {
905 struct nand_ecclayout_user *usrlay;
906
907 if (!mtd->ecclayout)
908 return -EOPNOTSUPP;
909
910 usrlay = kmalloc(sizeof(*usrlay), GFP_KERNEL);
911 if (!usrlay)
912 return -ENOMEM;
913
914 shrink_ecclayout(mtd->ecclayout, usrlay);
915
916 if (copy_to_user(argp, usrlay, sizeof(*usrlay)))
917 ret = -EFAULT;
918 kfree(usrlay);
919 break;
920 }
921
922 case ECCGETSTATS:
923 {
924 if (copy_to_user(argp, &mtd->ecc_stats,
925 sizeof(struct mtd_ecc_stats)))
926 return -EFAULT;
927 break;
928 }
929
930 case MTDFILEMODE:
931 {
932 mfi->mode = 0;
933
934 switch(arg) {
935 case MTD_MODE_OTP_FACTORY:
936 case MTD_MODE_OTP_USER:
937 ret = otp_select_filemode(mfi, arg);
938 break;
939
940 case MTD_MODE_RAW:
941 if (!mtd->read_oob || !mtd->write_oob)
942 return -EOPNOTSUPP;
943 mfi->mode = arg;
944
945 case MTD_MODE_NORMAL:
946 break;
947 default:
948 ret = -EINVAL;
949 }
950 file->f_pos = 0;
951 break;
952 }
953
954 case BLKPG:
955 {
956 ret = mtd_blkpg_ioctl(mtd,
957 (struct blkpg_ioctl_arg __user *)arg);
958 break;
959 }
960
961 case BLKRRPART:
962 {
963 /* No reread partition feature. Just return ok */
964 ret = 0;
965 break;
966 }
967
968 default:
969 ret = -ENOTTY;
970 }
971
972 return ret;
973 } /* memory_ioctl */
974
975 static long mtd_unlocked_ioctl(struct file *file, u_int cmd, u_long arg)
976 {
977 int ret;
978
979 mutex_lock(&mtd_mutex);
980 ret = mtd_ioctl(file, cmd, arg);
981 mutex_unlock(&mtd_mutex);
982
983 return ret;
984 }
985
986 #ifdef CONFIG_COMPAT
987
988 struct mtd_oob_buf32 {
989 u_int32_t start;
990 u_int32_t length;
991 compat_caddr_t ptr; /* unsigned char* */
992 };
993
994 #define MEMWRITEOOB32 _IOWR('M', 3, struct mtd_oob_buf32)
995 #define MEMREADOOB32 _IOWR('M', 4, struct mtd_oob_buf32)
996
997 static long mtd_compat_ioctl(struct file *file, unsigned int cmd,
998 unsigned long arg)
999 {
1000 struct mtd_file_info *mfi = file->private_data;
1001 struct mtd_info *mtd = mfi->mtd;
1002 void __user *argp = compat_ptr(arg);
1003 int ret = 0;
1004
1005 mutex_lock(&mtd_mutex);
1006
1007 switch (cmd) {
1008 case MEMWRITEOOB32:
1009 {
1010 struct mtd_oob_buf32 buf;
1011 struct mtd_oob_buf32 __user *buf_user = argp;
1012
1013 if (copy_from_user(&buf, argp, sizeof(buf)))
1014 ret = -EFAULT;
1015 else
1016 ret = mtd_do_writeoob(file, mtd, buf.start,
1017 buf.length, compat_ptr(buf.ptr),
1018 &buf_user->length);
1019 break;
1020 }
1021
1022 case MEMREADOOB32:
1023 {
1024 struct mtd_oob_buf32 buf;
1025 struct mtd_oob_buf32 __user *buf_user = argp;
1026
1027 /* NOTE: writes return length to buf->start */
1028 if (copy_from_user(&buf, argp, sizeof(buf)))
1029 ret = -EFAULT;
1030 else
1031 ret = mtd_do_readoob(mtd, buf.start,
1032 buf.length, compat_ptr(buf.ptr),
1033 &buf_user->start);
1034 break;
1035 }
1036 default:
1037 ret = mtd_ioctl(file, cmd, (unsigned long)argp);
1038 }
1039
1040 mutex_unlock(&mtd_mutex);
1041
1042 return ret;
1043 }
1044
1045 #endif /* CONFIG_COMPAT */
1046
1047 /*
1048 * try to determine where a shared mapping can be made
1049 * - only supported for NOMMU at the moment (MMU can't doesn't copy private
1050 * mappings)
1051 */
1052 #ifndef CONFIG_MMU
1053 static unsigned long mtd_get_unmapped_area(struct file *file,
1054 unsigned long addr,
1055 unsigned long len,
1056 unsigned long pgoff,
1057 unsigned long flags)
1058 {
1059 struct mtd_file_info *mfi = file->private_data;
1060 struct mtd_info *mtd = mfi->mtd;
1061
1062 if (mtd->get_unmapped_area) {
1063 unsigned long offset;
1064
1065 if (addr != 0)
1066 return (unsigned long) -EINVAL;
1067
1068 if (len > mtd->size || pgoff >= (mtd->size >> PAGE_SHIFT))
1069 return (unsigned long) -EINVAL;
1070
1071 offset = pgoff << PAGE_SHIFT;
1072 if (offset > mtd->size - len)
1073 return (unsigned long) -EINVAL;
1074
1075 return mtd->get_unmapped_area(mtd, len, offset, flags);
1076 }
1077
1078 /* can't map directly */
1079 return (unsigned long) -ENOSYS;
1080 }
1081 #endif
1082
1083 /*
1084 * set up a mapping for shared memory segments
1085 */
1086 static int mtd_mmap(struct file *file, struct vm_area_struct *vma)
1087 {
1088 #ifdef CONFIG_MMU
1089 struct mtd_file_info *mfi = file->private_data;
1090 struct mtd_info *mtd = mfi->mtd;
1091 struct map_info *map = mtd->priv;
1092 unsigned long start;
1093 unsigned long off;
1094 u32 len;
1095
1096 if (mtd->type == MTD_RAM || mtd->type == MTD_ROM) {
1097 off = vma->vm_pgoff << PAGE_SHIFT;
1098 start = map->phys;
1099 len = PAGE_ALIGN((start & ~PAGE_MASK) + map->size);
1100 start &= PAGE_MASK;
1101 if ((vma->vm_end - vma->vm_start + off) > len)
1102 return -EINVAL;
1103
1104 off += start;
1105 vma->vm_pgoff = off >> PAGE_SHIFT;
1106 vma->vm_flags |= VM_IO | VM_RESERVED;
1107
1108 #ifdef pgprot_noncached
1109 if (file->f_flags & O_DSYNC || off >= __pa(high_memory))
1110 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
1111 #endif
1112 if (io_remap_pfn_range(vma, vma->vm_start, off >> PAGE_SHIFT,
1113 vma->vm_end - vma->vm_start,
1114 vma->vm_page_prot))
1115 return -EAGAIN;
1116
1117 return 0;
1118 }
1119 return -ENOSYS;
1120 #else
1121 return vma->vm_flags & VM_SHARED ? 0 : -ENOSYS;
1122 #endif
1123 }
1124
1125 static const struct file_operations mtd_fops = {
1126 .owner = THIS_MODULE,
1127 .llseek = mtd_lseek,
1128 .read = mtd_read,
1129 .write = mtd_write,
1130 .unlocked_ioctl = mtd_unlocked_ioctl,
1131 #ifdef CONFIG_COMPAT
1132 .compat_ioctl = mtd_compat_ioctl,
1133 #endif
1134 .open = mtd_open,
1135 .release = mtd_close,
1136 .mmap = mtd_mmap,
1137 #ifndef CONFIG_MMU
1138 .get_unmapped_area = mtd_get_unmapped_area,
1139 #endif
1140 };
1141
1142 static struct dentry *mtd_inodefs_mount(struct file_system_type *fs_type,
1143 int flags, const char *dev_name, void *data)
1144 {
1145 return mount_pseudo(fs_type, "mtd_inode:", NULL, NULL, MTD_INODE_FS_MAGIC);
1146 }
1147
1148 static struct file_system_type mtd_inodefs_type = {
1149 .name = "mtd_inodefs",
1150 .mount = mtd_inodefs_mount,
1151 .kill_sb = kill_anon_super,
1152 };
1153
1154 static void mtdchar_notify_add(struct mtd_info *mtd)
1155 {
1156 }
1157
1158 static void mtdchar_notify_remove(struct mtd_info *mtd)
1159 {
1160 struct inode *mtd_ino = ilookup(mtd_inode_mnt->mnt_sb, mtd->index);
1161
1162 if (mtd_ino) {
1163 /* Destroy the inode if it exists */
1164 mtd_ino->i_nlink = 0;
1165 iput(mtd_ino);
1166 }
1167 }
1168
1169 static struct mtd_notifier mtdchar_notifier = {
1170 .add = mtdchar_notify_add,
1171 .remove = mtdchar_notify_remove,
1172 };
1173
1174 static int __init init_mtdchar(void)
1175 {
1176 int ret;
1177
1178 ret = __register_chrdev(MTD_CHAR_MAJOR, 0, 1 << MINORBITS,
1179 "mtd", &mtd_fops);
1180 if (ret < 0) {
1181 pr_notice("Can't allocate major number %d for "
1182 "Memory Technology Devices.\n", MTD_CHAR_MAJOR);
1183 return ret;
1184 }
1185
1186 ret = register_filesystem(&mtd_inodefs_type);
1187 if (ret) {
1188 pr_notice("Can't register mtd_inodefs filesystem: %d\n", ret);
1189 goto err_unregister_chdev;
1190 }
1191
1192 mtd_inode_mnt = kern_mount(&mtd_inodefs_type);
1193 if (IS_ERR(mtd_inode_mnt)) {
1194 ret = PTR_ERR(mtd_inode_mnt);
1195 pr_notice("Error mounting mtd_inodefs filesystem: %d\n", ret);
1196 goto err_unregister_filesystem;
1197 }
1198 register_mtd_user(&mtdchar_notifier);
1199
1200 return ret;
1201
1202 err_unregister_filesystem:
1203 unregister_filesystem(&mtd_inodefs_type);
1204 err_unregister_chdev:
1205 __unregister_chrdev(MTD_CHAR_MAJOR, 0, 1 << MINORBITS, "mtd");
1206 return ret;
1207 }
1208
1209 static void __exit cleanup_mtdchar(void)
1210 {
1211 unregister_mtd_user(&mtdchar_notifier);
1212 kern_unmount(mtd_inode_mnt);
1213 unregister_filesystem(&mtd_inodefs_type);
1214 __unregister_chrdev(MTD_CHAR_MAJOR, 0, 1 << MINORBITS, "mtd");
1215 }
1216
1217 module_init(init_mtdchar);
1218 module_exit(cleanup_mtdchar);
1219
1220 MODULE_ALIAS_CHARDEV_MAJOR(MTD_CHAR_MAJOR);
1221
1222 MODULE_LICENSE("GPL");
1223 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
1224 MODULE_DESCRIPTION("Direct character-device access to MTD devices");
1225 MODULE_ALIAS_CHARDEV_MAJOR(MTD_CHAR_MAJOR);
linux-next