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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
sharp.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：13k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

sharp.c：源码内容
  1. /*
  2.  * MTD chip driver for pre-CFI Sharp flash chips
  3.  *
  4.  * Copyright 2000,2001 David A. Schleef <ds@schleef.org>
  5.  *           2000,2001 Lineo, Inc.
  6.  *
  7.  * $Id: sharp.c,v 1.7 2002/02/13 15:49:07 dwmw2 Exp $
  8.  *
  9.  * Devices supported:
  10.  *   LH28F016SCT Symmetrical block flash memory, 2Mx8
  11.  *   LH28F008SCT Symmetrical block flash memory, 1Mx8
  12.  *
  13.  * Documentation:
  14.  *   http://www.sharpmeg.com/datasheets/memic/flashcmp/
  15.  *   http://www.sharpmeg.com/datasheets/memic/flashcmp/01symf/16m/016sctl9.pdf
  16.  *   016sctl9.pdf
  17.  *
  18.  * Limitations:
  19.  *   This driver only supports 4x1 arrangement of chips.
  20.  *   Not tested on anything but PowerPC.
  21.  */
  23. #include <linux/kernel.h>
  24. #include <linux/module.h>
  25. #include <linux/version.h>
  26. #include <linux/types.h>
  27. #include <linux/sched.h>
  28. #include <linux/errno.h>
  29. #include <linux/interrupt.h>
  30. #include <linux/mtd/map.h>
  31. #include <linux/mtd/cfi.h>
  32. #include <linux/delay.h>
  34. #define CMD_RESET 0xffffffff
  35. #define CMD_READ_ID 0x90909090
  36. #define CMD_READ_STATUS 0x70707070
  37. #define CMD_CLEAR_STATUS 0x50505050
  38. #define CMD_BLOCK_ERASE_1 0x20202020
  39. #define CMD_BLOCK_ERASE_2 0xd0d0d0d0
  40. #define CMD_BYTE_WRITE 0x40404040
  41. #define CMD_SUSPEND 0xb0b0b0b0
  42. #define CMD_RESUME 0xd0d0d0d0
  43. #define CMD_SET_BLOCK_LOCK_1 0x60606060
  44. #define CMD_SET_BLOCK_LOCK_2 0x01010101
  45. #define CMD_SET_MASTER_LOCK_1 0x60606060
  46. #define CMD_SET_MASTER_LOCK_2 0xf1f1f1f1
  47. #define CMD_CLEAR_BLOCK_LOCKS_1 0x60606060
  48. #define CMD_CLEAR_BLOCK_LOCKS_2 0xd0d0d0d0
  50. #define SR_READY 0x80808080 // 1 = ready
  51. #define SR_ERASE_SUSPEND 0x40404040 // 1 = block erase suspended
  52. #define SR_ERROR_ERASE 0x20202020 // 1 = error in block erase or clear lock bits
  53. #define SR_ERROR_WRITE 0x10101010 // 1 = error in byte write or set lock bit
  54. #define SR_VPP 0x08080808 // 1 = Vpp is low
  55. #define SR_WRITE_SUSPEND 0x04040404 // 1 = byte write suspended
  56. #define SR_PROTECT 0x02020202 // 1 = lock bit set
  57. #define SR_RESERVED 0x01010101
  59. #define SR_ERRORS (SR_ERROR_ERASE|SR_ERROR_WRITE|SR_VPP|SR_PROTECT)
  61. /* Configuration options */
  63. #undef AUTOUNLOCK  /* automatically unlocks blocks before erasing */
  65. struct mtd_info *sharp_probe(struct map_info *);
  67. static int sharp_probe_map(struct map_info *map,struct mtd_info *mtd);
  69. static int sharp_read(struct mtd_info *mtd, loff_t from, size_t len,
  70. size_t *retlen, u_char *buf);
  71. static int sharp_write(struct mtd_info *mtd, loff_t from, size_t len,
  72. size_t *retlen, const u_char *buf);
  73. static int sharp_erase(struct mtd_info *mtd, struct erase_info *instr);
  74. static void sharp_sync(struct mtd_info *mtd);
  75. static int sharp_suspend(struct mtd_info *mtd);
  76. static void sharp_resume(struct mtd_info *mtd);
  77. static void sharp_destroy(struct mtd_info *mtd);
  79. static int sharp_write_oneword(struct map_info *map, struct flchip *chip,
  80. unsigned long adr, __u32 datum);
  81. static int sharp_erase_oneblock(struct map_info *map, struct flchip *chip,
  82. unsigned long adr);
  83. #ifdef AUTOUNLOCK
  84. static void sharp_unlock_oneblock(struct map_info *map, struct flchip *chip,
  85. unsigned long adr);
  86. #endif
  89. struct sharp_info{
  90. struct flchip *chip;
  91. int bogus;
  92. int chipshift;
  93. int numchips;
  94. struct flchip chips[1];
  95. };
  97. struct mtd_info *sharp_probe(struct map_info *map);
  98. static void sharp_destroy(struct mtd_info *mtd);
  100. static struct mtd_chip_driver sharp_chipdrv = {
  101. probe: sharp_probe,
  102. destroy: sharp_destroy,
  103. name: "sharp",
  104. module: THIS_MODULE
  105. };
  108. struct mtd_info *sharp_probe(struct map_info *map)
  109. {
  110. struct mtd_info *mtd = NULL;
  111. struct sharp_info *sharp = NULL;
  112. int width;
  114. mtd = kmalloc(sizeof(*mtd), GFP_KERNEL);
  115. if(!mtd)
  116. return NULL;
  118. sharp = kmalloc(sizeof(*sharp), GFP_KERNEL);
  119. if(!sharp)
  120. return NULL;
  122. memset(mtd, 0, sizeof(*mtd));
  124. width = sharp_probe_map(map,mtd);
  125. if(!width){
  126. kfree(mtd);
  127. kfree(sharp);
  128. return NULL;
  129. }
  131. mtd->priv = map;
  132. mtd->type = MTD_NORFLASH;
  133. mtd->erase = sharp_erase;
  134. mtd->read = sharp_read;
  135. mtd->write = sharp_write;
  136. mtd->sync = sharp_sync;
  137. mtd->suspend = sharp_suspend;
  138. mtd->resume = sharp_resume;
  139. mtd->flags = MTD_CAP_NORFLASH;
  140. mtd->name = map->name;
  142. memset(sharp, 0, sizeof(*sharp));
  143. sharp->chipshift = 23;
  144. sharp->numchips = 1;
  145. sharp->chips[0].start = 0;
  146. sharp->chips[0].state = FL_READY;
  147. sharp->chips[0].mutex = &sharp->chips[0]._spinlock;
  148. sharp->chips[0].word_write_time = 0;
  149. init_waitqueue_head(&sharp->chips[0].wq);
  150. spin_lock_init(&sharp->chips[0]._spinlock);
  152. map->fldrv = &sharp_chipdrv;
  153. map->fldrv_priv = sharp;
  155. MOD_INC_USE_COUNT;
  156. return mtd;
  157. }
  159. static int sharp_probe_map(struct map_info *map,struct mtd_info *mtd)
  160. {
  161. unsigned long tmp;
  162. unsigned long base = 0;
  163. u32 read0, read4;
  164. int width = 4;
  166. tmp = map->read32(map, base+0);
  168. map->write32(map, CMD_READ_ID, base+0);
  170. read0=map->read32(map, base+0);
  171. read4=map->read32(map, base+4);
  172. if(read0 == 0x89898989){
  173. printk("Looks like sharp flashn");
  174. switch(read4){
  175. case 0xaaaaaaaa:
  176. case 0xa0a0a0a0:
  177. /* aa - LH28F016SCT-L95 2Mx8, 32 64k blocks*/
  178. /* a0 - LH28F016SCT-Z4  2Mx8, 32 64k blocks*/
  179. mtd->erasesize = 0x10000 * width;
  180. mtd->size = 0x200000 * width;
  181. return width;
  182. case 0xa6a6a6a6:
  183. /* a6 - LH28F008SCT-L12 1Mx8, 16 64k blocks*/
  184. /* a6 - LH28F008SCR-L85 1Mx8, 16 64k blocks*/
  185. mtd->erasesize = 0x10000 * width;
  186. mtd->size = 0x100000 * width;
  187. return width;
  188. #if 0
  189. case 0x00000000: /* unknown */
  190. /* XX - LH28F004SCT 512kx8, 8 64k blocks*/
  191. mtd->erasesize = 0x10000 * width;
  192. mtd->size = 0x80000 * width;
  193. return width;
  194. #endif
  195. default:
  196. printk("Sort-of looks like sharp flash, 0x%08x 0x%08xn",
  197. read0,read4);
  198. }
  199. }else if((map->read32(map, base+0) == CMD_READ_ID)){
  200. /* RAM, probably */
  201. printk("Looks like RAMn");
  202. map->write32(map, tmp, base+0);
  203. }else{
  204. printk("Doesn't look like sharp flash, 0x%08x 0x%08xn",
  205. read0,read4);
  206. }
  208. return 0;
  209. }
  211. /* This function returns with the chip->mutex lock held. */
  212. static int sharp_wait(struct map_info *map, struct flchip *chip)
  213. {
  214. __u16 status;
  215. unsigned long timeo = jiffies + HZ;
  216. DECLARE_WAITQUEUE(wait, current);
  217. int adr = 0;
  219. retry:
  220. spin_lock_bh(chip->mutex);
  222. switch(chip->state){
  223. case FL_READY:
  224. map->write32(map,CMD_READ_STATUS,adr);
  225. chip->state = FL_STATUS;
  226. case FL_STATUS:
  227. status = map->read32(map,adr);
  228. //printk("status=%08xn",status);
  230. udelay(100);
  231. if((status & SR_READY)!=SR_READY){
  232. //printk(".status=%08xn",status);
  233. udelay(100);
  234. }
  235. break;
  236. default:
  237. printk("Waiting for chipn");
  239. set_current_state(TASK_INTERRUPTIBLE);
  240. add_wait_queue(&chip->wq, &wait);
  242. spin_unlock_bh(chip->mutex);
  244. schedule();
  245. remove_wait_queue(&chip->wq, &wait);
  247. if(signal_pending(current))
  248. return -EINTR;
  250. timeo = jiffies + HZ;
  252. goto retry;
  253. }
  255. map->write32(map,CMD_RESET, adr);
  257. chip->state = FL_READY;
  259. return 0;
  260. }
  262. static void sharp_release(struct flchip *chip)
  263. {
  264. wake_up(&chip->wq);
  265. spin_unlock_bh(chip->mutex);
  266. }
  268. static int sharp_read(struct mtd_info *mtd, loff_t from, size_t len,
  269. size_t *retlen, u_char *buf)
  270. {
  271. struct map_info *map = mtd->priv;
  272. struct sharp_info *sharp = map->fldrv_priv;
  273. int chipnum;
  274. int ret = 0;
  275. int ofs = 0;
  277. chipnum = (from >> sharp->chipshift);
  278. ofs = from & ((1 << sharp->chipshift)-1);
  280. *retlen = 0;
  282. while(len){
  283. unsigned long thislen;
  285. if(chipnum>=sharp->numchips)
  286. break;
  288. thislen = len;
  289. if(ofs+thislen >= (1<<sharp->chipshift))
  290. thislen = (1<<sharp->chipshift) - ofs;
  292. ret = sharp_wait(map,&sharp->chips[chipnum]);
  293. if(ret<0)
  294. break;
  296. map->copy_from(map,buf,ofs,thislen);
  298. sharp_release(&sharp->chips[chipnum]);
  300. *retlen += thislen;
  301. len -= thislen;
  302. buf += thislen;
  304. ofs = 0;
  305. chipnum++;
  306. }
  307. return ret;
  308. }
  310. static int sharp_write(struct mtd_info *mtd, loff_t to, size_t len,
  311. size_t *retlen, const u_char *buf)
  312. {
  313. struct map_info *map = mtd->priv;
  314. struct sharp_info *sharp = map->fldrv_priv;
  315. int ret = 0;
  316. int i,j;
  317. int chipnum;
  318. unsigned long ofs;
  319. union { u32 l; unsigned char uc[4]; } tbuf;
  321. *retlen = 0;
  323. while(len){
  324. tbuf.l = 0xffffffff;
  325. chipnum = to >> sharp->chipshift;
  326. ofs = to & ((1<<sharp->chipshift)-1);
  328. j=0;
  329. for(i=ofs&3;i<4 && len;i++){
  330. tbuf.uc[i] = *buf;
  331. buf++;
  332. to++;
  333. len--;
  334. j++;
  335. }
  336. sharp_write_oneword(map, &sharp->chips[chipnum], ofs&~3, tbuf.l);
  337. if(ret<0)
  338. return ret;
  339. (*retlen)+=j;
  340. }
  342. return 0;
  343. }
  345. static int sharp_write_oneword(struct map_info *map, struct flchip *chip,
  346. unsigned long adr, __u32 datum)
  347. {
  348. int ret;
  349. int timeo;
  350. int try;
  351. int i;
  352. int status = 0;
  354. ret = sharp_wait(map,chip);
  356. for(try=0;try<10;try++){
  357. map->write32(map,CMD_BYTE_WRITE,adr);
  358. /* cpu_to_le32 -> hack to fix the writel be->le conversion */
  359. map->write32(map,cpu_to_le32(datum),adr);
  361. chip->state = FL_WRITING;
  363. timeo = jiffies + (HZ/2);
  365. map->write32(map,CMD_READ_STATUS,adr);
  366. for(i=0;i<100;i++){
  367. status = map->read32(map,adr);
  368. if((status & SR_READY)==SR_READY)
  369. break;
  370. }
  371. if(i==100){
  372. printk("sharp: timed out writingn");
  373. }
  375. if(!(status&SR_ERRORS))
  376. break;
  378. printk("sharp: error writing byte at addr=%08lx status=%08xn",adr,status);
  380. map->write32(map,CMD_CLEAR_STATUS,adr);
  381. }
  382. map->write32(map,CMD_RESET,adr);
  383. chip->state = FL_READY;
  385. wake_up(&chip->wq);
  386. spin_unlock_bh(chip->mutex);
  388. return 0;
  389. }
  391. static int sharp_erase(struct mtd_info *mtd, struct erase_info *instr)
  392. {
  393. struct map_info *map = mtd->priv;
  394. struct sharp_info *sharp = map->fldrv_priv;
  395. unsigned long adr,len;
  396. int chipnum, ret=0;
  398. //printk("sharp_erase()n");
  399. if(instr->addr & (mtd->erasesize - 1))
  400. return -EINVAL;
  401. if(instr->len & (mtd->erasesize - 1))
  402. return -EINVAL;
  403. if(instr->len + instr->addr > mtd->size)
  404. return -EINVAL;
  406. chipnum = instr->addr >> sharp->chipshift;
  407. adr = instr->addr & ((1<<sharp->chipshift)-1);
  408. len = instr->len;
  410. while(len){
  411. ret = sharp_erase_oneblock(map, &sharp->chips[chipnum], adr);
  412. if(ret)return ret;
  414. adr += mtd->erasesize;
  415. len -= mtd->erasesize;
  416. if(adr >> sharp->chipshift){
  417. adr = 0;
  418. chipnum++;
  419. if(chipnum>=sharp->numchips)
  420. break;
  421. }
  422. }
  424. if(instr->callback)
  425. instr->callback(instr);
  427. return 0;
  428. }
  430. static int sharp_do_wait_for_ready(struct map_info *map, struct flchip *chip,
  431. unsigned long adr)
  432. {
  433. int ret;
  434. int timeo;
  435. int status;
  436. DECLARE_WAITQUEUE(wait, current);
  438. map->write32(map,CMD_READ_STATUS,adr);
  439. status = map->read32(map,adr);
  441. timeo = jiffies + HZ;
  443. while(time_before(jiffies, timeo)){
  444. map->write32(map,CMD_READ_STATUS,adr);
  445. status = map->read32(map,adr);
  446. if((status & SR_READY)==SR_READY){
  447. ret = 0;
  448. goto out;
  449. }
  450. set_current_state(TASK_INTERRUPTIBLE);
  451. add_wait_queue(&chip->wq, &wait);
  453. //spin_unlock_bh(chip->mutex);
  455. schedule_timeout(1);
  456. schedule();
  457. remove_wait_queue(&chip->wq, &wait);
  459. //spin_lock_bh(chip->mutex);
  461. if (signal_pending(current)){
  462. ret = -EINTR;
  463. goto out;
  464. }
  466. }
  467. ret = -ETIME;
  468. out:
  469. return ret;
  470. }
  472. static int sharp_erase_oneblock(struct map_info *map, struct flchip *chip,
  473. unsigned long adr)
  474. {
  475. int ret;
  476. //int timeo;
  477. int status;
  478. //int i;
  480. //printk("sharp_erase_oneblock()n");
  482. #ifdef AUTOUNLOCK
  483. /* This seems like a good place to do an unlock */
  484. sharp_unlock_oneblock(map,chip,adr);
  485. #endif
  487. map->write32(map,CMD_BLOCK_ERASE_1,adr);
  488. map->write32(map,CMD_BLOCK_ERASE_2,adr);
  490. chip->state = FL_ERASING;
  492. ret = sharp_do_wait_for_ready(map,chip,adr);
  493. if(ret<0)return ret;
  495. map->write32(map,CMD_READ_STATUS,adr);
  496. status = map->read32(map,adr);
  498. if(!(status&SR_ERRORS)){
  499. map->write32(map,CMD_RESET,adr);
  500. chip->state = FL_READY;
  501. //spin_unlock_bh(chip->mutex);
  502. return 0;
  503. }
  505. printk("sharp: error erasing block at addr=%08lx status=%08xn",adr,status);
  506. map->write32(map,CMD_CLEAR_STATUS,adr);
  508. //spin_unlock_bh(chip->mutex);
  510. return -EIO;
  511. }
  513. #ifdef AUTOUNLOCK
  514. static void sharp_unlock_oneblock(struct map_info *map, struct flchip *chip,
  515. unsigned long adr)
  516. {
  517. int i;
  518. int status;
  520. map->write32(map,CMD_CLEAR_BLOCK_LOCKS_1,adr);
  521. map->write32(map,CMD_CLEAR_BLOCK_LOCKS_2,adr);
  523. udelay(100);
  525. status = map->read32(map,adr);
  526. printk("status=%08xn",status);
  528. for(i=0;i<1000;i++){
  529. //map->write32(map,CMD_READ_STATUS,adr);
  530. status = map->read32(map,adr);
  531. if((status & SR_READY)==SR_READY)
  532. break;
  533. udelay(100);
  534. }
  535. if(i==1000){
  536. printk("sharp: timed out unlocking blockn");
  537. }
  539. if(!(status&SR_ERRORS)){
  540. map->write32(map,CMD_RESET,adr);
  541. chip->state = FL_READY;
  542. return;
  543. }
  545. printk("sharp: error unlocking block at addr=%08lx status=%08xn",adr,status);
  546. map->write32(map,CMD_CLEAR_STATUS,adr);
  547. }
  548. #endif
  550. static void sharp_sync(struct mtd_info *mtd)
  551. {
  552. //printk("sharp_sync()n");
  553. }
  555. static int sharp_suspend(struct mtd_info *mtd)
  556. {
  557. printk("sharp_suspend()n");
  558. return -EINVAL;
  559. }
  561. static void sharp_resume(struct mtd_info *mtd)
  562. {
  563. printk("sharp_resume()n");
  565. }
  567. static void sharp_destroy(struct mtd_info *mtd)
  568. {
  569. printk("sharp_destroy()n");
  571. }
  573. int __init sharp_probe_init(void)
  574. {
  575. printk("MTD Sharp chip driver <ds@lineo.com>n");
  577. register_mtd_chip_driver(&sharp_chipdrv);
  579. return 0;
  580. }
  582. static void __exit sharp_probe_exit(void)
  583. {
  584. unregister_mtd_chip_driver(&sharp_chipdrv);
  585. }
  587. module_init(sharp_probe_init);
  588. module_exit(sharp_probe_exit);
  591. MODULE_LICENSE("GPL");
  592. MODULE_AUTHOR("David Schleef <ds@schleef.org>");
  593. MODULE_DESCRIPTION("Old MTD chip driver for pre-CFI Sharp flash chips");