projects / openwrt / staging / wigyori.git / blob
? search:


de2d5b170f3df0cd1453c9b30ec1da01c4f25700
[openwrt/staging/wigyori.git] / target / linux / brcm-2.4 / patches / 004-flash.patch
1 diff -urN linux.old/drivers/mtd/devices/Config.in linux.dev/drivers/mtd/devices/Config.in
2 --- linux.old/drivers/mtd/devices/Config.in 2006-06-22 17:35:39.000000000 +0200
3 +++ linux.dev/drivers/mtd/devices/Config.in 2006-06-21 21:41:24.000000000 +0200
4 @@ -5,6 +5,7 @@
5 mainmenu_option next_comment
6
7 comment 'Self-contained MTD device drivers'
8 +bool ' Broadcom Chipcommon Serial Flash support' CONFIG_MTD_SFLASH
9 dep_tristate ' Ramix PMC551 PCI Mezzanine RAM card support' CONFIG_MTD_PMC551 $CONFIG_MTD $CONFIG_PCI
10 if [ "$CONFIG_MTD_PMC551" = "y" -o "$CONFIG_MTD_PMC551" = "m" ]; then
11 bool ' PMC551 256M DRAM Bugfix' CONFIG_MTD_PMC551_BUGFIX
12 diff -urN linux.old/drivers/mtd/devices/Makefile linux.dev/drivers/mtd/devices/Makefile
13 --- linux.old/drivers/mtd/devices/Makefile 2006-06-22 17:35:39.000000000 +0200
14 +++ linux.dev/drivers/mtd/devices/Makefile 2006-06-21 21:41:24.000000000 +0200
15 @@ -3,6 +3,8 @@
16 #
17 # $Id: Makefile,v 1.4 2001/06/26 21:10:05 spse Exp $
18
19 +EXTRA_CFLAGS := -I$(TOPDIR)/arch/mips/bcm947xx/include
20 +
21 O_TARGET := devlink.o
22
23 # *** BIG UGLY NOTE ***
24 @@ -12,6 +14,7 @@
25 # here where previously there was none. We now have to ensure that
26 # doc200[01].o are linked before docprobe.o
27
28 +obj-$(CONFIG_MTD_SFLASH) += sflash.o
29 obj-$(CONFIG_MTD_DOC1000) += doc1000.o
30 obj-$(CONFIG_MTD_DOC2000) += doc2000.o
31 obj-$(CONFIG_MTD_DOC2001) += doc2001.o
32 diff -urN linux.old/drivers/mtd/devices/sflash.c linux.dev/drivers/mtd/devices/sflash.c
33 --- linux.old/drivers/mtd/devices/sflash.c 1970-01-01 01:00:00.000000000 +0100
34 +++ linux.dev/drivers/mtd/devices/sflash.c 2006-06-21 21:41:24.000000000 +0200
35 @@ -0,0 +1,298 @@
36 +/*
37 + * Broadcom SiliconBackplane chipcommon serial flash interface
38 + *
39 + * Copyright 2001-2003, Broadcom Corporation
40 + * All Rights Reserved.
41 + *
42 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
43 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
44 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
45 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
46 + *
47 + * $Id: sflash.c,v 1.1.1.3 2003/11/10 17:43:38 hyin Exp $
48 + */
49 +
50 +#include <linux/config.h>
51 +#include <linux/module.h>
52 +#include <linux/slab.h>
53 +#include <linux/ioport.h>
54 +#include <linux/mtd/compatmac.h>
55 +#include <linux/mtd/mtd.h>
56 +#include <linux/mtd/partitions.h>
57 +#include <linux/errno.h>
58 +#include <linux/pci.h>
59 +#include <linux/delay.h>
60 +#include <asm/io.h>
61 +
62 +#ifdef CONFIG_MTD_PARTITIONS
63 +#include <linux/mtd/mtd.h>
64 +#include <linux/mtd/partitions.h>
65 +#include <linux/minix_fs.h>
66 +#include <linux/ext2_fs.h>
67 +#include <linux/romfs_fs.h>
68 +#include <linux/cramfs_fs.h>
69 +#include <linux/jffs2.h>
70 +#endif
71 +
72 +#include <typedefs.h>
73 +#include <bcmdevs.h>
74 +#include <bcmutils.h>
75 +#include <osl.h>
76 +#include <bcmutils.h>
77 +#include <bcmnvram.h>
78 +#include <sbconfig.h>
79 +#include <sbchipc.h>
80 +#include <sflash.h>
81 +#include <trxhdr.h>
82 +
83 +#ifdef CONFIG_MTD_PARTITIONS
84 +extern struct mtd_partition * init_mtd_partitions(struct mtd_info *mtd, size_t size);
85 +#endif
86 +
87 +struct sflash_mtd {
88 + chipcregs_t *cc;
89 + struct semaphore lock;
90 + struct mtd_info mtd;
91 + struct mtd_erase_region_info regions[1];
92 +};
93 +
94 +/* Private global state */
95 +static struct sflash_mtd sflash;
96 +
97 +static int
98 +sflash_mtd_poll(struct sflash_mtd *sflash, unsigned int offset, int timeout)
99 +{
100 + int now = jiffies;
101 + int ret = 0;
102 +
103 + for (;;) {
104 + if (!sflash_poll(sflash->cc, offset)) {
105 + ret = 0;
106 + break;
107 + }
108 + if (time_after(jiffies, now + timeout)) {
109 + printk(KERN_ERR "sflash: timeout\n");
110 + ret = -ETIMEDOUT;
111 + break;
112 + }
113 + if (current->need_resched) {
114 + set_current_state(TASK_UNINTERRUPTIBLE);
115 + schedule_timeout(timeout / 10);
116 + } else
117 + udelay(1);
118 + }
119 +
120 + return ret;
121 +}
122 +
123 +static int
124 +sflash_mtd_read(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf)
125 +{
126 + struct sflash_mtd *sflash = (struct sflash_mtd *) mtd->priv;
127 + int bytes, ret = 0;
128 +
129 + /* Check address range */
130 + if (!len)
131 + return 0;
132 + if ((from + len) > mtd->size)
133 + return -EINVAL;
134 +
135 + down(&sflash->lock);
136 +
137 + *retlen = 0;
138 + while (len) {
139 + if ((bytes = sflash_read(sflash->cc, (uint) from, len, buf)) < 0) {
140 + ret = bytes;
141 + break;
142 + }
143 + from += (loff_t) bytes;
144 + len -= bytes;
145 + buf += bytes;
146 + *retlen += bytes;
147 + }
148 +
149 + up(&sflash->lock);
150 +
151 + return ret;
152 +}
153 +
154 +static int
155 +sflash_mtd_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf)
156 +{
157 + struct sflash_mtd *sflash = (struct sflash_mtd *) mtd->priv;
158 + int bytes, ret = 0;
159 +
160 + /* Check address range */
161 + if (!len)
162 + return 0;
163 + if ((to + len) > mtd->size)
164 + return -EINVAL;
165 +
166 + down(&sflash->lock);
167 +
168 + *retlen = 0;
169 + while (len) {
170 + if ((bytes = sflash_write(sflash->cc, (uint) to, len, buf)) < 0) {
171 + ret = bytes;
172 + break;
173 + }
174 + if ((ret = sflash_mtd_poll(sflash, (unsigned int) to, HZ / 10)))
175 + break;
176 + to += (loff_t) bytes;
177 + len -= bytes;
178 + buf += bytes;
179 + *retlen += bytes;
180 + }
181 +
182 + up(&sflash->lock);
183 +
184 + return ret;
185 +}
186 +
187 +static int
188 +sflash_mtd_erase(struct mtd_info *mtd, struct erase_info *erase)
189 +{
190 + struct sflash_mtd *sflash = (struct sflash_mtd *) mtd->priv;
191 + int i, j, ret = 0;
192 + unsigned int addr, len;
193 +
194 + /* Check address range */
195 + if (!erase->len)
196 + return 0;
197 + if ((erase->addr + erase->len) > mtd->size)
198 + return -EINVAL;
199 +
200 + addr = erase->addr;
201 + len = erase->len;
202 +
203 + down(&sflash->lock);
204 +
205 + /* Ensure that requested region is aligned */
206 + for (i = 0; i < mtd->numeraseregions; i++) {
207 + for (j = 0; j < mtd->eraseregions[i].numblocks; j++) {
208 + if (addr == mtd->eraseregions[i].offset + mtd->eraseregions[i].erasesize * j &&
209 + len >= mtd->eraseregions[i].erasesize) {
210 + if ((ret = sflash_erase(sflash->cc, addr)) < 0)
211 + break;
212 + if ((ret = sflash_mtd_poll(sflash, addr, 10 * HZ)))
213 + break;
214 + addr += mtd->eraseregions[i].erasesize;
215 + len -= mtd->eraseregions[i].erasesize;
216 + }
217 + }
218 + if (ret)
219 + break;
220 + }
221 +
222 + up(&sflash->lock);
223 +
224 + /* Set erase status */
225 + if (ret)
226 + erase->state = MTD_ERASE_FAILED;
227 + else
228 + erase->state = MTD_ERASE_DONE;
229 +
230 + /* Call erase callback */
231 + if (erase->callback)
232 + erase->callback(erase);
233 +
234 + return ret;
235 +}
236 +
237 +#if LINUX_VERSION_CODE < 0x20212 && defined(MODULE)
238 +#define sflash_mtd_init init_module
239 +#define sflash_mtd_exit cleanup_module
240 +#endif
241 +
242 +mod_init_t
243 +sflash_mtd_init(void)
244 +{
245 + struct pci_dev *pdev;
246 + int ret = 0;
247 + struct sflash *info;
248 + uint bank, i;
249 +#ifdef CONFIG_MTD_PARTITIONS
250 + struct mtd_partition *parts;
251 +#endif
252 +
253 + if (!(pdev = pci_find_device(VENDOR_BROADCOM, SB_CC, NULL))) {
254 + printk(KERN_ERR "sflash: chipcommon not found\n");
255 + return -ENODEV;
256 + }
257 +
258 + memset(&sflash, 0, sizeof(struct sflash_mtd));
259 + init_MUTEX(&sflash.lock);
260 +
261 + /* Map registers and flash base */
262 + if (!(sflash.cc = ioremap_nocache(pci_resource_start(pdev, 0),
263 + pci_resource_len(pdev, 0)))) {
264 + printk(KERN_ERR "sflash: error mapping registers\n");
265 + ret = -EIO;
266 + goto fail;
267 + }
268 +
269 + /* Initialize serial flash access */
270 + info = sflash_init(sflash.cc);
271 +
272 + if (!info) {
273 + printk(KERN_ERR "sflash: found no supported devices\n");
274 + ret = -ENODEV;
275 + goto fail;
276 + }
277 +
278 + /* Setup banks */
279 + sflash.regions[0].offset = 0;
280 + sflash.regions[0].erasesize = info->blocksize;
281 + sflash.regions[0].numblocks = info->numblocks;
282 + if (sflash.regions[0].erasesize > sflash.mtd.erasesize)
283 + sflash.mtd.erasesize = sflash.regions[0].erasesize;
284 + if (sflash.regions[0].erasesize * sflash.regions[0].numblocks) {
285 + sflash.mtd.size += sflash.regions[0].erasesize * sflash.regions[0].numblocks;
286 + }
287 + sflash.mtd.numeraseregions = 1;
288 + ASSERT(sflash.mtd.size == info->size);
289 +
290 + /* Register with MTD */
291 + sflash.mtd.name = "sflash";
292 + sflash.mtd.type = MTD_NORFLASH;
293 + sflash.mtd.flags = MTD_CAP_NORFLASH;
294 + sflash.mtd.eraseregions = sflash.regions;
295 + sflash.mtd.module = THIS_MODULE;
296 + sflash.mtd.erase = sflash_mtd_erase;
297 + sflash.mtd.read = sflash_mtd_read;
298 + sflash.mtd.write = sflash_mtd_write;
299 + sflash.mtd.priv = &sflash;
300 +
301 +#ifdef CONFIG_MTD_PARTITIONS
302 + parts = init_mtd_partitions(&sflash.mtd, sflash.mtd.size);
303 + for (i = 0; parts[i].name; i++);
304 + ret = add_mtd_partitions(&sflash.mtd, parts, i);
305 +#else
306 + ret = add_mtd_device(&sflash.mtd);
307 +#endif
308 + if (ret) {
309 + printk(KERN_ERR "sflash: add_mtd failed\n");
310 + goto fail;
311 + }
312 +
313 + return 0;
314 +
315 + fail:
316 + if (sflash.cc)
317 + iounmap((void *) sflash.cc);
318 + return ret;
319 +}
320 +
321 +mod_exit_t
322 +sflash_mtd_exit(void)
323 +{
324 +#ifdef CONFIG_MTD_PARTITIONS
325 + del_mtd_partitions(&sflash.mtd);
326 +#else
327 + del_mtd_device(&sflash.mtd);
328 +#endif
329 + iounmap((void *) sflash.cc);
330 +}
331 +
332 +module_init(sflash_mtd_init);
333 +module_exit(sflash_mtd_exit);
334 diff -urN linux.old/drivers/mtd/maps/bcm947xx-flash.c linux.dev/drivers/mtd/maps/bcm947xx-flash.c
335 --- linux.old/drivers/mtd/maps/bcm947xx-flash.c 1970-01-01 01:00:00.000000000 +0100
336 +++ linux.dev/drivers/mtd/maps/bcm947xx-flash.c 2006-06-23 18:08:46.000000000 +0200
337 @@ -0,0 +1,548 @@
338 +/*
339 + * Copyright (C) 2006 Felix Fietkau <nbd@openwrt.org>
340 + * Copyright (C) 2005 Waldemar Brodkorb <wbx@openwrt.org>
341 + * Copyright (C) 2004 Florian Schirmer (jolt@tuxbox.org)
342 + *
343 + * original functions for finding root filesystem from Mike Baker
344 + *
345 + * This program is free software; you can redistribute it and/or modify it
346 + * under the terms of the GNU General Public License as published by the
347 + * Free Software Foundation; either version 2 of the License, or (at your
348 + * option) any later version.
349 + *
350 + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
351 + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
352 + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
353 + * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
354 + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
355 + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
356 + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
357 + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
358 + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
359 + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
360 + *
361 + * You should have received a copy of the GNU General Public License along
362 + * with this program; if not, write to the Free Software Foundation, Inc.,
363 + * 675 Mass Ave, Cambridge, MA 02139, USA.
364 + *
365 + *
366 + * Copyright 2004, Broadcom Corporation
367 + * All Rights Reserved.
368 + *
369 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
370 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
371 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
372 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
373 + *
374 + * Flash mapping for BCM947XX boards
375 + *
376 + */
377 +
378 +#include <linux/module.h>
379 +#include <linux/types.h>
380 +#include <linux/kernel.h>
381 +#include <linux/wait.h>
382 +#include <linux/mtd/mtd.h>
383 +#include <linux/mtd/map.h>
384 +#ifdef CONFIG_MTD_PARTITIONS
385 +#include <linux/mtd/partitions.h>
386 +#endif
387 +#include <linux/config.h>
388 +#include <linux/squashfs_fs.h>
389 +#include <linux/jffs2.h>
390 +#include <linux/crc32.h>
391 +#include <asm/io.h>
392 +
393 +#include <typedefs.h>
394 +#include <osl.h>
395 +#include <bcmnvram.h>
396 +#include <bcmutils.h>
397 +#include <sbconfig.h>
398 +#include <sbchipc.h>
399 +#include <sbutils.h>
400 +#include <trxhdr.h>
401 +
402 +/* Global SB handle */
403 +extern void *bcm947xx_sbh;
404 +extern spinlock_t bcm947xx_sbh_lock;
405 +
406 +/* Convenience */
407 +#define sbh bcm947xx_sbh
408 +#define sbh_lock bcm947xx_sbh_lock
409 +
410 +#define WINDOW_ADDR 0x1fc00000
411 +#define WINDOW_SIZE 0x400000
412 +#define BUSWIDTH 2
413 +
414 +static struct mtd_info *bcm947xx_mtd;
415 +
416 +__u8 bcm947xx_map_read8(struct map_info *map, unsigned long ofs)
417 +{
418 + if (map->map_priv_2 == 1)
419 + return __raw_readb(map->map_priv_1 + ofs);
420 +
421 + u16 val = __raw_readw(map->map_priv_1 + (ofs & ~1));
422 + if (ofs & 1)
423 + return ((val >> 8) & 0xff);
424 + else
425 + return (val & 0xff);
426 +}
427 +
428 +__u16 bcm947xx_map_read16(struct map_info *map, unsigned long ofs)
429 +{
430 + return __raw_readw(map->map_priv_1 + ofs);
431 +}
432 +
433 +__u32 bcm947xx_map_read32(struct map_info *map, unsigned long ofs)
434 +{
435 + return __raw_readl(map->map_priv_1 + ofs);
436 +}
437 +
438 +void bcm947xx_map_copy_from(struct map_info *map, void *to, unsigned long from, ssize_t len)
439 +{
440 + if (len==1) {
441 + memcpy_fromio(to, map->map_priv_1 + from, len);
442 + } else {
443 + int i;
444 + u16 *dest = (u16 *) to;
445 + u16 *src = (u16 *) (map->map_priv_1 + from);
446 + for (i = 0; i < (len / 2); i++) {
447 + dest[i] = src[i];
448 + }
449 + if (len & 1)
450 + *((u8 *)dest+len-1) = src[i] & 0xff;
451 + }
452 +}
453 +
454 +void bcm947xx_map_write8(struct map_info *map, __u8 d, unsigned long adr)
455 +{
456 + __raw_writeb(d, map->map_priv_1 + adr);
457 + mb();
458 +}
459 +
460 +void bcm947xx_map_write16(struct map_info *map, __u16 d, unsigned long adr)
461 +{
462 + __raw_writew(d, map->map_priv_1 + adr);
463 + mb();
464 +}
465 +
466 +void bcm947xx_map_write32(struct map_info *map, __u32 d, unsigned long adr)
467 +{
468 + __raw_writel(d, map->map_priv_1 + adr);
469 + mb();
470 +}
471 +
472 +void bcm947xx_map_copy_to(struct map_info *map, unsigned long to, const void *from, ssize_t len)
473 +{
474 + memcpy_toio(map->map_priv_1 + to, from, len);
475 +}
476 +
477 +struct map_info bcm947xx_map = {
478 + name: "Physically mapped flash",
479 + size: WINDOW_SIZE,
480 + buswidth: BUSWIDTH,
481 + read8: bcm947xx_map_read8,
482 + read16: bcm947xx_map_read16,
483 + read32: bcm947xx_map_read32,
484 + copy_from: bcm947xx_map_copy_from,
485 + write8: bcm947xx_map_write8,
486 + write16: bcm947xx_map_write16,
487 + write32: bcm947xx_map_write32,
488 + copy_to: bcm947xx_map_copy_to
489 +};
490 +
491 +#ifdef CONFIG_MTD_PARTITIONS
492 +
493 +static struct mtd_partition bcm947xx_parts[] = {
494 + { name: "cfe", offset: 0, size: 0, mask_flags: MTD_WRITEABLE, },
495 + { name: "linux", offset: 0, size: 0, },
496 + { name: "rootfs", offset: 0, size: 0, },
497 + { name: "nvram", offset: 0, size: 0, },
498 + { name: "OpenWrt", offset: 0, size: 0, },
499 + { name: NULL, },
500 +};
501 +
502 +static int __init
503 +find_cfe_size(struct mtd_info *mtd, size_t size)
504 +{
505 + struct trx_header *trx;
506 + unsigned char buf[512];
507 + int off;
508 + size_t len;
509 + int blocksize;
510 +
511 + trx = (struct trx_header *) buf;
512 +
513 + blocksize = mtd->erasesize;
514 + if (blocksize < 0x10000)
515 + blocksize = 0x10000;
516 +
517 + for (off = (128*1024); off < size; off += blocksize) {
518 + memset(buf, 0xe5, sizeof(buf));
519 +
520 + /*
521 + * Read into buffer
522 + */
523 + if (MTD_READ(mtd, off, sizeof(buf), &len, buf) ||
524 + len != sizeof(buf))
525 + continue;
526 +
527 + /* found a TRX header */
528 + if (le32_to_cpu(trx->magic) == TRX_MAGIC) {
529 + goto found;
530 + }
531 + }
532 +
533 + printk(KERN_NOTICE
534 + "%s: Couldn't find bootloader size\n",
535 + mtd->name);
536 + return -1;
537 +
538 + found:
539 + printk(KERN_NOTICE "bootloader size: %d\n", off);
540 + return off;
541 +
542 +}
543 +
544 +/*
545 + * Copied from mtdblock.c
546 + *
547 + * Cache stuff...
548 + *
549 + * Since typical flash erasable sectors are much larger than what Linux's
550 + * buffer cache can handle, we must implement read-modify-write on flash
551 + * sectors for each block write requests. To avoid over-erasing flash sectors
552 + * and to speed things up, we locally cache a whole flash sector while it is
553 + * being written to until a different sector is required.
554 + */
555 +
556 +static void erase_callback(struct erase_info *done)
557 +{
558 + wait_queue_head_t *wait_q = (wait_queue_head_t *)done->priv;
559 + wake_up(wait_q);
560 +}
561 +
562 +static int erase_write (struct mtd_info *mtd, unsigned long pos,
563 + int len, const char *buf)
564 +{
565 + struct erase_info erase;
566 + DECLARE_WAITQUEUE(wait, current);
567 + wait_queue_head_t wait_q;
568 + size_t retlen;
569 + int ret;
570 +
571 + /*
572 + * First, let's erase the flash block.
573 + */
574 +
575 + init_waitqueue_head(&wait_q);
576 + erase.mtd = mtd;
577 + erase.callback = erase_callback;
578 + erase.addr = pos;
579 + erase.len = len;
580 + erase.priv = (u_long)&wait_q;
581 +
582 + set_current_state(TASK_INTERRUPTIBLE);
583 + add_wait_queue(&wait_q, &wait);
584 +
585 + ret = MTD_ERASE(mtd, &erase);
586 + if (ret) {
587 + set_current_state(TASK_RUNNING);
588 + remove_wait_queue(&wait_q, &wait);
589 + printk (KERN_WARNING "erase of region [0x%lx, 0x%x] "
590 + "on \"%s\" failed\n",
591 + pos, len, mtd->name);
592 + return ret;
593 + }
594 +
595 + schedule(); /* Wait for erase to finish. */
596 + remove_wait_queue(&wait_q, &wait);
597 +
598 + /*
599 + * Next, writhe data to flash.
600 + */
601 +
602 + ret = MTD_WRITE (mtd, pos, len, &retlen, buf);
603 + if (ret)
604 + return ret;
605 + if (retlen != len)
606 + return -EIO;
607 + return 0;
608 +}
609 +
610 +
611 +
612 +
613 +static int __init
614 +find_root(struct mtd_info *mtd, size_t size, struct mtd_partition *part)
615 +{
616 + struct trx_header trx, *trx2;
617 + unsigned char buf[512], *block;
618 + int off, blocksize;
619 + u32 i, crc = ~0;
620 + size_t len;
621 + struct squashfs_super_block *sb = (struct squashfs_super_block *) buf;
622 +
623 + blocksize = mtd->erasesize;
624 + if (blocksize < 0x10000)
625 + blocksize = 0x10000;
626 +
627 + for (off = (128*1024); off < size; off += blocksize) {
628 + memset(&trx, 0xe5, sizeof(trx));
629 +
630 + /*
631 + * Read into buffer
632 + */
633 + if (MTD_READ(mtd, off, sizeof(trx), &len, (char *) &trx) ||
634 + len != sizeof(trx))
635 + continue;
636 +
637 + /* found a TRX header */
638 + if (le32_to_cpu(trx.magic) == TRX_MAGIC) {
639 + part->offset = le32_to_cpu(trx.offsets[2]) ? :
640 + le32_to_cpu(trx.offsets[1]);
641 + part->size = le32_to_cpu(trx.len);
642 +
643 + part->size -= part->offset;
644 + part->offset += off;
645 +
646 + goto found;
647 + }
648 + }
649 +
650 + printk(KERN_NOTICE
651 + "%s: Couldn't find root filesystem\n",
652 + mtd->name);
653 + return -1;
654 +
655 + found:
656 + if (part->size == 0)
657 + return 0;
658 +
659 + if (MTD_READ(mtd, part->offset, sizeof(buf), &len, buf) || len != sizeof(buf))
660 + return 0;
661 +
662 + if (*((__u32 *) buf) == SQUASHFS_MAGIC) {
663 + printk(KERN_INFO "%s: Filesystem type: squashfs, size=0x%x\n", mtd->name, (u32) sb->bytes_used);
664 +
665 + /* Update the squashfs partition size based on the superblock info */
666 + part->size = sb->bytes_used;
667 + len = part->offset + part->size;
668 + len += (mtd->erasesize - 1);
669 + len &= ~(mtd->erasesize - 1);
670 + part->size = len - part->offset;
671 + } else if (*((__u16 *) buf) == JFFS2_MAGIC_BITMASK) {
672 + printk(KERN_INFO "%s: Filesystem type: jffs2\n", mtd->name);
673 +
674 + /* Move the squashfs outside of the trx */
675 + part->size = 0;
676 + } else {
677 + printk(KERN_INFO "%s: Filesystem type: unknown\n", mtd->name);
678 + return 0;
679 + }
680 +
681 + if (trx.len != part->offset + part->size - off) {
682 + /* Update the trx offsets and length */
683 + trx.len = part->offset + part->size - off;
684 +
685 + /* Update the trx crc32 */
686 + for (i = (u32) &(((struct trx_header *)NULL)->flag_version); i <= trx.len; i += sizeof(buf)) {
687 + if (MTD_READ(mtd, off + i, sizeof(buf), &len, buf) || len != sizeof(buf))
688 + return 0;
689 + crc = crc32_le(crc, buf, min(sizeof(buf), trx.len - i));
690 + }
691 + trx.crc32 = crc;
692 +
693 + /* read first eraseblock from the trx */
694 + trx2 = block = kmalloc(mtd->erasesize, GFP_KERNEL);
695 + if (MTD_READ(mtd, off, mtd->erasesize, &len, block) || len != mtd->erasesize) {
696 + printk("Error accessing the first trx eraseblock\n");
697 + return 0;
698 + }
699 +
700 + printk("Updating TRX offsets and length:\n");
701 + printk("old trx = [0x%08x, 0x%08x, 0x%08x], len=0x%08x crc32=0x%08x\n", trx2->offsets[0], trx2->offsets[1], trx2->offsets[2], trx2->len, trx2->crc32);
702 + printk("new trx = [0x%08x, 0x%08x, 0x%08x], len=0x%08x crc32=0x%08x\n", trx.offsets[0], trx.offsets[1], trx.offsets[2], trx.len, trx.crc32);
703 +
704 + /* Write updated trx header to the flash */
705 + memcpy(block, &trx, sizeof(trx));
706 + if (mtd->unlock)
707 + mtd->unlock(mtd, off, mtd->erasesize);
708 + erase_write(mtd, off, mtd->erasesize, block);
709 + if (mtd->sync)
710 + mtd->sync(mtd);
711 + kfree(block);
712 + printk("Done\n");
713 + }
714 +
715 + return part->size;
716 +}
717 +
718 +struct mtd_partition * __init
719 +init_mtd_partitions(struct mtd_info *mtd, size_t size)
720 +{
721 + int cfe_size;
722 +
723 + if ((cfe_size = find_cfe_size(mtd,size)) < 0)
724 + return NULL;
725 +
726 + /* boot loader */
727 + bcm947xx_parts[0].offset = 0;
728 + bcm947xx_parts[0].size = cfe_size;
729 +
730 + /* nvram */
731 + if (cfe_size != 384 * 1024) {
732 + bcm947xx_parts[3].offset = size - ROUNDUP(NVRAM_SPACE, mtd->erasesize);
733 + bcm947xx_parts[3].size = ROUNDUP(NVRAM_SPACE, mtd->erasesize);
734 + } else {
735 + /* nvram (old 128kb config partition on netgear wgt634u) */
736 + bcm947xx_parts[3].offset = bcm947xx_parts[0].size;
737 + bcm947xx_parts[3].size = ROUNDUP(NVRAM_SPACE, mtd->erasesize);
738 + }
739 +
740 + /* linux (kernel and rootfs) */
741 + if (cfe_size != 384 * 1024) {
742 + bcm947xx_parts[1].offset = bcm947xx_parts[0].size;
743 + bcm947xx_parts[1].size = bcm947xx_parts[3].offset -
744 + bcm947xx_parts[1].offset;
745 + } else {
746 + /* do not count the elf loader, which is on one block */
747 + bcm947xx_parts[1].offset = bcm947xx_parts[0].size +
748 + bcm947xx_parts[3].size + mtd->erasesize;
749 + bcm947xx_parts[1].size = size -
750 + bcm947xx_parts[0].size -
751 + (2*bcm947xx_parts[3].size) -
752 + mtd->erasesize;
753 + }
754 +
755 + /* find and size rootfs */
756 + if (find_root(mtd,size,&bcm947xx_parts[2])==0) {
757 + /* entirely jffs2 */
758 + bcm947xx_parts[4].name = NULL;
759 + bcm947xx_parts[2].size = size - bcm947xx_parts[2].offset -
760 + bcm947xx_parts[3].size;
761 + } else {
762 + /* legacy setup */
763 + /* calculate leftover flash, and assign it to the jffs2 partition */
764 + if (cfe_size != 384 * 1024) {
765 + bcm947xx_parts[4].offset = bcm947xx_parts[2].offset +
766 + bcm947xx_parts[2].size;
767 + if ((bcm947xx_parts[4].offset % mtd->erasesize) > 0) {
768 + bcm947xx_parts[4].offset += mtd->erasesize -
769 + (bcm947xx_parts[4].offset % mtd->erasesize);
770 + }
771 + bcm947xx_parts[4].size = bcm947xx_parts[3].offset -
772 + bcm947xx_parts[4].offset;
773 + } else {
774 + bcm947xx_parts[4].offset = bcm947xx_parts[2].offset +
775 + bcm947xx_parts[2].size;
776 + if ((bcm947xx_parts[4].offset % mtd->erasesize) > 0) {
777 + bcm947xx_parts[4].offset += mtd->erasesize -
778 + (bcm947xx_parts[4].offset % mtd->erasesize);
779 + }
780 + bcm947xx_parts[4].size = size - bcm947xx_parts[3].size -
781 + bcm947xx_parts[4].offset;
782 + }
783 + }
784 +
785 + return bcm947xx_parts;
786 +}
787 +
788 +#endif
789 +
790 +
791 +mod_init_t init_bcm947xx_map(void)
792 +{
793 + ulong flags;
794 + uint coreidx;
795 + chipcregs_t *cc;
796 + uint32 fltype;
797 + uint window_addr = 0, window_size = 0;
798 + size_t size;
799 + int ret = 0;
800 +#ifdef CONFIG_MTD_PARTITIONS
801 + struct mtd_partition *parts;
802 + int i;
803 +#endif
804 +
805 + spin_lock_irqsave(&sbh_lock, flags);
806 + coreidx = sb_coreidx(sbh);
807 +
808 + /* Check strapping option if chipcommon exists */
809 + if ((cc = sb_setcore(sbh, SB_CC, 0))) {
810 + fltype = readl(&cc->capabilities) & CAP_FLASH_MASK;
811 + if (fltype == PFLASH) {
812 + bcm947xx_map.map_priv_2 = 1;
813 + window_addr = 0x1c000000;
814 + bcm947xx_map.size = window_size = 32 * 1024 * 1024;
815 + if ((readl(&cc->flash_config) & CC_CFG_DS) == 0)
816 + bcm947xx_map.buswidth = 1;
817 + }
818 + } else {
819 + fltype = PFLASH;
820 + bcm947xx_map.map_priv_2 = 0;
821 + window_addr = WINDOW_ADDR;
822 + window_size = WINDOW_SIZE;
823 + }
824 +
825 + sb_setcoreidx(sbh, coreidx);
826 + spin_unlock_irqrestore(&sbh_lock, flags);
827 +
828 + if (fltype != PFLASH) {
829 + printk(KERN_ERR "pflash: found no supported devices\n");
830 + ret = -ENODEV;
831 + goto fail;
832 + }
833 +
834 + bcm947xx_map.map_priv_1 = (unsigned long) ioremap(window_addr, window_size);
835 +
836 + if (!bcm947xx_map.map_priv_1) {
837 + printk(KERN_ERR "Failed to ioremap\n");
838 + return -EIO;
839 + }
840 +
841 + if (!(bcm947xx_mtd = do_map_probe("cfi_probe", &bcm947xx_map))) {
842 + printk(KERN_ERR "pflash: cfi_probe failed\n");
843 + iounmap((void *)bcm947xx_map.map_priv_1);
844 + return -ENXIO;
845 + }
846 +
847 + bcm947xx_mtd->module = THIS_MODULE;
848 +
849 + size = bcm947xx_mtd->size;
850 +
851 + printk(KERN_NOTICE "Flash device: 0x%x at 0x%x\n", size, window_addr);
852 +
853 +#ifdef CONFIG_MTD_PARTITIONS
854 + parts = init_mtd_partitions(bcm947xx_mtd, size);
855 + for (i = 0; parts[i].name; i++);
856 + ret = add_mtd_partitions(bcm947xx_mtd, parts, i);
857 + if (ret) {
858 + printk(KERN_ERR "Flash: add_mtd_partitions failed\n");
859 + goto fail;
860 + }
861 +#endif
862 +
863 + return 0;
864 +
865 + fail:
866 + if (bcm947xx_mtd)
867 + map_destroy(bcm947xx_mtd);
868 + if (bcm947xx_map.map_priv_1)
869 + iounmap((void *) bcm947xx_map.map_priv_1);
870 + bcm947xx_map.map_priv_1 = 0;
871 + return ret;
872 +}
873 +
874 +mod_exit_t cleanup_bcm947xx_map(void)
875 +{
876 +#ifdef CONFIG_MTD_PARTITIONS
877 + del_mtd_partitions(bcm947xx_mtd);
878 +#endif
879 + map_destroy(bcm947xx_mtd);
880 + iounmap((void *) bcm947xx_map.map_priv_1);
881 + bcm947xx_map.map_priv_1 = 0;
882 +}
883 +
884 +module_init(init_bcm947xx_map);
885 +module_exit(cleanup_bcm947xx_map);
886 diff -urN linux.old/drivers/mtd/maps/Config.in linux.dev/drivers/mtd/maps/Config.in
887 --- linux.old/drivers/mtd/maps/Config.in 2006-06-22 17:35:39.000000000 +0200
888 +++ linux.dev/drivers/mtd/maps/Config.in 2006-06-21 21:41:24.000000000 +0200
889 @@ -48,6 +48,7 @@
890 fi
891
892 if [ "$CONFIG_MIPS" = "y" ]; then
893 + dep_tristate ' CFI Flash device mapped on Broadcom BCM947XX boards' CONFIG_MTD_BCM947XX $CONFIG_MTD_CFI
894 dep_tristate ' Pb1000 MTD support' CONFIG_MTD_PB1000 $CONFIG_MIPS_PB1000
895 dep_tristate ' Pb1500 MTD support' CONFIG_MTD_PB1500 $CONFIG_MIPS_PB1500
896 dep_tristate ' Pb1100 MTD support' CONFIG_MTD_PB1100 $CONFIG_MIPS_PB1100
897 diff -urN linux.old/drivers/mtd/maps/Makefile linux.dev/drivers/mtd/maps/Makefile
898 --- linux.old/drivers/mtd/maps/Makefile 2006-06-22 17:35:39.000000000 +0200
899 +++ linux.dev/drivers/mtd/maps/Makefile 2006-06-21 21:41:24.000000000 +0200
900 @@ -3,6 +3,8 @@
901 #
902 # $Id: Makefile,v 1.37 2003/01/24 14:26:38 dwmw2 Exp $
903
904 +EXTRA_CFLAGS := -I$(TOPDIR)/arch/mips/bcm947xx/include
905 +
906 BELOW25 := $(shell echo $(PATCHLEVEL) | sed s/[1234]/y/)
907
908 ifeq ($(BELOW25),y)
909 @@ -10,6 +12,7 @@
910 endif
911
912 # Chip mappings
913 +obj-$(CONFIG_MTD_BCM947XX) += bcm947xx-flash.o
914 obj-$(CONFIG_MTD_CDB89712) += cdb89712.o
915 obj-$(CONFIG_MTD_ARM_INTEGRATOR)+= integrator-flash.o
916 obj-$(CONFIG_MTD_CFI_FLAGADM) += cfi_flagadm.o
Staging tree of Zoltan Herpai