开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
mtdchar-compat.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：12k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

mtdchar-compat.c：源码内容
  1. /*
  2.  * $Id: mtdchar-compat.c,v 1.2 2001/10/02 15:05:11 dwmw2 Exp $
  3.  *
  4.  * Character-device access to raw MTD devices.
  5.  *
  6.  */
  9. #include <linux/mtd/compatmac.h>
  10. #include <linux/config.h>
  11. #include <linux/kernel.h>
  12. #include <linux/module.h>
  13. #include <linux/mtd/mtd.h>
  14. #include <linux/slab.h>
  16. #ifdef CONFIG_DEVFS_FS
  17. #include <linux/devfs_fs_kernel.h>
  18. static void mtd_notify_add(struct mtd_info* mtd);
  19. static void mtd_notify_remove(struct mtd_info* mtd);
  21. static struct mtd_notifier notifier = {
  22. add: mtd_notify_add,
  23. remove: mtd_notify_remove,
  24. };
  26. static devfs_handle_t devfs_dir_handle;
  27. static devfs_handle_t devfs_rw_handle[MAX_MTD_DEVICES];
  28. static devfs_handle_t devfs_ro_handle[MAX_MTD_DEVICES];
  29. #endif
  31. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
  32. static loff_t mtd_lseek (struct file *file, loff_t offset, int orig)
  33. #else
  34. static int mtd_lseek (struct inode *inode, struct file *file, off_t offset, int orig)
  35. #endif
  36. {
  37. struct mtd_info *mtd=(struct mtd_info *)file->private_data;
  39. switch (orig) {
  40. case 0:
  41. /* SEEK_SET */
  42. file->f_pos = offset;
  43. break;
  44. case 1:
  45. /* SEEK_CUR */
  46. file->f_pos += offset;
  47. break;
  48. case 2:
  49. /* SEEK_END */
  50. file->f_pos =mtd->size + offset;
  51. break;
  52. default:
  53. return -EINVAL;
  54. }
  56. if (file->f_pos < 0)
  57. file->f_pos = 0;
  58. else if (file->f_pos >= mtd->size)
  59. file->f_pos = mtd->size - 1;
  61. return file->f_pos;
  62. }
  66. static int mtd_open(struct inode *inode, struct file *file)
  67. {
  68. int minor = MINOR(inode->i_rdev);
  69. int devnum = minor >> 1;
  70. struct mtd_info *mtd;
  72. DEBUG(MTD_DEBUG_LEVEL0, "MTD_openn");
  74. if (devnum >= MAX_MTD_DEVICES)
  75. return -ENODEV;
  77. /* You can't open the RO devices RW */
  78. if ((file->f_mode & 2) && (minor & 1))
  79. return -EACCES;
  81. mtd = get_mtd_device(NULL, devnum);
  82. if (!mtd)
  83. return -ENODEV;
  84. if (MTD_ABSENT == mtd->type) {
  85. put_mtd_device(mtd);
  86. return -ENODEV;
  87. }
  89. MOD_INC_USE_COUNT;
  91. file->private_data = mtd;
  93. /* You can't open it RW if it's not a writeable device */
  94. if ((file->f_mode & 2) && !(mtd->flags & MTD_WRITEABLE)) {
  95. put_mtd_device(mtd);
  96. MOD_DEC_USE_COUNT;
  97. return -EACCES;
  98. }
  100. return 0;
  101. } /* mtd_open */
  103. /*====================================================================*/
  105. static release_t mtd_close(struct inode *inode,
  106.  struct file *file)
  107. {
  108. struct mtd_info *mtd;
  110. DEBUG(MTD_DEBUG_LEVEL0, "MTD_closen");
  112. mtd = (struct mtd_info *)file->private_data;
  114. if (mtd->sync)
  115. mtd->sync(mtd);
  117. put_mtd_device(mtd);
  119. MOD_DEC_USE_COUNT;
  120. release_return(0);
  121. } /* mtd_close */
  123. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
  124. #define FILE_POS *ppos
  125. #else
  126. #define FILE_POS file->f_pos
  127. #endif
  129. /* FIXME: This _really_ needs to die. In 2.5, we should lock the
  130.    userspace buffer down and use it directly with readv/writev.
  131. */
  132. #define MAX_KMALLOC_SIZE 0x20000
  134. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
  135. static ssize_t mtd_read(struct file *file, char *buf, size_t count,loff_t *ppos)
  136. #else
  137. static int mtd_read(struct inode *inode,struct file *file, char *buf, int count)
  138. #endif
  139. {
  140. struct mtd_info *mtd = (struct mtd_info *)file->private_data;
  141. size_t retlen=0;
  142. size_t total_retlen=0;
  143. int ret=0;
  144. #ifndef NO_MM
  145. int len;
  146. char *kbuf;
  147. #endif
  148. DEBUG(MTD_DEBUG_LEVEL0,"MTD_readn");
  150. if (FILE_POS + count > mtd->size)
  151. count = mtd->size - FILE_POS;
  153. if (!count)
  154. return 0;
  156. /* FIXME: Use kiovec in 2.3 or 2.2+rawio, or at
  157.  * least split the IO into smaller chunks.
  158.  */
  159. #ifdef NO_MM
  160. ret = MTD_READ(mtd, FILE_POS, count, &retlen, buf);
  161. if (!ret) {
  162. FILE_POS += retlen;
  163. ret = retlen;
  164. }
  165. total_retlen = ret;
  166. #else
  167. while (count) {
  168. if (count > MAX_KMALLOC_SIZE) 
  169. len = MAX_KMALLOC_SIZE;
  170. else
  171. len = count;
  173. kbuf=kmalloc(len,GFP_KERNEL);
  174. if (!kbuf)
  175. return -ENOMEM;
  177. ret = MTD_READ(mtd, FILE_POS, len, &retlen, kbuf);
  178. if (!ret) {
  179. FILE_POS += retlen;
  180. if (copy_to_user(buf, kbuf, retlen)) {
  181.         kfree(kbuf);
  182. return -EFAULT;
  183. }
  184. else
  185. total_retlen += retlen;
  187. count -= retlen;
  188. buf += retlen;
  189. }
  190. else {
  191. kfree(kbuf);
  192. return ret;
  193. }
  195. kfree(kbuf);
  196. }
  198. #endif
  199. return total_retlen;
  200. } /* mtd_read */
  202. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
  203. static ssize_t mtd_write(struct file *file, const char *buf, size_t count,loff_t *ppos)
  204. #else
  205. static read_write_t mtd_write(struct inode *inode,struct file *file, const char *buf, count_t count)
  206. #endif
  207. {
  208. struct mtd_info *mtd = (struct mtd_info *)file->private_data;
  209. size_t retlen;
  210. size_t total_retlen=0;
  211. int ret=0;
  212. #ifndef NO_MM
  213. int len;
  214. char *kbuf;
  215. #endif
  217. DEBUG(MTD_DEBUG_LEVEL0,"MTD_writen");
  219. if (FILE_POS == mtd->size)
  220. return -ENOSPC;
  222. if (FILE_POS + count > mtd->size)
  223. count = mtd->size - FILE_POS;
  225. if (!count)
  226. return 0;
  228. #ifdef NO_MM
  229. ret = MTD_WRITE(mtd, FILE_POS, count, &retlen, buf);
  230. if (!ret) {
  231. FILE_POS += retlen;
  232. ret = retlen;
  233. }
  234. total_retlen = ret;
  235. #else
  236. while (count) {
  237. if (count > MAX_KMALLOC_SIZE) 
  238. len = MAX_KMALLOC_SIZE;
  239. else
  240. len = count;
  242. kbuf=kmalloc(len,GFP_KERNEL);
  243. if (!kbuf) {
  244. printk("kmalloc is nulln");
  245. return -ENOMEM;
  246. }
  248. if (copy_from_user(kbuf, buf, len)) {
  249. kfree(kbuf);
  250. return -EFAULT;
  251. }
  253.         ret = (*(mtd->write))(mtd, FILE_POS, len, &retlen, kbuf);
  254. if (!ret) {
  255. FILE_POS += retlen;
  256. total_retlen += retlen;
  257. count -= retlen;
  258. buf += retlen;
  259. }
  260. else {
  261. kfree(kbuf);
  262. return ret;
  263. }
  265. kfree(kbuf);
  266. }
  267. #endif
  268. return total_retlen;
  269. } /* mtd_write */
  271. /*======================================================================
  273.     IOCTL calls for getting device parameters.
  275. ======================================================================*/
  276. static void mtd_erase_callback (struct erase_info *instr)
  277. {
  278. wake_up((wait_queue_head_t *)instr->priv);
  279. }
  281. static int mtd_ioctl(struct inode *inode, struct file *file,
  282.      u_int cmd, u_long arg)
  283. {
  284. struct mtd_info *mtd = (struct mtd_info *)file->private_data;
  285. int ret = 0;
  286. u_long size;
  288. DEBUG(MTD_DEBUG_LEVEL0, "MTD_ioctln");
  290. size = (cmd & IOCSIZE_MASK) >> IOCSIZE_SHIFT;
  291. if (cmd & IOC_IN) {
  292. ret = verify_area(VERIFY_READ, (char *)arg, size);
  293. if (ret) return ret;
  294. }
  295. if (cmd & IOC_OUT) {
  296. ret = verify_area(VERIFY_WRITE, (char *)arg, size);
  297. if (ret) return ret;
  298. }
  300. switch (cmd) {
  301. case MEMGETREGIONCOUNT:
  302. if (copy_to_user((int *) arg, &(mtd->numeraseregions), sizeof(int)))
  303. return -EFAULT;
  304. break;
  306. case MEMGETREGIONINFO:
  307. {
  308. struct region_info_user ur;
  310. if (copy_from_user( &ur, 
  311. (struct region_info_user *)arg, 
  312. sizeof(struct region_info_user))) {
  313. return -EFAULT;
  314. }
  316. if (ur.regionindex >= mtd->numeraseregions)
  317. return -EINVAL;
  318. if (copy_to_user((struct mtd_erase_region_info *) arg, 
  319. &(mtd->eraseregions[ur.regionindex]),
  320. sizeof(struct mtd_erase_region_info)))
  321. return -EFAULT;
  322. break;
  323. }
  325. case MEMGETINFO:
  326. if (copy_to_user((struct mtd_info *)arg, mtd,
  327.  sizeof(struct mtd_info_user)))
  328. return -EFAULT;
  329. break;
  331. case MEMERASE:
  332. {
  333. struct erase_info *erase=kmalloc(sizeof(struct erase_info),GFP_KERNEL);
  334. if (!erase)
  335. ret = -ENOMEM;
  336. else {
  337. wait_queue_head_t waitq;
  338. DECLARE_WAITQUEUE(wait, current);
  340. init_waitqueue_head(&waitq);
  342. memset (erase,0,sizeof(struct erase_info));
  343. if (copy_from_user(&erase->addr, (u_long *)arg,
  344.    2 * sizeof(u_long))) {
  345. kfree(erase);
  346. return -EFAULT;
  347. }
  348. erase->mtd = mtd;
  349. erase->callback = mtd_erase_callback;
  350. erase->priv = (unsigned long)&waitq;
  352. /*
  353.   FIXME: Allow INTERRUPTIBLE. Which means
  354.   not having the wait_queue head on the stack.
  355.   
  356.   If the wq_head is on the stack, and we
  357.   leave because we got interrupted, then the
  358.   wq_head is no longer there when the
  359.   callback routine tries to wake us up.
  360. */
  361. ret = mtd->erase(mtd, erase);
  362. if (!ret) {
  363. set_current_state(TASK_UNINTERRUPTIBLE);
  364. add_wait_queue(&waitq, &wait);
  365. if (erase->state != MTD_ERASE_DONE &&
  366.     erase->state != MTD_ERASE_FAILED)
  367. schedule();
  368. remove_wait_queue(&waitq, &wait);
  369. set_current_state(TASK_RUNNING);
  371. ret = (erase->state == MTD_ERASE_FAILED)?-EIO:0;
  372. }
  373. kfree(erase);
  374. }
  375. break;
  376. }
  378. case MEMWRITEOOB:
  379. {
  380. struct mtd_oob_buf buf;
  381. void *databuf;
  382. ssize_t retlen;
  384. if (copy_from_user(&buf, (struct mtd_oob_buf *)arg, sizeof(struct mtd_oob_buf)))
  385. return -EFAULT;
  387. if (buf.length > 0x4096)
  388. return -EINVAL;
  390. if (!mtd->write_oob)
  391. ret = -EOPNOTSUPP;
  392. else
  393. ret = verify_area(VERIFY_READ, (char *)buf.ptr, buf.length);
  395. if (ret)
  396. return ret;
  398. databuf = kmalloc(buf.length, GFP_KERNEL);
  399. if (!databuf)
  400. return -ENOMEM;
  402. if (copy_from_user(databuf, buf.ptr, buf.length)) {
  403. kfree(databuf);
  404. return -EFAULT;
  405. }
  407. ret = (mtd->write_oob)(mtd, buf.start, buf.length, &retlen, databuf);
  409. if (copy_to_user((void *)arg + sizeof(u_int32_t), &retlen, sizeof(u_int32_t)))
  410. ret = -EFAULT;
  412. kfree(databuf);
  413. break;
  415. }
  417. case MEMREADOOB:
  418. {
  419. struct mtd_oob_buf buf;
  420. void *databuf;
  421. ssize_t retlen;
  423. if (copy_from_user(&buf, (struct mtd_oob_buf *)arg, sizeof(struct mtd_oob_buf)))
  424. return -EFAULT;
  426. if (buf.length > 0x4096)
  427. return -EINVAL;
  429. if (!mtd->read_oob)
  430. ret = -EOPNOTSUPP;
  431. else
  432. ret = verify_area(VERIFY_WRITE, (char *)buf.ptr, buf.length);
  434. if (ret)
  435. return ret;
  437. databuf = kmalloc(buf.length, GFP_KERNEL);
  438. if (!databuf)
  439. return -ENOMEM;
  441. ret = (mtd->read_oob)(mtd, buf.start, buf.length, &retlen, databuf);
  443. if (copy_to_user((void *)arg + sizeof(u_int32_t), &retlen, sizeof(u_int32_t)))
  444. ret = -EFAULT;
  445. else if (retlen && copy_to_user(buf.ptr, databuf, retlen))
  446. ret = -EFAULT;
  448. kfree(databuf);
  449. break;
  450. }
  452. case MEMLOCK:
  453. {
  454. unsigned long adrs[2];
  456. if (copy_from_user(adrs ,(void *)arg, 2* sizeof(unsigned long)))
  457. return -EFAULT;
  459. if (!mtd->lock)
  460. ret = -EOPNOTSUPP;
  461. else
  462. ret = mtd->lock(mtd, adrs[0], adrs[1]);
  463. break;
  464. }
  466. case MEMUNLOCK:
  467. {
  468. unsigned long adrs[2];
  470. if (copy_from_user(adrs, (void *)arg, 2* sizeof(unsigned long)))
  471. return -EFAULT;
  473. if (!mtd->unlock)
  474. ret = -EOPNOTSUPP;
  475. else
  476. ret = mtd->unlock(mtd, adrs[0], adrs[1]);
  477. break;
  478. }
  481. default:
  482. DEBUG(MTD_DEBUG_LEVEL0, "Invalid ioctl %x (MEMGETINFO = %x)n", cmd, MEMGETINFO);
  483. ret = -ENOTTY;
  484. }
  486. return ret;
  487. } /* memory_ioctl */
  489. static struct file_operations mtd_fops = {
  490. #if LINUX_VERSION_CODE >= 0x20300 /* Someone knows when these made their debut? */
  491. owner: THIS_MODULE,
  492. #endif
  493. #if LINUX_VERSION_CODE >=0x20200
  494. llseek: mtd_lseek,      /* lseek */
  495. #else
  496. lseek: mtd_lseek,      /* lseek */
  497. #endif
  498. read: mtd_read, /* read */
  499. write:  mtd_write,  /* write */
  500. ioctl: mtd_ioctl, /* ioctl */
  501. open: mtd_open, /* open */
  502. release: mtd_close, /* release */
  503. };
  506. #ifdef CONFIG_DEVFS_FS
  507. /* Notification that a new device has been added. Create the devfs entry for
  508.  * it. */
  510. static void mtd_notify_add(struct mtd_info* mtd)
  511. {
  512. char name[8];
  514. if (!mtd)
  515. return;
  517. sprintf(name, "%d", mtd->index);
  518. devfs_rw_handle[mtd->index] = devfs_register(devfs_dir_handle, name,
  519. DEVFS_FL_DEFAULT, MTD_CHAR_MAJOR, mtd->index*2,
  520. S_IFCHR | S_IRUGO | S_IWUGO,
  521. &mtd_fops, NULL);
  523. sprintf(name, "%dro", mtd->index);
  524. devfs_ro_handle[mtd->index] = devfs_register(devfs_dir_handle, name,
  525. DEVFS_FL_DEFAULT, MTD_CHAR_MAJOR, mtd->index*2+1,
  526. S_IFCHR | S_IRUGO | S_IWUGO,
  527. &mtd_fops, NULL);
  528. }
  530. static void mtd_notify_remove(struct mtd_info* mtd)
  531. {
  532. if (!mtd)
  533. return;
  535. devfs_unregister(devfs_rw_handle[mtd->index]);
  536. devfs_unregister(devfs_ro_handle[mtd->index]);
  537. }
  538. #endif
  540. #if LINUX_VERSION_CODE < 0x20212 && defined(MODULE)
  541. #define init_mtdchar init_module
  542. #define cleanup_mtdchar cleanup_module
  543. #endif
  545. mod_init_t init_mtdchar(void)
  546. {
  547. #ifdef CONFIG_DEVFS_FS
  548. if (devfs_register_chrdev(MTD_CHAR_MAJOR, "mtd", &mtd_fops))
  549. {
  550. printk(KERN_NOTICE "Can't allocate major number %d for Memory Technology Devices.n",
  551.        MTD_CHAR_MAJOR);
  552. return -EAGAIN;
  553. }
  555. devfs_dir_handle = devfs_mk_dir(NULL, "mtd", NULL);
  557. register_mtd_user(&notifier);
  558. #else
  559. if (register_chrdev(MTD_CHAR_MAJOR, "mtd", &mtd_fops))
  560. {
  561. printk(KERN_NOTICE "Can't allocate major number %d for Memory Technology Devices.n",
  562.        MTD_CHAR_MAJOR);
  563. return -EAGAIN;
  564. }
  565. #endif
  567. return 0;
  568. }
  570. mod_exit_t cleanup_mtdchar(void)
  571. {
  572. #ifdef CONFIG_DEVFS_FS
  573. unregister_mtd_user(&notifier);
  574. devfs_unregister(devfs_dir_handle);
  575. devfs_unregister_chrdev(MTD_CHAR_MAJOR, "mtd");
  576. #else
  577. unregister_chrdev(MTD_CHAR_MAJOR, "mtd");
  578. #endif
  579. }
  581. module_init(init_mtdchar);
  582. module_exit(cleanup_mtdchar);
  585. MODULE_LICENSE("GPL");
  586. MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
  587. MODULE_DESCRIPTION("Direct character-device access to MTD devices");