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

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

嵌入式Linux

开发平台：

Unix_Linux

cfi_cmdset_0002.c：源码内容
  1. /*
  2.  * Common Flash Interface support:
  3.  *   AMD & Fujitsu Standard Vendor Command Set (ID 0x0002)
  4.  *
  5.  * Copyright (C) 2000 Crossnet Co. <info@crossnet.co.jp>
  6.  *
  7.  * 2_by_8 routines added by Simon Munton
  8.  *
  9.  * This code is GPL
  10.  *
  11.  * $Id: cfi_cmdset_0002.c,v 1.54 2002/01/10 20:27:40 eric Exp $
  12.  *
  13.  */
  15. #include <linux/module.h>
  16. #include <linux/types.h>
  17. #include <linux/kernel.h>
  18. #include <linux/sched.h>
  19. #include <asm/io.h>
  20. #include <asm/byteorder.h>
  22. #include <linux/errno.h>
  23. #include <linux/slab.h>
  24. #include <linux/delay.h>
  25. #include <linux/interrupt.h>
  26. #include <linux/mtd/map.h>
  27. #include <linux/mtd/cfi.h>
  29. #define AMD_BOOTLOC_BUG
  31. static int cfi_amdstd_read (struct mtd_info *, loff_t, size_t, size_t *, u_char *);
  32. static int cfi_amdstd_write(struct mtd_info *, loff_t, size_t, size_t *, const u_char *);
  33. static int cfi_amdstd_erase_chip(struct mtd_info *, struct erase_info *);
  34. static int cfi_amdstd_erase_onesize(struct mtd_info *, struct erase_info *);
  35. static int cfi_amdstd_erase_varsize(struct mtd_info *, struct erase_info *);
  36. static void cfi_amdstd_sync (struct mtd_info *);
  37. static int cfi_amdstd_suspend (struct mtd_info *);
  38. static void cfi_amdstd_resume (struct mtd_info *);
  40. static void cfi_amdstd_destroy(struct mtd_info *);
  42. struct mtd_info *cfi_cmdset_0002(struct map_info *, int);
  43. static struct mtd_info *cfi_amdstd_setup (struct map_info *);
  46. static struct mtd_chip_driver cfi_amdstd_chipdrv = {
  47. probe: NULL, /* Not usable directly */
  48. destroy: cfi_amdstd_destroy,
  49. name: "cfi_cmdset_0002",
  50. module: THIS_MODULE
  51. };
  53. struct mtd_info *cfi_cmdset_0002(struct map_info *map, int primary)
  54. {
  55. struct cfi_private *cfi = map->fldrv_priv;
  56. unsigned char bootloc;
  57. int ofs_factor = cfi->interleave * cfi->device_type;
  58. int i;
  59. __u8 major, minor;
  60. __u32 base = cfi->chips[0].start;
  62. if (cfi->cfi_mode==CFI_MODE_CFI){
  63. __u16 adr = primary?cfi->cfiq->P_ADR:cfi->cfiq->A_ADR;
  65. cfi_send_gen_cmd(0x98, 0x55, base, map, cfi, cfi->device_type, NULL);
  67. major = cfi_read_query(map, base + (adr+3)*ofs_factor);
  68. minor = cfi_read_query(map, base + (adr+4)*ofs_factor);
  70. printk(KERN_NOTICE " Amd/Fujitsu Extended Query Table v%c.%c at 0x%4.4Xn",
  71.        major, minor, adr);
  72. cfi_send_gen_cmd(0xf0, 0x55, base, map, cfi, cfi->device_type, NULL);
  74. cfi_send_gen_cmd(0xaa, 0x555, base, map, cfi, cfi->device_type, NULL);
  75. cfi_send_gen_cmd(0x55, 0x2aa, base, map, cfi, cfi->device_type, NULL);
  76. cfi_send_gen_cmd(0x90, 0x555, base, map, cfi, cfi->device_type, NULL);
  77. cfi->mfr = cfi_read_query(map, base);
  78. cfi->id = cfi_read_query(map, base + ofs_factor);
  80. /* Wheee. Bring me the head of someone at AMD. */
  81. #ifdef AMD_BOOTLOC_BUG
  82. if (((major << 8) | minor) < 0x3131) {
  83. /* CFI version 1.0 => don't trust bootloc */
  84. if (cfi->id & 0x80) {
  85. printk(KERN_WARNING "%s: JEDEC Device ID is 0x%02X. Assuming broken CFI table.n", map->name, cfi->id);
  86. bootloc = 3; /* top boot */
  87. } else {
  88. bootloc = 2; /* bottom boot */
  89. }
  90. } else
  91. #endif
  92. {
  93. cfi_send_gen_cmd(0x98, 0x55, base, map, cfi, cfi->device_type, NULL);
  94. bootloc = cfi_read_query(map, base + (adr+15)*ofs_factor);
  95. }
  96. if (bootloc == 3 && cfi->cfiq->NumEraseRegions > 1) {
  97. printk(KERN_WARNING "%s: Swapping erase regions for broken CFI table.n", map->name);
  99. for (i=0; i<cfi->cfiq->NumEraseRegions / 2; i++) {
  100. int j = (cfi->cfiq->NumEraseRegions-1)-i;
  101. __u32 swap;
  103. swap = cfi->cfiq->EraseRegionInfo[i];
  104. cfi->cfiq->EraseRegionInfo[i] = cfi->cfiq->EraseRegionInfo[j];
  105. cfi->cfiq->EraseRegionInfo[j] = swap;
  106. }
  107. }
  108. switch (cfi->device_type) {
  109. case CFI_DEVICETYPE_X8:
  110. cfi->addr_unlock1 = 0x555; 
  111. cfi->addr_unlock2 = 0x2aa; 
  112. break;
  113. case CFI_DEVICETYPE_X16:
  114. cfi->addr_unlock1 = 0xaaa;
  115. if (map->buswidth == cfi->interleave) {
  116. /* X16 chip(s) in X8 mode */
  117. cfi->addr_unlock2 = 0x555;
  118. } else {
  119. cfi->addr_unlock2 = 0x554;
  120. }
  121. break;
  122. case CFI_DEVICETYPE_X32:
  123. cfi->addr_unlock1 = 0x1555; 
  124. cfi->addr_unlock2 = 0xaaa; 
  125. break;
  126. default:
  127. printk(KERN_NOTICE "Eep. Unknown cfi_cmdset_0002 device type %dn", cfi->device_type);
  128. return NULL;
  129. }
  130. } /* CFI mode */
  132. for (i=0; i< cfi->numchips; i++) {
  133. cfi->chips[i].word_write_time = 1<<cfi->cfiq->WordWriteTimeoutTyp;
  134. cfi->chips[i].buffer_write_time = 1<<cfi->cfiq->BufWriteTimeoutTyp;
  135. cfi->chips[i].erase_time = 1<<cfi->cfiq->BlockEraseTimeoutTyp;
  136. }
  138. map->fldrv = &cfi_amdstd_chipdrv;
  139. MOD_INC_USE_COUNT;
  141. cfi_send_gen_cmd(0xf0, 0x55, base, map, cfi, cfi->device_type, NULL);
  142. return cfi_amdstd_setup(map);
  143. }
  145. static struct mtd_info *cfi_amdstd_setup(struct map_info *map)
  146. {
  147. struct cfi_private *cfi = map->fldrv_priv;
  148. struct mtd_info *mtd;
  149. unsigned long devsize = (1<<cfi->cfiq->DevSize) * cfi->interleave;
  151. mtd = kmalloc(sizeof(*mtd), GFP_KERNEL);
  152. printk(KERN_NOTICE "number of %s chips: %dn", 
  153. (cfi->cfi_mode == CFI_MODE_CFI)?"CFI":"JEDEC",cfi->numchips);
  155. if (!mtd) {
  156.   printk(KERN_WARNING "Failed to allocate memory for MTD devicen");
  157.   kfree(cfi->cmdset_priv);
  158.   return NULL;
  159. }
  161. memset(mtd, 0, sizeof(*mtd));
  162. mtd->priv = map;
  163. mtd->type = MTD_NORFLASH;
  164. /* Also select the correct geometry setup too */ 
  165. mtd->size = devsize * cfi->numchips;
  167. if (cfi->cfiq->NumEraseRegions == 1) {
  168. /* No need to muck about with multiple erase sizes */
  169. mtd->erasesize = ((cfi->cfiq->EraseRegionInfo[0] >> 8) & ~0xff) * cfi->interleave;
  170. } else {
  171. unsigned long offset = 0;
  172. int i,j;
  174. mtd->numeraseregions = cfi->cfiq->NumEraseRegions * cfi->numchips;
  175. mtd->eraseregions = kmalloc(sizeof(struct mtd_erase_region_info) * mtd->numeraseregions, GFP_KERNEL);
  176. if (!mtd->eraseregions) { 
  177. printk(KERN_WARNING "Failed to allocate memory for MTD erase region infon");
  178. kfree(cfi->cmdset_priv);
  179. return NULL;
  180. }
  182. for (i=0; i<cfi->cfiq->NumEraseRegions; i++) {
  183. unsigned long ernum, ersize;
  184. ersize = ((cfi->cfiq->EraseRegionInfo[i] >> 8) & ~0xff) * cfi->interleave;
  185. ernum = (cfi->cfiq->EraseRegionInfo[i] & 0xffff) + 1;
  187. if (mtd->erasesize < ersize) {
  188. mtd->erasesize = ersize;
  189. }
  190. for (j=0; j<cfi->numchips; j++) {
  191. mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].offset = (j*devsize)+offset;
  192. mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].erasesize = ersize;
  193. mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].numblocks = ernum;
  194. }
  195. offset += (ersize * ernum);
  196. }
  197. if (offset != devsize) {
  198. /* Argh */
  199. printk(KERN_WARNING "Sum of regions (%lx) != total size of set of interleaved chips (%lx)n", offset, devsize);
  200. kfree(mtd->eraseregions);
  201. kfree(cfi->cmdset_priv);
  202. return NULL;
  203. }
  204. #if 0
  205. // debug
  206. for (i=0; i<mtd->numeraseregions;i++){
  207. printk("%d: offset=0x%x,size=0x%x,blocks=%dn",
  208.        i,mtd->eraseregions[i].offset,
  209.        mtd->eraseregions[i].erasesize,
  210.        mtd->eraseregions[i].numblocks);
  211. }
  212. #endif
  213. }
  215. switch (CFIDEV_BUSWIDTH)
  216. {
  217. case 1:
  218. case 2:
  219. case 4:
  220. #if 1
  221. if (mtd->numeraseregions > 1)
  222. mtd->erase = cfi_amdstd_erase_varsize;
  223. else
  224. #endif
  225. if (((cfi->cfiq->EraseRegionInfo[0] & 0xffff) + 1) == 1)
  226. mtd->erase = cfi_amdstd_erase_chip;
  227. else
  228. mtd->erase = cfi_amdstd_erase_onesize;
  229. mtd->read = cfi_amdstd_read;
  230. mtd->write = cfi_amdstd_write;
  231. break;
  233. default:
  234.         printk(KERN_WARNING "Unsupported buswidthn");
  235. kfree(mtd);
  236. kfree(cfi->cmdset_priv);
  237. return NULL;
  238. break;
  239. }
  240. if (cfi->fast_prog) {
  241. /* In cfi_amdstd_write() we frob the protection stuff
  242.    without paying any attention to the state machine.
  243.    This upsets in-progress erases. So we turn this flag
  244.    off for now till the code gets fixed. */
  245. printk(KERN_NOTICE "cfi_cmdset_0002: Disabling fast programming due to code brokenness.n");
  246. cfi->fast_prog = 0;
  247. }
  249. mtd->sync = cfi_amdstd_sync;
  250. mtd->suspend = cfi_amdstd_suspend;
  251. mtd->resume = cfi_amdstd_resume;
  252. mtd->flags = MTD_CAP_NORFLASH;
  253. map->fldrv = &cfi_amdstd_chipdrv;
  254. mtd->name = map->name;
  255. MOD_INC_USE_COUNT;
  256. return mtd;
  257. }
  259. static inline int do_read_onechip(struct map_info *map, struct flchip *chip, loff_t adr, size_t len, u_char *buf)
  260. {
  261. DECLARE_WAITQUEUE(wait, current);
  262. unsigned long timeo = jiffies + HZ;
  264.  retry:
  265. cfi_spin_lock(chip->mutex);
  267. if (chip->state != FL_READY){
  268. #if 0
  269.         printk(KERN_DEBUG "Waiting for chip to read, status = %dn", chip->state);
  270. #endif
  271. set_current_state(TASK_UNINTERRUPTIBLE);
  272. add_wait_queue(&chip->wq, &wait);
  273.                 
  274. cfi_spin_unlock(chip->mutex);
  276. schedule();
  277. remove_wait_queue(&chip->wq, &wait);
  278. #if 0
  279. if(signal_pending(current))
  280. return -EINTR;
  281. #endif
  282. timeo = jiffies + HZ;
  284. goto retry;
  285. }
  287. adr += chip->start;
  289. chip->state = FL_READY;
  291. map->copy_from(map, buf, adr, len);
  293. wake_up(&chip->wq);
  294. cfi_spin_unlock(chip->mutex);
  296. return 0;
  297. }
  299. static int cfi_amdstd_read (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf)
  300. {
  301. struct map_info *map = mtd->priv;
  302. struct cfi_private *cfi = map->fldrv_priv;
  303. unsigned long ofs;
  304. int chipnum;
  305. int ret = 0;
  307. /* ofs: offset within the first chip that the first read should start */
  309. chipnum = (from >> cfi->chipshift);
  310. ofs = from - (chipnum <<  cfi->chipshift);
  313. *retlen = 0;
  315. while (len) {
  316. unsigned long thislen;
  318. if (chipnum >= cfi->numchips)
  319. break;
  321. if ((len + ofs -1) >> cfi->chipshift)
  322. thislen = (1<<cfi->chipshift) - ofs;
  323. else
  324. thislen = len;
  326. ret = do_read_onechip(map, &cfi->chips[chipnum], ofs, thislen, buf);
  327. if (ret)
  328. break;
  330. *retlen += thislen;
  331. len -= thislen;
  332. buf += thislen;
  334. ofs = 0;
  335. chipnum++;
  336. }
  337. return ret;
  338. }
  340. static int do_write_oneword(struct map_info *map, struct flchip *chip, unsigned long adr, __u32 datum, int fast)
  341. {
  342. unsigned long timeo = jiffies + HZ;
  343. unsigned int Last[4];
  344. unsigned long Count = 0;
  345. struct cfi_private *cfi = map->fldrv_priv;
  346. DECLARE_WAITQUEUE(wait, current);
  347. int ret = 0;
  349.  retry:
  350. cfi_spin_lock(chip->mutex);
  352. if (chip->state != FL_READY){
  353. #if 0
  354.         printk(KERN_DEBUG "Waiting for chip to write, status = %dn", chip->state);
  355. #endif
  356. set_current_state(TASK_UNINTERRUPTIBLE);
  357. add_wait_queue(&chip->wq, &wait);
  358.                 
  359. cfi_spin_unlock(chip->mutex);
  361. schedule();
  362. remove_wait_queue(&chip->wq, &wait);
  363. #if 0
  364. printk(KERN_DEBUG "Wake up to write:n");
  365. if(signal_pending(current))
  366. return -EINTR;
  367. #endif
  368. timeo = jiffies + HZ;
  370. goto retry;
  371. }
  373. chip->state = FL_WRITING;
  375. adr += chip->start;
  376. ENABLE_VPP(map);
  377. if (fast) { /* Unlock bypass */
  378. cfi_send_gen_cmd(0xA0, 0, chip->start, map, cfi, cfi->device_type, NULL);
  379. }
  380. else {
  381.         cfi_send_gen_cmd(0xAA, cfi->addr_unlock1, chip->start, map, cfi, CFI_DEVICETYPE_X8, NULL);
  382.         cfi_send_gen_cmd(0x55, cfi->addr_unlock2, chip->start, map, cfi, CFI_DEVICETYPE_X8, NULL);
  383.         cfi_send_gen_cmd(0xA0, cfi->addr_unlock1, chip->start, map, cfi, CFI_DEVICETYPE_X8, NULL);
  384. }
  386. cfi_write(map, datum, adr);
  388. cfi_spin_unlock(chip->mutex);
  389. cfi_udelay(chip->word_write_time);
  390. cfi_spin_lock(chip->mutex);
  392. Last[0] = cfi_read(map, adr);
  393. // printk("Last[0] is %xn", Last[0]);
  394. Last[1] = cfi_read(map, adr);
  395. // printk("Last[1] is %xn", Last[1]);
  396. Last[2] = cfi_read(map, adr);
  397. // printk("Last[2] is %xn", Last[2]);
  399. for (Count = 3; Last[(Count - 1) % 4] != Last[(Count - 2) % 4] && Count < 10000; Count++){
  400. cfi_spin_unlock(chip->mutex);
  401. cfi_udelay(10);
  402. cfi_spin_lock(chip->mutex);
  404.         Last[Count % 4] = cfi_read(map, adr);
  405. // printk("Last[%d%%4] is %xn", Count, Last[Count%4]);
  406. }
  408. if (Last[(Count - 1) % 4] != datum){
  409. printk(KERN_WARNING "Last[%ld] is %x, datum is %xn",(Count - 1) % 4,Last[(Count - 1) % 4],datum);
  410.         cfi_send_gen_cmd(0xF0, 0, chip->start, map, cfi, cfi->device_type, NULL);
  411. DISABLE_VPP(map);
  412. ret = -EIO;
  413. }       
  414. DISABLE_VPP(map);
  415. chip->state = FL_READY;
  416. wake_up(&chip->wq);
  417. cfi_spin_unlock(chip->mutex);
  419. return ret;
  420. }
  422. static int cfi_amdstd_write (struct mtd_info *mtd, loff_t to , size_t len, size_t *retlen, const u_char *buf)
  423. {
  424. struct map_info *map = mtd->priv;
  425. struct cfi_private *cfi = map->fldrv_priv;
  426. int ret = 0;
  427. int chipnum;
  428. unsigned long ofs, chipstart;
  430. *retlen = 0;
  431. if (!len)
  432. return 0;
  434. chipnum = to >> cfi->chipshift;
  435. ofs = to  - (chipnum << cfi->chipshift);
  436. chipstart = cfi->chips[chipnum].start;
  438. /* If it's not bus-aligned, do the first byte write */
  439. if (ofs & (CFIDEV_BUSWIDTH-1)) {
  440. unsigned long bus_ofs = ofs & ~(CFIDEV_BUSWIDTH-1);
  441. int i = ofs - bus_ofs;
  442. int n = 0;
  443. u_char tmp_buf[4];
  444. __u32 datum;
  446. map->copy_from(map, tmp_buf, bus_ofs + cfi->chips[chipnum].start, CFIDEV_BUSWIDTH);
  447. while (len && i < CFIDEV_BUSWIDTH)
  448. tmp_buf[i++] = buf[n++], len--;
  450. if (cfi_buswidth_is_2()) {
  451. datum = *(__u16*)tmp_buf;
  452. } else if (cfi_buswidth_is_4()) {
  453. datum = *(__u32*)tmp_buf;
  454. } else {
  455. return -EINVAL;  /* should never happen, but be safe */
  456. }
  458. ret = do_write_oneword(map, &cfi->chips[chipnum], 
  459. bus_ofs, datum, 0);
  460. if (ret) 
  461. return ret;
  463. ofs += n;
  464. buf += n;
  465. (*retlen) += n;
  467. if (ofs >> cfi->chipshift) {
  468. chipnum ++; 
  469. ofs = 0;
  470. if (chipnum == cfi->numchips)
  471. return 0;
  472. }
  473. }
  475. if (cfi->fast_prog) {
  476. /* Go into unlock bypass mode */
  477. cfi_send_gen_cmd(0xAA, cfi->addr_unlock1, chipstart, map, cfi, CFI_DEVICETYPE_X8, NULL);
  478. cfi_send_gen_cmd(0x55, cfi->addr_unlock2, chipstart, map, cfi, CFI_DEVICETYPE_X8, NULL);
  479. cfi_send_gen_cmd(0x20, cfi->addr_unlock1, chipstart, map, cfi, CFI_DEVICETYPE_X8, NULL);
  480. }
  482. /* We are now aligned, write as much as possible */
  483. while(len >= CFIDEV_BUSWIDTH) {
  484. __u32 datum;
  486. if (cfi_buswidth_is_1()) {
  487. datum = *(__u8*)buf;
  488. } else if (cfi_buswidth_is_2()) {
  489. datum = *(__u16*)buf;
  490. } else if (cfi_buswidth_is_4()) {
  491. datum = *(__u32*)buf;
  492. } else {
  493. return -EINVAL;
  494. }
  495. ret = do_write_oneword(map, &cfi->chips[chipnum],
  496.        ofs, datum, cfi->fast_prog);
  497. if (ret) {
  498. if (cfi->fast_prog){
  499. /* Get out of unlock bypass mode */
  500. cfi_send_gen_cmd(0x90, 0, chipstart, map, cfi, cfi->device_type, NULL);
  501. cfi_send_gen_cmd(0x00, 0, chipstart, map, cfi, cfi->device_type, NULL);
  502. }
  503. return ret;
  504. }
  506. ofs += CFIDEV_BUSWIDTH;
  507. buf += CFIDEV_BUSWIDTH;
  508. (*retlen) += CFIDEV_BUSWIDTH;
  509. len -= CFIDEV_BUSWIDTH;
  511. if (ofs >> cfi->chipshift) {
  512. if (cfi->fast_prog){
  513. /* Get out of unlock bypass mode */
  514. cfi_send_gen_cmd(0x90, 0, chipstart, map, cfi, cfi->device_type, NULL);
  515. cfi_send_gen_cmd(0x00, 0, chipstart, map, cfi, cfi->device_type, NULL);
  516. }
  518. chipnum ++; 
  519. ofs = 0;
  520. if (chipnum == cfi->numchips)
  521. return 0;
  522. chipstart = cfi->chips[chipnum].start;
  523. if (cfi->fast_prog){
  524. /* Go into unlock bypass mode for next set of chips */
  525. cfi_send_gen_cmd(0xAA, cfi->addr_unlock1, chipstart, map, cfi, CFI_DEVICETYPE_X8, NULL);
  526. cfi_send_gen_cmd(0x55, cfi->addr_unlock2, chipstart, map, cfi, CFI_DEVICETYPE_X8, NULL);
  527. cfi_send_gen_cmd(0x20, cfi->addr_unlock1, chipstart, map, cfi, CFI_DEVICETYPE_X8, NULL);
  528. }
  529. }
  530. }
  532. if (cfi->fast_prog){
  533. /* Get out of unlock bypass mode */
  534. cfi_send_gen_cmd(0x90, 0, chipstart, map, cfi, cfi->device_type, NULL);
  535. cfi_send_gen_cmd(0x00, 0, chipstart, map, cfi, cfi->device_type, NULL);
  536. }
  538. if (len & (CFIDEV_BUSWIDTH-1)) {
  539. int i = 0, n = 0;
  540. u_char tmp_buf[4];
  541. __u32 datum;
  543. map->copy_from(map, tmp_buf, ofs + cfi->chips[chipnum].start, CFIDEV_BUSWIDTH);
  544. while (len--)
  545. tmp_buf[i++] = buf[n++];
  547. if (cfi_buswidth_is_2()) {
  548. datum = *(__u16*)tmp_buf;
  549. } else if (cfi_buswidth_is_4()) {
  550. datum = *(__u32*)tmp_buf;
  551. } else {
  552. return -EINVAL;  /* should never happen, but be safe */
  553. }
  555. ret = do_write_oneword(map, &cfi->chips[chipnum], 
  556. ofs, datum, 0);
  557. if (ret) 
  558. return ret;
  560. (*retlen) += n;
  561. }
  563. return 0;
  564. }
  566. static inline int do_erase_chip(struct map_info *map, struct flchip *chip)
  567. {
  568. unsigned int oldstatus, status;
  569. unsigned int dq6, dq5;
  570. unsigned long timeo = jiffies + HZ;
  571. unsigned int adr;
  572. struct cfi_private *cfi = map->fldrv_priv;
  573. DECLARE_WAITQUEUE(wait, current);
  575.  retry:
  576. cfi_spin_lock(chip->mutex);
  578. if (chip->state != FL_READY){
  579. set_current_state(TASK_UNINTERRUPTIBLE);
  580. add_wait_queue(&chip->wq, &wait);
  581.                 
  582. cfi_spin_unlock(chip->mutex);
  584. schedule();
  585. remove_wait_queue(&chip->wq, &wait);
  586. #if 0
  587. if(signal_pending(current))
  588. return -EINTR;
  589. #endif
  590. timeo = jiffies + HZ;
  592. goto retry;
  593. }
  595. chip->state = FL_ERASING;
  597. /* Handle devices with one erase region, that only implement
  598.  * the chip erase command.
  599.  */
  600. ENABLE_VPP(map);
  601. cfi_send_gen_cmd(0xAA, cfi->addr_unlock1, chip->start, map, cfi, CFI_DEVICETYPE_X8, NULL);
  602. cfi_send_gen_cmd(0x55, cfi->addr_unlock2, chip->start, map, cfi, CFI_DEVICETYPE_X8, NULL);
  603. cfi_send_gen_cmd(0x80, cfi->addr_unlock1, chip->start, map, cfi, CFI_DEVICETYPE_X8, NULL);
  604. cfi_send_gen_cmd(0xAA, cfi->addr_unlock1, chip->start, map, cfi, CFI_DEVICETYPE_X8, NULL);
  605. cfi_send_gen_cmd(0x55, cfi->addr_unlock2, chip->start, map, cfi, CFI_DEVICETYPE_X8, NULL);
  606. cfi_send_gen_cmd(0x10, cfi->addr_unlock1, chip->start, map, cfi, CFI_DEVICETYPE_X8, NULL);
  607. timeo = jiffies + (HZ*20);
  608. adr = cfi->addr_unlock1;
  610. /* Wait for the end of programing/erasure by using the toggle method.
  611.  * As long as there is a programming procedure going on, bit 6 of the last
  612.  * written byte is toggling it's state with each consectuve read.
  613.  * The toggling stops as soon as the procedure is completed.
  614.  *
  615.  * If the process has gone on for too long on the chip bit 5 gets.
  616.  * After bit5 is set you can kill the operation by sending a reset
  617.  * command to the chip.
  618.  */
  619. dq6 = CMD(1<<6);
  620. dq5 = CMD(1<<5);
  622. oldstatus = cfi_read(map, adr);
  623. status = cfi_read(map, adr);
  624. while( ((status & dq6) != (oldstatus & dq6)) && 
  625. ((status & dq5) != dq5) &&
  626. !time_after(jiffies, timeo)) {
  627. int wait_reps;
  629. /* an initial short sleep */
  630. cfi_spin_unlock(chip->mutex);
  631. schedule_timeout(HZ/100);
  632. cfi_spin_lock(chip->mutex);
  634. if (chip->state != FL_ERASING) {
  635. /* Someone's suspended the erase. Sleep */
  636. set_current_state(TASK_UNINTERRUPTIBLE);
  637. add_wait_queue(&chip->wq, &wait);
  639. cfi_spin_unlock(chip->mutex);
  640. printk("erase suspended. Sleepingn");
  642. schedule();
  643. remove_wait_queue(&chip->wq, &wait);
  644. #if 0
  645. if (signal_pending(current))
  646. return -EINTR;
  647. #endif
  648. timeo = jiffies + (HZ*2); /* FIXME */
  649. cfi_spin_lock(chip->mutex);
  650. continue;
  651. }
  653. /* Busy wait for 1/10 of a milisecond */
  654. for(wait_reps = 0;
  655.      (wait_reps < 100) &&
  656. ((status & dq6) != (oldstatus & dq6)) && 
  657. ((status & dq5) != dq5);
  658. wait_reps++) {
  660. /* Latency issues. Drop the lock, wait a while and retry */
  661. cfi_spin_unlock(chip->mutex);
  663. cfi_udelay(1);
  665. cfi_spin_lock(chip->mutex);
  666. oldstatus = cfi_read(map, adr);
  667. status = cfi_read(map, adr);
  668. }
  669. oldstatus = cfi_read(map, adr);
  670. status = cfi_read(map, adr);
  671. }
  672. if ((status & dq6) != (oldstatus & dq6)) {
  673. /* The erasing didn't stop?? */
  674. if ((status & dq5) == dq5) {
  675. /* dq5 is active so we can do a reset and stop the erase */
  676. cfi_write(map, CMD(0xF0), chip->start);
  677. }
  678. chip->state = FL_READY;
  679. wake_up(&chip->wq);
  680. cfi_spin_unlock(chip->mutex);
  681. printk("waiting for erase to complete timed out.");
  682. DISABLE_VPP(map);
  683. return -EIO;
  684. }
  685. DISABLE_VPP(map);
  686. chip->state = FL_READY;
  687. wake_up(&chip->wq);
  688. cfi_spin_unlock(chip->mutex);
  689. return 0;
  691. }
  693. static inline int do_erase_oneblock(struct map_info *map, struct flchip *chip, unsigned long adr)
  694. {
  695. unsigned int oldstatus, status;
  696. unsigned int dq6, dq5;
  697. unsigned long timeo = jiffies + HZ;
  698. struct cfi_private *cfi = map->fldrv_priv;
  699. DECLARE_WAITQUEUE(wait, current);
  701.  retry:
  702. cfi_spin_lock(chip->mutex);
  704. if (chip->state != FL_READY){
  705. set_current_state(TASK_UNINTERRUPTIBLE);
  706. add_wait_queue(&chip->wq, &wait);
  707.                 
  708. cfi_spin_unlock(chip->mutex);
  710. schedule();
  711. remove_wait_queue(&chip->wq, &wait);
  712. #if 0
  713. if(signal_pending(current))
  714. return -EINTR;
  715. #endif
  716. timeo = jiffies + HZ;
  718. goto retry;
  719. }
  721. chip->state = FL_ERASING;
  723. adr += chip->start;
  724. ENABLE_VPP(map);
  725. cfi_send_gen_cmd(0xAA, cfi->addr_unlock1, chip->start, map, cfi, CFI_DEVICETYPE_X8, NULL);
  726. cfi_send_gen_cmd(0x55, cfi->addr_unlock2, chip->start, map, cfi, CFI_DEVICETYPE_X8, NULL);
  727. cfi_send_gen_cmd(0x80, cfi->addr_unlock1, chip->start, map, cfi, CFI_DEVICETYPE_X8, NULL);
  728. cfi_send_gen_cmd(0xAA, cfi->addr_unlock1, chip->start, map, cfi, CFI_DEVICETYPE_X8, NULL);
  729. cfi_send_gen_cmd(0x55, cfi->addr_unlock2, chip->start, map, cfi, CFI_DEVICETYPE_X8, NULL);
  730. cfi_write(map, CMD(0x30), adr);
  732. timeo = jiffies + (HZ*20);
  734. /* Wait for the end of programing/erasure by using the toggle method.
  735.  * As long as there is a programming procedure going on, bit 6 of the last
  736.  * written byte is toggling it's state with each consectuve read.
  737.  * The toggling stops as soon as the procedure is completed.
  738.  *
  739.  * If the process has gone on for too long on the chip bit 5 gets.
  740.  * After bit5 is set you can kill the operation by sending a reset
  741.  * command to the chip.
  742.  */
  743. dq6 = CMD(1<<6);
  744. dq5 = CMD(1<<5);
  746. oldstatus = cfi_read(map, adr);
  747. status = cfi_read(map, adr);
  748. while( ((status & dq6) != (oldstatus & dq6)) && 
  749. ((status & dq5) != dq5) &&
  750. !time_after(jiffies, timeo)) {
  751. int wait_reps;
  753. /* an initial short sleep */
  754. cfi_spin_unlock(chip->mutex);
  755. schedule_timeout(HZ/100);
  756. cfi_spin_lock(chip->mutex);
  758. if (chip->state != FL_ERASING) {
  759. /* Someone's suspended the erase. Sleep */
  760. set_current_state(TASK_UNINTERRUPTIBLE);
  761. add_wait_queue(&chip->wq, &wait);
  763. cfi_spin_unlock(chip->mutex);
  764. printk(KERN_DEBUG "erase suspended. Sleepingn");
  766. schedule();
  767. remove_wait_queue(&chip->wq, &wait);
  768. #if 0
  769. if (signal_pending(current))
  770. return -EINTR;
  771. #endif
  772. timeo = jiffies + (HZ*2); /* FIXME */
  773. cfi_spin_lock(chip->mutex);
  774. continue;
  775. }
  777. /* Busy wait for 1/10 of a milisecond */
  778. for(wait_reps = 0;
  779.      (wait_reps < 100) &&
  780. ((status & dq6) != (oldstatus & dq6)) && 
  781. ((status & dq5) != dq5);
  782. wait_reps++) {
  784. /* Latency issues. Drop the lock, wait a while and retry */
  785. cfi_spin_unlock(chip->mutex);
  787. cfi_udelay(1);
  789. cfi_spin_lock(chip->mutex);
  790. oldstatus = cfi_read(map, adr);
  791. status = cfi_read(map, adr);
  792. }
  793. oldstatus = cfi_read(map, adr);
  794. status = cfi_read(map, adr);
  795. }
  796. if ((status & dq6) != (oldstatus & dq6)) {
  797. /* The erasing didn't stop?? */
  798. if ((status & dq5) == dq5) {
  799. /* dq5 is active so we can do a reset and stop the erase */
  800. cfi_write(map, CMD(0xF0), chip->start);
  801. }
  802. chip->state = FL_READY;
  803. wake_up(&chip->wq);
  804. cfi_spin_unlock(chip->mutex);
  805. printk("waiting for erase to complete timed out.");
  806. DISABLE_VPP(map);
  807. return -EIO;
  808. }
  809. DISABLE_VPP(map);
  810. chip->state = FL_READY;
  811. wake_up(&chip->wq);
  812. cfi_spin_unlock(chip->mutex);
  813. return 0;
  814. }
  816. static int cfi_amdstd_erase_varsize(struct mtd_info *mtd, struct erase_info *instr)
  817. {
  818. struct map_info *map = mtd->priv;
  819. struct cfi_private *cfi = map->fldrv_priv;
  820. unsigned long adr, len;
  821. int chipnum, ret = 0;
  822. int i, first;
  823. struct mtd_erase_region_info *regions = mtd->eraseregions;
  825. if (instr->addr > mtd->size)
  826. return -EINVAL;
  828. if ((instr->len + instr->addr) > mtd->size)
  829. return -EINVAL;
  831. /* Check that both start and end of the requested erase are
  832.  * aligned with the erasesize at the appropriate addresses.
  833.  */
  835. i = 0;
  837. /* Skip all erase regions which are ended before the start of 
  838.    the requested erase. Actually, to save on the calculations,
  839.    we skip to the first erase region which starts after the
  840.    start of the requested erase, and then go back one.
  841. */
  843. while (i < mtd->numeraseregions && instr->addr >= regions[i].offset)
  844.        i++;
  845. i--;
  847. /* OK, now i is pointing at the erase region in which this 
  848.    erase request starts. Check the start of the requested
  849.    erase range is aligned with the erase size which is in
  850.    effect here.
  851. */
  853. if (instr->addr & (regions[i].erasesize-1))
  854. return -EINVAL;
  856. /* Remember the erase region we start on */
  857. first = i;
  859. /* Next, check that the end of the requested erase is aligned
  860.  * with the erase region at that address.
  861.  */
  863. while (i<mtd->numeraseregions && (instr->addr + instr->len) >= regions[i].offset)
  864. i++;
  866. /* As before, drop back one to point at the region in which
  867.    the address actually falls
  868. */
  869. i--;
  871. if ((instr->addr + instr->len) & (regions[i].erasesize-1))
  872. return -EINVAL;
  874. chipnum = instr->addr >> cfi->chipshift;
  875. adr = instr->addr - (chipnum << cfi->chipshift);
  876. len = instr->len;
  878. i=first;
  880. while(len) {
  881. ret = do_erase_oneblock(map, &cfi->chips[chipnum], adr);
  883. if (ret)
  884. return ret;
  886. adr += regions[i].erasesize;
  887. len -= regions[i].erasesize;
  889. if (adr % (1<< cfi->chipshift) == ((regions[i].offset + (regions[i].erasesize * regions[i].numblocks)) %( 1<< cfi->chipshift)))
  890. i++;
  892. if (adr >> cfi->chipshift) {
  893. adr = 0;
  894. chipnum++;
  896. if (chipnum >= cfi->numchips)
  897. break;
  898. }
  899. }
  901. instr->state = MTD_ERASE_DONE;
  902. if (instr->callback)
  903. instr->callback(instr);
  905. return 0;
  906. }
  908. static int cfi_amdstd_erase_onesize(struct mtd_info *mtd, struct erase_info *instr)
  909. {
  910. struct map_info *map = mtd->priv;
  911. struct cfi_private *cfi = map->fldrv_priv;
  912. unsigned long adr, len;
  913. int chipnum, ret = 0;
  915. if (instr->addr & (mtd->erasesize - 1))
  916. return -EINVAL;
  918. if (instr->len & (mtd->erasesize -1))
  919. return -EINVAL;
  921. if ((instr->len + instr->addr) > mtd->size)
  922. return -EINVAL;
  924. chipnum = instr->addr >> cfi->chipshift;
  925. adr = instr->addr - (chipnum << cfi->chipshift);
  926. len = instr->len;
  928. while(len) {
  929. ret = do_erase_oneblock(map, &cfi->chips[chipnum], adr);
  931. if (ret)
  932. return ret;
  934. adr += mtd->erasesize;
  935. len -= mtd->erasesize;
  937. if (adr >> cfi->chipshift) {
  938. adr = 0;
  939. chipnum++;
  941. if (chipnum >= cfi->numchips)
  942. break;
  943. }
  944. }
  946. instr->state = MTD_ERASE_DONE;
  947. if (instr->callback)
  948. instr->callback(instr);
  950. return 0;
  951. }
  953. static int cfi_amdstd_erase_chip(struct mtd_info *mtd, struct erase_info *instr)
  954. {
  955. struct map_info *map = mtd->priv;
  956. struct cfi_private *cfi = map->fldrv_priv;
  957. int ret = 0;
  959. if (instr->addr != 0)
  960. return -EINVAL;
  962. if (instr->len != mtd->size)
  963. return -EINVAL;
  965. ret = do_erase_chip(map, &cfi->chips[0]);
  966. if (ret)
  967. return ret;
  969. instr->state = MTD_ERASE_DONE;
  970. if (instr->callback)
  971. instr->callback(instr);
  973. return 0;
  974. }
  976. static void cfi_amdstd_sync (struct mtd_info *mtd)
  977. {
  978. struct map_info *map = mtd->priv;
  979. struct cfi_private *cfi = map->fldrv_priv;
  980. int i;
  981. struct flchip *chip;
  982. int ret = 0;
  983. DECLARE_WAITQUEUE(wait, current);
  985. for (i=0; !ret && i<cfi->numchips; i++) {
  986. chip = &cfi->chips[i];
  988. retry:
  989. cfi_spin_lock(chip->mutex);
  991. switch(chip->state) {
  992. case FL_READY:
  993. case FL_STATUS:
  994. case FL_CFI_QUERY:
  995. case FL_JEDEC_QUERY:
  996. chip->oldstate = chip->state;
  997. chip->state = FL_SYNCING;
  998. /* No need to wake_up() on this state change - 
  999.  * as the whole point is that nobody can do anything
  1000.  * with the chip now anyway.
  1001.  */
  1002. case FL_SYNCING:
  1003. cfi_spin_unlock(chip->mutex);
  1004. break;
  1006. default:
  1007. /* Not an idle state */
  1008. add_wait_queue(&chip->wq, &wait);
  1010. cfi_spin_unlock(chip->mutex);
  1012. schedule();
  1014.         remove_wait_queue(&chip->wq, &wait);
  1016. goto retry;
  1017. }
  1018. }
  1020. /* Unlock the chips again */
  1022. for (i--; i >=0; i--) {
  1023. chip = &cfi->chips[i];
  1025. cfi_spin_lock(chip->mutex);
  1027. if (chip->state == FL_SYNCING) {
  1028. chip->state = chip->oldstate;
  1029. wake_up(&chip->wq);
  1030. }
  1031. cfi_spin_unlock(chip->mutex);
  1032. }
  1033. }
  1036. static int cfi_amdstd_suspend(struct mtd_info *mtd)
  1037. {
  1038. struct map_info *map = mtd->priv;
  1039. struct cfi_private *cfi = map->fldrv_priv;
  1040. int i;
  1041. struct flchip *chip;
  1042. int ret = 0;
  1043. //printk("suspendn");
  1045. for (i=0; !ret && i<cfi->numchips; i++) {
  1046. chip = &cfi->chips[i];
  1048. cfi_spin_lock(chip->mutex);
  1050. switch(chip->state) {
  1051. case FL_READY:
  1052. case FL_STATUS:
  1053. case FL_CFI_QUERY:
  1054. case FL_JEDEC_QUERY:
  1055. chip->oldstate = chip->state;
  1056. chip->state = FL_PM_SUSPENDED;
  1057. /* No need to wake_up() on this state change - 
  1058.  * as the whole point is that nobody can do anything
  1059.  * with the chip now anyway.
  1060.  */
  1061. case FL_PM_SUSPENDED:
  1062. break;
  1064. default:
  1065. ret = -EAGAIN;
  1066. break;
  1067. }
  1068. cfi_spin_unlock(chip->mutex);
  1069. }
  1071. /* Unlock the chips again */
  1073. if (ret) {
  1074.      for (i--; i >=0; i--) {
  1075. chip = &cfi->chips[i];
  1077. cfi_spin_lock(chip->mutex);
  1079. if (chip->state == FL_PM_SUSPENDED) {
  1080. chip->state = chip->oldstate;
  1081. wake_up(&chip->wq);
  1082. }
  1083. cfi_spin_unlock(chip->mutex);
  1084. }
  1085. }
  1087. return ret;
  1088. }
  1090. static void cfi_amdstd_resume(struct mtd_info *mtd)
  1091. {
  1092. struct map_info *map = mtd->priv;
  1093. struct cfi_private *cfi = map->fldrv_priv;
  1094. int i;
  1095. struct flchip *chip;
  1096. //printk("resumen");
  1098. for (i=0; i<cfi->numchips; i++) {
  1100. chip = &cfi->chips[i];
  1102. cfi_spin_lock(chip->mutex);
  1104. if (chip->state == FL_PM_SUSPENDED) {
  1105. chip->state = FL_READY;
  1106. cfi_write(map, CMD(0xF0), chip->start);
  1107. wake_up(&chip->wq);
  1108. }
  1109. else
  1110. printk(KERN_ERR "Argh. Chip not in PM_SUSPENDED state upon resume()n");
  1112. cfi_spin_unlock(chip->mutex);
  1113. }
  1114. }
  1116. static void cfi_amdstd_destroy(struct mtd_info *mtd)
  1117. {
  1118. struct map_info *map = mtd->priv;
  1119. struct cfi_private *cfi = map->fldrv_priv;
  1120. kfree(cfi->cmdset_priv);
  1121. kfree(cfi);
  1122. }
  1124. static char im_name[]="cfi_cmdset_0002";
  1126. int __init cfi_amdstd_init(void)
  1127. {
  1128. inter_module_register(im_name, THIS_MODULE, &cfi_cmdset_0002);
  1129. return 0;
  1130. }
  1132. static void __exit cfi_amdstd_exit(void)
  1133. {
  1134. inter_module_unregister(im_name);
  1135. }
  1137. module_init(cfi_amdstd_init);
  1138. module_exit(cfi_amdstd_exit);
  1140. MODULE_LICENSE("GPL");
  1141. MODULE_AUTHOR("Crossnet Co. <info@crossnet.co.jp> et al.");
  1142. MODULE_DESCRIPTION("MTD chip driver for AMD/Fujitsu flash chips");