Version:  2.0.40 2.2.26 2.4.37 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1

Linux/drivers/mtd/mtdchar.c

  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/magic.h>
 35 #include <linux/major.h>
 36 #include <linux/mtd/mtd.h>
 37 #include <linux/mtd/partitions.h>
 38 #include <linux/mtd/map.h>
 39 
 40 #include <asm/uaccess.h>
 41 
 42 #include "mtdcore.h"
 43 
 44 static DEFINE_MUTEX(mtd_mutex);
 45 
 46 /*
 47  * Data structure to hold the pointer to the mtd device as well
 48  * as mode information of various use cases.
 49  */
 50 struct mtd_file_info {
 51         struct mtd_info *mtd;
 52         enum mtd_file_modes mode;
 53 };
 54 
 55 static loff_t mtdchar_lseek(struct file *file, loff_t offset, int orig)
 56 {
 57         struct mtd_file_info *mfi = file->private_data;
 58         return fixed_size_llseek(file, offset, orig, mfi->mtd->size);
 59 }
 60 
 61 static int mtdchar_open(struct inode *inode, struct file *file)
 62 {
 63         int minor = iminor(inode);
 64         int devnum = minor >> 1;
 65         int ret = 0;
 66         struct mtd_info *mtd;
 67         struct mtd_file_info *mfi;
 68 
 69         pr_debug("MTD_open\n");
 70 
 71         /* You can't open the RO devices RW */
 72         if ((file->f_mode & FMODE_WRITE) && (minor & 1))
 73                 return -EACCES;
 74 
 75         mutex_lock(&mtd_mutex);
 76         mtd = get_mtd_device(NULL, devnum);
 77 
 78         if (IS_ERR(mtd)) {
 79                 ret = PTR_ERR(mtd);
 80                 goto out;
 81         }
 82 
 83         if (mtd->type == MTD_ABSENT) {
 84                 ret = -ENODEV;
 85                 goto out1;
 86         }
 87 
 88         /* You can't open it RW if it's not a writeable device */
 89         if ((file->f_mode & FMODE_WRITE) && !(mtd->flags & MTD_WRITEABLE)) {
 90                 ret = -EACCES;
 91                 goto out1;
 92         }
 93 
 94         mfi = kzalloc(sizeof(*mfi), GFP_KERNEL);
 95         if (!mfi) {
 96                 ret = -ENOMEM;
 97                 goto out1;
 98         }
 99         mfi->mtd = mtd;
100         file->private_data = mfi;
101         mutex_unlock(&mtd_mutex);
102         return 0;
103 
104 out1:
105         put_mtd_device(mtd);
106 out:
107         mutex_unlock(&mtd_mutex);
108         return ret;
109 } /* mtdchar_open */
110 
111 /*====================================================================*/
112 
113 static int mtdchar_close(struct inode *inode, struct file *file)
114 {
115         struct mtd_file_info *mfi = file->private_data;
116         struct mtd_info *mtd = mfi->mtd;
117 
118         pr_debug("MTD_close\n");
119 
120         /* Only sync if opened RW */
121         if ((file->f_mode & FMODE_WRITE))
122                 mtd_sync(mtd);
123 
124         put_mtd_device(mtd);
125         file->private_data = NULL;
126         kfree(mfi);
127 
128         return 0;
129 } /* mtdchar_close */
130 
131 /* 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  */
148 
149 static ssize_t mtdchar_read(struct file *file, char __user *buf, size_t count,
150                         loff_t *ppos)
151 {
152         struct mtd_file_info *mfi = file->private_data;
153         struct mtd_info *mtd = mfi->mtd;
154         size_t retlen;
155         size_t total_retlen=0;
156         int ret=0;
157         int len;
158         size_t size = count;
159         char *kbuf;
160 
161         pr_debug("MTD_read\n");
162 
163         if (*ppos + count > mtd->size)
164                 count = mtd->size - *ppos;
165 
166         if (!count)
167                 return 0;
168 
169         kbuf = mtd_kmalloc_up_to(mtd, &size);
170         if (!kbuf)
171                 return -ENOMEM;
172 
173         while (count) {
174                 len = min_t(size_t, count, size);
175 
176                 switch (mfi->mode) {
177                 case MTD_FILE_MODE_OTP_FACTORY:
178                         ret = mtd_read_fact_prot_reg(mtd, *ppos, len,
179                                                      &retlen, kbuf);
180                         break;
181                 case MTD_FILE_MODE_OTP_USER:
182                         ret = mtd_read_user_prot_reg(mtd, *ppos, len,
183                                                      &retlen, kbuf);
184                         break;
185                 case MTD_FILE_MODE_RAW:
186                 {
187                         struct mtd_oob_ops ops;
188 
189                         ops.mode = MTD_OPS_RAW;
190                         ops.datbuf = kbuf;
191                         ops.oobbuf = NULL;
192                         ops.len = len;
193 
194                         ret = mtd_read_oob(mtd, *ppos, &ops);
195                         retlen = ops.retlen;
196                         break;
197                 }
198                 default:
199                         ret = mtd_read(mtd, *ppos, len, &retlen, kbuf);
200                 }
201                 /* Nand returns -EBADMSG on ECC errors, but it returns
202                  * the data. For our userspace tools it is important
203                  * to dump areas with ECC errors!
204                  * For kernel internal usage it also might return -EUCLEAN
205                  * to signal the caller that a bitflip has occurred and has
206                  * been corrected by the ECC algorithm.
207                  * Userspace software which accesses NAND this way
208                  * must be aware of the fact that it deals with NAND
209                  */
210                 if (!ret || mtd_is_bitflip_or_eccerr(ret)) {
211                         *ppos += retlen;
212                         if (copy_to_user(buf, kbuf, retlen)) {
213                                 kfree(kbuf);
214                                 return -EFAULT;
215                         }
216                         else
217                                 total_retlen += retlen;
218 
219                         count -= retlen;
220                         buf += retlen;
221                         if (retlen == 0)
222                                 count = 0;
223                 }
224                 else {
225                         kfree(kbuf);
226                         return ret;
227                 }
228 
229         }
230 
231         kfree(kbuf);
232         return total_retlen;
233 } /* mtdchar_read */
234 
235 static ssize_t mtdchar_write(struct file *file, const char __user *buf, size_t count,
236                         loff_t *ppos)
237 {
238         struct mtd_file_info *mfi = file->private_data;
239         struct mtd_info *mtd = mfi->mtd;
240         size_t size = count;
241         char *kbuf;
242         size_t retlen;
243         size_t total_retlen=0;
244         int ret=0;
245         int len;
246 
247         pr_debug("MTD_write\n");
248 
249         if (*ppos == mtd->size)
250                 return -ENOSPC;
251 
252         if (*ppos + count > mtd->size)
253                 count = mtd->size - *ppos;
254 
255         if (!count)
256                 return 0;
257 
258         kbuf = mtd_kmalloc_up_to(mtd, &size);
259         if (!kbuf)
260                 return -ENOMEM;
261 
262         while (count) {
263                 len = min_t(size_t, count, size);
264 
265                 if (copy_from_user(kbuf, buf, len)) {
266                         kfree(kbuf);
267                         return -EFAULT;
268                 }
269 
270                 switch (mfi->mode) {
271                 case MTD_FILE_MODE_OTP_FACTORY:
272                         ret = -EROFS;
273                         break;
274                 case MTD_FILE_MODE_OTP_USER:
275                         ret = mtd_write_user_prot_reg(mtd, *ppos, len,
276                                                       &retlen, kbuf);
277                         break;
278 
279                 case MTD_FILE_MODE_RAW:
280                 {
281                         struct mtd_oob_ops ops;
282 
283                         ops.mode = MTD_OPS_RAW;
284                         ops.datbuf = kbuf;
285                         ops.oobbuf = NULL;
286                         ops.ooboffs = 0;
287                         ops.len = len;
288 
289                         ret = mtd_write_oob(mtd, *ppos, &ops);
290                         retlen = ops.retlen;
291                         break;
292                 }
293 
294                 default:
295                         ret = mtd_write(mtd, *ppos, len, &retlen, kbuf);
296                 }
297 
298                 /*
299                  * Return -ENOSPC only if no data could be written at all.
300                  * Otherwise just return the number of bytes that actually
301                  * have been written.
302                  */
303                 if ((ret == -ENOSPC) && (total_retlen))
304                         break;
305 
306                 if (!ret) {
307                         *ppos += retlen;
308                         total_retlen += retlen;
309                         count -= retlen;
310                         buf += retlen;
311                 }
312                 else {
313                         kfree(kbuf);
314                         return ret;
315                 }
316         }
317 
318         kfree(kbuf);
319         return total_retlen;
320 } /* mtdchar_write */
321 
322 /*======================================================================
323 
324     IOCTL calls for getting device parameters.
325 
326 ======================================================================*/
327 static void mtdchar_erase_callback (struct erase_info *instr)
328 {
329         wake_up((wait_queue_head_t *)instr->priv);
330 }
331 
332 static int otp_select_filemode(struct mtd_file_info *mfi, int mode)
333 {
334         struct mtd_info *mtd = mfi->mtd;
335         size_t retlen;
336 
337         switch (mode) {
338         case MTD_OTP_FACTORY:
339                 if (mtd_read_fact_prot_reg(mtd, -1, 0, &retlen, NULL) ==
340                                 -EOPNOTSUPP)
341                         return -EOPNOTSUPP;
342 
343                 mfi->mode = MTD_FILE_MODE_OTP_FACTORY;
344                 break;
345         case MTD_OTP_USER:
346                 if (mtd_read_user_prot_reg(mtd, -1, 0, &retlen, NULL) ==
347                                 -EOPNOTSUPP)
348                         return -EOPNOTSUPP;
349 
350                 mfi->mode = MTD_FILE_MODE_OTP_USER;
351                 break;
352         case MTD_OTP_OFF:
353                 mfi->mode = MTD_FILE_MODE_NORMAL;
354                 break;
355         default:
356                 return -EINVAL;
357         }
358 
359         return 0;
360 }
361 
362 static int mtdchar_writeoob(struct file *file, struct mtd_info *mtd,
363         uint64_t start, uint32_t length, void __user *ptr,
364         uint32_t __user *retp)
365 {
366         struct mtd_file_info *mfi = file->private_data;
367         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 
377         if (!mtd->_write_oob)
378                 ret = -EOPNOTSUPP;
379         else
380                 ret = access_ok(VERIFY_READ, ptr, length) ? 0 : -EFAULT;
381 
382         if (ret)
383                 return ret;
384 
385         ops.ooblen = length;
386         ops.ooboffs = start & (mtd->writesize - 1);
387         ops.datbuf = NULL;
388         ops.mode = (mfi->mode == MTD_FILE_MODE_RAW) ? MTD_OPS_RAW :
389                 MTD_OPS_PLACE_OOB;
390 
391         if (ops.ooboffs && ops.ooblen > (mtd->oobsize - ops.ooboffs))
392                 return -EINVAL;
393 
394         ops.oobbuf = memdup_user(ptr, length);
395         if (IS_ERR(ops.oobbuf))
396                 return PTR_ERR(ops.oobbuf);
397 
398         start &= ~((uint64_t)mtd->writesize - 1);
399         ret = mtd_write_oob(mtd, start, &ops);
400 
401         if (ops.oobretlen > 0xFFFFFFFFU)
402                 ret = -EOVERFLOW;
403         retlen = ops.oobretlen;
404         if (copy_to_user(retp, &retlen, sizeof(length)))
405                 ret = -EFAULT;
406 
407         kfree(ops.oobbuf);
408         return ret;
409 }
410 
411 static int mtdchar_readoob(struct file *file, struct mtd_info *mtd,
412         uint64_t start, uint32_t length, void __user *ptr,
413         uint32_t __user *retp)
414 {
415         struct mtd_file_info *mfi = file->private_data;
416         struct mtd_oob_ops ops;
417         int ret = 0;
418 
419         if (length > 4096)
420                 return -EINVAL;
421 
422         if (!access_ok(VERIFY_WRITE, ptr, length))
423                 return -EFAULT;
424 
425         ops.ooblen = length;
426         ops.ooboffs = start & (mtd->writesize - 1);
427         ops.datbuf = NULL;
428         ops.mode = (mfi->mode == MTD_FILE_MODE_RAW) ? MTD_OPS_RAW :
429                 MTD_OPS_PLACE_OOB;
430 
431         if (ops.ooboffs && ops.ooblen > (mtd->oobsize - ops.ooboffs))
432                 return -EINVAL;
433 
434         ops.oobbuf = kmalloc(length, GFP_KERNEL);
435         if (!ops.oobbuf)
436                 return -ENOMEM;
437 
438         start &= ~((uint64_t)mtd->writesize - 1);
439         ret = mtd_read_oob(mtd, start, &ops);
440 
441         if (put_user(ops.oobretlen, retp))
442                 ret = -EFAULT;
443         else if (ops.oobretlen && copy_to_user(ptr, ops.oobbuf,
444                                             ops.oobretlen))
445                 ret = -EFAULT;
446 
447         kfree(ops.oobbuf);
448 
449         /*
450          * NAND returns -EBADMSG on ECC errors, but it returns the OOB
451          * data. For our userspace tools it is important to dump areas
452          * with ECC errors!
453          * For kernel internal usage it also might return -EUCLEAN
454          * to signal the caller that a bitflip has occured and has
455          * been corrected by the ECC algorithm.
456          *
457          * Note: currently the standard NAND function, nand_read_oob_std,
458          * does not calculate ECC for the OOB area, so do not rely on
459          * this behavior unless you have replaced it with your own.
460          */
461         if (mtd_is_bitflip_or_eccerr(ret))
462                 return 0;
463 
464         return ret;
465 }
466 
467 /*
468  * Copies (and truncates, if necessary) data from the larger struct,
469  * nand_ecclayout, to the smaller, deprecated layout struct,
470  * nand_ecclayout_user. This is necessary only to support the deprecated
471  * API ioctl ECCGETLAYOUT while allowing all new functionality to use
472  * nand_ecclayout flexibly (i.e. the struct may change size in new
473  * releases without requiring major rewrites).
474  */
475 static int shrink_ecclayout(const struct nand_ecclayout *from,
476                 struct nand_ecclayout_user *to)
477 {
478         int i;
479 
480         if (!from || !to)
481                 return -EINVAL;
482 
483         memset(to, 0, sizeof(*to));
484 
485         to->eccbytes = min((int)from->eccbytes, MTD_MAX_ECCPOS_ENTRIES);
486         for (i = 0; i < to->eccbytes; i++)
487                 to->eccpos[i] = from->eccpos[i];
488 
489         for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES; i++) {
490                 if (from->oobfree[i].length == 0 &&
491                                 from->oobfree[i].offset == 0)
492                         break;
493                 to->oobavail += from->oobfree[i].length;
494                 to->oobfree[i] = from->oobfree[i];
495         }
496 
497         return 0;
498 }
499 
500 static int mtdchar_blkpg_ioctl(struct mtd_info *mtd,
501                            struct blkpg_ioctl_arg __user *arg)
502 {
503         struct blkpg_ioctl_arg a;
504         struct blkpg_partition p;
505 
506         if (!capable(CAP_SYS_ADMIN))
507                 return -EPERM;
508 
509         if (copy_from_user(&a, arg, sizeof(struct blkpg_ioctl_arg)))
510                 return -EFAULT;
511 
512         if (copy_from_user(&p, a.data, sizeof(struct blkpg_partition)))
513                 return -EFAULT;
514 
515         switch (a.op) {
516         case BLKPG_ADD_PARTITION:
517 
518                 /* Only master mtd device must be used to add partitions */
519                 if (mtd_is_partition(mtd))
520                         return -EINVAL;
521 
522                 /* Sanitize user input */
523                 p.devname[BLKPG_DEVNAMELTH - 1] = '\0';
524 
525                 return mtd_add_partition(mtd, p.devname, p.start, p.length);
526 
527         case BLKPG_DEL_PARTITION:
528 
529                 if (p.pno < 0)
530                         return -EINVAL;
531 
532                 return mtd_del_partition(mtd, p.pno);
533 
534         default:
535                 return -EINVAL;
536         }
537 }
538 
539 static int mtdchar_write_ioctl(struct mtd_info *mtd,
540                 struct mtd_write_req __user *argp)
541 {
542         struct mtd_write_req req;
543         struct mtd_oob_ops ops;
544         const void __user *usr_data, *usr_oob;
545         int ret;
546 
547         if (copy_from_user(&req, argp, sizeof(req)))
548                 return -EFAULT;
549 
550         usr_data = (const void __user *)(uintptr_t)req.usr_data;
551         usr_oob = (const void __user *)(uintptr_t)req.usr_oob;
552         if (!access_ok(VERIFY_READ, usr_data, req.len) ||
553             !access_ok(VERIFY_READ, usr_oob, req.ooblen))
554                 return -EFAULT;
555 
556         if (!mtd->_write_oob)
557                 return -EOPNOTSUPP;
558 
559         ops.mode = req.mode;
560         ops.len = (size_t)req.len;
561         ops.ooblen = (size_t)req.ooblen;
562         ops.ooboffs = 0;
563 
564         if (usr_data) {
565                 ops.datbuf = memdup_user(usr_data, ops.len);
566                 if (IS_ERR(ops.datbuf))
567                         return PTR_ERR(ops.datbuf);
568         } else {
569                 ops.datbuf = NULL;
570         }
571 
572         if (usr_oob) {
573                 ops.oobbuf = memdup_user(usr_oob, ops.ooblen);
574                 if (IS_ERR(ops.oobbuf)) {
575                         kfree(ops.datbuf);
576                         return PTR_ERR(ops.oobbuf);
577                 }
578         } else {
579                 ops.oobbuf = NULL;
580         }
581 
582         ret = mtd_write_oob(mtd, (loff_t)req.start, &ops);
583 
584         kfree(ops.datbuf);
585         kfree(ops.oobbuf);
586 
587         return ret;
588 }
589 
590 static int mtdchar_ioctl(struct file *file, u_int cmd, u_long arg)
591 {
592         struct mtd_file_info *mfi = file->private_data;
593         struct mtd_info *mtd = mfi->mtd;
594         void __user *argp = (void __user *)arg;
595         int ret = 0;
596         u_long size;
597         struct mtd_info_user info;
598 
599         pr_debug("MTD_ioctl\n");
600 
601         size = (cmd & IOCSIZE_MASK) >> IOCSIZE_SHIFT;
602         if (cmd & IOC_IN) {
603                 if (!access_ok(VERIFY_READ, argp, size))
604                         return -EFAULT;
605         }
606         if (cmd & IOC_OUT) {
607                 if (!access_ok(VERIFY_WRITE, argp, size))
608                         return -EFAULT;
609         }
610 
611         switch (cmd) {
612         case MEMGETREGIONCOUNT:
613                 if (copy_to_user(argp, &(mtd->numeraseregions), sizeof(int)))
614                         return -EFAULT;
615                 break;
616 
617         case MEMGETREGIONINFO:
618         {
619                 uint32_t ur_idx;
620                 struct mtd_erase_region_info *kr;
621                 struct region_info_user __user *ur = argp;
622 
623                 if (get_user(ur_idx, &(ur->regionindex)))
624                         return -EFAULT;
625 
626                 if (ur_idx >= mtd->numeraseregions)
627                         return -EINVAL;
628 
629                 kr = &(mtd->eraseregions[ur_idx]);
630 
631                 if (put_user(kr->offset, &(ur->offset))
632                     || put_user(kr->erasesize, &(ur->erasesize))
633                     || put_user(kr->numblocks, &(ur->numblocks)))
634                         return -EFAULT;
635 
636                 break;
637         }
638 
639         case MEMGETINFO:
640                 memset(&info, 0, sizeof(info));
641                 info.type       = mtd->type;
642                 info.flags      = mtd->flags;
643                 info.size       = mtd->size;
644                 info.erasesize  = mtd->erasesize;
645                 info.writesize  = mtd->writesize;
646                 info.oobsize    = mtd->oobsize;
647                 /* The below field is obsolete */
648                 info.padding    = 0;
649                 if (copy_to_user(argp, &info, sizeof(struct mtd_info_user)))
650                         return -EFAULT;
651                 break;
652 
653         case MEMERASE:
654         case MEMERASE64:
655         {
656                 struct erase_info *erase;
657 
658                 if(!(file->f_mode & FMODE_WRITE))
659                         return -EPERM;
660 
661                 erase=kzalloc(sizeof(struct erase_info),GFP_KERNEL);
662                 if (!erase)
663                         ret = -ENOMEM;
664                 else {
665                         wait_queue_head_t waitq;
666                         DECLARE_WAITQUEUE(wait, current);
667 
668                         init_waitqueue_head(&waitq);
669 
670                         if (cmd == MEMERASE64) {
671                                 struct erase_info_user64 einfo64;
672 
673                                 if (copy_from_user(&einfo64, argp,
674                                             sizeof(struct erase_info_user64))) {
675                                         kfree(erase);
676                                         return -EFAULT;
677                                 }
678                                 erase->addr = einfo64.start;
679                                 erase->len = einfo64.length;
680                         } else {
681                                 struct erase_info_user einfo32;
682 
683                                 if (copy_from_user(&einfo32, argp,
684                                             sizeof(struct erase_info_user))) {
685                                         kfree(erase);
686                                         return -EFAULT;
687                                 }
688                                 erase->addr = einfo32.start;
689                                 erase->len = einfo32.length;
690                         }
691                         erase->mtd = mtd;
692                         erase->callback = mtdchar_erase_callback;
693                         erase->priv = (unsigned long)&waitq;
694 
695                         /*
696                           FIXME: Allow INTERRUPTIBLE. Which means
697                           not having the wait_queue head on the stack.
698 
699                           If the wq_head is on the stack, and we
700                           leave because we got interrupted, then the
701                           wq_head is no longer there when the
702                           callback routine tries to wake us up.
703                         */
704                         ret = mtd_erase(mtd, erase);
705                         if (!ret) {
706                                 set_current_state(TASK_UNINTERRUPTIBLE);
707                                 add_wait_queue(&waitq, &wait);
708                                 if (erase->state != MTD_ERASE_DONE &&
709                                     erase->state != MTD_ERASE_FAILED)
710                                         schedule();
711                                 remove_wait_queue(&waitq, &wait);
712                                 set_current_state(TASK_RUNNING);
713 
714                                 ret = (erase->state == MTD_ERASE_FAILED)?-EIO:0;
715                         }
716                         kfree(erase);
717                 }
718                 break;
719         }
720 
721         case MEMWRITEOOB:
722         {
723                 struct mtd_oob_buf buf;
724                 struct mtd_oob_buf __user *buf_user = argp;
725 
726                 /* NOTE: writes return length to buf_user->length */
727                 if (copy_from_user(&buf, argp, sizeof(buf)))
728                         ret = -EFAULT;
729                 else
730                         ret = mtdchar_writeoob(file, mtd, buf.start, buf.length,
731                                 buf.ptr, &buf_user->length);
732                 break;
733         }
734 
735         case MEMREADOOB:
736         {
737                 struct mtd_oob_buf buf;
738                 struct mtd_oob_buf __user *buf_user = argp;
739 
740                 /* NOTE: writes return length to buf_user->start */
741                 if (copy_from_user(&buf, argp, sizeof(buf)))
742                         ret = -EFAULT;
743                 else
744                         ret = mtdchar_readoob(file, mtd, buf.start, buf.length,
745                                 buf.ptr, &buf_user->start);
746                 break;
747         }
748 
749         case MEMWRITEOOB64:
750         {
751                 struct mtd_oob_buf64 buf;
752                 struct mtd_oob_buf64 __user *buf_user = argp;
753 
754                 if (copy_from_user(&buf, argp, sizeof(buf)))
755                         ret = -EFAULT;
756                 else
757                         ret = mtdchar_writeoob(file, mtd, buf.start, buf.length,
758                                 (void __user *)(uintptr_t)buf.usr_ptr,
759                                 &buf_user->length);
760                 break;
761         }
762 
763         case MEMREADOOB64:
764         {
765                 struct mtd_oob_buf64 buf;
766                 struct mtd_oob_buf64 __user *buf_user = argp;
767 
768                 if (copy_from_user(&buf, argp, sizeof(buf)))
769                         ret = -EFAULT;
770                 else
771                         ret = mtdchar_readoob(file, mtd, buf.start, buf.length,
772                                 (void __user *)(uintptr_t)buf.usr_ptr,
773                                 &buf_user->length);
774                 break;
775         }
776 
777         case MEMWRITE:
778         {
779                 ret = mtdchar_write_ioctl(mtd,
780                       (struct mtd_write_req __user *)arg);
781                 break;
782         }
783 
784         case MEMLOCK:
785         {
786                 struct erase_info_user einfo;
787 
788                 if (copy_from_user(&einfo, argp, sizeof(einfo)))
789                         return -EFAULT;
790 
791                 ret = mtd_lock(mtd, einfo.start, einfo.length);
792                 break;
793         }
794 
795         case MEMUNLOCK:
796         {
797                 struct erase_info_user einfo;
798 
799                 if (copy_from_user(&einfo, argp, sizeof(einfo)))
800                         return -EFAULT;
801 
802                 ret = mtd_unlock(mtd, einfo.start, einfo.length);
803                 break;
804         }
805 
806         case MEMISLOCKED:
807         {
808                 struct erase_info_user einfo;
809 
810                 if (copy_from_user(&einfo, argp, sizeof(einfo)))
811                         return -EFAULT;
812 
813                 ret = mtd_is_locked(mtd, einfo.start, einfo.length);
814                 break;
815         }
816 
817         /* Legacy interface */
818         case MEMGETOOBSEL:
819         {
820                 struct nand_oobinfo oi;
821 
822                 if (!mtd->ecclayout)
823                         return -EOPNOTSUPP;
824                 if (mtd->ecclayout->eccbytes > ARRAY_SIZE(oi.eccpos))
825                         return -EINVAL;
826 
827                 oi.useecc = MTD_NANDECC_AUTOPLACE;
828                 memcpy(&oi.eccpos, mtd->ecclayout->eccpos, sizeof(oi.eccpos));
829                 memcpy(&oi.oobfree, mtd->ecclayout->oobfree,
830                        sizeof(oi.oobfree));
831                 oi.eccbytes = mtd->ecclayout->eccbytes;
832 
833                 if (copy_to_user(argp, &oi, sizeof(struct nand_oobinfo)))
834                         return -EFAULT;
835                 break;
836         }
837 
838         case MEMGETBADBLOCK:
839         {
840                 loff_t offs;
841 
842                 if (copy_from_user(&offs, argp, sizeof(loff_t)))
843                         return -EFAULT;
844                 return mtd_block_isbad(mtd, offs);
845                 break;
846         }
847 
848         case MEMSETBADBLOCK:
849         {
850                 loff_t offs;
851 
852                 if (copy_from_user(&offs, argp, sizeof(loff_t)))
853                         return -EFAULT;
854                 return mtd_block_markbad(mtd, offs);
855                 break;
856         }
857 
858         case OTPSELECT:
859         {
860                 int mode;
861                 if (copy_from_user(&mode, argp, sizeof(int)))
862                         return -EFAULT;
863 
864                 mfi->mode = MTD_FILE_MODE_NORMAL;
865 
866                 ret = otp_select_filemode(mfi, mode);
867 
868                 file->f_pos = 0;
869                 break;
870         }
871 
872         case OTPGETREGIONCOUNT:
873         case OTPGETREGIONINFO:
874         {
875                 struct otp_info *buf = kmalloc(4096, GFP_KERNEL);
876                 size_t retlen;
877                 if (!buf)
878                         return -ENOMEM;
879                 switch (mfi->mode) {
880                 case MTD_FILE_MODE_OTP_FACTORY:
881                         ret = mtd_get_fact_prot_info(mtd, 4096, &retlen, buf);
882                         break;
883                 case MTD_FILE_MODE_OTP_USER:
884                         ret = mtd_get_user_prot_info(mtd, 4096, &retlen, buf);
885                         break;
886                 default:
887                         ret = -EINVAL;
888                         break;
889                 }
890                 if (!ret) {
891                         if (cmd == OTPGETREGIONCOUNT) {
892                                 int nbr = retlen / sizeof(struct otp_info);
893                                 ret = copy_to_user(argp, &nbr, sizeof(int));
894                         } else
895                                 ret = copy_to_user(argp, buf, retlen);
896                         if (ret)
897                                 ret = -EFAULT;
898                 }
899                 kfree(buf);
900                 break;
901         }
902 
903         case OTPLOCK:
904         {
905                 struct otp_info oinfo;
906 
907                 if (mfi->mode != MTD_FILE_MODE_OTP_USER)
908                         return -EINVAL;
909                 if (copy_from_user(&oinfo, argp, sizeof(oinfo)))
910                         return -EFAULT;
911                 ret = mtd_lock_user_prot_reg(mtd, oinfo.start, oinfo.length);
912                 break;
913         }
914 
915         /* This ioctl is being deprecated - it truncates the ECC layout */
916         case ECCGETLAYOUT:
917         {
918                 struct nand_ecclayout_user *usrlay;
919 
920                 if (!mtd->ecclayout)
921                         return -EOPNOTSUPP;
922 
923                 usrlay = kmalloc(sizeof(*usrlay), GFP_KERNEL);
924                 if (!usrlay)
925                         return -ENOMEM;
926 
927                 shrink_ecclayout(mtd->ecclayout, usrlay);
928 
929                 if (copy_to_user(argp, usrlay, sizeof(*usrlay)))
930                         ret = -EFAULT;
931                 kfree(usrlay);
932                 break;
933         }
934 
935         case ECCGETSTATS:
936         {
937                 if (copy_to_user(argp, &mtd->ecc_stats,
938                                  sizeof(struct mtd_ecc_stats)))
939                         return -EFAULT;
940                 break;
941         }
942 
943         case MTDFILEMODE:
944         {
945                 mfi->mode = 0;
946 
947                 switch(arg) {
948                 case MTD_FILE_MODE_OTP_FACTORY:
949                 case MTD_FILE_MODE_OTP_USER:
950                         ret = otp_select_filemode(mfi, arg);
951                         break;
952 
953                 case MTD_FILE_MODE_RAW:
954                         if (!mtd_has_oob(mtd))
955                                 return -EOPNOTSUPP;
956                         mfi->mode = arg;
957 
958                 case MTD_FILE_MODE_NORMAL:
959                         break;
960                 default:
961                         ret = -EINVAL;
962                 }
963                 file->f_pos = 0;
964                 break;
965         }
966 
967         case BLKPG:
968         {
969                 ret = mtdchar_blkpg_ioctl(mtd,
970                       (struct blkpg_ioctl_arg __user *)arg);
971                 break;
972         }
973 
974         case BLKRRPART:
975         {
976                 /* No reread partition feature. Just return ok */
977                 ret = 0;
978                 break;
979         }
980 
981         default:
982                 ret = -ENOTTY;
983         }
984 
985         return ret;
986 } /* memory_ioctl */
987 
988 static long mtdchar_unlocked_ioctl(struct file *file, u_int cmd, u_long arg)
989 {
990         int ret;
991 
992         mutex_lock(&mtd_mutex);
993         ret = mtdchar_ioctl(file, cmd, arg);
994         mutex_unlock(&mtd_mutex);
995 
996         return ret;
997 }
998 
999 #ifdef CONFIG_COMPAT
1000 
1001 struct mtd_oob_buf32 {
1002         u_int32_t start;
1003         u_int32_t length;
1004         compat_caddr_t ptr;     /* unsigned char* */
1005 };
1006 
1007 #define MEMWRITEOOB32           _IOWR('M', 3, struct mtd_oob_buf32)
1008 #define MEMREADOOB32            _IOWR('M', 4, struct mtd_oob_buf32)
1009 
1010 static long mtdchar_compat_ioctl(struct file *file, unsigned int cmd,
1011         unsigned long arg)
1012 {
1013         struct mtd_file_info *mfi = file->private_data;
1014         struct mtd_info *mtd = mfi->mtd;
1015         void __user *argp = compat_ptr(arg);
1016         int ret = 0;
1017 
1018         mutex_lock(&mtd_mutex);
1019 
1020         switch (cmd) {
1021         case MEMWRITEOOB32:
1022         {
1023                 struct mtd_oob_buf32 buf;
1024                 struct mtd_oob_buf32 __user *buf_user = argp;
1025 
1026                 if (copy_from_user(&buf, argp, sizeof(buf)))
1027                         ret = -EFAULT;
1028                 else
1029                         ret = mtdchar_writeoob(file, mtd, buf.start,
1030                                 buf.length, compat_ptr(buf.ptr),
1031                                 &buf_user->length);
1032                 break;
1033         }
1034 
1035         case MEMREADOOB32:
1036         {
1037                 struct mtd_oob_buf32 buf;
1038                 struct mtd_oob_buf32 __user *buf_user = argp;
1039 
1040                 /* NOTE: writes return length to buf->start */
1041                 if (copy_from_user(&buf, argp, sizeof(buf)))
1042                         ret = -EFAULT;
1043                 else
1044                         ret = mtdchar_readoob(file, mtd, buf.start,
1045                                 buf.length, compat_ptr(buf.ptr),
1046                                 &buf_user->start);
1047                 break;
1048         }
1049         default:
1050                 ret = mtdchar_ioctl(file, cmd, (unsigned long)argp);
1051         }
1052 
1053         mutex_unlock(&mtd_mutex);
1054 
1055         return ret;
1056 }
1057 
1058 #endif /* CONFIG_COMPAT */
1059 
1060 /*
1061  * try to determine where a shared mapping can be made
1062  * - only supported for NOMMU at the moment (MMU can't doesn't copy private
1063  *   mappings)
1064  */
1065 #ifndef CONFIG_MMU
1066 static unsigned long mtdchar_get_unmapped_area(struct file *file,
1067                                            unsigned long addr,
1068                                            unsigned long len,
1069                                            unsigned long pgoff,
1070                                            unsigned long flags)
1071 {
1072         struct mtd_file_info *mfi = file->private_data;
1073         struct mtd_info *mtd = mfi->mtd;
1074         unsigned long offset;
1075         int ret;
1076 
1077         if (addr != 0)
1078                 return (unsigned long) -EINVAL;
1079 
1080         if (len > mtd->size || pgoff >= (mtd->size >> PAGE_SHIFT))
1081                 return (unsigned long) -EINVAL;
1082 
1083         offset = pgoff << PAGE_SHIFT;
1084         if (offset > mtd->size - len)
1085                 return (unsigned long) -EINVAL;
1086 
1087         ret = mtd_get_unmapped_area(mtd, len, offset, flags);
1088         return ret == -EOPNOTSUPP ? -ENODEV : ret;
1089 }
1090 
1091 static unsigned mtdchar_mmap_capabilities(struct file *file)
1092 {
1093         struct mtd_file_info *mfi = file->private_data;
1094 
1095         return mtd_mmap_capabilities(mfi->mtd);
1096 }
1097 #endif
1098 
1099 /*
1100  * set up a mapping for shared memory segments
1101  */
1102 static int mtdchar_mmap(struct file *file, struct vm_area_struct *vma)
1103 {
1104 #ifdef CONFIG_MMU
1105         struct mtd_file_info *mfi = file->private_data;
1106         struct mtd_info *mtd = mfi->mtd;
1107         struct map_info *map = mtd->priv;
1108 
1109         /* This is broken because it assumes the MTD device is map-based
1110            and that mtd->priv is a valid struct map_info.  It should be
1111            replaced with something that uses the mtd_get_unmapped_area()
1112            operation properly. */
1113         if (0 /*mtd->type == MTD_RAM || mtd->type == MTD_ROM*/) {
1114 #ifdef pgprot_noncached
1115                 if (file->f_flags & O_DSYNC || map->phys >= __pa(high_memory))
1116                         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
1117 #endif
1118                 return vm_iomap_memory(vma, map->phys, map->size);
1119         }
1120         return -ENODEV;
1121 #else
1122         return vma->vm_flags & VM_SHARED ? 0 : -EACCES;
1123 #endif
1124 }
1125 
1126 static const struct file_operations mtd_fops = {
1127         .owner          = THIS_MODULE,
1128         .llseek         = mtdchar_lseek,
1129         .read           = mtdchar_read,
1130         .write          = mtdchar_write,
1131         .unlocked_ioctl = mtdchar_unlocked_ioctl,
1132 #ifdef CONFIG_COMPAT
1133         .compat_ioctl   = mtdchar_compat_ioctl,
1134 #endif
1135         .open           = mtdchar_open,
1136         .release        = mtdchar_close,
1137         .mmap           = mtdchar_mmap,
1138 #ifndef CONFIG_MMU
1139         .get_unmapped_area = mtdchar_get_unmapped_area,
1140         .mmap_capabilities = mtdchar_mmap_capabilities,
1141 #endif
1142 };
1143 
1144 int __init init_mtdchar(void)
1145 {
1146         int ret;
1147 
1148         ret = __register_chrdev(MTD_CHAR_MAJOR, 0, 1 << MINORBITS,
1149                                    "mtd", &mtd_fops);
1150         if (ret < 0) {
1151                 pr_err("Can't allocate major number %d for MTD\n",
1152                        MTD_CHAR_MAJOR);
1153                 return ret;
1154         }
1155 
1156         return ret;
1157 }
1158 
1159 void __exit cleanup_mtdchar(void)
1160 {
1161         __unregister_chrdev(MTD_CHAR_MAJOR, 0, 1 << MINORBITS, "mtd");
1162 }
1163 
1164 MODULE_ALIAS_CHARDEV_MAJOR(MTD_CHAR_MAJOR);
1165 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us