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

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

Linux/Unix编程

开发平台：

Unix_Linux

sa1100-flash.c：源码内容
  1. /*
  2.  * Flash memory access on SA11x0 based devices
  3.  * 
  4.  * (C) 2000 Nicolas Pitre <nico@cam.org>
  5.  * 
  6.  * $Id: sa1100-flash.c,v 1.26 2002/03/13 16:30:44 rmk Exp $
  7.  */
  9. #include <linux/config.h>
  10. #include <linux/module.h>
  11. #include <linux/types.h>
  12. #include <linux/ioport.h>
  13. #include <linux/kernel.h>
  15. #include <linux/mtd/mtd.h>
  16. #include <linux/mtd/map.h>
  17. #include <linux/mtd/partitions.h>
  19. #include <asm/hardware.h>
  20. #include <asm/io.h>
  23. #ifndef CONFIG_ARCH_SA1100
  24. #error This is for SA1100 architecture only
  25. #endif
  28. #define WINDOW_ADDR 0xe8000000
  30. static __u8 sa1100_read8(struct map_info *map, unsigned long ofs)
  31. {
  32. return readb(map->map_priv_1 + ofs);
  33. }
  35. static __u16 sa1100_read16(struct map_info *map, unsigned long ofs)
  36. {
  37. return readw(map->map_priv_1 + ofs);
  38. }
  40. static __u32 sa1100_read32(struct map_info *map, unsigned long ofs)
  41. {
  42. return readl(map->map_priv_1 + ofs);
  43. }
  45. static void sa1100_copy_from(struct map_info *map, void *to, unsigned long from, ssize_t len)
  46. {
  47. memcpy(to, (void *)(map->map_priv_1 + from), len);
  48. }
  50. static void sa1100_write8(struct map_info *map, __u8 d, unsigned long adr)
  51. {
  52. writeb(d, map->map_priv_1 + adr);
  53. }
  55. static void sa1100_write16(struct map_info *map, __u16 d, unsigned long adr)
  56. {
  57. writew(d, map->map_priv_1 + adr);
  58. }
  60. static void sa1100_write32(struct map_info *map, __u32 d, unsigned long adr)
  61. {
  62. writel(d, map->map_priv_1 + adr);
  63. }
  65. static void sa1100_copy_to(struct map_info *map, unsigned long to, const void *from, ssize_t len)
  66. {
  67. memcpy((void *)(map->map_priv_1 + to), from, len);
  68. }
  70. static struct map_info sa1100_map = {
  71. name: "SA1100 flash",
  72. read8: sa1100_read8,
  73. read16: sa1100_read16,
  74. read32: sa1100_read32,
  75. copy_from: sa1100_copy_from,
  76. write8: sa1100_write8,
  77. write16: sa1100_write16,
  78. write32: sa1100_write32,
  79. copy_to: sa1100_copy_to,
  81. map_priv_1: WINDOW_ADDR,
  82. map_priv_2: -1,
  83. };
  86. /*
  87.  * Here are partition information for all known SA1100-based devices.
  88.  * See include/linux/mtd/partitions.h for definition of the mtd_partition
  89.  * structure.
  90.  *
  91.  * The *_max_flash_size is the maximum possible mapped flash size which
  92.  * is not necessarily the actual flash size.  It must be no more than
  93.  * the value specified in the "struct map_desc *_io_desc" mapping
  94.  * definition for the corresponding machine.
  95.  *
  96.  * Please keep these in alphabetical order, and formatted as per existing
  97.  * entries.  Thanks.
  98.  */
  100. #ifdef CONFIG_SA1100_ADSBITSY
  101. #define ADSBITSY_FLASH_SIZE 0x02000000
  102. static struct mtd_partition adsbitsy_partitions[] = {
  103. {
  104. name: "bootROM",
  105. size: 0x80000,
  106. offset: 0,
  107. mask_flags: MTD_WRITEABLE,  /* force read-only */
  108. }, {
  109. name: "zImage",
  110. size: 0x100000,
  111. offset: MTDPART_OFS_APPEND,
  112. mask_flags: MTD_WRITEABLE,  /* force read-only */
  113. }, {
  114. name: "ramdisk.gz",
  115. size: 0x300000,
  116. offset: MTDPART_OFS_APPEND,
  117. mask_flags: MTD_WRITEABLE,  /* force read-only */
  118. }, {
  119. name: "User FS",
  120. size: MTDPART_SIZ_FULL,
  121. offset: MTDPART_OFS_APPEND,
  122. }
  123. };
  124. #endif
  126. #ifdef CONFIG_SA1100_ASSABET
  127. /* Phase 4 Assabet has two 28F160B3 flash parts in bank 0: */
  128. #define ASSABET4_FLASH_SIZE 0x00400000
  129. static struct mtd_partition assabet4_partitions[] = {
  130. {
  131. name: "bootloader",
  132. size: 0x00020000,
  133. offset: 0,
  134. mask_flags: MTD_WRITEABLE,
  135. }, {
  136. name: "bootloader params",
  137. size: 0x00020000,
  138. offset: MTDPART_OFS_APPEND,
  139. mask_flags: MTD_WRITEABLE,
  140. }, {
  141. name: "jffs",
  142. size: MTDPART_SIZ_FULL,
  143. offset: MTDPART_OFS_APPEND,
  144. }
  145. };
  147. /* Phase 5 Assabet has two 28F128J3A flash parts in bank 0: */
  148. #define ASSABET5_FLASH_SIZE 0x02000000
  149. static struct mtd_partition assabet5_partitions[] = {
  150. {
  151. name: "bootloader",
  152. size: 0x00040000,
  153. offset: 0,
  154. mask_flags: MTD_WRITEABLE,
  155. }, {
  156. name: "bootloader params",
  157. size: 0x00040000,
  158. offset: MTDPART_OFS_APPEND,
  159. mask_flags: MTD_WRITEABLE,
  160. }, {
  161. name: "jffs",
  162. size: MTDPART_SIZ_FULL,
  163. offset: MTDPART_OFS_APPEND,
  164. }
  165. };
  167. #define ASSABET_FLASH_SIZE ASSABET5_FLASH_SIZE
  168. #define assabet_partitions assabet5_partitions
  169. #endif
  171. #ifdef CONFIG_SA1100_BADGE4
  173. /*
  174.  * 1 x Intel 28F320C3BA100 Advanced+ Boot Block Flash (32 Mi bit)
  175.  *   Eight 4 KiW Parameter Bottom Blocks (64 KiB)
  176.  *   Sixty-three 32 KiW Main Blocks (4032 Ki b)
  177.  */
  178. #define BADGE4_FLASH_SIZE 0x00400000
  179. static struct mtd_partition badge4_partitions[] = {
  180. {
  181. name: "BLOB boot loader",
  182. offset: 0,
  183. size: 0x0000A000
  184. }, {
  185. name: "params",
  186. offset: MTDPART_OFS_APPEND,
  187. size: 0x00006000
  188. }, {
  189. name: "kernel",
  190. offset: MTDPART_OFS_APPEND,
  191. size: 0x00100000
  192. }, {
  193. name: "root",
  194. offset: MTDPART_OFS_APPEND,
  195. size: MTDPART_SIZ_FULL
  196. }
  197. };
  199. #endif
  202. #ifdef CONFIG_SA1100_CERF
  203. #ifdef CONFIG_SA1100_CERF_FLASH_32MB
  204. #define CERF_FLASH_SIZE 0x02000000
  205. static struct mtd_partition cerf_partitions[] = {
  206. {
  207. name: "firmware",
  208. size: 0x00040000,
  209. offset: 0,
  210. }, {
  211. name: "params",
  212. size: 0x00040000,
  213. offset: 0x00040000,
  214. }, {
  215. name: "kernel",
  216. size: 0x00100000,
  217. offset: 0x00080000,
  218. }, {
  219. name: "rootdisk",
  220. size: 0x01E80000,
  221. offset: 0x00180000,
  222. }
  223. };
  224. #elif defined CONFIG_SA1100_CERF_FLASH_16MB
  225. #define CERF_FLASH_SIZE 0x01000000
  226. static struct mtd_partition cerf_partitions[] = {
  227. {
  228. name: "firmware",
  229. size: 0x00020000,
  230. offset: 0,
  231. }, {
  232. name: "params",
  233. size: 0x00020000,
  234. offset: 0x00020000,
  235. }, {
  236. name: "kernel",
  237. size: 0x00100000,
  238. offset: 0x00040000,
  239. }, {
  240. name: "rootdisk",
  241. size: 0x00EC0000,
  242. offset: 0x00140000,
  243. }
  244. };
  245. #elif defined CONFIG_SA1100_CERF_FLASH_8MB
  246. #   error "Unwritten type definition"
  247. #else
  248. #   error "Undefined memory orientation for CERF in sa1100-flash.c"
  249. #endif
  250. #endif
  252. #ifdef CONFIG_SA1100_CONSUS
  253. #define CONSUS_FLASH_SIZE 0x02000000
  254. static struct mtd_partition consus_partitions[] = {
  255. {
  256. name: "Consus boot firmware",
  257. offset: 0,
  258. size: 0x00040000,
  259. mask_flags: MTD_WRITABLE, /* force read-only */
  260. }, {
  261. name: "Consus kernel",
  262. offset: 0x00040000,
  263. size: 0x00100000,
  264. mask_flags: 0,
  265. }, {
  266. name: "Consus disk",
  267. offset: 0x00140000,
  268. /* The rest (up to 16M) for jffs.  We could put 0 and
  269.    make it find the size automatically, but right now
  270.    i have 32 megs.  jffs will use all 32 megs if given
  271.    the chance, and this leads to horrible problems
  272.    when you try to re-flash the image because blob
  273.    won't erase the whole partition. */
  274. size: 0x01000000 - 0x00140000,
  275. mask_flags: 0,
  276. }, {
  277. /* this disk is a secondary disk, which can be used as
  278.    needed, for simplicity, make it the size of the other
  279.    consus partition, although realistically it could be
  280.    the remainder of the disk (depending on the file
  281.    system used) */
  282.  name: "Consus disk2",
  283.  offset: 0x01000000,
  284.  size: 0x01000000 - 0x00140000,
  285.  mask_flags: 0,
  286. }
  287. };
  288. #endif
  290. #ifdef CONFIG_SA1100_FLEXANET
  291. /* Flexanet has two 28F128J3A flash parts in bank 0: */
  292. #define FLEXANET_FLASH_SIZE 0x02000000
  293. static struct mtd_partition flexanet_partitions[] = {
  294. {
  295. name: "bootloader",
  296. size: 0x00040000,
  297. offset: 0,
  298. mask_flags: MTD_WRITEABLE,
  299. }, {
  300. name: "bootloader params",
  301. size: 0x00040000,
  302. offset: MTDPART_OFS_APPEND,
  303. mask_flags: MTD_WRITEABLE,
  304. }, {
  305. name: "kernel",
  306. size: 0x000C0000,
  307. offset: MTDPART_OFS_APPEND,
  308. mask_flags: MTD_WRITEABLE,
  309. }, {
  310. name: "altkernel",
  311. size: 0x000C0000,
  312. offset: MTDPART_OFS_APPEND,
  313. mask_flags: MTD_WRITEABLE,
  314. }, {
  315. name: "root",
  316. size: 0x00400000,
  317. offset: MTDPART_OFS_APPEND,
  318. mask_flags: MTD_WRITEABLE,
  319. }, {
  320. name: "free1",
  321. size: 0x00300000,
  322. offset: MTDPART_OFS_APPEND,
  323. mask_flags: MTD_WRITEABLE,
  324. }, {
  325. name: "free2",
  326. size: 0x00300000,
  327. offset: MTDPART_OFS_APPEND,
  328. mask_flags: MTD_WRITEABLE,
  329. }, {
  330. name: "free3",
  331. size: MTDPART_SIZ_FULL,
  332. offset: MTDPART_OFS_APPEND,
  333. mask_flags: MTD_WRITEABLE,
  334. }
  335. };
  336. #endif
  338. #ifdef CONFIG_SA1100_FREEBIRD
  339. #define FREEBIRD_FLASH_SIZE 0x02000000
  340. static struct mtd_partition freebird_partitions[] = {
  341. #if CONFIG_SA1100_FREEBIRD_NEW
  342. {
  343. name: "firmware",
  344. size: 0x00040000,
  345. offset: 0,
  346. mask_flags: MTD_WRITEABLE,  /* force read-only */
  347. }, {
  348. name: "kernel",
  349. size: 0x00080000,
  350. offset: 0x00040000,
  351. }, {
  352. name: "params",
  353. size: 0x00040000,
  354. offset: 0x000C0000,
  355. }, {
  356. name: "initrd",
  357. size: 0x00100000,
  358. offset: 0x00100000,
  359. }, {
  360. name: "root cramfs",
  361. size: 0x00300000,
  362. offset: 0x00200000,
  363. }, {
  364. name: "usr cramfs",
  365. size: 0x00C00000,
  366. offset: 0x00500000,
  367. }, {
  368. name: "local",
  369. size: MTDPART_SIZ_FULL,
  370. offset: 0x01100000,
  371. }
  372. #else
  373. {
  374. size: 0x00040000,
  375. offset: 0,
  376. }, {
  377. size: 0x000c0000,
  378. offset: MTDPART_OFS_APPEND,
  379. }, {
  380. size: 0x00400000,
  381. offset: MTDPART_OFS_APPEND,
  382. }, {
  383. size: MTDPART_SIZ_FULL,
  384. offset: MTDPART_OFS_APPEND,
  385. }
  386. #endif
  387. };
  388. #endif
  390. #ifdef CONFIG_SA1100_FRODO
  391. /* Frodo has 2 x 16M 28F128J3A flash chips in bank 0: */
  392. #define FRODO_FLASH_SIZE 0x02000000
  393. static struct mtd_partition frodo_partitions[] =
  394. {
  395. {
  396. name: "bootloader",
  397. size: 0x00040000,
  398. offset: 0x00000000,
  399. mask_flags: MTD_WRITEABLE
  400. }, {
  401. name: "bootloader params",
  402. size: 0x00040000,
  403. offset: MTDPART_OFS_APPEND,
  404. mask_flags: MTD_WRITEABLE
  405. }, {
  406. name: "kernel",
  407. size: 0x00100000,
  408. offset: MTDPART_OFS_APPEND,
  409. mask_flags: MTD_WRITEABLE
  410. }, {
  411. name: "ramdisk",
  412. size: 0x00400000,
  413. offset: MTDPART_OFS_APPEND,
  414. mask_flags: MTD_WRITEABLE
  415. }, {
  416. name: "file system",
  417. size: MTDPART_SIZ_FULL,
  418. offset: MTDPART_OFS_APPEND
  419. }
  420. };
  421. #endif
  423. #ifdef CONFIG_SA1100_GRAPHICSCLIENT
  424. #define GRAPHICSCLIENT_FLASH_SIZE 0x02000000
  425. static struct mtd_partition graphicsclient_partitions[] = {
  426. {
  427. name: "zImage",
  428. size: 0x100000,
  429. offset: 0,
  430. mask_flags: MTD_WRITEABLE,  /* force read-only */
  431. }, {
  432. name: "ramdisk.gz",
  433. size: 0x300000,
  434. offset: MTDPART_OFS_APPEND,
  435. mask_flags: MTD_WRITEABLE,  /* force read-only */
  436. }, {
  437. name: "User FS",
  438. size: MTDPART_SIZ_FULL,
  439. offset: MTDPART_OFS_APPEND,
  440. }
  441. };
  442. #endif
  444. #ifdef CONFIG_SA1100_GRAPHICSMASTER
  445. #define GRAPHICSMASTER_FLASH_SIZE 0x01000000
  446. static struct mtd_partition graphicsmaster_partitions[] = {
  447. {
  448. name: "zImage",
  449. size: 0x100000,
  450. offset: 0,
  451. mask_flags: MTD_WRITEABLE,  /* force read-only */
  452. },
  453. {
  454. name: "ramdisk.gz",
  455. size: 0x300000,
  456. offset: MTDPART_OFS_APPEND,
  457. mask_flags: MTD_WRITEABLE,  /* force read-only */
  458. },
  459. {
  460. name: "User FS",
  461. size: MTDPART_SIZ_FULL,
  462. offset: MTDPART_OFS_APPEND,
  463. }
  464. };
  465. #endif
  467. #ifdef CONFIG_SA1100_H3600
  468. #define H3600_FLASH_SIZE 0x02000000
  469. static struct mtd_partition h3600_partitions[] = {
  470. {
  471. name: "H3600 boot firmware",
  472. size: 0x00040000,
  473. offset: 0,
  474. mask_flags: MTD_WRITEABLE,  /* force read-only */
  475. }, {
  476. name: "H3600 kernel",
  477. size: 0x00080000,
  478. offset: 0x00040000,
  479. }, {
  480. name: "H3600 params",
  481. size: 0x00040000,
  482. offset: 0x000C0000,
  483. }, {
  484. #ifdef CONFIG_JFFS2_FS
  485. name: "H3600 root jffs2",
  486. size: MTDPART_SIZ_FULL,
  487. offset: 0x00100000,
  488. #else
  489. name: "H3600 initrd",
  490. size: 0x00100000,
  491. offset: 0x00100000,
  492. }, {
  493. name: "H3600 root cramfs",
  494. size: 0x00300000,
  495. offset: 0x00200000,
  496. }, {
  497. name: "H3600 usr cramfs",
  498. size: 0x00800000,
  499. offset: 0x00500000,
  500. }, {
  501. name: "H3600 usr local",
  502. size: MTDPART_SIZ_FULL,
  503. offset: 0x00d00000,
  504. #endif
  505. }
  506. };
  508. static void h3600_set_vpp(struct map_info *map, int vpp)
  509. {
  510. assign_h3600_egpio(IPAQ_EGPIO_VPP_ON, vpp);
  511. }
  512. #endif
  514. #ifdef CONFIG_SA1100_HUW_WEBPANEL
  515. #define HUW_WEBPANEL_FLASH_SIZE 0x01000000
  516. static struct mtd_partition huw_webpanel_partitions[] = {
  517. {
  518. name: "Loader",
  519. size: 0x00040000,
  520. offset: 0,
  521. }, {
  522. name: "Sector 1",
  523. size: 0x00040000,
  524. offset: MTDPART_OFS_APPEND,
  525. }, {
  526. size: MTDPART_SIZ_FULL,
  527. offset: MTDPART_OFS_APPEND,
  528. }
  529. };
  530. #endif
  532. #ifdef CONFIG_SA1100_JORNADA720
  533. #define JORNADA720_FLASH_SIZE 0x02000000
  534. static struct mtd_partition jornada720_partitions[] = {
  535. {
  536. name: "JORNADA720 boot firmware",
  537. size: 0x00040000,
  538. offset: 0,
  539. mask_flags: MTD_WRITEABLE,  /* force read-only */
  540. }, {
  541. name: "JORNADA720 kernel",
  542. size: 0x000c0000,
  543. offset: 0x00040000,
  544. }, {
  545. name: "JORNADA720 params",
  546. size: 0x00040000,
  547. offset: 0x00100000,
  548. }, {
  549. name: "JORNADA720 initrd",
  550. size: 0x00100000,
  551. offset: 0x00140000,
  552. }, {
  553. name: "JORNADA720 root cramfs",
  554. size: 0x00300000,
  555. offset: 0x00240000,
  556. }, {
  557. name: "JORNADA720 usr cramfs",
  558. size: 0x00800000,
  559. offset: 0x00540000,
  560. }, {
  561. name: "JORNADA720 usr local",
  562. size: 0  /* will expand to the end of the flash */
  563. offset: 0x00d00000,
  564. }
  565. };
  567. static void jornada720_set_vpp(int vpp)
  568. {
  569. if (vpp)
  570. PPSR |= 0x80;
  571. else
  572. PPSR &= ~0x80;
  573. PPDR |= 0x80;
  574. }
  576. #endif
  578. #ifdef CONFIG_SA1100_PANGOLIN
  579. #define PANGOLIN_FLASH_SIZE 0x04000000
  580. static struct mtd_partition pangolin_partitions[] = {
  581. {
  582. name: "boot firmware",
  583. size: 0x00080000,
  584. offset: 0x00000000,
  585. mask_flags: MTD_WRITEABLE,  /* force read-only */
  586. }, {
  587. name: "kernel",
  588. size: 0x00100000,
  589. offset: 0x00080000,
  590. }, {
  591. name: "initrd",
  592. size: 0x00280000,
  593. offset: 0x00180000,
  594. }, {
  595. name: "initrd-test",
  596. size: 0x03C00000,
  597. offset: 0x00400000,
  598. }
  599. };
  600. #endif
  602. #ifdef CONFIG_SA1100_PT_SYSTEM3
  603. /* erase size is 0x40000 == 256k partitions have to have this boundary */
  604. #define SYSTEM3_FLASH_SIZE 0x01000000
  605. static struct mtd_partition system3_partitions[] = {
  606. {
  607. name: "BLOB",
  608. size: 0x00040000,
  609. offset: 0x00000000,
  610. mask_flags: MTD_WRITEABLE,  /* force read-only */
  611. }, {
  612. name: "config",
  613. size: 0x00040000,
  614. offset: MTDPART_OFS_APPEND,
  615. }, {
  616. name: "kernel",
  617. size: 0x00100000,
  618. offset: MTDPART_OFS_APPEND,
  619. }, {
  620. name: "root",
  621. size: MTDPART_SIZ_FULL,
  622. offset: MTDPART_OFS_APPEND,
  623. }
  624. };
  625. #endif
  627. #ifdef CONFIG_SA1100_SHANNON
  628. #define SHANNON_FLASH_SIZE 0x00400000
  629. static struct mtd_partition shannon_partitions[] = {
  630. {
  631. name: "BLOB boot loader",
  632. offset: 0,
  633. size: 0x20000
  634. },
  635. {
  636. name: "kernel",
  637. offset: MTDPART_OFS_APPEND,
  638. size: 0xe0000
  639. },
  640. { 
  641. name: "initrd",
  642. offset: MTDPART_OFS_APPEND,
  643. size: MTDPART_SIZ_FULL
  644. }
  645. };
  647. #endif
  649. #ifdef CONFIG_SA1100_SHERMAN
  650. #define SHERMAN_FLASH_SIZE 0x02000000
  651. static struct mtd_partition sherman_partitions[] = {
  652. {
  653. size: 0x50000,
  654. offset: 0,
  655. }, {
  656. size: 0x70000,
  657. offset: MTDPART_OFS_APPEND,
  658. }, {
  659. size: 0x600000,
  660. offset: MTDPART_OFS_APPEND,
  661. }, {
  662. size: 0xA0000,
  663. offset: MTDPART_OFS_APPEND,
  664. }
  665. };
  666. #endif
  668. #ifdef CONFIG_SA1100_SIMPAD
  669. #define SIMPAD_FLASH_SIZE 0x02000000
  670. static struct mtd_partition simpad_partitions[] = {
  671. {
  672. name: "SIMpad boot firmware",
  673. size: 0x00080000,
  674. offset: 0,
  675. mask_flags: MTD_WRITEABLE,  /* force read-only */
  676. }, {
  677. name: "SIMpad kernel",
  678. size: 0x00100000,
  679. offset: 0x00080000,
  680. }, {
  681. #ifdef CONFIG_JFFS2_FS
  682. name: "SIMpad root jffs2",
  683. size: MTDPART_SIZ_FULL,
  684. offset: 0x00180000,
  685. #else
  686. name: "SIMpad initrd",
  687. size: 0x00300000,
  688. offset: 0x00180000,
  689. }, {
  690. name: "SIMpad root cramfs",
  691. size: 0x00300000,
  692. offset: 0x00480000,
  693. }, {
  694. name: "SIMpad usr cramfs",
  695. size: 0x005c0000,
  696. offset: 0x00780000,
  697. }, {
  698. name: "SIMpad usr local",
  699. size: MTDPART_SIZ_FULL,
  700. offset: 0x00d40000,
  701. #endif
  702. }
  703. };
  704. #endif /* CONFIG_SA1100_SIMPAD */
  706. #ifdef CONFIG_SA1100_STORK
  707. #define STORK_FLASH_SIZE 0x02000000
  708. static struct mtd_partition stork_partitions[] = {
  709. {
  710. name: "STORK boot firmware",
  711. size: 0x00040000,
  712. offset: 0,
  713. mask_flags: MTD_WRITEABLE,  /* force read-only */
  714. }, {
  715. name: "STORK params",
  716. size: 0x00040000,
  717. offset: 0x00040000,
  718. }, {
  719. name: "STORK kernel",
  720. size: 0x00100000,
  721. offset: 0x00080000,
  722. }, {
  723. #ifdef CONFIG_JFFS2_FS
  724. name: "STORK root jffs2",
  725. offset: 0x00180000,
  726. size: MTDPART_SIZ_FULL,
  727. #else
  728. name: "STORK initrd",
  729. size: 0x00100000,
  730. offset: 0x00180000,
  731. }, {
  732. name: "STORK root cramfs",
  733. size: 0x00300000,
  734. offset: 0x00280000,
  735. }, {
  736. name: "STORK usr cramfs",
  737. size: 0x00800000,
  738. offset: 0x00580000,
  739. }, {
  740. name: "STORK usr local",
  741. offset: 0x00d80000,
  742. size: MTDPART_SIZ_FULL,
  743. #endif
  744. }
  745. };
  746. #endif
  748. #ifdef CONFIG_SA1100_YOPY
  749. #define YOPY_FLASH_SIZE 0x08000000
  750. static struct mtd_partition yopy_partitions[] = {
  751. {
  752. name: "boot firmware",
  753. size: 0x00040000,
  754. offset: 0x00000000,
  755. mask_flags: MTD_WRITEABLE,  /* force read-only */
  756. }, {
  757. name: "kernel",
  758. size: 0x00080000,
  759. offset: 0x00080000,
  760. }, {
  761. name: "initrd",
  762. size: 0x00300000,
  763. offset: 0x00100000,
  764. }, {
  765. name: "root",
  766. size: 0x01000000,
  767. offset: 0x00400000,
  768. }
  769. };
  770. #endif
  772. extern int parse_redboot_partitions(struct mtd_info *master, struct mtd_partition **pparts);
  773. extern int parse_bootldr_partitions(struct mtd_info *master, struct mtd_partition **pparts);
  775. static struct mtd_partition *parsed_parts;
  776. static struct mtd_info *mymtd;
  778. int __init sa1100_mtd_init(void)
  779. {
  780. struct mtd_partition *parts;
  781. int nb_parts = 0, ret;
  782. int parsed_nr_parts = 0;
  783. const char *part_type;
  784. unsigned long base = -1UL;
  786. /* Default flash buswidth */
  787. sa1100_map.buswidth = (MSC0 & MSC_RBW) ? 2 : 4;
  789. /*
  790.  * Static partition definition selection
  791.  */
  792. part_type = "static";
  794. #ifdef CONFIG_SA1100_ADSBITSY
  795. if (machine_is_adsbitsy()) {
  796. parts = adsbitsy_partitions;
  797. nb_parts = ARRAY_SIZE(adsbitsy_partitions);
  798. sa1100_map.size = ADSBITSY_FLASH_SIZE;
  799. sa1100_map.buswidth = (MSC1 & MSC_RBW) ? 2 : 4;
  800. }
  801. #endif
  802. #ifdef CONFIG_SA1100_ASSABET
  803. if (machine_is_assabet()) {
  804. parts = assabet_partitions;
  805. nb_parts = ARRAY_SIZE(assabet_partitions);
  806. sa1100_map.size = ASSABET_FLASH_SIZE;
  807. }
  808. #endif
  809. #ifdef CONFIG_SA1100_BADGE4
  810. if (machine_is_badge4()) {
  811. parts = badge4_partitions;
  812. nb_parts = ARRAY_SIZE(badge4_partitions);
  813. sa1100_map.size = BADGE4_FLASH_SIZE;
  814. }
  815. #endif
  816. #ifdef CONFIG_SA1100_CERF
  817. if (machine_is_cerf()) {
  818. parts = cerf_partitions;
  819. nb_parts = ARRAY_SIZE(cerf_partitions);
  820. sa1100_map.size = CERF_FLASH_SIZE;
  821. }
  822. #endif
  823. #ifdef CONFIG_SA1100_CONSUS
  824. if (machine_is_consus()) {
  825. parts = consus_partitions;
  826. nb_parts = ARRAY_SIZE(consus_partitions);
  827. sa1100_map.size = CONSUS_FLASH_SIZE;
  828. }
  829. #endif
  830. #ifdef CONFIG_SA1100_FLEXANET
  831. if (machine_is_flexanet()) {
  832. parts = flexanet_partitions;
  833. nb_parts = ARRAY_SIZE(flexanet_partitions);
  834. sa1100_map.size = FLEXANET_FLASH_SIZE;
  835. }
  836. #endif
  837. #ifdef CONFIG_SA1100_FREEBIRD
  838. if (machine_is_freebird()) {
  839. parts = freebird_partitions;
  840. nb_parts = ARRAY_SIZE(freebird_partitions);
  841. sa1100_map.size = FREEBIRD_FLASH_SIZE;
  842. }
  843. #endif
  844. #ifdef CONFIG_SA1100_FRODO
  845. if (machine_is_frodo()) {
  846. parts = frodo_partitions;
  847. nb_parts = ARRAY_SIZE(frodo_partitions);
  848. sa1100_map.size = FRODO_FLASH_SIZE;
  849. base = 0x00000000;
  850. }
  851. #ifdef CONFIG_SA1100_GRAPHICSCLIENT
  852. if (machine_is_graphicsclient()) {
  853. parts = graphicsclient_partitions;
  854. nb_parts = ARRAY_SIZE(graphicsclient_partitions);
  855. sa1100_map.size = GRAPHICSCLIENT_FLASH_SIZE;
  856. sa1100_map.buswidth = (MSC1 & MSC_RBW) ? 2:4;
  857. }
  858. #endif
  859. #ifdef CONFIG_SA1100_GRAPHICSMASTER
  860. if (machine_is_graphicsmaster()) {
  861. parts = graphicsmaster_partitions;
  862. nb_parts = ARRAY_SIZE(graphicsmaster_partitions);
  863. sa1100_map.size = GRAPHICSMASTER_FLASH_SIZE;
  864. sa1100_map.buswidth = (MSC1 & MSC_RBW) ? 2:4;
  865. }
  866. #endif
  867. #ifdef CONFIG_SA1100_H3600
  868. if (machine_is_h3600()) {
  869. parts = h3600_partitions;
  870. nb_parts = ARRAY_SIZE(h3600_partitions);
  871. sa1100_map.size = H3600_FLASH_SIZE;
  872. sa1100_map.set_vpp = h3600_set_vpp;
  873. }
  874. #endif
  875. #ifdef CONFIG_SA1100_HUW_WEBPANEL
  876. if (machine_is_huw_webpanel()) {
  877. parts = huw_webpanel_partitions;
  878. nb_parts = ARRAY_SIZE(huw_webpanel_partitions);
  879. sa1100_map.size = HUW_WEBPANEL_FLASH_SIZE;
  880. }
  881. #endif
  882. #ifdef CONFIG_SA1100_JORNADA720
  883. if (machine_is_jornada720()) {
  884. parts = jornada720_partitions;
  885. nb_parts = ARRAY_SIZE(jornada720_partitions);
  886. sa1100_map.size = JORNADA720_FLASH_SIZE;
  887. sa1100_map.set_vpp = jornada720_set_vpp;
  888. }
  889. #endif
  890. #ifdef CONFIG_SA1100_PANGOLIN
  891. if (machine_is_pangolin()) {
  892. parts = pangolin_partitions;
  893. nb_parts = ARRAY_SIZE(pangolin_partitions);
  894. sa1100_map.size = PANGOLIN_FLASH_SIZE;
  895. }
  896. #endif
  897. #ifdef CONFIG_SA1100_PT_SYSTEM3
  898. if (machine_is_pt_system3()) {
  899. parts = system3_partitions;
  900. nb_parts = ARRAY_SIZE(system3_partitions);
  901. sa1100_map.size = SYSTEM3_FLASH_SIZE;
  902. }
  903. #endif
  904. #ifdef CONFIG_SA1100_SHANNON
  905. if (machine_is_shannon()) {
  906. parts = shannon_partitions;
  907. nb_parts = ARRAY_SIZE(shannon_partitions);
  908. sa1100_map.size = SHANNON_FLASH_SIZE;
  909. }
  910. #endif
  911. #ifdef CONFIG_SA1100_SHERMAN
  912. if (machine_is_sherman()) {
  913. parts = sherman_partitions;
  914. nb_parts = ARRAY_SIZE(sherman_partitions);
  915. sa1100_map.size = SHERMAN_FLASH_SIZE;
  916. }
  917. #endif
  918. #ifdef CONFIG_SA1100_SIMPAD
  919. if (machine_is_simpad()) {
  920. parts = simpad_partitions;
  921. nb_parts = ARRAY_SIZE(simpad_partitions);
  922. sa1100_map.size = SIMPAD_FLASH_SIZE;
  923. }
  924. #endif
  925. #ifdef CONFIG_SA1100_STORK
  926. if (machine_is_stork()) {
  927. parts = stork_partitions;
  928. nb_parts = ARRAY_SIZE(stork_partitions);
  929. sa1100_map.size = STORK_FLASH_SIZE;
  930. }
  931. #endif
  932. #ifdef CONFIG_SA1100_YOPY
  933. if (machine_is_yopy()) {
  934. parts = yopy_partitions;
  935. nb_parts = ARRAY_SIZE(yopy_partitions);
  936. sa1100_map.size = YOPY_FLASH_SIZE;
  937. }
  938. #endif
  940. /*
  941.  * For simple flash devices, use ioremap to map the flash.
  942.  */
  943. if (base != (unsigned long)-1) {
  944. if (!request_mem_region(base, sa1100_map.size, "flash"))
  945. return -EBUSY;
  946. sa1100_map.map_priv_2 = base;
  947. sa1100_map.map_priv_1 = (unsigned long)
  948. ioremap(base, sa1100_map.size);
  949. ret = -ENOMEM;
  950. if (!sa1100_map.map_priv_1)
  951. goto out_err;
  952. }
  954. /*
  955.  * Now let's probe for the actual flash.  Do it here since
  956.  * specific machine settings might have been set above.
  957.  */
  958. printk(KERN_NOTICE "SA1100 flash: probing %d-bit flash busn", sa1100_map.buswidth*8);
  959. mymtd = do_map_probe("cfi_probe", &sa1100_map);
  960. ret = -ENXIO;
  961. if (!mymtd)
  962. goto out_err;
  963. mymtd->module = THIS_MODULE;
  965. /*
  966.  * Dynamic partition selection stuff (might override the static ones)
  967.  */
  968. #ifdef CONFIG_MTD_REDBOOT_PARTS
  969. if (parsed_nr_parts == 0) {
  970. int ret = parse_redboot_partitions(mymtd, &parsed_parts);
  972. if (ret > 0) {
  973. part_type = "RedBoot";
  974. parsed_nr_parts = ret;
  975. }
  976. }
  977. #endif
  978. #ifdef CONFIG_MTD_BOOTLDR_PARTS
  979. if (parsed_nr_parts == 0) {
  980. int ret = parse_bootldr_partitions(mymtd, &parsed_parts);
  981. if (ret > 0) {
  982. part_type = "Compaq bootldr";
  983. parsed_nr_parts = ret;
  984. }
  985. }
  986. #endif
  988. if (parsed_nr_parts > 0) {
  989. parts = parsed_parts;
  990. nb_parts = parsed_nr_parts;
  991. }
  993. if (nb_parts == 0) {
  994. printk(KERN_NOTICE "SA1100 flash: no partition info available, registering whole flash at oncen");
  995. add_mtd_device(mymtd);
  996. } else {
  997. printk(KERN_NOTICE "Using %s partition definitionn", part_type);
  998. add_mtd_partitions(mymtd, parts, nb_parts);
  999. }
  1000. return 0;
  1002.  out_err:
  1003. if (sa1100_map.map_priv_2 != -1) {
  1004. iounmap((void *)sa1100_map.map_priv_1);
  1005. release_mem_region(sa1100_map.map_priv_2, sa1100_map.size);
  1006. }
  1007. return ret;
  1008. }
  1010. static void __exit sa1100_mtd_cleanup(void)
  1011. {
  1012. if (mymtd) {
  1013. del_mtd_partitions(mymtd);
  1014. map_destroy(mymtd);
  1015. if (parsed_parts)
  1016. kfree(parsed_parts);
  1017. }
  1018. if (sa1100_map.map_priv_2 != -1) {
  1019. iounmap((void *)sa1100_map.map_priv_1);
  1020. release_mem_region(sa1100_map.map_priv_2, sa1100_map.size);
  1021. }
  1022. }
  1024. module_init(sa1100_mtd_init);
  1025. module_exit(sa1100_mtd_cleanup);
  1027. MODULE_AUTHOR("Nicolas Pitre");
  1028. MODULE_DESCRIPTION("SA1100 CFI map driver");
  1029. MODULE_LICENSE("GPL");