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

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

嵌入式Linux

开发平台：

Unix_Linux

bon.c：源码内容
  1. /* TODO:
  3.    (C) 2002, Mizi Research Inc.
  4.    Author: Hwang, Chideok <hwang@mizi.co.kr>
  5. */
  7. #include <linux/config.h>
  8. #include <linux/types.h>
  9. #include <linux/kernel.h>
  10. #include <linux/module.h>
  11. #include <linux/mtd/mtd.h>
  12. #include <linux/mtd/partitions.h>
  13. #include <linux/mtd/nand_ecc.h>
  14. #include <asm/errno.h>
  16. #define BON_MAJOR 97
  18. #define MAJOR_NR BON_MAJOR
  19. #define DEVICE_NAME "bon"
  20. #define DEVICE_REQUEST do_bon_request
  21. #define DEVICE_NR(device) (device)
  22. #define DEVICE_ON(device)
  23. #define DEVICE_OFF(device)
  24. #define DEVICE_NO_RANDOM
  25. #include <linux/blk.h>
  27. #include <linux/devfs_fs_kernel.h>
  29. static int PARTITION_OFFSET  = (~0);
  31. #define MAX_RETRY 5
  32. #define MAX_MTD_PART 2
  34. #define MAX_PART 5
  36. typedef struct {
  37.     unsigned long offset;
  38.     unsigned long size;
  39.     unsigned long flag;
  40.     devfs_handle_t devfs_rw_handle;
  41.     unsigned short *bad_blocks;
  42. } partition_t;
  44. static struct {
  45.     struct mtd_info *mtd;
  46.     struct mtd_info *shadow_mtd[MAX_MTD_PART];
  47.     int num_part;
  48. int num_mtd_part;
  49.     devfs_handle_t devfs_dir_handle;
  50.     partition_t parts[MAX_PART];
  51. struct mtd_partition mtd_parts[MAX_MTD_PART];
  52. } bon;
  54. static const char BON_MAGIC[8] = {'M', 0, 0, 'I', 0, 'Z', 'I', 0};
  55. static int bon_sizes[MAX_PART];
  56. static int bon_blksizes[MAX_PART];
  58. #ifdef CONFIG_PROC_FS
  59. #include <linux/proc_fs.h>
  60. static struct proc_dir_entry *proc_bon;
  62. static inline 
  63. int bon_proc_info (char *buf, int i)
  64. {
  65. partition_t *this = (partition_t *)&bon.parts[i];
  67. if (!this)
  68. return 0;
  70. return sprintf(buf, "bon%d: %8.8lx-%8.8lx (%8.8lx) %8.8lxn", i, 
  71. this->offset, this->offset + this->size, this->size, this->flag);
  72. }
  74. static int 
  75. bon_read_proc ( char *page, char **start, off_t off,int count 
  76. ,int *eof, void *data_unused)
  77. {
  78. int len, l, i;
  79. off_t   begin = 0;
  81. len = sprintf(page, "      position          size       flagn");
  83. for (i=0; i< bon.num_part; i++) { 
  84. l = bon_proc_info(page + len, i);
  85. len += l;
  86. if (len+begin > off+count)
  87. goto done;
  88. if (len+begin < off) {
  89. begin += len;
  90. len = 0;
  91. }
  92. }
  93. *eof = 1;
  95. done:
  96. if (off >= len+begin)
  97. return 0;
  98. *start = page + (off-begin);
  99. return ((count < begin+len-off) ? count : begin+len-off);
  100. }
  101. #endif // CONFIG_PROC_FS
  103. static int
  104. bon_open(struct inode *inode, struct file *file)
  105. {
  106.     int minor = MINOR(inode->i_rdev);
  107.     partition_t *part = &bon.parts[minor];
  108.     if (minor >= bon.num_part || !part->size) return -ENODEV;
  110.     get_mtd_device(bon.mtd, -1);
  112.     return 0;
  113. }
  115. static int
  116. bon_close(struct inode *inode, struct file *file)
  117. {
  118. //    int minor = MINOR(inode->i_rdev);
  119.     struct mtd_info *mtd;
  120. //    partition_t *part = &bon.parts[minor];
  122.     mtd = bon.mtd;
  124. #if LINUX_VERSION_CODE != KERNEL_VERSION(2,4,18)
  125.     invalidate_device(inode->i_rdev, 1);
  126. #endif
  127.     if (mtd->sync) mtd->sync(mtd);
  129.     put_mtd_device(mtd);
  130.     return 0;
  131. }
  133. static int
  134. bon_ioctl(struct inode *inode, struct file *file,
  135.     u_int cmd, u_long arg)
  136. {
  137.     int minor = MINOR(inode->i_rdev);
  138.     partition_t *part = &bon.parts[minor];
  140.     switch(cmd) {
  141. case BLKGETSIZE:
  142.     return put_user((part->size>>9), (long *)arg);
  143. #ifdef BLKGETSIZE64
  144. case BLKGETSIZE64:
  145.     return put_user((u64)(part->size>>9), (long *)arg);
  146. #endif
  147. case BLKFLSBUF:
  148.     if (!capable(CAP_SYS_ADMIN)) return -EACCES;
  149.     fsync_dev(inode->i_rdev);
  150.     invalidate_buffers(inode->i_rdev);
  151.     if (bon.mtd->sync) bon.mtd->sync(bon.mtd);
  152.     return 0;
  153. default:
  154.     return -ENOTTY;
  155.     }
  156. }
  158. static struct block_device_operations bon_blk_fops = {
  159.     owner: THIS_MODULE,
  160.     open: bon_open,
  161.     release: bon_close,
  162.     ioctl: bon_ioctl
  163. };
  165. static int
  166. do_read(partition_t *part, char *buf, unsigned long pos, size_t size)
  167. {
  168.     int ret, retlen;
  169.     int i;
  170.     while(size > 0) {
  171. unsigned long block = pos / bon.mtd->erasesize;
  172. unsigned long start, start_in_block;
  173. size_t this_size;
  175. if (part->bad_blocks) {
  176.     unsigned short *bad = part->bad_blocks;
  177.     while(*bad++ <= block) {
  178. block++;
  179.     }
  180. }
  181. start_in_block = pos % bon.mtd->erasesize;
  182. start = block * bon.mtd->erasesize + start_in_block;
  183. this_size = bon.mtd->erasesize - start_in_block;
  184. if (this_size > size) this_size = size;
  186. ret = MTD_READ(bon.mtd, part->offset + start, this_size, &retlen, buf);
  187. if (ret) return ret;
  188. if (this_size != retlen) return -EIO;
  190. /* ecc */
  191. for(i=0;i<this_size;i++) {
  192.     unsigned char oobbuf[16];
  193.     unsigned char *ecc1 = oobbuf + 8, *ecc2 = ecc1 + 3;
  194.     unsigned char calc_ecc[3];
  195.     size_t retlen;
  196.     int ecc_result;
  197.     MTD_READOOB(bon.mtd, part->offset + start + i, 16, &retlen, oobbuf);
  199.     nand_calculate_ecc(buf,  calc_ecc);
  200.     ecc_result = nand_correct_data(buf, ecc1, calc_ecc);
  201.     if (ecc_result == -1) {
  202. printk("bon: ecc error, page = 0x%08lxn", (part->offset + start + i) >> 9);
  203. return -EIO;
  204.     }
  205.     nand_calculate_ecc(buf + 256,  calc_ecc);
  206.     ecc_result = nand_correct_data(buf + 256, ecc2, calc_ecc);
  207.     if (ecc_result == -1) {
  208. printk("bon: ecc error, page = 0x%08lxn", (part->offset + start + i) >> 9);
  209. return -EIO;
  210.     }
  211.     i += 512;
  212. }
  213. size -= this_size;
  214. buf += this_size;
  215. pos += this_size;
  216.     }
  217.     return 0;
  218. }
  220. static void
  221. do_bon_request(request_queue_t *q)
  222. {
  223.     struct request *req;
  224. //    struct mtd_info *mtd = bon.mtd;
  225.     partition_t *part;
  226.     int res;
  228.     while (1) {
  229. INIT_REQUEST;
  230. req = CURRENT;
  231. spin_unlock_irq(&io_request_lock);
  232. res = 0;
  233. if (MINOR(req->rq_dev) >= bon.num_part) {
  234.     printk("bon: Unsupported devicesn");
  235.     goto end_req;
  236. }
  237. part = &bon.parts[MINOR(req->rq_dev)];
  238. if (req->current_nr_sectors << 9 > part->size) {
  239.     printk("bon: attempt to read past end of device!n");
  240.     goto end_req;
  241. }
  242. switch(req->cmd) {
  243.     int err;
  244.     case READ:
  245. err = do_read(part, req->buffer, 
  246.     req->sector << 9, req->current_nr_sectors << 9);
  247. if (!err) res = 1;
  248. break;
  249.     case WRITE:
  250. break;
  251. }
  252. end_req:
  253. spin_lock_irq(&io_request_lock);
  254. end_request(res);
  255.     }
  256. }
  258. static int
  259. read_partition_info(struct mtd_info *mtd)
  260. {
  261.     unsigned long offset = PARTITION_OFFSET;
  262.     int i;
  263.     char buf[512];
  264.     unsigned char oobbuf[16];
  265.     unsigned int *s;
  266.     int retlen, k;
  267.     int retry_count = MAX_RETRY;
  269.     if (offset > mtd->size - mtd->erasesize) 
  270. offset = mtd->size - mtd->erasesize;
  272.     while(retry_count-- > 0) {
  273. if (MTD_READOOB(mtd, offset, 8, &retlen, oobbuf) < 0) {
  274.     goto next_block;
  275. }
  276. if (oobbuf[5] != 0xff) {
  277.     goto next_block;
  278. }
  279. if (MTD_READ(mtd, offset, 512, &retlen, buf) < 0) {
  280.     goto next_block;
  281. }
  282. if (strncmp(buf, BON_MAGIC, 8) == 0) break;
  283. printk("bon:cannot find partition tablen");
  284. return -1;
  285. next_block:
  286.         offset -= mtd->erasesize;
  287.     }
  289.     if (retry_count <= 0) {
  290. printk("bon:cannot find partition tablen");
  291. return -1;
  292.     }
  294.     s = (unsigned int *)(buf + 8);
  295.     bon.num_part = min_t(unsigned long, *s++, MAX_PART);
  296. bon.num_mtd_part = 0;
  298.     bon.mtd = mtd;
  300.     bon.devfs_dir_handle = devfs_mk_dir(NULL, "bon", NULL);
  301.     // for each partition, make 
  302.     for(i=0;i < bon.num_part; i++) {
  303. char name[8];
  304. // int num_block;
  305. bon.parts[i].offset = *s++;
  306. bon.parts[i].size = *s++;
  307. bon.parts[i].flag = *s++;
  310. printk("bon%d: %8.8lx-%8.8lx (%8.8lx) %8.8lxn", i, 
  311. bon.parts[i].offset, bon.parts[i].offset + bon.parts[i].size, bon.parts[i].size, bon.parts[i].flag);
  314. if (bon.parts[i].flag & 0x01) {
  315. #if 0 // bushi
  316. struct mtd_partition *mtd_part;
  317. if (bon.num_mtd_part >= MAX_MTD_PART)
  318. continue;
  319.     mtd_part = &(bon.mtd_parts[bon.num_mtd_part]);
  320.     mtd_part->mask_flags = 0;
  321.     mtd_part->size = bon.parts[i].size;
  322.     mtd_part->name = "nandflash  (bon  )";
  323. sprintf(mtd_part->name, "nandflash%d (bon%d)", bon.num_mtd_part, i);
  324.     mtd_part->offset = bon.parts[i].offset;
  325. mtd_part->mtdp = &bon.shadow_mtd[bon.num_mtd_part];
  326.     bon.num_mtd_part++;
  327. #endif
  328. } else {
  329.     sprintf(name, "%d", i);
  330.     bon.parts[i].devfs_rw_handle = devfs_register(bon.devfs_dir_handle,
  331. name, DEVFS_FL_DEFAULT, BON_MAJOR, i, 
  332. S_IFBLK | S_IRUGO, // | S_IWUGO, /* forbid writing */
  333. &bon_blk_fops, NULL);
  334. }
  335.     }
  336.     for(i=0;i<bon.num_part;i++) {
  337. unsigned int num_bad_block = *s++;
  338. if (num_bad_block == 0) continue;
  339. bon.parts[i].bad_blocks = kmalloc((1+num_bad_block) * sizeof(unsigned short), GFP_KERNEL);
  340. for(k=0;k<num_bad_block;k++) {
  341.     bon.parts[i].bad_blocks[k] = *s++;
  342. }
  343. bon.parts[i].bad_blocks[k] = ~0;
  344.     }
  346. #if 0 // bushi
  347. printk("add mtd part! - startn");
  348. if (bon.num_mtd_part) {
  349. add_mtd_partitions(mtd, &bon.mtd_parts[0], bon.num_mtd_part);
  350. }
  351. printk("add mtd part! - endn");
  352. #endif
  354.     return 0;
  355. }
  357. static void
  358. bon_notify_add(struct mtd_info *mtd)
  359. {
  360. //    partition_t *part;
  361. //    int dev;
  362.     int i;
  364.     if (!mtd->read_oob) return; 
  365.     if (bon.num_part) return;
  366.     if (read_partition_info(mtd)) return;
  367.     for(i=0;i<bon.num_part;i++) {
  368. bon_sizes[i] = bon.parts[i].size/1024;
  369. bon_blksizes[i] = mtd->erasesize;
  370. if (bon_blksizes[i] > PAGE_SIZE) bon_blksizes[i] = PAGE_SIZE;
  371.     }
  372. }
  374. static void
  375. bon_notify_remove(struct mtd_info *mtd)
  376. {
  377.     int i;
  378.     if (!bon.num_part || bon.mtd != mtd) return;
  379.     devfs_unregister(bon.devfs_dir_handle);
  380.     for(i=0;i<bon.num_part;i++) {
  381. devfs_unregister(bon.parts[i].devfs_rw_handle);
  382.     }
  383.     memset(&bon, 0, sizeof(bon));
  384. }
  386. static struct mtd_notifier bon_notifier = {
  387.     add: bon_notify_add,
  388.     remove: bon_notify_remove
  389. };
  391. static int
  392. init_bon(void)
  393. {
  394.     int i;
  396.     memset(&bon, 0, sizeof(bon));
  398.     if (devfs_register_blkdev(BON_MAJOR, "bon", &bon_blk_fops)) {
  399. printk(KERN_WARNING "bon: unable to allocate major device numn");
  400. return -EAGAIN;
  401.     }
  403.     for(i=0;i<MAX_PART;i++) {
  404.         bon_blksizes[i] = 1024;
  405. bon_sizes[i] = 0;
  406.     }
  408.     blksize_size[BON_MAJOR] = bon_blksizes;
  409.     blk_size[BON_MAJOR] = bon_sizes;
  411.     blk_init_queue(BLK_DEFAULT_QUEUE(BON_MAJOR), &do_bon_request);
  412.     register_mtd_user(&bon_notifier);
  414. #ifdef CONFIG_PROC_FS
  415. if ((proc_bon = create_proc_entry( "bon", 0, 0 )))
  416. proc_bon->read_proc = bon_read_proc;
  417. #endif
  419.     return 0;
  420. }
  422. static void __exit cleanup_bon(void)
  423. {
  424.     unregister_mtd_user(&bon_notifier);
  425.     devfs_unregister_blkdev(BON_MAJOR, "bon");
  426.     blk_cleanup_queue(BLK_DEFAULT_QUEUE(BON_MAJOR));
  427.     blksize_size[BON_MAJOR] = NULL;
  429. #ifdef CONFIG_PROC_FS
  430. if (proc_bon)
  431. remove_proc_entry( "bon", 0);
  432. #endif
  433. }
  435. #ifdef MODULE
  436. MODULE_PARM(PARTITION_OFFSET, "i");
  437. #else
  438. int __init part_setup(char *options)
  439. {
  440.     if (!options || !*options) return 0;
  441.     PARTITION_OFFSET = simple_strtoul(options, &options, 0);
  442.     if (*options == 'k' || *options == 'K') {
  443. PARTITION_OFFSET *= 1024;
  444.     } else if (*options == 'm' || *options == 'M') {
  445. PARTITION_OFFSET *= 1024;
  446.     }
  447.     return 0;
  448. }
  449. __setup("nand_part_offset=", part_setup);
  450. #endif
  452. void get_bon_data_area(unsigned long *address, unsigned long *size)
  453. {
  454. *address = bon.parts[2].offset;
  455. *size    = bon.parts[2].size;
  456. }
  457. module_init(init_bon);
  458. module_exit(cleanup_bon);
  460. MODULE_LICENSE("GPL");
  461. MODULE_AUTHOR("Hwang, Chideok <hwang@mizi.co.kr>");
  462. MODULE_DESCRIPTION("Simple Block Device for Nand Flash");