1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Copyright © 1999-2010 David Woodhouse <dwmw2@infradead.org>
6 #include <linux/device.h>
10 #include <linux/init.h>
11 #include <linux/kernel.h>
12 #include <linux/module.h>
13 #include <linux/slab.h>
14 #include <linux/sched.h>
15 #include <linux/mutex.h>
16 #include <linux/backing-dev.h>
17 #include <linux/compat.h>
18 #include <linux/mount.h>
19 #include <linux/blkpg.h>
20 #include <linux/magic.h>
21 #include <linux/major.h>
22 #include <linux/mtd/mtd.h>
23 #include <linux/mtd/partitions.h>
24 #include <linux/mtd/map.h>
26 #include <linux/uaccess.h>
31 * Data structure to hold the pointer to the mtd device as well
32 * as mode information of various use cases.
34 struct mtd_file_info
{
36 enum mtd_file_modes mode
;
39 static loff_t
mtdchar_lseek(struct file
*file
, loff_t offset
, int orig
)
41 struct mtd_file_info
*mfi
= file
->private_data
;
42 return fixed_size_llseek(file
, offset
, orig
, mfi
->mtd
->size
);
45 static int mtdchar_open(struct inode
*inode
, struct file
*file
)
47 int minor
= iminor(inode
);
48 int devnum
= minor
>> 1;
51 struct mtd_file_info
*mfi
;
53 pr_debug("MTD_open\n");
55 /* You can't open the RO devices RW */
56 if ((file
->f_mode
& FMODE_WRITE
) && (minor
& 1))
59 mtd
= get_mtd_device(NULL
, devnum
);
64 if (mtd
->type
== MTD_ABSENT
) {
69 /* You can't open it RW if it's not a writeable device */
70 if ((file
->f_mode
& FMODE_WRITE
) && !(mtd
->flags
& MTD_WRITEABLE
)) {
75 mfi
= kzalloc(sizeof(*mfi
), GFP_KERNEL
);
81 file
->private_data
= mfi
;
89 /*====================================================================*/
91 static int mtdchar_close(struct inode
*inode
, struct file
*file
)
93 struct mtd_file_info
*mfi
= file
->private_data
;
94 struct mtd_info
*mtd
= mfi
->mtd
;
96 pr_debug("MTD_close\n");
98 /* Only sync if opened RW */
99 if ((file
->f_mode
& FMODE_WRITE
))
103 file
->private_data
= NULL
;
107 } /* mtdchar_close */
109 /* Back in June 2001, dwmw2 wrote:
111 * FIXME: This _really_ needs to die. In 2.5, we should lock the
112 * userspace buffer down and use it directly with readv/writev.
114 * The implementation below, using mtd_kmalloc_up_to, mitigates
115 * allocation failures when the system is under low-memory situations
116 * or if memory is highly fragmented at the cost of reducing the
117 * performance of the requested transfer due to a smaller buffer size.
119 * A more complex but more memory-efficient implementation based on
120 * get_user_pages and iovecs to cover extents of those pages is a
121 * longer-term goal, as intimated by dwmw2 above. However, for the
122 * write case, this requires yet more complex head and tail transfer
123 * handling when those head and tail offsets and sizes are such that
124 * alignment requirements are not met in the NAND subdriver.
127 static ssize_t
mtdchar_read(struct file
*file
, char __user
*buf
, size_t count
,
130 struct mtd_file_info
*mfi
= file
->private_data
;
131 struct mtd_info
*mtd
= mfi
->mtd
;
133 size_t total_retlen
=0;
139 pr_debug("MTD_read\n");
141 if (*ppos
+ count
> mtd
->size
) {
142 if (*ppos
< mtd
->size
)
143 count
= mtd
->size
- *ppos
;
151 kbuf
= mtd_kmalloc_up_to(mtd
, &size
);
156 len
= min_t(size_t, count
, size
);
159 case MTD_FILE_MODE_OTP_FACTORY
:
160 ret
= mtd_read_fact_prot_reg(mtd
, *ppos
, len
,
163 case MTD_FILE_MODE_OTP_USER
:
164 ret
= mtd_read_user_prot_reg(mtd
, *ppos
, len
,
167 case MTD_FILE_MODE_RAW
:
169 struct mtd_oob_ops ops
= {};
171 ops
.mode
= MTD_OPS_RAW
;
176 ret
= mtd_read_oob(mtd
, *ppos
, &ops
);
181 ret
= mtd_read(mtd
, *ppos
, len
, &retlen
, kbuf
);
183 /* Nand returns -EBADMSG on ECC errors, but it returns
184 * the data. For our userspace tools it is important
185 * to dump areas with ECC errors!
186 * For kernel internal usage it also might return -EUCLEAN
187 * to signal the caller that a bitflip has occurred and has
188 * been corrected by the ECC algorithm.
189 * Userspace software which accesses NAND this way
190 * must be aware of the fact that it deals with NAND
192 if (!ret
|| mtd_is_bitflip_or_eccerr(ret
)) {
194 if (copy_to_user(buf
, kbuf
, retlen
)) {
199 total_retlen
+= retlen
;
217 static ssize_t
mtdchar_write(struct file
*file
, const char __user
*buf
, size_t count
,
220 struct mtd_file_info
*mfi
= file
->private_data
;
221 struct mtd_info
*mtd
= mfi
->mtd
;
225 size_t total_retlen
=0;
229 pr_debug("MTD_write\n");
231 if (*ppos
>= mtd
->size
)
234 if (*ppos
+ count
> mtd
->size
)
235 count
= mtd
->size
- *ppos
;
240 kbuf
= mtd_kmalloc_up_to(mtd
, &size
);
245 len
= min_t(size_t, count
, size
);
247 if (copy_from_user(kbuf
, buf
, len
)) {
253 case MTD_FILE_MODE_OTP_FACTORY
:
256 case MTD_FILE_MODE_OTP_USER
:
257 ret
= mtd_write_user_prot_reg(mtd
, *ppos
, len
,
261 case MTD_FILE_MODE_RAW
:
263 struct mtd_oob_ops ops
= {};
265 ops
.mode
= MTD_OPS_RAW
;
271 ret
= mtd_write_oob(mtd
, *ppos
, &ops
);
277 ret
= mtd_write(mtd
, *ppos
, len
, &retlen
, kbuf
);
281 * Return -ENOSPC only if no data could be written at all.
282 * Otherwise just return the number of bytes that actually
285 if ((ret
== -ENOSPC
) && (total_retlen
))
290 total_retlen
+= retlen
;
302 } /* mtdchar_write */
304 /*======================================================================
306 IOCTL calls for getting device parameters.
308 ======================================================================*/
310 static int otp_select_filemode(struct mtd_file_info
*mfi
, int mode
)
312 struct mtd_info
*mtd
= mfi
->mtd
;
316 case MTD_OTP_FACTORY
:
317 if (mtd_read_fact_prot_reg(mtd
, -1, 0, &retlen
, NULL
) ==
321 mfi
->mode
= MTD_FILE_MODE_OTP_FACTORY
;
324 if (mtd_read_user_prot_reg(mtd
, -1, 0, &retlen
, NULL
) ==
328 mfi
->mode
= MTD_FILE_MODE_OTP_USER
;
331 mfi
->mode
= MTD_FILE_MODE_NORMAL
;
340 static int mtdchar_writeoob(struct file
*file
, struct mtd_info
*mtd
,
341 uint64_t start
, uint32_t length
, void __user
*ptr
,
342 uint32_t __user
*retp
)
344 struct mtd_info
*master
= mtd_get_master(mtd
);
345 struct mtd_file_info
*mfi
= file
->private_data
;
346 struct mtd_oob_ops ops
= {};
353 if (!master
->_write_oob
)
357 ops
.ooboffs
= start
& (mtd
->writesize
- 1);
359 ops
.mode
= (mfi
->mode
== MTD_FILE_MODE_RAW
) ? MTD_OPS_RAW
:
362 if (ops
.ooboffs
&& ops
.ooblen
> (mtd
->oobsize
- ops
.ooboffs
))
365 ops
.oobbuf
= memdup_user(ptr
, length
);
366 if (IS_ERR(ops
.oobbuf
))
367 return PTR_ERR(ops
.oobbuf
);
369 start
&= ~((uint64_t)mtd
->writesize
- 1);
370 ret
= mtd_write_oob(mtd
, start
, &ops
);
372 if (ops
.oobretlen
> 0xFFFFFFFFU
)
374 retlen
= ops
.oobretlen
;
375 if (copy_to_user(retp
, &retlen
, sizeof(length
)))
382 static int mtdchar_readoob(struct file
*file
, struct mtd_info
*mtd
,
383 uint64_t start
, uint32_t length
, void __user
*ptr
,
384 uint32_t __user
*retp
)
386 struct mtd_file_info
*mfi
= file
->private_data
;
387 struct mtd_oob_ops ops
= {};
394 ops
.ooboffs
= start
& (mtd
->writesize
- 1);
396 ops
.mode
= (mfi
->mode
== MTD_FILE_MODE_RAW
) ? MTD_OPS_RAW
:
399 if (ops
.ooboffs
&& ops
.ooblen
> (mtd
->oobsize
- ops
.ooboffs
))
402 ops
.oobbuf
= kmalloc(length
, GFP_KERNEL
);
406 start
&= ~((uint64_t)mtd
->writesize
- 1);
407 ret
= mtd_read_oob(mtd
, start
, &ops
);
409 if (put_user(ops
.oobretlen
, retp
))
411 else if (ops
.oobretlen
&& copy_to_user(ptr
, ops
.oobbuf
,
418 * NAND returns -EBADMSG on ECC errors, but it returns the OOB
419 * data. For our userspace tools it is important to dump areas
421 * For kernel internal usage it also might return -EUCLEAN
422 * to signal the caller that a bitflip has occurred and has
423 * been corrected by the ECC algorithm.
425 * Note: currently the standard NAND function, nand_read_oob_std,
426 * does not calculate ECC for the OOB area, so do not rely on
427 * this behavior unless you have replaced it with your own.
429 if (mtd_is_bitflip_or_eccerr(ret
))
436 * Copies (and truncates, if necessary) OOB layout information to the
437 * deprecated layout struct, nand_ecclayout_user. This is necessary only to
438 * support the deprecated API ioctl ECCGETLAYOUT while allowing all new
439 * functionality to use mtd_ooblayout_ops flexibly (i.e. mtd_ooblayout_ops
440 * can describe any kind of OOB layout with almost zero overhead from a
441 * memory usage point of view).
443 static int shrink_ecclayout(struct mtd_info
*mtd
,
444 struct nand_ecclayout_user
*to
)
446 struct mtd_oob_region oobregion
;
447 int i
, section
= 0, ret
;
452 memset(to
, 0, sizeof(*to
));
455 for (i
= 0; i
< MTD_MAX_ECCPOS_ENTRIES
;) {
458 ret
= mtd_ooblayout_ecc(mtd
, section
++, &oobregion
);
466 eccpos
= oobregion
.offset
;
467 for (; i
< MTD_MAX_ECCPOS_ENTRIES
&&
468 eccpos
< oobregion
.offset
+ oobregion
.length
; i
++) {
469 to
->eccpos
[i
] = eccpos
++;
474 for (i
= 0; i
< MTD_MAX_OOBFREE_ENTRIES
; i
++) {
475 ret
= mtd_ooblayout_free(mtd
, i
, &oobregion
);
483 to
->oobfree
[i
].offset
= oobregion
.offset
;
484 to
->oobfree
[i
].length
= oobregion
.length
;
485 to
->oobavail
+= to
->oobfree
[i
].length
;
491 static int get_oobinfo(struct mtd_info
*mtd
, struct nand_oobinfo
*to
)
493 struct mtd_oob_region oobregion
;
494 int i
, section
= 0, ret
;
499 memset(to
, 0, sizeof(*to
));
502 for (i
= 0; i
< ARRAY_SIZE(to
->eccpos
);) {
505 ret
= mtd_ooblayout_ecc(mtd
, section
++, &oobregion
);
513 if (oobregion
.length
+ i
> ARRAY_SIZE(to
->eccpos
))
516 eccpos
= oobregion
.offset
;
517 for (; eccpos
< oobregion
.offset
+ oobregion
.length
; i
++) {
518 to
->eccpos
[i
] = eccpos
++;
523 for (i
= 0; i
< 8; i
++) {
524 ret
= mtd_ooblayout_free(mtd
, i
, &oobregion
);
532 to
->oobfree
[i
][0] = oobregion
.offset
;
533 to
->oobfree
[i
][1] = oobregion
.length
;
536 to
->useecc
= MTD_NANDECC_AUTOPLACE
;
541 static int mtdchar_blkpg_ioctl(struct mtd_info
*mtd
,
542 struct blkpg_ioctl_arg
*arg
)
544 struct blkpg_partition p
;
546 if (!capable(CAP_SYS_ADMIN
))
549 if (copy_from_user(&p
, arg
->data
, sizeof(p
)))
553 case BLKPG_ADD_PARTITION
:
555 /* Only master mtd device must be used to add partitions */
556 if (mtd_is_partition(mtd
))
559 /* Sanitize user input */
560 p
.devname
[BLKPG_DEVNAMELTH
- 1] = '\0';
562 return mtd_add_partition(mtd
, p
.devname
, p
.start
, p
.length
);
564 case BLKPG_DEL_PARTITION
:
569 return mtd_del_partition(mtd
, p
.pno
);
576 static int mtdchar_write_ioctl(struct mtd_info
*mtd
,
577 struct mtd_write_req __user
*argp
)
579 struct mtd_info
*master
= mtd_get_master(mtd
);
580 struct mtd_write_req req
;
581 struct mtd_oob_ops ops
= {};
582 const void __user
*usr_data
, *usr_oob
;
585 if (copy_from_user(&req
, argp
, sizeof(req
)))
588 usr_data
= (const void __user
*)(uintptr_t)req
.usr_data
;
589 usr_oob
= (const void __user
*)(uintptr_t)req
.usr_oob
;
591 if (!master
->_write_oob
)
594 ops
.len
= (size_t)req
.len
;
595 ops
.ooblen
= (size_t)req
.ooblen
;
599 ops
.datbuf
= memdup_user(usr_data
, ops
.len
);
600 if (IS_ERR(ops
.datbuf
))
601 return PTR_ERR(ops
.datbuf
);
607 ops
.oobbuf
= memdup_user(usr_oob
, ops
.ooblen
);
608 if (IS_ERR(ops
.oobbuf
)) {
610 return PTR_ERR(ops
.oobbuf
);
616 ret
= mtd_write_oob(mtd
, (loff_t
)req
.start
, &ops
);
624 static int mtdchar_ioctl(struct file
*file
, u_int cmd
, u_long arg
)
626 struct mtd_file_info
*mfi
= file
->private_data
;
627 struct mtd_info
*mtd
= mfi
->mtd
;
628 struct mtd_info
*master
= mtd_get_master(mtd
);
629 void __user
*argp
= (void __user
*)arg
;
631 struct mtd_info_user info
;
633 pr_debug("MTD_ioctl\n");
636 * Check the file mode to require "dangerous" commands to have write
640 /* "safe" commands */
641 case MEMGETREGIONCOUNT
:
642 case MEMGETREGIONINFO
:
650 case OTPGETREGIONCOUNT
:
651 case OTPGETREGIONINFO
:
659 /* "dangerous" commands */
670 if (!(file
->f_mode
& FMODE_WRITE
))
679 case MEMGETREGIONCOUNT
:
680 if (copy_to_user(argp
, &(mtd
->numeraseregions
), sizeof(int)))
684 case MEMGETREGIONINFO
:
687 struct mtd_erase_region_info
*kr
;
688 struct region_info_user __user
*ur
= argp
;
690 if (get_user(ur_idx
, &(ur
->regionindex
)))
693 if (ur_idx
>= mtd
->numeraseregions
)
696 kr
= &(mtd
->eraseregions
[ur_idx
]);
698 if (put_user(kr
->offset
, &(ur
->offset
))
699 || put_user(kr
->erasesize
, &(ur
->erasesize
))
700 || put_user(kr
->numblocks
, &(ur
->numblocks
)))
707 memset(&info
, 0, sizeof(info
));
708 info
.type
= mtd
->type
;
709 info
.flags
= mtd
->flags
;
710 info
.size
= mtd
->size
;
711 info
.erasesize
= mtd
->erasesize
;
712 info
.writesize
= mtd
->writesize
;
713 info
.oobsize
= mtd
->oobsize
;
714 /* The below field is obsolete */
716 if (copy_to_user(argp
, &info
, sizeof(struct mtd_info_user
)))
723 struct erase_info
*erase
;
725 erase
=kzalloc(sizeof(struct erase_info
),GFP_KERNEL
);
729 if (cmd
== MEMERASE64
) {
730 struct erase_info_user64 einfo64
;
732 if (copy_from_user(&einfo64
, argp
,
733 sizeof(struct erase_info_user64
))) {
737 erase
->addr
= einfo64
.start
;
738 erase
->len
= einfo64
.length
;
740 struct erase_info_user einfo32
;
742 if (copy_from_user(&einfo32
, argp
,
743 sizeof(struct erase_info_user
))) {
747 erase
->addr
= einfo32
.start
;
748 erase
->len
= einfo32
.length
;
751 ret
= mtd_erase(mtd
, erase
);
759 struct mtd_oob_buf buf
;
760 struct mtd_oob_buf __user
*buf_user
= argp
;
762 /* NOTE: writes return length to buf_user->length */
763 if (copy_from_user(&buf
, argp
, sizeof(buf
)))
766 ret
= mtdchar_writeoob(file
, mtd
, buf
.start
, buf
.length
,
767 buf
.ptr
, &buf_user
->length
);
773 struct mtd_oob_buf buf
;
774 struct mtd_oob_buf __user
*buf_user
= argp
;
776 /* NOTE: writes return length to buf_user->start */
777 if (copy_from_user(&buf
, argp
, sizeof(buf
)))
780 ret
= mtdchar_readoob(file
, mtd
, buf
.start
, buf
.length
,
781 buf
.ptr
, &buf_user
->start
);
787 struct mtd_oob_buf64 buf
;
788 struct mtd_oob_buf64 __user
*buf_user
= argp
;
790 if (copy_from_user(&buf
, argp
, sizeof(buf
)))
793 ret
= mtdchar_writeoob(file
, mtd
, buf
.start
, buf
.length
,
794 (void __user
*)(uintptr_t)buf
.usr_ptr
,
801 struct mtd_oob_buf64 buf
;
802 struct mtd_oob_buf64 __user
*buf_user
= argp
;
804 if (copy_from_user(&buf
, argp
, sizeof(buf
)))
807 ret
= mtdchar_readoob(file
, mtd
, buf
.start
, buf
.length
,
808 (void __user
*)(uintptr_t)buf
.usr_ptr
,
815 ret
= mtdchar_write_ioctl(mtd
,
816 (struct mtd_write_req __user
*)arg
);
822 struct erase_info_user einfo
;
824 if (copy_from_user(&einfo
, argp
, sizeof(einfo
)))
827 ret
= mtd_lock(mtd
, einfo
.start
, einfo
.length
);
833 struct erase_info_user einfo
;
835 if (copy_from_user(&einfo
, argp
, sizeof(einfo
)))
838 ret
= mtd_unlock(mtd
, einfo
.start
, einfo
.length
);
844 struct erase_info_user einfo
;
846 if (copy_from_user(&einfo
, argp
, sizeof(einfo
)))
849 ret
= mtd_is_locked(mtd
, einfo
.start
, einfo
.length
);
853 /* Legacy interface */
856 struct nand_oobinfo oi
;
858 if (!master
->ooblayout
)
861 ret
= get_oobinfo(mtd
, &oi
);
865 if (copy_to_user(argp
, &oi
, sizeof(struct nand_oobinfo
)))
874 if (copy_from_user(&offs
, argp
, sizeof(loff_t
)))
876 return mtd_block_isbad(mtd
, offs
);
883 if (copy_from_user(&offs
, argp
, sizeof(loff_t
)))
885 return mtd_block_markbad(mtd
, offs
);
891 if (copy_from_user(&mode
, argp
, sizeof(int)))
894 mfi
->mode
= MTD_FILE_MODE_NORMAL
;
896 ret
= otp_select_filemode(mfi
, mode
);
902 case OTPGETREGIONCOUNT
:
903 case OTPGETREGIONINFO
:
905 struct otp_info
*buf
= kmalloc(4096, GFP_KERNEL
);
910 case MTD_FILE_MODE_OTP_FACTORY
:
911 ret
= mtd_get_fact_prot_info(mtd
, 4096, &retlen
, buf
);
913 case MTD_FILE_MODE_OTP_USER
:
914 ret
= mtd_get_user_prot_info(mtd
, 4096, &retlen
, buf
);
921 if (cmd
== OTPGETREGIONCOUNT
) {
922 int nbr
= retlen
/ sizeof(struct otp_info
);
923 ret
= copy_to_user(argp
, &nbr
, sizeof(int));
925 ret
= copy_to_user(argp
, buf
, retlen
);
936 struct otp_info oinfo
;
938 if (mfi
->mode
!= MTD_FILE_MODE_OTP_USER
)
940 if (copy_from_user(&oinfo
, argp
, sizeof(oinfo
)))
943 ret
= mtd_lock_user_prot_reg(mtd
, oinfo
.start
, oinfo
.length
);
945 ret
= mtd_erase_user_prot_reg(mtd
, oinfo
.start
, oinfo
.length
);
949 /* This ioctl is being deprecated - it truncates the ECC layout */
952 struct nand_ecclayout_user
*usrlay
;
954 if (!master
->ooblayout
)
957 usrlay
= kmalloc(sizeof(*usrlay
), GFP_KERNEL
);
961 shrink_ecclayout(mtd
, usrlay
);
963 if (copy_to_user(argp
, usrlay
, sizeof(*usrlay
)))
971 if (copy_to_user(argp
, &mtd
->ecc_stats
,
972 sizeof(struct mtd_ecc_stats
)))
982 case MTD_FILE_MODE_OTP_FACTORY
:
983 case MTD_FILE_MODE_OTP_USER
:
984 ret
= otp_select_filemode(mfi
, arg
);
987 case MTD_FILE_MODE_RAW
:
988 if (!mtd_has_oob(mtd
))
993 case MTD_FILE_MODE_NORMAL
:
1004 struct blkpg_ioctl_arg __user
*blk_arg
= argp
;
1005 struct blkpg_ioctl_arg a
;
1007 if (copy_from_user(&a
, blk_arg
, sizeof(a
)))
1010 ret
= mtdchar_blkpg_ioctl(mtd
, &a
);
1016 /* No reread partition feature. Just return ok */
1023 } /* memory_ioctl */
1025 static long mtdchar_unlocked_ioctl(struct file
*file
, u_int cmd
, u_long arg
)
1027 struct mtd_file_info
*mfi
= file
->private_data
;
1028 struct mtd_info
*mtd
= mfi
->mtd
;
1029 struct mtd_info
*master
= mtd_get_master(mtd
);
1032 mutex_lock(&master
->master
.chrdev_lock
);
1033 ret
= mtdchar_ioctl(file
, cmd
, arg
);
1034 mutex_unlock(&master
->master
.chrdev_lock
);
1039 #ifdef CONFIG_COMPAT
1041 struct mtd_oob_buf32
{
1044 compat_caddr_t ptr
; /* unsigned char* */
1047 #define MEMWRITEOOB32 _IOWR('M', 3, struct mtd_oob_buf32)
1048 #define MEMREADOOB32 _IOWR('M', 4, struct mtd_oob_buf32)
1050 static long mtdchar_compat_ioctl(struct file
*file
, unsigned int cmd
,
1053 struct mtd_file_info
*mfi
= file
->private_data
;
1054 struct mtd_info
*mtd
= mfi
->mtd
;
1055 struct mtd_info
*master
= mtd_get_master(mtd
);
1056 void __user
*argp
= compat_ptr(arg
);
1059 mutex_lock(&master
->master
.chrdev_lock
);
1064 struct mtd_oob_buf32 buf
;
1065 struct mtd_oob_buf32 __user
*buf_user
= argp
;
1067 if (!(file
->f_mode
& FMODE_WRITE
)) {
1072 if (copy_from_user(&buf
, argp
, sizeof(buf
)))
1075 ret
= mtdchar_writeoob(file
, mtd
, buf
.start
,
1076 buf
.length
, compat_ptr(buf
.ptr
),
1083 struct mtd_oob_buf32 buf
;
1084 struct mtd_oob_buf32 __user
*buf_user
= argp
;
1086 /* NOTE: writes return length to buf->start */
1087 if (copy_from_user(&buf
, argp
, sizeof(buf
)))
1090 ret
= mtdchar_readoob(file
, mtd
, buf
.start
,
1091 buf
.length
, compat_ptr(buf
.ptr
),
1098 /* Convert from blkpg_compat_ioctl_arg to blkpg_ioctl_arg */
1099 struct blkpg_compat_ioctl_arg __user
*uarg
= argp
;
1100 struct blkpg_compat_ioctl_arg compat_arg
;
1101 struct blkpg_ioctl_arg a
;
1103 if (copy_from_user(&compat_arg
, uarg
, sizeof(compat_arg
))) {
1108 memset(&a
, 0, sizeof(a
));
1109 a
.op
= compat_arg
.op
;
1110 a
.flags
= compat_arg
.flags
;
1111 a
.datalen
= compat_arg
.datalen
;
1112 a
.data
= compat_ptr(compat_arg
.data
);
1114 ret
= mtdchar_blkpg_ioctl(mtd
, &a
);
1119 ret
= mtdchar_ioctl(file
, cmd
, (unsigned long)argp
);
1122 mutex_unlock(&master
->master
.chrdev_lock
);
1127 #endif /* CONFIG_COMPAT */
1130 * try to determine where a shared mapping can be made
1131 * - only supported for NOMMU at the moment (MMU can't doesn't copy private
1135 static unsigned long mtdchar_get_unmapped_area(struct file
*file
,
1138 unsigned long pgoff
,
1139 unsigned long flags
)
1141 struct mtd_file_info
*mfi
= file
->private_data
;
1142 struct mtd_info
*mtd
= mfi
->mtd
;
1143 unsigned long offset
;
1147 return (unsigned long) -EINVAL
;
1149 if (len
> mtd
->size
|| pgoff
>= (mtd
->size
>> PAGE_SHIFT
))
1150 return (unsigned long) -EINVAL
;
1152 offset
= pgoff
<< PAGE_SHIFT
;
1153 if (offset
> mtd
->size
- len
)
1154 return (unsigned long) -EINVAL
;
1156 ret
= mtd_get_unmapped_area(mtd
, len
, offset
, flags
);
1157 return ret
== -EOPNOTSUPP
? -ENODEV
: ret
;
1160 static unsigned mtdchar_mmap_capabilities(struct file
*file
)
1162 struct mtd_file_info
*mfi
= file
->private_data
;
1164 return mtd_mmap_capabilities(mfi
->mtd
);
1169 * set up a mapping for shared memory segments
1171 static int mtdchar_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1174 struct mtd_file_info
*mfi
= file
->private_data
;
1175 struct mtd_info
*mtd
= mfi
->mtd
;
1176 struct map_info
*map
= mtd
->priv
;
1178 /* This is broken because it assumes the MTD device is map-based
1179 and that mtd->priv is a valid struct map_info. It should be
1180 replaced with something that uses the mtd_get_unmapped_area()
1181 operation properly. */
1182 if (0 /*mtd->type == MTD_RAM || mtd->type == MTD_ROM*/) {
1183 #ifdef pgprot_noncached
1184 if (file
->f_flags
& O_DSYNC
|| map
->phys
>= __pa(high_memory
))
1185 vma
->vm_page_prot
= pgprot_noncached(vma
->vm_page_prot
);
1187 return vm_iomap_memory(vma
, map
->phys
, map
->size
);
1191 return vma
->vm_flags
& VM_SHARED
? 0 : -EACCES
;
1195 static const struct file_operations mtd_fops
= {
1196 .owner
= THIS_MODULE
,
1197 .llseek
= mtdchar_lseek
,
1198 .read
= mtdchar_read
,
1199 .write
= mtdchar_write
,
1200 .unlocked_ioctl
= mtdchar_unlocked_ioctl
,
1201 #ifdef CONFIG_COMPAT
1202 .compat_ioctl
= mtdchar_compat_ioctl
,
1204 .open
= mtdchar_open
,
1205 .release
= mtdchar_close
,
1206 .mmap
= mtdchar_mmap
,
1208 .get_unmapped_area
= mtdchar_get_unmapped_area
,
1209 .mmap_capabilities
= mtdchar_mmap_capabilities
,
1213 int __init
init_mtdchar(void)
1217 ret
= __register_chrdev(MTD_CHAR_MAJOR
, 0, 1 << MINORBITS
,
1220 pr_err("Can't allocate major number %d for MTD\n",
1228 void __exit
cleanup_mtdchar(void)
1230 __unregister_chrdev(MTD_CHAR_MAJOR
, 0, 1 << MINORBITS
, "mtd");
1233 MODULE_ALIAS_CHARDEV_MAJOR(MTD_CHAR_MAJOR
);