+
+static void flash_switch_bank(unsigned long addr)
+{
+ unsigned long val;
+
+ /* Set GPIO as output */
+ val = *GPIO_IO | (1 << (FLASH_A20_GPIO+16));
+ if ( addr & FLASH_BOUNDARY ) {
+ val |= 1 << (FLASH_A20_GPIO + 24);
+ } else {
+ val &= ~(1 << (FLASH_A20_GPIO + 24));
+ }
+ *GPIO_IO = val;
+}
+
+static map_word adm5120_map_read(struct map_info *map, unsigned long ofs)
+{
+ flash_switch_bank(ofs);
+ return inline_map_read(map, ofs);
+}
+
+static void adm5120_map_write(struct map_info *map, const map_word datum, unsigned long ofs)
+{
+ flash_switch_bank(ofs);
+ inline_map_write(map, datum, ofs);
+}
+
+static void adm5120_map_copy_from(struct map_info *map, void *to, unsigned long from, ssize_t len)
+{
+ ssize_t tmp;
+
+ if (from < FLASH_BOUNDARY) {
+ tmp = (len < (FLASH_BOUNDARY - from)) ? len : (FLASH_BOUNDARY - from);
+ flash_switch_bank(0);
+ inline_map_copy_from(map, to, from, tmp);
+ to = (void *)((char *)to + tmp);
+ from += tmp;
+ len -= tmp;
+ }
+ if (len > 0) {
+ flash_switch_bank(FLASH_BOUNDARY);
+ inline_map_copy_from(map, to, from, len);
+ }
+
+}
+
+static int __init
+find_cfe_size(struct mtd_info *mtd, size_t size)
+{
+ struct trx_header *trx;
+ unsigned char buf[512];
+ int off;
+ size_t len;
+ int blocksize;
+
+ trx = (struct trx_header *) buf;
+
+ blocksize = mtd->erasesize;
+ if (blocksize < 0x10000)
+ blocksize = 0x10000;
+
+ for (off = (128*1024); off < size; off += blocksize) {
+ memset(buf, 0xe5, sizeof(buf));
+
+ /*
+ * Read into buffer
+ */
+ if (mtd->read(mtd, off, sizeof(buf), &len, buf) ||
+ len != sizeof(buf))
+ continue;
+
+ /* found a TRX header */
+ if (le32_to_cpu(trx->magic) == TRX_MAGIC) {
+ goto found;
+ }
+ }
+
+ printk(KERN_NOTICE
+ "%s: Couldn't find bootloader size\n",
+ mtd->name);
+ return -1;
+
+ found:
+ printk(KERN_NOTICE "bootloader size: %d\n", off);
+ return off;
+
+}
+
+/*
+ * Copied from mtdblock.c
+ *
+ * Cache stuff...
+ *
+ * Since typical flash erasable sectors are much larger than what Linux's
+ * buffer cache can handle, we must implement read-modify-write on flash
+ * sectors for each block write requests. To avoid over-erasing flash sectors
+ * and to speed things up, we locally cache a whole flash sector while it is
+ * being written to until a different sector is required.
+ */
+
+static void erase_callback(struct erase_info *done)
+{
+ wait_queue_head_t *wait_q = (wait_queue_head_t *)done->priv;
+ wake_up(wait_q);
+}
+
+static int erase_write (struct mtd_info *mtd, unsigned long pos,
+ int len, const char *buf)
+{
+ struct erase_info erase;
+ DECLARE_WAITQUEUE(wait, current);
+ wait_queue_head_t wait_q;
+ size_t retlen;
+ int ret;
+
+ /*
+ * First, let's erase the flash block.
+ */
+
+ init_waitqueue_head(&wait_q);
+ erase.mtd = mtd;
+ erase.callback = erase_callback;
+ erase.addr = pos;
+ erase.len = len;
+ erase.priv = (u_long)&wait_q;
+
+ set_current_state(TASK_INTERRUPTIBLE);
+ add_wait_queue(&wait_q, &wait);
+
+ ret = mtd->erase(mtd, &erase);
+ if (ret) {
+ set_current_state(TASK_RUNNING);
+ remove_wait_queue(&wait_q, &wait);
+ printk (KERN_WARNING "erase of region [0x%lx, 0x%x] "
+ "on \"%s\" failed\n",
+ pos, len, mtd->name);
+ return ret;
+ }
+
+ schedule(); /* Wait for erase to finish. */
+ remove_wait_queue(&wait_q, &wait);
+
+ /*
+ * Next, writhe data to flash.
+ */
+
+ ret = mtd->write (mtd, pos, len, &retlen, buf);
+ if (ret)
+ return ret;
+ if (retlen != len)
+ return -EIO;
+ return 0;
+}
+
+
+
+
+static int __init
+find_root(struct mtd_info *mtd, size_t size, struct mtd_partition *part)
projects / openwrt.git / blobdiff