blob: 02389528f622d819431fe24b0277031b214dd702 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
David Woodhousea1452a32010-08-08 20:58:20 +01002 * 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 *
18 */
19
Thomas Gleixner15fdc522005-11-07 00:14:42 +010020#include <linux/device.h>
21#include <linux/fs.h>
Andrew Morton0c1eafd2007-08-10 13:01:06 -070022#include <linux/mm.h>
Artem Bityutskiy9c740342006-10-11 14:52:47 +030023#include <linux/err.h>
Thomas Gleixner15fdc522005-11-07 00:14:42 +010024#include <linux/init.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include <linux/kernel.h>
26#include <linux/module.h>
Thomas Gleixner15fdc522005-11-07 00:14:42 +010027#include <linux/slab.h>
28#include <linux/sched.h>
Arnd Bergmann5aa82942010-06-02 14:28:52 +020029#include <linux/mutex.h>
David Howells402d3262009-02-12 10:40:00 +000030#include <linux/backing-dev.h>
Kevin Cernekee97718542009-04-08 22:53:13 -070031#include <linux/compat.h>
Kirill A. Shutemovcd874232010-05-17 16:55:47 +030032#include <linux/mount.h>
Roman Tereshonkovd0f79592010-09-17 13:31:42 +030033#include <linux/blkpg.h>
Muthu Kumarb502bd12012-03-23 15:01:50 -070034#include <linux/magic.h>
Ezequiel Garciaf83c3832013-10-13 18:05:23 -030035#include <linux/major.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include <linux/mtd/mtd.h>
Roman Tereshonkovd0f79592010-09-17 13:31:42 +030037#include <linux/mtd/partitions.h>
Anatolij Gustschindd02b672010-06-15 09:30:15 +020038#include <linux/mtd/map.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
Linus Torvalds7c0f6ba2016-12-24 11:46:01 -080040#include <linux/uaccess.h>
Todd Poynor9bc7b382005-06-30 01:23:27 +010041
Artem Bityutskiy660685d2013-03-14 13:27:40 +020042#include "mtdcore.h"
43
Arnd Bergmann5aa82942010-06-02 14:28:52 +020044static DEFINE_MUTEX(mtd_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
Nicolas Pitre045e9a5d52005-02-08 19:12:53 +000046/*
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +020047 * Data structure to hold the pointer to the mtd device as well
Brian Norris92394b5c2011-07-20 09:53:42 -070048 * as mode information of various use cases.
Nicolas Pitre045e9a5d52005-02-08 19:12:53 +000049 */
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +020050struct mtd_file_info {
51 struct mtd_info *mtd;
52 enum mtd_file_modes mode;
53};
Nicolas Pitre31f42332005-02-08 17:45:55 +000054
Artem Bityutskiy969e57a2011-12-23 17:27:46 +020055static loff_t mtdchar_lseek(struct file *file, loff_t offset, int orig)
Linus Torvalds1da177e2005-04-16 15:20:36 -070056{
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +020057 struct mtd_file_info *mfi = file->private_data;
Al Virob9599572013-06-16 20:27:42 +040058 return fixed_size_llseek(file, offset, orig, mfi->mtd->size);
Linus Torvalds1da177e2005-04-16 15:20:36 -070059}
60
Artem Bityutskiy969e57a2011-12-23 17:27:46 +020061static int mtdchar_open(struct inode *inode, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -070062{
63 int minor = iminor(inode);
64 int devnum = minor >> 1;
Jonathan Corbet60712392008-05-15 10:10:37 -060065 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070066 struct mtd_info *mtd;
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +020067 struct mtd_file_info *mfi;
Linus Torvalds1da177e2005-04-16 15:20:36 -070068
Brian Norris289c0522011-07-19 10:06:09 -070069 pr_debug("MTD_open\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -070070
Linus Torvalds1da177e2005-04-16 15:20:36 -070071 /* You can't open the RO devices RW */
Al Viroaeb5d722008-09-02 15:28:45 -040072 if ((file->f_mode & FMODE_WRITE) && (minor & 1))
Linus Torvalds1da177e2005-04-16 15:20:36 -070073 return -EACCES;
74
Arnd Bergmann5aa82942010-06-02 14:28:52 +020075 mutex_lock(&mtd_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 mtd = get_mtd_device(NULL, devnum);
Thomas Gleixner97894cd2005-11-07 11:15:26 +000077
Jonathan Corbet60712392008-05-15 10:10:37 -060078 if (IS_ERR(mtd)) {
79 ret = PTR_ERR(mtd);
80 goto out;
81 }
Thomas Gleixner97894cd2005-11-07 11:15:26 +000082
David Howells402d3262009-02-12 10:40:00 +000083 if (mtd->type == MTD_ABSENT) {
Jonathan Corbet60712392008-05-15 10:10:37 -060084 ret = -ENODEV;
Al Viroc65390f2012-04-09 01:36:28 -040085 goto out1;
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 }
87
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 /* You can't open it RW if it's not a writeable device */
Al Viroaeb5d722008-09-02 15:28:45 -040089 if ((file->f_mode & FMODE_WRITE) && !(mtd->flags & MTD_WRITEABLE)) {
Jonathan Corbet60712392008-05-15 10:10:37 -060090 ret = -EACCES;
Christoph Hellwigb4caecd2015-01-14 10:42:32 +010091 goto out1;
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 }
Thomas Gleixner97894cd2005-11-07 11:15:26 +000093
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +020094 mfi = kzalloc(sizeof(*mfi), GFP_KERNEL);
95 if (!mfi) {
Jonathan Corbet60712392008-05-15 10:10:37 -060096 ret = -ENOMEM;
Christoph Hellwigb4caecd2015-01-14 10:42:32 +010097 goto out1;
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +020098 }
99 mfi->mtd = mtd;
100 file->private_data = mfi;
Al Viroc65390f2012-04-09 01:36:28 -0400101 mutex_unlock(&mtd_mutex);
102 return 0;
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200103
Al Viroc65390f2012-04-09 01:36:28 -0400104out1:
105 put_mtd_device(mtd);
Jonathan Corbet60712392008-05-15 10:10:37 -0600106out:
Arnd Bergmann5aa82942010-06-02 14:28:52 +0200107 mutex_unlock(&mtd_mutex);
Jonathan Corbet60712392008-05-15 10:10:37 -0600108 return ret;
Artem Bityutskiy969e57a2011-12-23 17:27:46 +0200109} /* mtdchar_open */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110
111/*====================================================================*/
112
Artem Bityutskiy969e57a2011-12-23 17:27:46 +0200113static int mtdchar_close(struct inode *inode, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114{
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200115 struct mtd_file_info *mfi = file->private_data;
116 struct mtd_info *mtd = mfi->mtd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117
Brian Norris289c0522011-07-19 10:06:09 -0700118 pr_debug("MTD_close\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119
Joakim Tjernlund7eafaed2007-06-27 00:56:40 +0200120 /* Only sync if opened RW */
Artem Bityutskiy327cf292011-12-30 16:35:35 +0200121 if ((file->f_mode & FMODE_WRITE))
Artem Bityutskiy85f2f2a2011-12-23 19:03:12 +0200122 mtd_sync(mtd);
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000123
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 put_mtd_device(mtd);
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200125 file->private_data = NULL;
126 kfree(mfi);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127
128 return 0;
Artem Bityutskiy969e57a2011-12-23 17:27:46 +0200129} /* mtdchar_close */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130
Grant Erickson3e45cf52011-04-08 08:51:33 -0700131/* Back in June 2001, dwmw2 wrote:
132 *
133 * FIXME: This _really_ needs to die. In 2.5, we should lock the
134 * userspace buffer down and use it directly with readv/writev.
135 *
136 * The implementation below, using mtd_kmalloc_up_to, mitigates
137 * allocation failures when the system is under low-memory situations
138 * or if memory is highly fragmented at the cost of reducing the
139 * performance of the requested transfer due to a smaller buffer size.
140 *
141 * A more complex but more memory-efficient implementation based on
142 * get_user_pages and iovecs to cover extents of those pages is a
143 * longer-term goal, as intimated by dwmw2 above. However, for the
144 * write case, this requires yet more complex head and tail transfer
145 * handling when those head and tail offsets and sizes are such that
146 * alignment requirements are not met in the NAND subdriver.
147 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148
Artem Bityutskiy969e57a2011-12-23 17:27:46 +0200149static ssize_t mtdchar_read(struct file *file, char __user *buf, size_t count,
150 loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151{
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200152 struct mtd_file_info *mfi = file->private_data;
153 struct mtd_info *mtd = mfi->mtd;
Artem Bityutskiy30fa9842011-12-29 15:16:28 +0200154 size_t retlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 size_t total_retlen=0;
156 int ret=0;
157 int len;
Grant Erickson3e45cf52011-04-08 08:51:33 -0700158 size_t size = count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 char *kbuf;
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000160
Brian Norris289c0522011-07-19 10:06:09 -0700161 pr_debug("MTD_read\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162
Jann Horn6c6bc9e2018-07-07 05:37:22 +0200163 if (*ppos + count > mtd->size) {
164 if (*ppos < mtd->size)
165 count = mtd->size - *ppos;
166 else
167 count = 0;
168 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169
170 if (!count)
171 return 0;
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000172
Grant Erickson3e45cf52011-04-08 08:51:33 -0700173 kbuf = mtd_kmalloc_up_to(mtd, &size);
Thago Galesib802c072006-04-17 17:38:15 +0100174 if (!kbuf)
175 return -ENOMEM;
176
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 while (count) {
Grant Erickson3e45cf52011-04-08 08:51:33 -0700178 len = min_t(size_t, count, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200180 switch (mfi->mode) {
Brian Norrisbeb133f2011-08-30 18:45:41 -0700181 case MTD_FILE_MODE_OTP_FACTORY:
Artem Bityutskiyd264f722011-12-23 18:40:06 +0200182 ret = mtd_read_fact_prot_reg(mtd, *ppos, len,
183 &retlen, kbuf);
Nicolas Pitre31f42332005-02-08 17:45:55 +0000184 break;
Brian Norrisbeb133f2011-08-30 18:45:41 -0700185 case MTD_FILE_MODE_OTP_USER:
Artem Bityutskiy4ea1cab2011-12-23 18:47:59 +0200186 ret = mtd_read_user_prot_reg(mtd, *ppos, len,
187 &retlen, kbuf);
Nicolas Pitre31f42332005-02-08 17:45:55 +0000188 break;
Brian Norrisbeb133f2011-08-30 18:45:41 -0700189 case MTD_FILE_MODE_RAW:
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200190 {
191 struct mtd_oob_ops ops;
192
Brian Norris0612b9d2011-08-30 18:45:40 -0700193 ops.mode = MTD_OPS_RAW;
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200194 ops.datbuf = kbuf;
195 ops.oobbuf = NULL;
196 ops.len = len;
197
Artem Bityutskiyfd2819bb2011-12-23 18:27:05 +0200198 ret = mtd_read_oob(mtd, *ppos, &ops);
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200199 retlen = ops.retlen;
200 break;
201 }
Nicolas Pitre31f42332005-02-08 17:45:55 +0000202 default:
Artem Bityutskiy329ad392011-12-23 17:30:16 +0200203 ret = mtd_read(mtd, *ppos, len, &retlen, kbuf);
Nicolas Pitre31f42332005-02-08 17:45:55 +0000204 }
Brian Norris7854d3f2011-06-23 14:12:08 -0700205 /* Nand returns -EBADMSG on ECC errors, but it returns
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 * the data. For our userspace tools it is important
Brian Norris7854d3f2011-06-23 14:12:08 -0700207 * to dump areas with ECC errors!
Thomas Gleixner9a1fcdf2006-05-29 14:56:39 +0200208 * For kernel internal usage it also might return -EUCLEAN
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300209 * to signal the caller that a bitflip has occurred and has
Thomas Gleixner9a1fcdf2006-05-29 14:56:39 +0200210 * been corrected by the ECC algorithm.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 * Userspace software which accesses NAND this way
212 * must be aware of the fact that it deals with NAND
213 */
Brian Norrisd57f40542011-09-20 18:34:25 -0700214 if (!ret || mtd_is_bitflip_or_eccerr(ret)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 *ppos += retlen;
216 if (copy_to_user(buf, kbuf, retlen)) {
Thomas Gleixnerf4a43cf2006-05-28 11:01:53 +0200217 kfree(kbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 return -EFAULT;
219 }
220 else
221 total_retlen += retlen;
222
223 count -= retlen;
224 buf += retlen;
Nicolas Pitre31f42332005-02-08 17:45:55 +0000225 if (retlen == 0)
226 count = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 }
228 else {
229 kfree(kbuf);
230 return ret;
231 }
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000232
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 }
234
Thago Galesib802c072006-04-17 17:38:15 +0100235 kfree(kbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 return total_retlen;
Artem Bityutskiy969e57a2011-12-23 17:27:46 +0200237} /* mtdchar_read */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238
Artem Bityutskiy969e57a2011-12-23 17:27:46 +0200239static ssize_t mtdchar_write(struct file *file, const char __user *buf, size_t count,
240 loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241{
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200242 struct mtd_file_info *mfi = file->private_data;
243 struct mtd_info *mtd = mfi->mtd;
Grant Erickson3e45cf52011-04-08 08:51:33 -0700244 size_t size = count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 char *kbuf;
246 size_t retlen;
247 size_t total_retlen=0;
248 int ret=0;
249 int len;
250
Brian Norris289c0522011-07-19 10:06:09 -0700251 pr_debug("MTD_write\n");
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000252
Jann Horn6c6bc9e2018-07-07 05:37:22 +0200253 if (*ppos >= mtd->size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 return -ENOSPC;
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000255
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 if (*ppos + count > mtd->size)
257 count = mtd->size - *ppos;
258
259 if (!count)
260 return 0;
261
Grant Erickson3e45cf52011-04-08 08:51:33 -0700262 kbuf = mtd_kmalloc_up_to(mtd, &size);
Thago Galesib802c072006-04-17 17:38:15 +0100263 if (!kbuf)
264 return -ENOMEM;
265
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 while (count) {
Grant Erickson3e45cf52011-04-08 08:51:33 -0700267 len = min_t(size_t, count, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 if (copy_from_user(kbuf, buf, len)) {
270 kfree(kbuf);
271 return -EFAULT;
272 }
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000273
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200274 switch (mfi->mode) {
Brian Norrisbeb133f2011-08-30 18:45:41 -0700275 case MTD_FILE_MODE_OTP_FACTORY:
Nicolas Pitre31f42332005-02-08 17:45:55 +0000276 ret = -EROFS;
277 break;
Brian Norrisbeb133f2011-08-30 18:45:41 -0700278 case MTD_FILE_MODE_OTP_USER:
Artem Bityutskiy482b43a2011-12-23 18:50:04 +0200279 ret = mtd_write_user_prot_reg(mtd, *ppos, len,
280 &retlen, kbuf);
Nicolas Pitre31f42332005-02-08 17:45:55 +0000281 break;
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200282
Brian Norrisbeb133f2011-08-30 18:45:41 -0700283 case MTD_FILE_MODE_RAW:
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200284 {
285 struct mtd_oob_ops ops;
286
Brian Norris0612b9d2011-08-30 18:45:40 -0700287 ops.mode = MTD_OPS_RAW;
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200288 ops.datbuf = kbuf;
289 ops.oobbuf = NULL;
Peter Wippichbf514082011-06-06 15:50:58 +0200290 ops.ooboffs = 0;
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200291 ops.len = len;
292
Artem Bityutskiya2cc5ba2011-12-23 18:29:55 +0200293 ret = mtd_write_oob(mtd, *ppos, &ops);
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200294 retlen = ops.retlen;
295 break;
296 }
297
Nicolas Pitre31f42332005-02-08 17:45:55 +0000298 default:
Artem Bityutskiyeda95cb2011-12-23 17:35:41 +0200299 ret = mtd_write(mtd, *ppos, len, &retlen, kbuf);
Nicolas Pitre31f42332005-02-08 17:45:55 +0000300 }
Christian Riesch9a78bc82014-03-06 12:42:37 +0100301
302 /*
303 * Return -ENOSPC only if no data could be written at all.
304 * Otherwise just return the number of bytes that actually
305 * have been written.
306 */
307 if ((ret == -ENOSPC) && (total_retlen))
308 break;
309
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 if (!ret) {
311 *ppos += retlen;
312 total_retlen += retlen;
313 count -= retlen;
314 buf += retlen;
315 }
316 else {
317 kfree(kbuf);
318 return ret;
319 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 }
321
Thago Galesib802c072006-04-17 17:38:15 +0100322 kfree(kbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 return total_retlen;
Artem Bityutskiy969e57a2011-12-23 17:27:46 +0200324} /* mtdchar_write */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325
326/*======================================================================
327
328 IOCTL calls for getting device parameters.
329
330======================================================================*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200332static int otp_select_filemode(struct mtd_file_info *mfi, int mode)
333{
334 struct mtd_info *mtd = mfi->mtd;
Artem Bityutskiyb6de3d62011-12-29 10:06:32 +0200335 size_t retlen;
Artem Bityutskiyb6de3d62011-12-29 10:06:32 +0200336
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200337 switch (mode) {
338 case MTD_OTP_FACTORY:
Uwe Kleine-König5dc63fa2013-03-04 17:35:24 +0100339 if (mtd_read_fact_prot_reg(mtd, -1, 0, &retlen, NULL) ==
340 -EOPNOTSUPP)
341 return -EOPNOTSUPP;
342
Artem Bityutskiyb6de3d62011-12-29 10:06:32 +0200343 mfi->mode = MTD_FILE_MODE_OTP_FACTORY;
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200344 break;
345 case MTD_OTP_USER:
Uwe Kleine-König5dc63fa2013-03-04 17:35:24 +0100346 if (mtd_read_user_prot_reg(mtd, -1, 0, &retlen, NULL) ==
347 -EOPNOTSUPP)
348 return -EOPNOTSUPP;
349
Artem Bityutskiyb6de3d62011-12-29 10:06:32 +0200350 mfi->mode = MTD_FILE_MODE_OTP_USER;
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200351 break;
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200352 case MTD_OTP_OFF:
Uwe Kleine-König5dc63fa2013-03-04 17:35:24 +0100353 mfi->mode = MTD_FILE_MODE_NORMAL;
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200354 break;
Uwe Kleine-König5dc63fa2013-03-04 17:35:24 +0100355 default:
356 return -EINVAL;
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200357 }
Uwe Kleine-König5dc63fa2013-03-04 17:35:24 +0100358
359 return 0;
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200360}
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200361
Artem Bityutskiy969e57a2011-12-23 17:27:46 +0200362static int mtdchar_writeoob(struct file *file, struct mtd_info *mtd,
Kevin Cernekee97718542009-04-08 22:53:13 -0700363 uint64_t start, uint32_t length, void __user *ptr,
364 uint32_t __user *retp)
365{
Brian Norris9ce244b2011-08-30 18:45:37 -0700366 struct mtd_file_info *mfi = file->private_data;
Kevin Cernekee97718542009-04-08 22:53:13 -0700367 struct mtd_oob_ops ops;
368 uint32_t retlen;
369 int ret = 0;
370
371 if (!(file->f_mode & FMODE_WRITE))
372 return -EPERM;
373
374 if (length > 4096)
375 return -EINVAL;
376
Artem Bityutskiy3c3c10b2012-01-30 14:58:32 +0200377 if (!mtd->_write_oob)
Al Viro0db188f2017-09-29 13:55:19 -0400378 return -EOPNOTSUPP;
Kevin Cernekee97718542009-04-08 22:53:13 -0700379
380 ops.ooblen = length;
Brian Norris305b93f2011-08-23 17:17:32 -0700381 ops.ooboffs = start & (mtd->writesize - 1);
Kevin Cernekee97718542009-04-08 22:53:13 -0700382 ops.datbuf = NULL;
Brian Norrisbeb133f2011-08-30 18:45:41 -0700383 ops.mode = (mfi->mode == MTD_FILE_MODE_RAW) ? MTD_OPS_RAW :
Brian Norris0612b9d2011-08-30 18:45:40 -0700384 MTD_OPS_PLACE_OOB;
Kevin Cernekee97718542009-04-08 22:53:13 -0700385
386 if (ops.ooboffs && ops.ooblen > (mtd->oobsize - ops.ooboffs))
387 return -EINVAL;
388
Julia Lawalldf1f1d12010-05-22 10:22:49 +0200389 ops.oobbuf = memdup_user(ptr, length);
390 if (IS_ERR(ops.oobbuf))
391 return PTR_ERR(ops.oobbuf);
Kevin Cernekee97718542009-04-08 22:53:13 -0700392
Brian Norris305b93f2011-08-23 17:17:32 -0700393 start &= ~((uint64_t)mtd->writesize - 1);
Artem Bityutskiya2cc5ba2011-12-23 18:29:55 +0200394 ret = mtd_write_oob(mtd, start, &ops);
Kevin Cernekee97718542009-04-08 22:53:13 -0700395
396 if (ops.oobretlen > 0xFFFFFFFFU)
397 ret = -EOVERFLOW;
398 retlen = ops.oobretlen;
399 if (copy_to_user(retp, &retlen, sizeof(length)))
400 ret = -EFAULT;
401
402 kfree(ops.oobbuf);
403 return ret;
404}
405
Artem Bityutskiy969e57a2011-12-23 17:27:46 +0200406static int mtdchar_readoob(struct file *file, struct mtd_info *mtd,
Brian Norrisc46f6482011-08-30 18:45:38 -0700407 uint64_t start, uint32_t length, void __user *ptr,
408 uint32_t __user *retp)
Kevin Cernekee97718542009-04-08 22:53:13 -0700409{
Brian Norrisc46f6482011-08-30 18:45:38 -0700410 struct mtd_file_info *mfi = file->private_data;
Kevin Cernekee97718542009-04-08 22:53:13 -0700411 struct mtd_oob_ops ops;
412 int ret = 0;
413
414 if (length > 4096)
415 return -EINVAL;
416
Kevin Cernekee97718542009-04-08 22:53:13 -0700417 ops.ooblen = length;
Brian Norris305b93f2011-08-23 17:17:32 -0700418 ops.ooboffs = start & (mtd->writesize - 1);
Kevin Cernekee97718542009-04-08 22:53:13 -0700419 ops.datbuf = NULL;
Brian Norrisbeb133f2011-08-30 18:45:41 -0700420 ops.mode = (mfi->mode == MTD_FILE_MODE_RAW) ? MTD_OPS_RAW :
Brian Norris0612b9d2011-08-30 18:45:40 -0700421 MTD_OPS_PLACE_OOB;
Kevin Cernekee97718542009-04-08 22:53:13 -0700422
423 if (ops.ooboffs && ops.ooblen > (mtd->oobsize - ops.ooboffs))
424 return -EINVAL;
425
426 ops.oobbuf = kmalloc(length, GFP_KERNEL);
427 if (!ops.oobbuf)
428 return -ENOMEM;
429
Brian Norris305b93f2011-08-23 17:17:32 -0700430 start &= ~((uint64_t)mtd->writesize - 1);
Artem Bityutskiyfd2819bb2011-12-23 18:27:05 +0200431 ret = mtd_read_oob(mtd, start, &ops);
Kevin Cernekee97718542009-04-08 22:53:13 -0700432
433 if (put_user(ops.oobretlen, retp))
434 ret = -EFAULT;
435 else if (ops.oobretlen && copy_to_user(ptr, ops.oobbuf,
436 ops.oobretlen))
437 ret = -EFAULT;
438
439 kfree(ops.oobbuf);
Brian Norris041e4572011-06-23 16:45:24 -0700440
441 /*
442 * NAND returns -EBADMSG on ECC errors, but it returns the OOB
443 * data. For our userspace tools it is important to dump areas
444 * with ECC errors!
445 * For kernel internal usage it also might return -EUCLEAN
Nobuhiro Iwamatsu5d708ec2017-01-27 10:36:38 +0900446 * to signal the caller that a bitflip has occurred and has
Brian Norris041e4572011-06-23 16:45:24 -0700447 * been corrected by the ECC algorithm.
448 *
Brian Norrisc478d7e2011-06-28 16:29:00 -0700449 * Note: currently the standard NAND function, nand_read_oob_std,
450 * does not calculate ECC for the OOB area, so do not rely on
451 * this behavior unless you have replaced it with your own.
Brian Norris041e4572011-06-23 16:45:24 -0700452 */
Brian Norrisd57f40542011-09-20 18:34:25 -0700453 if (mtd_is_bitflip_or_eccerr(ret))
Brian Norris041e4572011-06-23 16:45:24 -0700454 return 0;
455
Kevin Cernekee97718542009-04-08 22:53:13 -0700456 return ret;
457}
458
Brian Norriscc26c3c2010-08-24 18:12:00 -0700459/*
Boris Brezillonaab616e2016-02-04 10:16:18 +0100460 * Copies (and truncates, if necessary) OOB layout information to the
461 * deprecated layout struct, nand_ecclayout_user. This is necessary only to
462 * support the deprecated API ioctl ECCGETLAYOUT while allowing all new
463 * functionality to use mtd_ooblayout_ops flexibly (i.e. mtd_ooblayout_ops
464 * can describe any kind of OOB layout with almost zero overhead from a
465 * memory usage point of view).
Brian Norriscc26c3c2010-08-24 18:12:00 -0700466 */
Boris Brezillonc2b78452016-02-03 20:10:30 +0100467static int shrink_ecclayout(struct mtd_info *mtd,
468 struct nand_ecclayout_user *to)
Brian Norriscc26c3c2010-08-24 18:12:00 -0700469{
Boris Brezillonc2b78452016-02-03 20:10:30 +0100470 struct mtd_oob_region oobregion;
471 int i, section = 0, ret;
Brian Norriscc26c3c2010-08-24 18:12:00 -0700472
Boris Brezillonc2b78452016-02-03 20:10:30 +0100473 if (!mtd || !to)
Brian Norriscc26c3c2010-08-24 18:12:00 -0700474 return -EINVAL;
475
476 memset(to, 0, sizeof(*to));
477
Boris Brezillonc2b78452016-02-03 20:10:30 +0100478 to->eccbytes = 0;
479 for (i = 0; i < MTD_MAX_ECCPOS_ENTRIES;) {
480 u32 eccpos;
481
OuYang ZhiZhong6de56492018-03-11 15:59:07 +0800482 ret = mtd_ooblayout_ecc(mtd, section++, &oobregion);
Boris Brezillonc2b78452016-02-03 20:10:30 +0100483 if (ret < 0) {
484 if (ret != -ERANGE)
485 return ret;
486
487 break;
488 }
489
490 eccpos = oobregion.offset;
491 for (; i < MTD_MAX_ECCPOS_ENTRIES &&
492 eccpos < oobregion.offset + oobregion.length; i++) {
493 to->eccpos[i] = eccpos++;
494 to->eccbytes++;
495 }
496 }
Brian Norriscc26c3c2010-08-24 18:12:00 -0700497
498 for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES; i++) {
Boris Brezillonc2b78452016-02-03 20:10:30 +0100499 ret = mtd_ooblayout_free(mtd, i, &oobregion);
500 if (ret < 0) {
501 if (ret != -ERANGE)
502 return ret;
503
Brian Norriscc26c3c2010-08-24 18:12:00 -0700504 break;
Boris Brezillonc2b78452016-02-03 20:10:30 +0100505 }
506
507 to->oobfree[i].offset = oobregion.offset;
508 to->oobfree[i].length = oobregion.length;
509 to->oobavail += to->oobfree[i].length;
Brian Norriscc26c3c2010-08-24 18:12:00 -0700510 }
511
512 return 0;
513}
514
Boris Brezillonc2b78452016-02-03 20:10:30 +0100515static int get_oobinfo(struct mtd_info *mtd, struct nand_oobinfo *to)
516{
517 struct mtd_oob_region oobregion;
518 int i, section = 0, ret;
519
520 if (!mtd || !to)
521 return -EINVAL;
522
523 memset(to, 0, sizeof(*to));
524
525 to->eccbytes = 0;
526 for (i = 0; i < ARRAY_SIZE(to->eccpos);) {
527 u32 eccpos;
528
OuYang ZhiZhong6de56492018-03-11 15:59:07 +0800529 ret = mtd_ooblayout_ecc(mtd, section++, &oobregion);
Boris Brezillonc2b78452016-02-03 20:10:30 +0100530 if (ret < 0) {
531 if (ret != -ERANGE)
532 return ret;
533
534 break;
535 }
536
537 if (oobregion.length + i > ARRAY_SIZE(to->eccpos))
538 return -EINVAL;
539
540 eccpos = oobregion.offset;
541 for (; eccpos < oobregion.offset + oobregion.length; i++) {
542 to->eccpos[i] = eccpos++;
543 to->eccbytes++;
544 }
545 }
546
547 for (i = 0; i < 8; i++) {
548 ret = mtd_ooblayout_free(mtd, i, &oobregion);
549 if (ret < 0) {
550 if (ret != -ERANGE)
551 return ret;
552
553 break;
554 }
555
556 to->oobfree[i][0] = oobregion.offset;
557 to->oobfree[i][1] = oobregion.length;
558 }
559
560 to->useecc = MTD_NANDECC_AUTOPLACE;
561
562 return 0;
563}
564
Artem Bityutskiy969e57a2011-12-23 17:27:46 +0200565static int mtdchar_blkpg_ioctl(struct mtd_info *mtd,
Brian Norris53bb7242015-09-21 13:26:59 -0700566 struct blkpg_ioctl_arg *arg)
Roman Tereshonkovd0f79592010-09-17 13:31:42 +0300567{
Roman Tereshonkovd0f79592010-09-17 13:31:42 +0300568 struct blkpg_partition p;
569
570 if (!capable(CAP_SYS_ADMIN))
571 return -EPERM;
572
Brian Norris53bb7242015-09-21 13:26:59 -0700573 if (copy_from_user(&p, arg->data, sizeof(p)))
Roman Tereshonkovd0f79592010-09-17 13:31:42 +0300574 return -EFAULT;
575
Brian Norris53bb7242015-09-21 13:26:59 -0700576 switch (arg->op) {
Roman Tereshonkovd0f79592010-09-17 13:31:42 +0300577 case BLKPG_ADD_PARTITION:
578
Roman Tereshonkova7e93dc2010-11-23 14:17:17 +0200579 /* Only master mtd device must be used to add partitions */
580 if (mtd_is_partition(mtd))
581 return -EINVAL;
582
Brian Norris1cc8d842014-07-21 19:08:13 -0700583 /* Sanitize user input */
584 p.devname[BLKPG_DEVNAMELTH - 1] = '\0';
585
Roman Tereshonkovd0f79592010-09-17 13:31:42 +0300586 return mtd_add_partition(mtd, p.devname, p.start, p.length);
587
588 case BLKPG_DEL_PARTITION:
589
590 if (p.pno < 0)
591 return -EINVAL;
592
593 return mtd_del_partition(mtd, p.pno);
594
595 default:
596 return -EINVAL;
597 }
598}
Roman Tereshonkovd0f79592010-09-17 13:31:42 +0300599
Artem Bityutskiy969e57a2011-12-23 17:27:46 +0200600static int mtdchar_write_ioctl(struct mtd_info *mtd,
Brian Norrise99d8b02011-09-09 09:59:03 -0700601 struct mtd_write_req __user *argp)
602{
603 struct mtd_write_req req;
604 struct mtd_oob_ops ops;
Geert Uytterhoevenf62cde42014-05-01 20:40:54 +0200605 const void __user *usr_data, *usr_oob;
Brian Norrise99d8b02011-09-09 09:59:03 -0700606 int ret;
607
Geert Uytterhoevenf62cde42014-05-01 20:40:54 +0200608 if (copy_from_user(&req, argp, sizeof(req)))
Brian Norrise99d8b02011-09-09 09:59:03 -0700609 return -EFAULT;
Geert Uytterhoevenf62cde42014-05-01 20:40:54 +0200610
611 usr_data = (const void __user *)(uintptr_t)req.usr_data;
612 usr_oob = (const void __user *)(uintptr_t)req.usr_oob;
Geert Uytterhoevenf62cde42014-05-01 20:40:54 +0200613
Artem Bityutskiy3c3c10b2012-01-30 14:58:32 +0200614 if (!mtd->_write_oob)
Brian Norrise99d8b02011-09-09 09:59:03 -0700615 return -EOPNOTSUPP;
616
617 ops.mode = req.mode;
618 ops.len = (size_t)req.len;
619 ops.ooblen = (size_t)req.ooblen;
620 ops.ooboffs = 0;
621
Geert Uytterhoevenf62cde42014-05-01 20:40:54 +0200622 if (usr_data) {
Brian Norrise99d8b02011-09-09 09:59:03 -0700623 ops.datbuf = memdup_user(usr_data, ops.len);
624 if (IS_ERR(ops.datbuf))
625 return PTR_ERR(ops.datbuf);
626 } else {
627 ops.datbuf = NULL;
628 }
629
Geert Uytterhoevenf62cde42014-05-01 20:40:54 +0200630 if (usr_oob) {
Brian Norrise99d8b02011-09-09 09:59:03 -0700631 ops.oobbuf = memdup_user(usr_oob, ops.ooblen);
632 if (IS_ERR(ops.oobbuf)) {
633 kfree(ops.datbuf);
634 return PTR_ERR(ops.oobbuf);
635 }
636 } else {
637 ops.oobbuf = NULL;
638 }
639
Artem Bityutskiya2cc5ba2011-12-23 18:29:55 +0200640 ret = mtd_write_oob(mtd, (loff_t)req.start, &ops);
Brian Norrise99d8b02011-09-09 09:59:03 -0700641
642 kfree(ops.datbuf);
643 kfree(ops.oobbuf);
644
645 return ret;
646}
647
Artem Bityutskiy969e57a2011-12-23 17:27:46 +0200648static int mtdchar_ioctl(struct file *file, u_int cmd, u_long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649{
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200650 struct mtd_file_info *mfi = file->private_data;
651 struct mtd_info *mtd = mfi->mtd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 void __user *argp = (void __user *)arg;
653 int ret = 0;
Joern Engel73c619e2006-05-30 14:25:35 +0200654 struct mtd_info_user info;
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000655
Brian Norris289c0522011-07-19 10:06:09 -0700656 pr_debug("MTD_ioctl\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 switch (cmd) {
659 case MEMGETREGIONCOUNT:
660 if (copy_to_user(argp, &(mtd->numeraseregions), sizeof(int)))
661 return -EFAULT;
662 break;
663
664 case MEMGETREGIONINFO:
665 {
Zev Weissb67c5f82008-09-01 05:02:12 -0700666 uint32_t ur_idx;
667 struct mtd_erase_region_info *kr;
H Hartley Sweetenbcc98a42010-01-15 11:25:38 -0700668 struct region_info_user __user *ur = argp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669
Zev Weissb67c5f82008-09-01 05:02:12 -0700670 if (get_user(ur_idx, &(ur->regionindex)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 return -EFAULT;
672
Dan Carpenter5e59be12010-09-08 21:39:56 +0200673 if (ur_idx >= mtd->numeraseregions)
674 return -EINVAL;
675
Zev Weissb67c5f82008-09-01 05:02:12 -0700676 kr = &(mtd->eraseregions[ur_idx]);
677
678 if (put_user(kr->offset, &(ur->offset))
679 || put_user(kr->erasesize, &(ur->erasesize))
680 || put_user(kr->numblocks, &(ur->numblocks)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 return -EFAULT;
Zev Weissb67c5f82008-09-01 05:02:12 -0700682
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 break;
684 }
685
686 case MEMGETINFO:
Vasiliy Kulikova0c5a392010-11-06 17:41:24 +0300687 memset(&info, 0, sizeof(info));
Joern Engel73c619e2006-05-30 14:25:35 +0200688 info.type = mtd->type;
689 info.flags = mtd->flags;
690 info.size = mtd->size;
691 info.erasesize = mtd->erasesize;
692 info.writesize = mtd->writesize;
693 info.oobsize = mtd->oobsize;
Brian Norris19fb4342011-08-30 18:45:46 -0700694 /* The below field is obsolete */
695 info.padding = 0;
Joern Engel73c619e2006-05-30 14:25:35 +0200696 if (copy_to_user(argp, &info, sizeof(struct mtd_info_user)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 return -EFAULT;
698 break;
699
700 case MEMERASE:
Kevin Cernekee0dc54e92009-04-08 22:52:28 -0700701 case MEMERASE64:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 {
703 struct erase_info *erase;
704
Al Viroaeb5d722008-09-02 15:28:45 -0400705 if(!(file->f_mode & FMODE_WRITE))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 return -EPERM;
707
Burman Yan95b93a02006-11-15 21:10:29 +0200708 erase=kzalloc(sizeof(struct erase_info),GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 if (!erase)
710 ret = -ENOMEM;
711 else {
Kevin Cernekee0dc54e92009-04-08 22:52:28 -0700712 if (cmd == MEMERASE64) {
713 struct erase_info_user64 einfo64;
714
715 if (copy_from_user(&einfo64, argp,
716 sizeof(struct erase_info_user64))) {
717 kfree(erase);
718 return -EFAULT;
719 }
720 erase->addr = einfo64.start;
721 erase->len = einfo64.length;
722 } else {
723 struct erase_info_user einfo32;
724
725 if (copy_from_user(&einfo32, argp,
726 sizeof(struct erase_info_user))) {
727 kfree(erase);
728 return -EFAULT;
729 }
730 erase->addr = einfo32.start;
731 erase->len = einfo32.length;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 }
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000733
Artem Bityutskiy7e1f0dc2011-12-23 15:25:39 +0200734 ret = mtd_erase(mtd, erase);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 kfree(erase);
736 }
737 break;
738 }
739
740 case MEMWRITEOOB:
741 {
742 struct mtd_oob_buf buf;
Kevin Cernekee97718542009-04-08 22:53:13 -0700743 struct mtd_oob_buf __user *buf_user = argp;
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000744
Kevin Cernekee97718542009-04-08 22:53:13 -0700745 /* NOTE: writes return length to buf_user->length */
746 if (copy_from_user(&buf, argp, sizeof(buf)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747 ret = -EFAULT;
Kevin Cernekee97718542009-04-08 22:53:13 -0700748 else
Artem Bityutskiy969e57a2011-12-23 17:27:46 +0200749 ret = mtdchar_writeoob(file, mtd, buf.start, buf.length,
Kevin Cernekee97718542009-04-08 22:53:13 -0700750 buf.ptr, &buf_user->length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 }
753
754 case MEMREADOOB:
755 {
756 struct mtd_oob_buf buf;
Kevin Cernekee97718542009-04-08 22:53:13 -0700757 struct mtd_oob_buf __user *buf_user = argp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758
Kevin Cernekee97718542009-04-08 22:53:13 -0700759 /* NOTE: writes return length to buf_user->start */
760 if (copy_from_user(&buf, argp, sizeof(buf)))
761 ret = -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 else
Artem Bityutskiy969e57a2011-12-23 17:27:46 +0200763 ret = mtdchar_readoob(file, mtd, buf.start, buf.length,
Kevin Cernekee97718542009-04-08 22:53:13 -0700764 buf.ptr, &buf_user->start);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 break;
766 }
767
Kevin Cernekeeaea7cea2009-04-08 22:53:49 -0700768 case MEMWRITEOOB64:
769 {
770 struct mtd_oob_buf64 buf;
771 struct mtd_oob_buf64 __user *buf_user = argp;
772
773 if (copy_from_user(&buf, argp, sizeof(buf)))
774 ret = -EFAULT;
775 else
Artem Bityutskiy969e57a2011-12-23 17:27:46 +0200776 ret = mtdchar_writeoob(file, mtd, buf.start, buf.length,
Kevin Cernekeeaea7cea2009-04-08 22:53:49 -0700777 (void __user *)(uintptr_t)buf.usr_ptr,
778 &buf_user->length);
779 break;
780 }
781
782 case MEMREADOOB64:
783 {
784 struct mtd_oob_buf64 buf;
785 struct mtd_oob_buf64 __user *buf_user = argp;
786
787 if (copy_from_user(&buf, argp, sizeof(buf)))
788 ret = -EFAULT;
789 else
Artem Bityutskiy969e57a2011-12-23 17:27:46 +0200790 ret = mtdchar_readoob(file, mtd, buf.start, buf.length,
Kevin Cernekeeaea7cea2009-04-08 22:53:49 -0700791 (void __user *)(uintptr_t)buf.usr_ptr,
792 &buf_user->length);
793 break;
794 }
795
Brian Norrise99d8b02011-09-09 09:59:03 -0700796 case MEMWRITE:
797 {
Artem Bityutskiy969e57a2011-12-23 17:27:46 +0200798 ret = mtdchar_write_ioctl(mtd,
Brian Norrise99d8b02011-09-09 09:59:03 -0700799 (struct mtd_write_req __user *)arg);
800 break;
801 }
802
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 case MEMLOCK:
804 {
Harvey Harrison175428b2008-07-03 23:40:14 -0700805 struct erase_info_user einfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806
Harvey Harrison175428b2008-07-03 23:40:14 -0700807 if (copy_from_user(&einfo, argp, sizeof(einfo)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 return -EFAULT;
809
Artem Bityutskiy38134562011-12-30 17:00:35 +0200810 ret = mtd_lock(mtd, einfo.start, einfo.length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 break;
812 }
813
814 case MEMUNLOCK:
815 {
Harvey Harrison175428b2008-07-03 23:40:14 -0700816 struct erase_info_user einfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817
Harvey Harrison175428b2008-07-03 23:40:14 -0700818 if (copy_from_user(&einfo, argp, sizeof(einfo)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 return -EFAULT;
820
Artem Bityutskiy38134562011-12-30 17:00:35 +0200821 ret = mtd_unlock(mtd, einfo.start, einfo.length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 break;
823 }
824
Richard Cochran99384242010-06-14 18:10:33 +0200825 case MEMISLOCKED:
826 {
827 struct erase_info_user einfo;
828
829 if (copy_from_user(&einfo, argp, sizeof(einfo)))
830 return -EFAULT;
831
Artem Bityutskiy38134562011-12-30 17:00:35 +0200832 ret = mtd_is_locked(mtd, einfo.start, einfo.length);
Richard Cochran99384242010-06-14 18:10:33 +0200833 break;
834 }
835
Thomas Gleixner5bd34c02006-05-27 22:16:10 +0200836 /* Legacy interface */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 case MEMGETOOBSEL:
838 {
Thomas Gleixner5bd34c02006-05-27 22:16:10 +0200839 struct nand_oobinfo oi;
840
Boris Brezillonadbbc3b2016-02-03 19:01:31 +0100841 if (!mtd->ooblayout)
Thomas Gleixner5bd34c02006-05-27 22:16:10 +0200842 return -EOPNOTSUPP;
Thomas Gleixner5bd34c02006-05-27 22:16:10 +0200843
Boris Brezillonc2b78452016-02-03 20:10:30 +0100844 ret = get_oobinfo(mtd, &oi);
845 if (ret)
846 return ret;
Thomas Gleixner5bd34c02006-05-27 22:16:10 +0200847
848 if (copy_to_user(argp, &oi, sizeof(struct nand_oobinfo)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849 return -EFAULT;
850 break;
851 }
852
853 case MEMGETBADBLOCK:
854 {
855 loff_t offs;
Thomas Gleixner97894cd2005-11-07 11:15:26 +0000856
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 if (copy_from_user(&offs, argp, sizeof(loff_t)))
858 return -EFAULT;
Artem Bityutskiy8f461a72012-01-02 13:48:54 +0200859 return mtd_block_isbad(mtd, offs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 break;
861 }
862
863 case MEMSETBADBLOCK:
864 {
865 loff_t offs;
866
867 if (copy_from_user(&offs, argp, sizeof(loff_t)))
868 return -EFAULT;
Artem Bityutskiy800ffd32012-01-02 13:59:12 +0200869 return mtd_block_markbad(mtd, offs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 break;
871 }
872
Nicolas Pitre31f42332005-02-08 17:45:55 +0000873 case OTPSELECT:
874 {
875 int mode;
876 if (copy_from_user(&mode, argp, sizeof(int)))
877 return -EFAULT;
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200878
Brian Norrisbeb133f2011-08-30 18:45:41 -0700879 mfi->mode = MTD_FILE_MODE_NORMAL;
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200880
881 ret = otp_select_filemode(mfi, mode);
882
Nicolas Pitre81dba482005-04-01 16:36:15 +0100883 file->f_pos = 0;
Nicolas Pitre31f42332005-02-08 17:45:55 +0000884 break;
885 }
886
887 case OTPGETREGIONCOUNT:
888 case OTPGETREGIONINFO:
889 {
890 struct otp_info *buf = kmalloc(4096, GFP_KERNEL);
Christian Riesch4b78fc42f2014-01-28 09:29:44 +0100891 size_t retlen;
Nicolas Pitre31f42332005-02-08 17:45:55 +0000892 if (!buf)
893 return -ENOMEM;
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200894 switch (mfi->mode) {
Brian Norrisbeb133f2011-08-30 18:45:41 -0700895 case MTD_FILE_MODE_OTP_FACTORY:
Christian Riesch4b78fc42f2014-01-28 09:29:44 +0100896 ret = mtd_get_fact_prot_info(mtd, 4096, &retlen, buf);
Nicolas Pitre31f42332005-02-08 17:45:55 +0000897 break;
Brian Norrisbeb133f2011-08-30 18:45:41 -0700898 case MTD_FILE_MODE_OTP_USER:
Christian Riesch4b78fc42f2014-01-28 09:29:44 +0100899 ret = mtd_get_user_prot_info(mtd, 4096, &retlen, buf);
Nicolas Pitre31f42332005-02-08 17:45:55 +0000900 break;
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200901 default:
Artem Bityutskiy87e858a92011-12-28 18:47:46 +0200902 ret = -EINVAL;
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200903 break;
Nicolas Pitre31f42332005-02-08 17:45:55 +0000904 }
Christian Riesch4b78fc42f2014-01-28 09:29:44 +0100905 if (!ret) {
Nicolas Pitre31f42332005-02-08 17:45:55 +0000906 if (cmd == OTPGETREGIONCOUNT) {
Christian Riesch4b78fc42f2014-01-28 09:29:44 +0100907 int nbr = retlen / sizeof(struct otp_info);
Nicolas Pitre31f42332005-02-08 17:45:55 +0000908 ret = copy_to_user(argp, &nbr, sizeof(int));
909 } else
Christian Riesch4b78fc42f2014-01-28 09:29:44 +0100910 ret = copy_to_user(argp, buf, retlen);
Nicolas Pitre31f42332005-02-08 17:45:55 +0000911 if (ret)
912 ret = -EFAULT;
913 }
914 kfree(buf);
915 break;
916 }
917
918 case OTPLOCK:
919 {
Harvey Harrison175428b2008-07-03 23:40:14 -0700920 struct otp_info oinfo;
Nicolas Pitre31f42332005-02-08 17:45:55 +0000921
Brian Norrisbeb133f2011-08-30 18:45:41 -0700922 if (mfi->mode != MTD_FILE_MODE_OTP_USER)
Nicolas Pitre31f42332005-02-08 17:45:55 +0000923 return -EINVAL;
Harvey Harrison175428b2008-07-03 23:40:14 -0700924 if (copy_from_user(&oinfo, argp, sizeof(oinfo)))
Nicolas Pitre31f42332005-02-08 17:45:55 +0000925 return -EFAULT;
Artem Bityutskiy4403dbfb2011-12-23 18:55:49 +0200926 ret = mtd_lock_user_prot_reg(mtd, oinfo.start, oinfo.length);
Nicolas Pitre31f42332005-02-08 17:45:55 +0000927 break;
928 }
Nicolas Pitre31f42332005-02-08 17:45:55 +0000929
Brian Norris7854d3f2011-06-23 14:12:08 -0700930 /* This ioctl is being deprecated - it truncates the ECC layout */
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200931 case ECCGETLAYOUT:
932 {
Brian Norriscc26c3c2010-08-24 18:12:00 -0700933 struct nand_ecclayout_user *usrlay;
934
Boris Brezillonadbbc3b2016-02-03 19:01:31 +0100935 if (!mtd->ooblayout)
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200936 return -EOPNOTSUPP;
937
Brian Norriscc26c3c2010-08-24 18:12:00 -0700938 usrlay = kmalloc(sizeof(*usrlay), GFP_KERNEL);
939 if (!usrlay)
940 return -ENOMEM;
941
Boris Brezillonc2b78452016-02-03 20:10:30 +0100942 shrink_ecclayout(mtd, usrlay);
Brian Norriscc26c3c2010-08-24 18:12:00 -0700943
944 if (copy_to_user(argp, usrlay, sizeof(*usrlay)))
945 ret = -EFAULT;
946 kfree(usrlay);
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200947 break;
948 }
949
950 case ECCGETSTATS:
951 {
952 if (copy_to_user(argp, &mtd->ecc_stats,
953 sizeof(struct mtd_ecc_stats)))
954 return -EFAULT;
955 break;
956 }
957
958 case MTDFILEMODE:
959 {
960 mfi->mode = 0;
961
962 switch(arg) {
Brian Norrisbeb133f2011-08-30 18:45:41 -0700963 case MTD_FILE_MODE_OTP_FACTORY:
964 case MTD_FILE_MODE_OTP_USER:
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200965 ret = otp_select_filemode(mfi, arg);
966 break;
967
Brian Norrisbeb133f2011-08-30 18:45:41 -0700968 case MTD_FILE_MODE_RAW:
Artem Bityutskiyfc002e32011-12-28 18:35:07 +0200969 if (!mtd_has_oob(mtd))
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200970 return -EOPNOTSUPP;
971 mfi->mode = arg;
972
Brian Norrisbeb133f2011-08-30 18:45:41 -0700973 case MTD_FILE_MODE_NORMAL:
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200974 break;
975 default:
976 ret = -EINVAL;
977 }
978 file->f_pos = 0;
979 break;
980 }
981
Roman Tereshonkovd0f79592010-09-17 13:31:42 +0300982 case BLKPG:
983 {
Brian Norris53bb7242015-09-21 13:26:59 -0700984 struct blkpg_ioctl_arg __user *blk_arg = argp;
985 struct blkpg_ioctl_arg a;
986
987 if (copy_from_user(&a, blk_arg, sizeof(a)))
988 ret = -EFAULT;
989 else
990 ret = mtdchar_blkpg_ioctl(mtd, &a);
Roman Tereshonkovd0f79592010-09-17 13:31:42 +0300991 break;
992 }
993
994 case BLKRRPART:
995 {
996 /* No reread partition feature. Just return ok */
997 ret = 0;
998 break;
999 }
Roman Tereshonkovd0f79592010-09-17 13:31:42 +03001000
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001 default:
1002 ret = -ENOTTY;
1003 }
1004
1005 return ret;
1006} /* memory_ioctl */
1007
Artem Bityutskiy969e57a2011-12-23 17:27:46 +02001008static long mtdchar_unlocked_ioctl(struct file *file, u_int cmd, u_long arg)
Arnd Bergmann55929332010-04-27 00:24:05 +02001009{
1010 int ret;
1011
Arnd Bergmann5aa82942010-06-02 14:28:52 +02001012 mutex_lock(&mtd_mutex);
Artem Bityutskiy969e57a2011-12-23 17:27:46 +02001013 ret = mtdchar_ioctl(file, cmd, arg);
Arnd Bergmann5aa82942010-06-02 14:28:52 +02001014 mutex_unlock(&mtd_mutex);
Arnd Bergmann55929332010-04-27 00:24:05 +02001015
1016 return ret;
1017}
1018
Kevin Cernekee97718542009-04-08 22:53:13 -07001019#ifdef CONFIG_COMPAT
1020
1021struct mtd_oob_buf32 {
1022 u_int32_t start;
1023 u_int32_t length;
1024 compat_caddr_t ptr; /* unsigned char* */
1025};
1026
1027#define MEMWRITEOOB32 _IOWR('M', 3, struct mtd_oob_buf32)
1028#define MEMREADOOB32 _IOWR('M', 4, struct mtd_oob_buf32)
1029
Artem Bityutskiy969e57a2011-12-23 17:27:46 +02001030static long mtdchar_compat_ioctl(struct file *file, unsigned int cmd,
Kevin Cernekee97718542009-04-08 22:53:13 -07001031 unsigned long arg)
1032{
1033 struct mtd_file_info *mfi = file->private_data;
1034 struct mtd_info *mtd = mfi->mtd;
David Woodhouse0b6585c2009-05-29 16:09:08 +01001035 void __user *argp = compat_ptr(arg);
Kevin Cernekee97718542009-04-08 22:53:13 -07001036 int ret = 0;
1037
Arnd Bergmann5aa82942010-06-02 14:28:52 +02001038 mutex_lock(&mtd_mutex);
Kevin Cernekee97718542009-04-08 22:53:13 -07001039
1040 switch (cmd) {
1041 case MEMWRITEOOB32:
1042 {
1043 struct mtd_oob_buf32 buf;
1044 struct mtd_oob_buf32 __user *buf_user = argp;
1045
1046 if (copy_from_user(&buf, argp, sizeof(buf)))
1047 ret = -EFAULT;
1048 else
Artem Bityutskiy969e57a2011-12-23 17:27:46 +02001049 ret = mtdchar_writeoob(file, mtd, buf.start,
Kevin Cernekee97718542009-04-08 22:53:13 -07001050 buf.length, compat_ptr(buf.ptr),
1051 &buf_user->length);
1052 break;
1053 }
1054
1055 case MEMREADOOB32:
1056 {
1057 struct mtd_oob_buf32 buf;
1058 struct mtd_oob_buf32 __user *buf_user = argp;
1059
1060 /* NOTE: writes return length to buf->start */
1061 if (copy_from_user(&buf, argp, sizeof(buf)))
1062 ret = -EFAULT;
1063 else
Artem Bityutskiy969e57a2011-12-23 17:27:46 +02001064 ret = mtdchar_readoob(file, mtd, buf.start,
Kevin Cernekee97718542009-04-08 22:53:13 -07001065 buf.length, compat_ptr(buf.ptr),
1066 &buf_user->start);
1067 break;
1068 }
Brian Norris53bb7242015-09-21 13:26:59 -07001069
1070 case BLKPG:
1071 {
1072 /* Convert from blkpg_compat_ioctl_arg to blkpg_ioctl_arg */
1073 struct blkpg_compat_ioctl_arg __user *uarg = argp;
1074 struct blkpg_compat_ioctl_arg compat_arg;
1075 struct blkpg_ioctl_arg a;
1076
1077 if (copy_from_user(&compat_arg, uarg, sizeof(compat_arg))) {
1078 ret = -EFAULT;
1079 break;
1080 }
1081
1082 memset(&a, 0, sizeof(a));
1083 a.op = compat_arg.op;
1084 a.flags = compat_arg.flags;
1085 a.datalen = compat_arg.datalen;
1086 a.data = compat_ptr(compat_arg.data);
1087
1088 ret = mtdchar_blkpg_ioctl(mtd, &a);
1089 break;
1090 }
1091
Kevin Cernekee97718542009-04-08 22:53:13 -07001092 default:
Artem Bityutskiy969e57a2011-12-23 17:27:46 +02001093 ret = mtdchar_ioctl(file, cmd, (unsigned long)argp);
Kevin Cernekee97718542009-04-08 22:53:13 -07001094 }
1095
Arnd Bergmann5aa82942010-06-02 14:28:52 +02001096 mutex_unlock(&mtd_mutex);
Kevin Cernekee97718542009-04-08 22:53:13 -07001097
1098 return ret;
1099}
1100
1101#endif /* CONFIG_COMPAT */
1102
David Howells402d3262009-02-12 10:40:00 +00001103/*
1104 * try to determine where a shared mapping can be made
1105 * - only supported for NOMMU at the moment (MMU can't doesn't copy private
1106 * mappings)
1107 */
1108#ifndef CONFIG_MMU
Artem Bityutskiy969e57a2011-12-23 17:27:46 +02001109static unsigned long mtdchar_get_unmapped_area(struct file *file,
David Howells402d3262009-02-12 10:40:00 +00001110 unsigned long addr,
1111 unsigned long len,
1112 unsigned long pgoff,
1113 unsigned long flags)
1114{
1115 struct mtd_file_info *mfi = file->private_data;
1116 struct mtd_info *mtd = mfi->mtd;
Artem Bityutskiycd621272011-12-30 14:31:57 +02001117 unsigned long offset;
1118 int ret;
David Howells402d3262009-02-12 10:40:00 +00001119
Artem Bityutskiycd621272011-12-30 14:31:57 +02001120 if (addr != 0)
1121 return (unsigned long) -EINVAL;
David Howells402d3262009-02-12 10:40:00 +00001122
Artem Bityutskiycd621272011-12-30 14:31:57 +02001123 if (len > mtd->size || pgoff >= (mtd->size >> PAGE_SHIFT))
1124 return (unsigned long) -EINVAL;
David Howells402d3262009-02-12 10:40:00 +00001125
Artem Bityutskiycd621272011-12-30 14:31:57 +02001126 offset = pgoff << PAGE_SHIFT;
1127 if (offset > mtd->size - len)
1128 return (unsigned long) -EINVAL;
David Howells402d3262009-02-12 10:40:00 +00001129
Artem Bityutskiycd621272011-12-30 14:31:57 +02001130 ret = mtd_get_unmapped_area(mtd, len, offset, flags);
Vladimir Zapolskiyb9995932013-10-28 18:08:15 +02001131 return ret == -EOPNOTSUPP ? -ENODEV : ret;
David Howells402d3262009-02-12 10:40:00 +00001132}
Christoph Hellwigb4caecd2015-01-14 10:42:32 +01001133
1134static unsigned mtdchar_mmap_capabilities(struct file *file)
1135{
1136 struct mtd_file_info *mfi = file->private_data;
1137
1138 return mtd_mmap_capabilities(mfi->mtd);
1139}
David Howells402d3262009-02-12 10:40:00 +00001140#endif
1141
1142/*
1143 * set up a mapping for shared memory segments
1144 */
Artem Bityutskiy969e57a2011-12-23 17:27:46 +02001145static int mtdchar_mmap(struct file *file, struct vm_area_struct *vma)
David Howells402d3262009-02-12 10:40:00 +00001146{
1147#ifdef CONFIG_MMU
1148 struct mtd_file_info *mfi = file->private_data;
1149 struct mtd_info *mtd = mfi->mtd;
Anatolij Gustschindd02b672010-06-15 09:30:15 +02001150 struct map_info *map = mtd->priv;
David Howells402d3262009-02-12 10:40:00 +00001151
David Woodhousef5cf8f02012-10-09 15:08:10 +01001152 /* This is broken because it assumes the MTD device is map-based
1153 and that mtd->priv is a valid struct map_info. It should be
1154 replaced with something that uses the mtd_get_unmapped_area()
1155 operation properly. */
1156 if (0 /*mtd->type == MTD_RAM || mtd->type == MTD_ROM*/) {
Anatolij Gustschindd02b672010-06-15 09:30:15 +02001157#ifdef pgprot_noncached
Linus Torvalds8558e4a2013-04-19 09:53:07 -07001158 if (file->f_flags & O_DSYNC || map->phys >= __pa(high_memory))
Anatolij Gustschindd02b672010-06-15 09:30:15 +02001159 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
1160#endif
Linus Torvalds8558e4a2013-04-19 09:53:07 -07001161 return vm_iomap_memory(vma, map->phys, map->size);
Anatolij Gustschindd02b672010-06-15 09:30:15 +02001162 }
Vladimir Zapolskiyb9995932013-10-28 18:08:15 +02001163 return -ENODEV;
David Howells402d3262009-02-12 10:40:00 +00001164#else
Vladimir Zapolskiyb9995932013-10-28 18:08:15 +02001165 return vma->vm_flags & VM_SHARED ? 0 : -EACCES;
David Howells402d3262009-02-12 10:40:00 +00001166#endif
1167}
1168
Arjan van de Vend54b1fd2007-02-12 00:55:34 -08001169static const struct file_operations mtd_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170 .owner = THIS_MODULE,
Artem Bityutskiy969e57a2011-12-23 17:27:46 +02001171 .llseek = mtdchar_lseek,
1172 .read = mtdchar_read,
1173 .write = mtdchar_write,
1174 .unlocked_ioctl = mtdchar_unlocked_ioctl,
Kevin Cernekee97718542009-04-08 22:53:13 -07001175#ifdef CONFIG_COMPAT
Artem Bityutskiy969e57a2011-12-23 17:27:46 +02001176 .compat_ioctl = mtdchar_compat_ioctl,
Kevin Cernekee97718542009-04-08 22:53:13 -07001177#endif
Artem Bityutskiy969e57a2011-12-23 17:27:46 +02001178 .open = mtdchar_open,
1179 .release = mtdchar_close,
1180 .mmap = mtdchar_mmap,
David Howells402d3262009-02-12 10:40:00 +00001181#ifndef CONFIG_MMU
Artem Bityutskiy969e57a2011-12-23 17:27:46 +02001182 .get_unmapped_area = mtdchar_get_unmapped_area,
Christoph Hellwigb4caecd2015-01-14 10:42:32 +01001183 .mmap_capabilities = mtdchar_mmap_capabilities,
David Howells402d3262009-02-12 10:40:00 +00001184#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185};
1186
Artem Bityutskiy660685d2013-03-14 13:27:40 +02001187int __init init_mtdchar(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188{
Kirill A. Shutemovcd874232010-05-17 16:55:47 +03001189 int ret;
David Brownell1f24b5a2009-03-26 00:42:41 -07001190
Kirill A. Shutemovcd874232010-05-17 16:55:47 +03001191 ret = __register_chrdev(MTD_CHAR_MAJOR, 0, 1 << MINORBITS,
Ben Hutchingsdad0db32010-01-29 21:00:04 +00001192 "mtd", &mtd_fops);
Kirill A. Shutemovcd874232010-05-17 16:55:47 +03001193 if (ret < 0) {
Artem Bityutskiy57ae2b62013-03-15 12:59:36 +02001194 pr_err("Can't allocate major number %d for MTD\n",
1195 MTD_CHAR_MAJOR);
Kirill A. Shutemovcd874232010-05-17 16:55:47 +03001196 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197 }
1198
Kirill A. Shutemovcd874232010-05-17 16:55:47 +03001199 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200}
1201
Artem Bityutskiy660685d2013-03-14 13:27:40 +02001202void __exit cleanup_mtdchar(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203{
Ben Hutchingsdad0db32010-01-29 21:00:04 +00001204 __unregister_chrdev(MTD_CHAR_MAJOR, 0, 1 << MINORBITS, "mtd");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205}
1206
Scott James Remnant90160e12009-03-02 18:42:39 +00001207MODULE_ALIAS_CHARDEV_MAJOR(MTD_CHAR_MAJOR);