mtd: add MEMERASE64 ioctl for >4GiB devices
[linux-2.6.git] / drivers / mtd / mtdchar.c
1 /*
2  * Character-device access to raw MTD devices.
3  *
4  */
5
6 #include <linux/device.h>
7 #include <linux/fs.h>
8 #include <linux/mm.h>
9 #include <linux/err.h>
10 #include <linux/init.h>
11 #include <linux/kernel.h>
12 #include <linux/module.h>
13 #include <linux/slab.h>
14 #include <linux/sched.h>
15 #include <linux/smp_lock.h>
16 #include <linux/backing-dev.h>
17
18 #include <linux/mtd/mtd.h>
19 #include <linux/mtd/compatmac.h>
20
21 #include <asm/uaccess.h>
22
23
24 /*
25  * Data structure to hold the pointer to the mtd device as well
26  * as mode information ofr various use cases.
27  */
28 struct mtd_file_info {
29         struct mtd_info *mtd;
30         enum mtd_file_modes mode;
31 };
32
33 static loff_t mtd_lseek (struct file *file, loff_t offset, int orig)
34 {
35         struct mtd_file_info *mfi = file->private_data;
36         struct mtd_info *mtd = mfi->mtd;
37
38         switch (orig) {
39         case SEEK_SET:
40                 break;
41         case SEEK_CUR:
42                 offset += file->f_pos;
43                 break;
44         case SEEK_END:
45                 offset += mtd->size;
46                 break;
47         default:
48                 return -EINVAL;
49         }
50
51         if (offset >= 0 && offset <= mtd->size)
52                 return file->f_pos = offset;
53
54         return -EINVAL;
55 }
56
57
58
59 static int mtd_open(struct inode *inode, struct file *file)
60 {
61         int minor = iminor(inode);
62         int devnum = minor >> 1;
63         int ret = 0;
64         struct mtd_info *mtd;
65         struct mtd_file_info *mfi;
66
67         DEBUG(MTD_DEBUG_LEVEL0, "MTD_open\n");
68
69         if (devnum >= MAX_MTD_DEVICES)
70                 return -ENODEV;
71
72         /* You can't open the RO devices RW */
73         if ((file->f_mode & FMODE_WRITE) && (minor & 1))
74                 return -EACCES;
75
76         lock_kernel();
77         mtd = get_mtd_device(NULL, devnum);
78
79         if (IS_ERR(mtd)) {
80                 ret = PTR_ERR(mtd);
81                 goto out;
82         }
83
84         if (mtd->type == MTD_ABSENT) {
85                 put_mtd_device(mtd);
86                 ret = -ENODEV;
87                 goto out;
88         }
89
90         if (mtd->backing_dev_info)
91                 file->f_mapping->backing_dev_info = mtd->backing_dev_info;
92
93         /* You can't open it RW if it's not a writeable device */
94         if ((file->f_mode & FMODE_WRITE) && !(mtd->flags & MTD_WRITEABLE)) {
95                 put_mtd_device(mtd);
96                 ret = -EACCES;
97                 goto out;
98         }
99
100         mfi = kzalloc(sizeof(*mfi), GFP_KERNEL);
101         if (!mfi) {
102                 put_mtd_device(mtd);
103                 ret = -ENOMEM;
104                 goto out;
105         }
106         mfi->mtd = mtd;
107         file->private_data = mfi;
108
109 out:
110         unlock_kernel();
111         return ret;
112 } /* mtd_open */
113
114 /*====================================================================*/
115
116 static int mtd_close(struct inode *inode, struct file *file)
117 {
118         struct mtd_file_info *mfi = file->private_data;
119         struct mtd_info *mtd = mfi->mtd;
120
121         DEBUG(MTD_DEBUG_LEVEL0, "MTD_close\n");
122
123         /* Only sync if opened RW */
124         if ((file->f_mode & FMODE_WRITE) && mtd->sync)
125                 mtd->sync(mtd);
126
127         put_mtd_device(mtd);
128         file->private_data = NULL;
129         kfree(mfi);
130
131         return 0;
132 } /* mtd_close */
133
134 /* FIXME: This _really_ needs to die. In 2.5, we should lock the
135    userspace buffer down and use it directly with readv/writev.
136 */
137 #define MAX_KMALLOC_SIZE 0x20000
138
139 static ssize_t mtd_read(struct file *file, char __user *buf, size_t count,loff_t *ppos)
140 {
141         struct mtd_file_info *mfi = file->private_data;
142         struct mtd_info *mtd = mfi->mtd;
143         size_t retlen=0;
144         size_t total_retlen=0;
145         int ret=0;
146         int len;
147         char *kbuf;
148
149         DEBUG(MTD_DEBUG_LEVEL0,"MTD_read\n");
150
151         if (*ppos + count > mtd->size)
152                 count = mtd->size - *ppos;
153
154         if (!count)
155                 return 0;
156
157         /* FIXME: Use kiovec in 2.5 to lock down the user's buffers
158            and pass them directly to the MTD functions */
159
160         if (count > MAX_KMALLOC_SIZE)
161                 kbuf=kmalloc(MAX_KMALLOC_SIZE, GFP_KERNEL);
162         else
163                 kbuf=kmalloc(count, GFP_KERNEL);
164
165         if (!kbuf)
166                 return -ENOMEM;
167
168         while (count) {
169
170                 if (count > MAX_KMALLOC_SIZE)
171                         len = MAX_KMALLOC_SIZE;
172                 else
173                         len = count;
174
175                 switch (mfi->mode) {
176                 case MTD_MODE_OTP_FACTORY:
177                         ret = mtd->read_fact_prot_reg(mtd, *ppos, len, &retlen, kbuf);
178                         break;
179                 case MTD_MODE_OTP_USER:
180                         ret = mtd->read_user_prot_reg(mtd, *ppos, len, &retlen, kbuf);
181                         break;
182                 case MTD_MODE_RAW:
183                 {
184                         struct mtd_oob_ops ops;
185
186                         ops.mode = MTD_OOB_RAW;
187                         ops.datbuf = kbuf;
188                         ops.oobbuf = NULL;
189                         ops.len = len;
190
191                         ret = mtd->read_oob(mtd, *ppos, &ops);
192                         retlen = ops.retlen;
193                         break;
194                 }
195                 default:
196                         ret = mtd->read(mtd, *ppos, len, &retlen, kbuf);
197                 }
198                 /* Nand returns -EBADMSG on ecc errors, but it returns
199                  * the data. For our userspace tools it is important
200                  * to dump areas with ecc errors !
201                  * For kernel internal usage it also might return -EUCLEAN
202                  * to signal the caller that a bitflip has occured and has
203                  * been corrected by the ECC algorithm.
204                  * Userspace software which accesses NAND this way
205                  * must be aware of the fact that it deals with NAND
206                  */
207                 if (!ret || (ret == -EUCLEAN) || (ret == -EBADMSG)) {
208                         *ppos += retlen;
209                         if (copy_to_user(buf, kbuf, retlen)) {
210                                 kfree(kbuf);
211                                 return -EFAULT;
212                         }
213                         else
214                                 total_retlen += retlen;
215
216                         count -= retlen;
217                         buf += retlen;
218                         if (retlen == 0)
219                                 count = 0;
220                 }
221                 else {
222                         kfree(kbuf);
223                         return ret;
224                 }
225
226         }
227
228         kfree(kbuf);
229         return total_retlen;
230 } /* mtd_read */
231
232 static ssize_t mtd_write(struct file *file, const char __user *buf, size_t count,loff_t *ppos)
233 {
234         struct mtd_file_info *mfi = file->private_data;
235         struct mtd_info *mtd = mfi->mtd;
236         char *kbuf;
237         size_t retlen;
238         size_t total_retlen=0;
239         int ret=0;
240         int len;
241
242         DEBUG(MTD_DEBUG_LEVEL0,"MTD_write\n");
243
244         if (*ppos == mtd->size)
245                 return -ENOSPC;
246
247         if (*ppos + count > mtd->size)
248                 count = mtd->size - *ppos;
249
250         if (!count)
251                 return 0;
252
253         if (count > MAX_KMALLOC_SIZE)
254                 kbuf=kmalloc(MAX_KMALLOC_SIZE, GFP_KERNEL);
255         else
256                 kbuf=kmalloc(count, GFP_KERNEL);
257
258         if (!kbuf)
259                 return -ENOMEM;
260
261         while (count) {
262
263                 if (count > MAX_KMALLOC_SIZE)
264                         len = MAX_KMALLOC_SIZE;
265                 else
266                         len = count;
267
268                 if (copy_from_user(kbuf, buf, len)) {
269                         kfree(kbuf);
270                         return -EFAULT;
271                 }
272
273                 switch (mfi->mode) {
274                 case MTD_MODE_OTP_FACTORY:
275                         ret = -EROFS;
276                         break;
277                 case MTD_MODE_OTP_USER:
278                         if (!mtd->write_user_prot_reg) {
279                                 ret = -EOPNOTSUPP;
280                                 break;
281                         }
282                         ret = mtd->write_user_prot_reg(mtd, *ppos, len, &retlen, kbuf);
283                         break;
284
285                 case MTD_MODE_RAW:
286                 {
287                         struct mtd_oob_ops ops;
288
289                         ops.mode = MTD_OOB_RAW;
290                         ops.datbuf = kbuf;
291                         ops.oobbuf = NULL;
292                         ops.len = len;
293
294                         ret = mtd->write_oob(mtd, *ppos, &ops);
295                         retlen = ops.retlen;
296                         break;
297                 }
298
299                 default:
300                         ret = (*(mtd->write))(mtd, *ppos, len, &retlen, kbuf);
301                 }
302                 if (!ret) {
303                         *ppos += retlen;
304                         total_retlen += retlen;
305                         count -= retlen;
306                         buf += retlen;
307                 }
308                 else {
309                         kfree(kbuf);
310                         return ret;
311                 }
312         }
313
314         kfree(kbuf);
315         return total_retlen;
316 } /* mtd_write */
317
318 /*======================================================================
319
320     IOCTL calls for getting device parameters.
321
322 ======================================================================*/
323 static void mtdchar_erase_callback (struct erase_info *instr)
324 {
325         wake_up((wait_queue_head_t *)instr->priv);
326 }
327
328 #ifdef CONFIG_HAVE_MTD_OTP
329 static int otp_select_filemode(struct mtd_file_info *mfi, int mode)
330 {
331         struct mtd_info *mtd = mfi->mtd;
332         int ret = 0;
333
334         switch (mode) {
335         case MTD_OTP_FACTORY:
336                 if (!mtd->read_fact_prot_reg)
337                         ret = -EOPNOTSUPP;
338                 else
339                         mfi->mode = MTD_MODE_OTP_FACTORY;
340                 break;
341         case MTD_OTP_USER:
342                 if (!mtd->read_fact_prot_reg)
343                         ret = -EOPNOTSUPP;
344                 else
345                         mfi->mode = MTD_MODE_OTP_USER;
346                 break;
347         default:
348                 ret = -EINVAL;
349         case MTD_OTP_OFF:
350                 break;
351         }
352         return ret;
353 }
354 #else
355 # define otp_select_filemode(f,m)       -EOPNOTSUPP
356 #endif
357
358 static int mtd_ioctl(struct inode *inode, struct file *file,
359                      u_int cmd, u_long arg)
360 {
361         struct mtd_file_info *mfi = file->private_data;
362         struct mtd_info *mtd = mfi->mtd;
363         void __user *argp = (void __user *)arg;
364         int ret = 0;
365         u_long size;
366         struct mtd_info_user info;
367
368         DEBUG(MTD_DEBUG_LEVEL0, "MTD_ioctl\n");
369
370         size = (cmd & IOCSIZE_MASK) >> IOCSIZE_SHIFT;
371         if (cmd & IOC_IN) {
372                 if (!access_ok(VERIFY_READ, argp, size))
373                         return -EFAULT;
374         }
375         if (cmd & IOC_OUT) {
376                 if (!access_ok(VERIFY_WRITE, argp, size))
377                         return -EFAULT;
378         }
379
380         switch (cmd) {
381         case MEMGETREGIONCOUNT:
382                 if (copy_to_user(argp, &(mtd->numeraseregions), sizeof(int)))
383                         return -EFAULT;
384                 break;
385
386         case MEMGETREGIONINFO:
387         {
388                 uint32_t ur_idx;
389                 struct mtd_erase_region_info *kr;
390                 struct region_info_user *ur = (struct region_info_user *) argp;
391
392                 if (get_user(ur_idx, &(ur->regionindex)))
393                         return -EFAULT;
394
395                 kr = &(mtd->eraseregions[ur_idx]);
396
397                 if (put_user(kr->offset, &(ur->offset))
398                     || put_user(kr->erasesize, &(ur->erasesize))
399                     || put_user(kr->numblocks, &(ur->numblocks)))
400                         return -EFAULT;
401
402                 break;
403         }
404
405         case MEMGETINFO:
406                 info.type       = mtd->type;
407                 info.flags      = mtd->flags;
408                 info.size       = mtd->size;
409                 info.erasesize  = mtd->erasesize;
410                 info.writesize  = mtd->writesize;
411                 info.oobsize    = mtd->oobsize;
412                 /* The below fields are obsolete */
413                 info.ecctype    = -1;
414                 info.eccsize    = 0;
415                 if (copy_to_user(argp, &info, sizeof(struct mtd_info_user)))
416                         return -EFAULT;
417                 break;
418
419         case MEMERASE:
420         case MEMERASE64:
421         {
422                 struct erase_info *erase;
423
424                 if(!(file->f_mode & FMODE_WRITE))
425                         return -EPERM;
426
427                 erase=kzalloc(sizeof(struct erase_info),GFP_KERNEL);
428                 if (!erase)
429                         ret = -ENOMEM;
430                 else {
431                         wait_queue_head_t waitq;
432                         DECLARE_WAITQUEUE(wait, current);
433
434                         init_waitqueue_head(&waitq);
435
436                         if (cmd == MEMERASE64) {
437                                 struct erase_info_user64 einfo64;
438
439                                 if (copy_from_user(&einfo64, argp,
440                                             sizeof(struct erase_info_user64))) {
441                                         kfree(erase);
442                                         return -EFAULT;
443                                 }
444                                 erase->addr = einfo64.start;
445                                 erase->len = einfo64.length;
446                         } else {
447                                 struct erase_info_user einfo32;
448
449                                 if (copy_from_user(&einfo32, argp,
450                                             sizeof(struct erase_info_user))) {
451                                         kfree(erase);
452                                         return -EFAULT;
453                                 }
454                                 erase->addr = einfo32.start;
455                                 erase->len = einfo32.length;
456                         }
457                         erase->mtd = mtd;
458                         erase->callback = mtdchar_erase_callback;
459                         erase->priv = (unsigned long)&waitq;
460
461                         /*
462                           FIXME: Allow INTERRUPTIBLE. Which means
463                           not having the wait_queue head on the stack.
464
465                           If the wq_head is on the stack, and we
466                           leave because we got interrupted, then the
467                           wq_head is no longer there when the
468                           callback routine tries to wake us up.
469                         */
470                         ret = mtd->erase(mtd, erase);
471                         if (!ret) {
472                                 set_current_state(TASK_UNINTERRUPTIBLE);
473                                 add_wait_queue(&waitq, &wait);
474                                 if (erase->state != MTD_ERASE_DONE &&
475                                     erase->state != MTD_ERASE_FAILED)
476                                         schedule();
477                                 remove_wait_queue(&waitq, &wait);
478                                 set_current_state(TASK_RUNNING);
479
480                                 ret = (erase->state == MTD_ERASE_FAILED)?-EIO:0;
481                         }
482                         kfree(erase);
483                 }
484                 break;
485         }
486
487         case MEMWRITEOOB:
488         {
489                 struct mtd_oob_buf buf;
490                 struct mtd_oob_ops ops;
491                 struct mtd_oob_buf __user *user_buf = argp;
492                 uint32_t retlen;
493
494                 if(!(file->f_mode & FMODE_WRITE))
495                         return -EPERM;
496
497                 if (copy_from_user(&buf, argp, sizeof(struct mtd_oob_buf)))
498                         return -EFAULT;
499
500                 if (buf.length > 4096)
501                         return -EINVAL;
502
503                 if (!mtd->write_oob)
504                         ret = -EOPNOTSUPP;
505                 else
506                         ret = access_ok(VERIFY_READ, buf.ptr,
507                                         buf.length) ? 0 : EFAULT;
508
509                 if (ret)
510                         return ret;
511
512                 ops.ooblen = buf.length;
513                 ops.ooboffs = buf.start & (mtd->oobsize - 1);
514                 ops.datbuf = NULL;
515                 ops.mode = MTD_OOB_PLACE;
516
517                 if (ops.ooboffs && ops.ooblen > (mtd->oobsize - ops.ooboffs))
518                         return -EINVAL;
519
520                 ops.oobbuf = kmalloc(buf.length, GFP_KERNEL);
521                 if (!ops.oobbuf)
522                         return -ENOMEM;
523
524                 if (copy_from_user(ops.oobbuf, buf.ptr, buf.length)) {
525                         kfree(ops.oobbuf);
526                         return -EFAULT;
527                 }
528
529                 buf.start &= ~(mtd->oobsize - 1);
530                 ret = mtd->write_oob(mtd, buf.start, &ops);
531
532                 if (ops.oobretlen > 0xFFFFFFFFU)
533                         ret = -EOVERFLOW;
534                 retlen = ops.oobretlen;
535                 if (copy_to_user(&user_buf->length, &retlen, sizeof(buf.length)))
536                         ret = -EFAULT;
537
538                 kfree(ops.oobbuf);
539                 break;
540
541         }
542
543         case MEMREADOOB:
544         {
545                 struct mtd_oob_buf buf;
546                 struct mtd_oob_ops ops;
547
548                 if (copy_from_user(&buf, argp, sizeof(struct mtd_oob_buf)))
549                         return -EFAULT;
550
551                 if (buf.length > 4096)
552                         return -EINVAL;
553
554                 if (!mtd->read_oob)
555                         ret = -EOPNOTSUPP;
556                 else
557                         ret = access_ok(VERIFY_WRITE, buf.ptr,
558                                         buf.length) ? 0 : -EFAULT;
559                 if (ret)
560                         return ret;
561
562                 ops.ooblen = buf.length;
563                 ops.ooboffs = buf.start & (mtd->oobsize - 1);
564                 ops.datbuf = NULL;
565                 ops.mode = MTD_OOB_PLACE;
566
567                 if (ops.ooboffs && ops.ooblen > (mtd->oobsize - ops.ooboffs))
568                         return -EINVAL;
569
570                 ops.oobbuf = kmalloc(buf.length, GFP_KERNEL);
571                 if (!ops.oobbuf)
572                         return -ENOMEM;
573
574                 buf.start &= ~(mtd->oobsize - 1);
575                 ret = mtd->read_oob(mtd, buf.start, &ops);
576
577                 if (put_user(ops.oobretlen, (uint32_t __user *)argp))
578                         ret = -EFAULT;
579                 else if (ops.oobretlen && copy_to_user(buf.ptr, ops.oobbuf,
580                                                     ops.oobretlen))
581                         ret = -EFAULT;
582
583                 kfree(ops.oobbuf);
584                 break;
585         }
586
587         case MEMLOCK:
588         {
589                 struct erase_info_user einfo;
590
591                 if (copy_from_user(&einfo, argp, sizeof(einfo)))
592                         return -EFAULT;
593
594                 if (!mtd->lock)
595                         ret = -EOPNOTSUPP;
596                 else
597                         ret = mtd->lock(mtd, einfo.start, einfo.length);
598                 break;
599         }
600
601         case MEMUNLOCK:
602         {
603                 struct erase_info_user einfo;
604
605                 if (copy_from_user(&einfo, argp, sizeof(einfo)))
606                         return -EFAULT;
607
608                 if (!mtd->unlock)
609                         ret = -EOPNOTSUPP;
610                 else
611                         ret = mtd->unlock(mtd, einfo.start, einfo.length);
612                 break;
613         }
614
615         /* Legacy interface */
616         case MEMGETOOBSEL:
617         {
618                 struct nand_oobinfo oi;
619
620                 if (!mtd->ecclayout)
621                         return -EOPNOTSUPP;
622                 if (mtd->ecclayout->eccbytes > ARRAY_SIZE(oi.eccpos))
623                         return -EINVAL;
624
625                 oi.useecc = MTD_NANDECC_AUTOPLACE;
626                 memcpy(&oi.eccpos, mtd->ecclayout->eccpos, sizeof(oi.eccpos));
627                 memcpy(&oi.oobfree, mtd->ecclayout->oobfree,
628                        sizeof(oi.oobfree));
629                 oi.eccbytes = mtd->ecclayout->eccbytes;
630
631                 if (copy_to_user(argp, &oi, sizeof(struct nand_oobinfo)))
632                         return -EFAULT;
633                 break;
634         }
635
636         case MEMGETBADBLOCK:
637         {
638                 loff_t offs;
639
640                 if (copy_from_user(&offs, argp, sizeof(loff_t)))
641                         return -EFAULT;
642                 if (!mtd->block_isbad)
643                         ret = -EOPNOTSUPP;
644                 else
645                         return mtd->block_isbad(mtd, offs);
646                 break;
647         }
648
649         case MEMSETBADBLOCK:
650         {
651                 loff_t offs;
652
653                 if (copy_from_user(&offs, argp, sizeof(loff_t)))
654                         return -EFAULT;
655                 if (!mtd->block_markbad)
656                         ret = -EOPNOTSUPP;
657                 else
658                         return mtd->block_markbad(mtd, offs);
659                 break;
660         }
661
662 #ifdef CONFIG_HAVE_MTD_OTP
663         case OTPSELECT:
664         {
665                 int mode;
666                 if (copy_from_user(&mode, argp, sizeof(int)))
667                         return -EFAULT;
668
669                 mfi->mode = MTD_MODE_NORMAL;
670
671                 ret = otp_select_filemode(mfi, mode);
672
673                 file->f_pos = 0;
674                 break;
675         }
676
677         case OTPGETREGIONCOUNT:
678         case OTPGETREGIONINFO:
679         {
680                 struct otp_info *buf = kmalloc(4096, GFP_KERNEL);
681                 if (!buf)
682                         return -ENOMEM;
683                 ret = -EOPNOTSUPP;
684                 switch (mfi->mode) {
685                 case MTD_MODE_OTP_FACTORY:
686                         if (mtd->get_fact_prot_info)
687                                 ret = mtd->get_fact_prot_info(mtd, buf, 4096);
688                         break;
689                 case MTD_MODE_OTP_USER:
690                         if (mtd->get_user_prot_info)
691                                 ret = mtd->get_user_prot_info(mtd, buf, 4096);
692                         break;
693                 default:
694                         break;
695                 }
696                 if (ret >= 0) {
697                         if (cmd == OTPGETREGIONCOUNT) {
698                                 int nbr = ret / sizeof(struct otp_info);
699                                 ret = copy_to_user(argp, &nbr, sizeof(int));
700                         } else
701                                 ret = copy_to_user(argp, buf, ret);
702                         if (ret)
703                                 ret = -EFAULT;
704                 }
705                 kfree(buf);
706                 break;
707         }
708
709         case OTPLOCK:
710         {
711                 struct otp_info oinfo;
712
713                 if (mfi->mode != MTD_MODE_OTP_USER)
714                         return -EINVAL;
715                 if (copy_from_user(&oinfo, argp, sizeof(oinfo)))
716                         return -EFAULT;
717                 if (!mtd->lock_user_prot_reg)
718                         return -EOPNOTSUPP;
719                 ret = mtd->lock_user_prot_reg(mtd, oinfo.start, oinfo.length);
720                 break;
721         }
722 #endif
723
724         case ECCGETLAYOUT:
725         {
726                 if (!mtd->ecclayout)
727                         return -EOPNOTSUPP;
728
729                 if (copy_to_user(argp, mtd->ecclayout,
730                                  sizeof(struct nand_ecclayout)))
731                         return -EFAULT;
732                 break;
733         }
734
735         case ECCGETSTATS:
736         {
737                 if (copy_to_user(argp, &mtd->ecc_stats,
738                                  sizeof(struct mtd_ecc_stats)))
739                         return -EFAULT;
740                 break;
741         }
742
743         case MTDFILEMODE:
744         {
745                 mfi->mode = 0;
746
747                 switch(arg) {
748                 case MTD_MODE_OTP_FACTORY:
749                 case MTD_MODE_OTP_USER:
750                         ret = otp_select_filemode(mfi, arg);
751                         break;
752
753                 case MTD_MODE_RAW:
754                         if (!mtd->read_oob || !mtd->write_oob)
755                                 return -EOPNOTSUPP;
756                         mfi->mode = arg;
757
758                 case MTD_MODE_NORMAL:
759                         break;
760                 default:
761                         ret = -EINVAL;
762                 }
763                 file->f_pos = 0;
764                 break;
765         }
766
767         default:
768                 ret = -ENOTTY;
769         }
770
771         return ret;
772 } /* memory_ioctl */
773
774 /*
775  * try to determine where a shared mapping can be made
776  * - only supported for NOMMU at the moment (MMU can't doesn't copy private
777  *   mappings)
778  */
779 #ifndef CONFIG_MMU
780 static unsigned long mtd_get_unmapped_area(struct file *file,
781                                            unsigned long addr,
782                                            unsigned long len,
783                                            unsigned long pgoff,
784                                            unsigned long flags)
785 {
786         struct mtd_file_info *mfi = file->private_data;
787         struct mtd_info *mtd = mfi->mtd;
788
789         if (mtd->get_unmapped_area) {
790                 unsigned long offset;
791
792                 if (addr != 0)
793                         return (unsigned long) -EINVAL;
794
795                 if (len > mtd->size || pgoff >= (mtd->size >> PAGE_SHIFT))
796                         return (unsigned long) -EINVAL;
797
798                 offset = pgoff << PAGE_SHIFT;
799                 if (offset > mtd->size - len)
800                         return (unsigned long) -EINVAL;
801
802                 return mtd->get_unmapped_area(mtd, len, offset, flags);
803         }
804
805         /* can't map directly */
806         return (unsigned long) -ENOSYS;
807 }
808 #endif
809
810 /*
811  * set up a mapping for shared memory segments
812  */
813 static int mtd_mmap(struct file *file, struct vm_area_struct *vma)
814 {
815 #ifdef CONFIG_MMU
816         struct mtd_file_info *mfi = file->private_data;
817         struct mtd_info *mtd = mfi->mtd;
818
819         if (mtd->type == MTD_RAM || mtd->type == MTD_ROM)
820                 return 0;
821         return -ENOSYS;
822 #else
823         return vma->vm_flags & VM_SHARED ? 0 : -ENOSYS;
824 #endif
825 }
826
827 static const struct file_operations mtd_fops = {
828         .owner          = THIS_MODULE,
829         .llseek         = mtd_lseek,
830         .read           = mtd_read,
831         .write          = mtd_write,
832         .ioctl          = mtd_ioctl,
833         .open           = mtd_open,
834         .release        = mtd_close,
835         .mmap           = mtd_mmap,
836 #ifndef CONFIG_MMU
837         .get_unmapped_area = mtd_get_unmapped_area,
838 #endif
839 };
840
841 static int __init init_mtdchar(void)
842 {
843         int status;
844
845         status = register_chrdev(MTD_CHAR_MAJOR, "mtd", &mtd_fops);
846         if (status < 0) {
847                 printk(KERN_NOTICE "Can't allocate major number %d for Memory Technology Devices.\n",
848                        MTD_CHAR_MAJOR);
849         }
850
851         return status;
852 }
853
854 static void __exit cleanup_mtdchar(void)
855 {
856         unregister_chrdev(MTD_CHAR_MAJOR, "mtd");
857 }
858
859 module_init(init_mtdchar);
860 module_exit(cleanup_mtdchar);
861
862 MODULE_ALIAS_CHARDEV_MAJOR(MTD_CHAR_MAJOR);
863
864 MODULE_LICENSE("GPL");
865 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
866 MODULE_DESCRIPTION("Direct character-device access to MTD devices");
867 MODULE_ALIAS_CHARDEV_MAJOR(MTD_CHAR_MAJOR);