mtdchar.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820
  1. /*
  2. * $Id: mtdchar.c,v 1.76 2005/11/07 11:14:20 gleixner Exp $
  3. *
  4. * Character-device access to raw MTD devices.
  5. *
  6. */
  7. #include <linux/device.h>
  8. #include <linux/fs.h>
  9. #include <linux/mm.h>
  10. #include <linux/err.h>
  11. #include <linux/init.h>
  12. #include <linux/kernel.h>
  13. #include <linux/module.h>
  14. #include <linux/slab.h>
  15. #include <linux/sched.h>
  16. #include <linux/smp_lock.h>
  17. #include <linux/mtd/mtd.h>
  18. #include <linux/mtd/compatmac.h>
  19. #include <asm/uaccess.h>
  20. static struct class *mtd_class;
  21. static void mtd_notify_add(struct mtd_info* mtd)
  22. {
  23. if (!mtd)
  24. return;
  25. device_create(mtd_class, NULL, MKDEV(MTD_CHAR_MAJOR, mtd->index*2), "mtd%d", mtd->index);
  26. device_create(mtd_class, NULL,
  27. MKDEV(MTD_CHAR_MAJOR, mtd->index*2+1), "mtd%dro", mtd->index);
  28. }
  29. static void mtd_notify_remove(struct mtd_info* mtd)
  30. {
  31. if (!mtd)
  32. return;
  33. device_destroy(mtd_class, MKDEV(MTD_CHAR_MAJOR, mtd->index*2));
  34. device_destroy(mtd_class, MKDEV(MTD_CHAR_MAJOR, mtd->index*2+1));
  35. }
  36. static struct mtd_notifier notifier = {
  37. .add = mtd_notify_add,
  38. .remove = mtd_notify_remove,
  39. };
  40. /*
  41. * Data structure to hold the pointer to the mtd device as well
  42. * as mode information ofr various use cases.
  43. */
  44. struct mtd_file_info {
  45. struct mtd_info *mtd;
  46. enum mtd_file_modes mode;
  47. };
  48. static loff_t mtd_lseek (struct file *file, loff_t offset, int orig)
  49. {
  50. struct mtd_file_info *mfi = file->private_data;
  51. struct mtd_info *mtd = mfi->mtd;
  52. switch (orig) {
  53. case SEEK_SET:
  54. break;
  55. case SEEK_CUR:
  56. offset += file->f_pos;
  57. break;
  58. case SEEK_END:
  59. offset += mtd->size;
  60. break;
  61. default:
  62. return -EINVAL;
  63. }
  64. if (offset >= 0 && offset <= mtd->size)
  65. return file->f_pos = offset;
  66. return -EINVAL;
  67. }
  68. static int mtd_open(struct inode *inode, struct file *file)
  69. {
  70. int minor = iminor(inode);
  71. int devnum = minor >> 1;
  72. int ret = 0;
  73. struct mtd_info *mtd;
  74. struct mtd_file_info *mfi;
  75. DEBUG(MTD_DEBUG_LEVEL0, "MTD_open\n");
  76. if (devnum >= MAX_MTD_DEVICES)
  77. return -ENODEV;
  78. /* You can't open the RO devices RW */
  79. if ((file->f_mode & 2) && (minor & 1))
  80. return -EACCES;
  81. lock_kernel();
  82. mtd = get_mtd_device(NULL, devnum);
  83. if (IS_ERR(mtd)) {
  84. ret = PTR_ERR(mtd);
  85. goto out;
  86. }
  87. if (MTD_ABSENT == mtd->type) {
  88. put_mtd_device(mtd);
  89. ret = -ENODEV;
  90. goto out;
  91. }
  92. /* You can't open it RW if it's not a writeable device */
  93. if ((file->f_mode & 2) && !(mtd->flags & MTD_WRITEABLE)) {
  94. put_mtd_device(mtd);
  95. ret = -EACCES;
  96. goto out;
  97. }
  98. mfi = kzalloc(sizeof(*mfi), GFP_KERNEL);
  99. if (!mfi) {
  100. put_mtd_device(mtd);
  101. ret = -ENOMEM;
  102. goto out;
  103. }
  104. mfi->mtd = mtd;
  105. file->private_data = mfi;
  106. out:
  107. unlock_kernel();
  108. return ret;
  109. } /* mtd_open */
  110. /*====================================================================*/
  111. static int mtd_close(struct inode *inode, struct file *file)
  112. {
  113. struct mtd_file_info *mfi = file->private_data;
  114. struct mtd_info *mtd = mfi->mtd;
  115. DEBUG(MTD_DEBUG_LEVEL0, "MTD_close\n");
  116. /* Only sync if opened RW */
  117. if ((file->f_mode & 2) && mtd->sync)
  118. mtd->sync(mtd);
  119. put_mtd_device(mtd);
  120. file->private_data = NULL;
  121. kfree(mfi);
  122. return 0;
  123. } /* mtd_close */
  124. /* FIXME: This _really_ needs to die. In 2.5, we should lock the
  125. userspace buffer down and use it directly with readv/writev.
  126. */
  127. #define MAX_KMALLOC_SIZE 0x20000
  128. static ssize_t mtd_read(struct file *file, char __user *buf, size_t count,loff_t *ppos)
  129. {
  130. struct mtd_file_info *mfi = file->private_data;
  131. struct mtd_info *mtd = mfi->mtd;
  132. size_t retlen=0;
  133. size_t total_retlen=0;
  134. int ret=0;
  135. int len;
  136. char *kbuf;
  137. DEBUG(MTD_DEBUG_LEVEL0,"MTD_read\n");
  138. if (*ppos + count > mtd->size)
  139. count = mtd->size - *ppos;
  140. if (!count)
  141. return 0;
  142. /* FIXME: Use kiovec in 2.5 to lock down the user's buffers
  143. and pass them directly to the MTD functions */
  144. if (count > MAX_KMALLOC_SIZE)
  145. kbuf=kmalloc(MAX_KMALLOC_SIZE, GFP_KERNEL);
  146. else
  147. kbuf=kmalloc(count, GFP_KERNEL);
  148. if (!kbuf)
  149. return -ENOMEM;
  150. while (count) {
  151. if (count > MAX_KMALLOC_SIZE)
  152. len = MAX_KMALLOC_SIZE;
  153. else
  154. len = count;
  155. switch (mfi->mode) {
  156. case MTD_MODE_OTP_FACTORY:
  157. ret = mtd->read_fact_prot_reg(mtd, *ppos, len, &retlen, kbuf);
  158. break;
  159. case MTD_MODE_OTP_USER:
  160. ret = mtd->read_user_prot_reg(mtd, *ppos, len, &retlen, kbuf);
  161. break;
  162. case MTD_MODE_RAW:
  163. {
  164. struct mtd_oob_ops ops;
  165. ops.mode = MTD_OOB_RAW;
  166. ops.datbuf = kbuf;
  167. ops.oobbuf = NULL;
  168. ops.len = len;
  169. ret = mtd->read_oob(mtd, *ppos, &ops);
  170. retlen = ops.retlen;
  171. break;
  172. }
  173. default:
  174. ret = mtd->read(mtd, *ppos, len, &retlen, kbuf);
  175. }
  176. /* Nand returns -EBADMSG on ecc errors, but it returns
  177. * the data. For our userspace tools it is important
  178. * to dump areas with ecc errors !
  179. * For kernel internal usage it also might return -EUCLEAN
  180. * to signal the caller that a bitflip has occured and has
  181. * been corrected by the ECC algorithm.
  182. * Userspace software which accesses NAND this way
  183. * must be aware of the fact that it deals with NAND
  184. */
  185. if (!ret || (ret == -EUCLEAN) || (ret == -EBADMSG)) {
  186. *ppos += retlen;
  187. if (copy_to_user(buf, kbuf, retlen)) {
  188. kfree(kbuf);
  189. return -EFAULT;
  190. }
  191. else
  192. total_retlen += retlen;
  193. count -= retlen;
  194. buf += retlen;
  195. if (retlen == 0)
  196. count = 0;
  197. }
  198. else {
  199. kfree(kbuf);
  200. return ret;
  201. }
  202. }
  203. kfree(kbuf);
  204. return total_retlen;
  205. } /* mtd_read */
  206. static ssize_t mtd_write(struct file *file, const char __user *buf, size_t count,loff_t *ppos)
  207. {
  208. struct mtd_file_info *mfi = file->private_data;
  209. struct mtd_info *mtd = mfi->mtd;
  210. char *kbuf;
  211. size_t retlen;
  212. size_t total_retlen=0;
  213. int ret=0;
  214. int len;
  215. DEBUG(MTD_DEBUG_LEVEL0,"MTD_write\n");
  216. if (*ppos == mtd->size)
  217. return -ENOSPC;
  218. if (*ppos + count > mtd->size)
  219. count = mtd->size - *ppos;
  220. if (!count)
  221. return 0;
  222. if (count > MAX_KMALLOC_SIZE)
  223. kbuf=kmalloc(MAX_KMALLOC_SIZE, GFP_KERNEL);
  224. else
  225. kbuf=kmalloc(count, GFP_KERNEL);
  226. if (!kbuf)
  227. return -ENOMEM;
  228. while (count) {
  229. if (count > MAX_KMALLOC_SIZE)
  230. len = MAX_KMALLOC_SIZE;
  231. else
  232. len = count;
  233. if (copy_from_user(kbuf, buf, len)) {
  234. kfree(kbuf);
  235. return -EFAULT;
  236. }
  237. switch (mfi->mode) {
  238. case MTD_MODE_OTP_FACTORY:
  239. ret = -EROFS;
  240. break;
  241. case MTD_MODE_OTP_USER:
  242. if (!mtd->write_user_prot_reg) {
  243. ret = -EOPNOTSUPP;
  244. break;
  245. }
  246. ret = mtd->write_user_prot_reg(mtd, *ppos, len, &retlen, kbuf);
  247. break;
  248. case MTD_MODE_RAW:
  249. {
  250. struct mtd_oob_ops ops;
  251. ops.mode = MTD_OOB_RAW;
  252. ops.datbuf = kbuf;
  253. ops.oobbuf = NULL;
  254. ops.len = len;
  255. ret = mtd->write_oob(mtd, *ppos, &ops);
  256. retlen = ops.retlen;
  257. break;
  258. }
  259. default:
  260. ret = (*(mtd->write))(mtd, *ppos, len, &retlen, kbuf);
  261. }
  262. if (!ret) {
  263. *ppos += retlen;
  264. total_retlen += retlen;
  265. count -= retlen;
  266. buf += retlen;
  267. }
  268. else {
  269. kfree(kbuf);
  270. return ret;
  271. }
  272. }
  273. kfree(kbuf);
  274. return total_retlen;
  275. } /* mtd_write */
  276. /*======================================================================
  277. IOCTL calls for getting device parameters.
  278. ======================================================================*/
  279. static void mtdchar_erase_callback (struct erase_info *instr)
  280. {
  281. wake_up((wait_queue_head_t *)instr->priv);
  282. }
  283. #if defined(CONFIG_MTD_OTP) || defined(CONFIG_MTD_ONENAND_OTP)
  284. static int otp_select_filemode(struct mtd_file_info *mfi, int mode)
  285. {
  286. struct mtd_info *mtd = mfi->mtd;
  287. int ret = 0;
  288. switch (mode) {
  289. case MTD_OTP_FACTORY:
  290. if (!mtd->read_fact_prot_reg)
  291. ret = -EOPNOTSUPP;
  292. else
  293. mfi->mode = MTD_MODE_OTP_FACTORY;
  294. break;
  295. case MTD_OTP_USER:
  296. if (!mtd->read_fact_prot_reg)
  297. ret = -EOPNOTSUPP;
  298. else
  299. mfi->mode = MTD_MODE_OTP_USER;
  300. break;
  301. default:
  302. ret = -EINVAL;
  303. case MTD_OTP_OFF:
  304. break;
  305. }
  306. return ret;
  307. }
  308. #else
  309. # define otp_select_filemode(f,m) -EOPNOTSUPP
  310. #endif
  311. static int mtd_ioctl(struct inode *inode, struct file *file,
  312. u_int cmd, u_long arg)
  313. {
  314. struct mtd_file_info *mfi = file->private_data;
  315. struct mtd_info *mtd = mfi->mtd;
  316. void __user *argp = (void __user *)arg;
  317. int ret = 0;
  318. u_long size;
  319. struct mtd_info_user info;
  320. DEBUG(MTD_DEBUG_LEVEL0, "MTD_ioctl\n");
  321. size = (cmd & IOCSIZE_MASK) >> IOCSIZE_SHIFT;
  322. if (cmd & IOC_IN) {
  323. if (!access_ok(VERIFY_READ, argp, size))
  324. return -EFAULT;
  325. }
  326. if (cmd & IOC_OUT) {
  327. if (!access_ok(VERIFY_WRITE, argp, size))
  328. return -EFAULT;
  329. }
  330. switch (cmd) {
  331. case MEMGETREGIONCOUNT:
  332. if (copy_to_user(argp, &(mtd->numeraseregions), sizeof(int)))
  333. return -EFAULT;
  334. break;
  335. case MEMGETREGIONINFO:
  336. {
  337. struct region_info_user ur;
  338. if (copy_from_user(&ur, argp, sizeof(struct region_info_user)))
  339. return -EFAULT;
  340. if (ur.regionindex >= mtd->numeraseregions)
  341. return -EINVAL;
  342. if (copy_to_user(argp, &(mtd->eraseregions[ur.regionindex]),
  343. sizeof(struct mtd_erase_region_info)))
  344. return -EFAULT;
  345. break;
  346. }
  347. case MEMGETINFO:
  348. info.type = mtd->type;
  349. info.flags = mtd->flags;
  350. info.size = mtd->size;
  351. info.erasesize = mtd->erasesize;
  352. info.writesize = mtd->writesize;
  353. info.oobsize = mtd->oobsize;
  354. /* The below fields are obsolete */
  355. info.ecctype = -1;
  356. info.eccsize = 0;
  357. if (copy_to_user(argp, &info, sizeof(struct mtd_info_user)))
  358. return -EFAULT;
  359. break;
  360. case MEMERASE:
  361. {
  362. struct erase_info *erase;
  363. if(!(file->f_mode & 2))
  364. return -EPERM;
  365. erase=kzalloc(sizeof(struct erase_info),GFP_KERNEL);
  366. if (!erase)
  367. ret = -ENOMEM;
  368. else {
  369. wait_queue_head_t waitq;
  370. DECLARE_WAITQUEUE(wait, current);
  371. init_waitqueue_head(&waitq);
  372. if (copy_from_user(&erase->addr, argp,
  373. sizeof(struct erase_info_user))) {
  374. kfree(erase);
  375. return -EFAULT;
  376. }
  377. erase->mtd = mtd;
  378. erase->callback = mtdchar_erase_callback;
  379. erase->priv = (unsigned long)&waitq;
  380. /*
  381. FIXME: Allow INTERRUPTIBLE. Which means
  382. not having the wait_queue head on the stack.
  383. If the wq_head is on the stack, and we
  384. leave because we got interrupted, then the
  385. wq_head is no longer there when the
  386. callback routine tries to wake us up.
  387. */
  388. ret = mtd->erase(mtd, erase);
  389. if (!ret) {
  390. set_current_state(TASK_UNINTERRUPTIBLE);
  391. add_wait_queue(&waitq, &wait);
  392. if (erase->state != MTD_ERASE_DONE &&
  393. erase->state != MTD_ERASE_FAILED)
  394. schedule();
  395. remove_wait_queue(&waitq, &wait);
  396. set_current_state(TASK_RUNNING);
  397. ret = (erase->state == MTD_ERASE_FAILED)?-EIO:0;
  398. }
  399. kfree(erase);
  400. }
  401. break;
  402. }
  403. case MEMWRITEOOB:
  404. {
  405. struct mtd_oob_buf buf;
  406. struct mtd_oob_ops ops;
  407. uint32_t retlen;
  408. if(!(file->f_mode & 2))
  409. return -EPERM;
  410. if (copy_from_user(&buf, argp, sizeof(struct mtd_oob_buf)))
  411. return -EFAULT;
  412. if (buf.length > 4096)
  413. return -EINVAL;
  414. if (!mtd->write_oob)
  415. ret = -EOPNOTSUPP;
  416. else
  417. ret = access_ok(VERIFY_READ, buf.ptr,
  418. buf.length) ? 0 : EFAULT;
  419. if (ret)
  420. return ret;
  421. ops.ooblen = buf.length;
  422. ops.ooboffs = buf.start & (mtd->oobsize - 1);
  423. ops.datbuf = NULL;
  424. ops.mode = MTD_OOB_PLACE;
  425. if (ops.ooboffs && ops.ooblen > (mtd->oobsize - ops.ooboffs))
  426. return -EINVAL;
  427. ops.oobbuf = kmalloc(buf.length, GFP_KERNEL);
  428. if (!ops.oobbuf)
  429. return -ENOMEM;
  430. if (copy_from_user(ops.oobbuf, buf.ptr, buf.length)) {
  431. kfree(ops.oobbuf);
  432. return -EFAULT;
  433. }
  434. buf.start &= ~(mtd->oobsize - 1);
  435. ret = mtd->write_oob(mtd, buf.start, &ops);
  436. if (ops.oobretlen > 0xFFFFFFFFU)
  437. ret = -EOVERFLOW;
  438. retlen = ops.oobretlen;
  439. if (copy_to_user(&((struct mtd_oob_buf *)argp)->length,
  440. &retlen, sizeof(buf.length)))
  441. ret = -EFAULT;
  442. kfree(ops.oobbuf);
  443. break;
  444. }
  445. case MEMREADOOB:
  446. {
  447. struct mtd_oob_buf buf;
  448. struct mtd_oob_ops ops;
  449. if (copy_from_user(&buf, argp, sizeof(struct mtd_oob_buf)))
  450. return -EFAULT;
  451. if (buf.length > 4096)
  452. return -EINVAL;
  453. if (!mtd->read_oob)
  454. ret = -EOPNOTSUPP;
  455. else
  456. ret = access_ok(VERIFY_WRITE, buf.ptr,
  457. buf.length) ? 0 : -EFAULT;
  458. if (ret)
  459. return ret;
  460. ops.ooblen = buf.length;
  461. ops.ooboffs = buf.start & (mtd->oobsize - 1);
  462. ops.datbuf = NULL;
  463. ops.mode = MTD_OOB_PLACE;
  464. if (ops.ooboffs && ops.ooblen > (mtd->oobsize - ops.ooboffs))
  465. return -EINVAL;
  466. ops.oobbuf = kmalloc(buf.length, GFP_KERNEL);
  467. if (!ops.oobbuf)
  468. return -ENOMEM;
  469. buf.start &= ~(mtd->oobsize - 1);
  470. ret = mtd->read_oob(mtd, buf.start, &ops);
  471. if (put_user(ops.oobretlen, (uint32_t __user *)argp))
  472. ret = -EFAULT;
  473. else if (ops.oobretlen && copy_to_user(buf.ptr, ops.oobbuf,
  474. ops.oobretlen))
  475. ret = -EFAULT;
  476. kfree(ops.oobbuf);
  477. break;
  478. }
  479. case MEMLOCK:
  480. {
  481. struct erase_info_user info;
  482. if (copy_from_user(&info, argp, sizeof(info)))
  483. return -EFAULT;
  484. if (!mtd->lock)
  485. ret = -EOPNOTSUPP;
  486. else
  487. ret = mtd->lock(mtd, info.start, info.length);
  488. break;
  489. }
  490. case MEMUNLOCK:
  491. {
  492. struct erase_info_user info;
  493. if (copy_from_user(&info, argp, sizeof(info)))
  494. return -EFAULT;
  495. if (!mtd->unlock)
  496. ret = -EOPNOTSUPP;
  497. else
  498. ret = mtd->unlock(mtd, info.start, info.length);
  499. break;
  500. }
  501. /* Legacy interface */
  502. case MEMGETOOBSEL:
  503. {
  504. struct nand_oobinfo oi;
  505. if (!mtd->ecclayout)
  506. return -EOPNOTSUPP;
  507. if (mtd->ecclayout->eccbytes > ARRAY_SIZE(oi.eccpos))
  508. return -EINVAL;
  509. oi.useecc = MTD_NANDECC_AUTOPLACE;
  510. memcpy(&oi.eccpos, mtd->ecclayout->eccpos, sizeof(oi.eccpos));
  511. memcpy(&oi.oobfree, mtd->ecclayout->oobfree,
  512. sizeof(oi.oobfree));
  513. oi.eccbytes = mtd->ecclayout->eccbytes;
  514. if (copy_to_user(argp, &oi, sizeof(struct nand_oobinfo)))
  515. return -EFAULT;
  516. break;
  517. }
  518. case MEMGETBADBLOCK:
  519. {
  520. loff_t offs;
  521. if (copy_from_user(&offs, argp, sizeof(loff_t)))
  522. return -EFAULT;
  523. if (!mtd->block_isbad)
  524. ret = -EOPNOTSUPP;
  525. else
  526. return mtd->block_isbad(mtd, offs);
  527. break;
  528. }
  529. case MEMSETBADBLOCK:
  530. {
  531. loff_t offs;
  532. if (copy_from_user(&offs, argp, sizeof(loff_t)))
  533. return -EFAULT;
  534. if (!mtd->block_markbad)
  535. ret = -EOPNOTSUPP;
  536. else
  537. return mtd->block_markbad(mtd, offs);
  538. break;
  539. }
  540. #if defined(CONFIG_MTD_OTP) || defined(CONFIG_MTD_ONENAND_OTP)
  541. case OTPSELECT:
  542. {
  543. int mode;
  544. if (copy_from_user(&mode, argp, sizeof(int)))
  545. return -EFAULT;
  546. mfi->mode = MTD_MODE_NORMAL;
  547. ret = otp_select_filemode(mfi, mode);
  548. file->f_pos = 0;
  549. break;
  550. }
  551. case OTPGETREGIONCOUNT:
  552. case OTPGETREGIONINFO:
  553. {
  554. struct otp_info *buf = kmalloc(4096, GFP_KERNEL);
  555. if (!buf)
  556. return -ENOMEM;
  557. ret = -EOPNOTSUPP;
  558. switch (mfi->mode) {
  559. case MTD_MODE_OTP_FACTORY:
  560. if (mtd->get_fact_prot_info)
  561. ret = mtd->get_fact_prot_info(mtd, buf, 4096);
  562. break;
  563. case MTD_MODE_OTP_USER:
  564. if (mtd->get_user_prot_info)
  565. ret = mtd->get_user_prot_info(mtd, buf, 4096);
  566. break;
  567. default:
  568. break;
  569. }
  570. if (ret >= 0) {
  571. if (cmd == OTPGETREGIONCOUNT) {
  572. int nbr = ret / sizeof(struct otp_info);
  573. ret = copy_to_user(argp, &nbr, sizeof(int));
  574. } else
  575. ret = copy_to_user(argp, buf, ret);
  576. if (ret)
  577. ret = -EFAULT;
  578. }
  579. kfree(buf);
  580. break;
  581. }
  582. case OTPLOCK:
  583. {
  584. struct otp_info info;
  585. if (mfi->mode != MTD_MODE_OTP_USER)
  586. return -EINVAL;
  587. if (copy_from_user(&info, argp, sizeof(info)))
  588. return -EFAULT;
  589. if (!mtd->lock_user_prot_reg)
  590. return -EOPNOTSUPP;
  591. ret = mtd->lock_user_prot_reg(mtd, info.start, info.length);
  592. break;
  593. }
  594. #endif
  595. case ECCGETLAYOUT:
  596. {
  597. if (!mtd->ecclayout)
  598. return -EOPNOTSUPP;
  599. if (copy_to_user(argp, mtd->ecclayout,
  600. sizeof(struct nand_ecclayout)))
  601. return -EFAULT;
  602. break;
  603. }
  604. case ECCGETSTATS:
  605. {
  606. if (copy_to_user(argp, &mtd->ecc_stats,
  607. sizeof(struct mtd_ecc_stats)))
  608. return -EFAULT;
  609. break;
  610. }
  611. case MTDFILEMODE:
  612. {
  613. mfi->mode = 0;
  614. switch(arg) {
  615. case MTD_MODE_OTP_FACTORY:
  616. case MTD_MODE_OTP_USER:
  617. ret = otp_select_filemode(mfi, arg);
  618. break;
  619. case MTD_MODE_RAW:
  620. if (!mtd->read_oob || !mtd->write_oob)
  621. return -EOPNOTSUPP;
  622. mfi->mode = arg;
  623. case MTD_MODE_NORMAL:
  624. break;
  625. default:
  626. ret = -EINVAL;
  627. }
  628. file->f_pos = 0;
  629. break;
  630. }
  631. default:
  632. ret = -ENOTTY;
  633. }
  634. return ret;
  635. } /* memory_ioctl */
  636. static const struct file_operations mtd_fops = {
  637. .owner = THIS_MODULE,
  638. .llseek = mtd_lseek,
  639. .read = mtd_read,
  640. .write = mtd_write,
  641. .ioctl = mtd_ioctl,
  642. .open = mtd_open,
  643. .release = mtd_close,
  644. };
  645. static int __init init_mtdchar(void)
  646. {
  647. if (register_chrdev(MTD_CHAR_MAJOR, "mtd", &mtd_fops)) {
  648. printk(KERN_NOTICE "Can't allocate major number %d for Memory Technology Devices.\n",
  649. MTD_CHAR_MAJOR);
  650. return -EAGAIN;
  651. }
  652. mtd_class = class_create(THIS_MODULE, "mtd");
  653. if (IS_ERR(mtd_class)) {
  654. printk(KERN_ERR "Error creating mtd class.\n");
  655. unregister_chrdev(MTD_CHAR_MAJOR, "mtd");
  656. return PTR_ERR(mtd_class);
  657. }
  658. register_mtd_user(&notifier);
  659. return 0;
  660. }
  661. static void __exit cleanup_mtdchar(void)
  662. {
  663. unregister_mtd_user(&notifier);
  664. class_destroy(mtd_class);
  665. unregister_chrdev(MTD_CHAR_MAJOR, "mtd");
  666. }
  667. module_init(init_mtdchar);
  668. module_exit(cleanup_mtdchar);
  669. MODULE_LICENSE("GPL");
  670. MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
  671. MODULE_DESCRIPTION("Direct character-device access to MTD devices");